Bike Safety Assistent
→ 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
Um das Projekt strukturiert anzugehen, wurde im ersten Schritt ein Gantt-Diagramm erstellt, welches die verschiedenen Aufgaben der einzelnen Phasen das Projektes zeigt und Fristen für die Erledigung setzt.
Projektplan
Der aktuelle Stand der Projektplanung ist in dieser Excel-Tabelle 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 ist der Grundstein dieses Projektes. Die Anforderungsliste definiert die Ausgangssituation dieses Projektes.
Funktionaler Systementwurf
Ein funktionale Systementwurf soll grundsätzlich die Systemstruktur ermitteln und dabei lösungsneutral sein. Den funktionale Systementwurf zu diesem Projekt wird in die vier Module "Sensorik", "Benutzereingaben", "Berechnung" und "Darstellung" unterteilt.
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 funktionale Systementwurf besteht folglich ebenfalls aus vier Modulgruppen. Die Modulgruppe "Sensorik" beinhaltet die 3 Ultraschallsensoren welche zwischen 3cm und 5m betrieben werden. Der Induktive Näherungssensor 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.
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. Mit einem Schalter kann der Bike Safety Assistent ein- und ausgeschaltet werden. Um zwischen einer Fahrt innerhalb oder außerhalb einer Ortschaft zu wählen wird ein zweiter Schalter verwendet. Durch drücken des Tasters wird der Überholvorgang bestätigt.
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 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.
Komponentenspezifikation
Die komplette Komponentenspezifikation ist in dieser Excel-Tabelle zu finden
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.
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
Komponententest
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.vertex42.com/ExcelTemplates/simple-gantt-chart.html?utm_source=ms&utm_medium=file&utm_campaign=office&utm_content=text
→ zurück zum Hauptartikel: WS 21/22: Fachpraktikum Elektrotechnik (MTR) und Angewandte Elektrotechnik (BSE)