1

ISTITUTO PROFESSIONALE STATALE PER L’INDUSTRIA E L’ARTIGIANATO

“A. Castigliano” ASTI (AT)

TESI SPERIMENTALE PER L'ESAME DI STATO:

“Armuino” Braccio meccanico robotizzato controllato tramite joystick o con programmi preimpostati. Sviluppato con il sistema di sviluppo ARDUINO UNO. Svolta dal candidato:

Tagliabue Luca Classe: 5° F Indirizzo: Elettronica e Telecomunicazioni Anno scolastico: 2011/2012

2

Indice

1. Cos’è “ARMUINO”

1.1 I gradi di libertà

1.2 Progetto

1.3 Schema a blocchi del funzionamento di ARMUINO

1.4 Realizzare ARMUINO

1.4.1 Collegamenti elettrici

1.4.2 Schema elettrico

1.4.3 Come usare ARMUINO

1.4.4 Legenda tasti

2 Microcontrollore

2.1 struttura del microcontrollore

2.2 Schema a blocchi Arduino

2.3 Schema elettrico

2.4 Team di Arduino

2.5 Versioni

2.6 La programmazione del microcontroller

2.7 Pin di Arduino

2.8 Pin mapping ATmega 328

2.9 Funzionalità di input/output

2.10 Connettori I/O

2.11 I/O analogico

2.12 Alimentazione elettrica

2.13 La programmazione del microcontrollore

2.14 Open hardware e open source

3

2.15 Accessori hardware

2.15.1 La shield joystick 2.15.1.1 Come usare la shield 2.15.1.2 Come trovare la posizione corrente del joystick? 2.15.1.3 Come trovare la direzione corrente del joystick? 2.15.1.4 Come impostare Arduino in modo da sapere quando

un pulsante è stato premuto 2.15.1.5 Come sapere quando è stato premuto un pulsante

sullo scudo Joystick?

2.15.2 La shield “PROTO”

2.16 Librerie

2.16.1 libreria servo.h 2.16.1.1 istruzioni

3 Linguaggio di programmazione

4 I servomotori

4.1 Schema a Blocchi di un tipico Servo 4.2 Collegamento Elettrico di un Servo 4.3 Relazione Esistente tra Larghezza degli Impulsi e Rotazione

5 Modulazioni PWM

5.1 Cos’è il PWM

5.2 Quindi i servo con che segnale vengono comandati?

6 Sketch ARMUINO 1.0

6.1 Flow chart programma “ARMUINO 1.0”

7 Collaudo

8 Costo stimato Realizzazione HW

9 Conclusioni ed eventuali modifiche apportabili

10 Bibliografia

4

Cos’è “ARMUINO”

“ARMUINO” è un braccio robot basato su Arduino UNO.

La realizzazione di un braccio robot, anche di piccole dimensioni, come “Armuino” prevede

la conoscenza di più materie: elettronica, programmazione, meccanica, robotica e fisica.

Vorrei concentrarmi sulla parte di elettronica e programmazione, con qualche cenno sulla

parte meccanica.

Il braccio è costruito partendo da zero, e l‟unico componente meccanico già costruito che

ho comprato è la pinza (mano). Il telaio del braccio è in alluminio, legno e plexiglass per la

realizzazione della scatola. Il movimento viene effettuato grazie a dei servomotori

controllati con Arduino UNO. I servo sono collegati a dei piedini (pin) di Arduino tramite

proto shield appositamente realizzata. Viene alimentato da un alimentatore ATX da PC

500W in modo da avere prima di tutto l‟efficienza dello switching e secondo diverse

alimentazioni come per esempio +-12V, +-5V, 3.3V e un costo relativamente basso

rispetto ad altri alimentatori in grado di fornire una corrente di picco di 30A a 5V; infine sia

tensione che corrente sono molto costanti e per dei servomotori questa alimentazione è

perfetta. Può sembrare strano ma quando si usano 7 servomotori le correnti sono piuttosto

alte; ogni servo ha un assorbimento che varia in base alla coppia resistente e quindi dal

peso che deve muovere, ma in media assorbono circa 2A l‟uno. Bisogna tenere conto del

fatto che tutti i servo sono sempre in funzione anche se non in movimento, questo perché

il servo deve rimanere “attivo” in modo da tenere la posizione dell‟albero interno e

contrastare la forza del peso. Con i 5V possiamo alimentare il sistema di sviluppo. Il

braccio appoggia su una scatola di legno verniciato e la parte superiore in plexiglass

consente di vedere all‟interno. Nella parte anteriore c‟è il sistema di sviluppo, il cuore del

braccio, ed è visibile anche grazie a degli strip di led bianchi posti all‟interno della scatola

in modo da illuminare sia ARDUINO, sia il servo che permette il movimento rotatorio. Nella

parte posteriore invece è collocato l‟alimentatore ATX. Armuino si può comandare tramite

una shield joystick oppure scrivendo un programma specifico e automatico tramite l‟ IDE

Arduino nel linguaggio wiring.

5

I gradi di libertà

Per rendere più chiaro ciò che dirò ho segnato alcuni punti in modo da dare un nome a

ciascun movimento.

A: rotazione base.

Consente al braccio

di girare a destra e a

sinistra, il movimento

è attuato grazie ad un

servo collegato a un

ingranaggio che

morde

sull’ingranaggio

dell’albero al centro

della disco(base).

(servo power HD

1501 MG)

B: movimento spalla. Consente il movimento della spalla. È il punto che ha bisogno di

maggior coppia.per questo ho usato due servo identici in parallelo. (servo power HD 1501

MG)

C: movimento gomito. Consente il movimento del gomito tramite la rotazione di un

ingranaggio fissato sul servo e l’altro ingranaggio fissato sull’alberino del gomito e allo

stesso tempo sul telaio. (servo power HD 1501 MG)

D: movimento polso. Consente il movimento del polso (su e giù) grazie ad un servo

collegato direttamente al telaio del braccio.

E:rotazione polso. Consente la rotazione del polso di 180°, 90° a destra e 90° a sinistra.

F: pinza. Consente alla pinza di stringere e allargare le due estremità in modo da poter

afferrare e rilasciare un oggetto di piccole dimensioni.

G: contenitore. Al di sotto del pannello di plexiglass troviamo arduino e la shield proto con

i collegamenti dei servo

H: shield joystick. Da qui è possibile muovere il servo. Funziona da plancia dei comandi.

Al di sotto è collocato l’alimentatore ATX.

6

Progetto

Armuino è un progetto che parte da zero, senza aver mai costruito nulla di meccanico e

tanto meno robotizzato. All‟inizio del progetto il traguardo sembrava non arrivare mai, ogni

volta c‟era qualcosa da rifare o da modificare. Sapevo che sarebbe stato difficile,

soprattutto trovare i materiali giusti come per esempio i cuscinetti o altre parti meccaniche.

Bisognava poi capire come fare meccanicamente i vari movimenti, in certi casi la

trasmissione è tramite ingranaggi altre volte invece direttamente sulla squadretta del

servo, ma tutte queste decisioni vengono prese dopo averle provate entrambe. Questo

può andare bene se l‟attività è hobbistica perchè nell‟industria comporta perdite di tempo e

spreco di soldi. C‟è da ricordare che nell‟industria si lavora spesso in team e questo

permette di risolvere tanti problemi. I 2 movimenti più complicati sono sicuramente la

spalla e la rotazione del braccio. Il primo, la spalla, è difficile perché deve sollevare il peso

di tutto il braccio. Quindi serve maggior “coppia” e per ottenere un buon risultato ho deciso

di usarne 2 in parallelo. Il secondo, la rotazione della spalla, non sapevo come iniziarlo. Il

piatto del braccio deve appoggiare da qualche parte senza fare attrito in modo da

consentire la rotazione. Dopo diversi tentativi decido di usare le sfere portanti, ideali per

l‟applicazione.

Le sfere portanti sono usate anche come rotelle di alcuni mobili

e non sono difficili da trovare.

La parte del gomito è anch‟essa piuttosto difficile perché bisogna essere estremamente

precisi nel tagliare e bucare, per evitare che braccio e avambraccio risultino storti.

7

Ha un perno passante nei vari laminati di alluminio che

costituiscono il braccio e per rendere possibile la

rotazione del perno, quest‟ultimo è stato inserito nei

cuscinetti flangiati. Sono cuscinetti da modellismo,

dimensioni 0.8mmx0.5mmx2.5mm e grazie alla flangia

è possibile inserirli direttamente sul telaio senza dover

predisporre sedi apposite, così si riduce il peso e

soprattutto il lavoro, perché fare le sedi per dei

cuscinetti non è così semplice, occorre almeno un

tornio. Coi cuscinetti flangiati invece, basta una punta di

precisione e un buon trapano e il cuscinetto si inserirà perfettamente nel foro e una volta

che la flangia appoggia sul laminato sappiamo anche che il cuscinetto è in piano. Il perno

è realizzato con un tondino in alluminio facilmente reperibile nei fai da te con diametro

0.5mm che si inserisce perfettamente nei cuscinetti. Andrebbe meglio in materiali più

robusti dell‟alluminio come ad esempio acciaio ma non avendo trovato un tondino

d‟acciaio di quel diametro mi sono accontentato. Il braccio in fondo non deve alzare grossi

pesi, il perno è corto e quindi l‟alluminio non flette e va bene.

Schema a blocchi del funzionamento di ARMUINO

8

REALIZZARE “ARMUINO”

La realizzazione del braccio parte dalla costruzione del telaio; per realizzarlo ho comprato del normalissimo alluminio, quello che si trova nei fai da te, largo 30mm e spesso 3mm Vengono poi tagliati 2 segmenti lunghi 198mm per il braccio e 2 segmenti lunghi 135mm per l‟avambraccio. Con dei tubi di alluminio ho creato i distanziali, che servono a irrigidire il braccio e mantenere la distanza tra i due lati. Sono realizzati con segmenti di tubi di 2 lunghezze diverse per braccio e avambraccio: 40mm per l‟avambraccio e 45mm per il braccio, all‟interno dei tubi passa una barra filettata stretta all‟estremità dai bulloni autofilettanti. I distanziali sono appositamente messi a triangolo per le proprietà geometriche di questa figura. Questo rende braccio e avambraccio molto più solidi.

Nella prossima pagina vengono illustrati i vari componenti del telaio di Armuino. Le staffe

a “L” si trovano già fatte nei fai da te a pochi euro. I laminati sono largi 3cm, spessi 0.2mm.

Gli attrezzi che servono per la lavorazione sono un buon trapano (con delle buone punte

decimali) e un DREMEL per le fresature.

9

10

A questo punto abbiamo una struttura simile a questa e la parte più lunga è quella che va

fissata alla base, che è composta da un disco di alluminio con diametro 120 mm e

spessore 4 mm.

Il disco è stato realizzato con un tornio partendo da una base di forma quadrata, poi è

stato fresato fino ad ottenere un cerchio. Al centro del disco, nella parte inferiore c‟è il

perno che consente la rotazione, realizzato sempre in alluminio con un tondino diametro

10mm. al perno ho applicato un ingranaggio che viene fatto girare dall‟ingranaggio sul

servo. Il servo a sua volta è fissato sul fondo in legno della scatola del braccio. Sul

plexiglass ho fissato un cuscinetto per il perno e uno sulla base. Tra la parte in plexiglass

e il disco ci sono le sfere portanti. Queste creano 4 punti d‟appoggio mobili.

Quindi per collegare la parte del braccio alla base,cioè il disco, ho usato delle

comunissime staffe a “L”. Su di esse sono stati aperti due fori simmetrici in modo da poter

infilare la squadretta del servo e attaccarla al telaio del braccio.

11

A: foro per il passaggio della

squadretta del servo

B: squadretta del servo

C: telaio ARMUINO

Per quanto riguarda la pinza è di derivazione “FUTURA ELETTRONICA”, viene venduta in

kit e ha 2 servo che servono uno per la chiusura della pinza e l‟altro per la rotazione della

pinza. Inoltre nel modo in cui l‟ho montata si aggiunge un terzo movimento che rende

possibile muovere la pinza su e giù.

Come si può notare dalla foto la pinza è collegata meccanicamente al braccio tramite la

squadretta del servo, proprio come il collegamento tra la staffa a “L” e il braccio. La pinza

vera e propria in realtà non viene venduta con 3 servo ma solo 2. Quello che ho aggiustato

permette il movimento su e giù e per collegarlo ho attaccato i 2 servo con una barra

filettata piegata a “L”. Dalla foto sopra si può capire abbastanza bene. I servo sono fissati

con segmenti di barre filettate al telaio.

Tutti i servo usati sono standard sia come dimensioni e sia come rotazione, ruotano da 0°

a 180°. L‟unico accorgimento è quello di usare 2 servo identici per la spalla, in quanto

collegati in parallelo devo fare gli stessi identici movimenti.

12

Troviamo 2 tipi di servo:

POWER HD 1501 MG e HITEC HS-422.

POWER HD 1501 MG: Il servo analogico 1501MG della Power HD è caratterizzato da ottime performance di

potenza grazie anche all'utilizzo di ingranaggi in metallo e all'uso di cuscinetti a sfera che ne assicurano una lunga durata. Queste caratteristiche lo rendono l'attuatore perfetto per robot e modelli dinamici, pur rimanendo un prodotto dal prezzo contenuto. dimensioni: 40.7 x 39.5 x 20.5 mm

alimentazione: 4,8 - 6,0V coppia: 17.0 kg-cm velocità: 0.14 sec/60° peso: 60.0 g

HITEC HS-422

L'HS-422 e' un servo molto robusto costruito dalla HITEC. Utilizza due boccole in iron-oilite, ingranaggi in resina ad alta resistenza e circuiteria avanzata. L'HS-422 e' caratterizzato da una eccellente risoluzione e un centraggio preciso.

dimensioni: 41 x 20 x 37 mm peso: 45.5gr alimentazione: 4,8 - 6,0V coppia: 4.1 Kg cm velocità: 0.21 sec/60°

13

Per la costruzione della scatola ho tagliato il legno e il plexiglass nelle seguenti

forme e misure:

14

Poi viene fissato l‟alimentatore,Arduino e la shield. Nella parte posteriore della scatola del braccio viene fissato l‟alimentatore al piano di legno; poi si fissano le pareti della scatola e Arduino facendo un buco per la porta usb su una parete della scatola; la shield proto viene inserita sopra ad arduino.

Collegamenti elettrici

Adesso si possono fare i collegamenti. Il circuito elettrico è molto semplice, a parte i connettori dei servo e gli strip di led non bisogna saldare nulla. ho disegnato uno schema semplicissimo per mostrare i collegamenti.

Schema collegamenti elettronici

L‟unica cosa essenziale da ricordare è di collegare le masse di Arduino e dei servo in comune altrimenti il segnale di controllo non ha riferimento. Per il resto è semplice, i 7 servo sono collegati tutti allo stesso modo, tranne 2 che sono in parallelo. Gli strip di led sono alimentati con i 12V senza bisogno di mettere resistenze perché sono integrate. Le

15

shield, invece, vengono applicate a “panino” su Arduino (anche se il joystick non è sopra ad Arduino il collegamento è lo stesso)

Per ricavare l‟alimentazione ho creato, con tecnica a pennarello, un piccolo PCB con la presa ATX dove viene collegato l‟alimentatore e affianco gli strip femmina con le alimentazioni separate. sopra all‟alimentatore viene fissato un piano di plexiglass con già montata la shield joystick. Sulla shield proto sono stati saldati dei connettori a 3 pin per collegare i servo. I pin dei servo prendono alimentazione dall‟ ATX e il segnale di controllo da Arduino.

Arduino è alimentato con i 5V, gli strip di led sulle pareti interne con i 12V. fare i prolungamenti dei pin della shield joystick in modo da collegarli alla shield proto (le due shield sono separate quindi con dei cavetti sottili bisogna collegarle). I collegamenti sono finiti

Infine bisogna inserire il cuscinetto per il perno del disco sia sul plexiglass ,in mezzo alle sfere portanti, sia sul fondo di legno cercando di posizionarli in modo che il perno sia in asse e perpendicolare. Fatte queste operazioni rimane da posizionare il perno del braccio all‟interno dei cuscinetti ricordandosi di inserire tra il plexiglass e il legno l‟ ingranaggio. Quest‟ultimo viene fatto ruotare da un servo posizionato sul fondo in modo che gli ingranaggi combacino alla perfezione. Per rifinire i bordi della scatola ho usato un angolare di alluminio. Per concludere si può verniciare la scatola il plexiglass e, volendo, l‟alluminio del braccio.

16

Nella foto sottostante si può vedere l‟interno di Armuino. In altro a destra c‟è arduino e la proto con i vari collegamenti. Di fianco ad Arduino, il PCB che ho stampato per prelevare l‟alimentazione dall‟ATX. Sotto si può vedere il cuscinetto inferiore e il servo che fa ruotare gli ingranaggi. Sul bordo della scatola ci sono degli strip di led bianchi che illuminano l‟interno quando il braccio è montato.

Interno della scatola di Armuino

17

Come usare “ARMUINO”

Armuino è programmato per fare una serie di movimenti stabiliti da me in automatico, oppure posso muoverlo io stesso con il joystick. I 4 pulsanti sulla shield servono per selezionare rispettivamente i servo: gomito, rotazione polso, polso e pinza, mentre il pulsante sotto al joystick seleziona il tipo di programma, se viene premuto farà quello automatico, se non è premuto è sul manuale. I movimenti si possono regolare in base all‟utente, più o meno rapidi, cambiando un dato (l‟incremento) nello sketch.

legenda tasti

in questo momento Armuino ha come programma predefinito lo spostamento di un cubo di polistirolo. Questo inizia quando si preme il pulsante sotto al joystick.

18

MICROCONTROLLORE

struttura del microcontrollore ATMEL AVR AT MEGA 328

“ARDUINO”: cos'è e come funziona

Arduino è una piattaforma di prototipazione elettronica open-source che permette la prototipazione rapida e l'apprendimento veloce dei principi fondamentali dell'elettronica e della programmazione. È composto da una piattaforma hardware per il physical computing sviluppata presso l'Interaction Design Institute, un istituto di formazione post-dottorale con sede a Ivrea, fondato da Olivetti e Telecom Italia. Il nome della scheda deriva da quello di un bar di Ivrea (che richiama a sua volta il nome di Arduino d'Ivrea, primo Re d‟Italia nel1002) frequentato da alcuni dei fondatori del progetto.

19

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 (Linux, Apple Macintosh e Windows). 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.

La piattaforma hardware Arduino è spesso distribuita agli hobbisti in versione pre-assemblata, 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 desideri può legalmente auto-costruirsi 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, e infatti oggi è 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, sensore, display o attuatore. Dopo anni di sperimentazione è oggi possibile fruire di un database di informazioni vastissimo.

Schema a blocchi Arduino

il

physical computing:

il phisycal computing usa l’elettronica per prototipare nuovi materiali per designer e artisti. Il suo scopo è la progettazione di oggetti interattivi che possono comunicare con gli esseri umani usando sensori e attuatori controllati da un comportamento implementato in forma di software ed eseguito all’ interno di un microcontrollore.

20

Schema elettrico

21

Il team di ARDUINO

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 mercato. A ottobre 2008 in tutto il mondo erano già stati venduti più di 50.000 esemplari di Arduino.

L'hardware originale Arduino è interamente realizzato in Italia dalla Smart Projects, invece i cloni della scheda possono essere realizzati ovunque, come in Cina, Europa o Stati Uniti. Una scheda Arduino tipica consiste in un microcontroller 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 serie megaAVR - 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.

Versioni

Principali versioni di Arduino

1. Arduino Mini, una versione in miniatura facente uso di un ATmega168 a montaggio superficiale

2. Arduino Nano, una versione ancora più piccola della Mini, utilizzante lo stesso controller ATmega168 SMD e alimentata tramite USB

3. 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[5]

4. Arduino BT, con interfaccia di programmazione Bluetooth e con un ATmega168 5. Arduino Diecimila, con interfaccia di programmazione USB e con un ATmega168 in

un package DIL28 6. 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

7. Arduino Mega, che fa uso di un ATmega1280 a montaggio superficiale per I/O e memoria addizionale.

8. Arduino Uno, evoluzione della Duemilanove, con un differente chip, programmabile e più economico, dedicato alla conversione USB-seriale.

9. Arduino Mega2560, che fa uso di un ATmega2560 ed è un'evoluzione dell'Arduino Mega.

22

La programmazione del microcontroller

Inoltre, il microcontroller della scheda in alcuni case è 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 un 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: l'ultima versione, la 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.

Pin di arduino

23

Pin mapping ATmega 328

Funzionalità di input/output

Arduino è fornita di funzionalità di input/output (I/O), grazie alle quali essa riceve i segnali raccolti da sensori esterni. In base a tali valori, il comportamento della scheda è gestito dal microcontroller, in base alle decisioni determinate dal particolare programma in esecuzione in quel momento sulla scheda. L'interazione con l'esterno avviene attraverso attuatori pilotati dal programma attraverso i canali di output in dotazione.

Connettori I/O

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". 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 segnali 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

24

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à.

I/O analogico Sempre sulla Uno, sono presenti altri 6 connettori specificamente dedicati a ingressi di segnali analogici, 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.

Alimentazione elettrica

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 programmazione del microcontrollore

La programmazione può avvenire tramite il protocollo ISP e un'altra scheda Arduino utilizzata come programmatore, tramite la usb (in alcuni casi il microcontrollore contiene usb hardware) oppure grazie a un programmatore esterno dedicato. Software

IDE di Arduino

Screenshot dell'IDE di Arduino, che mostra un semplice codice di esempio.

25

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 a programmare, quindi ideale per chi si sta appassionando alla programmazione e ha bisogno di fare 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 syntax 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. L'ambiente di sviluppo integrato di Arduino è fornito di una libreria software C/C++ chiamata "Wiring" (dall'omonimo progetto Wiring): la disponibilità della libreria rende molto più semplice implementare via software le comuni operazioni di input/output. I programmi di Arduino sono scritti in C/C++, ma all'utilizzatore, per poter creare un file eseguibile, non è richiesto di scrivere un programma in C, ma solo di definire due funzioni:

setup() : funzione invocata una sola volta all'inizio di un programma che può essere utilizzata per i settaggi iniziali;

loop() : funzione invocata ripetutamente, la cui esecuzione si interrompe solo con lo spegnimento della scheda.

Esempi di codice

Un tipico esempio di programma per iniziare a far pratica con un microcontroller è quello, molto semplice, che permette l'accensione ripetuta di un LED. Nell'ambiente di sviluppo di Arduino, l'utilizzatore potrebbe farlo con un programmino come il seguente: #define LED_PIN 13 void setup () { pinMode (LED_PIN, OUTPUT); // abilita il pin 13 per l'output digitale } void loop () { digitalWrite (LED_PIN, HIGH); // accende il LED delay (1000); // aspetta 1 secondo (1000 millisecondi) digitalWrite (LED_PIN, LOW); // spegne il LED delay (1000); // aspetta un secondo }

Scritto in questo modo, il codice non verrebbe riconosciuto come programma valido da un compilatore C++; per questo motivo, quando l'utilizzatore seleziona il bottone di comando "Upload to I/O board" (presente nell'IDE), una copia del codice viene automaticamente trascritta in un file temporaneo con l'aggiunta di un extra include header all'inizio del codice e l'implementazione di una semplicissima funzione main() in basso: #include "WProgram.h" #define LED_PIN 13 void setup () { pinMode (LED_PIN, OUTPUT); // abilita il pin 13 per l'output digitale

26

} void loop () { digitalWrite (LED_PIN, HIGH); // accende il LED delay (1000); // aspetta 1 secondo (1000 millisecondi) digitalWrite (LED_PIN, LOW); // spegne il LED delay (1000); // aspetta 1 secondo } int main(void) { init(); setup(); for (;;) loop(); return 0; }

"WProgram.h" è lo header file principale per la libreria Wiring. La funzione main()effettua solo tre chiamate, init(), setup() e loop(); le ultime due sono definite dall'utente, mentre la prima è scritta nella libreria stessa. La funzione loop(), come richiesto, è automaticamente nidificata in un loop infinito. L‟ IDE di Arduino usa la GNU toolchain e la AVR Libc per compilare i programmi, mentre usa avrdude per caricarli sulla scheda.

Open hardware e open source

Gli schemi hardware di Arduino sono distribuiti in modo da poter essere utilizzati nei termini legali di una licenza Creative Commons Attribution Share-Alike 2.5, e sono disponibili sul sito ufficiale Arduino. Per alcune versioni della scheda sono disponibili anche il layout e i file di produzione. Il codice sorgente per l'ambiente di sviluppo integrato e la libreria residente sono invece disponibili, e concessi in uso, secondo i termini legali contenuti nella licenza GPLv2.

Accessori hardware

Una "shield" joystick montata su una scheda Arduino.

27

Sia la scheda originale, sia i cloni, fanno uso di shield, ovvero di espansioni alla Arduino base, realizzate con schede a circuito stampato che possono essere collocate al di sopra della Arduino, inserendosi nei connettori già normalmente presenti su Arduino. Esistono espansioni dedicate a varie funzioni, dal controllo motorio, al breadboarding (prototipizzazione).

La shield joystick

La shield joystick fornisce semplici ingressi analogici con quattro pulsanti separati e un pulsante sotto il joystick stessa. Il joystick può essere utilizzato per controllare le uscite come una melodia o pixel su uno schermo. I pulsanti possono essere utilizzati per la navigazione o controllo di gioco.

Come usare la shield

Una volta che la shield è assemblata, è possibile iniziare a usarla

Come trovare la posizione corrente del joystick?

La posizione del joystick è calcolata dai due potenziometri nel joystick. Il joystick può muoversi in due dimensioni che in genere rappresenterebbero coordinate x e Y, ma potrebbero rappresentare qualsiasi due quantità dimensionale. Per leggere i potenziometri si usa la funzione analogRead che restituisce un numero da 0 a 1023. Abbiamo bisogno di fornire 2 pin analogici per far funzionare il joystick. posizione x viene letta dal pin analogico 0 e la posizione y viene letta dal pin analogico 1. Con il pezzo di sketch seguente imposta costanti per i pin analogici 0 e 1 e stampa sulla console la posizione corrente di x e y.

Serial.println(analogRead(0)); // Prints current X position

Serial.println(analogRead(1)); // Prints current Y position

const byte PIN_ANALOG_X = 0;

const byte PIN_ANALOG_Y = 1;

void setup() {

Serial.begin(9600);

}

28

void loop() {

Serial.print("x:");

Serial.print(analogRead(PIN_ANALOG_X));

Serial.print(" ");

Serial.print("y:");

Serial.print(analogRead(PIN_ANALOG_Y));

Serial.print(" ");

Serial.println();

}

Come trovare la direzione corrente del joystick?

Può essere utile utilizzare il valore della posizione x e y per determinare se il joystick è centrato o spostato in una delle 8 direzioni (giù, su, destra, sinistra, sinistra giu, sinistra su, destra giù, destra su e centro). Poiché sappiamo che il valore in ogni dimensione sarà compreso tra 0 e 1023 si potrebbe aspettare il valore di centro a circa 511 o 512, ma siccome i joystick sono dispositivi fisici il valore effettivo è improbabile che sia la metà esatta. Se si sceglie il valore errato il joystick si potrebbe trovare in chissà quale posizione anche se è al centro. Per ovviare a questo problema abbiamo specificare due valori "soglia" e considerare che qualsiasi valore all'interno dell'intervallo deve essere considerata "centrato": |----------|----|----------|

0 505 515 1023

I valori di soglia che da scegliere possono essere differenti a seconda del proprio joystick. Specifichiamo i valori come costanti nel codice: const int X_THRESHOLD_LOW = 505;

const int X_THRESHOLD_HIGH = 515;

const int Y_THRESHOLD_LOW = 500;

const int Y_THRESHOLD_HIGH = 510;

Successivamente, vogliamo mappare il nostro valore in ogni dimensione da una gamma di posizione di 0-1023 su un valore di direzione nella gamma -1 a 1. Quindi X=-1 spostato a sinistra, 0 significa che non entra nella dimensione x e 1 significa spostato a destra. Se Y=-1 spostato giù, 0 non entra nella dimensione X e 1 spostato su.

29

Iniziamo impostando la direzione in ogni dimensione su 0 ("centrato") e poi usiamo if/else dichiarazioni per controllare se il valore di posizione in entrambe le dimensione è sopra o sotto i nostri valori di soglia: x_direction = 0;

y_direction = 0;

x_position = analogRead(PIN_ANALOG_X);

y_position = analogRead(PIN_ANALOG_Y);

if (x_position > X_THRESHOLD_HIGH) {

x_direction = 1;

} else if (x_position < X_THRESHOLD_LOW) {

x_direction = -1;

}

if (y_position > Y_THRESHOLD_HIGH) {

y_direction = 1;

} else if (y_position < Y_THRESHOLD_LOW) {

y_direction = -1;

}

Come si può vedere nel prossimo esempio completo usiamo istruzioni if/else per stampare la direzione. é possibile modificare questo esempio per eseguire qualsiasi azione è necessario: const byte PIN_ANALOG_X = 0;

const byte PIN_ANALOG_Y = 1;

const int X_THRESHOLD_LOW = 505;

const int X_THRESHOLD_HIGH = 515;

const int Y_THRESHOLD_LOW = 500;

const int Y_THRESHOLD_HIGH = 510;

int x_position;

int y_position;

int x_direction;

int y_direction;

void setup() {

Serial.begin(9600);

}

void loop () {

x_direction = 0;

y_direction = 0;

x_position = analogRead(PIN_ANALOG_X);

y_position = analogRead(PIN_ANALOG_Y);

if (x_position > X_THRESHOLD_HIGH) {

x_direction = 1;

} else if (x_position < X_THRESHOLD_LOW) {

x_direction = -1;

}

if (y_position > Y_THRESHOLD_HIGH) {

y_direction = 1;

30

} else if (y_position < Y_THRESHOLD_LOW) {

y_direction = -1;

}

if (x_direction == -1) {

if (y_direction == -1) {

Serial.println("left-down");

} else if (y_direction == 0) {

Serial.println("left");

} else {

// y_direction == 1

Serial.println("left-up");

}

} else if (x_direction == 0) {

if (y_direction == -1) {

Serial.println("down");

} else if (y_direction == 0) {

Serial.println("centered");

} else {

// y_direction == 1

Serial.println("up");

}

} else {

// x_direction == 1

if (y_direction == -1) {

Serial.println("right-down");

} else if (y_direction == 0) {

Serial.println("right");

} else {

// y_direction == 1

Serial.println("right-up");

}

}

Come impostare Arduino in modo da sapere quando un pulsante è

stato premuto

Prima si può sapere se un pulsante sullo scudo è stato spinto è necessario impostare Arduino in modo da riconoscere i pulsanti Innanzitutto definiamo costanti per il pin di Arduino associato a ciascun pulsante: // Select button is triggered when joystick is pressed

const byte PIN_BUTTON_SELECT = 2;

const byte PIN_BUTTON_RIGHT = 3;

const byte PIN_BUTTON_UP = 4;

const byte PIN_BUTTON_DOWN = 5;

const byte PIN_BUTTON_LEFT = 6;

normalmente nei pulsanti è richiesto un resistore al fine di rilevare una tensione nota quando non viene premuto il pulsante. Arduino ha effettivamente dei resistori interni connessi ai pin dentro il microcontrollore. Per poter utilizzare le resistenze interne, abbiamo bisogno di "attivare le resistenze di pull-up interno". Quando un resistore "pull-up" è collegato a un pulsante vuol dire che il livello di tensione quando non viene premuto il pulsante sarà alta perché le resistenze "tira la tensione di salire di livello" alto quando non viene premuto il pulsante.

31

Per abilitare la resistenza di un pin pull-up si imposta il pin come input e poi si attiva impostando lo stesso pin come HIGH: pinMode(PIN_BUTTON_RIGHT, INPUT);

digitalWrite(PIN_BUTTON_RIGHT, HIGH);

Il codice effettivo per abilitare il pull-up davvero non ha alcun senso se leggete letteralmente ma funziona in questo modo.

Come sapere quando è stato premuto un pulsante sullo scudo Joystick? Una volta impostato Arduino può dire se viene premuto il pulsante con la funzione

digitalRead().Quando la lettura del valore è basso viene premuto il pulsante e quando il valore è alto non viene premuto il pulsante. if (digitalRead(PIN_BUTTON_LEFT) == LOW) {

// Button is pressed

} else {

// Button is not pressed

}

Il seguente esempio stampa lo stato di ciascun pulsante e il valore del joystick per la console seriale Arduino: // Store the Arduino pin associated with each input

// Select button is triggered when joystick is pressed

const byte PIN_BUTTON_SELECT = 2;

const byte PIN_BUTTON_RIGHT = 3;

const byte PIN_BUTTON_UP = 4;

const byte PIN_BUTTON_DOWN = 5;

const byte PIN_BUTTON_LEFT = 6;

const byte PIN_ANALOG_X = 0;

const byte PIN_ANALOG_Y = 1;

void setup() {

Serial.begin(9600);

pinMode(PIN_BUTTON_RIGHT, INPUT);

digitalWrite(PIN_BUTTON_RIGHT, HIGH);

pinMode(PIN_BUTTON_LEFT, INPUT);

digitalWrite(PIN_BUTTON_LEFT, HIGH);

pinMode(PIN_BUTTON_UP, INPUT);

digitalWrite(PIN_BUTTON_UP, HIGH);

pinMode(PIN_BUTTON_DOWN, INPUT);

digitalWrite(PIN_BUTTON_DOWN, HIGH);

pinMode(PIN_BUTTON_SELECT, INPUT);

digitalWrite(PIN_BUTTON_SELECT, HIGH);

}

void loop() {

Serial.print("l:");

Serial.print(digitalRead(PIN_BUTTON_LEFT));

32

Serial.print(" ");

Serial.print("r:");

Serial.print(digitalRead(PIN_BUTTON_RIGHT));

Serial.print(" ");

Serial.print("u:");

Serial.print(digitalRead(PIN_BUTTON_UP));

Serial.print(" ");

Serial.print("d:");

Serial.print(digitalRead(PIN_BUTTON_DOWN));

Serial.print(" ");

Serial.print("x:");

Serial.print(analogRead(PIN_ANALOG_X));

Serial.print(" ");

Serial.print("y:");

Serial.print(analogRead(PIN_ANALOG_Y));

Serial.print(" ");

Serial.print("s:");

Serial.print(digitalRead(PIN_BUTTON_SELECT));

Serial.print(" ");

Serial.println();

}

La shield “PROTO”

La shield di prototipazione, abbreviato “proto” è una shield vuota con alcune piste già fatte per integrati. Il resto della superficie è una mille fori in modo da realizzare diversi circuiti. In certe circostanze può essere molto utile. In Armuino ad esempio, l‟ho usata per saldare gli attacchi dei servo. Sulla proto infatti arriva sia l‟alimentazione per i servo e sia il controllo del servo.

33

Le “Librerie”

In Informatica, una libreria è un insieme di funzioni o strutture dati predisposte per essere collegate ad un programma software attraverso opportuno collegamento. Il collegamento può essere statico o dinamico; nel secondo caso si parla di dynamic-link library. Il termine libreria nasce da un'errata traduzione dell'inglese library (letteralmente, biblioteca), ma ormai è così diffuso nel vocabolario dei professionisti da essere accettato quale esatta traduzione.

Scopo ed utilizzo

Lo scopo delle librerie software è quello di fornire una collezione di entità di base pronte per l'uso ovvero riuso di codice, evitando al programmatore di dover riscrivere ogni volta le stesse funzioni o strutture dati e facilitando così le operazioni di manutenzione. Questa caratteristica si inserisce quindi nel più vasto contesto del 'richiamo di codice' all'interno di programmi e applicazioni ed è presente in quasi tutti i linguaggi. I vantaggi principali derivanti dall'uso di un simile approccio sono i seguenti:

Si può separare la logica di programmazione di una certa applicazione da quella necessaria per la risoluzione di problemi specifici, quali il calcolo di funzioni matematiche o la gestione di collezioni;

Le entità definite in una certa libreria possono essere riutilizzate da più applicazioni; Si può modificare la libreria separatamente dal programma, senza limiti alla

potenziale vastità di funzioni e strutture dati man mano disponibili nel tempo.

Librerie standard

Quasi tutti i linguaggi di programmazione supportano il concetto di libreria e moltissimi includono delle librerie standardizzate (spesso chiamate proprio librerie standard del linguaggio in questione): si tratta di un insieme di funzioni e/o strutture dati che permettono di risolvere i problemi di programmazione più comuni. Ad esempio, molti linguaggi di programmazione hanno una libreria matematica, che consente di eseguire elevamenti a potenza, il calcolo dei logaritmi e così via; funzioni di I/O; funzioni e strutture dati per la gestione di collezioni di oggetti; e altre. Le librerie standard, rispetto a quelle non-standard, consentono una più agevole portabilità degli applicativi che le sfruttano; infatti, ogni produttore di compilatori è tenuto a includere una certa implementazione delle librerie standard; questo significa che le librerie sono potenzialmente supportate da tutte le piattaforme per le quali esiste un compilatore specifico. Viceversa, una libreria non-standard potrebbe non essere supportata su un certo sistema.

34

Libreria Servo.h

Questa libreria permette ad una scheda Arduino di controllare i servomotori. Più comunemente chiamati “Servo” hanno ingranaggi integrati e un albero che può essere controllato con precisione. Un Servo standard consente all'albero di essere posizionato in varie angolazioni, solitamente tra 0 e 180 gradi. I Servo a rotazione continua consentono la rotazione continua dell'albero e si può impostare la velocità. La libreria Servo supporta fino a 12 motori sulla maggior parte delle schede Arduino e 48 sulle Arduino Mega. Sulle schede diverse dalla Mega, l'uso della libreria analogWrite disabilita () (PWM) la funzionalità sui pin 9 e 10, anche se non c'è un Servo su quei pin. Sul Mega, fino a 12 servo può essere utilizzato senza interferire con la funzionalità PWM; uso di motori 12 e 23 disabilita PWM su perni 11 e 12. circuito

Istruzioni Attach()

Associa la variabile servo ad uno specifico pin. Sintassi servo.attach(pin), servo.attach(pin, min,max).

Parametri servo: variabile di tipo Servo. Pin: numero del pin hardware utilizzato.

Min (opzionale): durata minima dell'impulso, in microsecondi, corrispondente al minimo grado di rotazione (0 gradi) del servo (il valore predefinito è 544).

Max (opzionale): durata massima dell'impulso, in microsecondi, corrispondente alla massima rotazione ( 180 gradi) del servo (il valore predefinito è 2400).

Istruzioni Attached()

Verifica l'associazione tra la variabile servo ed il pin.

Sintassi: servo.attached().

Parametri servo: variable di tipo Servo.

Ritorno: vero se il servo è associato al pin; falso in caso contrario.

Istruzioni Detach()

Dissocia la variabile servo al pin specificato. Se tutte le variabili servo non sono associate, i pin 9 e 10 possono essere usati come uscite PWM con l'istruzione analogWrite().

Sintassi: servo.detach().

Parametrri: servo= variabile di tipo servo.

Istruzione Read()

Legge l'attuale posizione del servo corrispondente all'ultima posizione passata con l'istruzione write().

Sintassi: servo.read().

Parametri servo: variabile di tipo servo.

Ritorno: l'angolo del servo da 0 a 180 gradi.

35

Istruzione Write()

Invia il valore in gradi relativo alla posizione del perno del servo. Un valore 0 corrisponde alla massima rotazione a sinistra, mentre 180 equivale alla massima rotazione a destra; il valore 90 indica la posizione centrale. L'esatta corrispondenza tra valore in gradi inviato e l'effettiva rotazione del servo viene specificata dai valori Max e Min nella dichiarazione dell'istruzione attach(); tali valori devono essere ricavati mediante prove pratiche, in quanto possono anche variare da servo a servo.

Sintassi: servo.write(angle).

Parametri servo: variabile di tipo servo.

Angle: valore corrispondente alla rotazione in gradi.

Istruzione WriteMicrosecond() Imposta la posizione del servo come valore relativo alla durata dell‟impulso espressa in microsecondi. Normalmente un valore 1000 corrisponde alla massima rotazione a sinistra, 2000 alla massima rotazione a destra ed il valore 1500 corrisponde alla posizione centrale (neutro) Sintassi: servo.writeMicroseconds(μS). Parametri servo: variabile di tipo servo. μS: valore in microsecondi relativo alla posizionedel servo.

36

Linguaggio di programmazione Il linguaggio di programmazione Arduino è un‟implementazione di Wiring, una piattaforma di physical computing simile, che è a sua volta basato su un altro ambiente multimediale di programmazione chiamato Processing. L'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. L'ambiente di sviluppo integrato di Arduino è fornito di una libreria software C/C++ chiamata "Wiring" (dall'omonimo progetto Wiring), che rende molto più semplice implementare via software le comuni operazioni input/output. I programmi di Arduino sono scritti in C/C++, ma, per poter creare un file eseguibile, all'utilizzatore non è chiesto altro se non definire due funzioni:

setup() – una funzione invocata una sola volta all'inizio di un programma che può essere utilizzata per i settaggi iniziali

loop() – una funzione chiamata ripetutamente fino a che la scheda non viene spenta.

37

I servomotori Un Servomotore è un organo meccanico di potenza, in grado di gestire un movimento, il quale può essere comandato da un segnale logico di bassa o bassissima potenza. In questo caso non ci occuperemo dei sofisticati modelli industriali ma dei più comuni modelli per uso nel modellismo per aerei, navi, auto, robot, ecc. Stiamo parlato di quelli che, in gergo, vengono chiamati SERVOS, in Inglese, o più semplicemente SERVO, in Italiano, e che molti appassionati adoperano, o vorrebbero adoperare, sui propri modellini.

Alcuni tipi di Servomotori o, più comunemente detti, Servo. Il Servo è generalmente alloggiato in un contenitore ed è costituito da un motore elettrico, completo di riduzione meccanica, un sistema di feedback per la posizione dell'asse di uscita e tutta l'elettronica di controllo. Tramite un opportuno sistema di comando è possibile far ruotare l'asse di uscita del servo e posizionarlo in una specifica e precisa posizione.

Esistono Servo di varia potenza, ingombro, funzionalità, ecc. ma la caratteristica

fondamentale è che si comandano tutti allo stesso modo.

Vista Interna di un tipico Servo.

38

Qui si possono vedere le parti meccaniche del servo. Ci si può rendere conto che esso non è che una serie di ingranaggi che ha lo scopo di ridurre il numero dei giri del motore ad un valore utilizzabile dal dispositivo che deve essere comandato. Notate bene che l'albero di uscita del servo, normalmente, può ruotare soltanto di 180°. Per superare questo limite occorre adoperare dei Servo in grado di superare i 360° oppure modificare il servo.

Schema a Blocchi di un tipico Servo.

Il funzionamento del Servo è molto semplice. Come si può osservare, dallo schema a blocchi, il segnale di Controllo arriva all'Elettronica. Questa lo confronta con il valore presente sul Potenziometro e decide se deve fare ruotare il motore ed in che direzione.

Collegamento Elettrico di un Servo.

Per gestire il Servo occorrono solo 3 fili. Due sono quelle della alimentazione che, in genere, è di 6Vdc ma, a scapito di una riduzione della potenza, è accettato anche il 5Vdc. Un terzo filo è quello del segnale di Controllo e che è tipicamente a livello TTL.

39

Elementi Costitutivi di un tipico Servo.

Approfitto dell'occasione per ribadire che, nonostante ci sia una notevole

somiglianza, il segnale di controllo dei Servo NON è assolutamente un segnale

PWM e nemmeno PCM. Dopo capiremo perché.

Per comandare un Servo occorre, tramite il filo di controllo, inviare allo stesso una serie di impulsi TTL. La durata del singolo impulso determina la posizione dell'asse di uscita. Il tempo di pausa, tra un impulso ed il successivo, può variare entro ampi limiti senza che si abbia una perdita di controllo del Servo. Dopo avere data una descrizione qualitativa cominciamo a dare delle indicazioni quantitative stabilendo dei precisi valori numerici. La durata dell'impulso può variare tra un minimo di 1mS ed un massimo di 2mS. In funzione della durata di questo impulso il Servo farà ruotare il perno di uscita, solidale con il potenziometro, fino al raggiungimento del completo equilibrio.

Relazione Esistente trà

Larghezza degli Impulsi

e Rotazione.

La durata minima e massima dell'impulso corrisponde ai due estremi dell'escursione del Servo. L'impulso della durata di 1,5ms corrisponde alla posizione centrale, o mediana, del Servo. Bisogna ricordare che questo impulso deve essere continuamente rinfrescato

40

(ripetuto) altrimenti il Servo, non essendo più governato, si porterà a riposo. Questo significa che non potrà più garantire di mantenere la posizione e l'albero potrà essere mosso dalle forze attualmente presenti del carico applicato. La durata della Pausa, tra un impulso ed il successivo, deve essere compresa tra un minimo di 10ms ed un massimo di 40ms. La durata tipica della Pausa tra gli impulsi è di 20ms che sono pari a 50Hz.

Modulazioni PWM

Cos’è la PWM

Modulazione PWM PWM è l‟acronimo di Pulse Width Modulation, ossia modulazione ad impulsi. Consiste in un segnale ad onda quadra di un determinato periodo (fisso), con duty cycle variabile (modulabile). Si definisce duty cycle di un onda quadra, il rapporto tra il tempo in cui l‟onda assume valore alto e il periodo T. Un duty cycle del 50%, caratterizza un onda quadra, che in un periodo T si mantiene per T/2 a livello alto e per il restante T/2 a livello basso, così come un duty cycle dell‟80% sta ad indicare che l‟onda quadra per l‟80% del suo periodo T è a livello alto ed il restante 20% a livello basso. Un duty cycle del 100% rappresenta un segnale sempre a livello alto, e viceversa un duty cycle dello 0% un segnale sempre a livello basso. Il tempo alto dell‟impulso, viene definito „durata‟ dell‟impulso ed è il principale parametro utile per governare i motori.

(nella figura si suppone T = 1)

41

Quindi i servo con che segnale vengono comandati?

Spesso si sente dire che I servomotori sono pilotati con un segnale PWM. In realtà non sono

pilotati con questa modulazione ma è molto simile. Solitamente quando viene usato il PWM si fa

variare e si legge il valore medio, ma in questo caso a variare è il tempo dell‟impulso. È proprio

questo valore che determina la rotazione del servo.

42

ARMUINO 1.0

Flow Chart di massima di “ARMUINO 1.0”

43

ARMUINO 1.0

/*

QUESTO SKETCH PERMETTE AD "ARMUINO" DI ESSERE MOSSO TRAMITE JOYSTICK,

SELEZIONANDO ANCHE IL SINGOLO SERVO, OPPURE PREMENDO IL PULSANTE SOTTO

IL JOYSTICK INIZIERà UN PROGRAMMA PRESTABILITO CON IL QUALE IL BRACCIO

ROBOT SI MUOVERà AUTOMATICAMENTE.

*/

#include <Servo.h>

Servo servo_pinza; //crea oggetto servo_pinza

Servo servo_rotazione_polso; //crea oggetto servo_rotazione_polso

Servo servo_polso; //crea oggetto servo_polso

Servo servo_gomito; //crea oggetto servo_gomito

Servo servo_spalla; //crea oggetto servo_spalla

Servo servo_rotazione; //crea oggetto servo_rotazione

#define start 2 //attacca il pulsante d3 al pin digitale3

#define gomito 5 //attacca il pulsante d5 al pin digitale 5

#define polso 6 //attacca il pulsante d3 al pin digitale 6

#define rotazione_polso 4 //attacca il pulsante d3 al pin digitale 4

#define pinza 3 //attacca il pulsante d3 al pin digitale 2

const byte PIN_ANALOGICO_X = 0;

const byte PIN_ANALOGICO_Y = 1;

const int X_SOGLIA_BASSA = 405;

const int X_SOGLIA_ALTA = 615;

const int Y_SOGLIA_BASSA = 400;

const int Y_SOGLIA_ALTA = 610;

int x_position;

int y_position;

int x_direction;

int y_direction;

int angolo_spalla = 90;

int angolo_gomito = 90;

int angolo_rotazione_polso = 90;

int angolo_polso = 90;

int angolo_pinza = 90;

void setup() {

Serial.begin(9600);

servo_pinza.attach(13); //attacca servo pinza al pin 13

servo_rotazione_polso.attach(12); //attacca servo rotazione polso al pin 12

servo_polso.attach(11); //attacca servo polso al pin 11

servo_gomito.attach(10); //attacca servo gomito al pin 10

servo_spalla.attach(8); //attacca servo spalla1 al pin 8

servo_rotazione.attach(9); //attacca servo rotazione al pin 9

pinMode(start, INPUT);

digitalWrite(start, HIGH); //resistenza di pull up

pinMode(gomito, INPUT);

digitalWrite(gomito, HIGH); //resistenza di pull up

pinMode(polso, INPUT);

digitalWrite(polso, HIGH); //resistenza di pull up

pinMode(rotazione_polso, INPUT);

digitalWrite(rotazione_polso, HIGH); //resistenza di pull up

pinMode(pinza, INPUT);

digitalWrite(pinza, HIGH); //resistenza di pull up

posizione_partenza();

}

44

void loop () {

x_direction = 0;

y_direction = 0;

x_position = analogRead(PIN_ANALOGICO_X);

y_position = analogRead(PIN_ANALOGICO_Y);

if (x_position > X_SOGLIA_ALTA) { // se la x > soglia alta (direzione = 1)

x_direction = 1;

}

else if (x_position < X_SOGLIA_BASSA) { // se la x > soglia alta (direzione = -1)

x_direction = -1;

}

if (y_position > Y_SOGLIA_ALTA) { // se la y > soglia alta (direzione = 1)

y_direction = 1;

}

else if (y_position < Y_SOGLIA_BASSA) { // se la y > soglia alta (direzione = -1)

y_direction = -1;

}

if (x_direction == -1 && y_direction == -1) { //se x = -1

Serial.println("sinista-giù"); //scrivi: sinistra-giù

}

else if (x_direction == -1 && y_direction == 0) { //e se y = 0

Serial.println("sinistra"); //scrivi: sinistra

servo_rotazione.attach(9);

servo_rotazione.write(--angolo_spalla);

}

if (x_direction == -1 && y_direction == 1) { //altro (y = 1)

Serial.println("sinistra-su"); //scrivi: sinistra-su

}

else if (x_direction == 0 && y_direction == -1 && digitalRead(gomito)==HIGH &&

digitalRead(rotazione_polso)==HIGH && digitalRead(polso)==HIGH && digitalRead(pinza)==HIGH) {

Serial.println("giù");

servo_spalla.attach(8);

servo_spalla.write(--angolo_spalla);

}

if (x_direction == 0 && y_direction == -1 && digitalRead(pinza)==LOW) {

Serial.println("MOVIMENTO_PINZA"); //scrivi:giù

servo_pinza.attach(13);

servo_pinza.write(--angolo_pinza);

}

else if (x_direction == 0 && y_direction == 0) {

Serial.println("centro");

}

if (x_direction == 0 && y_direction == 1 && digitalRead(gomito)==HIGH &&

digitalRead(rotazione_polso)==HIGH && digitalRead(polso)==HIGH && digitalRead(pinza)==HIGH) {

Serial.println("su");

servo_spalla.attach(8);

servo_spalla.write(++angolo_spalla);

}

else if (x_direction == 1 && y_direction == -1) { //altro (x = 1)

Serial.println("destra-giù"); //scrivi:destra-giù

}

if (x_direction == 1 && y_direction == 0) { //e se y = 0

Serial.println("destra"); //scrivi: destra

servo_rotazione.attach(9);

servo_rotazione.write(++angolo_spalla);

}

else if (x_direction == 1 && y_direction == 1) { //altro (y = 1

Serial.println("destra-su"); //scrivi:destra-su

}

else if (x_direction == 0 && y_direction == -1 && digitalRead(gomito)==LOW) {

Serial.println("GOMITO");

servo_gomito.attach(10);

servo_gomito.write(--angolo_gomito);

}

if (x_direction == 0 && y_direction == 1 && digitalRead(gomito)==LOW) {

Serial.println("GOMITO");

servo_gomito.attach(10);

servo_gomito.write(++angolo_gomito);

}

if (x_direction == 0 && y_direction == 1 && digitalRead(polso)==LOW) {

45

Serial.println("POLSO");

servo_polso.attach(11);

servo_polso.write(--angolo_polso);

}

if (x_direction == 0 && y_direction == -1 && digitalRead(polso)==LOW) {

Serial.println("POLSO");

servo_polso.attach(11);

servo_polso.write(++angolo_polso);

}

if (x_direction == 0 && y_direction == 1 && digitalRead(rotazione_polso)==LOW) {

Serial.println("ROTAZIONE_POLSO");

servo_rotazione_polso.attach(12);

servo_rotazione_polso.write(--angolo_rotazione_polso);

}

if (x_direction == 0 && y_direction == -1 && digitalRead(rotazione_polso)==LOW) {

Serial.println("ROTAZIONE_POLSO");

servo_rotazione_polso.attach(12);

servo_rotazione_polso.write(++angolo_rotazione_polso);

}

if (x_direction == 0 && y_direction == 1 && digitalRead(pinza)==LOW) {

Serial.println("PINZA");

servo_pinza.attach(13);

servo_pinza.write(++angolo_pinza);

}

if (x_direction == 0 && y_direction == -1 && digitalRead(pinza)==LOW) {

Serial.println("PINZA");

servo_pinza.attach(13);

servo_pinza.write(--angolo_pinza);

}

else if (x_direction == 0 && y_direction == 0 && digitalRead(start)==LOW) {

Serial.println("start");

automatico();

delay(1000);

posizione_partenza();

}

}

void posizione_partenza (){

servo_rotazione.write (90); // servo rotazione fermo

servo_pinza.write(90);

servo_polso.write(110);

servo_spalla.write(60); //servo spalla1 90°

servo_gomito.write(180); //servo gomito 90°

}

void automatico(){

servo_rotazione_polso.write(80);

delay(1000);

servo_rotazione.write (90); // servo rotazione fermo

servo_pinza.write(90);

servo_polso.write(110);

servo_spalla.write(60); //servo spalla1 90°

servo_gomito.write(180); //servo gomito 90°

delay(2000);

servo_gomito.write(70);

servo_pinza.write(0);

servo_polso.write(20);

servo_spalla.write(120);

delay(1000);

servo_spalla.write(130);

delay(1000);

servo_pinza.write(180); //afferra oggetto

delay(1000);

servo_spalla.write(90);

delay(2000);

servo_rotazione.write(180);

delay(1000);

servo_spalla.write(100);

delay(100);

servo_spalla.write(130);

delay(1000);

servo_pinza.write(0); //lascia oggetto

delay(1000);

servo_spalla.write(110);

delay(2000);

}

46

Collaudo

Il collaudo è senza dubbio la cosa più emozionante del progetto. Il primo collaudo non è

stato soddisfacente, l‟avambraccio era troppo lungo, il servo del gomito non lavorava

bene, allora ho deciso di accorciare l‟avambraccio. Dopo questa modifica il braccio

funziona! Per vederlo in funzione si può visitare il sito http://armuino.altervista.org/ oppure

su www.youtube.com e scrivendo “Armuino” nella ricerca . sito

http://armuino.altervista.org/ è un sito in costruzione quindi con un po‟ di pazienza sarà più

ricco di contenuti.

Costo stimato Realizzazione HW

Spese:

servo power HD 1501 MG 4x 25E = 100

servo hitec hs 422 3x 10E = 30

alluminio telaio = 5

pinza = 19

ingranaggi 4x5E = 20

bulloneria, barre filettate,tondini, minuteria ecc.. = 30

legno = 15

alimentatore = 50

arduino = 23

joystick schield = 12

proto shield = 12

plexiglass = 15

vernici = 15

adesivi = 10

cavo, cavetti = 5

totale = 361E

47

Conclusioni ed eventuali modifiche apportabili

é davvero un‟ enorme soddisfazione vedere un progetto finito e funzionante senza aver

preso nemmeno spunto da progetti altrui. Sono contento che tutto funzioni ma ci sono

ancora molti miglioramenti e molti componenti da aggiungere. I miglioramenti riguardano

la meccanica e qualche volta i problemi erano dovuti alla mancanza di macchinari giusti

per determinati lavori. Per quanto riguarda l‟aggiunta di componenti si potrebbe parlare ad

esempio di alcuni sensori,come di prossimità, luce, calore e tante altre cose. In futuro

Armuino potrà muoversi grazie a dei cingoli che verranno montati sotto la scatola. Diciamo

che si possono fare moltissimi lavori con questo robot e io lo consiglierei per fare didattica

dato che in esso si trovano diverse materie.

Bibliografia Essenziale

Materiale su Arduino: www.arduino.cc

Materiale sui servo: documentazione file PDF

Materiale su Modulazione PWM: documentazione file PDF