Smart Motorcycle HUD-Prototyp (Turn-by-Turn-Navigation und vieles mehr) - Gunook

2024 Autor: John Day | [email protected]. Zuletzt bearbeitet: 2024-01-30 07:15

Hi !

Dieses Instructables ist die Geschichte, wie ich eine HUD-Plattform (Heads-Up-Display) entworfen und gebaut habe, die für die Montage auf Motorradhelmen entwickelt wurde. Es wurde im Rahmen des "Karten"-Wettbewerbs geschrieben. Leider konnte ich dieses Projekt nicht rechtzeitig vor Ablauf der Wettbewerbsfrist fertigstellen, aber ich wollte trotzdem meine Fortschritte teilen und alle Versuche und Irrtümer dokumentieren, die ich dabei gemacht habe.

Die Idee zu diesem Projekt kam mir zum ersten Mal vor ein paar Jahren, als ich mit Motorrädern begann, und ich begann zu überlegen, welche Ausrüstung ich kaufen müsste, um meine Fahrten angenehmer zu machen. Damals verblüffte es mich, dass der beste Weg, um während der Fahrt eine grundlegende GPS-Navigation zu erhalten, darin bestand, Ihr Smartphone im Grunde genommen am Lenker Ihres Fahrrads zu befestigen. Ich dachte mir, dass es sicherlich einen besseren Weg geben könnte, diese Art von Informationen im Handumdrehen zu erhalten.

Da wurde es mir klar: Ein Heads-up-Display könnte der Weg sein, um während der Fahrt navigieren zu können, ohne den Akku Ihres Telefons zu leeren und es den Elementen auszusetzen.

Im Laufe der Zeit reifte diese Idee in meinem Kopf, und ich dachte, dass ein HUD immer vor mir viel mehr Verwendungsmöglichkeiten bieten würde als einfache Navigation. Aus diesem Grund möchte ich die Plattform öffentlich und modular machen, damit jeder ein Modul erstellen kann, das die benötigten Informationen auf seinem eigenen HUD anzeigt

Es gibt zwar kommerziell erhältliche Produkte, die diese Aufgabe erfüllen, aber keine, die so modular wie meine Plattform sind, und dazu neigen sie auch ein wenig teuer zu sein. Wie auch immer, willkommen zu diesem Projekt.

Was funktioniert ab sofort

Wie bereits erwähnt, befindet sich dieses Projekt noch in einem sehr großen Entwicklungsstadium, und daran wird derzeit gearbeitet.

- Kommunikation zwischen einem Smartphone und einem ESP32-basierten Board (Telefon wach)

- Optikdesign fertig (könnte auf lange Sicht kleine Anpassungen erfordern)

- Android-Navigations-App mit dem Mapbox-Navigations-SDK:

- Kann die Position des Benutzers auf einer Karte berechnen und anzeigen, sowie eine Route von dieser zum Ziel

- Kann eine Verbindung zu einem Bluetooth-Gerät herstellen (die MAC-Adresse des Geräts ist ab sofort fest codiert)

- Echtzeit-Navigation möglich, einschließlich Extrahieren und Senden der Informationen des bevorstehenden Manövers über serielles Bluetooth (unterstützt derzeit nur Kurven)

Was braucht Arbeit

Diese Liste enthält Elemente, die für die beabsichtigte Verwendung des HUDs unbedingt erforderlich sind, aber noch nicht implementiert werden können.

- Gesamtdesign (Helmbefestigung, Winkeleinstellmechanismus des Reflektors,..)

- Android App:

- Implementieren von Off-Route-Erkennung und -Korrektur

- Möglichkeit für den Benutzer, die Zieladresse einzugeben

- Wegpunkte ?

- Ergonomie / Ästhetik

Lieferungen:

Grundlagen

- Ein ESP32-basiertes Entwicklungsboard

- Jedes etwas neuere Android-Smartphone (Bluetooth-fähig)

- Ein SSD1306 oder ein anderer aktivierter 96" OLED-Bildschirm (meiner war 128x64 Pixel, siehe "The brains: Microcontroller & Screen" Teil)

- Ein Reflektor (jedes Stück Acryl / Glas / Plexiglas reicht aus)

- Eine Fresnel-Linse (meine hatte eine F-Länge von ca. 13cm, siehe Abschnitt "Linsenwahl")

Werkzeuge

- Lötkolben

- Steckbrett

- Ein paar Starthilfekabel

- 3D-Drucker / 3D-Druckservice

Schritt 1: Wie alles funktioniert: Design-Entscheidungen erklärt

Die Grundidee eines Heads-Up-Displays besteht darin, ein Bild vor den Augen von jemandem anzuzeigen, damit er nicht von allem wegschauen muss, was er tut (sei es ein Flugzeug zu steuern oder ein Motorrad zu fahren, was unsere Aufgabe sein wird Beispielfall).

Optik

Technisch könnte dies erreicht werden, indem ein Bildschirm direkt vor die Augen des Benutzers gestellt wird. Ein Bildschirm ist jedoch nicht transparent und würde daher die Sicht des Benutzers beeinträchtigen. Sie können den Bildschirm dann vor einer reflektierenden Oberfläche platzieren, die den Inhalt des Bildschirms widerspiegelt und gleichzeitig durchsichtig genug ist, damit der Benutzer sehen kann, was sich vor ihm befindet.

Dieser Ansatz hat jedoch einen großen Fehler: Der eigentliche Bildschirm ist normalerweise näher an den Augen des Benutzers als das, worauf der Benutzer tatsächlich fokussieren muss (z. B. die Straße vor ihm). Das bedeutet, dass sich die Augen des Benutzers zum Ablesen der spiegelnden Fläche an den Abstand des Displays zu seinen Augen (z (~2/5 Meter). Die Zeit, die dieser gesamte Vorgang in Anspruch nimmt, ist kostbare Zeit, die mit Blick auf die Straße verbracht werden sollte, und häufige Anpassungen können für den Benutzer bereits nach wenigen Minuten unangenehm sein.

Deshalb habe ich mich entschieden, eine Linse zwischen Bildschirm und Reflektor hinzuzufügen. Dieses Objektiv sollte bei sorgfältiger Auswahl die Erstellung eines virtuellen Bildes des Bildschirms ermöglichen (siehe Schema oben), das dann weiter von den Augen des Benutzers entfernt zu sein scheint, als es tatsächlich ist, und daher weniger abrupte Anpassungen (oder überhaupt keine, in einem perfekten Szenario). Dieses Design ermöglicht es dem Benutzer, schnell auf den Reflektor zu blicken, die benötigten Informationen zu erhalten und sofort wieder auf die Straße zu blicken.

Die Rolle des Smartphones

Da es unrealistisch war, eine ganze Navigationsanwendung allein auf dem ESP32 zu implementieren, entschied ich mich, eine Android-App zu entwickeln, die sich darum kümmert. Die App müsste dann dem ESP32 nur mitteilen, was der Benutzer tun muss, um an sein Ziel zu gelangen, und der ESP32 leitet diese Informationen über das HUD weiter (siehe Abbildung "Funktionsweise des Moduls").

Schritt 2: Teile - die Gehirne: Mikrocontroller & Bildschirm

Wie oben erwähnt, hatte ich geplant, dass mein Modul Navigationsinformationen anzeigt, während es nicht die tatsächliche Positionierung, Verfolgung und Echtzeitnavigation berechnet. das Telefon des Benutzers würde stattdessen mit dem Modul kommunizieren und ihm die Informationen senden, die dann auf dem HUD angezeigt werden.

Um die Kommunikation zwischen dem Telefon des Benutzers und dem Modul zu erleichtern, habe ich mich für dieses Projekt entschieden, ein ESP32-basiertes Board zu verwenden. Diese Wahl war auf dieses spezielle Modul mit integrierten Bluetooth-Funktionen sowie einigen anderen interessanten Spezifikationen zurückzuführen (einfach zu verwendender nichtflüchtiger Speicher, Dual-Core-CPU, genug RAM, um das OLED-Display tatsächlich über I2C anzusteuern, …). Es ist relativ einfach, PCBs basierend auf dem ESP32 zu entwerfen, was ich berücksichtigt habe. Ich habe auch Berufserfahrung im Umgang mit und im Design von Schaltungen mit dem ESP32, was meine Wahl definitiv beeinflusst hat.

Bei der Wahl des Bildschirms kam es im Wesentlichen darauf an, was ich finden konnte, dass es hell genug für Ihre Verwendung sein würde, aber auch so klein wie möglich. Ich machte mir keine großen Sorgen um die Anzahl der Pixel des Bildschirms, da mein Ziel eine sehr minimalistische und einfache Benutzeroberfläche war.

Es ist zu beachten, dass der Bildschirmtreiber von einer Bibliothek unterstützt werden sollte, die eine Bildspiegelung ermöglicht. Das liegt daran, dass das angezeigte Bild gespiegelt wird, wenn es durch die Linse gelangt und auf dem Reflektor erscheint, und es ist eine enorme Last, die wir als Bauherren nicht manuell umkehren müssen, was angezeigt wird.

Schritt 3: Teile - Optik: Einen Kompromiss finden

Die Optik für dieses Projekt war ziemlich schwer zu erreichen, da ich zu Beginn dieses Projekts noch keine Ahnung hatte, wonach ich überhaupt suchte. Nach einigen Recherchen habe ich verstanden, dass ich ein "virtuelles Bild" meines OLED-Bildschirms erstellen wollte, das weiter vom Auge entfernt zu sein scheint, als es tatsächlich ist. Der ideale Abstand für dieses virtuelle Bild wäre etwa 2-5 Meter vor dem Fahrer, dies scheint der Abstand zu den Objekten zu sein, auf die wir beim Fahren fokussieren (andere Autos, Unebenheiten auf der Straße usw.).).

Um dieses Ziel zu erreichen, habe ich mich für eine Fresnel-Linse entschieden, da diese ziemlich groß und billig sind, eine ausreichende Brennweite für mein Projekt zu bieten schienen und mit einer einfachen Schere geschnitten werden können (was bei nicht der Fall ist). raffiniertere runde Glaslinsen). Fresnel-Linsen finden sich unter Namen wie "Taschenlupe" oder "Lesekartenlupe", da sie sehr gut geeignet sind, um Menschen mit Sehschwäche beim Lesen zu helfen.

Im Grunde ging es hier darum, den richtigen Kompromiss zu finden zwischen:

- Einen angemessenen virtuellen Bildabstand haben (d. h. wie weit das HUD für den Benutzer erscheint oder wie weit der Benutzer seine Augen anpassen muss, um zu sehen, was sich auf dem HUD befindet)

- Den Text auf dem Bildschirm durch das Objektiv (das im Grunde eine Lupe ist) nicht zu stark vergrößern

- Einen angemessenen Abstand zwischen dem OLED-Bildschirm und der Linse haben, was sonst zu einem sehr sperrigen Modul führen würde

Ich habe persönlich bei Amazon ein paar verschiedene Objektive bestellt und deren jeweilige Brennweite bestimmt, bevor ich mich für eines mit einer Blendenlänge von ca. 13 cm entschieden habe. Ich fand diese F-Länge, mit einem OLED-Linsenabstand von 9cm, gab mir ein zufriedenstellendes Bild auf meinem Reflektor (siehe letzte Bilder oben).

Wie Sie auf meinen Abbildungen sehen werden, muss sich die Kamera, mit der diese Bilder aufgenommen wurden, so einstellen, als würde sie auf ein weit entferntes Objekt fokussieren, um den angezeigten Text richtig zu fokussieren, wodurch alles auf der gleichen Ebene wie der Reflektor verschwommen erscheint. Genau das wollen wir für unser HUD.

Die 3D-Dateien für den Linsenhalter finden Sie hier.

Schritt 4: Teile - ein Behälter, um sie alle zu halten

Während ich diese Instructables schreibe, ist der eigentliche Behälter, der jedes Stück des Heads-Up-Displays hält, nicht ganz entworfen. Ich habe jedoch ein paar Ideen über seine allgemeine Form und wie man bestimmte Probleme angehen kann (z. B. wie man einen Reflektor still hält und ihn Winden über 100 km/h standhält). Dies ist noch sehr in Arbeit.

Schritt 5: Erstellen eines Protokolls für unser Modul

Um die Navigationsanweisungen vom Telefon an das Entwicklungsboard zu senden, musste ich ein eigenes Kommunikationsprotokoll entwickeln, das es mir ermöglicht, die erforderlichen Daten einfach vom Telefon zu senden und gleichzeitig die Verarbeitung nach dem Empfang zu erleichtern.

Zum Zeitpunkt des Schreibens dieser Instructables waren die Informationen, die vom Telefon übertragen werden mussten, um mit dem Modul zu navigieren:

- Art des bevorstehenden Manövers (einfache Abbiegung, Kreisverkehr, Einmündung in eine andere Straße, …)

- Die genauen Anweisungen des bevorstehenden Manövers (abhängig vom Manövertyp: rechts/links für eine Abbiegung; welche Ausfahrt für einen Kreisverkehr zu nehmen ist, …)

- Die verbleibende Distanz bis zum bevorstehenden Manöver (vorerst in Metern)

Ich beschloss, diese Daten mit der folgenden Rahmenstruktur zu organisieren:

:typ. Anweisungen, Abstand;

Dies ist zwar keine schöne Lösung, ermöglicht es uns jedoch, jedes Feld unseres Protokolls leicht zu trennen und zu unterscheiden, was die Kodierung auf der ESP32-Seite erleichtert.

Es ist wichtig zu bedenken, dass für zukünftige Funktionen diesem Protokoll möglicherweise andere Informationen hinzugefügt werden müssen (z Gebäudelogik wie jetzt.

Schritt 6: Der Code: ESP32-Seite

Der Code für den ESP32 ist derzeit recht einfach. Es verwendet die U8g2lib-Bibliothek, die eine einfache Steuerung des OLED-Bildschirms ermöglicht (während die Spiegelung des angezeigten Bildes ermöglicht).

Im Grunde genommen empfängt der ESP32 nur serielle Daten über Bluetooth, wenn die App sie sendet, analysiert sie und zeigt diese Daten oder Bilder basierend auf diesen Daten an (dh Anzeige eines Pfeils anstelle des Satzes "links / rechts abbiegen"). Hier ist der Code:

/*Programm zur Steuerung eines HUD von einer Android-App über serielles Bluetooth*/#include "BluetoothSerial.h" //Header-Datei für serielles Bluetooth, wird standardmäßig in Arduino hinzugefügt#include #include #ifdef U8X8_HAVE_HW_SPI#include #endif# ifdef U8X8_HAVE_HW_I2C#include #endif//OLED-Bibliothekskonstruktor, muss entsprechend Ihrem Bildschirm geändert werdenU8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_MIRROR, /* reset=*/ U8X8_PIN_NONE); // Zustandsmaschine erkannte_Feldwerte + Variable#define manöverField 1#define InstructionsField 2#define distanceField 3#define endOfFrame 4intDetected_field = endOfFrame;BluetoothSerial serialBT; // Objekt für Bluetoothchar eingehend_char;char manöver[10];char Instructions[10];char distance[10];char tempManeuver[10];char tempInstructions[10];char tempDistance[10];int nbr_char_maneuver = 0;int nbr_char_instructions = 0;int nbr_char_distance = 0;boolean fullsentence = false;void setup () { Serial.begin (9600); // Starten Sie den seriellen Monitor in 9600 Baud u8g2.begin (); // OLED-Steuerung initialisieren serialBT.begin("ESP32_BT"); // Name der Bluetooth-Signalverzögerung (20); Serial.println ("Bluetooth Device is Ready to Pair");}void loop () { if (serialBT.available () && !fullsentence) // Zeichen, die über Bluetooth seriell empfangen werden {eingang_char = serialBT.read (); Serial.print ("Empfangen:"); Serial.println (incoming_char); } switch (detected_field) { case manöverField: Serial.println ("Erkanntes Feld: Manöver"); if (incoming_char == '.') // Nächstes Feld erkannt {Detected_field = InstructionsField; } else { // Füllen Sie das Manövertyp-Info-Array aus manöver[nbr_char_maneuver] = eingehend_char; nbr_char_manöver ++; } brechen; case InstructionsField: Serial.println ("Erkanntes Feld: Anweisungen"); if (incoming_char == ', ') // Nächstes Feld erkannt {Detected_field = distanceField; } else { // Instruktionen ausfüllen info array Instructions[nbr_char_instructions] = eingehend_char; nbr_char_Anweisungen ++; } brechen; case distanceField: Serial.println ("Erkanntes Feld: Distanz"); if (incoming_char == ';') // Frame-Ende erkannt {Detected_field = endOfFrame; Serial.print ("Manöver:"); Serial.println (Manöver); Serial.print ("Anweisungen:"); Serial.println (Anweisungen); Serial.print ("Abstand:"); Serial.println (Entfernung); voller Satz = wahr; update_Display(); // Vollbild empfangen, parsen und empfangene Daten anzeigen } else { // Fülle das Distance-Info-Array distance[nbr_char_distance] = eingehend_char; nbr_char_distanz ++; } brechen; case endOfFrame: if (incoming_char == ':') detektiertes_field = manöverField; // Neuer Frame erkannt Break; default: // Nichts tun break; } delay(20);}void update_Display(){ // Cache jedes char-Arrays, um mögliche Konflikte zu vermeiden memcpy(tempManeuver, manöver, nbr_char_maneuver); memcpy(tempAnweisungen, Anweisungen, nbr_char_Anweisungen); memcpy(tempDistance, distance, nbr_char_distance); parseCache(); // char-Arrays parsen und verarbeiten fullsentence = false; // Satz verarbeitet, bereit für den nächsten}void parseCache(){ u8g2.clearBuffer(); // den internen Speicher löschen u8g2.setFont (u8g2_font_ncenB10_tr); // Wählen Sie eine geeignete Schriftart // char-Arrays -> String erforderlich, um die Funktion substring() zu verwenden String manöverString = tempManeuver; String-AnweisungenString = tempInstructions; //Implementiere das Protokoll hier. Unterstützt vorerst nur Kurven. if (maneuverString.substring (0, 4) == "turn") {// Auf Manövertyp prüfen Serial.print ("TURN DETECTED"); if (instructionsString.substring(0, 5) == "right") { // Bestimmte Anweisungen prüfen und entsprechend anzeigen u8g2.drawStr(5, 15, "-"); } else if (instructionsString.substring(0, 4) == "left") { // Bestimmte Anweisungen prüfen und entsprechend anzeigen u8g2.drawStr(5, 15, "<---"); } else u8g2.drawStr(5, 15, "Err."); // Feld für ungültige Anweisungen } /* Andere Manövertypen implementieren (Kreisel usw.) * else if (tempManeuver == "rdbt"){ * *] */ u8g2.drawStr(5, 30, tempDistance); // Reststrecke anzeigen u8g2.sendBuffer(); // Internen Speicher auf das Display übertragen // Alle Zeichenarrays vor dem nächsten Lesen zurücksetzen memset (manöver, 0, 10); memset (Anweisungen, 0, 10); memset (Entfernung, 0, 10); memset(tempManöver, 0, 10); memset(tempInstructions, 0, 10); memset (tempDistance, 0, 10); // Anzahl der Elemente in Arrays zurücksetzen nbr_char_distance = 0; nbr_char_Anweisungen = 0; nbr_char_manöver = 0;}

Schritt 7: Der Code: Android-Seite

Für die Smartphone-App habe ich mich für das Navigations-SDK von Mapbox entschieden, da es viele nützliche Funktionen bietet, wenn es darum geht, eine Navigationskarte von Grund auf neu zu erstellen. Es ermöglicht auch die Verwendung vieler nützlicher Listener, die definitiv dazu beitragen, dass dieses Modul funktioniert. Ich habe auch die android-bluetooth-serial-Bibliothek von harry1453 für Android verwendet, da sie die serielle Bluetooth-Kommunikation viel einfacher zusammenzustellen machte.

Wenn Sie diese App zu Hause erstellen möchten, benötigen Sie ein Mapbox-Zugriffstoken, das bis zu einer bestimmten Anzahl von Anfragen pro Monat kostenlos ist. Sie müssen dieses Token in den Code einfügen und die App auf Ihrer Seite erstellen. Sie müssen auch die Bluetooth-MAC-Adresse Ihres ESP32 eingeben.

So wie es aussieht, kann die App Sie von Ihrem aktuellen Standort zu jedem Ort führen, den Sie auf der Karte anklicken können. Wie im Intro erwähnt, unterstützt es jedoch keine anderen Manöver als Kurven und bewältigt noch keine Off-Routen.

Den kompletten Quellcode findet ihr auf meinem Github.

Schritt 8: Was kommt als nächstes?

Nachdem die App nun funktional genug ist, um den Benutzer tatsächlich auf einer festgelegten Route zu führen (sofern keine Abweichungen von der festgelegten Route auftreten), liegt mein Hauptaugenmerk darauf, die Smartphone-App zu verbessern und die wenigen Funktionen zu implementieren, die das Modul zu einem brauchbares Navigationsgerät. Dazu gehört die Aktivierung der Bluetooth-Kommunikation vom Telefon auch bei ausgeschaltetem Bildschirm sowie die Unterstützung anderer Fahrmanöver (Kreisel, Zusammenführung, …). Ich werde auch eine Umleitungsfunktion implementieren, wenn der Benutzer von der ursprünglichen Route abweicht.

Wenn all dies erledigt ist, werde ich den Container und seinen Befestigungsmechanismus verbessern, ihn in 3D drucken und versuchen, das Modul für einen ersten Lauf zu nehmen.

Wenn alles gut geht, ist mein langfristiges Ziel, eine kundenspezifische Leiterplatte für die eingebettete Elektronik dieses Projekts zu entwerfen, die viel Platz auf dem Endprodukt sparen würde.

Ich könnte diesem Modul in Zukunft auch einige andere Funktionen hinzufügen, darunter eine Zeitanzeige sowie einen Telefonbenachrichtigungsalarm, der ein Symbol anzeigen lassen könnte, wenn der Benutzer eine Textnachricht oder einen Anruf erhält. Schließlich würde ich als großer Musikfan gerne Spotify-Funktionen zu diesem Modul hinzufügen. Zu diesem Zeitpunkt ist dies jedoch nur ein nice to have.

Schritt 9: Fazit und besonderer Dank

Wie im Intro erwähnt, wollte ich dieses Projekt, obwohl es noch lange nicht fertig ist, wirklich mit der Welt teilen, in der Hoffnung, dass es jemand anderen inspirieren könnte. Ich wollte auch meine Forschungen zu diesem Thema dokumentieren, da das Interesse von Hobbyisten an AR und HUDs nicht wirklich groß ist, was ich schade finde.

Ein großes Dankeschön möchte ich Awall99 und Danel Quintana aussprechen, deren jeweiliges Augmented-Reality-Projekt mich bei der Erstellung dieses Moduls sehr inspiriert hat.

Vielen Dank für Ihre Aufmerksamkeit, ich werde auf jeden Fall ein Update veröffentlichen, wenn dieses Projekt in naher Zukunft verbessert wird. In der Zwischenzeit bis später!