Bike Safety Assistent: Unterschied zwischen den Versionen
K (→Anforderungen) |
K (→Projektplanung) |
||
| Zeile 17: | Zeile 17: | ||
<br clear = all> | <br clear = all> | ||
== Projektplanung == | == 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. | 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 [https://svn.hshl.de/svn/Elektrotechnik_Fachpraktikum/trunk/Projekte/126-150/140_Bike_Safety_Assistent/00_Projektplanung/Gantt-Diagramm.gan dieser Datei] zu finden. | |||
[[Datei:Gantt BSA.JPG|left|mini|x400px|Abb. 2: Projektplanung als Gantt-Diagramm ]] | [[Datei:Gantt BSA.JPG|left|mini|x400px|Abb. 2: Projektplanung als Gantt-Diagramm ]] | ||
| Zeile 24: | Zeile 26: | ||
<br clear=all> | <br clear=all> | ||
=== Stufenplan === | === Stufenplan === | ||
Version vom 8. Januar 2022, 19:04 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 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.
Komponentenspezifikation
Die Komponentenspezifikation bricht die Module in ihre einzelnen Komponenten herunter und beschreibt detailliert die die Funktionsweisen der einzelnen Komponenten. Abbildung 13 zeigt das Deckblatt der Komponentenspezifikation. Die komplette Komponentenspezifikation ist in dieser Excel-Tabelle zu finden
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.
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.
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.
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.
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
Header und Variablendeklaration
//////////////////////////////////////////////////////////////////////// // 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 : 28.12.2021 // // // //////////////////////////////////////////////////////////////////////// #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
// 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
// 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(100);
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(100);
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 + v1; // 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 (entfernung0 >= 5000 || entfernung0 <= 30)
{
lcd.print("NAN");
}
else
{
lcd.print(Distanz0);
}
lcd.print(", ");
if (entfernungPlus45 >= 5000 || entfernungPlus45 <= 30)
{
lcd.print("NAN");
}
else
{
lcd.print(DistanzPlus45);
}
lcd.print(", ");
if (entfernungMinus45 >= 5000 || entfernungMinus45 <= 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 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.
Projektvideo
Zusammenfassung
Lessons Learned
Ausblick
Literaturverzeichnis
- ↑ https://de.statista.com/statistik/daten/studie/154198/umfrage/fahrradbestand-in-deutschland/
- ↑ https://de.statista.com/statistik/daten/studie/1130205/umfrage/getoetete-und-verletzte-bei-unfaellen-mit-e-scootern-und-fahrraedern-in-deutschland/
- ↑ https://de.statista.com/statistik/daten/studie/1122974/umfrage/umfrage-zu-fahrradunfreundlicher-infrastruktur-hamburg/
- ↑ https://www.microsonic.de/de/service/ultraschallsensoren/prinzip.htm
→ zurück zum Hauptartikel: WS 21/22: Fachpraktikum Elektrotechnik (MTR) und Angewandte Elektrotechnik (BSE)