Un Gmeter – F1

con Arduino

Introduzione

E’ un mix di passioni che mi ha portato a sviluppare questo progetto: motori ed elettronica. Da anni durante le riprese dei gran premi di Formula Uno è possibile vedere un riquadro che indica le accelerazioni longitudinali e trasversali della vettura. I valori sono da brivido, con punte oltre i 4g (quattro volte il nostro peso!) e ben lontani dall’esperienza di guida quotidiana. Quel “pallino” rosso che si sposta continuamente avanti e indietro ad ogni staccata o ripresa, a destra e sinistra ad ogni curva, è intrigante ed aumenta la percezione di cosa si viva a bordo della bolide.

Il progetto

Questo progetto vuole replicare a livello hobbistico e per fini didattici le principali funzioni del Gmeter impiegato in campo racing, impiegando materiale legato all’universo Arduino.

In particolare si perseguiranno i seguenti obiettivi:

• acquisizione delle accelerazioni longitudinali e trasversali del veicolo
• presentazione dei dati in tempo reale su piano cartesiano
• rappresentazione in tempo reale delle due componenti di accelerazione tramite barre verdi
• memorizzazione a video delle accelerazioni istantane tramite accensione di pixel bianchi che creano una “nuvola” di punti
• salvataggio delle misure su una scheda di memoria rimovibile per future analisi

 L’hardware

Il sistema è composto da quattro moduli principali: un sensore di accelerazione, una unità di acquisizione ed elaborazione, uno di visualizzazione e una di stoccaggio dei dati.

Il sensore

Una buona scelta è l’impiego dell’accelerometro modello ADXL345 della Analog Devices. E’ un sensore di tipo triassiale con uscite analogiche indipendenti per ogni canale di misura. E’ piccolo, leggero ed economico, qualità che ne aumentano l’appeal in questa applicazione.

Ha un range di +/-3g fondo scala, più che adeguato anche all’impiego su “vetture sportive”. Richiede una alimentazione di circa 3V, prelevata direttamente dal modulo Arduino. Occorre porre molta attenzione al fatto che il dispositivo non ha protezione, perciò in caso di sovra alimentazione si danneggia irremediabilmente.

L’accelerometro ha uscite proporzionali all’accelerazione lungo i tre assi, ivi inclusa quella terrestre. Ruotandolo quindi, le uscite varieranno di conseguenza, mentre appoggiato su di un piano parallelo al suolo, l’uscita Z darà un valore prossimo all’unità.

La caratteristica tipica indica una uscita pari a 1,5V ad accelerazione nulla ed una sensibilità di circa 300 mV/g. Per inciso, possiamo considerare 1g pari a 9,8m/s².

Il modulo è racchiuso in un piccolo contenitore LFCSP difficile da impiegare a livello hobbistico per le sue ridotte dimensioni e difficoltà di saldatura con mezzi domestici. Molto più conveniente è invece l’acquisto della breakout omonima della Sparkfun che in poco più di 3cm² di circuito stampato, rende disponibile facilmente tutti i segnali necessari.

Per funzionare correttamente nella nostra applicazione, la board deve essere installata circa parallela al suolo e vincolata in maniera rigida al veicolo. Se si intende mantenere la portabilità dell’esperimento si può fissare il piccolo stampato ad una massa di qualche chilogrammo (ad esempio un mattone) collocata nella parte bassa del mezzo.

Il modulo Arduino

La scelta più diretta e conveniente è l’impiego di un modulo Arduino Uno. E’ largamente diffuso, economico e molto, molto ben documentato. Uno dei vantaggi di questa versione è anche la sua elevata riusabilità per altri esperimenti e progetti, una volta “finito il diventimento” con questo. Nulla vieta ovviamente di studiare ed implementare il Gmetro su altre piattaforme arduiniche. La connessione coi dispositivi esterni è visibile sotto:

L’Arduino si collega sostanzialmente con:

• il modulo display e memory card
• l’accelerometro
• i pulsanti start/stop
• la batteria

I singoli pin dei moduli vengono connessi come indicato nella tabella seguente:

La comunicazione colle periferiche avviene tramite la Serial Peripheral Interface o SPI, che è un bus standard di comunicazione ideato dalla Motorola.

La trasmissione avviene tra un dispositivo principale detto master e uno o secondari detti slave (in questo caso il display e la scheda SD).

Il master controlla il bus, emette il segnale di clock, definisce quando iniziare e terminare la comunicazione.

Il bus SPI è quindi:

• di tipo seriale
• sincrono, per la presenza di un clock che coordina trasmissione e ricezione dei singoli bit, determinandone la velocità di trasmissione
• full-duplex, in quanto il colloquio fra i moduli può avvenire contemporaneamente in trasmissione e ricezione.

L’intero sistema è alimentato da due piccole batterie al litio da 3,7V nominali connesse in serie, per un totale di circa 7,5V. Questi accumulatori sono oggi facilmente disponibili nel campo della modellsitica, sono leggere, economiche e hanno grande capacità specifica.

Su ogni ingresso analogico vi è un condensatore da 1μF connesso verso massa che ha la funzione di limitare a circa 5Hz la banda passante dei segnali accelerometrici.

Il display e la memorizzazione

Per rappresentare in tempo reale i dati, ho impiegato il display a colori TFT da 1,7″, parte del corredo di Arduino e noto come Robot LCD.

Il modulo impiega lo schermo HTF0177SN-01 della Huanan Electronic Technology Co.,Ltd e include uno slot per schede micro SD.

L’lcd ha una diagonale di 1.77″ (45mm), una risoluzione di 160 x 128 pixel ed una profondità di colore variabile dai 5 agli 8 bit a seconda del canale. Per il suo controllo tramite Arduino è disponibile una specifica libreria che ne rende l’uso molto semplice e diretto.

Occorre prestare attenzione al fatto che nel tempo è stato sostituito il controller del TFT e le librerie non sono pienamente intercambiabili. La vecchia versione è conosciuta come “red tab” per via della linguetta rossa presente sulla pellicola protettiva del display. Questa versione funziona con la libreria TFT inclusa con la versione 1.0.x dell’IDE. La versione più moderna, riconoscibile invece dalla stessa linguetta ma di colore verde, funziona solo con quella abbinata alla versione 1.5.x (e superiori) dell’IDE Arduino.

Vediamo l’utilizzo dei suoi pin:

Il codice

Premetto che non sono certo un esperto programmatore e quindi il codice può sicuramente essere scritto in maniera migliore. Questo detto, concentriamoci quindi solo sul flusso delle operazioni sotto rappresentato:

1. primo blocco
   1. definisco i pin usati per gli ingressi analogici (sensori) e digitali (pulsanti) e quelli necessari alla comunicazione verso i vari dispositivi (TFT e SD).
   2. “allego” al codice le librerie per il display, la scheda SD e la comunicazione seriale
   3. definisco variabili e costanti, fra cui il fondo scala dello strumento (espresso in g).
2. secondo blocco
   1. inizializzo la comunicazione seriale (porta USB) a 57600baud (ma anche velocità inferiori possono andare bene)
   2. inizializzo la scheda SD, pronta ad essere scritta
   3. inizializzo il display, sfondo scuro e traccio anche due cerchi di misura concentrici di colore rosso, posti al 50 e 100% del fondo scala
3. ingresso nel loop continuo
4. verifico se il pulsante start è premuto
5. nel caso lo sia, si assumono le accelerazioni correnti come “punto zero” e si attiva il flag “run”
6. se lo Start non è premuto, verifico se lo è lo Stop
7. in caso affermativo, esco dal modo “run”
8. se nemmeno lo Stop è premuto, procedo a verificare se siamo in “run” o meno, cioè cioè se serve acquisire, salvare e mostrare dati oppure se si è in attesa di comandi
9. in caso positivo:
   1. acquisisco i segnali dall’accelerometro e ne sottraggo i valori di base prima acquisiti (alla pressione dello start). In questo modo ottengo “valori netti” di accelerazione
   2. salvo i valori di accelerazione sulla scheda SD, assieme al tempo relativo (per tempo relativo intendo quello trascorso dall’ultima pressione del pulsante start)
   3. aggiorno il display, disegnando le nuove striscie verdi proporzionali all’accelerazione sui due assi e ad accendo un pixel bianco alle coordinate equivalenti alle due accelerazioni
10. trasmetto sulla seriale una serie di variabili configurabili a piacere
11. attendo un centinaio i millisecondi e ritorno all’inizio del loop

Il codice completamente commentato, è disponbile al link (RKE.???..) ovviamente sotto licenza GPLv3.

Le prove

La mia realizzazione è come di consueto molto spartana. Il modulo TFT+SD è montato su una piccola millefori che supporta anche i due pulsanti di avvio e arresto delle misure.

Per convenienza il sensore accelerometrico è incollato su un di mattone pieno, appoggiato al fondo del veicolo, nel vano piedi del passeggero.

Prima di partire a misurare, è necessario dare coerenza ai sistemi di coordinate di sensore e schermo, orientando il primo opportunamente. Con lo schema ed il codice prima visto, l’asse X è quello delle accelerazioni laterali.

Pronti? Via!

All’accensione il modulo si inizializza fino a presentare due cerchi concentrici rossi sullo schermo che rappresentano il 50 e 100% del fondo scala di misura definito nelle prime righe del codice.

A titolo d’esempio posso suggerire come valori:

• bicicletta: 0,3g
• motocarro: 0,5g
• autovettura: 1g

Alla pressione del tasto start, l’unità comincia ad acquisire. Due barre verdi lungo gli assi si muoveranno secondo la seguente logica:

Frenata	Acceleraz ione
Svolta a sinistra	Svolta a destra

E’ ovviamente possibile che le accelerazioni siano “miste”, ad esempio:

Frenata in curva a sinistra	Accelerazione durante curva a destra

Ad ogni “giro del loop” viene anche acceso un pixel bianco le cui cordinate sono i valori delle accelerazioni lungo i due assi.

Dopo un breve percorso nel traffico, questa potrebbe essere l’aspetto dello schermo:

I dati acquisiti durante la marcia vengono salvati sulla scheda micro SD per eventuali analisi ed elaborazioni successive.

Conclusioni

Questo progetto è particolarmente interessante per la varietà di discipline che coinvolge e i differenti interessi che può riunire. La sua realizzazione è estremamente semplice, così come risulta una buona base per mille modifiche ed espansioni.

Ringraziamenti

Come sempre, desidero ricordare quanti mi hanno in vario modo aiutato. Primi e forse incosapevolmente i ragazzi del RaspiBo, che col loro contagioso entusiasmo mi hanno acceso la voglia di sperimentare. Complice di questo, il personale di Homotix che mi ha aiutato a recuperare in pochissimo tempo il materiale necessario. Un ringraziamento speciale va però dedicato a tutti coloro che continuamente condividono il loro sapere permettendo uno sviluppo continuo di nuove idee.

Bibliografia

http://www.homotix.it

http://arduino.cc/en/Reference/TFTLibrary

http://it.wikipedia.org/wiki/Serial_Peripheral_Interface

http://arduino.cc/en/Guide/TFTtoBoards

http://www.parallax.com/go/PBASICHelp/Content/LanguageTopics/Commands/LCDIN.htm

http://unorthodox-engineers.blogspot.it/2014/03/release-fritzing-design-files-for.html

https://www.sparkfun.com/products/11345

datasheet HTF0177SN-01