Slim motorfiets HUD-prototipe (draai-vir-draai-navigasie en soveel meer): 9 stappe

2024 Outeur: John Day | [email protected]. Laas verander: 2024-01-30 07:23

Hi !

Hierdie instruksies is die verhaal van hoe ek 'n HUD (Heads-Up Display) platform ontwerp en gebou het wat ontwerp is om op motorhelms gemonteer te word. Dit is geskryf in die konteks van die "kaarte" -kompetisie. Ongelukkig kon ek nie hierdie projek betyds voltooi vir die sperdatum van die wedstryd nie, maar ek wou nog steeds my vordering daaroor deel, asook al die proewe en foute wat ek by die bereiking daarvan kon dokumenteer.

Die idee vir hierdie projek het 'n paar jaar gelede die eerste keer by my opgekom, toe ek in die motorfiets klim, en ek het begin kyk watter toerusting ek sou moes koop om my ritte lekkerder te maak. Destyds het dit my verbaas dat die beste manier om basiese GPS -navigasie te kry terwyl u ry, basies u slimfoon aan die stuur van u fiets was. Ek dink beslis dat daar 'n beter manier is om sulke inligting vinnig te kry.

Dit is toe ek by my uitkom: 'n head-up-skerm kan die manier wees om navigasie te kry terwyl u ry, sonder om die telefoon se battery leeg te maak en dit bloot te stel aan die elemente.

Mettertyd het hierdie idee in my gedagtes volwasse geword, en ek het gedink dat as ek te alle tye 'n HUD voor my gehad het, baie meer gebruike as eenvoudige navigasie moontlik sou wees. Daarom is my plan om die platform publiek en modulêr te maak, sodat almal 'n module kan skep wat die nodige inligting op hul eie HUD kan vertoon

Alhoewel daar in die handel beskikbare produkte is wat hierdie taak vervul, is daar nie so modulêr soos my platform nie, en dit is ook geneig om 'n bietjie duur te wees. In elk geval, welkom by hierdie projek.

Wat nou werk

Soos genoem, is hierdie projek nog steeds in 'n ontwikkelende toestand, en dit is wat tans werk.

- Kommunikasie tussen 'n slimfoon en 'n ESP32 -kaart (telefoon wakker)

- Optika -ontwerp gedoen (benodig dalk klein aanpassings op die lange duur)

- Android -navigasie -app met behulp van die Mapbox -navigasie -SDK:

- Kan die gebruiker se posisie op 'n kaart bereken en vertoon, sowel as 'n roete daarvan na die bestemming

- Kan aan 'n Bluetooth -toestel koppel (die MAC -adres van die toestel is tans hardkodeerbaar)

- Real -time navigasie moontlik, insluitend die onttrek en stuur van die inligting van die komende maneuver via seriële Bluetooth (ondersteun tans slegs draaie)

Wat werk nodig het

Hierdie lys bevat items wat absoluut noodsaaklik is vir die beoogde gebruik van die HUD, maar nog nie gereed is om geïmplementeer te word nie.

- Algehele ontwerp (helmaanhegsel, meganisme vir aanpassing van die hoek van die reflektor,..)

- Android -program:

- Implementeer opsporing en regstelling buite die roete

- Die gebruiker kan die bestemmingsadres invoer

- Waypoints?

- Ergonomie / estetika

Benodighede:

Noodsaaklikhede

- 'n Ontwikkelingsbord op esp32 gebaseer

- Enige ietwat onlangse Android -slimfoon (met Bluetooth aangeskakel)

- 'n SSD1306 of ander geaktiveerde 96 "OLED -skerm (myne was 128x64 pixels, sien die gedeelte" Die brein: mikrobeheerder en skerm ")

- 'n Reflektor (enige stuk akriel/glas/plexiglas kan gebruik word)

- 'n Fresnel -lens (myne het 'n F. -lengte van ongeveer 13 cm, sien die gedeelte "Lenskeuse")

Gereedskap

- Soldeerbout

- Broodbord

- 'n Paar springkabels

- 3D -drukker / 3D -drukdiens

Stap 1: Hoe dit alles werk: Ontwerpkeuses verduidelik

Die basiese idee van 'n Heads Up Display is om 'n beeld voor iemand se visie te vertoon, sodat hulle nie hoef weg te kyk van wat hulle ook al doen nie (of dit nou 'n vliegtuig is, of 'n motorfiets ry, wat ons sal wees) voorbeeld geval).

Optika

Tegnies kan dit bereik word deur reguit 'n skerm voor die gebruiker se oë te plaas. 'N Skerm is egter nie deursigtig nie en kan die gebruiker se visie belemmer. U kan dan die skerm voor 'n weerkaatsende oppervlak plaas, wat die inhoud van die skerm weerspieël, terwyl dit ook deursigtig genoeg is sodat die gebruiker kan sien wat voor hom is.

Hierdie benadering het egter 'n groot fout: die werklike skerm is gewoonlik nader aan die gebruiker se oë as waarop die gebruiker eintlik moet fokus (bv. Die pad wat voor hom lê). Dit beteken dat die oë van die gebruiker, om te lees wat op die reflekterende oppervlak is, moet aanpas by die afstand van die skerm van sy oë (kom ons sê 20 cm) en dan weer moet aanpas om op die pad vorentoe te fokus. (~ 2/5 meter). Die tyd wat hierdie hele operasie neem, is kosbare tyd wat u moet spandeer om na die pad te kyk, en om gereeld aan te pas, kan na 'n paar minute vir die gebruiker ongemaklik wees.

Daarom het ek besluit om 'n lens tussen die skerm en die reflektor by te voeg. Hierdie lens, as dit noukeurig gekies word, moet 'n virtuele beeld van die skerm moontlik maak (sien die skema hierbo), wat dan blykbaar verder weg is van die gebruiker se oë soos dit eintlik is, en vereis dus minder abrupte aanpassings (of glad nie, in 'n perfekte scenario). Met hierdie ontwerp kan die gebruiker vinnig na die reflektor kyk, die inligting kry wat hy nodig het en onmiddellik terugkyk na die pad.

Die rol van die slimfoon

Omdat dit onrealisties was om 'n hele navigasie -toepassing op die ESP32 alleen te probeer implementeer, het ek besluit om 'n Android -app te maak wat hiervoor sal sorg. Die app hoef dan net aan die ESP32 te vertel wat die gebruiker moet doen om by sy bestemming uit te kom, en die ESP32 stuur die inligting deur die HUD (sien figuur "Hoe die module werk").

Stap 2: Onderdele - die breins: mikrobeheerder en skerm

Soos hierbo genoem, was ek van plan om my module-navigasie-inligting te laat sien, terwyl ek dit nie eintlik die werklike posisionering, opsporing en intydse navigasie kon bereken nie. die telefoon van die gebruiker sal in plaas daarvan met die module kommunikeer en die inligting aan hom stuur om dan op die HUD vertoon te word.

Om die kommunikasie tussen die gebruiker se telefoon en die module te vergemaklik, het ek gekies om 'n ESP32 -bord vir hierdie projek te gebruik. Hierdie keuse was te danke aan die spesifieke module met geïntegreerde Bluetooth-vermoëns, asook 'n paar ander interessante spesifikasies (maklik om te gebruik, nie-vlugtige berging, 'n tweekern-verwerker, genoeg RAM om die OLED-skerm eintlik via I2C te bestuur, …). Dit is relatief eenvoudig om PCB's te ontwerp wat gebaseer is op die ESP32, wat ek wel in ag geneem het. Ek het ook professionele ervaring met die gebruik en ontwerp van stroombane met die ESP32, wat my keuse beslis beïnvloed het.

Die keuse van die skerm kom basies neer op alles wat ek kon vind, maar ek sou helder genoeg wees vir u gebruik, terwyl ek ook so klein as moontlik was. Ek was nie baie bekommerd oor die aantal pixels van die skerm nie, want my doel was om 'n baie minimalistiese en eenvoudige UI te hê.

Daar moet op gelet word dat die skermbestuurder ondersteun moet word deur 'n biblioteek wat beeldspieëling moontlik maak. Dit is omdat die beeld wat vertoon word, omgedraai word as dit deur die lens kom en op die reflektor verskyn, en as dit nie 'n groot gewig van ons skouers hoef te wees om dit wat vertoon word, handmatig om te draai nie.

Stap 3: Onderdele - optika: 'n kompromie vind

Die optika vir hierdie projek was redelik moeilik om te benader, aangesien ek nie 'n idee gehad het waarna ek gesoek het toe ek die eerste keer met hierdie projek begin het nie. Na 'n bietjie ondersoek het ek besef dat wat ek wou doen, was om 'n 'virtuele beeld' van my OLED -skerm te skep, wat blykbaar verder van die oog af is as wat dit werklik is. Die ideale afstand vir die vorming van hierdie virtuele beeld sou ongeveer 2-5 meter voor die bestuurder wees; dit lyk asof dit die afstand is tot die voorwerpe waarop ons fokus wanneer ons ry (ander motors, stampe op die pad, ens …).

Om hierdie doel te bereik, het ek gekies om 'n Fresnel -lens te gebruik, aangesien dit redelik groot en goedkoop is, dit lyk asof hulle 'n goeie fokusafstand vir my projek bied, en dit kan met 'n eenvoudige skêr gesny word (wat nie die geval is nie meer verfynde ronde glaslense). Fresnel -lense kan name gevind word soos "pocket vergrootglas" of "leeskaart vergrootglas", aangesien dit baie geskik is om mense met swak sig te help lees.

Die truuk hier gaan eintlik oor die vind van die regte kompromie tussen:

- Met 'n redelike virtuele beeldafstand (dit wil sê, hoe ver die HUD na die gebruiker sal lyk, of hoe ver die gebruiker sy oë sal moet aanpas om te sien wat op die HUD is)

- As die teks op die skerm nie te groot word deur die lens nie (wat eintlik 'n vergrootglas is)

- 'n redelike afstand tussen die OLED -skerm en die lens, wat andersins tot 'n baie lywige module sou lei

Ek het persoonlik 'n paar verskillende lense op Amazon bestel, en hulle onderskeie brandpunte bepaal, voordat ek een met 'n F. -lengte van ongeveer 13 cm gekies het. Ek het hierdie F. lengte, met 'n OLED-lensafstand van 9 cm, gevind, het my 'n bevredigende beeld op my reflektor gegee (sien die laaste paar beelde hierbo).

Soos u op my illustrasies sal sien, moet die kamera wat gebruik is om hierdie foto's te neem, regstel om te fokus asof dit op 'n verre voorwerp fokus, sodat alles op dieselfde vlak as die reflektor vaag lyk. Dit is presies wat ons wil hê vir ons HUD.

U kan die 3d -lêers vir die lenshouer hier vind.

Stap 4: Onderdele - 'n houer om almal in te hou

Terwyl ek hierdie instruksies skryf, is die werklike houer wat elke stuk van die head-up-skerm bevat, nie heeltemal ontwerp nie. Ek het egter 'n paar idees oor die algemene vorm en hoe om sekere probleme te benader (soos hoe om 'n reflektor stil te hou en dit teen wind van meer as 100 km/h te weerstaan). Dit is nog steeds 'n werk wat aan die gang is.

Stap 5: Skep 'n protokol vir ons module

Om die navigasie -instruksies van die telefoon na die ontwikkelingsbord te stuur, moes ek 'n eie kommunikasieprotokol opstel waarmee ek die vereiste data maklik van die telefoon kon stuur, terwyl ek die verwerking daarvan kon vergemaklik sodra ek dit ontvang het.

By die skryf van hierdie instruksies was die inligting wat van die telefoon af gestuur moes word om met die module te navigeer:

- Die tipe komende maneuver (eenvoudige draai, rotonde, saamsmelt op 'n ander pad, …)

- Die presiese instruksies van die komende maneuver (afhanklik van die tipe maneuver: regs/links vir 'n draai; watter afrit om 'n rotonde te neem, …)

- Die afstand wat oorbly voor die komende maneuver (in meter vir eers)

Ek het besluit om hierdie data te organiseer met behulp van die volgende raamstruktuur:

: tipe.instruksies, afstand;

Alhoewel dit nie 'n pragtige oplossing is nie, kan ons elke veld van ons protokol maklik skei en onderskei, wat die kodering aan die ESP32 -kant vergemaklik het.

Dit is belangrik om in gedagte te hou dat ander inligting vir toekomstige funksies moontlik by hierdie protokol gevoeg moet word (soos die presiese dag en tyd, of die musiek wat op die telefoon van die gebruiker gespeel word), wat maklik haalbaar is met dieselfde bou logika soos nou.

Stap 6: Die kode: ESP32 -kant

Die kode vir die ESP32 is tans redelik eenvoudig. Dit gebruik die U8g2lib -biblioteek, wat die beheer van die OLED -skerm maklik moontlik maak (terwyl dit die spieël van die vertoonde beeld moontlik maak).

Eintlik is al wat die ESP32 doen, om seriële data via Bluetooth te ontvang wanneer die app dit stuur, ontleed en hierdie data of foto's vertoon op grond van hierdie data (dws 'n pyl in plaas van die sin "draai links/regs"). Hier is die kode:

/*Program om 'n HUD vanaf 'n Android -app via seriële bluetooth te beheer*/#sluit in "BluetoothSerial.h" // Koptekstlêer vir seriële Bluetooth, word standaard bygevoeg in Arduino#sluit #include #ifdef U8X8_HAVE_HW_SPI#include#endif#in ifdef U8X8_HAVE_HW_I2C #sluit #endif // OLED -biblioteekkonstrukteur in, moet dienooreenkomstig verander word na u skermU8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2 (U8G2_MIRROR,/* reset =*/U8X8_PIN_NONE;) // Staatsmasjien detect_field waardes + veranderlike#definieer maneuver Field 1#definieer instruksies Field 2#definieer distanceField 3#definieer endOfFrame 4int detect_field = endOfFrame; BluetoothSerial serialBT; // Voorwerp vir Bluetoothchar inkomende_char; charmaneuver [10]; char -instruksies [10]; char -afstand [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; leegte opstelling () {Serial.begin (9600); // Begin Serial monitor in 9600 bauds u8g2.begin (); // Eerste OLED -beheer serialBT.begin ("ESP32_BT"); // Naam van die Bluetooth -seinvertraging (20); Serial.println ("Bluetooth -toestel is gereed om te koppel");} void loop () {if (serialBT.available () &&! Fullsentence) // Characters being received via Bluetooth serial {incoming_char = serialBT.read (); Serial.print ("Ontvang:"); Serial.println (inkomende_char); } skakelaar (detect_field) {case maneuverField: Serial.println ("Ontdek veld: maneuver"); if (inkomende_char == '.') // Volgende veld opgespoor {detect_field = instructionField; } anders {// Vul die maneuver tipe info array maneuver [nbr_char_maneuver] = inkomende_char; nbr_char_maneuver ++; } breek; saakinstruksiesField: Serial.println ("Ontdek veld: instruksies"); if (inkomende_char == ',') // Volgende veld opgespoor {detect_field = distanceField; } anders {// Vul die instruksies in: info array -instruksies [nbr_char_instructions] = inkomende_char; nbr_char_instructions ++; } breek; case distanceField: Serial.println ("Ontdek veld: afstand"); if (inkomende_char == ';') // Einde van raam opgespoor {detect_field = endOfFrame; Serial.print ("maneuver:"); Serial.println (maneuver); Serial.print ("instruksies:"); Serial.println (instruksies); Serial.print ("afstand:"); Serial.println (afstand); volsin = waar; update_Display (); // Volle raam ontvang, ontleed dit en vertoon herhaalde data} anders {// Vul die afstandinligtingreeksafstand [nbr_char_distance] = inkomende_char; nbr_char_distance ++; } breek; case endOfFrame: if (incoming_char == ':') detect_field = maneuverField; // Nuwe raam opgespoor breek; standaard: // Moet niks breek nie; } vertraging (20);} ongeldige update_Display () {// Stoor elke char -skikking in die kas om moontlike konflikte te vermy memcpy (tempManeuver, maneuver, nbr_char_maneuver); memcpy (tempInstruksies, instruksies, nbr_char_instructions); memcpy (tempDistance, distance, nbr_char_distance); parseCache (); // Ontleed en verwerk char arrays volsin = vals; // Sin verwerk, gereed vir die volgende een} void parseCache () {u8g2.clearBuffer (); // maak die interne geheue u8g2.setFont (u8g2_font_ncenB10_tr) skoon; // kies 'n geskikte lettertipe // char arrays -> string verpligtend om substring () funksie te gebruik String maneuverString = tempManeuver; String instructionString = tempInstructions; // Implementeringsprotokol hier. Ondersteun tans net beurte. if (maneuverString.substring (0, 4) == "draai") {// Kyk vir maneuversoort Serial.print ("TURN DETECTED"); if (instructionsString.substring (0, 5) == "regs") {// Gaan spesifieke instruksies na en vertoon dienooreenkomstig u8g2.drawStr (5, 15, "-"); } anders as (instructionString.substring (0, 4) == "links") {// Gaan spesifieke instruksies na en vertoon dienooreenkomstig u8g2.drawStr (5, 15, "<---"); } anders u8g2.drawStr (5, 15, "Err."); // Ongeldige instruksieveld}/ * Implementeer ander manoeuvre tipes (rotondes, ens.) * Anders as (tempManeuver == "rdbt") { * *] */ u8g2.drawStr (5, 30, tempDistance); // Wys oorblywende afstand u8g2.sendBuffer (); // dra die interne geheue oor na die skerm // Stel alle char -skikkings terug voor die volgende meting (maneuver, 0, 10); memset (instruksies, 0, 10); memset (afstand, 0, 10); memset (tempManeuver, 0, 10); memset (tempInstructions, 0, 10); memset (tempDistance, 0, 10); // Stel die aantal elemente in skikkings terug nbr_char_distance = 0; nbr_char_instructions = 0; nbr_char_maneuver = 0;}

Stap 7: Die kode: Android -kant

Vir die slimfoon -app het ek besluit om die navigasie -SDK van Mapbox te gebruik, aangesien dit baie nuttige funksies bied om 'n navigasiekaart van nuuts af te bou. Dit laat ook baie nuttige luisteraars toe, wat beslis help om hierdie module te laat werk. Ek het ook die Android-bluetooth-seriële biblioteek van harry1453 vir Android gebruik, aangesien dit baie makliker was om die seriële kommunikasie van Bluetooth aanmekaar te sit.

As u hierdie app tuis wil bou, moet u 'n Mapbox -toegangstoken kry, wat gratis is vir 'n sekere aantal versoeke per maand. U moet hierdie teken in die kode plaas en die app aan u kant bou. U moet ook u eie ESP32 se Bluetooth MAC -adres kodeer.

Soos dit tans is, kan die app u lei vanaf u huidige ligging na enige plek waarop u op die kaart kan klik. Soos in die inleiding genoem, ondersteun dit egter geen ander maneuver as draaie nie, en hanteer dit nog nie off-roetes nie.

U kan die hele bronkode op my github vind.

Stap 8: Wat is volgende?

Noudat die app funksioneel genoeg is om sy gebruiker op 'n vasgestelde roete te lei (as daar geen afwykings van die ingestelde roete is nie), is my hooffokus die verbetering van die slimfoon -app en die implementering van die paar funksies wat die module 'n lewensvatbare navigasietoestel. Dit sluit in dat Bluetooth -kommunikasie vanaf die telefoon moontlik is, selfs as die skerm af is, sowel as ondersteuning vir ander maneuvers (rotonde, samesmelting, …). Ek sal ook 'n herleidingsfunksie implementeer as die gebruiker van die oorspronklike roete afwyk.

As dit alles gedoen is, sal ek die houer en die hegmeganisme daarvan verbeter, dit 3d druk en die module vir die eerste keer probeer neem.

As alles goed gaan, is my langtermyndoelwit om 'n pasgemaakte PCB vir die ingeboude elektronika van hierdie projek te ontwerp, wat baie ruimte op die finale produk kan bespaar.

Ek kan in die toekoms ook 'n paar ander funksies by hierdie module voeg, insluitend 'n tydsweergawe, sowel as 'n telefoonkennisgewingalarm, wat 'n ikoon kan laat verskyn wanneer die gebruiker 'n sms of 'n oproep ontvang. Uiteindelik sal ek graag Spotify -funksies by hierdie module wil voeg, as 'n groot musiekliefhebber. Op hierdie tydstip is dit egter net lekker om te hê.

Stap 9: Gevolgtrekking en spesiale dank

Soos in die inleiding gesê, hoewel hierdie projek nog lank nie voltooi is nie, wou ek dit regtig met die wêreld deel, in die hoop dat dit iemand anders kan inspireer. Ek wou ook my navorsing oor hierdie onderwerp dokumenteer, aangesien daar nie regtig 'n groot stokperdjie -belangstelling in AR en HUD's is nie, wat volgens my jammer is.

Ek wil baie dankie sê aan Awall99 en Danel Quintana, wie se onderskeie augmented reality -projek my baie geïnspireer het in die maak van hierdie module.

Dankie vir u aandag, ek sal beslis 'n opdatering plaas wanneer hierdie projek in die nabye toekoms verbeter word. Intussen sien ons almal later!