Bike Safety Assistent: Unterschied zwischen den Versionen

Version vom 10. Januar 2022, 12:05 Uhr

→ zurück zum Hauptartikel: WS 21/22: Fachpraktikum Elektrotechnik (MTR) und Angewandte Elektrotechnik (BSE)

Autoren: Pia Kostede; Gerrit Wurth; Andreas Mentrup
Betreuer: Marc Ebmeyer

Einleitung

Das Fahrradfahren wird seit Jahren immer beliebter. So nimmt die Anzahl an Fahrrädern in Deutschland kontinuierlich zu. Im Jahr 2005 gab es 67 Mio. Fahrräder. 2020 waren es bereits 79,1 Mio. Dies entspricht einem Anstieg um 18 Prozent ^[1]. Nicht nur der Umweltgedanke, sondern auch die persönliche Fitness spielen dabei eine wichtige Rolle. Allerdings ist das Fahrradfahren, besonders im fließenden Straßenverkehr, nicht gerade ungefährlich. So gab es im Jahr 2020 allein im ersten Jahresquartal 10.200 registrierte Fahrradunfälle mit Personenschaden. Davon waren 8.245 Unfälle mit Leichtverletzen, 1.901 Schwerverletzten und 54 Unfälle endeten tödlich ^[2]. Besonders die schlecht ausgebauten Radwege bzw. Radfahrstreifen werden von den Fahrradfahrern als Risikofaktor wahrgenommen ^[3].
Da auch die Politik dieses Problem erkannt hat, wurde reagiert und die StVO hinsichtlich der geltenden Abstandsregelungen beim Überholen von Fahrrädern mit Kraftfahrzeugen geändert. Seit April 2020 gilt nun ein Mindestabstand innerorts von 1,5 Metern und außerorts von 2 Metern. Diese Vorschrift trägt dazu bei, das Radfahren ein wenig sicherer zu machen. Allerdings wird dieser Abstand von den Autofahrern in den meisten Fällen nicht eingehalten. Daher ist es als Fahrradfahrer notwendig, sich zusätzlich selbst zu schützen. Eine Möglichkeit wird der Bike Safety Assistent, ein Abstandsmesssystem für das Fahrrad, sein. Dieser misst den zu erwartenden Seitenabstand und zeigt diesen dem Fahrradfahrer an. Der Bike Safety Assistent soll im Rahmen dieses Projektes im Fach Angewandte Elektrotechnik im Masterstudiengang Business and Systems Engineering entwickelt und realisiert werden.

Projektplanung

Projektplan

Um das Projekt strukturiert anzugehen, wurde im ersten Schritt ein Gantt-Diagramm erstellt. Abbildung 2 zeigt die verschiedenen Aufgaben der einzelnen Phasen und setzt Fristen für die Erledigung. Das Gantt-Diagramm wurde während der Durchführung des Projektes regelmäßig aktualisiert. Zudem wurde ein Ressourcendiagramm (Abbildung 3) erstellt und so die Aufgaben unter den Projektteilnehmern aufgeteilt. Der aktuelle Stand der Projektplanung ist in dieser Datei zu finden.

Stufenplan

Zudem wurde ein Stufenplan erstellt, welcher bei der Erarbeitung des Prototypen Orientierung geben soll. Dabei werden in der ersten Stufe die "Grundfunktionen" realisiert und diese in den Stufen zwei und drei erweitert. Durch dieses Vorgehen wird die Aufgabe in mehrere kleine Teilabschnitte gegliedert und strukturiert somit die Arbeit.

Anforderungen

Die nachfolgenden Anforderungen wurden zusammengestellt und sind der Grundstein dieses Projektes. Die Anforderungsliste, in Abbildung 5 zu sehen, definiert die Ausgangssituation dieses Projektes. Die komplette Anforderungsliste ist in dieser Excel-Tabelle zu finden.

Funktionaler Systementwurf

Ein funktionaler Systementwurf soll die grundsätzliche Systemstruktur veranschaulichen und dabei lösungsneutral sein. Der funktionale Systementwurf zu diesem Projekt ist in die vier Module "Sensorik", "Benutzereingaben", "Berechnung" und "Darstellung" unterteilt. Der funktionale Systementwurf für den Bike Safety Assistent ist in Abbildung 6 zu sehen.

Sensorik

Die Sensorik erfasst die Messwerte und bildet somit die Berechnungsgrundlage der Ausgangsvariablen des Mikrocontrollers. Es werden drei Ultraschallsensoren und ein Hall-Sensor verwendet, dessen primäre Funktion es ist, Abstandswerte zu ermitteln und diese Messwerte und Messgrößen zyklisch an den Mikrocontroller zu übergeben.

Benutzereingaben

Das Module "Benutzereingaben" wurde im Projektverlauf mit Abstand am häufigsten angepasst und mit der Zeit immer weiter ausgedünnt. Dies war vor allem der knappen Zeit geschuldet. Letztlich wurde festgelegt, dass als einzige Benutzereingaben das An- und Ausschalten des Systems realisiert werden soll.

Berechnung

Die Berechnung erfolgt im Mikrocontroller und wird über den Programmablauf im Arduino IDE gesteuert. Nachdem die Eingangsvariablen (Messgrößen) in den Mikrocontroller übergeben, werden die Ausgangsvariablen auf Formelbasis berechnet. Die Ausgangsvariablen sind die Distanz zum überholendem Kraftfahrzeug, die Geschwindigkeit des Fahrrads und die Geschwindigkeit des überholenden Kraftfahrzeugs.

Darstellung

Die Darstellung erfolgt auf einem Display. Dort erfolgt die Ausgabe der berechneten Größen. Diese wurden in dem Mikrocontroller berechnet. Die Ausgabewerte variieren im Sekundentakt. Ausgabegrößen sind die eigene Geschwindigkeit, die Überholdistanz und die Geschwindigkeit des überholenden Kraftfahrzeuges.

Technischer Systementwurf

Der technische Systementwurf besteht folglich ebenfalls aus den vier Modulgruppen. Die Modulgruppe "Sensorik" beinhaltet die 3 Ultraschallsensoren welche zwischen 30mm und 5000mm betrieben werden. Der Hall-Sensor misst am Vorderrad die Drehzahl des Rades. Die zweite Modulgruppe "Benutzereingabe" ist für das Ein- und Ausschalten des Systems zuständig. Dies wird denkbar simpel über das An- und Abklemmen der Batterie realisiert. In der Modulgruppe "Berechnung" befindet sich der Mikrocontroller, welcher für die Berechnung der Ausgangsvariablen zuständig ist. Die letzte Modulgruppe "Darstellung" gibt die berechneten Variablen auf dem Display aus. Abbildung 7 zeigt den technischen Systementwurf.

Komponentenspezifikation

Die Komponentenspezifikation bricht die Module in ihre einzelnen Komponenten herunter und beschreibt detailliert die die Funktionsweisen der einzelnen Komponenten. Abbildung 8 zeigt das Deckblatt der Komponentenspezifikation. Die komplette Komponentenspezifikation ist in dieser Excel-Tabelle zu finden

Hardware

Stückliste

ID	Anzahl	Kosten pro Stück €	Summe	Bezeichnung / Komponente	technische Bezeichnung	Beschreibung	Datenblatt	Abbildung
1	3x	0,50 €	1,50 €	Ultraschallsensoren	HY-SRF05	Mit den drei Ultraschallsensoren wird die Distanz zum überholenden KFZ gemessen. Ergänzend dazu wird über Sensor 1 und Sensor 3 die Zeit des Überholvorganges erfasst. Dazu strahlen die Ultraschallsensoren zyklisch einen kurzen und hochfrequenten Schalimpuls aus. Wenn dieser von einem Objekt reflektiert wird, gelangt der Schallimpuls als Echo zu dem Ultraschallsensor zurück. Entscheidend für die Ermittlung der Entfernung des Objektes ist die Zeitspanne zwischen dem Aussenden des Schallimpulses und dem Empfangen des Echos ^[4]. Damit sich die drei verwendeten Ultraschallsensoren nicht gegenseitig stören, ist es wichtig, das Aussenden der Schallimpulse zeitlich versetzt auszulösen und ein entsprechendes Delay zu definieren.	Datenblatt Ultraschallsensor	Abb. 9: Ultraschallsensor
2	1x	0,40€	0,40€	Hall Sensor	Honeywell 2SS52M Series	Mit dem Hall-Sensor werden die Umdrehungen am Vorderrad gemessen. Mit dem Umfang des Vorderrades wird daraus die eigene Geschwindigkeit ermittelt. Der Hall-Sensor wird am Vorderrad montiert.	Datenblatt Hall-Sensor	Abb. 10: Hall-Sensor
3	1x	0,00€	0,00€	Mikrocontroller	Funduino UNO R3	Als Mikrocontroller wird ein Funduino UNO R3 benutzt, welcher die Sensordaten von den Ultraschallsensoren sowie des Hall-Sensors erhält. Diese werden anschließend verarbeitet. Mit dem Programmacode, welcher in Arduino IDE geschrieben wurde, werden verschiedene Variablen nach Formeln berechnet und anschließend erfolgt die Ausgabe auf dem Display. Der Mikrocontroller ist in dem Funduino Lernset für die HSHL enthalten.		Abb. 11: Mikrocontroller Funduino Uno
4	1x	0,00€	0,00€	Anzeige	LCD-Display	Auf einem LCD-Display kann die eigene Geschwindigkeit, die zurückgelegte Strecke, die Durchschnittsgeschwindigkeit der letzten 2 Kilometer und die Dauer der Fahrt angezeigt werden. Wird ein Überholvorgang erkannt, werden diese Werte durch die Überholdistanz sowie die Geschwindigkeit des überholenden KFZ ergänzt. Das LCD_Display ist in dem Funduino Lernset für die HSHL enthalten.		Abb. 12: LCD-Display
5	1x	0,00€	0,00€	Elektronik	10 kΩ Widerstand	Pull-Up Widerstand für den Hall-Sensor (Siehe Schaltplan), ist in dem Funduino Lernset für die HSHL enthalten.
6	1x	2,99€	2,99€	Elektronik	Alkaline Batterie 9-V-Block	Für die mobile Spannungsversorgung des Bike Safety Assistenten werden 9-V-Block Alkaline Batterien verwendet		Abb. 13: Alkaline Batterie 9-V-Block
7	x	0,00€	0,00€	Elektronik	Klingeldraht	Für die Verkabelung am Fahrrad wurde Klingeldraht verwendet. Der Klingeldraht ist aus eigenem Bestand.		Abb. 14: Klingeldraht
8	x	0,00€	0,00€	Montagematerial	Diverse Kabelbinder	Zum befestigen einiger Bauteile und Komponenten wurden Kabelbinder verwendet. Die Kabelbinder sind aus eigenem Bestand.		Abb. 15: Diverse Kabelbinder
9	x	0,00€	0,00€	Montagematerial	Diverse Schrauben	Zum befestigen einiger Bauteile und Komponenten wurden Schrauben verwendet. Die Schrauben sind aus eigenem Bestand.		Abb. 16: Diverse Schrauben
10	x	0,00€	0,00€	Montagematerial	Diverse Holzreste	Für die Montage der Komponenten wurden Montageplatten aus Holz angefertigt und mit Kabelbindern am Fahrrad befestigt. Für das LCD-Display wurde ein kleines Gehäuse aus Leimholzplatten gefertigt. Die Holzreste sind aus eigenem Bestand.		Abb. 17: Diverse Holzreste
11	2x	48,55€	97,10€	Diverse Komponenten	Funduino Lernset für die HSHL	Inhalt siehe Webseite des Funduino Shops	(Kein Datenblatt vorhanden)	Abb. 18: Funduino Lernset für die HSHL

Schaltplan

Die Schaltpläne wurden mit der Software Eplan P8 Education Version 2.7 erstellt. Dargestellt wird der Anschluss der Sensoren und des LCD-Displays am Funduino UNO R3.

Programmierung

Programmablaufpläne

Die nachfolgenden Programmablaufpläne zeigen die Vorgelagerten und Nachgelagerten Prozesse der einzelnen Modulgruppen um die Abläufe zu visualisieren. Die 3 Modulgruppen lassen sich in Sensoren, Benutzereingabe, Mikrocontroller und Anzeige unterteilen. Anhand der Unterteilungen lassen sich Eingaben und Ausgaben darstellen, welche auf die jeweilige Baugruppe wirken.

Gesamter Programmablaufplan

Modulgruppe: Sensoren

In der Modulgruppe Sensoren liefern die Sensoren als Eingabe die Messwerte, welche als Ausgabe an den verarbeitenden Mikrocontroller weitergegeben werden.

Modulgruppe: Mikrocontroller

In der nachfolgenden Abbildung erkennt man die Eingaben sowie Ausgaben die im Rahmen der Verarbeitung auf den Mikrocontroller wirken. Der Mikrocontroller erhält Eingaben in Form von Messwerten aus den Sensoren und manuelle Eingaben welche in die Verarbeitung mit einfließen. Anschließend werden im Mikrocontroller Variablen / Ausgangsvariablen berechnet, welche dann über das Display ausgegeben werden.

Modulgruppe: Anzeige

In der Modulgruppe Anzeige wirken die Ausgangsvariablen des Mikrocontrollers als Eingabe des Displays. Die Darstellung erfolgt permanent. Es werden drei Variablen (Fahrradgeschwindigkeit, Distanzberechnung und KFZ Geschwindigkeit) ausgegeben im Display.

Programmcode

////////////////////////////////////////////////////////////////////////
//                    Hochschule Hamm-Lippstadt                       //
////////////////////////////////////////////////////////////////////////
//                                                                    //
// Modul            : Bike Safety Assistent                           //
//                                                                    //
// Studiengang      : Business and Systems Engineering                //
//                                                                    //
// Fach             : Angewandte Elektrotechnik                       //
//                                                                    //
// Gruppe           : BSE 1.2                                         //
//                                                                    //
// Autoren          : Pia Kostede                                     //
//                    Andreas Mentrup                                 //
//                    Gerrit Wurth                                    //
//                                                                    //
// Betreuer         : Marc Ebmeyer                                    //
//                                                                    //
// Beschreibung     : Programm für den Bike Safety Assistenten        //
//                    In diesem Programm werden die Sensorwerte       //
//                    von insgesamt drei Ultraschall und einem        //
//                    Hall-Sensor eingelesen und darüber der          //
//                    Überholabstand zwischen dem Fahrrad und         //
//                    dem PKW, sowie die Geschwindigkeit des          //
//                    PKWs und des eigenen Fahrrads berechnet.        //
//                    Die ermittelten Werte werden anschließend       //
//                    über ein Display ausgegeben.                    //
//                                                                    //
// Funktionen       : Berechnung und Darstellung der Fahrtparameter   //
//                    - Einlesen der Messwerte                        //
//                    - Verarbeitung                                  //
//                    - Ausgabe                                       //
//                                                                    //
// Implementierung  : Arduino IDE 1.8.19                              //
//                                                                    //
// Bibliotheken     : LiquidCrystal_I2C.h                             //
//                    Wire.h                                          //
//                                                                    //
// Letzte Änderung  : 09.01.2022                                      //
//                                                                    //
////////////////////////////////////////////////////////////////////////

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

LiquidCrystal_I2C lcd(0x27, 16, 2);

// Deklaration der Ein- und Ausgänge
int echo0 = 2;
int trigger0 = 3;
int Hall = 4;
int LED = 5;
int triggerPlus45 = 6;
int echoPlus45 = 7;
int echoMinus45 = 8;
int triggerMinus45 = 9;
int Taster1 = 10;
int Taster2 = 11;

// Variablendeklaration
int HallStatus = 0;
int n = 0;
int Merker = 0;
long dauer0 = 0;
long dauerPlus45 = 0;
long dauerMinus45 = 0;
long entfernung0 = 0;
long entfernungPlus45 = 0;
long entfernungMinus45 = 0;
long Distanz0 = 0;
long DistanzPlus45 = 0;
long DistanzMinus45 = 0;
int Tasterstatus1 = 0;
int Tasterstatus2 = 0;
int DauerAnzeige = 800;
int PauseAnzeigeLang = 5000;
int PauseAnzeigeKurz = 2000;
long LetzteAusfuehrungLang = -1;
long LetzteAusfuehrungKurz = -1;
int Merker2 = 0;
int Merker1 = 0;

long r = 355;
long t1 = 0;
long t2 = 0;
long t3 = 0;
long t4 = 0;
long dt1 = 0;
long dt2 = 0;
long v1 = 0;
long v2 = 0;
long s_kfz = 0;
long s_fr = 0;
long s_o = 1120;

// Definition der Anzeige Zustände 

#define Anzeige1 1          // Anzeige-Zustand 1 angelegt - Willkommen und Initialisierung
#define Anzeige2 2          // Anzeige-Zustand 2 angelegt - Anzeige der eigenen Geschwindigkeit
#define Anzeige3 3          // Anzeige-Zustand 3 angelegt - Anzeige der gemessenenen Abstände
#define Anzeige4 4          // Anzeige-Zustand 4 angelegt - Anzeige der Geschwindigkeit des überholenden KFZ

char Anzeige = Anzeige1;    // Anzeige1 (Willkommen und Initialisierung) als Startzustand festgelegt

// Initialisierung
void setup()
{
  // put your setup code here, to run once:
  lcd.init();
  lcd.backlight();
  //Serial.begin(9600);             // Seriellen Monitor zum debuggen
  
  pinMode(LED, OUTPUT);
  //pinMode(Taster, INPUT);
  pinMode(Hall, INPUT);
  pinMode(trigger0,OUTPUT);
  pinMode(echo0, INPUT);
  pinMode(triggerPlus45,OUTPUT);
  pinMode(echoPlus45, INPUT);
  pinMode(triggerMinus45,OUTPUT);
  pinMode(echoMinus45, INPUT);
}

// Programmschleife
void loop() {
  // put your main code here, to run repeatedly:
  long Zeit = millis();                         // Zeit seit Programmstart messen
  
  //_________________________________________________________________
  // Geschwindigkeit berechnen mit dem Hall-Sensor
  HallStatus = digitalRead(Hall);               // Hall-Sensor einlesen

  if (HallStatus == HIGH)                       // Abfrage für die Realisierung der Flankenerkennung
  {
    Merker = 1;                                 // Merker für die Realisierung der Flankenerkennung
    digitalWrite(LED, LOW);                     // LED zum debuggen
  }
  
  if (HallStatus == LOW && Merker == 1)         // Realisierung der Flankenerkennung
  {
    digitalWrite(LED, HIGH);                  // LED zum debuggen
    delay(10);                                  // Verzögerung zum entprellen
    n = n+1;                                    // Zähler für die Umdrehungen
    digitalWrite(LED, LOW);                   // LED zum debuggen
    //Serial.print("Anzahl Umdrehungen: ");     // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(n);                        // Ausgabe auf dem Seriellen Monitor zum debuggen
    Merker = 0;                                 // Merker für die Realisierung der Flankenerkennung
  }
  //n = n+1;

  if (n==1)                       //Bei erster Umdrehung...
  {
    t1 = millis();                //... Zeit erfassen
  }
  if (n==3)                       //Bei dritter Umdrehung...
  {
    t2 = millis();                //... Zeit erfassen
    dt1 = t2-t1;                  // Zeit Differenz berechnen
    v1 = PI*((2/(dt1))*r)*3.6;    // Geschwindigkeit des Fahrrades berechnen
    n=0;                          // Zähler für die Umdrehungen zurücksetzen
  }
  //v1 = 20;                      // Konstante geschwindigkeit zum debuggen
  //_________________________________________________________________
  // Trigger Signal Sensor 3 Hinten bei -45 Grad
  digitalWrite(triggerMinus45,LOW);
  delay(5);
  digitalWrite(triggerMinus45,HIGH);
  delay(10);
  digitalWrite(triggerMinus45,LOW);

  // Sensor 3 Hinten bei -45 Grad einlesen
  dauerMinus45 = pulseIn(echoMinus45, HIGH);
  // Entfernung Sensor 3 Hinten bei -45 Grad berechnen
  entfernungMinus45 = (dauerMinus45/2) * 0.3432;
  

  // Ausgabe der Entfernung von Sensor 3 Hinten bei -45 Grad 
  if (entfernungMinus45 >= 5000 || entfernungMinus45 <= 30)
  {
    //Serial.println("Sensor 3 Hinten bei -45 Grad Kein Messwert");     // Ausgabe auf dem Seriellen Monitor zum debuggen
  }
  else
  {
    DistanzMinus45 = (sin(45*(PI/180)) * entfernungMinus45) - 200;      // Umrechnung Entfernung/Distanz und Offset Lenkerbreite abziehen
    //Serial.print("Sensor 3 Hinten bei -45 Grad misst: ");             // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print(entfernungMinus45);                                  // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(" mm");                                            // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print("Distanz 3 Hinten bei -45 Grad berechnet: ");        // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print(DistanzMinus45);                                     // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(" mm");                                            // Ausgabe auf dem Seriellen Monitor zum debuggen
  }

  //_________________________________________________________________
  // Trigger Signal Sensor 2 Mitte bei 0 Grad
  delay(50);
  digitalWrite(trigger0,LOW);
  delay(5);
  digitalWrite(trigger0,HIGH);
  delay(10);
  digitalWrite(trigger0,LOW);
  
  // Sensor 2 Mitte bei 0 Grad einlesen
  dauer0 = pulseIn(echo0, HIGH);
  // Entfernung Mitte bei 0 Grad Berechnen
  entfernung0 = (dauer0/2) * 0.3432;
  
  
  // Ausgabe der Entfernung von Sensor 2 Mitte bei 0 Grad
  if (entfernung0 >= 5000 || entfernung0 <= 30)
  {
    //Serial.println("Sensor 2 Mitte bei 0 Grad Kein Messwert");    // Ausgabe auf dem Seriellen Monitor zum debuggen
  }
  else
  {
    Distanz0 = entfernung0 - 150;                                   // Offset Lenkerbreite addieren
    //Serial.print("Sensor 2 Mitte bei 0 Grad misst: ");            // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print(entfernung0);                                    // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(" mm");                                        // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print("Sensor 2 Mitte bei 0 Grad berechnet: ");        // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print(Distanz0);                                       // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(" mm");                                        // Ausgabe auf dem Seriellen Monitor zum debuggen
  }

  //_________________________________________________________________
  // Trigger Signal Sensor 1 Vorne bei +45 Grad
  delay(50);
  digitalWrite(triggerPlus45,LOW);
  delay(5);
  digitalWrite(triggerPlus45,HIGH);
  delay(10);
  digitalWrite(triggerPlus45,LOW);

  // Sensor 1 Vorne bei +45 Grad einlesen
  dauerPlus45 = pulseIn(echoPlus45, HIGH);
  // Entfernung Sensor 1 Vorne bei +45 Grad Berechnen
  entfernungPlus45 = (dauerPlus45/2) * 0.3432;
  

  // Ausgabe der Entfernung von Sensor 1 Vorne bei +45 Grad
  if (entfernungPlus45 >= 5000 || entfernungPlus45 <= 30)
  {
    //Serial.println("Sensor 1 Vorne bei +45 Grad Kein Messwert");  // Ausgabe auf dem Seriellen Monitor zum debuggen
  }
  else
  {
    DistanzPlus45 = (sin(45*(PI/180)) * entfernungPlus45) - 300;    // Umrechnung Entfernung/Distanz und Offset Lenkerbreite abziehen
    //Serial.print("Sensor 1 Vorne bei +45 Grad misst: ");          // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print(entfernungPlus45);                               // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(" mm");                                        // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print("Distanz 1 Vorne bei +45 Grad berechnet: ");     // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print(DistanzPlus45);                                  // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(" mm");                                        // Ausgabe auf dem Seriellen Monitor zum debuggen
  }
  //delay(1000);
  //_________________________________________________________________
  // Berechnung der Geschwindigkeit des überholenden KFZ
  if (entfernungMinus45 < 2000)                   // Bei einer gemessenen Entfernung kleiner 2 m an Sensor 3...
  {
    t3 = millis();                                //... Zeit erfassen
    //Serial.print("t3: ");                       // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(t3);                         // Ausgabe auf dem Seriellen Monitor zum debuggen
    Merker1 = 1;                                  // Merker Sensor 3 setzen
  }
  if (Merker1 ==1 && entfernung0 < 2000)          // Bei einer gemessenen Entfernung kleiner 2 m an Sensor 2...
  {
    Merker2 = 1;                                  // Merker Sensor 2 setzen
    Merker1 = 0;                                  // Merker Sensor 3 zurücksetzen
  }
  if (Merker2 ==1 && entfernungPlus45 < 2000)     // Bei einer gemessenen Entfernung kleiner 2 m an Sensor 1...
  {
    t4 = millis();                                //... Zeit erfassen
    
    dt2 = t4 - t3;                                // Zeit Differenz berechnen
    //Serial.print("dt2: ");                      // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(dt2);                        // Ausgabe auf dem Seriellen Monitor zum debuggen
    s_fr = (v1 / 3.6) * dt2;                      // Strecke des Fahrrades berechnen
    s_kfz = (s_fr + s_o + DistanzPlus45 + DistanzMinus45);      // Strecke des KFZ berechnen
    //Serial.print("s_kfz: ");                    // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(s_kfz);                      // Ausgabe auf dem Seriellen Monitor zum debuggen
    v2 = (s_kfz / dt2) * 3.6;                     // Geschwindigkeit des KFZ berechnen
    //Serial.print("Fahrrad Geschwindigkeit: ");  // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(v1);                         // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.print("KFZ Geschwindigkeit: ");      // Ausgabe auf dem Seriellen Monitor zum debuggen
    //Serial.println(v2);                         // Ausgabe auf dem Seriellen Monitor zum debuggen
    Merker2 = 0;                                  // Merker Sensor 2 zurücksetzen
  }

  
  
  //_________________________________________________________________
  // Ausgabe auf dem LCD-Display
    switch (Anzeige)                                // Switch für die durchlaufende Anzeige am LCD-Display
    {
      case Anzeige1:
        // Anzeige-Zustand 1 angelegt - Willkommen und Initialisierung

        lcd.clear();                                // Display anzeige Löschen
        lcd.setCursor(0, 0);                        // Curser erstes Zeichen erste Zeile setzen
        lcd.print("BikeSafetyAssistent");           // Ausgabe erste Zeile des LCD-Displays
        lcd.setCursor(0, 1);                        // Curser erstes Zeichen zweite Zeile setzen
        lcd.print("Initialisierung Erfolgreich");   // Ausgabe zweite Zeile des LCD-Displays
        
        if (LetzteAusfuehrungKurz < (Zeit-PauseAnzeigeLang))    // Ersatz für Delay
        {
          LetzteAusfuehrungKurz = Zeit;
          LetzteAusfuehrungLang = Zeit;
          Anzeige = Anzeige2;                       //Wechsle in den Zustand 2
        }
        break;

      case Anzeige2:
        // Anzeige-Zustand 2 angelegt - Anzeige der eigenen Geschwindigkeit
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Geschwindigkeit:");
        lcd.setCursor(0, 1);
        
        if (v1 >= 50 || v1 <= 10)
        {
          lcd.print("NAN");
        }
        else
        {
          lcd.print(v1);
        }

        if (LetzteAusfuehrungLang < (Zeit-PauseAnzeigeLang))    // Ersatz für Delay
        {
          LetzteAusfuehrungLang = Zeit;
          Anzeige = Anzeige3;                       //Wechsle in den Zustand Anzeige3
        }
        break;


      case Anzeige3:
        // Anzeige-Zustand 3 angelegt - Anzeige der gemessenenen Abstände
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("Distanz0,+45,-45");
        lcd.setCursor(0, 1);
        
        if (Distanz0 >= 5000 || Distanz0 <= 30)
        {
          lcd.print("NAN");
        }
        else
        {
          lcd.print(Distanz0);
        }
        lcd.print(", ");
        
        if (DistanzPlus45 >= 5000 || DistanzPlus45 <= 30)
        {
          lcd.print("NAN");
        }
        else
        {
          lcd.print(DistanzPlus45);
        }
        lcd.print(", ");
        
        if (DistanzMinus45 >= 5000 || DistanzMinus45 <= 30)
        {
          lcd.print("NAN");
        }
        else
        {
          lcd.print(DistanzMinus45);
        }
      
        if (LetzteAusfuehrungLang < (Zeit-PauseAnzeigeLang))    // Ersatz für Delay
        {
          LetzteAusfuehrungLang = Zeit;
          Anzeige = Anzeige4;                       //Wechsle in den Zustand Anzeige4
        }
        break;

      
      case Anzeige4:
        // Anzeige-Zustand 4 angelegt - Anzeige der Geschwindigkeit des überholenden KFZ
        lcd.clear();
        lcd.setCursor(0, 0);
        lcd.print("PKW-Geschwindigkeit:");
        lcd.setCursor(0, 1);
        
        if (v2 >= 200 || v2 <= 20)
        {
          lcd.print("NAN");
        }
        else
        {
          lcd.print(v2);
        }

        if (LetzteAusfuehrungLang < (Zeit-PauseAnzeigeLang))    // Ersatz für Delay
        {
          LetzteAusfuehrungLang = Zeit;
          Anzeige = Anzeige2;                       //Wechsle in den Zustand Anzeige2
        }
        break;
    }
  v2 = 0;
}

Aufbau

Der Bike Safety Assistent setzt sich aus verschiedenen Komponenten zusammen, die am Fahrrad an verschiedenen Stellen montiert werden. Die drei Ultraschallsensoren werden vorne, mittig und hinten in dem entsprechenden Winkel montiert. Für die Montage wurde für den mittigen und den hinteren Sensor eine Holzleiste neben dem Gepäckträger montiert. Das Ende der Holzleiste wurde für den entsprechenden Winkel von 45 Grad zugeschnitten und bildet so die Montagegrundlage für den hinteren Ultraschallsensor. Der mittige Ultraschallsensor wurde am anderen Ende der Holzleiste parallel zum Fahrrad montiert, welcher sich in Höhe der Sitzposition befindet. Das nachfolgende Bild visualisiert die Montagepunkte.

Auf der Holzleiste erkennt man die zwei Plastikdosen, welche den Mikrocontroller (im hinteren Bereich) sowie das Steckbrett (vorderer Bereich) vor Witterungseinflüsse schützen.

Der dritte Ultraschallsensor befindet sich an der Vorderachse des Fahrrades und ist dort ebenfalls mit einer Holzleiste befestigt, die den entsprechenden Winkel von 45 Grad aufweist und zugeschnitten wurde.

Der Hall-Sensor ist an der Vorderradgabel montiert und zwei Magneten an den Speichen des Vorderades, um die entsprechenden Umdrehungen zu messen. Das Display befindet sich am Lenker und ist dort mittig angebracht, um während der Fahrt problemlos draufzuschauen. Die Kabel der drei vorderen Einheiten werden über die Mittelachse mit dem hinten liegenden Mikrocontroller verbunden.

Komponententest

Beim Komponententest werden die in der Komponentenspezifikation definierten Komponenten nach speziellen festgelegten Verfahren getestet. Abbildung 22 Zeigt das Deckblatt des Komponententests. Die Tabelle selbst ist in dieser Excel-Tabelle zu finden.

Im Folgenden werden die Testmethoden zu den einzelnen Komponenten kurz erläutert. Die konkreten Testfälle mit den jeweiligen Parametern können der oben verlinkten Tabelle entnommen werden.

Test der Ultraschallsensoren

Hier sollte geprüft werden, ob die Ultraschallsensoren plausibele Werte messen. Dazu wurden für jeden Test eine andere Distanz zwischen dem Messobjekt und dem Sensor definiert und im Voraus mit einem Maßband abgemessen. Anschließend wurde eine Messung mit den Ultraschallsensoren durchgeführt und der ausgegebene Wert mit dem zuvor gemessenen Wert verglichen. Hierbei wurde eine Abweichung von unter einem Prozent als akzeptabel eingestuft.

Test des Hall-Sensors

Der Hall-Sensor wurde schon in einem sehr frühen Stadium des Prototypenbau getestet. Dafür wurde lediglich ein Magnet an den Hall-Sensor angenähert. Sobald der Sensor durchschaltet, leuchtet eine LED, damit der Schaltvorgang visualisiert wurde.

Test des Ein- und Ausschaltens

Auch das Ein- und Ausschalten des Systems mittels Ab- und Anklemmen der Batterie konnte denkbar simpel getestet werden. Unter der Voraussetzung, dass das System und vor allem das Display bereits einwandfrei funktioniert, wurde die Batterie angeklemmt und beobachtet, ob die Display-Anzeige erscheint. Beim Abklemmen der Batterie musste auch das Display ausschalten. Dies war bei dem Test der Fall und somit wurde der Komponententest als bestanden eingestuft.

Test der Distanzberechnung

Hier musste getestet werden, ob bei den äußeren beiden Ultraschallsensoren die Umrechnung der im 45-Grad-Winkel gemessenen Werte in die senkrechten Abstände funktioniert. Bei dem mittleren Abstandssensor musste für die korrekte Berechnung lediglich ein Offset für die Lenkerbreite abgezogen werden. Diese Aspekte wurden mit einer ähnlichen Methode wie der Test der Ultraschallsensoren validiert. Es wurde also ein Objekt in einem vorher definierten und gemessenen Abstand zu den Ultraschallsensoren positioniert und der korrekte senkrechte Abstand errechnet. Anschließend wurde die Messung mittels des Bike Safety Assistenten durchgeführt und die durch das Programm errechneten Werte und die im Voraus händisch ermittelten Werte miteinander verglichen.

Test der Ermittlung der Fahrradgeschwindigkeit

Für diesen Test wurde ein schlichter Vergleich als Validierung durchgeführt. Zum einen wurde die Fahrradgeschwindigkeit mittels des Bike Safety Assistenten ermittelt und zum anderen zeitgleich mit einem herkömmlichen Fahrrad-Tacho gemessen. Die ermittelten Werte wurden verglichen, wobei nur geringe Abweichungen festgestellt werden konnten. Daher wurde der Test als bestanden eingestuft.

Test der Ermittlung der KFZ-Geschwindigkeit

Für diesen Test wurde eine konstante Fahrrad-Geschwindigkeit von 20 km/h angenommen, da das Fahrrad für diesen Test nicht wirklich gefahren ist, sondern statisch an einer Stelle stand. Anschließend wurden die Ultraschallsensoren nacheinander durch das Vorbeigehen einer Person ausgelöst und die Zeit des simulierten Überholvorgangs mittels einer Handystoppuhr gemessen. Die von dem System ermittelte KFZ-Geschwindigkeit wurde dann auf Plausibilität überprüft.

Test der permanenten Darstellung

Für diesen Test wurde eine optische Bewertung der Anzeige durchgeführt. Hier wurde jeweils überprüft, ob die Fahrrad-Geschwindigkeit, die Überholdistanz und die KFZ-Geschwindigkeit in gewünschter Weise dargestellt werden.

Projektvideo

Zusammenfassung

Lessons Learned

Das Projekt des Bike Safety Assistenten konnte erfolgreich umgesetzt werden. Das System funktioniert für einen Prototypen hinreichend genau und könnte, mit einigen Verbesserungen, zur Sicherheit im Straßenverkehr beitragen. Die Schwierigkeiten bei der Umsetzung des Projektes lagen vor allem in der knappen Zeit. So wurde bspw. nicht genügend Puffer für die Genehmigung des Projektes und für die Vorbereitung der parallel laufenden Praktika eingeplant, was zum Ende hin Zeitdruck erzeugte. Eine weitere Schwierigkeit/Verzögerung wurde durch die anfängliche Verwendung eines Touch-Displays hervorgerufen. Um die Ausgabe der Distanzen und Geschwindigkeiten übersichtlich zu gestalten, sollte nicht das im Funduino-Set beinhaltete LCD-Display, sondern ein größeres Touch-Display verwendet werden. Allerdings wurde hier die Bauteilkompatibilität im Voraus nicht gewissenhaft geprüft, sodass es im Weiteren zu diversen Problemen gekommen ist. Unter anderem waren bei dem verwendeten Funduino UNO nicht genügend Ports vorhanden, um sowohl das Touch-Display als auch alle benötigten Sensoren zu betreiben. Dies hätte im Vorfeld durch eine umfassendere Recherche umgangen werden können. So hätte bspw. direkt mit einem anderen Microcontroller gearbeitet werden können. Letztlich wurde anstatt dem Touch-Display das dem Funduino-Set beiliegenden LCD-Display verwendet. Dies reicht für die Anzeige der ermittelten Distanzen und Geschwindigkeiten vollkommen aus. Jedoch könnte durch die Verwendung eines Touch-Display die Anwenderfreundlichkeit gesteigert werden. Ein weiterer Aspekt bezüglich des Zeitmanagements war die Kommunikation zwischen den Projektbeteiligten. Diese wurde zum Ende hin immer weiter verbessert, da Aufgaben klarer verteilt wurden und dies bspw. durch To-Do-Listen verschriftlicht wurde. Ein nicht unwesentlicher Punkt war zum Ende hin die Komponententests. Hier wurde das System hinsichtlich der Überholgeschwindigkeit des KFZ mit unrealistischen Zahlen validiert. Dies führte dazu, dass sich die ausgegebenen KFZ-Geschwindigkeiten trotz unterschiedlicher Überholzeiten nicht signifikant verändert haben. Letztlich wurde das System mit deutlich geringeren Überholzeiten getestet, sodass tatsächlich Veränderungen hinsichtlich der Geschwindigkeit zu beobachten waren.

Zusammenfassend bleibt festzuhalten, dass das Projekt „Bike Safety Assistent“ erfolgreich mit der zur Verfügung stehenden Zeit und den vorhandenen Mittel umgesetzt werden konnte., es jedoch einige Punkte im Projektverlauf gab, die bei einem nächsten Projekt verbessert werden können.

Ausblick

Um den vorhandenen Prototypen weiterzuentwickeln und somit ein fertiges und einsatzbereites Produkt zu erhalten, müsste wie bereits beschrieben ein Touch-Screen verbaut werden, um die Anwenderfreundlichkeit zu steigern. Ein weiterer Punkt wäre die Parallelisierung des Programmablaufs. Hier muss sichergestellt werden, dass das System zu jeder Zeit einwandfrei läuft. In einigen Situationen war dies bei dem Prototypen nicht gegeben, da bei hohen Geschwindigkeiten der Microcontroller manchmal nicht jede Raddrehung gezählt hat. So haben sich Messfehler ergeben. Dies war der Tatsache geschuldet, dass auf dem Microcontroller aktuell das Programm ohne parallele Messungen und Berechnungen durchläuft. Daher konnten manchmal einfach keine neuen Messungen erkannt werden, da der Microcontroller noch Berechnungen aufgeführt hat, anstatt die Messwerte der Sensoren abzufragen. Dies würde durch einen parallelen Programmablauf vermieden werden. Auch hinsichtlich der äußeren Gestaltung der Bike Safety Assistenten könnten Verbesserungen durchgeführt werden. So könnten bspw. wetterfeste Gehäuse entwickelt und 3D-gedruckt oder auch die Befestigungen an dem Fahrrad optimiert werden. Auch die Realisierung von neunen Features wäre denkbar. So könnte bspw. ein Kamerasystem verbaut werden, welches bei einem zu geringen Überholabstand das Kennzeichen es KFZ erkennt und speichert.

Der Bike Safety Assistent würde besonders in Großstädten die Sicherheit für Fahrradfahrer erhöhen und somit die Nutzung des Fahrrades noch attraktiver machen.

Literaturverzeichnis