Smart motorcykel HUD-prototyp (turn-by-turn navigation och så mycket mer): 9 steg

2024 Författare: John Day | [email protected]. Senast ändrad: 2024-01-30 12:35

Hej !

This Instructables är berättelsen om hur jag konstruerade och byggde en HUD-plattform (Heads-Up Display) utformad för att monteras på motorcykelhjälmar. Det skrevs i samband med "kartor" -tävlingen. Tyvärr kunde jag inte helt slutföra detta projekt i tid för tävlingens deadline, men jag ville fortfarande dela med mig av mina framsteg med det, samt dokumentera alla försök och fel som jag fick genom att göra det.

Idén till det här projektet kom först till mig för några år sedan, när jag satte mig in i motorcyklar, och jag började undersöka vilka redskap jag skulle behöva köpa för att göra mina åkattraktioner roligare. Då förvirrade det mig att det bästa sättet att få lite grundläggande GPS -navigering under ridning var att i princip fästa din smartphone till din cykels styr. Jag tänker för mig själv att det säkert kan finnas ett bättre sätt att få den typen av information i farten.

Det var då det kom till mig: en head-up display kan vara sättet att få navigering medan du kör, utan att tömma telefonens batteri och utsätta den för elementen.

Med tiden mognade denna idé i mitt sinne, och jag menade att om jag alltid hade en HUD framför mig skulle det möjliggöra många fler användningsområden än enkel navigering. Det är därför min plan är att göra plattformen offentlig och modulär, så att alla kan skapa en modul som visar den information de behöver på sin egen HUD

Även om det finns kommersiellt tillgängliga produkter som uppfyller denna uppgift, finns det inga som är lika modulära som min plattform, och de tenderar också att vara lite dyra. Hur som helst, välkommen till det här projektet.

Vad fungerar nu

Som sagt är detta projekt fortfarande mycket i utvecklingsläge, och det är det som fungerar för närvarande.

- Kommunikation mellan en smartphone och ett ESP32 -baserat kort (telefon vaken)

- Optikdesign gjord (kan behöva små justeringar på lång sikt)

- Android -navigationsapp med Mapbox -navigations -SDK:

- Kan beräkna och visa användarens position på en karta, samt en rutt från den till destinationen

- Kan ansluta till en Bluetooth -enhet (enhetens MAC -adress är hårdkodad från och med nu)

- Kan navigera i realtid, inklusive att extrahera och skicka information om den kommande manövern via seriell Bluetooth (stöder bara svängar för tillfället)

Vad behöver arbete

Denna lista innehåller objekt som är absolut nödvändiga för HUD: s avsedda användning, men som inte är redo att implementeras ännu.

- Övergripande design (hjälmfäste, reflektorns vinkeljusteringsmekanism,..)

- Android -app:

- Implementera upptäckt och korrigering utanför vägen

- Möjlighet för användaren att ange destinationsadressen

- Waypoints?

- Ergonomi / estetik

Tillbehör:

Essentials

- En esp32 -baserad utvecklingskort

- Någon nyligen genomförd Android -smartphone (Bluetooth -aktiverad)

- En SSD1306 eller annan aktiverad 96 "OLED -skärm (min var 128x64 pixlar, se avsnittet" Hjärnan: mikrokontroller och skärm ")

- En reflektor (alla bitar av akryl/glas/plexiglas kommer att göra)

- Ett Fresnel -objektiv (mitt hade en F.längd på cirka 13 cm, se "Linsval" -delen)

Verktyg

- Lödkolv

- Brödbräda

- Några bygelkablar

- 3D -skrivare / 3D -utskriftstjänst

Steg 1: Hur allt fungerar: Designval förklaras

Grundidén med en Heads Up Display är att visa en bild framför någons vision, så att de inte behöver titta bort från vad de gör (vare sig det är att styra ett plan eller att köra en motorcykel, vilket blir vår exempelfall).

Optik

Tekniskt sett kan detta uppnås genom att rakt upp lägga en skärm framför användarens ögon. En skärm är dock inte transparent och hindrar därför användarens syn. Du kan sedan placera skärmen framför en reflekterande yta, vilket speglar skärmens innehåll samtidigt som den är genomskinlig nog att användaren kan se vad som finns framför honom.

Detta tillvägagångssätt har dock en stor brist: den faktiska skärmen är vanligtvis närmare användarens ögon än vad användaren faktiskt måste fokusera på (t.ex. vägen framför honom). Detta betyder att för att kunna läsa vad som finns på den reflekterande ytan måste användarens ögon anpassa sig till displayens avstånd från ögonen (låt oss säga 20 cm) och sedan behöva anpassa sig igen för att fokusera på vägen framåt (~ 2/5 meter). Den tid som hela denna operation tar är dyrbar tid som bör läggas på att titta på vägen, och att anpassa ofta kan vara obekvämt för användaren efter bara några minuter.

Det är därför jag bestämde mig för att lägga till ett objektiv mellan skärmen och reflektorn. Det här objektivet, om det väljs noggrant, bör möjliggöra skapande av en virtuell bild av skärmen (se schemat ovan), som sedan verkar vara längre bort från användarens ögon som det faktiskt är, vilket kräver mindre abrupta anpassningar (eller ingen alls, i ett perfekt scenario). Denna design gör det möjligt för användaren att snabbt titta på reflektorn, få den information han behöver och omedelbart titta tillbaka på vägen.

Smarttelefonens roll

Eftersom det var orealistiskt att försöka implementera en hel navigationsapplikation enbart på ESP32, bestämde jag mig för att göra en Android -app som skulle ta hand om detta. Appen skulle då bara behöva berätta för ESP32 vad användaren måste göra för att komma till sin destination, och ESP32 vidarebefordrar den informationen till HUD (se figuren "Hur modulen fungerar").

Steg 2: Delar - Brains: Microcontroller & Screen

Som nämnts ovan planerade jag att få min modul att visa navigationsinformation, utan att faktiskt få den att beräkna den faktiska positioneringen, spårningen och navigering i realtid. användarens telefon skulle istället kommunicera med modulen och skicka den informationen för att sedan visas på HUD.

För att underlätta kommunikationen mellan användarens telefon och modulen valde jag att använda ett ESP32 -baserat kort för detta projekt. Detta val berodde på att den här specifika modulen har integrerade Bluetooth-funktioner, samt några andra intressanta specifikationer (lättanvänd icke-flyktig lagring, dubbelkärnig CPU, tillräckligt med RAM-minne för att faktiskt driva OLED-skärmen via I2C, …). Det är relativt enkelt att designa PCB baserat på ESP32, vilket jag tog hänsyn till. Jag har också yrkeserfarenhet med att använda och designa kretsar med ESP32, vilket definitivt påverkade mitt val.

Valet av skärmen berodde i princip på vad jag än kunde tycka om att jag skulle vara tillräckligt ljus för att kunna använda den samtidigt som den var så liten som möjligt. Jag var inte särskilt orolig för skärmens antal pixlar, eftersom mitt mål var att ha ett mycket minimalistiskt och enkelt användargränssnitt.

Det bör noteras att skärmdrivrutinen ska stödjas av ett bibliotek som möjliggör bildspegling. Det beror på att den visade bilden vänds när den kommer genom linsen och visas på reflektorn, och att inte behöva vända manuellt det som visas är en enorm vikt från våra axlar som byggare.

Steg 3: Delar - Optik: Hitta en kompromiss

Optiken för det här projektet var ganska svår att närma sig, eftersom jag inte hade en aning om vad jag ens letade efter när jag startade det här projektet. Efter lite undersökning förstod jag att det jag ville göra var att skapa en "virtuell bild" av min OLED -skärm, som verkar vara längre bort från ögat än vad det faktiskt är. Det idealiska avståndet för att skapa denna virtuella bild skulle vara cirka 2-5 meter framför föraren, a detta verkar vara avståndet till de föremål vi fokuserar på när vi kör (andra bilar, gupp på vägen osv …).

För att uppnå det målet valde jag att använda ett Fresnel -objektiv, eftersom dessa är ganska stora, billiga, de verkade erbjuda ett tillräckligt bra brännavstånd för mitt projekt, och de kan klippas med en enkel sax (vilket inte är fallet för mer raffinerade rundformade glaslinser). Fresnel -linser kan hittas namn som "fickförstorare" eller "läskortsförstorare", eftersom de är mycket lämpliga för att hjälpa personer med dålig syn att läsa.

I grund och botten handlade tricket här om att hitta rätt kompromiss mellan:

- Att ha ett rimligt virtuellt bildavstånd (det vill säga hur långt HUD verkar verka för användaren, eller hur långt användaren måste justera ögonen för att se vad som finns på HUD)

- Att inte ha texten på skärmen förstoras för mycket av linsen (som i grunden är en förstoringsglas)

- Att ha ett rimligt avstånd mellan OLED -skärmen och objektivet, vilket annars skulle leda till en mycket skrymmande modul

Jag beställde personligen några olika objektiv på amazon och bestämde deras respektive brännvidd innan jag valde ett med en F.längd på cirka 13 cm. Jag hittade denna F.längd, med ett OLED-objektivavstånd på 9 cm, gav mig en tillfredsställande bild på min reflektor (se de senaste bilderna ovan).

Som du kommer att se på mina illustrationer måste kameran som används för att korrekt fokusera på den visade texten justeras som om den fokuserade på ett avlägset objekt, vilket gör att allt på samma plan som reflektorn verkar suddigt. Detta är precis vad vi vill ha för vår HUD.

Du hittar 3d -filerna för linshållaren här.

Steg 4: Delar - en behållare för att hålla dem alla

När jag skriver denna instruktion är den egentliga behållaren som rymmer varje del av head-up-displayen inte riktigt utformad. Jag har dock några idéer om dess allmänna form och hur jag ska hantera vissa problem (som hur man håller en reflektor stilla och får den att klara 100+ km/h vindar). Detta pågår fortfarande mycket.

Steg 5: Skapa ett protokoll för vår modul

För att skicka navigationsinstruktionerna från telefonen till utvecklingskortet var jag tvungen att komma med ett eget kommunikationsprotokoll som skulle göra det möjligt för mig att enkelt skicka nödvändig data från telefonen, samtidigt som det underlättade behandlingen när den väl mottogs.

Vid skrivandet av denna instruktionsbok var informationen som behövde överföras från telefonen för att navigera med modulen:

- Den kommande manöverens typ (enkel sväng, rondell, sammanslagning till en annan väg, …)

- Den kommande manöverens exakta instruktioner (beroende på manöver typ: höger/vänster för en sväng; vilken avfart för att ta en rondell, …)

- Det kvarvarande avståndet före den kommande manövern (i meter för närvarande)

Jag bestämde mig för att organisera dessa data med hjälp av följande ramstruktur:

: typ.instruktioner, avstånd;

Även om det inte är en vacker lösning, tillåter den här oss att enkelt skilja och skilja varje fält i vårt protokoll, vilket underlättade kodningen på ESP32 -sidan.

Det är viktigt att komma ihåg att för framtida funktioner kan annan information behöva läggas till i detta protokoll (till exempel exakt dag och tid eller musiken som spelas upp på användarens telefon), vilket skulle vara enkelt att använda samma bygglogik som nu.

Steg 6: Koden: ESP32 -sidan

Koden för ESP32 är för närvarande ganska enkel. Den använder U8g2lib -biblioteket, vilket möjliggör enkel kontroll av OLED -skärmen (samtidigt som spegling av den visade bilden).

I grund och botten är allt ESP32 gör att ta emot seriell data via Bluetooth när appen skickar den, analyserar den och visar dessa data eller bilder baserade på dessa data (dvs. visar en pil istället för meningen "sväng vänster/höger"). Här är koden:

/*Program för att styra en HUD från en Android -app via seriell bluetooth*/#inkluderar "BluetoothSerial.h" // Rubrikfil för seriell Bluetooth, läggs till som standard i Arduino#include #include #ifdef U8X8_HAVE_HW_SPI#include#endif# ifdef U8X8_HAVE_HW_I2C #include #endif // OLED bibliotekskonstruktör, måste ändras i enlighet med din skärmU8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2 (U8G2_MIRROR,/* reset =*/U8X8_PIN_NONE;) // Statens maskin detekterade_fältvärden + variabel#definiera manöverFält 1#definiera instruktionerFält 2#definiera avståndFält 3#definiera endOfFrame 4int detekterat_fält = endOfFrame; BluetoothSerial serialBT; // Objekt för Bluetoothchar inkommande_char; rödingmanöver [10]; rödningsinstruktioner [10]; rödningsavstånd [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; boolsk fullsändning = falsk; void setup () {Serial.begin (9600); // Starta seriell bildskärm i 9600 bauds u8g2.begin (); // Init OLED -kontroll serialBT.begin ("ESP32_BT"); // Namn på Bluetooth -signalfördröjning (20); Serial.println ("Bluetooth -enhet är redo att para");} void loop () {if (serialBT.available () &&! Fullsentence) // Tecken tas emot via Bluetooth -seriell {incoming_char = serialBT.read (); Serial.print ("Mottaget:"); Serial.println (inkommande_char); } switch (detekterat_fält) {case maneuverField: Serial.println ("Upptäckt fält: manöver"); if (inkommande_char == '.') // Nästa fält upptäckt {detect_field = instructionField; } annat {// Fyll på manöver typ info array maneuver [nbr_char_maneuver] = inkommande_char; nbr_char_manöver ++; } ha sönder; case instructionsField: Serial.println ("Upptäckt fält: instruktioner"); if (inkommande_char == ',') // Nästa fält upptäckt {detekterat_fält = distansfält; } annat {// Fyll instruktionerna info array -instruktioner [nbr_char_instructions] = inkommande_char; nbr_char_instructions ++; } ha sönder; case distanceField: Serial.println ("Upptäckt fält: avstånd"); if (inkommande_char == ';') // Slut på ram upptäckt {detect_field = endOfFrame; Serial.print ("manöver:"); Serial.println (manöver); Serial.print ("instruktioner:"); Serial.println (instruktioner); Serial.print ("avstånd:"); Serial.println (avstånd); fullsänkning = sant; update_Display (); // Hel bildram mottagen, analysera den och visa återkommande data} annat {// Fyll avståndsinformationsmatrisavståndet [nbr_char_distance] = inkommande_char; nbr_char_distance ++; } ha sönder; case endOfFrame: if (incoming_char == ':') detect_field = maneuverField; // Ny ram upptäckt paus; default: // Gör inget sönder; } delay (20);} void update_Display () {// Cache varje char array för att undvika eventuella konflikter memcpy (tempManeuver, maneuver, nbr_char_maneuver); memcpy (tempInstruktioner, instruktioner, nbr_char_instructions); memcpy (tempDistance, distance, nbr_char_distance); parseCache (); // Analysera och bearbeta char -matriser fullsänkning = falskt; // Meningen bearbetad, redo för nästa}} void parseCache () {u8g2.clearBuffer (); // rensa det interna minnet u8g2.setFont (u8g2_font_ncenB10_tr); // välj ett lämpligt teckensnitt // char arrays -> string obligatoriskt för att använda substring () funktion String maneuverString = tempManeuver; StränginstruktionerString = tempInstructions; // Implementeringsprotokoll här. Stöder bara svängar för tillfället. if (maneuverString.substring (0, 4) == "turn") {// Sök efter manöver typ Serial.print ("TURN DETECTED"); if (instructionsString.substring (0, 5) == "right") {// Kontrollera specifika instruktioner och visa därefter u8g2.drawStr (5, 15, "-"); } annars if (instructionsString.substring (0, 4) == "vänster") {// Kontrollera specifika instruktioner och visa därefter u8g2.drawStr (5, 15, "<---"); } annars u8g2.drawStr (5, 15, "Err."); // Ogiltigt instruktionsfält}/ * Implementera andra manövertyper (rondeller osv.) * Else if (tempManeuver == "rdbt") { * *] */ u8g2.drawStr (5, 30, tempDistance); // Visa återstående avstånd u8g2.sendBuffer (); // överför internt minne till displayen // Återställ alla char -matriser före nästa läsning memset (manöver, 0, 10); memset (instruktioner, 0, 10); memset (avstånd, 0, 10); memset (tempManeuver, 0, 10); memset (tempInstructions, 0, 10); memset (tempDistance, 0, 10); // Återställ antal element i matriser nbr_char_distance = 0; nbr_char_instructions = 0; nbr_char_manöver = 0;}

Steg 7: Koden: Android Side

För smartphone -appen bestämde jag mig för att använda Mapbox navigations -SDK, eftersom det erbjuder många användbara funktioner när det gäller att bygga en navigeringskarta från grunden. Det tillåter också användning av många användbara lyssnare, vilket definitivt hjälper till att få denna modul att fungera. Jag använde också harry1453s android-bluetooth-seriella bibliotek för android, eftersom det gjorde Bluetooth seriell kommunikation mycket enklare att sätta ihop.

Om du vill bygga den här appen hemma måste du få en Mapbox -åtkomsttoken, som är gratis upp till ett visst antal förfrågningar per månad. Du måste sätta denna token i koden och bygga appen på din sida. Du måste också koda i din egen ESP32: s Bluetooth MAC -adress.

Som det ser ut kan appen leda dig från din nuvarande plats till valfri plats som du kan klicka på på kartan. Som nämnts i inledningen stöder den dock ingen annan manöver än svängar och hanterar inte off-rutter än.

Du hittar hela källkoden på min github.

Steg 8: Vad är nästa?

Nu när appen är tillräckligt funktionell för att faktiskt vägleda sin användare på en bestämd rutt (om det inte finns några avvikelser från den inställda rutten) kommer mitt huvudfokus vara att förbättra smartphone -appen och implementera de få funktioner som skulle göra modulen till en livskraftig navigationsenhet. Detta inkluderar aktivering av Bluetooth -kommunikation från telefonen även när skärmen är avstängd, samt stöd för andra typer av manövrar (rondeller, sammanslagning, …). Jag kommer också att implementera en omdirigeringsfunktion om användaren avviker från den ursprungliga rutten.

När allt detta är gjort kommer jag att förbättra behållaren och dess fastsättningsmekanism, 3D -skriva ut den och försöka ta modulen för en första körning.

Om allt går bra är mitt långsiktiga mål att designa ett anpassat kretskort för den inbyggda elektroniken i detta projekt, vilket skulle spara mycket utrymme på den slutliga produkten.

Jag kan också lägga till några andra funktioner i den här modulen i framtiden, inklusive en tidsvisning, samt ett telefonlarm, som kan få en ikon att visas när användaren får ett textmeddelande eller ett samtal. Slutligen skulle jag vilja lägga till Spotify -funktioner till den här modulen, som ett stort musikfan. Men vid denna tidpunkt är detta bara trevligt att ha.

Steg 9: Slutsats och särskilt tack

Som framgår av inledningen, även om detta projekt långt ifrån är klart, ville jag verkligen dela det med världen, i hopp om att det kan inspirera någon annan. Jag ville också dokumentera min forskning om detta ämne, eftersom det inte finns särskilt mycket hobbyintresse för AR och HUD, vilket jag tycker är synd.

Jag vill rikta ett stort tack till Awall99 och Danel Quintana, vars respektive augmented reality -projekt inspirerade mig mycket vid skapandet av denna modul.

Tack alla för er uppmärksamhet, jag kommer att lägga upp en uppdatering när detta projekt förbättras inom en snar framtid. Under tiden ses vi alla senare!