Bike Safety Assistent

Aus HSHL Mechatronik
Zur Navigation springen Zur Suche springen

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

Abb. 1: Symbolbild Bike Safety Assistent

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.

Abb. 2: Projektplanung als Gantt-Diagramm
Abb. 3: Ressourcendiagramm


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.

Abb. 4: Stufenplan


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.

Abb. 5: Anforderungsliste



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.

Abb. 6: Funktionaler Systementwurf


Sensorik

Die Sensorik erfasst die Messwerte und bildet somit die Berechnungsgrundlage der Ausgangsvariablen des Mikrocontrollers. Es werden drei Ultraschallsensoren und ein Induktiver Näherungssensor 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.

Abb. 7: Technischer 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

Abb. 8: Deckblatt Komponentenspezifikation



Hardware

Sensoren

Ultraschallsensoren

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.

Abb. 9: Ultraschallsensor


Datenblatt Link: Medium:HY-SRF05-ETC.pdf

Induktiver Näherungssensor

Mit den Induktiven Näherungssensor werden die Umdrehungen am Vorderrad gemessen. Mit dem Umfang des Vorderrades wird daraus die eigene Geschwindigkeit ermittelt. Der Induktive Näherungssensor wird am Vorderrad montiert.

Abb. 10: Induktiver Näherungssensor


Mikrocontroller

Als Mikrocontroller wird ein Funduino UNO R3 benutzt, welcher die Sensordaten von den Ultraschallsensoren sowie den Induktiven Näherungssensor erhält. Diese werden anschließend verarbeitet. Mit dem Programmablauf Code, welcher in Arduino IDE geschrieben wurde, werden verschiedene Variablen nach Formeln berechnet und anschließend erfolgt die Ausgabe auf dem Display.

Abb. 11: Mikrocontroller Funduino Uno


Anzeige

Auf einem 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.

Abb. 12: Display


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.


Abb. 13: Schaltplan LCD-Display
Abb. 14: Schaltplan Ultraschallsensoren
Abb. 15: Schaltplan Hall-Sensor



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

Abb. 15: Gesamter Programmablaufplan


Modulgruppe: Sensoren

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

Abb. 14: Modulgruppe Sensoren


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.

Abb. 15: Programmablaufplan Mikrocontroller


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.

Abb. 16: Programmablaufplan Anzeige



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.


Abb. 19: Montage hinten


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.


Abb. 20: Montage vorne


Der induktive Näherungssensor (Hall Sensor) ist an der Achse des Vorderrades montiert und ein entsprechender Magnet an der Speiche der 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 21 Zeigt das Deckblatt des Komponententests. Die Tabelle selbst ist in dieser Excel-Tabelle zu finden.

Abb. 21: Deckblatt Komponententest


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



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