Leggi la tesina

Istituto Tecnino Industriale "Don Luigi Orione
a.s. 2014-2015
ESAME DI STATO
Classe 5°
Candidato
Tomassoni Geremia
Argomento scelto dal candidato
Prototipo di un'autovettura autonoma (CL4P-TP)
1
2
ABSTRACT
Una vera e propria rivoluzione sta per avvenire nel mondo dei trasporti.
L’avanguardia tecnologica dei tempi in cui viviamo sta modificando e modificherà sempre
più il modo di viaggiare spingendoci in un futuro vicino dove le macchine non
necessiteranno più di piloti umani. Partendo dal modello di automobile autonoma realizzato
da Google, il volere finale di questa tesina sperimentale è dimostrare che tutti possono
costruire la propria, piccola ‘Google car’, anche se usata per altri fini.
A real revolution is going to take place in the transport sector, the technological vanguard of
the times we live in is changing and will change more and more the way to travel pushing us
in a near future where cars will not need more than human pilots. Based on the model of
autonomous car designed by Google, the will of this final thesis is experimental to show that
everyone can build their own small ‘Google car’, even if used for other purposes.
3
Indice
1. Introduzione .......................................................................................................PAG. 6
1.1 Evoluzione degli autoveicoli .................................................................PAG. 6
1.2 Evoluzione dei sistemi di posizionamento ............................................PAG. 8
1.3 Cosa sta accadendo ................................................................................PAG. 9
2. Realizzazione di un sistema automatico .............................................................PAG. 11
2.1 Componenti utilizzati..............................................................................PAG. 11
2.2 Arduino...................................................................................................PAG. 12
2.2.1 Presentazione ...........................................................................PAG. 12
2.2.2 Hardware...................................................................................PAG. 13
2.2.3 Versioni ....................................................................................PAG. 14
2.2.4 Programmazione del microcontrollore......................................PAG. 16
2.2.5 Input e output.............................................................................PAG. 16
2.2.6 Ambiente di sviluppo.................................................................PAG. 18
2.3 HC-SR04..................................................................................................PAG. 19
2.3.1 Specifiche...................................................................................PAG. 20
2.3.2 Grafico onde...............................................................................PAG. 21
2.3.3 Collegamenti...............................................................................PAG. 24
4
2.4 GPS...........................................................................................................PAG. 25
2.4.1 Dati NMEA.................................................................................PAG. 26
2.4.2 Codice di funzionamento............................................................PAG. 27
2.5 Motori DC.................................................................................................PAG. 38
2.5.1 Codice.........................................................................................PAG. 39
2.6 Modulo SD................................................................................................PAG. 41
2.6.1 Codice..........................................................................................PAG. 42
3. Realizzazione telaio...............................................................................................PAG. 46
3.1 Stati della realizzazione.............................................................................PAG. 46
4. Conclusione............................................................................................................PAG. 53
4.1 Problematiche incontrate...........................................................................PAG. 53
5
Capitolo 1
Introduzione
1.1 Evoluzione degli autoveicoli
L'automobile nacque come mezzo di locomozione per sostituire l'animale e si affermò come
mezzo di trasporto solo nel XIX secolo. Già dal Rinascimento si progettarono modelli tali,
ma restarono solo su carta, prototipi come il Carro di Cugnot, carro con motore a vapore,
furono costruiti solo verso la fine del XVII secolo. I sistemi di alimentazione dei motori
cambiarono molto ed il motore endotermico e la benzina furono introdotti solo dopo la
prima guerra mondiale, nonostante ciò si cercavano e si cercano ancora alimentazioni
alternative alla benzina ed eco sostenibili.
Il Carro di Cugnot è la prima dimostrazione pratica della possibilità di trasporto senza
trazione animale, anche se, quando fu azionata procedette lentamente solo per una dozzina
di minuti con una punta di velocità massima stimata inferiore ai 10km/h. Il primo prototipo
costruito possedeva molte problematiche che si aggiungevano alla lentezza del mezzo, come
per esempio la lentezza di sterzata e la difficoltà nel fermarlo e infatti si distrusse contro un
muro. Invece il secondo prototipo raggiunse gli obiettivi sperati e attualmente è conservato
al “Conservatoire National des Arts et Métiers” a Parigi. Il carro di Cugnot fu un prototipo
fondamentale per il progresso in questo campo, ma ancora non era una valida alternativa
alla trazione animale. La svolta si ebbe grazie a modelli introdotti da imprenditori come per
esempio Carl Benz.
Un altro passo molto importante si ebbe nel 1876 grazie a Nikolaus August Otto, inventore
del primo motore a combustione interna a quattro tempi. Nel 1886 fu Carl Benz a costruire
il primo veicolo con motore endotermico.
Al giorno d'oggi sono in commercio svariati tipi di carburanti, alcuni fossili, derivati dal
petrolio come la benzina e il diesel, altri allo stato gassoso come il metano e il GPL; da
qualche anno sono state sviluppate automobili con motore elettrico che utilizzano come
6
"carburante" energia elettrica racchiusa dentro delle batterie ricaricabili o all'interno di
"serbatoi". La maggioranza dei veicoli con motore elettrico sono ibridi perchè possiedono
anche un motore a combustione interna combinato con quello elettrico, ultimamente sono
state progettate e costruite auto con solo il motore elettrico.
Nella seconda metà del XX secolo, un ingegnere statunitense, Stanley Meyer, progetto un
sistema di combustione ad acqua, che secondo i suoi studi richiedeva una minore quantità di
requisiti previsti dalla scienza tradizionale per compiere l'elettrolisi. Meyer esibì questo
motore montandolo su di una dune buggy e stimò un consumo di circa 83 litri per una
distanza di 4500 km. Nel 1996 Meyer fu citato in tribunale, il suo veicolo sarebbe dovuto
essere esaminato da Micheal Laughton in qualità di perito, tuttavia quel test non si svolse.
La sua "pila a combustione ad acqua" fu in seguito esaminata da altri tre periti nominati dal
tribunale che giudicarono il progetto di Meyer dicendo che non c'era niente di rivoluzionario,
che sfruttava l'elettrolisi convenzionale. Il tribunale lo ritenne colpevole di "una grossolana
frode", e dovette rimborsare tutti i suoi investitori per la somma di $25000. Stanley Meyer
morì improvvisamente il 20 marzo del 1998 dopo una cena al ristorante. Durante la cena
incontrò due investitori di nazionalità belga e Meyer corse improvvisamente fuori urlando:
"mi hanno avvelenato!". Dall'autopsia, i medici riscontrarono che soffriva di ipertensione e
morì di aneurisma cerebrale. I suoi sostenitori affermano che fu assassinato per sopprimere
le sue scoperte.
7
1.2 Evoluzione dei sistemi di posizionamento
I sistemi di posizionamento nascono con l'esigenza di sapere la propria posizione nel globo.
Questa è una problematica che l'uomo ha da molto tempo, prima della nascita dei sistemi
moderni, ovvero sin da quando l'uomo inizio ad esplorare e viaggiare. In passato venivano
usati vari metodi, per esempio nell'antichità, l'uomo si spostava lungo le rive di fiumi che
oltre ad una posizione approssimata offriva anche la possibilità di aver acqua corrente.
Quando l'uomo iniziò a navigare, inizialmente navigò attorno le coste per evitare di perdersi,
ma quando iniziò ad inoltrarsi in mare aperto, una delle problematiche maggiori era stabilire
(anche se in linea di massima) la propria posizione, sia per ritrovare luoghi già visitati, sia
per evitare ostacoli già segnalati in precedenza. Storicamente, uno dei primi metodi con cui
l'uomo iniziò a navigare in mare aperto, fu attraverso gli astri, come la stella Polare, fu
Talete di Mileto (634-548 a.C. circa), a lasciare la prima traccia storica dell'utilizzo di
questa stella, anche se non si esclude che non sia stato il primo a farne uso. Il popolo arabo
fu uno dei primi ad utilizzare uno strumento che faceva riferimento alla stella Polare, il
Kalam. Questo strumento era costituito da una tavoletta legata a una sagola a nodi, a ogni
nodo corrispondeva la latitudine di un porto conosciuto. Si usava prendendo fra i denti il
nodo corrispondente al punto di arrivo e, stendendo il braccio, si portava la tavoletta in linea
con l’orizzonte, se la stella Polare era più alta o più bassa del bordo superiore della tavoletta
voleva dire che ci si trovava a una latitudine più a sud o più a nord di quella del porto di
arrivo. Ci si trovava invece alla latitudine voluta quando la stella si adagiava sul bordo
superiore della tavoletta. Questo sistema non permetteva una precisione superiore alle 25
miglia. Prima che il navigatore europeo utilizzi sistemi di posizionamento bisognerà
aspettare gli anni sessanta del 1400, gli storici stimano che il primo strumento utilizzato fu
la balestriglia, che ha un funzionamento molto simile al Kalam, ma è composta da un’asta
graduata munita di due o tre tavolette scorrevoli. Invece alcuni storici credono che il primo
strumento utlizzato dagli europei fu il quadrante, il quale era formato da un quarto di
cerchio graduato, con a lato un mirino per inquadrare la stella Polare e per determinare
l'angolo era munito di un piccolo peso in piombo. Questo strumento fu largamente utilizzato
8
durante le scoperte della seconda metà del '400 e inizio '500, anche da personaggi come
Cristoforo Colombo, che lo adoperò durante il suo viaggio per le indie.
In seguito fu utilizzato l'astrolabio, di gran lunga molto più preciso, ma dalla sua forma
doveva essere per forza attaccato ad un'asta, ad in mare non restituiva dati molto precisi, per
cui i marinai più diligenti, quando si fermavano in porto lo utilizzavano di nuovo per poi
confrontare i dati ed avere una misura senz'altro giusta. Un altro strumento impiegato per il
calcolo della latitudine è il sestante, che venne ampiamente utilizzato fino all'introduzione di
sistemi moderni quali, Transit, o il più moderno GPS.
Per poter avere la propria posizione con precisione, si necessita di due coordinate: latitudine
e longitudine. Rispetto alla latitudine (che fu molto più semplice trovarla grazie ai metodi
elencati sopra), la longitudine fu più difficoltoso calcolarla, basti pensare che il parlamento
inglese nel 1714 offrì una ricompensa di 26.000 sterline (attuali 10 Milioni di Euro) a chi
avesse risolto il problema.
Spinti dalla ricompensa molti scienziati studiarono nuovi e precisi metodi per la
determinazione di essa, questo portò un grande sviluppo in molte materie, la più privilegiata
fu l'astronomia. Fu un orologiaio inglese, John Harrison, ha trovare il metodo opportuno
per il calcolo della longitudine. Egli utilizzò un orologio fisso sull'orario inglese,
precisamente di Greenwich, preso come punto fisso. Per perfezionare la sua scoperta ci mise
più di quaranta anni e i suoi seguaci la continuarono, fino ad arrivare ai moderni sistemi di
geolocalizzazione.
1.3 Cosa sta accadendo
Al giorno d'oggi, ci sono sempre più tecnologie rivolte al miglioramento del trasporto sia
pubblico che privato. La tecnologia detta "driverless" (ovvero senza conducente), è una di
queste. Attualmente è utilizzata nelle metropolitane di varie città e capitali mondiali come
Copenaghen, Hong Kong, Lille, Parigi, Torino, è stata testata anche a Roma, nella metro C
(il treno si è fermato quattro stazioni prima del capolinea). La tecnologia driverless è stata
attuata per concedere servizi efficenti e puntuali per incentivare la popolazione ad utilizzare
i mezzi pubblici anzi che quelli privati su gomma. Al tempo stesso permette un sostanzioso
9
risparmio delle risorse da parte delle aziende. Oltre alla riduzione dei costi di gestione,
escludendo la cabina del conducente, la tecnologia driverless consente di aumentare il carico
gli spazi disponibili per gli utilizzatori del servizio. Ma la vera innovazione è proposta da
Google, con la sua "Google car", auto con movimento autonomo dotate di speciali
componenti che permettono al veicolo di spostarsi su strada. Google car è equipaggiata con
un apparato del valore di 150000 dollari, di cui solo 70000 solo il LIDAR (Light Detection
and Ranging), strumento essenziale per lo spostamento su strada, perchè è grazie al LIDAR
che il sistema riesce a creare una mappatura tridimensionale dell'ambiente circostante, il
resto dell'apparato è formato da sensori ultrasuono, fotocamere stereo grazie al quale si
riesce ad acquisire immagini molto più vicine alla visione ottica di un umano piuttosto che
ad una comune fotocamera, una multitudine di laser, GPS, radar, per avere un'immagine di
essa a 360°. Grazie a questo vasto equipaggiamento hardware, il software riesce ad eviare
ostacoli, come persone, oggetti, altre macchine e anche i ciclisti, rispetta le leggi della strada
come semafori o stop, e grazie al GPS con mappe sempre aggiornate riesce ad individuare
lavori stradali per una guida migliore e più sicura.
Questo veicolo presenta ancora delle limitazioni, è stata testata maggiormente in California,
e risulta poco adatta alla vita frenetica delle strade di grandi città e la sua velocità massima è
di 45 km/h (28 mph). Google però, ha investito molto sulla parte della sicurezza, non solo
per le persone dentro l'abitacolo ma anche per l'esterno, in caso di collisioni per esempio
con pedoni o ciclisti; sono stati installati degli air bag speciali anche all'esterno che in caso
di scoppio non scaraventa il malcapitato a 10 m di distanza ma ne assorbe la forma, ed è
anche dotata di un parabrezza leggermente flessibile che ha la funzione, insieme all'air bag
esterno, di attutire lo schianto.
10
Capitolo 2
Realizzazione di un sistema automatico
2.1 Componenti utilizzati
Per lo sviluppo di questo progetto sono stati utilizzati svariati componenti, per un valore
totale che si aggira su un paio di centinaia di euro.
Componenti:
 Arduino Uno: verrà utilizzato per il funzionamento dei motori e del modulo
ultrasuoni;
 arduino Nano: verrà utilizzato per il funzionamento del GPS e scheda SD;
 seeed studio Motor Shield V2: verrà utilizzato per il funzionamento dei motori ;
 sensore ultrasuoni HC SR04: verrà utilizzato per visualizzare possibili ostacoli di
fonte al veicolo;
 DC motor + ruote: verranno utilizzate per lo spostamento;
 adafruit Ultimate GPS: è il modulo GPS che stampa i dati NMEA;
 SD card data logger: è il modulo che servirà per permettere all'arduino di scrivere i
dati NMEA del GPS su una scheda SD;
 breadboard: verrà utilizzata per fare piccoli collegamenti all'interno del veicolo;
 una ruota sferica: verrà utilizzata come appoggio anteriore, per permettere al veicolo
di sterzare liberamente;
 scatola in pvc per collegamenti elettrici: sarà il telaio, il corpo del progetto;
11
 adattatore uFL to SMA e antenna: per permettere che il segnale GPS sia registrabile
anche dall'interno di un edifico;
 saldatore a stagno, sega circolare, smerigliatrice angolare: strumenti necessari.
2.2 Arduino UNO
2.2.1 Presentazione
Arduino è una scheda elettronica di piccole dimensioni, con un microcontrollore e
circuiteria di contorno, utile per creare rapidamente prototipi oppure usarlo per scopi
hobbistici e didattici.
Con Arduino si possono realizzare in maniera relativamente rapida e semplice piccoli
dispositivi come controllori di luci, di velocità per motori, sensori di luce, temperatura e
umidità e molti altri progetti che utilizzano sensori,e comunicazione con altri dispositivi. È
fornito di un semplice ambiente di sviluppo integrato per la programmazione. Tutto
il software a corredo è libero, e gli schemi circuitali sono distribuiti come hardware libero.
2.2.2 Hardware
Arduino comprende una piattaforma hardware per il phycal computing sviluppata presso
l'Interaction Design Institute, un istituto di formazione post-dottorale con sede a Ivrea,
fondato da Olivetti e Telecom Italia.
Questa si basa su un circuito stampato che integra un microcontrollore con pin connessi alle
porte I/O, un regolatore di tensione e quando necessario un'interfaccia USB che permette la
comunicazione con il computer. A questo hardware viene affiancato un ambiente di
sviluppo
integrato (IDE) multipiattaforma (per Linux, Apple
Macintosh e Windows).
12
Questo software permette anche ai novizi di scrivere programmi con un linguaggio semplice
e intuitivo derivato da C e C++ chiamato Wiring, liberamente scaricabile e modificabile. I
programmi in Arduino vengono chiamati sketch.
Arduino può essere utilizzato per lo sviluppo di oggetti interattivi stand-alone e può anche
interagire, tramite collegamento, con software residenti su computer, come Adobe
Flash, Processing, Max/MSP, Pure Data, Supercollider, Vvvv.
La piattaforma hardware Arduino è spesso distribuita agli hobbisti in versione preassemblata, acquistabile in internet o in negozi specializzati. La particolarità del progetto è
che le informazioni sull'hardware, e soprattutto i progetti, sono disponibili per chiunque: si
tratta quindi di un hardware open source, distribuito nei termini della licenza Creative
Commons Attribution-ShareAlike 2.5. In questo modo, chi lo desidera può legalmente autocostruirsi un clone di Arduino o derivarne una versione modificata, scaricando
gratuitamente lo schema elettrico e l'elenco dei componenti elettronici necessari. Questa
possibilità ha consentito lo sviluppo di prodotti Arduino compatibili da parte di piccole e
medie aziende in tutto il mondo: è quindi divenuto possibile scegliere tra un'enorme quantità
di schede Arduino-compatibili. Ciò che accomuna questi prodotti inerenti elettronica
sperimentale e sviluppo è il codice sorgente per l'ambiente di sviluppo integrato e
la libreria residente che sono resi disponibili, e concessi in uso, secondo i termini legali di
una licenza libera, GPLv2.
Grazie alla base software comune ideata dai creatori del progetto, per la comunità Arduino è
stato possibile sviluppare programmi per connettere, a questo hardware, più o meno
qualsiasi
oggetto
elettronico,
computer, sensori, display o attuatori.
Dopo
anni
di
sperimentazione, è oggi possibile fruire di un database di informazioni vastissimo.
Il team di Arduino è composto da Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca
Martino, e David Mellis. Il progetto prese avvio in Italia a Ivrea nel 2005, con lo scopo di
rendere disponibile, a progetti di Interaction design realizzati da studenti, un dispositivo per
il controllo che fosse più economico rispetto ai sistemi di prototipazione allora disponibili. I
progettisti riuscirono a creare una piattaforma di semplice utilizzo ma che, al tempo stesso,
permetteva una significativa riduzione dei costi rispetto ad altri prodotti disponibili sul
13
mercato. A ottobre 2008, in tutto il mondo erano già stati venduti più di 50.000 esemplari di
Arduino.
Dopo la nomina ad amministratore delegato di Intel, Brian Krzanich farà produrre schede
Arduino dotate di processore Intel.
2.2.3 Versioni
L'hardware originale Arduino è interamente realizzato in Italia dalla Smart Projects, mentre
i cloni della scheda possono essere realizzati da chiunque in qualsiasi parte del mondo.
Una scheda Arduino tipica consiste in un microcontrollore a 8-bit AVR prodotto dalla
Atmel, con l'aggiunta di componenti complementari per facilitarne l'incorporazione in altri
circuiti. In queste schede sono usati chip della seriemegaAVR - nello specifico i modelli
ATmega8, ATmega168, ATmega328, ATmega1280 e ATmega2560.
Molte schede includono un regolatore lineare di tensione a 5 volt e un oscillatore a
cristallo a 16 MHz, sebbene alcune implementazioni, come ad esempio la piccola LilyPad,
abbiano un clock di 8 MHz e facciano a meno dello stabilizzatore di tensione.
Fino a oggi, sono state commercializzate 14 versioni dell'hardware Arduino:
1. Serial Arduino, programmata con una porta seriale DB9. Fa uso del microcontroller
ATmega8;
2. Arduino Extreme, con interfaccia di programmazione USB, facente uso del chip
ATmega8;
3. Arduino Mini, una versione in miniatura facente uso di un ATmega168 a montaggio
superficiale;
14
4. Arduino Nano, una versione ancor più piccola della Mini, utilizzante lo stesso
controller ATmega168 SMD e alimentata tramite USB;
5. LilyPad Arduino, un progetto minimalista (scheda circolare dal diametro di 50mm,
per circa 8mm di spessore), per applicazione su indumenti, con lo stesso ATmega168
in versione SMD;
6. Arduino NG, con un'interfaccia USB per programmare e usare un ATmega8;
7. Arduino NG plus, con interfaccia di programmazione USB, con un ATmega168;
8. Arduino BT, con interfaccia di programmazione Bluetooth e con un ATmega168;
9. Arduino Diecimila, con interfaccia di programmazione USB e con un ATmega168 in
un package DIL28;
10. Arduino Duemilanove, facente uso del chip Atmega168 (o Atmega328 nelle versioni
più recenti) e alimentata in corrente continua tramite USB, con commutazione
automatica tra le sorgenti di alimentazione;
11. Arduino Mega, che fa uso di un ATmega1280 a montaggio superficiale per I/O e
memoria addizionale;
12. Arduino Uno, evoluzione della Duemilanove con un differente chip, programmabile
e più economico, dedicato alla conversione USB-seriale;
13. Arduino Mega2560, che fa uso di un ATmega2560 ed è un'evoluzione dell'Arduino
Mega;
14. Arduino Due, che fa uso di un Atmel SAM3X8E ARM Cortex-M3 CPU;
15. Arduino Zero Pro, dotata di un microcontrollore Atmel SAMD21 basato su core
ARM Cortex M0+ a 32 bit.
2.2.4 Programmazione del microcontrollore
15
In alcuni casi il microcontrollore della scheda è pre-programmato con un bootloader che
semplifica il caricamento dei programmi sulla memoria flash incorporata nel chip.
A livello concettuale, tutte le schede sono programmate attraverso una porta seriale RS-232,
ma il modo in cui questa funzionalità è implementata nell'hardware, varia da versione a
versione. Le schede seriali Arduino contengono un semplice circuito inverter che permette
la conversione tra il livello della RS-232 e il livello dei segnali TTL.
Le versioni attuali di Arduino sono gestite via USB: la versione Uno utilizza
un microcontrollore Atmega8U2 programmato come convertitore USB-seriale, mentre le
precedenti versioni Diecimila e Duemilanove usavano chip adattatori USB-seriale, come gli
FT232 di FTDI. Alcune varianti, come la Arduino Mini e la versione non
ufficiale Boarduino, usano una scheda o un cavo adattatore USB-seriale staccabile.
2.2.5 Input e output
Per implementare il comportamento interattivo, Arduino è fornita di funzionalità
di input/output (I/O), grazie alle quali essa riceve i segnali raccolti da sensori esterni. Il
comportamento della scheda è gestito dal microcontroller in base ai valori provenienti dai
sensori e alle decisioni determinate dal particolare programma in esecuzione in quel
momento sulla scheda. L'interazione con l'esterno avviene attraverso attuatori pilotati dal
programma per mezzo dei canali di output in dotazione. A tale scopo, Arduino è dotata di
molti dei connettori di input/output per microcontroller in uso su altri circuiti. Tutti i pin di
I/O sono collocati sulla parte superiore della scheda mediante connettori femmina da 0,1".
Inoltre sono disponibili commercialmente molte schede applicative plug-in, note come
"shields".
Le schede Barebones e Boarduino, due cloni compatibili con la Arduino, sono dotate di
connettori maschio sul lato inferiore del circuito in modo da poter essere connesse a
una breadboard senza necessità di effettuare saldature.
16
La Arduino Uno, ad esempio, che ha soppiantato la Duemilanove, offre 14 connettori per
l'I/O digitale (numerati da 0 a 13). La direzione di funzionamento, input o output, è decisa
dallo sketch programmato sull'IDE.
Sei dei canali I/O possono produrre segnale Pulse-width modulation (PWM). Attraverso i
segnali PWM è possibile, ad esempio, regolare l'intensità di luminosità di un LED o la
velocità di rotazione di un motorino elettrico. L'hardware di tre dei pin di I/O (9, 10 e 11)
implementa la possibilità di gestirli direttamente attraverso la funzione analogWrite(), che
permette di controllare la PWM del segnale in uscita in maniera efficiente, senza dover
eseguire linee di codice appositamente predisposte. La funzione accetta due parametri, il
primo dei quali è il pin pilotato mentre il secondo rappresenta l'intensità della modulazione
(espressa su una scala da 0 a 255): così, ad esempio, analogWrite(9, 128) attiverà un led
collegato al pin 9 al 50% della sua luminosità.
Sempre sulla Uno, sono presenti altri 6 connettori specificamente dedicati a ingressi
di segnali analogici (collegati quindi ad una ADC), cioè valori di tensione letti
da sensori esterni i cui valori, fino a un massimo di 5 Volt, sono convertiti in 1024 livelli
discreti (da 0 a 1023). Questi 6 connettori possono essere riprogrammati (sempre
dal codice dello sketch sull'IDE) per funzionare come normali entrate/uscite digitali.
L'alimentazione della scheda può avvenire attraverso la porta USB del computer, o
attraverso la maggior parte degli alimentatori USB, oppure attraverso un adattatore in
corrente continua a 9 volt, con connettore cilindrico (diametro 2,1 mm e positivo centrale).
In quest'ultimo caso, la scheda commuta automaticamente sull'alimentazione esterna quando
il connettore dell'alimentatore esterno è inserito, mentre commuta autonomamente
sull'alimentazione USB in caso di disconnessione del connettore. La Arduino-NG e la
Arduino Diecimila, versioni meno recenti, necessitano di essere commutate a mano,
azionando uno switch ubicato tra la porta USB e l'ingresso dell'alimentazione esterna.
2.2.6 Ambiente di sviluppo
17
L'ambiente di sviluppo integrato (IDE) di Arduino è un'applicazione multipiattaforma scritta
in Java, ed è derivata dall'IDE creato per il linguaggio di programmazione Processing e per
il progetto Wiring. È concepita per iniziare alla programmazione artisti e altri neofiti, che
siano a digiuno di pratica nello sviluppo di software. Per permettere la stesura del codice
sorgente, l'IDE include un editore di testo dotato inoltre di alcune particolarità, come il
sintax highlighting, il controllo delle parentesi, e l'indentazione automatica. L'editor è
inoltre in grado di compilare e lanciare il programma eseguibile in una sola passata e con un
solo click. In genere non vi è bisogno di creare dei Makefile o far girare programmi
dalla riga di comando.
Insieme con l'IDE vengono scaricati vari sketch di esempio, per introdurre l'utente alla
programmazione della macchina; le tematiche sono molto basiche, come ad esempio gestire
gli ingressi analogici e digitali, far accendere un led in modo pulsante e variabile; si possono
però anche affrontare problemi più complessi come la gestione di un display LCD o di una
scheda telefonica GSM. Oltre alle varie librerie già incorporate (più di una decina), l'utente
può aggiungerne di nuove con uno strumento di importazione compreso nell'IDE. Per
vedere i risultati di uno sketch è attivabile dall'IDE una finestra seriale di monitoring, sulla
quale far comparire l'output di istruzioni Serial.print(parametro) incorporate nello sketch
stesso.
18
Figura 1: Arduino Rev 3.
2.3 HC-SR04
19
L'HC-SR04 è un sensore ultrasuoni con performance stabili, accurate ed è molto popolare
tra gli hobbisti e progettisti. Rapportandolo con lo Shap IR ranging module, è molto meno
costoso ed è anche più preciso.
2.3.1 Specifiche
 E' alimentato con corrente continua a 5V e 2mA di corrente;
 ha un lobo di sensibilità minore di 15°;
 misura da I due centimetri fino ai cinque metri;
 gli impulsi sono inviati ad una frequenza di 40k Hz;
 ha una risoluzione di 1 cm.
Figura 2: dimensioni e raggio di
propagazione ultrasuoni sensore HC-SR04.
20
Figura 3: sensore HC-SR04.
2.3.2 Grafico onde
All'attimo zero viene trasmesso un breve impulso che riflette contro l'oggetto, quando il
sensore riceve l'eco del segnale lo converte in segnale elettrico, l'impulo dopo viene
trasmesso quando il primo eco si spegne. Questo periodo di tempo è chiamato ”periodo di
ciclo”. Il periodo di ciclo è raccomandabile di mantenerlo a non meno di 50 ms. Se un
impulso del trigger con una larghezza di10μs viene inviato al pin del segnale, il modulo
ultrasuoni emette otto segnali ultrasonici a 40kHz e rileva l'eco di ritorno. La distanza
misurata è proporzionale alla larghezza di impulso di eco e può essere calcolata con la
formula di cui sopra. Se non viene rilevato nessun ostacolo, il pin di uscita darà un segnale
di 38ms di alto livello.
21
Figuta 4: grafico onde HC-SR04.
Sotto è riportato un semplice esempio di sketch Arduino per il funzionamento del sensore
HC-SR04.
Prima del Void Setup, vengono settati gli ingressi alla board, in questo caso il Trigger è
connesso al pin 9 dell'Arduino, mentre l'Echo al pin 8.
Nel Void Setup viene dichiarato se le componenti inserite hanno un valore in INPUT o in
OUTPUT.
Figura 5: semplice sketch per l'esecuzione funzionale del sensore HC-SR04.
22
Con queste poche righe di codice, questo sensore è in grado di dirci a quanti centimetri di
distanza si trova l'ostacolo. E' il pin Trigger che manda l'impulso che poi rimbalza
sul'ostacolo e viene recepito dal pin Echo.
23
2.3.3 Collegamenti
Figura 6 e 7: Collegamento tra l'Arduino UNO Rev 3 ed il sensore ultrasuoni HC-SR04,
come dichiarato nel codice.
24
2.4 GPS
Il modulo GPS che viene utilizzato in questo progetto è prodotto dall'Adafruit e nonostante
le piccole dimensioni possiede specifiche che nel suo genere pochi hanno:

-165 dBm sensitivity, 10 Hz updates, 66 channels

5V friendly design and only 20mA current draw

Breadboard friendly + two mounting holes

RTC battery-compatible

Built-in datalogging

PPS output on fix

Internal patch antenna + u.FL connector for external active antenna

Fix status LED
Questo modulo è costruito con a base un MTK3339 chipset, e come già detto qui sopra, è un
GPS di alta qualità in quanto può tracciare 22 satelliti su 66 canali differenti, un’alta
sensibilità e un’antenna incorporata, ma volendo lo si può equipaggiare con un’antenna
aggiuntiva tramite un adattatore uFL/SMA.
Il modulo GPS verrà così collegato all'Arduino Nano:
 TX: pin 3 Arduino Nano;
 RX: pin 2 Arduino Nano;
 GND: pin GND (massa) Arduino Nano;
 VIN: pin 5V Arduino Nano;
25
2.4.1 Dati NMEA
In Output il GPS restituisce sempre dati NMEA, che si differenziano in vari tipi di dati.
I dati NMEA sono caratterizzati dal prefisso “$GP”, seguito dal nome del dato che è diverso
in base alle informazioni che restituisce, per esempio "$GPRMC" (Recommended minimum
specific GPS/Transit data), indica informazioni come l'ora, la data, la latitudine, la
longitudine e i nodi (velocità). Ora è presentata la scomposizione delle varie stringhe
NMEA:
Stringa $GPRMC:
$GPRMC,194509.000,A,4042.6142,N,07400.4168,W,2.03,221.11,160412,,,A*77
 194509.000: la prima parte della stringa restituisce l'orario UTC (al meridiano di
Greenwich), perciò al momento dell'acquisizione del dato erano le 19:45':09" e i
restanti decimali caratterizzano i millesimi di secondo che in questo caso sono 0;
 A: questo dato è molto importante perché caratterizza lo stato del GPS, A sta per
"Active" cioè il segnale è presente e la qualità è maggiore a 3 (se la qualità del
segnale è minore di 3, il dato è segnato invalido). In caso di malfunzionamento al
posto della lettera a ci troveremo la lettera "V" Void (Figura 8);
 4042.6142,N: rappresenta il dato latitudinale corrispondente a 40 gradi e 42.6142
minuti decimali posizione Nord;
 07400.4168,W: rappresenta il dato longitudinale corrispondente a 74 gradi e 0.4168
minuti decimali posizione Ovest;
 2.03: corrisponde ai nodi ovvero alla velocità registrata in quel momento;
 221.11: corrisponde all'angolo di rilevamento che stabilisce approssimativamente la
direzione in base ai dati precedentemente raccolti;
 160412: corrisponde alla data in cui è stato registrato il dato ovvero il 16 Aprile 2012;
26
 A*77: quest'ultima parte è chiamata "Checksum" e caratterizza la fine della stringa
dati;
Stringa $PGTOP:
$PGTOP,11,x
 x: indica lo stato dell'antenna, se la x corrisponde a 3 si sta usando un'antenna esterna;
se è 2 si sta utilizzando l'antenna interna; se è 1 c'è un problema all'antenna.
2.4.2 Codice funzionamento
Per il funzionamento del modulo GPS è stato utilizzato un codice d'esempio compilato dalla
casa produttrice del modulo che ha creato anche la libreria, l'Adafruit. Il codice è qui di
seguito presentato:
// Test code for Adafruit GPS modules using MTK3329/MTK3339 driver
//
// This code shows how to listen to the GPS module in an interrupt
// which allows the program to have more 'freedom' - just parse
// when a new NMEA sentence is available! Then access data when
// desired.
//
// Tested and works great with the Adafruit Ultimate GPS module
// using MTK33x9 chipset
// ------> http://www.adafruit.com/products/746
// Pick one up today at the Adafruit electronics shop
27
// and help support open source hardware & software! -ada
#include <Adafruit_GPS.h>
#include <SoftwareSerial.h>
// If you're using a GPS module:
// Connect the GPS Power pin to 5V
// Connect the GPS Ground pin to ground
// If using software serial (sketch example default):
// Connect the GPS TX (transmit) pin to Digital 3
// Connect the GPS RX (receive) pin to Digital 2
// If using hardware serial (e.g. Arduino Mega):
// Connect the GPS TX (transmit) pin to Arduino RX1, RX2 or RX3
// Connect the GPS RX (receive) pin to matching TX1, TX2 or TX3
// If you're using the Adafruit GPS shield, change
// SoftwareSerial mySerial(3, 2); -> SoftwareSerial mySerial(8, 7);
// and make sure the switch is set to SoftSerial
// If using software serial, keep this line enabled
// (you can change the pin numbers to match your wiring):
SoftwareSerial mySerial(3, 2);
28
// If using hardware serial (e.g. Arduino Mega), comment out the
// above SoftwareSerial line, and enable this line instead
// (you can change the Serial number to match your wiring):
//HardwareSerial mySerial = Serial1;
Adafruit_GPS GPS(&mySerial);
// Set GPSECHO to 'false' to turn off echoing the GPS data to the Serial console
// Set to 'true' if you want to debug and listen to the raw GPS sentences.
#define GPSECHO true
// this keeps track of whether we're using the interrupt
// off by default!
boolean usingInterrupt = false;
void useInterrupt(boolean); // Func prototype keeps Arduino 0023 happy
void setup()
{
29
// connect at 115200 so we can read the GPS fast enough and echo without dropping chars
// also spit it out
Serial.begin(115200);
Serial.println("Adafruit GPS library basic test!");
// 9600 NMEA is the default baud rate for Adafruit MTK GPS's- some use 4800
GPS.begin(9600);
// uncomment this line to turn on RMC (recommended minimum) and GGA (fix data)
including altitude
GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCGGA);
// uncomment this line to turn on only the "minimum recommended" data
//GPS.sendCommand(PMTK_SET_NMEA_OUTPUT_RMCONLY);
// For parsing data, we don't suggest using anything but either RMC only or RMC+GGA
since
// the parser doesn't care about other sentences at this time
// Set the update rate
GPS.sendCommand(PMTK_SET_NMEA_UPDATE_1HZ); // 1 Hz update rate
// For the parsing code to work nicely and have time to sort thru the data, and
// print it out we don't suggest using anything higher than 1 Hz
30
// Request updates on antenna status, comment out to keep quiet
GPS.sendCommand(PGCMD_ANTENNA);
// the nice thing about this code is you can have a timer0 interrupt go off
// every 1 millisecond, and read data from the GPS for you. that makes the
// loop code a heck of a lot easier!
useInterrupt(true);
delay(1000);
// Ask for firmware version
mySerial.println(PMTK_Q_RELEASE);
}
// Interrupt is called once a millisecond, looks for any new GPS data, and stores it
SIGNAL(TIMER0_COMPA_vect) {
char c = GPS.read();
// if you want to debug, this is a good time to do it!
#ifdef UDR0
if (GPSECHO)
if (c) UDR0 = c;
31
// writing direct to UDR0 is much much faster than Serial.print
// but only one character can be written at a time.
#endif
}
void useInterrupt(boolean v) {
if (v) {
// Timer0 is already used for millis() - we'll just interrupt somewhere
// in the middle and call the "Compare A" function above
OCR0A = 0xAF;
TIMSK0 |= _BV(OCIE0A);
usingInterrupt = true;
} else {
// do not call the interrupt function COMPA anymore
TIMSK0 &= ~_BV(OCIE0A);
usingInterrupt = false;
}
}
uint32_t timer = millis();
void loop()
// run over and over again
{
32
// in case you are not using the interrupt above, you'll
// need to 'hand query' the GPS, not suggested :(
if (! usingInterrupt) {
// read data from the GPS in the 'main loop'
char c = GPS.read();
// if you want to debug, this is a good time to do it!
if (GPSECHO)
if (c) Serial.print(c);
}
// if a sentence is received, we can check the checksum, parse it...
if (GPS.newNMEAreceived()) {
// a tricky thing here is if we print the NMEA sentence, or data
// we end up not listening and catching other sentences!
// so be very wary if using OUTPUT_ALLDATA and trytng to print out data
//Serial.println(GPS.lastNMEA()); // this also sets the newNMEAreceived() flag to false
if (!GPS.parse(GPS.lastNMEA())) // this also sets the newNMEAreceived() flag to false
return; // we can fail to parse a sentence in which case we should just wait for another
}
// if millis() or timer wraps around, we'll just reset it
33
if (timer > millis()) timer = millis();
// approximately every 2 seconds or so, print out the current stats
if (millis() - timer > 2000) {
timer = millis(); // reset the timer
Serial.print("\nTime: ");
Serial.print(GPS.hour, DEC); Serial.print(':');
Serial.print(GPS.minute, DEC); Serial.print(':');
Serial.print(GPS.seconds, DEC); Serial.print('.');
Serial.println(GPS.milliseconds);
Serial.print("Date: ");
Serial.print(GPS.day, DEC); Serial.print('/');
Serial.print(GPS.month, DEC); Serial.print("/20");
Serial.println(GPS.year, DEC);
Serial.print("Fix: "); Serial.print((int)GPS.fix);
Serial.print(" quality: "); Serial.println((int)GPS.fixquality);
if (GPS.fix) {
Serial.print("Location: ");
Serial.print(GPS.latitude, 4); Serial.print(GPS.lat);
Serial.print(", ");
Serial.print(GPS.longitude, 4); Serial.println(GPS.lon);
34
Serial.print("Location (in degrees, works with Google Maps): ");
Serial.print(GPS.latitudeDegrees, 4);
Serial.print(", ");
Serial.println(GPS.longitudeDegrees, 4);
Serial.print("Speed (knots): "); Serial.println(GPS.speed);
Serial.print("Angle: "); Serial.println(GPS.angle);
Serial.print("Altitude: "); Serial.println(GPS.altitude);
Serial.print("Satellites: "); Serial.println((int)GPS.satellites);
}
}
}
35
Figura 8: output NMEA con "fix" e "quality" minori di 3, in campo navale, vengono
considerati non veritieri.
36
Figura 9: output corretto in base al codice caricato nel micro processore.
37
2.5 Motori DC
Il motore a corrente continua (o DC, Direct Current in inglese), è stato il primo motore
elettrico realizzato, è tutt'ora largamente utilizzato per grandi o piccole potenze. Molto
ricorrente è l'uso domestico di questa tecnologia per piccole potenze.
Il primo motore DC è stato realizzato nel 1821 da Michael Faraday e consisteva in un filo
conduttore tenuto fermo verticalmente alla sua estremità superiore in modo che l'estremità
inferiore fosse immersa in un piatto contenente mercurio. Un magnete permanente circolare
era sistemato al centro del piatto. Quando una corrente elettrica veniva fatta scorrere nel filo,
questo ruotava attorno al magnete mostrando che la corrente generava un campo
magnetico attorno al filo.
In questo progetto sono stati utilizzati due motori a corrente continua applicati a dei riduttori
per "ruotare il movimento" di 90°. I motori scelti sono frequentemente utilizzati per questo
genere di progetti e sono facilmente reperibili sul web.
In questo progetto, i motori verranno collegati negli appositi morsetti del motor shield, il
destro MOTOR A e il sinistro MOTOR B.
38
Figura 10: Motore utilizzato nel progetto.
2.5.1 Codice
#include "MotorDriver.h"
void setup()
{
/*Configure the motor A to control the wheel at the left side.*/
/*Configure the motor B to control the wheel at the right side.*/
motordriver.init();
motordriver.setSpeed(200,MOTORB);
motordriver.setSpeed(200,MOTORA);
}
39
void loop()
{
motordriver.goForward();
delay(2000);
motordriver.stop();
delay(1000);
motordriver.goBackward();
delay(2000);
motordriver.stop();
delay(1000);
motordriver.goLeft();
delay(2000);
motordriver.stop();
delay(1000);
motordriver.goRight();
delay(2000);
motordriver.stop();
delay(1000);
}
40
2.6 Modulo SD
Per salvare i log dei dati NMEA del GPS, è stato utilizzato un modulo SD. Per il
funzionamento si è dovuto formattare la scheda SD in FAT16.
Il modulo utilizzato è quello rappresentato in figura:
Figura 11: Modulo SD Arduino.
Il modulo verrà così collegato:
 MISO: pin 12 Arduino Nano;
 SCK: pin 13 Arduino Nano;
 MOSI: pin 11 Arduino Nano;
 SDCS: pin 4 Arduino Nano;
 3.3V: pin 3.3V Arduino Nano;
 GND: pin GND (massa) Arduino Nano.
41
2.6.1 Codice
Il codice che si andrà ad utilizzare permette di scrivere e leggere sulla scheda SD, per questo
progetto verrà utilizzata solo la parte di scrittura:
#include <SPI.h>
#include <SD.h>
File myFile;
void setup()
{
// Open serial communications and wait for port to open:
Serial.begin(9600);
while (!Serial) {
; // wait for serial port to connect. Needed for Leonardo only
}
Serial.print("Initializing SD card...");
// On the Ethernet Shield, CS is pin 4. It's set as an output by default.
// Note that even if it's not used as the CS pin, the hardware SS pin
// (10 on most Arduino boards, 53 on the Mega) must be left as an output
42
// or the SD library functions will not work.
pinMode(10, OUTPUT);
if (!SD.begin(4)) {
Serial.println("initialization failed!");
return;
}
Serial.println("initialization done.");
// open the file. note that only one file can be open at a time,
// so you have to close this one before opening another.
myFile = SD.open("test.txt", FILE_WRITE);
// if the file opened okay, write to it:
if (myFile) {
Serial.print("Writing to test.txt...");
myFile.println("testing 1, 2, 3.");
// close the file:
myFile.close();
Serial.println("done.");
} else {
// if the file didn't open, print an error:
43
Serial.println("error opening test.txt");
}
// re-open the file for reading:
myFile = SD.open("test.txt");
if (myFile) {
Serial.println("test.txt:");
// read from the file until there's nothing else in it:
while (myFile.available()) {
Serial.write(myFile.read());
}
// close the file:
myFile.close();
} else {
// if the file didn't open, print an error:
Serial.println("error opening test.txt");
}
}
void loop()
{
44
// nothing happens after setup
}
45
Capitolo 3
Realizzazione del telaio
3.1 Stati della realizzazione
Come già detto, la realizzazione del telaio è stata la parte del progetto che ha portato
maggiori problematiche a causa di problemi per esempio come la convergenza delle ruote.
Sostanzialmente il telaio ha avuto quattro versioni, la seconda e la terza molto simili tra di
loro, ma la seconda porta alcune minimali migliorie.
La prima versione del telaio è stata realizzata con l'ausilio di una confezione di CD, il telaio
è stato realizzato in classe, tramite delle fascette sono stati fissati i motori e anche la "ruota"
anteriore (Figura 12).
Figura 12: primo telaio
46
A differenza della prima versione, la seconda è molto meno rudimentale ed è stata creata
tramite un asse di legno 120x170x7, tagliata a sega circolare e poi rinifinita a mano con
della carta vetrata P120. Per fissare i motori è stato forato l'asse e immesse viti a testa piatta
sia per estetica, sia per comodità. Inizialmente alle viti sono state unite due alette in
alluminio e fermate con dei dadi. Questo primo progetto è stato scartato subito perché
stretto il bullone, il motore “scivolava” fuori visto la forza di esso sulle alette. Le alette sono
state realizzate, come già detto, da una staffa di alluminio tagliata a mano con l'ausilio di
una smerigliatrice angolare (Figura 13).
Figura 13: realizzazione alette
Subito scartato questo stratagemma di bloccaggio ruote, è stato realizzato un altro sistema. I
motori sono stati fissati al telaio tramite una staffa di alluminio tagliata alle estremità per
permettere che entrassero "dentro" le ruote evitando di toccarle (Figura 14).
47
Figura 14: realizzazione secondo sistema di blocco.
Qui sotto è rappresentato la seconda versione del telaio (figura 15):
Figura 15: secondo telaio.
48
La seconda staffa avvitata sulla prima, serve per rendere piatta la superficie ove verrà
sistemata la breadboard.
Come già detto, tra questa versione e la successiva non ci sono molti cambiamenti, per
tentare di tenere il linea le ruote con il telaio sono stati applicati dei piccoli angolari e delle
barre di ferro forate, è stato aggiunto un interruttore per l'accensione dell'arduino,
un'ulteriore staffa di alluminio posta nella parte posteriore per bloccare le ruote.
Sfortunatamente non sono state realizzate foto complete del terzo telaio, ma è stata scattata
una foto rappresentante la sua carcassa(Figura 16):
Figura 16: carcassa terzo modello del telaio.
L'ultimo telaio invece, quello definitivo, è stato realizzato sfruttando una scatola per
collegamenti elettrici, che poi è stata forata per poterci fissare al suo interno i motori e
all'esterno le ruote, all'esterno sul coperchio è stato fissato Arduino uno con il motor shield,
mentre all'interno del coperchio è stato fissato Arduino nano e la breadboard con inseriti
GPS e modulo SD (figura 17).
49
Figura 17: collegamenti sul coperchio.
Nella parte frontale sono stati effettuati dei fori da 16mm ed inserito il modulo HC-SR04,
come raffigurato nell'immagine sucessiva(Figura 18):
50
Figura 18:realizzazione fori sensore ultrasuoni.
Mentre nella parte posteriore della scatola sono stati apllicati due fori per l'iserimento
dell'antenna GPS e dell'interruttore START & STOP, come in figura sottostante(Figura 19):
Figura 19: lato posteriore.
Per le ruote anteriori per ora sono state sostituiti da dei ritagli circolari in legno, fissate alla
scatola de due viti, la circonferenza esterna è stata ricoperta de un taglio di camera d'aria per
biciclette per simulare il copertone. Con questo metodo il veicolo non riesce a sterzare, si
sta cercando un altro stratagemma (figura 20).
51
Figura 20: ruote.
52
Capitolo 4
Conclusioni
Alla fine dei questo progetto si è appurato che effettivamente il futuro dei mezzi di trasporto
autonomi è sempre più vicino.
4.1 Problematiche incontrate
Durante lo svolgimento di questo progetto si è dovuto, molto spesso, cambiare strategia e
metodi d'approccio a causa di tutte le problematiche riscontrate. Una delle più grandi
problematiche è stata la reperibilità del materiale e i lunghi tempi di consegna, le ruote sono
arrivate a circa un mese dell'ordine e questo ha bloccato in modo significativo l'andamento
del progetto. Un grave problema s'è riscontrato a causa del modulo SD e GPS, perché
avendo applicato uno shield per il funzionamento dei motori all'Arduino UNO, i pin restanti
non bastavano per l'utilizzo del restante, così si è dovuto acquistare un ulteriore Arduino,
l'Arduino Nano. Quest'ultimo Arduino è adibito esclusivamente al funzionamento del GPS e
della scheda SD. Ulteriori problematiche sono state incontrate durante la realizzazione del
telaio.
53