Prototipo di HUD per motociclette intelligenti (navigazione passo-passo e molto altro): 9 passaggi

2024 Autore: John Day | [email protected]. Ultima modifica: 2024-01-30 09:59

Ciao !

Questo Instructables è la storia di come ho progettato e costruito una piattaforma HUD (Heads-Up Display) progettata per essere montata sui caschi da moto. È stato scritto nell'ambito del concorso "mappe". Purtroppo, non sono stato in grado di completare completamente questo progetto in tempo per la scadenza del concorso, ma volevo comunque condividere i miei progressi, oltre a documentare tutti i tentativi e gli errori che ho avuto nel realizzarlo.

L'idea di questo progetto mi è venuta per la prima volta alcuni anni fa, quando sono entrato in moto, e stavo iniziando a valutare quale attrezzatura avrei dovuto acquistare per rendere le mie uscite più piacevoli. All'epoca, ero sconcertato dal fatto che il modo migliore per ottenere una navigazione GPS di base durante la guida fosse sostanzialmente collegare lo smartphone al manubrio della bici. Ho pensato a me stesso che sicuramente potrebbe esserci un modo migliore per ottenere quel tipo di informazioni al volo.

Ecco quando è arrivato a me: un display heads-up potrebbe essere il modo per ottenere la navigazione durante la guida, senza svuotare la batteria del telefono ed esporlo agli elementi.

Nel corso del tempo, questa idea è maturata nella mia mente e ho pensato che avere un HUD davanti a me in ogni momento avrebbe consentito molti più usi della semplice navigazione. Questo è il motivo per cui il mio piano è rendere la piattaforma pubblica e modulare, in modo che chiunque possa creare un modulo che mostri le informazioni di cui ha bisogno sul proprio HUD

Sebbene ci siano prodotti disponibili in commercio che assolvono a questo compito, non ce ne sono nessuno che sia modulare come la mia piattaforma e tendono anche ad essere un po' costosi. Comunque, benvenuto in questo progetto.

Cosa funziona adesso

Come affermato, questo progetto è ancora molto in uno stato di sviluppo, e questo è ciò che sta attualmente funzionando.

- Comunicazione tra uno smartphone e una scheda basata su ESP32 (telefono attivo)

- Progettazione dell'ottica eseguita (potrebbe richiedere piccoli aggiustamenti a lungo termine)

- App di navigazione Android utilizzando l'SDK di navigazione Mapbox:

- In grado di calcolare e visualizzare la posizione dell'utente su una mappa, nonché un percorso da essa alla destinazione

- In grado di connettersi a un dispositivo Bluetooth (l'indirizzo MAC del dispositivo è già codificato)

- Capace di navigazione in tempo reale, inclusa l'estrazione e l'invio delle informazioni della manovra imminente tramite Bluetooth seriale (supporta solo le svolte per ora)

Cosa ha bisogno di lavoro

Questo elenco contiene elementi assolutamente necessari per l'uso previsto dell'HUD, ma non sono ancora pronti per essere implementati.

- Design generale (attacco al casco, meccanismo di regolazione dell'angolo del riflettore,..)

- Applicazione per Android:

- Implementare il rilevamento e la correzione fuori rotta

- Possibilità per l'utente di inserire l'indirizzo di destinazione

- Waypoint?

- Ergonomia / Estetica

Forniture:

Essenziali

- Una scheda di sviluppo basata su esp32

- Qualsiasi smartphone Android un po' recente (abilitato Bluetooth)

- Un SSD1306 o un altro schermo OLED da 96" abilitato (il mio era 128x64 pixel, vedere la parte "Il cervello: microcontrollore e schermo")

- Un riflettore (va bene qualsiasi pezzo di acrilico/vetro/plexiglass)

- Una lente di Fresnel (la mia aveva una lunghezza F. di circa 13cm, vedi parte "Scelta della lente")

Utensili

- Saldatore

- Tagliere

- Alcuni cavi jumper

- Stampante 3d / servizio di stampa 3d

Passaggio 1: come funziona: spiegazione delle scelte di progettazione

L'idea di base di un Heads Up Display è quella di mostrare un'immagine davanti alla vista di qualcuno, in modo che non debbano distogliere lo sguardo da qualunque cosa stiano facendo (che si tratti di pilotare un aereo o guidare una moto, che sarà il nostro caso esemplificativo).

Ottica

Tecnicamente, questo potrebbe essere ottenuto mettendo direttamente uno schermo davanti agli occhi dell'utente. Tuttavia, uno schermo non è trasparente e quindi ostacolerebbe la visione dell'utente. Puoi quindi posizionare lo schermo di fronte a una superficie riflettente, che rispecchi il contenuto dello schermo pur essendo abbastanza trasparente da consentire all'utente di vedere cosa c'è di fronte a lui.

Tuttavia, questo approccio ha un enorme difetto: lo schermo reale è solitamente più vicino agli occhi dell'utente rispetto a ciò su cui l'utente deve effettivamente concentrarsi (ad es. la strada davanti a sé). Ciò significa che, per leggere cosa c'è sulla superficie riflettente, gli occhi dell'utente dovrebbero adattarsi alla distanza del display dai suoi occhi (diciamo 20 cm), e poi dovrebbero adattarsi nuovamente per concentrarsi sulla strada da percorrere (~2/5 metri). Il tempo necessario per l'intera operazione è tempo prezioso che dovrebbe essere speso guardando la strada e l'adattamento frequente potrebbe essere scomodo per l'utente dopo pochi minuti.

Ecco perché ho deciso di aggiungere una lente tra lo schermo e il riflettore. Questa lente, se scelta con attenzione, dovrebbe consentire la creazione di un'immagine virtuale dello schermo (vedi schema sopra), che sembrerebbe poi essere più lontana dagli occhi dell'utente così com'è in realtà, richiedendo quindi adattamenti meno bruschi (o nessuno, in uno scenario perfetto). Questo design consente all'utente di dare una rapida occhiata al riflettore, ottenere le informazioni di cui ha bisogno e guardare immediatamente la strada.

Il ruolo dello smartphone

Poiché non era realistico provare a implementare un'intera applicazione di navigazione solo su ESP32, ho deciso di creare un'app Android che si occupasse di questo. L'app dovrebbe quindi solo dire all'ESP32 cosa deve fare l'utente per raggiungere la sua destinazione e l'ESP32 trasmette tali informazioni tramite l'HUD (vedere la figura "Come funziona il modulo").

Passaggio 2: parti - il cervello: microcontrollore e schermo

Come detto sopra, avevo pianificato che il mio modulo mostrasse le informazioni di navigazione, senza che calcolasse effettivamente il posizionamento, il tracciamento e la navigazione in tempo reale. il telefono dell'utente, invece, comunicherà con il modulo e gli invierà le informazioni per poi essere visualizzate sull'HUD.

Per facilitare la comunicazione tra il telefono dell'utente e il modulo, ho scelto di utilizzare una scheda basata su ESP32 per questo progetto. Questa scelta è dovuta a questo modulo specifico con funzionalità Bluetooth integrate, oltre ad alcune altre specifiche interessanti (archiviazione non volatile facile da usare, CPU dual-core, RAM sufficiente per pilotare effettivamente il display OLED tramite I2C, …). È relativamente semplice progettare PCB basati su ESP32, che ho preso in considerazione. Ho anche esperienza professionale nell'utilizzo e nella progettazione di circuiti con l'ESP32, che ha sicuramente influenzato la mia scelta.

La scelta dello schermo fondamentalmente si è ridotta a tutto ciò che potevo trovare che sarebbe stato abbastanza luminoso per l'uso, pur essendo il più piccolo possibile. Non ero molto preoccupato per il numero di pixel dello schermo, poiché il mio obiettivo era avere un'interfaccia utente molto minimalista e semplice.

Va notato che il driver dello schermo dovrebbe essere supportato da una libreria che consenta il mirroring delle immagini. Questo perché l'immagine visualizzata viene capovolta quando passa attraverso l'obiettivo e appare sul riflettore, e non dover invertire manualmente ciò che viene visualizzato è un enorme peso sulle nostre spalle come costruttori.

Fase 3: Parti - Ottica: trovare un compromesso

L'ottica per questo progetto era piuttosto difficile da affrontare, poiché non avevo idea di cosa stessi cercando quando ho iniziato questo progetto. Dopo alcune ricerche, ho capito che quello che volevo fare era creare una "immagine virtuale" del mio schermo OLED, che apparisse più lontana dall'occhio di quanto non sia in realtà. La distanza ideale per la formazione di questa immagine virtuale sarebbe di circa 2-5 metri davanti al guidatore, una questa sembra essere la distanza dagli oggetti su cui ci concentriamo durante la guida (altre auto, dossi sulla strada, ecc…).

Per raggiungere questo obiettivo, ho scelto di utilizzare una lente di Fresnel, poiché sono abbastanza grandi, economiche, sembravano offrire una distanza focale abbastanza buona per il mio progetto e possono essere tagliate con delle semplici forbici (cosa che non accade per lenti in vetro tondeggianti più raffinate). Le lenti di Fresnel possono essere trovate con nomi come "lente d'ingrandimento tascabile" o "lente d'ingrandimento per carte da lettura", poiché sono molto appropriate per aiutare le persone con problemi di vista a leggere.

Fondamentalmente, il trucco qui era trovare il giusto compromesso tra:

- Avere una ragionevole distanza dell'immagine virtuale (ovvero, quanto lontano sembrerà essere l'HUD all'utente o quanto l'utente dovrà regolare gli occhi per vedere cosa c'è sull'HUD)

- Avere il testo sullo schermo non troppo ingrandito dall'obiettivo (che è fondamentalmente una lente d'ingrandimento)

- Avere una distanza ragionevole tra lo schermo OLED e l'obiettivo, che altrimenti porterebbe a un modulo molto ingombrante

Ho personalmente ordinato alcuni obiettivi diversi su amazon e ho determinato le rispettive lunghezze focali, prima di sceglierne uno con una lunghezza F di circa 13 cm. Ho scoperto che questa lunghezza F, con una distanza dell'obiettivo OLED di 9 cm, mi ha dato un'immagine soddisfacente sul mio riflettore (vedi le ultime immagini sopra).

Come vedrai nelle mie illustrazioni, per mettere a fuoco correttamente il testo visualizzato, la fotocamera utilizzata per scattare queste foto deve regolarsi come se stesse mettendo a fuoco un oggetto lontano, il che rende sfocato tutto sullo stesso piano del riflettore. Questo è esattamente ciò che vogliamo per il nostro HUD.

Puoi trovare i file 3D per il supporto dell'obiettivo qui.

Passaggio 4: parti: un contenitore per contenerle tutte

Mentre scrivo questo Instructables, il contenitore effettivo che conterrà ogni parte del display heads-up non è del tutto progettato. Tuttavia ho alcune idee sulla sua forma generale e su come affrontare alcuni problemi (come come tenere fermo un riflettore e farlo resistere a venti di oltre 100 km/h). Questo è ancora un lavoro in corso.

Passaggio 5: creazione di un protocollo per il nostro modulo

Per poter inviare le istruzioni di navigazione dal telefono alla scheda di sviluppo, ho dovuto escogitare un mio protocollo di comunicazione che mi permettesse di inviare facilmente i dati richiesti dal telefono, facilitandone anche l'elaborazione una volta ricevuti.

Al momento della stesura di questo Instructables, le informazioni che dovevano essere trasmesse dal telefono per navigare con il modulo erano:

- Il tipo di manovra imminente (svolta semplice, rotatoria, immettersi in un'altra strada, …)

- Le istruzioni precise della manovra successiva (dipende dal tipo di manovra: destra/sinistra per una svolta; quale uscita prendere per una rotonda, …)

- La distanza rimanente prima della manovra imminente (in metri per ora)

Ho deciso di organizzare questi dati utilizzando la seguente struttura di frame:

:istruzioni.tipo, distanza;

Pur non essendo una bella soluzione, questa ci consente di separare e distinguere facilmente ogni campo del nostro protocollo, il che ha facilitato la codifica sul lato ESP32.

È importante tenere presente che, per funzionalità future, potrebbe essere necessario aggiungere altre informazioni a questo protocollo (come il giorno e l'ora esatti o la musica in riproduzione sul telefono dell'utente), che sarebbe facilmente realizzabile utilizzando lo stesso logica costruttiva come adesso.

Passaggio 6: il codice: lato ESP32

Il codice per ESP32 è attualmente abbastanza semplice. Utilizza la libreria U8g2lib, che consente un facile controllo dello schermo OLED (mentre abilita il mirroring dell'immagine visualizzata).

Fondamentalmente, tutto ciò che ESP32 fa è ricevere dati seriali tramite Bluetooth quando l'app li invia, analizzarli e visualizzare questi dati o immagini in base a questi dati (ad esempio visualizzando una freccia invece della frase "gira a sinistra/destra"). Ecco il codice:

/*Programma per controllare un HUD da un'app Android tramite bluetooth seriale*/#include "BluetoothSerial.h" //File di intestazione per Bluetooth seriale, verrà aggiunto per impostazione predefinita in Arduino#include #include #ifdef U8X8_HAVE_HW_SPI#include #endif# ifdef U8X8_HAVE_HW_I2C#include #endif//Costruttore di librerie OLED, deve essere modificato in base al tuo schermoU8G2_SSD1306_128X64_ALT0_F_HW_I2C u8g2(U8G2_MIRROR, /* reset=*/ U8X8_PIN_NONE); // Macchina a stati valori_campo rilevato + variabile#definire campo manovra 1#definire campo istruzioni 2#definire campodistanza 3#definire endOfFrame 4int campo_rilevato = endOfFrame;BluetoothSerial serialBT; // Oggetto per Bluetoothchar incoming_char;char manovra[10];char istruzioni[10];char distanza[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;frase completa booleana = false;void setup() { Serial.begin(9600); // Avvia il monitor seriale a 9600 baud u8g2.begin(); // Init controllo OLED serialBT.begin("ESP32_BT"); // Nome del ritardo del segnale Bluetooth (20); Serial.println("Il dispositivo Bluetooth è pronto per l'accoppiamento");}void loop() { if (serialBT.available() && !fullsentence) // Caratteri ricevuti tramite Bluetooth serial { incoming_char = serialBT.read(); Serial.print("Ricevuto:"); Serial.println(incoming_char); } switch (campo_rilevato) { case manovraField: Serial.println("Campo rilevato: manovra"); if (incoming_char == '.') // Campo successivo rilevato { campo_rilevato = campo istruzioni; } else { // Riempi l'array di informazioni sul tipo di manovra manovra[nbr_char_maneuver] = incoming_char; nbr_char_manovra++; } rottura; case instructionsField: Serial.println("Campo rilevato: istruzioni"); if (incoming_char == ', ') // Rilevato campo successivo { detect_field = distanceField; } else { // Compila l'array di istruzioni info instructions[nbr_char_instructions] = incoming_char; nbr_char_instructions ++; } rottura; case distanceField: Serial.println("Campo rilevato: distanza"); if (incoming_char == ';') // Fine del frame rilevata { detect_field = endOfFrame; Serial.print("manovra:"); Serial.println(manovra); Serial.print("istruzioni:"); Serial.println(istruzioni); Serial.print("distanza:"); Serial.println(distanza); frase intera = vero; update_Display(); // Full frame ricevuto, analizzalo e visualizza i dati del ricevitore } else { // Riempi l'array di informazioni sulla distanza distance[nbr_char_distance] = incoming_char; nbr_char_distance ++; } rottura; case endOfFrame: if (incoming_char == ':') rilevato_campo = manovraField; // Nuovo frame rilevato interruzione; default: // Non fare nulla; } delay(20);}void update_Display(){ // Memorizza nella cache ogni array di caratteri per evitare possibili conflitti memcpy(tempManeuver, manovra, nbr_char_maneuver); memcpy(tempInstructions, instructions, nbr_char_instructions); memcpy(tempDistance, distanza, nbr_char_distance); parseCache(); // Analizza ed elabora gli array di caratteri fullsentence = false; // Frase elaborata, pronta per la successiva}void parseCache(){ u8g2.clearBuffer(); // cancella la memoria interna u8g2.setFont(u8g2_font_ncenB10_tr); // scegli un carattere adatto // array di caratteri -> stringa obbligatoria per utilizzare la funzione substring() String manovString = tempManeuver; String instructionsString = tempInstructions; // Implementazione del protocollo qui. Supporta solo i turni per ora. if (maneuverString.substring(0, 4) == "turn") { // Verifica il tipo di manovra Serial.print("TURN DETECTED"); if (instructionsString.substring(0, 5) == "right") { // Controlla le istruzioni specifiche e visualizza di conseguenza u8g2.drawStr(5, 15, "-"); } else if (instructionsString.substring(0, 4) == "left") { // Controlla le istruzioni specifiche e visualizza di conseguenza u8g2.drawStr(5, 15, "<---"); } else u8g2.drawStr(5, 15, "Err."); // Campo istruzioni non valido } /* Implementa altri tipi di manovra (rotonde, ecc..) * else if (tempManeuver == "rdbt"){ * *] */ u8g2.drawStr(5, 30, tempDistance); // Visualizza la distanza rimanente u8g2.sendBuffer(); // trasferisce la memoria interna al display // ripristina tutti gli array di caratteri prima della lettura successiva memset(manovra, 0, 10); memset(istruzioni, 0, 10); memset(distanza, 0, 10); memset(tempManeuver, 0, 10); memset(tempInstructions, 0, 10); memset(tempDistance, 0, 10); // Reimposta il numero di elementi negli array nbr_char_distance = 0; nbr_char_instructions = 0; nbr_char_manovra = 0;}

Passaggio 7: il codice: lato Android

Per l'app per smartphone, ho deciso di utilizzare l'SDK di navigazione di Mapbox, in quanto offre molte funzioni utili quando si tratta di creare una mappa di navigazione da zero. Permette anche l'uso di molti ascoltatori utili, che sicuramente aiutano a far funzionare questo modulo. Ho anche usato la libreria seriale Android-Bluetooth di harry1453 per Android, poiché ha reso la comunicazione seriale Bluetooth molto più facile da mettere insieme.

Se vuoi creare questa app a casa, dovrai ottenere un token di accesso Mapbox, che è gratuito fino a un certo numero di richieste al mese. Dovrai inserire questo token nel codice e creare l'app dalla tua parte. Dovrai anche codificare l'indirizzo MAC Bluetooth del tuo ESP32.

Così com'è, l'app può guidarti dalla tua posizione attuale a qualsiasi posizione su cui puoi fare clic sulla mappa. Come menzionato nell'introduzione, tuttavia, non supporta altre manovre oltre alle virate e non gestisce ancora i fuori rotta.

Puoi trovare l'intero codice sorgente sul mio github.

Passaggio 8: cosa c'è dopo?

Ora che l'app è abbastanza funzionale da guidare effettivamente l'utente su un percorso prestabilito (se non ci sono deviazioni dal percorso impostato), il mio obiettivo principale sarà migliorare l'app per smartphone e implementare le poche funzionalità che renderebbero il modulo un valido dispositivo di navigazione. Ciò include l'abilitazione della comunicazione Bluetooth dal telefono anche quando lo schermo è spento, nonché il supporto per altri tipi di manovre (rotonde, unione, …). Implementerò anche una funzione di reindirizzamento se l'utente devia dal percorso originale.

Quando tutto questo sarà fatto, migliorerò il contenitore e il suo meccanismo di attacco, lo stamperò in 3D e proverò a prendere il modulo per una prima esecuzione.

Se tutto va bene, il mio obiettivo a lungo termine è progettare un PCB personalizzato per l'elettronica incorporata di questo progetto, risparmiando molto spazio sul prodotto finale.

Potrei anche aggiungere altre funzionalità a questo modulo in futuro, tra cui una visualizzazione dell'ora e un allarme di notifica del telefono, che potrebbe far apparire un'icona quando l'utente riceve un messaggio di testo o una chiamata. Infine, mi piacerebbe aggiungere le funzionalità di Spotify a questo modulo, in quanto grande fan della musica. Tuttavia, in questo momento, questo è solo un piacere da avere.

Passaggio 9: conclusione e ringraziamenti speciali

Come affermato nell'introduzione, sebbene questo progetto sia lungi dall'essere finito, volevo davvero condividerlo con il mondo, nella speranza che potesse ispirare qualcun altro. Volevo anche documentare la mia ricerca su questo argomento, poiché non c'è molto interesse da parte degli hobbisti per AR e HUD, il che penso sia un peccato.

Voglio ringraziare enormemente Awall99 e Danel Quintana, i cui rispettivi progetti di realtà aumentata mi hanno ispirato molto nella realizzazione di questo modulo.

Grazie a tutti per l'attenzione, non mancherò di pubblicare un aggiornamento quando questo progetto verrà migliorato nel prossimo futuro. Nel frattempo, ci vediamo più tardi!