Hinderniswarnsystem für Fahrzeug

Autoren: Matthias Rassenhövel, Lars Vienenkötter
Betreuer: Prof. Schneider

Plakat für Projektmesse

→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)

Einleitung

Im Rahmen des Praktikums WS 20/21: Angewandte Elektrotechnik (BSE) wollen wir ein ferngesteuertes Fahrzeug mit zusätzlichen Funktionen zur Hinderniserkennung ausstatten. Es sollen visuelle wie auch akustische Warnsignale in drei verschiedenen Stufen entsprechend der Distanz zum Hindernis ausgegeben werden. Detaillierte Angaben hierzu sind im nachfolgenden Kapitel (s. Anforderungen) zu finden.

Falls es der zeitliche Rahmen des Projektes zulässt wollen wir zusätzlich eine automatische Beleuchtung der Fahrbahn bei Dunkelheit (vom Fahrzeug aus) ergänzen. Weiterhin könnten wir die optische Warnleuchte als Rundumleuchte umsetzen.

Anforderungen

Ausstattung eines ferngesteuerten Fahrzeugs mit folgenden zusätzlichen Funktionen:

1) Warnung bei Annäherung des Fahrzeugs an Hindernisse in Form von:

• Akustischem Signal (mit Buzzer)
  • niedrige Frequenz (bei großer Distanz)
  • mittlere Frequenz (bei mittler Distanz)
  • hohe Frequenz (bei kurzer Distanz)
• Optischem Signal (mit RGB-LED)
  • grün (bei großer Distanz)
  • gelb (bei mittler Distanz)
  • rot (bei kurzer Distanz)

2) Anzeige der Distanz des Fahrzeugs zum Hindernis auf einem Display

3) Die Hindernisbewegung wird mit einem Konstante-Beschleunigung-Modell modelliert und die Zustände Position, Geschwindigkeit Beschleunigung werden mittels Zustandsschätzer (Kalman-Filter) geschätzt.

Zusätzliche Anforderungen:

• Alle benötigten Komponenten sollen im/am Fahrzeug verbaut werden.

Ausblick - Mögliche Ergänzungen:

• Optisches Signal als Rundumleuchte (mit Servomotor)
• Automatische Beleuchtung der Fahrbahn bei Dunkelheit (mit Fotowiderstand und LED's)

Funktionaler Systementwurf/Technischer Systementwurf

Systementwurf

Komponentenspezifikation

Unser Gesamtsystem besteht aus den drei Modulen Hinderniswarnsystem, Lichtautomatik und Zustandsschätzer. Die einzelnen Komponenten der Module werden in den folgenden Tabellen spezifiziert.

Hinderniswarnsystem

Komponente:	Eingänge:	Ausgänge:	ID:	Aufgabe:
Distanzsensor	Distanz zu Objekt	Spannungssignal an Microcontroller	1.1	Messung der Distanz zum nächstliegenden Objekt in Fahrtrichtung
			1.2	Montage am Fahrzeug: am Frontmodul, Ausrichtung in Fahrtrichtung
Microcontroller	Spannungssignal von Distanzsensor	Spannungssignale an Warnleuchte, Buzzer, Display	1.3	Steuerung der Komponenten und Signale
			1.4	Montage am Fahrzeug: im hinteren Teil unter dem Gehäuse, von außen nicht sichtbar
Warnleuchte	Spannungssignal von Microcotroller	Lichtsignal an Fahrer	1.5	Erzeugen eines Lichtssignals in definierten Farben und Blinkfrequenzen
			1.6	Automatisches Ändern der Farbe und Blinkfrequenz in Abhängigkeit der gemessenen Distanz (D) nach folgenden Bedingungen: - D > 50 cm: Grün ohne Blinken - D <= 50 cm & > 30 cm: Gelb ohne Blinken - D <= 30 cm & > 10 cm: Rot ohne Blinken - D <= 10 cm: Rot mit Blinken (0,5 sec an, 0,5 sec aus)
			1.7	Montage am Fahrzeug: mittig auf dem Dach, direkt hinter Windschutzscheibe
Buzzer	Spannungssignal von Microcontroller	Tonsignal an Fahrer	1.8	Erzeugen eines Tonsignals mit definierten Tonfrequenzen und -dauern
			1.9	Automatisches Ändern der Tonfrequenz und -dauer in Abhängigkeit der gemessenen Distanz (D) nach folgenden Bedingungen: - D > 50 cm: kein Ton - D <= 50 cm & > 30 cm: Tonfrequenz 1000 Hz (1 sec an, 1 sec aus) - D <= 30 cm & > 10 cm: Tonfrequenz 1500 Hz (0,5 sec an, 0,5 sec aus) - D <= 10 cm: Tonfrequenz 2000 Hz (durchgängig)
			1.10	Montage am Fahrzeug: auf Breadboard mittig unter dem Gehäuse, von außen nicht sichtbar
Display	Spannungssignal von Microcontroller	Text an Fahrer	1.11	Anzeige der aktuell gemessenen Distanz in Zentimeter
			1.12	Montage am Fahrzeug: hinten auf der Ladefläche, lesbar aus Sicht des Fahrers der hinter dem Fahrzeug steht

Lichtautomatik

Komponente:	Eingänge:	Ausgänge:	ID:	Aufgaben:
Lichtsensor	Lichtstärke der Umgebung	Spannungssignal an Microcontroller	2.1	Messung der Lichtstärke der direkten Umgebung des Fahrzeugs
			2.2	Montage am Fahrzeug: mittig auf dem Dach, direkt vor Heckscheibe
Microcontroller	Spannungssignal von Lichtsensor	Spannungssignal an Scheinwerfer	2.3	Steuerung der Komponenten und Signale
			2.4	Montage am Fahrzeug: im hinteren Teil unter dem Gehäuse, von außen nicht sichtbar
Scheinwerfer	Spannungssignal von Microcotroller	Lichtsignal an Umgebung	2.5	Automatische Frontbeleuchtung (links und rechts) in Fahrtrichtung ab definierter Lichtstärke der Umgebung - Einschalten der Scheinwerfer bei Dämmerung/Dunkelheit - Ausschalten der Scheinwerfer bei Tageslicht"
			2.6	Montage am Fahrzeug: Links und Rechts am Frontmodul

Zustandsschätzer

Komponente:	Eingänge:	Ausgänge:	ID:	Aufgaben:
Datenaufnahme	Positionsmessdaten von Microcontroller	formatierte Positionsmessdaten an Kalman-Filter	3.1	Einlesen der gespeicherten Positionsmessdaten des Distanzsensors
Kalman-Filter	Formatierte Positionsmessdaten von Datenaufnahme	Fahrzeugposition, Fahrzeuggeschwindigkeit, Fahrzeugposition an Visualisierung	3.2	Schätzung der Fahrzeugposition
			3.3	Schätzung der Fahrzeuggeschwindigkeit
			3.4	Schätzung der Fahrzeugbeschleunigung
Visualisierung	Fahrzeugposition, Fahrzeuggeschwindigkeit, Fahrzeugposition von Kalman-Filter	Graphische Darstellung	3.5	Visualisierung der Fahrzeugposition, -geschwindigkeit und -beschleunigung der Schätzung in einem Diagramm: - X-Achse: Zeit - Y-Achse: Position, Geschwindigkeit, Beschleunigung

Umsetzung (HW/SW)

Die Umsetzung der drei Module wird im Folgenden so dokumentiert, dass es für jeden einfach nachzubauen ist. Die Module Hinderniswarnsystem und Lichtautomatik bestehen jeweils aus Hardware und Software. Das Herzstück der Hardware bildet ein Arduino Uno R3, welcher beide Module steuert. Die Software wurde mit der Arduino eigenen Entwicklungsumgebung IDE erstellt, die auf Wiring IDE basiert. Beide Module wurden auf einem ferngesteuerten Fahrzeug verbaut. Die Komponente Zustandsschätzer besteht nur aus Software, welche mit Matlab erstellt wurde und auf einem PC ausgeführt wird.

Die Umsetzung der Hardware wird anhand eines Beschaltungsplans, welcher mit der Software Fritzing erstellt wurde, dargestellt. Zudem ist die BOM aufgeführt, damit für einen Nachbau alle Bauteile beschafft werden können. Für die Umsetzung der Software wird der Quellcode der Arduino-IDE abgebildet.

Hardware

Der Beschaltungsplan beinhaltet die Darstellung der Bauelemente auf dem Breadboard, um die Zusammenhänge und Funktionen übersichtlich darzustellen. Die Umsetzung in der Realität erfolgt an einem ferngesteuerten Fahrzeug. Dazu werden die Bauteile direkt am Fahrzeug befestigt.

Beschaltungsplan der Module Hinderniswarnsystem und Lichtautomatik

Stückliste (BOM)
Nr.	Anzahl	Bezeichnung	Beschaffung von	Modulzuordnung
1.	1	ferngesteuertes Fahrzeug	Beispiel	Hinderniswarnsystem + Lichtautomatik
2.	1	UNO R3 Mikrocontroller-Board	individuelles Lernset der HSHL	Hinderniswarnsystem + Lichtautomatik
3.	1	USB-Kabel für Arduino Mikrocontrollerboards	individuelles Lernset der HSHL	Hinderniswarnsystem + Lichtautomatik
4.	1	Breadboard	individuelles Lernset der HSHL	Hinderniswarnsystem + Lichtautomatik
5.	1	9 V Batterieklemme	individuelles Lernset der HSHL	Hinderniswarnsystem + Lichtautomatik
6.	1	9 V Blockbatterie	Beispiel	Hinderniswarnsystem + Lichtautomatik
7.	ca. 30	Breadboard Jumperkabel (m/m, m/f, f/f)	individuelles Lernset der HSHL	Hinderniswarnsystem + Lichtautomatik
8.	1	Ultraschallsensor HC-SR04	individuelles Lernset der HSHL	Hinderniswarnsystem
9.	1	Piezo Speaker	individuelles Lernset der HSHL	Hinderniswarnsystem
10.	1	LCD Modul mit I2C Ansteuerung	individuelles Lernset der HSHL	Hinderniswarnsystem
11.	1	RGB LED	individuelles Lernset der HSHL	Hinderniswarnsystem
12.	3	Widerstand 200 Ohm	individuelles Lernset der HSHL	Hinderniswarnsystem
13.	1	Fotowiderstand 1K Ohm	individuelles Lernset der HSHL	Lichtautomatik
14.	4	LED weiß	individuelles Lernset der HSHL	Lichtautomatik
15.	1	Widerstand 100 Ohm	individuelles Lernset der HSHL	Lichtautomatik
16.	1	Widerstand 2,2 kOhm	individuelles Lernset der HSHL	Lichtautomatik

Hinderniswarnsystem

Das Hinderniswarnsystem besteht aus den in der Komponentenspezifikation beschriebenen Komponenten Distanzsensor, Microcontroller, Warnleuchte, Buzzer und Display. Wie in dem Beschaltungsplan (siehe Abbildung) dargestellt, wird der Distanzsensor durch einen Ultraschallsensor realisiert. Dazu wird der Ultraschallsensor HC-SR04 verwendet. Dieser ist für die Messung von Distanzen zwischen 3 cm und 400 cm ausgelegt und weist eine maximale Abweichung von 0,3 mm auf. Der Sensor besitzt die vier Anschlüsse GND, VCC, Trigger und Echo. Mit Hilfe des Trigger-Pins wird ein Schallwellensignal ausgesendet. Der Echo-Pin dient zum Empfang des Signals. Der Sensor arbeitet mit einer Frequenz von 40 Hz. Um Hindernisse zu erkennen, die sich in Fahrtrichtung vor dem Fahrzeug befinden, wird der Sensor frontal am Auto mittels Heißkleber befestigt.

Das Sensorsignal wird an den Analogeingang des Microcontrollers gesendet. Als Microcontroller wird der Arduino Uno R3 verwendet. Dieser verarbeitet das Analogsignal des Ultraschallsensors und gibt diese Informationen über die digitalen I/O-Ports an die Aktoren weiter. Der Microcontroller wird mit Hilfe von Kabelbindern unterhalb der Fahrzeugverkleidung auf dem Fahrgestell angebracht. Neben dem Arduino wird hier ebenfalls das Breadboard angebracht, auf dem sich beispielsweise die Vorwiderstände befinden. Das Breadboard wird auf dem Fahrgestell angeklebt.

Als Aktor für das optische Warnsignal wird eine RGB-LED verwendet. Mit Hilfe der RGB-LED kann das Warnsignal die unterschiedlichen Distanzen nach dem Ampelprinzip darstellen. Das gelbe Signal wird als Kombination aus roter und grüner LED realisiert (siehe Quellcode). Für geringe Distanzen wird das rote Signal als Blinklicht umgesetzt. Die Blinkfrequenz wird über die Programmierung vorgegeben. Die RGB-LED besitzt vier Anschlüsse, von denen ein Anschluss für GND dient und die weiteren Anschlüsse jeweils das Signal des Arduinos für die rote, die grüne oder die blaue LED empfangen. Die LED wird zentral auf dem Fahrzeugdach angebracht. Die Anschlüsse der LED werden werden in dafür vorgesehenen Ausschnitten versenkt und unterhalb der Verkleidung angeschlossen.

Das akustische Signal wird durch den Buzzer realisiert. Um unterschiedliche Töne ausgeben zu können, wird ein Piezo-Buzzer verwendet, da hier die Frequenz variiert werden kann. Daher wird der Piezo-Buzzer an den PWM-Pin des Arduino angeschlossen. Der zweite Pin dient als Anschluss für GND. Da der Buzzer keine optische Funktion besitzt, wird dieser auf dem Breadboard befestigt und ist somit äußerlich nicht sichtbar.

Für die Text-Ausgabe der Distanz wird ein LC-Display verwendet. Für das Projekt wird ein I2C-Display genutzt, da der I2C-Kommunikations-Adapter die Anzahl der Anschlüsse auf die vier I/O-Leitungen GND, VCC, SDA, SCL reduziert. Die Leitungen SDA und SCL dienen als Datenleitungen und sind mit den Analogeingängen des Arduino verbunden. Das Display kann 32 Zeichen auf 2 Zeilen und 16 Spalten ausgeben. Aufgrund der Größe des Displays wird dieses auf der Ladefläche des Fahrzeugs angebracht. Dazu wird in der Kunststoffverkleidung des Fahrzeugs ein Ausschnitt für den I2C-Adapter erzeugt. So kann das Display unterhalb der Fahrzeugverkleidung verdrahtet werden.

Lichtautomatik

Für die Umsetzung der Lichtautomatik werden jeweils ein Lichtsensor, der Microcontroller sowie Leuchtmittel als Scheinwerfer benötigt. Im Beschaltungsplan (siehe Abbildung) ist zu erkennen, dass ein Fotowiderstand verwendet wird, welcher die Beleuchtung der Umgebung wahrnimmt und bei Dunkelheit reagieren kann. Um die Umgebungsbeleuchtung wahrnehmen zu können, wird der Sensor an der Heckscheibe des Fahrzeugs befestigt, sodass die Messfläche nicht durch Schatten beeinflusst werden kann.

Das Signal des Fotowiderstandes wird an den Analogeingang des Microcontrollers gegeben. Der Arduino verarbeitet das Signal und gibt es über einen Digitalausgang an die LEDs weiter, die als Scheinwerfer dienen. Da die LEDs als Frontscheinwerfer agieren, werden diese frontal am Fahrzeug befestigt. Dazu werden die Anschlusspins der LEDs durch die Fahrzeugverkleidung geführt. Als Scheinwerfer werden jeweils zwei LEDs auf der rechten und linken Seite des Ultraschallsensors angebracht. Innerhalb des Programms wird ein Wert für die Umgebungshelligkeit vorgegeben, ab dem die LEDs eingeschaltet werden.

Software

Hinderniswarnsystem

Die Software des Moduls "Hinderniswarnsystem" wurde mit der integrierten Entwicklungsumgebung Arduino IDE erstellt.

Einbinden der Bibliotheken:

#include <Wire.h>
#include <LiquidCrystal_I2C.h>

Definition der Pins:

const int trigPin = 2;      // Trigger-Pin des Ultraschallsensors
const int echoPin = 3 ;     // Echo-Pin des Ultraschallsensors

const int sdaPin = A4;      // SDA-Pin des I2C-LCD
const int sclPin = A5;      // SCL-Pin des I2C-LCD

const int buzzPin = 9;      // Buzzer-Pin (PWM für verschiedene Frequenzen)

const int redPin = 10;      // Pin für Rot der RGB-LED (PWM für verschiedene Lichtstärken)
const int greenPin = 6;     // Pin für Grün der RGB-LED (PWM für verschiedene Lichtstärken)
const int bluePin = 5;      // Pin für Blau der RGB-LED (PWM für verschiedene Lichtstärken)

Definition der globalen Variablen:

double Dauer = 0.0;
double Distanz = 0.0;

Weitere Einstellungen:

LiquidCrystal_I2C lcd = LiquidCrystal_I2C(0x27, 20, 4);   // Initialisierung LCD-Display

Setup starten:

void setup() {

Definition der Eingänge:

pinMode(echoPin, INPUT);

Definition der Ausgänge:

pinMode(trigPin, OUTPUT);
pinMode(buzzPin, OUTPUT);
pinMode(bluePin, OUTPUT);
pinMode(greenPin, OUTPUT);
pinMode(redPin, OUTPUT);

Initialisierung LCD:

lcd.init();       // LCD via I2C verbinden und initialisieren
lcd.backlight();  // Hintergrundbeleuchtung LCD anschalten

Setup beenden:

}

Loop starten:

void loop() {

Berechnung der Distanz:

digitalWrite(trigPin, LOW);     // Signal am Trigger-Pin auf LOW(0) setzen
delayMicroseconds(5);           // 5 µs warten
digitalWrite(trigPin, HIGH);    // Aktivierung: Signal am Trigger-Pin auf HIGH (1) setzen
delayMicroseconds(10);          // 5 µs warten
digitalWrite(trigPin, LOW);     // Signal am Trigger-Pin auf LOW (0) setzen
Dauer = pulseIn(echoPin, HIGH); // Einlesen des Signals (Schallimpuls) am Echo-Pin [in s]
Distanz = Dauer * 0.034 / 2;    // Berechnung der Distanz [in cm]

Anzeige der Distanz auf dem LCD:

lcd.setCursor(0, 0);            // Cursor auf Zeile 1, Spalte 1 setzten
lcd.print("Distanz: ");         // Anzeige von "Distanz: " auf LCD
lcd.setCursor(0, 1);            // Cursor auf Zeile 2, Spalte 1 setzten
lcd.print(Distanz);             // Anzeige von berechneter Distanz auf LCD
lcd.print(" cm  ");             // Anzeige von " cm" auf LCD
delay(50);                      // 10 ms warten

Erzeugen der verschiedenen Buzzer-Töne abhängig von der Distanz:

if (Distanz > 50 || Distanz < 0)
  {
    noTone(buzzPin);              // kein Ton
  }
if (Distanz > 30 && Distanz <= 50)
  {
    tone(buzzPin, 1000, 1000);    // Ton an (mit Frequenz: 1000 Hz & Dauer: 1000 ms)
    delay(1000);                  // Ton aus für 1000 ms
  }
if (Distanz > 10 && Distanz <= 30)
  {
    tone(buzzPin, 1500, 500);     // Ton an (mit Frequenz: 1500 Hz & Dauer: 500 ms)
    delay(500);                   // Ton aus für 500 ms
  }
if (Distanz <= 10 && Distanz >= 0)
  {
    tone(buzzPin, 2000);          // durchgängiger Ton an (mit Frequenz: 2000 Hz)
  }

Erzeugen der verschiedenen LED-Farben abhängig von der Distanz:

if (Distanz > 50 || Distanz < 0)
  {
    digitalWrite(bluePin, LOW);   // Blau 0% an
    digitalWrite(redPin, LOW);    // Rot 0% an
    digitalWrite(greenPin, HIGH); // Grün 100% an
  }
if (Distanz > 30 && Distanz <= 50)
  {
    analogWrite(bluePin, 0);      // Blau 0% an
    analogWrite(redPin, 255);     // Rot 100% an 
    analogWrite(greenPin, 30);    // Grün (30/255*100)% an
  }
if (Distanz > 10 && Distanz <= 30)
  {
    digitalWrite(bluePin, LOW);   // Blau 0% an
    digitalWrite(redPin, HIGH);   // Rot 100% an 
    digitalWrite(greenPin, LOW);  // Grün 0% an
  }
if (Distanz <= 10 && Distanz >= 0)
  {
    digitalWrite(bluePin, LOW);   // Blau 0% an
    digitalWrite(redPin, HIGH);   // Rot 100% an
    digitalWrite(greenPin, LOW);  // Grün 0% an
    delay(500);                   // 500 ms warten
    digitalWrite(bluePin, LOW);   // Blau 0% an
    digitalWrite(redPin, LOW);    // Rot 0% an
    digitalWrite(greenPin, LOW);  // Grün 0% an
  }

Loop beenden:

}

Lichtautomatik

Die Software des Moduls "Lichtautomatik" wurde mit der integrierten Entwicklungsumgebung Arduino IDE erstellt.

Definition der Pins:

const int ldrPin = A1;      // Pin für LDR-Sensor
const int ledPin = 8;       // Pin LED-Scheinwerfer für rechts und links

Definition der globalen Variablen:

double ldrWert = 0.0;

Setup starten:

void setup() {

Definition der Eingänge:

pinMode(ldrPin, INPUT);

Definition der Ausgänge:

pinMode(ledPin, OUTPUT);

Setup beenden:

}

Loop starten:

void loop() {

Anschalten der Scheinwerfer-LEDs bei Dunkelheit:

ldrWert = analogRead(ldrPin);   // Einlesen des aktuellen Wert des LDR-Sensors

if (ldrWert > 900)              // Ein-/Ausschalten der LEDs
  {
  digitalWrite(ledPin, HIGH);
  }
else 
  {
  digitalWrite(ledPin, LOW);
  }

Loop beenden:

}

Zustandsschätzer

Die Software des Moduls "Zustandsschätzer" wurde mit Matlab erstellt. Diese besteht aus einem Startskript für das Programm, einem Skript für das Einlesen der Ultraschalldaten und dem eigentlichen Skript mit den Parametern und Berechnungen des Kalmanfilters für die Schätzung der aktuellen Position, Geschwindikgkeit und Beschleunigung.

Kalmanfilter:

%****************************************************************
% Modul	          : KonstBeschlModell_Kalmanfilter.m            *
%                                                               *
% Datum           : 03-Dez-2020                                 *
%                                                               *
% Funktion        : Kalmanfilter für die Schätzung der Position,*
%                   Geschwindigkeit und Beschleunigung anhand   *
%                   von Positionsmessdaten eines                *             
%                   Ultraschallsensor an einem ferngescheuertem *
%                   Fahrzeug                                    * 
%                                                               *
% Implementation  : MATLAB 2020a                  	        *
%                                                               *
% Author          : Matthias Rassenhövel & Lars Vienenkötter    *                       
%                   basierend auf dem Programm von              *
%                   Prof. Dr Ulrich Schneider                   *
%                                                               *
% Quelle          : C:\SVN\BSE_Moderne_Trackingsysteme\Demos    *
%                                                               *
% Letzte Änderung : 23-Dez-2020                                 *
%                                                               *
%***************************************************************/

function [pos vel acc] = KonstBeschlModell_Kalmanfilter(z)

global dt % Abtastzeit in s
persistent A H Q R 
persistent x P
persistent bErsterDurchlauf

%% Initalisierung der Variablen bei ersten Durchlauf
if isempty(bErsterDurchlauf)
  A = [ 1 dt dt^2;   
        0 1 dt;
        0 0 1 ];  % Systemmatrix
    
  H = [ 1 0 0 ];  % Messmatrix
  
  Q = [ 1e-3 0 0;    
        0 1e-5 0;
        0 0 1e-6 ];  % Systemrauschen (Quelle: https://www.researchgate.net/publication/330540064_Kalman_Filter_Algorithm_Design_for_HC-SR04_Ultrasonic_Sensor_Data_Acquisition_System)
    
  R = 2.92e-3;       % Messrauschen (Quelle: https://www.researchgate.net/publication/330540064_Kalman_Filter_Algorithm_Design_for_HC-SR04_Ultrasonic_Sensor_Data_Acquisition_System)

  x = [ 0 5 5 ]'; % initiale Zustandsschätzung x0=0m v0=5m/s a0=5m/s^2
  
  P = [ 1 0 0;
        0 2 0;
        0 0 5 ];  % initiale Fehlerkovarianzmatrix
  
  bErsterDurchlauf = 1;
end

%% Prädiktion  
xp = A*x;  
Pp = A*P*A' + Q;    

%% Schätzung
K = Pp*H'*inv(H*Pp*H' + R);

if ~isnan(z)
    x = xp + K*(z - H*xp);
else
    x = xp;
end

P = Pp - K*H*Pp;   

%% Rückgabewerte
pos = x(1);
vel = x(2);
acc = x(3);

Startskript:

%****************************************************************
% Modul		  : KonstBeschlModell_Startskript.m             *
%                                                               *
% Datum           : 03-Dez-2020                                 *
%                                                               *
% Funktion        : Startskript für die Schätzung der Position, *
%                   Geschwindigkeit und Beschleunigung anhand   *
%                   von Positionsmessdaten eines                *             
%                   Ultraschallsensor an einem ferngescheuertem *
%                   Fahrzeug                                    *      
%                                                               *
% Implementation  : MATLAB 2020a                        	*
%                                                               *
% Author          : Matthias Rassenhövel & Lars Vienenkötter    *                       
%                   basierend auf dem Programm von              *
%                   Prof. Dr Ulrich Schneider                   *
%                                                               *
% Quelle          : C:\SVN\BSE_Moderne_Trackingsysteme\Demos    *
%                                                               *
% Letzte Änderung : 23-Dez-2020                                 *
%                                                               *
%***************************************************************/

clear all; close all; clc; % MATLAB vorbereiten

global dt
dt = 0.09;                    % Abtastzeit in s
nSamples = 115;               % Anzahl der Messwerte
t  = 0:dt:(nSamples*dt - dt); % Zeitachse als Array

%% Speicherplatz reservieren
Xsaved = zeros(nSamples, 3);
Zsaved = zeros(nSamples, 1);

%% Schleife über alle Messwerte
for k=1:nSamples
  z = LeseUltraschall();    % Messwerte lesen   
  [pos vel acc] = KonstBeschlModell_Kalmanfilter(z);  % Kalman-Filter
  
  %% Werte speichern
  Xsaved(k, :) = [pos vel acc];
  Zsaved(k)    = z;
end

figure
hold on
plot(t, Zsaved(:), 'r.')
plot(t, Xsaved(:, 1))
legend('Messwerte', 'Kalman-Filter Schätzung','Location','Best')
xlabel('Zeit in s')
ylabel('Distanz in m')

figure
hold on
plot(t, Xsaved(:, 2))
legend('Geschwindigkeit Kalman-Filter Schätzung', 'Location','Best')
xlabel('Zeit in s')
ylabel('Geschwindigkeit in m/s')

figure
hold on
plot(t, Xsaved(:, 3))
legend('Beschleunigung Kalman-Filter Schätzung', 'Location','Best')
xlabel('Zeit in s')
ylabel('Beschleunigung in m/s^2')

Einlesen Positionsmessdaten von Ultraschallsensor:

%****************************************************************
% Modul	          : LeseUltraschall.m                           *
%                                                               *
% Datum           : 03-Dez-2020                                 *
%                                                               *
% Funktion        : Gibt Messwert aus Ultraschallmessung zurück *
%                                                               *
% Implementation  : MATLAB 2020a                                *
%                                                               *
% Author          : Matthias Rassenhövel & Lars Vienenkötter    *                       
%                   basierend auf dem Programm von              *
%                   Prof. Dr Ulrich Schneider                   *
%                                                               *
% Quelle          : C:\SVN\BSE_Moderne_Trackingsysteme\Demos    *
%                                                               *
% Letzte Änderung : 23-Dez-2020                                 *
%                                                               *
%***************************************************************/

function h = LeseUltraschall()
%
%
persistent Ultraschallmessung       % Var. in Ultraschallmessung.mat
persistent k bErsterDurchlauf

%% Initalisierung der Variablen bei ersten Durchlauf
if isempty(bErsterDurchlauf)
  load('Ultraschallmessung.mat')
  k = 1;
  
  bErsterDurchlauf = 1;
end

h = Ultraschallmessung(k);
  
k = k + 1;

Komponententest

Hinderniswarnsystem

Komponente:	Anforderungs-ID:	zu testende Anforderungen aus Komponentenspezifikation:	Erfüllungsgrad
Warnleuchte	1.6	Automatisches Ändern der Farbe und Blinkfrequenz in Abhängigkeit der gemessenen Distanz (D) nach folgenden Bedingungen: - D > 50 cm: Grün ohne Blinken - D <= 50 cm & > 30 cm: Gelb ohne Blinken - D <= 30 cm & > 10 cm: Rot ohne Blinken - D <= 10 cm: Rot mit Blinken (0,5 sec an, 0,5 sec aus)	Die visuellen Signale werden wie gefordert ausgegeben. (s. Youtube-Video)
Buzzer	1.9	Automatisches Ändern der Tonfrequenz und -dauer in Abhängigkeit der gemessenen Distanz (D) nach folgenden Bedingungen: - D > 50 cm: kein Ton - D <= 50 cm & > 30 cm: Tonfrequenz 1000 Hz (1 sec an, 1 sec aus) - D <= 30 cm & > 10 cm: Tonfrequenz 1500 Hz (0,5 sec an, 0,5 sec aus) - D <= 10 cm: Tonfrequenz 2000 Hz (durchgängig)"	Die akustischen Signale werden wie gefordert ausgegeben. (s. Youtube-Video)
Display	1.11	Anzeige der aktuell gemessenen Distanz in Zentimeter	Die Distanz wird wie gefordert auf dem Display ausgegeben. (s. Youtube-Video)

Lichtautomatik

Komponente:	Anforderungs-ID:	zu testende Anforderungen aus Komponentenspezifikation:	Erfüllungsgrad
Scheinwerfer	2.5	Automatische Frontbeleuchtung (links und rechts) in Fahrtrichtung ab definierter Lichtstärke der Umgebung - Einschalten der Scheinwerfer bei Dämmerung/Dunkelheit - Ausschalten der Scheinwerfer bei Tageslicht	Die Beleuchtung wird wie gefordert bei Dunkelheit eingeschaltet und bei Helligkeit ausgeschaltet. (s. Youtube-Video)

Zustandsschätzer

Komponente:	Anforderungs-ID:	zu testende Anforderungen aus Komponentenspezifikation:	Erfüllungsgrad
Datenaufnahme	3.1	Einlesen der gespeicherten Positionsmessdaten des Distanzsensors	Die Positionsmessdaten können über eine xls-Datei in Matlab eingelesen werden.
Kalman-Filter	3.2	Schätzung der Fahrzeugposition	Die Position wird wie gefordert geschätzt.
	3.3	Schätzung der Fahrzeuggeschwindigkeit	Die Geschwindigkeit wird wie gefordert geschätzt.
	3.4	Schätzung der Fahrzeugbeschleunigung	Die Beschleunigung wird wie gefordert geschätzt.
Visualisierung	3.5	Visualisierung der Fahrzeugposition, -geschwindigkeit und -beschleunigung der Schätzung in einem Diagramm - X-Achse: Zeit - Y-Achse: Position, Geschwindigkeit, Beschleunigung	Die Daten werden wie gefordert in drei verschiedenen Diagrammen visualisiert.

Ergebnis

Alle vorher definierten Anforderungen (s. Kapitel "Anforderungen") wurden erfüllt. In der nachfolgenden Abbildung ist das Fahrzeug mit allen Funktionen abgebildet.

1. Lichtautomatik bestehend aus Lichtsensor und Scheinwerfer

2. Hinderniswarnsystem bestehend aus Distanzsensor, Warnleuchte, Display und Buzzer (Buzzer befindet sich unter dem Gehäuse und ist daher nicht sichtbar)

3. Dateien des Zustandsschätzers bestehend aus Kalman-Filter (zur Schätzung von Position, Geschwindigkeit, Beschleunigung) befinden sich in SVN.

Fahrzeug Hinderniswarnsystem

Zusammenfassung

Lessons Learned

Während des Projektes sind folgenden Schwierigkeiten aufgefallen, die man für eine erneute Durchführung berücksichtigen sollte.

1. Programmierung der Software außer Kalman-Filter mit Arduino-IDE, da MATLAB / Simulink zu aufwendig (Programmierung eines Arduino mit Arduino-IDE einfacher, da IDE dafür ausgelegt)
2. Fahrzeug mit genügend Bauraum für Elektronik auswählen
3. Saubere Kabelverlegung durch Verlöten der Kabel anstatt Jumper-Kabel
4. Kalman-Filter in Arduino-IDE umsetzen für einfache Übertragung der Messdaten

Projektunterlagen

Projektplan

Zu Beginn des Projekts wurde ein Projektplan erstellt, um die Projektdurchführung übersichtlicher zu gestalten. Der Projektplan ist im Folgenden abgebildet.

Projektplan

Projektdurchführung

Alle wichtigen Unterlagen, die während der Projektdurchführung erstellt wurden, befinden sich in SVN.

YouTube Video

Link zum Video

---

→ zurück zur Übersicht: WS 20/21: Angewandte Elektrotechnik (BSE)