Banzi, Massimo - Arduino, Guida Ufficiale

LA PIATTAFORMA
DI PROTOTIPAZIONE
ELETTRONIcA
OPEN
SOURCE
Arduino
La guida ufficiale
Massimo Banzi
E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Arduino
La guida ufficiale
Massimo Banzi

Authorized Italian translation of Getting Started with Arduino ISBN 9780596155513
© 2009, Massimo Banzi.
This translation is published and sold by permission of O’Reilly Media, Inc., the owner
of all rights to publish and sell the same.
© Tecniche Nuove 2009

Redazione: tel. 0239090258-264, fax 0239090255
e-mail: libri@tecnichenuove.com
Vendite: tel. 0239090440, fax 0239090373
e-mail: vendite-libri@tecnichenuove.com
www.tecnichenuove.com
ISBN 978-88-481-7424-4
978-88-481-2424-9
Tutti i diritti sono riservati. Nessuna parte del libro può essere riprodotta o diffusa con
un mezzo qualsiasi, fotocopie, microfilm o altro, senza il permesso dell’editore.
All rights reserved. No part of this book shall be reproduced, stored in a retrieval system,
or transmitted, by any means, electronic, mechanical photocopying, recording or
otherwise without written permission from the publisher.
Traduzione di Barbara Sansone

Realizzazione editoriale a cura di Mokarta sas – Gorgonzola (MI)
Copertina di Franco Beretta
La scheda in copertina è gentilmente concessa da Smart Projects
Stampa: Andersen, Borgomanero (NO)

Finito di stampare nel mese di agosto 2009
Printed in Italy

Sommario
Prefazione . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . v
1/Introduzione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 1
A chi è rivolto. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 2
Cos’è il Physical Computing?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 3
2/La filosofia di Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

La prototipazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 6
Il concetto di tinkering. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7
Patching. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 8
Il circuit bending . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 10
La manipolazione delle tastiere. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 12
Amiamo i rifiuti!. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 14
Modificare giocattoli . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 15
La collaborazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 16
3/La piattaforma Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

L’hardware di Arduino . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17
Il software (IDE). . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Installare Arduino sul computer. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 20
Installare i driver su Macintosh. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Installare i driver su Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 21
Identificare la porta su Macintosh. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 23
Identificare la porta su Windows. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 24
4/Cominciare a lavorare davvero con Arduino . . . . . . . . . . . . . . . . . . . . . . . 27

Anatomia di un dispositivo interattivo. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 27
Sensori e attuatori. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Far lampeggiare un LED . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 28
Passami il parmigiano . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 32
Arduino non permette di uscire. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
I veri tinkerer scrivono commenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 33
Il codice passo passo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 34
Cosa costruiremo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 36
Cos’è l’elettricità? . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 37
Usare un pulsante per controllare il LED. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 40

Come funziona?. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 42
Un circuito, mille comportamenti . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 43
5/Input e output avanzati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

Provare altri sensori On/Off. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51
Controllare la luce con la PWM. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 54
Usare un sensore di luce invece del pulsante. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 60
Gli input analogici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 62
Provare altri sensori analogici . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
La comunicazione seriale . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 66
Gestire carichi maggiori (motori, lampade e simili). . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
Sensori complessi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 68
6/Comunicare con la Rete. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71

Pianificazione. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 7 3
Il codice. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 74
Assemblare il circuito . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 81
Ecco come assemblarlo . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 82
7/Risoluzione dei problemi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Testare la scheda. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 86
Testare il circuito sulla breadboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 87
Isolare i problemi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Problemi con l’IDE. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 88
Come ottenere aiuto online. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 89
Appendici. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Appendice A/La breadboard . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 91
Appendice B/Resistenze e condensatori. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 93
Appendice C/Arduino: Guida rapida. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 9 5
Appendice D/Leggere gli schemi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 108
Indice analitico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

Prefazione
Alcuni anni fa mi fu proposta una sfida molto

interessante: insegnare ai designer i concetti
fondamentali dell’elettronica in modo da
permettere loro di costruire i prototipi interattivi
degli oggetti che stavano progettando.
All’inizio seguii il mio istinto e cominciai a insegnare l’elettronica come me l’ave-
vano insegnata a scuola. Poi mi accorsi che questo sistema non funzionava come
avrei voluto: mi ricordai di cosa voleva dire stare seduto in una classe, annoiatissi-
mo, ascoltando tutta la teoria che mi veniva propinata senza poterne sperimentare
alcuna applicazione pratica.
In realtà, quando andavo a scuola avevo già imparato qualcosa di elettronica in un

modo molto empirico: pochissima teoria e moltissima esperienza concreta.
Cominciai a pensare al processo grazie al quale avevo imparato concretamente i

concetti di elettronica:
» Smontavo tutti i dispositivi elettronici su cui riuscivo a mettere mano.

» A poco a poco imparai cos’erano tutti i vari componenti.
» Cominciai ad armeggiare, cambiando i loro collegamenti interni e osservando
cosa accadeva al dispositivo: di solito un’esplosione e una nuvoletta di fumo.
» Cominciai a costruire alcuni kit allegati a riviste di elettronica.

» Combinavo i dispositivi che avevo modificato e rielaboravo kit e altri circuiti che
trovavo nelle riviste per cambiarne la funzione.
Da bambino, sono stato sempre incuriosito da come funzionavano le cose e

per questo le smontavo. Questa passione cresceva mentre mi impossessavo
degli oggetti che in casa non si usavano e li smontavo in piccole parti. Alla fine,
Prefazione v

la gente mi portava dispositivi di ogni sorta per permettermi di sezionarli. A
quell’epoca i miei progetti più grandi furono una lavapiatti e un vecchio computer
che provenivano da un ufficio di assicurazioni, dotato di un’enorme stampante,
schede elettroniche, lettori di schede magnetiche e molte altre parti che trovavo
molto interessante e stimolante smontare completamente.
Dopo molte dissezioni, imparai a conoscere i componenti elettronici e le loro

funzioni. Inoltre, casa mia era piena di vecchie riviste di elettronica che mio padre
aveva comprato all’inizio degli anni 70. Quindi passavo ore a leggere gli articoli e a
osservare gli schemi dei circuiti senza capirci un granché.
Questa abitudine di rileggere più volte gli articoli, avvalendomi delle conoscenze
acquisite smontando i circuiti, generò un lento circolo virtuoso.
Feci un grosso passo avanti un Natale, quando mio padre mi regalò un kit pensato
per insegnare l’elettronica agli adolescenti. Ciascun componente era contenuto
in un cubo di plastica che si collegava magneticamente agli altri cubi, creando un
collegamento; sopra appariva il simbolo elettronico. Certo non mi aspettavo che
quel giocattolo era anche una pietra miliare della storia del design tedesco, perché
Dieter Rams lo aveva progettato negli anni 60.
Con questo nuovo strumento, potevo unire rapidamente dei circuiti e provarli per
vedere cosa succedeva. Il ciclo di prototipazione diventava sempre più breve.
Quindi cominciai a costruire radio, amplificatori, circuiti che producevano rumori
orribili o suoni gradevoli, sensori di pioggia e piccoli robot.
Ci impiegai molto a trovare una parola inglese che descrivesse un modo di lavora-
re senza un piano specifico, partendo da un’idea e arrivando a un risultato del tutto
inaspettato. Infine, scoprii la parola “tinkering”. Scoprii che questa parola veniva
usata in molti altri campi per descrivere un modo di agire e di definire le persone
che intraprendevano un percorso sul sentiero dell’esplorazione. Per esempio, la
generazione di registi francesi che diedero vita alla “Nouvelle Vague” venivano
chiamati “tinkerers”. Trovai la definizione migliore di “tinkering” in una mostra
presso l’Exploratorium di San Francisco:
Tinkering è quanto accade quando si cerca di fare qualcosa che non si sa bene
come fare, guidati dal capriccio, dall’immaginazione e dalla curiosità. Quando si
agisce in questo modo, non esistono istruzioni e neanche errori, non esiste un
modo giusto o un modo sbagliato di fare le cose. Si tratta di scoprire come funzio-
nano le cose e di manipolarle.
vi Arduino – La guida ufficiale

Aggeggi, macchine, oggetti discordanti che funzionano armoniosamente: ecco
cos’è il tinkering.
Tinkering, fondamentalmente, è un processo che coniuga gioco e ricerca. 
—www.exploratorium.edu/tinkering
Grazie ai miei primi esperimenti, imparai quanta esperienza è necessaria per riu-
scire a creare un circuito che faccia quello che si vuole a partire dai suoi compo-
nenti fondamentali.
Feci un altro grande passo avanti nell’estate del 1982, quando andai a Londra
con i miei genitori e trascorsi molte ore nel Museo della Scienza. Qui era appena
stata aperta una nuova ala dedicata ai computer e, seguendo una serie di espe-
rimenti guidati, appresi i concetti fondamentali della matematica binaria e della
programmazione.
Quindi scoprii che in molte applicazioni gli ingegneri non costruivano più i circuiti
a partire dai loro componenti fondamentali, ma che invece stavano implementan-
do molta intelligenza nei loro prodotti usando dei microprocessori. Il software sta-
va rimpiazzando molte ore di electronic design e permetteva un ciclo di tinkering
più breve.
Al mio ritorno cominciai a risparmiare, perché volevo comprare un computer e

imparare a programmare.
Il mio primo e più importante progetto quindi fu usare il mio nuovissimo compu-
ter ZX81 per controllare una saldatrice. So che può sembrare un progetto poco
eccitante, ma ce n’era bisogno e per me era una grossa sfida, perché avevo appe-
na imparato a programmare. A questo punto, divenne chiaro che scrivere linee di
codice avrebbe richiesto meno tempo che modificare circuiti complessi.
Più di vent’anni dopo, mi piace pensare che questa esperienza mi permette di

insegnare alla gente che non ha alcun ricordo delle lezioni di matematica e di
infondere lo stesso entusiasmo e la stessa capacità di “tinkering” che ho avuto
fin da ragazzo.
Massimo
Prefazione vii

Ringraziamenti
Questo libro è dedicato a Luisa e Alexandra.
Innanzitutto voglio ringraziare i miei compagni del Team di Arduino: David Cuartiel-
les, David Mellis, Gianluca Martino e Tom Igoe.
Lavorare con voi è un’esperienza fantastica.
Barbara Ghella non lo sa, ma senza i suoi preziosi consigli Arduino e questo libro
forse non esisterebbero.
Bill Verplank per avermi insegnato molto sul Physical Computing.
Gillian Crampton-Smith per avermi offerto un’opportunità e per tutto ciò che mi
ha insegnato.
Hernando Barragan per il lavoro svolto su Wiring.
Brian Jepson per essere un grande editore e per il suo entusiastico appoggio.
Nancy Kotary, Brian Scott, Terry Bronson e Patti Schiendelman per aver trasformato i
miei scritti in un libro completo.
Vorrei ringraziare molte altre persone, ma Brian dice che non c’è abbastanza spazio,
quindi elencherò solo un numero ridotto di persone che ringrazio per molte ragioni:
Adam Somlai-Fisher, Ailadi Cortelletti, Alberto Pezzotti, Alessandro Germinasi,

Alessandro Masserdotti, Andrea Piccolo, Anna Capellini, Casey Reas, Chris
Anderson, Claudio Moderini, Clementina Coppini, Concetta Capecchi, Csaba
Waldhauser, Dario Buzzini, Dario Molinari, Dario Parravicini, Donata Piccolo,
Edoardo Brambilla, Elisa Canducci, Fabio Violante, Fabio Zanola, Fabrizio Pignoloni,
Flavio Mauri, Francesca Mocellin, Francesco Monico, Giorgio Olivero, Giovanna
Gardi, Giovanni Battistini, Heather Martin, Jennifer Bove, Laura Dellamotta,
Lorenzo Parravicini, Luca Rocco, Marco Baioni, Marco Eynard, Maria Teresa
Longoni, Massimiliano Bolondi, Matteo Rivolta, Matthias Richter, Maurizio Pirola,
Michael Thorpe, Natalia Jordan, Ombretta Banzi, Oreste Banzi, Oscar Zoggia,
Pietro Dore, Prof Salvioni, Raffaella Ferrara, Renzo Giusti, Sandi Athanas, Sara
Carpentieri, Sigrid Wiederhecker, Stefano Mirti, Ubi De Feo, Veronika Bucko.
viii Arduino – La guida ufficiale

Qualche indirizzo utile per l’Italia
I lettori italiani possono trovare ulteriori informazioni su Arduino sul suo sito italia-
no www.arduino.cc/it.
Per acquistare la scheda e la componentistica necessaria alla realizzazione dei

progetti presentati nel libro possono rivolgersi a:
Smart Projects – www.smartprj.com.
Robot Italy – www.robot-italy.com.
Eshopen – www.eshopen.com.
Il sito del libro

Per commenti al libro, il lettore può inviare una mail a bookquestions@oreilly.com.
Il sito web O’Reilly di Arduino – La guida ufficiale presenta esempi, errata

e progetti per le future edizioni. Si può trovare questa pagina all’indirizzo www.
makezine.com/getstartedarduino.
Avvertenze importanti per il lettore

Il lettore è responsabile della propria sicurezza, del corretto utilizzo delle apparec-
chiature e dei dispositivi di sicurezza e di valutare il proprio livello di capacità ed
esperienza. L’elettricità e le altre risorse utilizzate per questi progetti sono pericolo-
se, a meno che non si faccia un uso corretto e si prendano precauzioni adeguate,
compreso l’utilizzo di dispositivi di sicurezza. Alcune illustrazioni non rappresen-
tano i dispositivi di sicurezza per poter mostrare il progetto nel modo più chiaro
possibile. Questi progetti non sono stati creati per essere utilizzati da bambini.
L’utilizzo delle istruzioni e dei suggerimenti in Arduino – La guida ufficiale è a

proprio rischio. O’Reilly Media, Inc., Tecniche Nuove e l’autore declinano qualsiasi
responsabilità per eventuali danni, lesioni o spese. È responsabilità del lettore
assicurarsi che le sue attività rispettino le leggi in vigore, comprese quelle relative
al copyright.
Prefazione ix

1/Introduzione
Arduino è una piattaforma open source di physical

computing basata su una semplice scheda
input/output (I/O) e un ambiente di sviluppo che
implementa il linguaggio Processing (www.
processing.org). Arduino può essere usato per
sviluppare oggetti interattivi indipendenti o può
essere collegato a un software sul computer
(come Flash, Processing, VVVV o Max/MSP).
Le schede possono essere assemblate a mano
o comprate preassemblate; l’IDE (Integrated
Development Environment) open source
può essere scaricato gratuitamente da www.
arduino.cc.
Arduino è diverso dalle altre piattaforme esistenti sul mercato, per via di queste
caratteristiche:
» È un ambiente multipiattaforma; disponibile per Windows, Macintosh e Linux.

» Si basa sull’IDE di programmazione Processing, un ambiente di sviluppo facile da
usare diretto ad artisti e designer.
» Si programma attraverso un cavo USB, non una porta seriale. Questa funziona-
lità è utile, perché molti computer moderni non sono dotati di porte seriali.
» È un hardware e software open source: volendo, si può scaricare il diagramma

del circuito, comprare tutti i componenti e crearsi la scheda da soli, senza paga-
re niente ai creatori di Arduino.
Introduzione 1

» L’hardware è economico. La scheda USB costa circa 20 € (attualmente, circa
35 $) e sostituire un chip bruciato sulla scheda è facile e non costa più di 5 € o
4 $. Quindi ci si può permettere di commettere errori.
» Esiste un’attiva comunità di utenti, pertanto si possono trovare moltissime

persone disposte a offrire aiuto.
» Il Progetto Arduino è stato sviluppato in un ambiente didattico e quindi è ideale

per i principianti che vogliono ottenere velocemente dei risultati.
Questo libro è pensato per aiutare i principianti a capire che vantaggi possono
trarre imparando a usare la piattaforma Arduino e abbracciandone la filosofia.
A chi è rivolto
Questo libro è stato scritto per gli utenti “originali” di Arduino: designer e artisti.
Quindi, cerca di spiegare le cose in un modo che potrebbe innervosire gli inge-
gneri. In realtà, uno di loro ha definito i capitoli introduttivi della mia prima bozza
“banalità”. E questo è proprio quello che volevo. Diciamoci la verità: quasi nessun
ingegnere è capace di spiegare quello che fa a un altro ingegnere, figuriamoci a un
essere umano normale. Quindi ora è il momento di immergerci nella “banalità”.
NOTA: Arduino si basa sulla tesi scritta da Hernando Barragan sulla piattafor-
ma Wiring mentre studiava con Casey Reas e me presso l’IDII di Ivrea.
Quando Arduino cominciò a diffondersi, mi accorsi che sperimentatori, hobbisti

e hacker di ogni sorta stavano cominciando a usarlo per creare oggetti pazzi e
bellissimi. Scoprii che tutti in qualche modo sono artisti e designer, quindi questo
libro è anche per voi.
Arduino nacque per insegnare Interaction Design, una disciplina di design che
mette la prototipazione al centro della sua metodologia. Esistono diverse defini-
zioni di Interaction Design, ma quella che preferisco è:
L’Interaction Design è il design di tutte le esperienze interattive.
Nel mondo di oggi, l’Interaction Design ha a che fare con la creazione di espe-
rienze significative tra noi (gli umani) e gli oggetti. È un buon modo di esplorare la
creazione di esperienze meravigliose (e forse anche controverse) tra noi e la tec-
nologia. L’Interaction Design incoraggia il design attraverso un processo iterativo
basato su prototipi sempre più fedeli. Questo approccio (che fa parte anche di
2 Arduino – La guida ufficiale

alcuni tipi di design “convenzionale”) può essere esteso per includere la prototi-
pazione con la tecnologia; in particolare, la prototipazione con l’elettronica.
Il campo specifico dell’Interaction Design che interessa Arduino è il Physical

Computing (o Physical Interaction Design).
Cos’è il Physical Computing?

Il Physical Computing usa l’elettronica per prototipare nuovi materiali per designer
e artisti.
Il suo scopo è la progettazione di oggetti interattivi che possano comunicare

con gli esseri umani usando sensori e attuatori controllati da un comportamento
implementato in forma di software ed eseguito all’interno di un microcontroller
(un piccolo computer su un unico chip).
In passato, usare l’elettronica significava doversi rivolgere a degli ingegneri e

costruire circuiti un piccolo componente per volta; questi ostacoli impedivano alla
gente di fare esperimenti diretti con il medium. La maggior parte degli strumenti
erano diretti agli ingegneri e richiedevano una profonda preparazione. Negli ultimi
anni, i microcontroller hanno cominciato a diventare più economici e più facili da
usare, permettendo di creare strumenti migliori.
Il progresso che abbiamo fatto con Arduino è stato portare questi strumenti un
passo più vicino ai principianti, permettendo alla gente di cominciare a costruire
qualcosa dopo appena due o tre giorni di corso.
Con Arduino, un designer o un artista può imparare molto rapidamente i concetti

fondamentali dei componenti elettronici e dei sensori e può cominciare a costrui-
re prototipi investendo pochissimo.
Introduzione 3

2/La filosofia di Arduino
La filosofia di Arduino si basa sul concetto di

creare progetti, anziché limitarsi a parlarne. È
una ricerca costante di modi più rapidi e potenti
di costruire prototipi migliori. Abbiamo esplorato
molte tecniche di prototipazione e sviluppato
modi di pensare con le mani.
L’ingegneria classica si basa su un processo rigido che porta da A a B; la filosofia

di Arduino si diletta con la possibilità di perdersi lungo il cammino e di trovare
invece C.
Questo è il processo di “tinkering” cui siamo tanto affezionati: giocare con il

medium in modo flessibile e trovare qualcosa di imprevisto. Nel corso di questa
ricerca di modi per costruire prototipi migliori, abbiamo anche selezionato alcuni
software che favoriscono il processo di manipolazione costante del software e
dell’hardware.
I prossimi paragrafi presentano alcune filosofie, eventi e pionieri che hanno ispirato
la forma mentis di Arduino.
La filosofia di Arduino 5

La prototipazione
La prototipazione è il cuore della filosofia di Arduino: facciamo cose e costruiamo
oggetti che interagiscono con altri oggetti, persone e reti. Ci sforziamo di trovare un
modo più facile e veloce di prototipare nel modo più economico possibile.
Moltissimi principianti che si avvicinano all’elettronica per la prima volta pensano di

dover imparare a costruire tutto a partire da zero. Ma questa sarebbe una perdita di
energia: l’obiettivo deve essere vedere subito qualcosa che funziona, in modo da
sentirci motivati a eseguire il passo successivo o magari motivare qualcun altro a
fornirci il denaro per farlo.
Ecco perché abbiamo sviluppato una “prototipazione opportunistica”: perché perde-

re tempo ed energia a costruire qualcosa da zero, un processo che richiede tempo
e profonde conoscenze tecniche, quando possiamo prendere dispositivi già pronti
e modificarli in modo da trovare il grosso del lavoro già fatto da grandi società e
ottimi ingegneri?
Il nostro eroe è James Dyson, che, prima di sentirsi soddisfatto, ha creato 5127
prototipi del suo aspirapolvere (www.international.dyson.com/jd/1947.asp).

Il concetto di tinkering
Crediamo che sia fondamentale giocare con la tecnologia, esplorare diverse
possibilità direttamente su hardware e software, a volte senza uno scopo
ben definito.
Riutilizzare la tecnologia esistente è una delle forme migliori di tinkering. Procurar-

si giocattoli economici o vecchie attrezzature che andrebbero buttate e modificar-
le per creare qualcosa di nuovo è uno dei modi migliori di ottenere ottimi risultati.

Patching
Sono sempre stato affascinato dalla modularità e dalla possibilità di costruire sistemi
complessi collegando tra loro dispositivi semplici. Questo processo è rappresentato
molto bene da Robert Moog e dal suo sintetizzatore analogico. I musicisti hanno
costruito i suoni, cercando infinite combinazioni mettendo insieme (patching) diversi
moduli con dei cavi. Questo approccio faceva sembrare il sintetizzatore un vecchio
centralino telefonico, ma combinato con diverse manopole, che rappresentava la
piattaforma perfetta per sperimentare con il suono e innovare la musica. Moog
descrisse questo processo come una via di mezzo tra “provare e scoprire”. Sono
sicuro che moltissimi musicisti all’inizio non sapevano a cosa servissero tutte quelle
centinaia di manopole, ma provarono e provarono, migliorando il loro stile senza
interrompere il flusso.
Ridurre il numero di interruzioni del flusso è molto importante per la creatività: più il
processo è fluido, più “tinkering” si verifica.
Questa tecnica nel mondo del software è stata tradotta da ambienti di “program-
mazione visiva” come Max, Pure Data o VVVV. Questi strumenti possono essere
visualizzati come un insieme di elementi chiusi, detti “box”, ciascuno dei quali offre
una diversa funzionalità, permettendo all’utente di costruire “patch” collegando tra
loro i box. Questi ambienti permettono all’utente di sperimentare con la programma-
zione senza soffrire le costanti interruzioni tipiche del ciclo normale: “digitare il codi-
ce; compilarlo; maledizione, c’è un errore; correggere l’errore; compilare; eseguire”.
Chi ha una mente più visiva farà bene a provarli.


Il circuit bending
Il circuit bending è una delle forme più interessanti di tinkering. Si tratta di provo-
care cortocircuiti creativi in dispositivi elettronici audio a basso voltaggio, alimen-
tati a batteria, come effetti a pedale per chitarra, giocattoli per bambini e piccoli
sintetizzatori, per creare nuovi strumenti musicali e generatori di suoni. Il fulcro
di questo processo è l’“arte della casualità”. Ebbe inizio nel 1966 quando Reed
Ghazala provocò un cortocircuito nell’amplificatore di un giocattolo mettendolo
casualmente a contatto con un oggetto metallico nel cassetto della sua scrivania,
producendo una serie di suoni inusuali. Quello che mi piace dei circuit bender è la
capacità di creare i dispositivi più originali sperimentando con la tecnologia senza
necessariamente capire cosa stanno facendo dal punto di vista teorico.

È un po’ come la fanzine Sniffin’ Glue mostrata qui: durante il periodo punk, saper
usare tre corde di una chitarra era sufficiente per fondare una band. Non dovete
lasciare che gli esperti di un campo dicano che non sarete mai uno di loro. Dovete
ignorarli e sorprenderli.

La manipolazione delle tastiere

Dopo più di 60 anni, il modo principale per interagire con i computer è ancora la
tastiera. Alex Pentland, direttore scientifico del MIT Media Laboratory, una volta
sottolineò: “Scusate l’espressione, ma gli orinatoi maschili sono più intelligenti
dei computer. I computer sono isolati da ciò che li circonda”.1
In qualità di tinkerer, possiamo implementare nuovi modi di interagire con il

software sostituendo i tasti con dispositivi in grado di “sentire” l’ambiente. Se
smontate la tastiera di un computer scoprirete un dispositivo molto semplice (ed
economico). Il suo cuore è una piccola scheda, di solito un circuito verde o marro-
ne con due serie di contatti che vanno ai due strati di plastica che contengono le
connessioni tra i vari tasti. Se eliminate il circuito e usate un cavo per fare ponte
tra due contatti, sullo schermo del computer appare una lettera. Se vi procura-
te un sensore di movimento e lo collegate alla tastiera, noterete che ogni volta
che qualcuno passa davanti al computer viene premuto un tasto. Se mettete in
corrispondenza questo dispositivo con il vostro software preferito, avrete reso il
vostro computer intelligente come un orinatoio. Imparare a modificare le tastiere
è una parte chiave della prototipazione e del Physical Computing.
1
Citato in Sara Reese Hedberg, “MIT Media Lab’s quest for perceptive computers”, Intelligent Systems and Their
Applications, IEEE, Lug/Ago 1998.

Amiamo i rifiuti!
Oggigiorno la gente butta moltissimi oggetti tecnologici: vecchie stampanti,
computer, strane macchine da ufficio, equipaggiamenti tecnici e perfino militari.
Di questa tecnologia di scarto è sempre esistito un fiorente mercato, specie tra
voi e/o gli hacker più poveri e quelli che sono agli inizi. Questo mercato divenne
notevole a Ivrea, dove sviluppammo Arduino. La città in passato era stata la sede
della società Olivetti, che costruiva computer già dagli anni 60. A metà degli anni
90, buttava via tutti i suoi rifiuti nel rottamaio della zona, che divenne pieno di
parti di computer, componenti elettronici e strani dispositivi di ogni genere. E noi
vi abbiamo passato innumerevoli ore, comprando aggeggi di ogni sorta a prezzi
bassissimi e riutilizzandoli nei nostri prototipi. Quando si riescono a comprare a
pochissimo centinaia di altoparlanti, alla fine inevitabilmente viene fuori un’idea.
Prima di cominciare a costruire qualcosa da zero, vi consiglio di cominciare ad
accumulare rifiuti.

Modificare giocattoli
I giocattoli sono una sorgente fantastica di tecnologia a buon mercato da mani-
polare e riutilizzare, come ha dimostrato la pratica del circuit bending menzionata
prima. Grazie all’attuale affluenza di migliaia di giocattoli tecnologici e a basso
prezzo provenienti dalla Cina, si possono realizzare rapidamente le proprie idee
usando gattini che miagolano e un paio di spade luminose. Da alcuni anni faccio
esattamente questo, per far capire ai miei studenti che la tecnologia non è così
spaventosa o difficile da avvicinare. Una delle mie sorgenti preferite è il libretto
“Low Tech Sensors and Actuators” di Usman Haque e Adam Somlai-Fischer
(lowtech.propositions.org.uk). Secondo me, gli autori nel loro manualetto han-
no descritto perfettamente questa tecnica e da allora la uso sempre.

La collaborazione
La collaborazione tra utenti è uno dei principi chiave nel mondo di Arduino:
attraverso il forum su www.arduino.cc/it, persone di diverse parti del mondo si
aiutano reciprocamente a imparare a usare la scheda. Il team di Arduino incorag-
gia le persone a collaborare a livello locale, oltre ad aiutare a fondare gruppi di
utenti nelle città che visita. Abbiamo creato anche una Wiki di nome “Playground”
(www.arduino.cc/playground), dove gli utenti documentano le loro scoperte.
Vedere quanta conoscenza questa gente mette a disposizione di tutti sul Web è
davvero incredibile. Questa cultura della condivisione e dell’aiuto reciproco è una
delle cose di cui sono più fiero riguardo ad Arduino.

3/La piattaforma
Arduino
Arduino è composto da due parti principali:

la scheda Arduino, l’hardware su cui si lavora
quando si costruiscono gli oggetti; e l’IDE
Arduino, il software che si esegue sul computer.
L’IDE serve a creare sketch (piccoli programmi
preparati sul computer) che si caricano sulla
scheda Arduino. Uno sketch istruisce la scheda su
cosa fare.
Non molto tempo fa, lavorare con l’hardware significava costruire circuiti da zero,
usando centinaia di componenti diversi con nomi strani come resistenze, conden-
satori, induttori, transistor e così via.
Ogni circuito era “cablato” per eseguire una applicazione specifica e apportare del-
le modifiche significava tagliare cavi, saldare collegamenti e così via.
Con l’avvento delle tecnologie digitali e dei microprocessori, queste funzioni, una
volta implementate con i cavi, sono state sostituite da programmi software.
Il software è più facile da modificare dell’hardware. Premendo appena pochi tasti,

si può cambiare radicalmente la logica di un dispositivo e provarne due o tre ver-
sioni nella stessa quantità di tempo necessaria per saldare un paio di resistenze.
L’hardware di Arduino
La scheda Arduino è una piccola scheda microcontroller, cioè un piccolo circuito
(la scheda) che contiene un intero computer in un piccolo chip (il microcontroller).
Questo computer è almeno mille volte meno potente del MacBook che sto usan-
La piattaforma Arduino 17

do per scrivere, ma è molto più economico e molto utile per costruire dispositivi
interessanti. Guardate la scheda Arduino: vedrete un chip nero con 28 “piedini”.
Quel chip è l’ATmega168, il cuore della scheda.
Su questa scheda, noi (il team di Arduino) abbiamo posizionato tutti i componenti
necessari perché questo microcontroller funzioni correttamente e comunichi con
il computer. Della scheda esistono molte versioni; quella che useremo in questo
libro è l’Arduino Duemilanove, la più semplice da usare e la migliore per impara-
re. Queste istruzioni, comunque, valgono anche per le versioni precedenti della
scheda, comprese la più recente Arduino Diecimila e la più vecchia Arduino NG.
La Figura 3-1 mostra l’Arduino Duemilanove; la Figura 3-2 mostra l’Arduino NG.
In queste illustrazioni, vedete la scheda Arduino. Sulle prime, tutti questi connet-
tori possono confondere un po’. Ecco la spiegazione di cosa fa ciascun elemento
della scheda:
14 Pin IO digitali (pin 0–13)

Possono essere usati come input o output, secondo quanto si specifica nello
sketch che si crea nell’IDE.
6 Pin di ingresso analogico (pin 0–5)

Questi pin dedicati agli input analogici accettano valori analogici (per esempio, il
voltaggio fornito da un sensore) e li convertono in numeri compresi tra 0 e 1023.
6 Pin di uscita analogica (pin 3, 5, 6, 9, 10 e 11)

In realtà si tratta di sei dei pin digitali che possono essere riprogrammati per fun-
gere da output analogici usando lo sketch che si crea nell’IDE.
La scheda può essere alimentata attraverso la porta USB del computer, la mag-
gior parte dei caricatori USB o un alimentatore esterno (si consiglia un alimentato-
re da 9 volt con spinotto cilindrico da 2,1 mm con positivo centrale). Se nella pre-
sa non è collegato nessun alimentatore, la scheda si alimenta via USB, ma, non
appena si collega un alimentatore di corrente, la scheda lo usa automaticamente.
NOTA: Se si usa un più vecchio Arduino-NG o Arduino Diecimila, si deve im-

postare il jumper per la scelta dell’alimentazione (che sulla scheda presenta
l’etichetta PWR_SEL) in modo da specificare EXT (alimentatore esterno) o
USB. Questo jumper si trova tra la presa dell’alimentatore e la porta USB.

Figura 3-1. L’Arduino Duemilanove
Figura 3-2. L’Arduino NG

Il software (IDE)
L’IDE (Integrated Development Environment) è un programma speciale che vie-
ne eseguito sul computer e permette di scrivere sketch per la scheda Arduino in
un linguaggio semplice basato sul linguaggio Processing (www.processing.
org). La magia avviene quando fate clic sul pulsante che carica lo sketch sulla
scheda: il codice che avete scritto viene tradotto in linguaggio C (di solito
piuttosto difficile da usare per un principiante) e passato al compilatore avr-gcc,
una parte importante di software open source che opera la traduzione finale nel
linguaggio compreso dal microcontroller. L’ultimo passaggio è molto importante,
perché è quello che permette ad Arduino di semplificarvi la vita tenendovi lonta-
ni il più possibile dalla difficoltà data dal programmare i microcontroller.
Il ciclo di programmazione su Arduino è fondamentalmente questo:
» Collegate la scheda a una porta USB del vostro computer.

» Scrivete uno sketch che darà vita alla scheda.
» Caricate lo sketch sulla scheda attraverso il collegamento USB e aspettate il
paio di secondi necessari perché la scheda si riavvii.
» La scheda esegue lo sketch che avete scritto.
NOTA: Mentre si sta scrivendo il libro, installare Arduino su Linux è un po’

complicato. Per le istruzioni complete, visitate www.arduino.cc/playground/
Learning/Linux.
Installare Arduino sul computer  

Per programmare la scheda Arduino, innanzitutto dovete scaricare l’ambiente di
sviluppo (l’IDE) da qui: www.arduino.cc/en/Main/Software [N.d.T. è consigliabi-
le scaricare il software dalla versione in inglese del sito, più aggiornata di quella in
italiano] e scegliere la versione adatta al vostro sistema operativo.
Scaricate il file e fatevi doppio clic per decomprimerlo; in questo modo verrà creata
una cartella di nome arduino-[versione], come arduino-0016. Trascinate questa
cartella dove volete che risieda: sulla scrivania, nella vostra cartella /Applicazioni (su
Mac), o nella vostra cartella C:\Programmi (su Windows). Ora, ogni volta che volete
eseguire l’IDE Arduino, dovete aprire la cartella arduino e fare doppio clic sull’icona
di Arduino. Ma non basta fare solo questo: si deve eseguire un altro passaggio.

NOTA: Se avete problemi a eseguire l’IDE Arduino, consultate il Capitolo 7,
Risoluzione dei problemi.
 
Ora dovete installare i driver che permettono al computer di comunicare con la
scheda attraverso la porta USB.
Installare i driver su Macintosh

Cercate la cartella Drivers all’interno della cartella arduino-0016 e fate doppio clic
sul file di nome FTDIUSBSerialDriver_x_x_x.dmg (x_x_x rappresenta il numero di
versione del driver, per esempio FTDIUSBSerialDriver_v2_2_9_Intel.dmg). Fate
doppio clic sul file .dmg per montarlo.
NotA: Se usate un Mac Intel, come un MacBook, un MacBook Pro, un Mac-

Book Air, un Mac Pro o un Mac Mini o un iMac Intel, assicuratevi di installare
il driver con la parola “Intel” nel suo nome, come in FTDIUSBSerialDriver_
v2_2_9_Intel.dmg. Se non state usando un Mac Intel, installate quello senza
“Intel” nel nome.
Quindi, installate il software contenuto nel pacchetto FTDIUSBSerialDriver fa-

cendovi doppio clic. Seguite le istruzioni fornite dall’installer e, se viene richiesto,
digitate la password di un utente amministratore. Al termine di questo processo,
riavviate la macchina per assicurarvi che i driver vengano caricati correttamente.
Quindi collegate la scheda al computer. La spia luminosa PWR sulla scheda do-
vrebbe accendersi e il LED giallo con l’etichetta “L” dovrebbe cominciare a lam-
peggiare. Se ciò non accade, consultate il Capitolo 7, Risoluzione dei problemi. 
Installare i driver su Windows

Collegate la scheda Arduino al computer; quando si apre la finestra Trovato nuovo
hardware, Windows innanzitutto cerca di trovare il driver sul sito Windows Update.
Windows XP chiede se si vuole cercare su Windows Update; se non volete usare

Windows Update, selezionate l’opzione “No, non ora” e fate clic su Avanti.
Nella schermata successiva, scegliete “Installa da un elenco o percorso specifi-

co” e fate clic su Avanti.

Spuntate la casella “Includi il seguente percorso nella ricerca”, fate clic su Sfoglia,
selezionate la cartella dove avete installato Arduino e come posizione selezionate
la cartella Drivers\FTDI USB Drivers. Fate clic su OK e poi su Avanti.
Windows Vista innanzitutto cerca di trovare il driver su Windows Update; se non

ci riesce, dovete indicargli che si trova nella cartella Drivers\FTDI USB Drivers.
Questa procedura va eseguita due volte, perché il computer innanzitutto installa

il driver a basso livello e quindi una porzione di codice che fa vedere la scheda al
computer come una porta seriale.
Una volta che i driver sono installati, potete lanciare l’IDE Arduino e cominciare a
usare Arduino.
Poi, dovrete scoprire quale porta seriale è stata assegnata alla scheda Arduino,
perché questa informazione servirà in seguito per programmarla. Le istruzioni per
ottenere questa informazione sono fornite nei prossimi paragrafi.

Identificare la porta su Macintosh
Nel menu Tools nell’IDE Arduino, selezionate “Serial Port” e scegliete la porta che
comincia con /dev/cu.usbserial-; si tratta del nome che il vostro computer usa per
riferirsi alla scheda Arduino. La Figura 3-3 mostra l’elenco di porte.
Figura 3-3.
La lista di porte seriali dell’IDE Arduino

Identificare la porta su Windows
Su Windows, il processo è un po’ più complicato, almeno all’inizio. Aprite Ge-
stione dispositivi facendo clic sul menu Start, fate clic con il pulsante destro su
Computer (Vista) o Risorse del computer (XP) e scegliete Proprietà. Su Windows
XP, fate clic su Hardware e scegliete Gestione dispositivi. Su Vista, fate clic su
Gestione dispositivi (che appare nell’elenco di attività sulla sinistra della finestra).
Cercate il dispositivo Arduino nella lista sotto “Porte (COM e LPT)”. Arduino
appare come USB Serial Port e presenta un nome come COM4, come mostra la
Figura 3-4.
Figura 3-4.
Gestione dispositivi di Windows, che mostra tutte le porte seriali disponibili

NotA: Su alcune macchine Windows, la porta COM presenta un numero
maggiore di 9; questa numerazione crea alcuni problemi quando Arduino
cerca di comunicarvi. Per risolvere questo problema, consultate il Capitolo 7,
Risoluzione dei problemi.
Una volta scoperta l’assegnazione della porta COM, la potete selezionare nel
menu Tools > Serial Port dell’IDE Arduino.
Ora l’ambiente di sviluppo di Arduino riesce a comunicare con la scheda Arduino e

a programmarla.

4/Cominciare a lavorare
davvero con Arduino
Adesso vedremo come costruire e programmare
un dispositivo interattivo.
Anatomia di un dispositivo interattivo

Tutti gli oggetti che costruiremo usando Arduino seguono uno schema molto
semplice che chiamiamo “dispositivo interattivo”. Il dispositivo interattivo è un
circuito elettronico capace di “sentire” l’ambiente usando sensori (componenti
elettronici che convertono le misurazioni del mondo reale in segnali elettrici). Il
dispositivo elabora le informazioni che ricava dai sensori secondo un comporta-
mento implementato in forma di software. Il dispositivo quindi diventa capace di
interagire con il mondo per mezzo di attuatori, componenti elettronici in grado di
convertire un segnale elettrico in un’azione fisica.
Sensazione/Percezione
Sensori
Comportamento
(software)
Attuatori
Azione/reazione
Figura 4-1.
Il dispositivo interattivo
Cominciare a lavorare davvero con Arduino 27

Sensori e attuatori
Sensori e attuatori sono componenti elettronici che permettono a un oggetto
elettronico di interagire con il mondo.
Il microcontroller, dato che è un computer molto semplice, è in grado di elabora-

re solo segnali elettrici (un po’ come gli impulsi elettrici che vengono inviati dai
neuroni nel nostro cervello). Perché sia sensibile alla luce, alla temperatura o ad
altre misurazioni fisiche, ha bisogno che qualcosa le converta in segnali elettrici.
Nel nostro corpo, per esempio, l’occhio converte la luce in segnali che possono
essere inviati al cervello per mezzo dei nervi. Nell’elettronica, possiamo usare un
semplice dispositivo detto fotoresistenza (o LDR, Light Dependent Resistor), in
grado di misurare la quantità di luce da cui viene colpito e di riportarla nella forma
di un segnale che possa essere compreso dal microcontroller.
Una volta che i sensori sono stati letti, il dispositivo dispone delle informazioni
necessarie per decidere come reagire. Il processo decisionale è gestito dal micro-
controller e la reazione è eseguita degli attuatori. Nel nostro corpo, per esempio,
i muscoli ricevono segnali elettrici dal cervello e li convertono in movimento. Nel
mondo dell’elettronica, queste funzioni possono essere svolte da una luce o da
un motore elettrico.
Nei prossimi paragrafi, imparerete a leggere sensori di vario tipo e a controllare

diversi tipi di attuatori.
Far lampeggiare un LED

Lo sketch che fa lampeggiare un LED è il primo programma che dovreste esegui-
re per verificare che la vostra scheda Arduino funzioni e sia configurata corretta-
mente. Di solito è anche il primissimo esercizio di programmazione che si svolge
quando si impara a programmare un microcontroller. Un LED (diodo a emissio-
ne luminosa, Light Emitting Diode) è un piccolo componente elettronico che
assomiglia a una minuscola lampadina, ma è più efficiente e per lavorare richiede
voltaggi inferiori.
La vostra scheda Arduino presenta un LED preinstallato, identificato da una “L”.

Potete anche aggiungervi un vostro LED, collegandolo come nella Figura 4-2.
K indica il catodo (negativo), o il terminale più corto; A indica l’anodo (positivo),
o il terminale più lungo. Una volta che il LED è collegato, dovete dire ad Arduino
cosa deve fare. E questo si fa con il codice, cioè con un elenco di istruzioni che si
forniscono al microcontroller perché faccia quello che vogliamo.

Figura 4-2.
Collegare un LED ad Arduino

Sul vostro computer, aprite la cartella dove avete copiato l’IDE Arduino. Fate
doppio clic sull’icona di Arduino per lanciarlo. Selezionate File > New e vi verrà
chiesto di scegliere il nome di una cartella di sketch: questo è il posto dove
salverete lo sketch di Arduino. Nominatelo Blinking_LED e fate clic su OK. Quindi,
digitate questo testo (Esempio 01) nell’editor di sketch di Arduino (la finestra
principale dell’IDE Arduino). Lo potete anche scaricare da www.makezine.com/
getstartedarduino. Dovrebbe presentarsi come nella Figura 4-3.
// Esempio 01 : Far lampeggiare un LED
#define LED 13 // LED collegato al

// pin digitale 13
void setup()
{
pinMode(LED, OUTPUT); // imposta il pin digitale
// come output
}
void loop()
{
digitalWrite(LED, HIGH); // accende il LED
delay(1000); // aspetta un secondo
digitalWrite(LED, LOW); // spegne il LED
}

Verify Upload to I/O board
Qui va il vostro sketch
Figura 4-3.
L’IDE Arduino con il primo sketch caricato
Ora che il codice si trova nel vostro IDE, dovete verificare che sia corretto. Fate
clic sul pulsante “Verify” (la Figura 4-3 mostra la sua posizione); se tutto è cor-
retto, in basso nell’IDE Arduino appare il messaggio “Done compiling”. Questo
messaggio significa che l’IDE Arduino ha tradotto lo sketch in un programma ese-
guibile che può essere eseguito sulla scheda, un po’ come un file .exe in Windows
o .app su Mac.
A questo punto, lo si può caricare sulla scheda: fate clic sul pulsante Upload to I/O
Board (Figura 4-3). In questo modo si resetta la scheda, costringendola a interrom-
pere ciò che sta facendo e ad ascoltare le istruzioni che provengono dalla porta
USB. L’IDE Arduino invia lo sketch attuale alla scheda, che lo inserisce nella sua
memoria e poi lo esegue.

Nell’area vuota in basso nella finestra appaiono alcuni messaggi e, subito al di
sopra di quell’area, appare il messaggio “Done uploading”, che comunica che il
processo è stato portato a termine correttamente. Sulla scheda ci sono due LED,
identificati come RX e TX; e questi lampeggiano ogni volta che la scheda invia o
riceve un byte. Durante il processo di upload, lampeggiano continuamente.
Se non lo fanno, o se invece di “Done uploading” appare un messaggio di errore,

significa che c’è un problema di comunicazione tra il computer e Arduino. Verifi-
cate di aver selezionato la porta seriale corretta (Capitolo 3) nel menu Tools >
Serial Port. Inoltre, controllate che nel menu Tools > Board sia selezionato il mo-
dello corretto di Arduino.
Se avete ancora problemi, consultate il Capitolo 7, Risoluzione dei problemi.
Una volta che il codice si trova sulla scheda Arduino, ci rimane finché non vi
caricate un altro sketch. Lo sketch sopravvive anche se la scheda viene riavviata
o spenta, un po’ come i dati sull’hard disk del computer.
Se lo sketch è stato caricato correttamente, il LED “L” si accende per un secon-

do e poi si spegne per un secondo. Se avete installato un LED separato come
mostrato nella Figura 4-2, anche quel LED lampeggia. Quello che avete appena
scritto ed eseguito è un programma, o uno sketch, come si chiamano i pro-
grammi di Arduino. Arduino, come ho detto prima, è un piccolo computer che
può essere programmato per fare quello che volete. Per farlo, dovete usare un
linguaggio di programmazione per digitare una serie di istruzioni nell’IDE Arduino,
che le converte in un programma eseguibile per la scheda Arduino.
Ora spiegherò lo sketch. Innanzitutto, Arduino esegue il codice dall’alto verso il

basso, quindi la prima riga in alto è la prima a essere letta; poi procede verso il
basso, un po’ come la testina di lettura di un riproduttore video come QuickTime
Player o Windows Media Player si muove da sinistra a destra mostrando in che
punto del filmato ci si trova.
Passami il parmigiano
Notate la presenza delle parentesi graffe, che si usano per raggruppare diverse
linee di codice e si rivelano particolarmente utili quando si vuole assegnare un
nome a un gruppo di istruzioni. Se durante una cena chiedete a qualcuno “Mi
passi il parmigiano, per favore?”, con questa domanda generate una serie di azio-
ni che si riassumono nella breve frase che avete appena pronunciato. Dato che
siamo umani, il tutto avviene in modo naturale, mentre nel caso di Arduino, che

non è potente come il nostro cervello, deve essere specificata ogni singola azione
necessaria. Quindi, per raggruppare diverse istruzioni, si racchiude il codice tra
una { e una }.
Qui potete notare che sono definiti in questo modo due blocchi di codice. Prima
di ciascuno di essi appare uno strano comando:
void setup()
Questa riga assegna un nome al blocco di codice. Se steste scrivendo un elenco
di istruzioni per spiegare ad Arduino come passarvi il parmigiano, dovreste
scrivere void passTheParmesan() all’inizio del blocco e questo blocco divente-
rebbe un’istruzione che si potrebbe chiamare da qualsiasi punto del codice di
Arduino. Questi blocchi si chiamano funzioni. Se poi in un altro punto del codice
scrivete passTheParmesan(), Arduino esegue queste istruzioni e prosegue da
dove era rimasto.
Arduino non permette di uscire

Arduino ha bisogno che esistano due funzioni: una di nome setup() e una di nome
loop().
setup() è il posto dove si inserisce tutto il codice che si vuole eseguire una sola
volta all’inizio del programma e loop() contiene il programma vero e proprio, che
viene eseguito ripetutamente. Questo accade perché Arduino non è come un
computer normale: non è in grado di eseguire contemporaneamente diversi pro-
grammi e dai programmi non si può uscire. Quando si accende la scheda, viene
eseguito il codice; quando lo si vuole fermare, basta spegnerla.
I veri tinkerer scrivono commenti

Tutti i testi che cominciano con // vengono ignorati da Arduino. Queste righe sono
commenti, cioè note che potete lasciare nel programma per il vostro uso, in modo
da ricordare cosa avete fatto quando le avete scritte, o per uso di altri, in modo che
possano capire il vostro codice.
Molto spesso (e lo so perché lo faccio sempre) si scrive un codice, lo si carica sulla

scheda e si dice “Bene, non lo toccherò mai più!”, per poi accorgersi, sei mesi
dopo, che è necessario aggiornare il codice o correggere un bug. A questo punto,
si apre il programma e, se non si sono inclusi commenti nel programma originale, si
pensa “Mamma mia, che confusione! Da dove comincio?”. Procedendo, vedremo
alcuni trucchi per rendere i programmi più leggibili e facili da gestire.

Il codice passo passo
Innanzitutto, dovete tenere presente che questo tipo di spiegazione non è indi-
spensabile, un po’ come quando a scuola si doveva studiare la Divina Commedia
di Dante (tutti gli studenti italiani ci sono dovuti passare, come anche per un altro
libro: I promessi sposi; che incubi!). Per ogni riga del poema, c’erano centinaia di
righe di commenti! Ma la spiegazione qui sarà molto più utile, mentre scriverete i
vostri programmi.
// Esempio 01 : Far lampeggiare un LED

Un commento è un modo pratico per scrivere delle brevi note. Il commento pre-
cedente è un titolo che ci aiuta a ricordare che questo programma, Esempio 01,
fa lampeggiare un LED.
#define LED 13 // LED collegato al

// pin digitale 13
#define è come una ricerca automatica che sostituisce il vostro codice; in questo
caso, chiede ad Arduino di scrivere il numero 13 ogni volta che appare la parola
LED. La sostituzione è la prima cosa che avviene quando si fa clic su Verify o
Upload to I/O Board (i risultati della sostituzione non si vedono mai perché avvie-
ne dietro le quinte). Stiamo usando questo comando per specificare che il LED
che vogliamo far lampeggiare è collegato al pin 13 di Arduino.
void setup()
Questa riga dice a Arduino che il blocco successivo di codice si chiamerà setup().
{
Aprendo questa parentesi graffa, si inizia un blocco di codice.
pinMode(LED, OUTPUT); // imposta il pin digitale

// come output
Infine, appare un’istruzione molto interessante. pinMode indica ad Arduino come
configurare un determinato pin. I pin digitali possono essere usati sia come IN-
PUT che come OUTPUT. In questo caso, per controllare il nostro LED ci serve un
pin output, quindi all’interno delle parentesi dobbiamo inserire il numero del pin e
la sua modalità. pinMode è una funzione e le parole (o i numeri) che si specifica-
no all’interno delle parentesi sono argomenti. INPUT e OUTPUT nel linguaggio
di Arduino sono costanti (come le variabili, le costanti sono valori assegnati, con
la differenza che i valori costanti sono predefiniti e non cambiano mai).
}
Questa parentesi graffa chiusa indica la fine della funzione setup().

void loop()
{
loop() è il luogo dove si specifica il comportamento principale del dispositivo inte-

rattivo, che verrà ripetuto all’infinito finché non si spegne la scheda.

Come dice il commento, digitalWrite() è in grado di accendere (o spegnere)
qualsiasi pin che sia stato configurato come un OUTPUT. Il primo argomento (in
questo caso, LED) specifica quale pin deve essere acceso o spento (ricordate
che LED è un valore costante che si riferisce al pin 13, quindi questo sarà il pin
interessato). Il secondo argomento accende (HIGH) o spegne (LOW) il pin.
Immaginate che tutti i pin di output siano piccole prese di corrente, come quelle
che avete sui muri di casa vostra. Quelle europee sono a 230 V, quelle americane
a 110 V e Arduino lavora soli 5 V. La magia avviene quando il software diventa
hardware. Quando scrivete digitalWrite(LED, HIGH), mandate al pin di output 5 V
e, se vi collegate un LED, si illumina. Quindi, a questo punto del codice, un’istru-
zione del software fa accadere qualcosa nel mondo fisico, controllando il flusso di
elettricità del pin. Accendere e spegnere il pin ora ci permetterà di tradurre tutto
ciò in qualcosa di più visibile per gli esseri umani; il LED è il nostro attuatore.

Arduino presenta una struttura molto semplice. Quindi, se volete che qualcosa
accada con una certa regolarità, dovete fermarvi e non fare niente finché non è il
momento di procedere con il passaggio successivo. Essenzialmente delay() ferma
il processore e gli chiede di non fare nulla durante il numero di millisecondi che si
passano come argomento. I millisecondi sono millesimi di secondo; quindi, 1000
millisecondi equivalgono a 1 secondo. In questo caso, dunque, il LED rimane
acceso per un secondo.
digitalWrite(LED, LOW); // spegne il LED

Questa istruzione ora spegne il LED che prima abbiamo acceso. Perché usiamo
HIGH e LOW? Si tratta di una vecchia convenzione dell’elettronica digitale. HIGH
significa che il pin è acceso e, nel caso di Arduino, verrà impostato su 5 V. LOW si-
gnifica 0 V. Potete anche sostituire mentalmente questi argomenti con ON e OFF.

Impostiamo un’attesa di un altro secondo. Il LED resterà spento per un secondo.
}
Questa parentesi graffa chiusa segna la fine della funzione ciclica.

Per riassumere, ecco cosa fa questo programma:
» Imposta come output il pin 13 (solo una volta all’inizio).

» Entra in un ciclo.
» Accende il LED collegato al pin 13.
» Aspetta un secondo.
» Spegne il LED collegato al pin 13.
» Aspetta un secondo.
» Torna all’inizio del ciclo.
Spero che non risulti troppo difficile. Nei prossimi esempi vedrete meglio
come programmare.
Prima di passare al prossimo paragrafo, voglio che giochiate un po’ con il codi-
ce. Per esempio, potete ridurre il ritardo, usando numeri diversi per gli impulsi
di accensione e spegnimento per vedere pattern di lampeggiamento diversi. In
particolare, dovreste vedere cosa succede quando impostate ritardi molto brevi,
ma usate ritardi diversi per accensione e spegnimento . . . c’è un momento in cui
accade qualcosa di strano; questo “qualcosa” si rivelerà molto utile quando, più
avanti in questo libro, studierete la modulazione di larghezza di impulso.
Cosa costruiremo
Sono sempre stato affascinato dalla luce e dalla possibilità di controllare diverse
sorgenti di luce con la tecnologia. E sono stato così fortunato da lavorare su alcuni
progetti molto interessanti che riguardano proprio il controllo della luce e la pos-
sibilità di farla interagire con la gente. Arduino lo fa davvero bene. In questo libro,
studieremo come progettare “lampade interattive”, usando Arduino come mezzo
per imparare i concetti fondamentali della costruzione dei dispositivi interattivi.
Nel prossimo paragrafo, cercherò di spiegare le basi dell’elettricità in un modo

che annoierebbe un ingegnere, ma che non spaventerà un nuovo programmatore
di Arduino.

Cos’è l’elettricità?
Se mai avete fatto qualche lavoro idraulico a casa vostra, non avrete problemi a
capire l’elettronica. Per capire come funzionano l’elettricità e i circuiti elettrici, il
modo migliore è usare la cosiddetta “analogia idraulica”. Prendiamo un dispositi-
vo semplice, come il ventilatore portatile a batteria mostrato nella Figura 4-4.
Figura 4-4.
Un ventilatore portatile
Se smontate un ventilatore, vedrete che contiene una piccola batteria, un paio di

cavi, un motore elettrico e che uno dei cavi che vanno al motore è interrotto da
un interruttore. Se avete una batteria carica e accendete l’interruttore, il motore
comincia a girare, regalando la ventilazione necessaria. Come funziona? Bene,

immaginate che la batteria sia contemporaneamente un serbatoio d’acqua e una
pompa, che l’interruttore sia un rubinetto e che il motore sia una di quelle ruote
che si vedono nei mulini. Quando si apre il rubinetto, l’acqua fuoriesce dalla pom-
pa e fa girare la ruota.
In questo semplice sistema idraulico, mostrato nella Figura 4-5, sono importanti
due fattori: la pressione dell’acqua (determinata dalla potenza della pompa) e la
quantità d’acqua che scorrerà nei tubi (che dipende dalla dimensione dei tubi e
dalla resistenza opposta dalla ruota al flusso d’acqua che la investe).
Figura 4-5.
Un sistema idraulico
Presto vi accorgerete che se volete che la ruota giri più in fretta, dovete aumenta-
re la dimensione dei tubi (soluzione efficace solo fino a un certo punto) e aumen-
tare la pressione che la pompa permette di ottenere. Aumentando la dimensione
dei tubi si ottiene un flusso maggiore d’acqua attraverso di essi; rendendoli più
grandi, abbiamo effettivamente ridotto la resistenza dei tubi al flusso d’acqua.
Questo approccio funziona fino a un certo punto, superato il quale la ruota non
girerà più in fretta, perché la pressione dell’acqua non sarà sufficiente. Quando
raggiungiamo questo punto, dobbiamo potenziare la pompa. Questo metodo per
accelerare il movimento della ruota può spingersi fino al punto in cui la ruota si
rompe perché la forza dell’acqua è eccessiva e la distrugge. Un altro aspetto che
noterete è che, mentre la ruota gira, l’asse si scalderà leggermente perché, a
prescindere da quanto bene abbiamo montato la ruota, l’attrito tra l’asse e i buchi

su cui è montato genererà calore. È importante capire che in un sistema come
questo non tutta l’energia che si pompa nel sistema verrà convertita in movimen-
to; parte di essa verrà dispersa e generalmente si manifesterà in forma di calore
prodotto da qualche parte del sistema.
Quali sono, quindi, le parti più importanti del sistema? Una è la pressione prodot-
ta dalla pompa; le altre la resistenza opposta al flusso dell’acqua dai tubi e dalla
ruota e il flusso vero e proprio dell’acqua (diciamo che questo è rappresentato dal
numero di litri d’acqua che fluiscono in un secondo). L’elettricità funziona un po’
come l’acqua. Disponete di una sorta di pompa (una sorgente qualsiasi di elettrici-
tà, come una batteria o una presa della luce) che spinge le cariche elettriche (im-
maginatele come “gocce” di elettricità) nei tubi, che sono rappresentati dai cavi;
alcuni dispositivi sono capaci di usarle per produrre calore (la coperta termica
della nonna), luce (la lampada sul comodino), suoni (il vostro stereo), movimento
(un ventilatore) e molto altro ancora.
Quindi quando leggete che il voltaggio di una batteria è pari a 9 V, immaginate

questo voltaggio come la pressione dell’acqua che potrebbe essere potenzial-
mente prodotta da questa piccola “pompa”. Il voltaggio si misura in volt, che
prendono il nome da Alessandro Volta, l’inventore della prima batteria.
Così come la pressione dell’acqua ha un suo equivalente elettrico, ne ha uno

anche il flusso dell’acqua. Questo si chiama corrente e si misura in ampere (da
André-Marie Ampère, pioniere dell’elettromagnetismo). La relazione tra voltaggio
e corrente può essere illustrata tornando alla ruota del mulino: un voltaggio mag-
giore (pressione) permette alla ruota di girare più velocemente; un flusso maggio-
re (corrente) permette di far girare una ruota più grande.
Infine, la resistenza che oppone il flusso di corrente nei percorsi che attraversa
viene detta (facile da indovinare) resistenza e si misura in ohm (dal fisico tede-
sco Georg Ohm). Herr Ohm è anche colui che formulò la legge più importante
nell’elettricità e l’unica formula che dovete davvero ricordare. Egli dimostrò che
in un circuito il voltaggio, la corrente e la resistenza sono tutti in relazione e in
particolare che la resistenza di un circuito determina la quantità di corrente che lo
percorrerà, assegnato un determinato voltaggio.
Se ci pensate è molto intuitiva. Prendete una batteria da 9 V e collegatela a un

circuito semplice. Mentre misurate la corrente, scoprirete che più resistenze
aggiungete nel circuito, meno corrente lo percorrerà. Tornando all’analogia con
l’acqua che scorre nei tubi, assegnata una determinata pompa, se si installa una
valvola (che in elettricità può essere paragonata a una resistenza variabile),

più chiudo la valvola (aumentando la resistenza al flusso dell’acqua) meno acqua
passerà attraverso i tubi. Ohm riassunse la sua legge in queste formule:
R (resistenza) = V (voltaggio) / I (corrente)

V = R * I
I = V / R
Questa è l’unica regola che dovete davvero memorizzare e imparare a usare,

perché nella maggior parte dei vostri progetti sarà l’unica di cui avrete effettiva-
mente bisogno.
Usare un pulsante per controllare il LED

Far lampeggiare un LED è stato facile, ma non penso che il fatto che la lampada
della vostra scrivania lampeggi in continuazione mentre cercate di leggere un
libro farebbe bene al vostro equilibrio. Quindi, dovete imparare a controllarlo.
Nell’esempio precedente, il LED era il nostro attuatore ed era Arduino a control-
larlo. Ciò che manca per completare il quadro è un sensore.
In questo caso, useremo la forma più semplice di sensore esistente: un pulsante.
Se smontate un pulsante, vedere che si tratta di un dispositivo molto semplice:

due parti di metallo separate da una molla e un cappuccio di plastica che, quando
viene premuto, fa entrare in contatto le due parti di metallo. Quando le parti di
metallo sono separate, nel pulsante non circola corrente (un po’ come quando è
chiusa una valvola dell’acqua); quando lo premiamo, creiamo un collegamento.
Per controllare lo stato di un interruttore, esiste un’istruzione di Arduino che ora

imparerete: la funzione digitalRead().
digitalRead() controlla che al pin specificato tra parentesi sia applicato un voltaggio
e restituisce un valore pari a HIGH o LOW, a seconda di quanto rileva. Le altre
istruzioni che abbiamo usato finora non restituivano nessun dato: si limitavano a
eseguire ciò che si chiedeva loro di fare. Ma questo tipo di funzione è un po’ limita-
ta, perché ci costringe ad accontentarci di sequenze di istruzioni molto prevedibili,
senza input da parte del mondo esterno. Grazie a digitalRead(), possiamo “porre
una domanda” ad Arduino e ricevere una risposta che può essere conservata da
qualche parte nella memoria e usata per prendere decisioni, subito o più tardi.
Costruite il circuito mostrato nella Figura 4-6. Per costruirlo, dovete procurarvi alcuni
oggetti (che torneranno utili anche nei prossimi progetti):

» Una breadboard che non richiede saldature, come l’articolo numero 276-002 di
RadioShack (www.radioshack.com) o l’articolo MKKN3 di Maker Shed (www.
makershed.com). L’Appendice A offre un’introduzione a questo strumento.
» Un kit di cavi di connessione già tagliati, come l’articolo 276-173 di RadioShack o
l’articolo MKKN4 di Maker Shed.
» Una resistenza da 10K Ohm, come l’articolo 271-1335 (pacco da 5) di RadioShack

o l’articolo COM-08374 di SparkFun (www.sparkfun.com).
» Un interruttore a pulsante momentaneo, come l’articolo COM-00097

di SparkFun.
Figura 4-6.
Collegare un pulsante

NOTA: invece di comprare dei cavi di connessione già tagliati, potete anche
comprare cavi di collegamento solid-core 22 AWG in piccole bobine e poi
tagliarli e pelarli usando pinze tagliafili e pelacavi.
Diamo un’occhiata al codice che useremo per controllare il LED con il nostro
pulsante:
// Esempio 02: Accende il LED mentre è premuto il pulsante
#define LED 13 // il pin del LED

#define BUTTON 7 // il pin di input dove è
// collegato il pulsante
int val = 0; // si userà val per conservare lo stato
// del pin di input
void setup() {
pinMode(LED, OUTPUT); // segnala ad Arduino che LED è un output
pinMode(BUTTON, INPUT); // e che BUTTON è un input
}
void loop(){
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// controlla che l'input sia HIGH (pulsante premuto)

if (val == HIGH) {
} else {
digitalWrite(LED, LOW);
}
}
In Arduino, selezionate File > New (se è aperto un altro sketch, potreste prima vo-
lerlo salvare). Quando Arduino chiede di assegnare un nome alla nuova cartella del-
lo sketch, digitate PushButtonControl. Digitate il codice dell’Esempio 02 in Arduino
(o scaricatelo da www.makezine.com/getstartedarduino e incollatelo nell’IDE
Arduino). Se tutto è corretto, il LED si accende quando premete il pulsante.
Come funziona?
Con questo programma di esempio ho introdotto due nuovi concetti: le funzioni
che restituiscono il risultato del loro lavoro e l’istruzione if.

L’istruzione if è forse l’istruzione più importante dei linguaggi di programmazione,
perché permette al computer (e ricordate che Arduino è un piccolo computer) di
prendere decisioni. Dopo la parola chiave if dovete scrivere una “domanda” tra
parentesi e se la “risposta”, o il risultato, è vera, viene eseguito il primo blocco di
codice; altrimenti, viene eseguito il blocco di codice che segue else. Notate che
invece di = ho usato il simbolo ==. Questo viene usato quando si confrontano due
entità e restituisce TRUE o FALSE; il primo simbolo invece assegna un valore a
una variabile. Verificate di aver usato quello giusto, perché è molto facile com-
mettere questo errore e usare solo =. In questo caso, il vostro programma non
funzionerà mai. Lo so bene, perché dopo 25 anni di programmazione, a volte mi
sbaglio ancora.
Tenere il dito sul pulsante per tutto il tempo in cui si vuole la luce accesa non è
molto comodo. Anche se vi renderebbe consapevoli di quanta energia sprecate
quando vi allontanate da una lampada che avete lasciato accesa, dobbiamo trova-
re un modo per cambiare questo comportamento.
Un circuito, mille comportamenti

Il grande vantaggio dell’elettronica digitale, basata sulla programmazione, rispetto
all’elettronica classica ora diventa evidente: vi mostrerò come implementare molti
“comportamenti” diversi usando lo stesso circuito elettronico del paragrafo pre-
cedente, semplicemente modificando il software. Come ho anticipato prima, non
è molto comodo dover tenere il dito sull’interruttore per tenere la luce accesa.
Quindi dobbiamo implementare un qualche tipo di “memoria”, nella forma di un
meccanismo software che ricordi quando abbiamo premuto il pulsante e manten-
ga la luce accesa anche dopo che lo abbiamo rilasciato.
Per farlo, useremo quella che si chiama una variabile (ne abbiamo già usata una,
ma non l’ho spiegata). Una variabile è una posizione nella memoria di Arduino
dove si possono conservare dei dati. Immaginatela come una di quelle note
adesive che usate per ricordarvi di qualcosa, come un numero di telefono: ne
prendete una, ci scrivete “Luisa 02 555 1212” e poi lo appiccicate sul monitor del
computer o sul frigo. Nel linguaggio di Arduino, è altrettanto semplice: basta che
decidiate che tipo di dato volete conservare (un numero o del testo, per esem-
pio), gli assegnate un nome e, quando volete, potete salvare o recuperare il dato.
Per esempio:
int val = 0;
int significa che la variabile conterrà un numero intero, val è il nome della variabile
e = 0 vi assegna un valore iniziale pari a zero.

Una variabile, come suggerisce il nome, può essere modificata in qualsiasi punto
del codice, per cui più avanti nel programma potreste scrivere:
val = 112;
che assegna un nuovo valore, 112, alla variabile.
NotA: Avete notato che in Arduino, tutte le istruzioni, con una sola eccezione
(#define), finiscono con il punto e virgola? Sono così perché il compilatore (la
parte di Arduino che converte lo sketch in un programma che il microcontrol-
ler può eseguire) possa riconoscere dove finisce un’istruzione e ne comincia
una nuova. Ricordatevi di usarlo sempre, tranne che nelle righe che comin-
ciano con #define. Le istruzioni #define vengono sostituite dal compilatore
prima che il codice venga tradotto in un eseguibile per Arduino.
Nel programma che segue, usiamo val per conservare il risultato di digitalRead();
qualunque cosa Arduino ricavi dall’input finisce nella variabile e vi resta finché
non viene cambiato da un’altra riga di codice. Notate che le variabili usano un tipo
di memoria chiamata RAM. È abbastanza rapida, ma quando si spegne la scheda
tutti i dati contenuti nella RAM vanno persi (che significa che, quando si riaccen-
de la scheda, tutte le variabili tornano al loro valore iniziale). I vostri programmi
sono invece conservati nella memoria flash (dello stesso tipo usato dal vostro
cellulare per conservare i numeri di telefono), che conserva tutti i suoi contenuti
anche quando la scheda è spenta.
Ora usiamo un’altra variabile per ricordare se il LED deve rimanere acceso o spen-
to dopo che rilasciamo il pulsante. L’Esempio 03A è un primo tentativo:

// Esempio 03A: Accende il LED quando il pulsante è premuto
// e lo mantiene acceso dopo che lo si rilascia

int val = 0; // val servirà per conservare lo stato
// del pin di input
int state = 0; // 0 = LED spento mentre 1 = LED acceso
void setup() {
pinMode(LED, OUTPUT); // indica ad Arduino che LED è un output
}
void loop() {
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// verifica che l'input sia HIGH (pulsante premuto)

// e ne cambia lo stato
if (val == HIGH) {
state = 1 - state;
}
if (state == 1) {
} else {
}
}
Ora provate questo codice. Noterete che funziona. . . in un certo senso. Scoprire-
te che la luce cambia così rapidamente che non si può impostarla correttamente
premendo il pulsante. Diamo un’occhiata alle parti più interessanti del codice: sta-
te è una variabile che conserva 0 o 1 per ricordare se il LED è acceso o spento.
Dopo che si rilascia il pulsante, la inizializziamo su 0 (LED spento).

Poi, leggiamo lo stato corrente del pulsante e, se è premuto (val == HIGH),
cambiamo lo stato da 0 a 1 o viceversa. E lo facciamo usando un trucchetto, dato
che lo stato può essere solo 1 o 0. Il trucco che uso chiama in causa un piccola
espressione matematica basata sull’idea che 1 – 0 fa 1 e 1 – 1 fa 0:
state = 1 – state;
La riga può non avere molto senso in matematica, ma ne ha in programmazione.
Il simbolo = sta per “assegna il risultato di ciò che viene dopo di me al nome di
variabile che mi precede” e in questo caso al nuovo valore di stato viene assegna-
to il valore di 1 meno il vecchio valore di stato.
Più avanti nel programma, potete vedere che usiamo lo stato per scoprire se il
LED deve essere acceso o spento. Come ho detto, questo produce un risultato
un po’ strano.
Il risultato è discontinuo per via del modo in cui leggiamo il pulsante. Arduino è
molto veloce; esegue le sue istruzioni interne a una velocità pari a 16 milioni di
istruzioni al secondo, cioè potrebbe eseguire tranquillamente alcuni milioni di
righe di codice al secondo. Questo significa che, mentre il nostro dito preme il
pulsante, Arduino probabilmente sta leggendo la posizione del pulsante alcune
centinaia di volte e ne modifica di conseguenza lo stato. Per questo, i risultati
finiscono per essere imprevedibili; il LED potrebbe apparire spento quando lo
vogliamo acceso o viceversa. Dato che perfino un orologio rotto dice la verità due
volte al giorno, il programma qualche volta potrebbe mostrare il comportamento
corretto, ma nella maggior parte dei casi no.
Come lo risolviamo? Bene, dobbiamo riconoscere il momento esatto in cui è

premuto il pulsante, che è l’unico momento in cui dobbiamo cambiare lo stato.
A me piace farlo salvando il valore di val prima di leggerne uno nuovo; in questo
modo posso confrontare la posizione corrente del pulsante con quella precedente
e cambiare lo stato solo quando il pulsante diventa HIGH dopo essere stato LOW.
L’Esempio 03B contiene il codice per farlo:

// Esempio 03B: Accende il LED quando è premuto il pulsante
// Ora con una nuova formula migliore!

// del pin di input
int old_val = 0; // questa variabile conserva il valore
// precedente di "val"
int state = 0; // 0 = LED spento e 1 = LED acceso
void setup() {
}
void loop(){
val = digitalRead(BUTTON); // legge il valore dell'input
// e lo conserva
// controlla se è avvenuta una transizione

if ((val == HIGH) && (old_val == LOW)){
state = 1 - state;
}
old_val = val; // memorizza il valore precedente di val
if (state == 1) {
} else {
}
}
Provatelo: ci siamo quasi!
Avrete notato che questo approccio non è perfetto, per via di un altro problema
degli interruttori meccanici. I pulsanti sono dispositivi molto semplici: due parti di

metallo separate da una molla. Quando premete il pulsante, i due contatti si tocca-
no e l’elettricità può fluire. Questo suona facile, ma nella vita reale il collegamento
non è così perfetto, specie quando il pulsante non è premuto completamente, e
genera dei segnali spuri detti rimbalzi (bouncing).
Quando il pulsante produce questi segnali, Arduino vede una sequenza molto rapi-
da di segnali acceso-spento. Per evitarlo sono state sviluppate molte tecniche, ma
in questo semplice codice ho notato che normalmente basta aggiungere un ritardo
di 10/50 millisecondi quando il codice rileva una transizione.
L’Esempio 03C mostra il codice finale:

// Esempio 03C: Accende il LED quando è premuto il pulsante
// includendo un semplice antirimbalzo (de-bouncing)
// Ora con un'altra formula nuova e migliore!!

// del pin di input
int old_val = 0; // questa variabile conserva il valore
// precedente di "val"
int state = 0; // 0 = LED spento e 1 = LED acceso
void setup() {
}
void loop(){
// e lo conserva

if ((val == HIGH) && (old_val == LOW)){
state = 1 - state;
delay(10);
}
if (state == 1) {
} else {
}
}

5/Input e output
avanzati
Nel Capitolo 4 avete imparato le operazioni più
elementari che si possono eseguire in Arduino:
controllare gli output digitali e leggere gli input
digitali. Se Arduino fosse un tipo di linguaggio
umano, queste sarebbero due lettere del suo
alfabeto. Immaginando che nell’alfabeto ci siano
solo cinque lettere, potete immaginare quanto
lavoro ci resta da fare prima di poter scrivere una
poesia con Arduino.
Provare altri sensori On/Off

Ora che avete imparato a usare un pulsante, dovreste sapere che esistono molti
altri sensori molto semplici che funzionano basandosi sullo stesso principio:
Interruttori
Sono come i pulsanti, ma non cambiano automaticamente lo stato quando vengo-
no rilasciati.
Termostati
Interruttori che si aprono quando la temperatura raggiunge un determinato valore.
Interruttori magnetici (detti anche “reed relay”)

Hanno due contatti che si uniscono quando sono vicino a una calamita; vengono
usati negli antifurti per riconoscere quando viene aperta una finestra.
Sensori a tappeto (carpet switch)

Piccole placche che si possono posizionare sotto a un tappeto o a uno zerbino per
rilevare la presenza di un essere umano (o di un gatto pesante).
Input e output avanzati 51

Interruttori a inclinazione (tilt switch)
Un semplice componente elettronico che contiene due contatti e una pallina di
metallo (o una goccia di mercurio, ma non consiglio di usare quelli di questo tipo)
Un esempio di interruttore a inclinazione è il cosiddetto sensore di inclinazione (tilt
sensor). La Figura 5-1 mostra l’interno di un modello tipico. Quando il sensore è
nella posizione normale, la pallina fa da ponte trai due contatti e funziona proprio
come se si fosse premuto un pulsante. Quando si inclina questo sensore, la pallina
si muove e il contatto viene aperto, proprio come quando si rilascia un pulsante.
Usando questo semplice componente, si possono implementare, per esempio,
interfacce gestuali che reagiscono quando un oggetto viene spostato o scosso.
Figura 5-1.
L’interno di un sensore di inclinazione

Un altro sensore che potreste provare è quello a infrarossi che si trova negli
antifurti (noto anche come infrarosso passivo o sensore PIR, Figura 5-2). Questo
piccolo dispositivo si aziona quando un essere umano (o un altro essere vivente) si
muove nei suoi pressi. È un modo semplice di rilevare il movimento.
Figura 5–2.
Un tipico sensore PIR

Ora dovreste fare degli esperimenti osservando tutti i dispositivi possibili che
presentino due contatti che si chiudono, come il termostato che imposta la tempe-
ratura della stanza (usatene uno vecchio che non è più collegato) o semplicemente
collocando due contatti uno accanto all’altro e facendovi gocciolare in mezzo
dell’acqua. Per esempio, usando l’esempio finale del Capitolo 4 e un sensore PIR,
potete fare in modo che la vostra lampada risponda alla presenza degli esseri
umani o potreste usare un interruttore a mercurio per costruirne una che si spenga
quando viene girata su un lato.
Controllare la luce con la PWM

Con le conoscenze che avete acquisito fin qui, potreste costruire una lampada
interattiva che può essere controllata non solo da un noioso interruttore on/off,
ma magari in un modo un po’ più elegante. Uno dei limiti degli esempi del LED
che lampeggia che abbiamo usato finora è che permettono solo di accendere o
spegnere la luce. Una lampada più interattiva deve essere regolabile. Per risolvere
questo problema, possiamo usare un trucchetto che rende possibili molte cose,
come la TV o il cinema: la persistenza della visione.
Come ho suggerito dopo il primo esempio del Capitolo 4, se cambiate i numeri

della funzione del ritardo fino a non vedere più lampeggiare il LED, noterete che
il LED sembra accendersi al 50% della sua luminosità normale. Ora cambiate i
numeri in modo che il LED sia acceso un quarto del tempo che trascorre spento.
Eseguite lo sketch e vedrete che la luminosità è appena al 25%. Questa tecnica
viene detta modulazione di larghezza di impulso (PWM, Pulse Width Modula-
tion), un modo originale di dire che se si fa lampeggiare un LED abbastanza rapida-
mente, non lo si vede più lampeggiare, ma se ne riesce a modificare la luminosità
cambiando il rapporto tra il tempo in cui sta acceso e quello in cui sta spento. La
Figura 5-3 mostra come funziona.
Questa tecnica funziona anche con dispositivi diversi dai LED. Per esempio, nello
stesso modo si può cambiare la velocità di un motore.
Facendo esperimenti, vedrete che far lampeggiare il LED inserendo dei ritardi nel
codice è un po’ scomodo, perché appena si vuole leggere un sensore o inviare dei
dati su una porta seriale, il LED tremolerà mentre è in attesa che finiate di leggere
il sensore. Fortunatamente, il processore che usa la scheda Arduino è dotato di
un hardware che può far lampeggiare in modo efficiente tre LED mentre lo sketch
fa qualcos’altro. Questo hardware è implementato nei pin 9, 10 e 11, che possono
essere controllati con l’istruzione analogWrite().

Figura 5-3.
La PWM in azione

Per esempio, scrivendo analogWrite(9,128) si imposta la luminosità di un LED
collegato nel pin 9 su 50%. Perché 128? analogWrite() come argomento si aspetta
un numero compreso tra 0 e 255, dove 255 rappresenta la massima luminosità e 0
significa spento.
NotA: Disporre di tre canali è un gran vantaggio, perché se si comprano dei

LED rosso, verde e blu, si possono mescolare le loro luci e creare una luce
del colore che si desidera!
Proviamo. Costruite il circuito che vedete nella Figura 5-4. Notate che i LED sono
polarizzati: il pin lungo (positivo) dovrebbe andare a destra e quello corto (negativo)
a sinistra. Inoltre, la maggior parte dei LED presenta la parte negativa appiattita,
come mostra la figura.
Figura 5-4.
Un LED collegato a un pin PWM

Quindi, create un nuovo sketch in Arduino e usate l’Esempio 04 (potete anche
scaricare gli esempi di codice da www.makezine.com/getstartedarduino):
// Esempio 04: Far accendere e spegnere lentamente un LED

// come nella luce di stop dei computer Apple

int i = 0; // la useremo per contare avanti e indietro
void setup() {
}
void loop(){
for (i = 0; i < 255; i++) { // procede ciclicamente da 0 a 254 (fade in)

analogWrite(LED, i); // imposta la luminosità del LED
delay(10); // aspetta 10ms perché analogWrite
// è istantaneo e non
// vedremmo il cambiamento
}
for (i = 255; i > 0; i--) { // procede ciclicamente da 255 a 1 (fade out)
analogWrite(LED, i); // imposta la luminosità del LED

delay(10); // aspetta 10ms
}
Ora avete replicato una funzionalità dei computer portatili (anche se usare Arduino
per così poco sarebbe un po’ uno spreco). Usiamo questa conoscenza per miglio-
rare la nostra lampada.
Aggiungete il circuito che abbiamo usato per leggere un pulsante (nel Capitolo 4)
a questa breadboard. Provate a farlo senza guardare la prossima pagina, perché
voglio che cominciate a realizzare che ogni circuito elementare che mostro qui è
un “blocco costitutivo” per creare progetti sempre più grandi. Se per procedere
avete bisogno di qualche suggerimento, non importa; la cosa più importante è che
dedichiate un po’ di tempo a pensare come dovrebbe presentarsi.

Per creare questo circuito, dovrete combinare il circuito che avete appena costrui-
to (mostrato nella Figura 5-4) con quello del pulsante mostrato nella Figura 4-6. Se
volete, potete limitarvi a costruire entrambi i circuiti su parti diverse della bread-
board; avete spazio a sufficienza. In ogni caso, uno dei vantaggi delle breadboard
(Appendice A) è che sono dotate di due piste di alimentazione che le attraversano
orizzontalmente in basso e in alto. Una è contrassegnata con il rosso (per il positi-
vo) e l’altra con il blu o il nero (per la messa a terra).
Queste piste servono per distribuire l’alimentazione e la terra dove è necessario.

Nel caso del circuito che dovete costruire per questo esempio, avete due com-
ponenti (entrambi resistenze) che vanno collegati al pin GND (terra) di Arduino.
Dato che Arduino è dotato di due pin GND, potete collegare questi due circuiti
semplicemente ed esattamente come mostrato in ciascuna delle due figure; basta
collegarli entrambi contemporaneamente ad Arduino. In alternativa, potete collega-
re un cavo dalla linea di terra della breadboard a uno dei pin GND di Arduino e poi
prendere i cavi collegati a GND nelle figure e collegarli invece alla pista di terra
della breadboard.
Se non siete pronti per provarci, non vi preoccupate: limitatevi a collegare entram-
bi i circuiti ad Arduino come mostrano le Figure 4-6 e 5-4. Nel Capitolo 6 vedrete
un esempio dove si usano le piste di terra e di alimentazione della breadboard.
Tornando al nostro prossimo esempio, se abbiamo solo un pulsante, come con-

trolliamo la luminosità della lampada? Stiamo per imparare un’ulteriore tecnica di
interaction design: rilevare per quanto a lungo è rimasto premuto un pulsante. Per
farlo, devo aggiornare l’Esempio 03C del Capitolo 4 aggiungendovi la regolazione.
L’idea è costruire un’“interfaccia” in cui le azioni di premere e rilasciare azionino
l’accensione e lo spegnimento della luce, mentre le azioni di premere e tenere
premuto modifichino la luminosità.
Diamo un’occhiata allo sketch:

// Esempio 05: Accende il LED quando è premuto il pulsante
// includendo un semplice antirimbalzo (de-bouncing).
// Se il pulsante rimane premuto, cambia la luminosità.

#define BUTTON 7 // pin di input del pulsante
int val = 0; // conserva lo stato del pin di input
int old_val = 0; // conserva il valore precedente di “val”

int state = 0; // 0 = LED spento mentre 1 = LED acceso
int brightness = 128; // conserva il valore della luminosità

unsigned long startTime = 0; // quando è cominciata la pressione?
void setup() {
}
void loop() {

// e lo conserva

if ((val == HIGH) && (old_val == LOW)) {
state = 1 - state; // cambia lo stato da spento ad acceso

// o viceversa
startTime = millis(); // millis() è l'orologio di Arduino

// che restituisce quanti millisecondi
// sono passati da quando è stata
// resettata la scheda.
// (questa riga ricorda quando è stato premuto

// il pulsante l'ultima volta)
delay(10);
}

// verifica che il pulsante sia ancora premuto
if ((val == HIGH) && (old_val == HIGH)) {
// se il pulsante è premuto per più di 500ms

if (state == 1 && (millis() - startTime) > 500) {
brightness++; // incrementa la luminosità di 1

delay(10); // ritardo per evitare che la luminosità
// aumenti troppo rapidamente
if (brightness > 255) { // 255 è la luminosità massima
brightness = 0; // se va oltre 255

// torna a 0
}
}
}
if (state == 1) {
analogWrite(LED, brightness); // accende il LED
// al livello corrente di luminosità
} else {
analogWrite(LED, 0); // spegne il LED
}
}
Ora provate. Come potete vedere, il nostro modello di interazione sta prenden-
do forma. Se si preme e si rilascia immediatamente il pulsante, si accende o si
spegne la lampada. Se si tiene premuto il pulsante, cambia la luminosità; quando
avete raggiunto la luminosità desiderata, basta rilasciarlo.
Ora vediamo come usare dei sensori più interessanti.
Usare un sensore di luce invece del pulsante

Ora proveremo un esperimento interessante. Prendete un sensore di luce, come
l’articolo 276-1657 (pacco da 5) di RadioShack (www.radioshack.com); il sensore
è mostrato nella Figura 5-5.

Figura 5-5.
Un fotoresistore, detto anche LDR (Light Dependent Resistor)
Nell’oscurità, la resistenza di un LDR (Light Dependent Resistor) è piuttosto alta.

Quando vi si punta una luce, la resistenza scende rapidamente e diventa un con-
duttore di elettricità ragionevolmente buono. È dunque una sorta di interruttore
che si attiva con la luce.
Costruite il circuito dell’Esempio 02 (“Usare un pulsante per controllare il LED” nel

Capitolo 4) e poi caricate su Arduino il codice dell’Esempio 02.
Ora nella breadboard, anziché il pulsante, collegate l’LDR. Noterete che, se coprite
l’LDR con le mani, il LED si spegne. Se scoprite l’LDR, la luce si accende. Avete
appena costruito il vostro primo LED gestito da un vero sensore. Questo è impor-
tante perché, per la prima volta in questo libro, stiamo usando un componente che
non è un semplice dispositivo meccanico, ma un sensore vero e proprio.

Gli input analogici
Come avete imparato nel paragrafo precedente, Arduino è in grado di rilevare se
su uno dei suoi pin è applicato un voltaggio e di riportarlo grazie alla funzione
digitalRead(). Questo genere di risposta va bene in moltissime applicazioni, ma il
sensore di luce che abbiamo appena usato è capace di comunicarci non solo se
c’è luce, ma anche quanta ce n’è. Questa è la differenza tra un sensore on/off
(che ci dice se c’è qualcosa) e un sensore analogico, il cui valore cambia continua-
mente. Per leggere questo tipo di sensore, ci serve un tipo diverso di pin.
Nella parte in basso a destra della scheda Arduino, appaiono sei pin contrasse-
gnati “Analog In”; si tratta di pin speciali che possono dirci non solo se su di loro
è applicato un voltaggio, ma, in caso positivo, anche il suo valore. Usando la fun-
zione analogRead(), possiamo leggere il voltaggio applicato a uno dei pin. Questa
funzione restituisce un numero compreso tra 0 e 1023, che rappresenta voltaggi
compresi tra 0 e 5 volt. Per esempio, se sul pin numero 0 è applicato un voltaggio
pari a 2,5 V, analogRead(0) restituisce 512.
Se ora costruite il circuito che vedete nella Figura 5-6, usando una resistenza 10k,
ed eseguite il codice dell’Esempio 06A, vedrete il LED incorporato (ma potete an-
che inserire un vostro LED nei pin 13 e GND come mostrato in “Far lampeggiare
un LED” nel Capitolo 4) lampeggiare a un ritmo condizionato dalla quantità di luce
che colpisce il sensore.

Figura 5-6.
Un circuito con un sensore analogico

// Esempio 06A: Far lampeggiare un LED a un ritmo specificato
// dal valore dell'input analogico
int val = 0; // variabile usata per conservare il valore

// che proviene dal sensore
void setup() {
pinMode(LED, OUTPUT); // LED è un OUTPUT
// Nota: I pin analogici sono

// impostati automaticamente come input
}
void loop() {
val = analogRead(0); // legge il valore proveniente

// dal sensore
digitalWrite(13, HIGH); // accende il LED
delay(val); // interrompe il programma per un tempo

// legato al valore proveniente dal sensore
digitalWrite(13, LOW); // spegne il LED
delay(val); // interrompe il programma per un tempo

// legato al valore proveniente dal sensore
}
Ora, provate l’Esempio 06B: ma, prima, dovete modificare il vostro circuito. Date
di nuovo un’occhiata alla Figura 5-4 e collegate il LED nel pin 9 come mostrato.
Dato che sulla breadboard ci sono già altre cose, dovete trovare un’area dove il
LED, i cavi e la resistenza non si sovrappongano al circuito dell’LDR.

// Esempio 06B: Impostare la luminosità di un LED
// su una luminosità specificata
// dal valore dell'input analogico
int val = 0; // variabile usata per conservare il valore

// che proviene dal sensore
void setup() {
pinMode(LED, OUTPUT); // LED è un OUTPUT
// Nota: I pin analogici sono

// impostati automaticamente come input
}
void loop() {
val = analogRead(0); // legge il valore proveniente

// dal sensore
analogWrite(LED, val/4); // accende il LED
// con la luminosità impostata
// dal sensore
delay(10); // interrompe il programma

// per 10 ms
}
NOTA: specifichiamo la luminosità dividendo val per 4, perché

analogRead() restituisce un numero fino a 1023, mentre analogWrite()
accetta come massimo 255.

Provare altri sensori analogici
Usando lo stesso circuito che abbiamo visto nel paragrafo precedente, potete
collegare moltissimi altri sensori resistivi che funzionano più o meno allo stesso
modo. Per esempio, potete collegare un termistore, un semplice dispositivo la cui
resistenza varia con la temperatura. Nel circuito, ho mostrato come le modifiche
della resistenza diventano modifiche del voltaggio che possono essere misurate
da Arduino.
Se lavorate con un termistore, fate attenzione al fatto che non esiste un collega-
mento diretto tra il valore che si legge e la temperatura vera e propria misurata.
Se vi serve una lettura esatta, dovete leggere i numeri che provengono dal pin
analogico mentre misurate con un termometro vero. Poi potete rappresentare que-
sti numeri in una tabella ed elaborare un criterio per tarare i risultati analogici sulle
temperature del mondo reale.
Finora, come dispositivo di output abbiamo usato solo un LED, ma come facciamo
a vedere i veri valori che Arduino legge dal sensore? Non possiamo fare in modo
che la scheda li comunichi lampeggiando in codice Morse (insomma, potremmo,
ma per gli esseri umani esiste un modo più facile per leggere i valori). Per questo,
dobbiamo fare in modo che Arduino parli con il computer attraverso una porta
seriale, come spiegato nel prossimo paragrafo.
La comunicazione seriale
All’inizio di questo libro avete imparato che Arduino è dotato di un collegamento
USB che viene usato dall’IDE per caricare il codice nel processore. La buona noti-
zia è che questo collegamento può essere usato anche dagli sketch che scriviamo
in Arduino per restituire dei dati al computer o per ricevere dei suoi comandi. A
questo scopo, stiamo per usare un oggetto seriale (un oggetto è una raccolta di
capacità impacchettate insieme per la comodità di chi deve scrivere gli sketch).
Questo oggetto contiene tutto il codice che ci serve per spedire e ricevere dati.
Adesso useremo l’ultimo circuito che abbiamo costruito con la fotoresistenza e in-
vieremo al computer i valori che vi vengono letti. Digitate questo codice in un nuo-
vo sketch (potete anche scaricarlo da www.makezine.com/getstartedarduino):

// Esempio 07: Inviare al computer i valori letti
// dall'input analogico 0
// Dopo l’upload assicuratevi di
// fare clic su "Serial Monitor"
#define SENSOR 0 // seleziona il pin di input per il

// sensore resistivo
int val = 0; // variabile per conservare il valore proveniente

// dal sensore
void setup() {
Serial.begin(9600); // apre la porta seriale per inviare

// dati al computer
// a 9600 bit al secondo
}
void loop() {
val = analogRead(SENSOR); // legge il valore proveniente

// dal sensore
Serial.println(val); // stampa il valore sulla

// porta seriale
delay(100); // tra un invio e l’altro

// aspetta 100ms
}
Dopo aver caricato il codice su Arduino, fate clic sul pulsante “Serial Monitor”
nell’IDE Arduino (il pulsante più a destra della barra strumenti); nella parte in
basso della finestra cominceranno a scorrere dei numeri. Ora, tutti i software
che sono in grado di leggere dati dalla porta seriale possono comunicare con
Arduino. Esistono molti linguaggi di programmazione che permettono di scrive-
re programmi sul computer in grado di dialogare con la porta seriale. Proces-
sing (www.processing.org) è un ottimo complemento per Arduino, perché i
linguaggi e gli IDE sono molto simili.

Gestire carichi maggiori (motori, lampade
e simili)
Ciascuno dei pin della scheda Arduino può essere usato per alimentare dispositivi
che usino fino a 20 milliampere: si tratta di una quantità di corrente molto piccola,
sufficiente appena per illuminare un LED. Se si prova a gestire qualcosa come un
motore, il pin smette immediatamente di funzionare e potrebbe anche bruciare
l’intero processore. Per gestire carichi maggiori come motori o lampade a incande-
scenza, dobbiamo usare un componente esterno che sia in grado di accendere e
spegnere questo genere di cose e che sia alimentato da un pin di Arduino. I dispo-
sitivi di questo genere si chiamano transistor MOSFET (il nome fa un po’ ridere):
interruttori elettronici che possono essere alimentati applicando un voltaggio su
uno dei loro tre pin, ognuno dei quali è detto gate. Sono come gli interruttori della
luce che usiamo a casa, ma in questo caso il gesto del dito che accende o spegne
la luce è sostituito da un pin sulla scheda Arduino che invia del voltaggio al gate
del MOSFET.
NotA: MOSFET significa “metal–oxide–semiconductor field-effect tran-

sistor” (transistor a effetto di campo metallo-ossido-semiconduttore). Si
tratta di un tipo speciale di transistor che opera basandosi sul principio
dell’effetto di campo. Questo significa che, quando sul pin gate viene
applicato un voltaggio, l’elettricità fluisce attraverso un materiale semicon-
duttore (tra i pin drain e source). Dato che il gate è isolato dal resto da uno
strato di ossido di metallo, la corrente non fluisce da Arduino al MOSFET,
rendendolo molto semplice da interfacciare. I MOSFET sono ideali per
accendere e spegnere grandi carichi ad altre frequenze.
Nella Figura 5-7, potete vedere come usare un MOSFET come l’IRF520 per
accendere e spegnere un piccolo motore collegato a un ventilatore. Noterete
anche che il motore viene alimentato dal connettore a 9 V sulla scheda Arduino.
Questo è un altro vantaggio offerto dai MOSFET: permettono di gestire dispositivi
la cui alimentazione è diversa da quella usata da Arduino. Dato che il MOSFET è
collegato al pin 9, per controllare la velocità del motore via PWM possiamo anche
usare analogWrite().
Sensori complessi
Definiamo sensori complessi quelli che producono un tipo di dato che richiede
l’uso di qualcosa in più rispetto alle funzioni digitalRead() o analogRead(). Di solito

si tratta di piccoli circuiti con un piccolo microcontroller al loro interno che elabora
preliminarmente i dati.
Alcuni dei sensori complessi reperibili sono misuratori a ultrasuoni, misuratori a

infrarossi e accelerometri. Alcuni esempi su come usarli sono disponibili nella
sezione “Tutorials” del nostro sito (www.arduino.cc/en/Tutorial/HomePage).
Making Things Talk (O’Reilly) di Tom Igoe (O’Reilly) spiega approfonditamente

questi sensori e molti altri sensori complessi.
Figura 5-7.
Il circuito di un motore per Arduino

6/Comunicare
con la Rete
Nei capitoli precedenti, abbiamo visto i concetti
fondamentali di Arduino e i blocchi costitutivi
disponibili. Lasciate che vi offra un ripasso
dell’“alfabeto di Arduino”:
Output digitale
L’abbiamo usato per controllare un LED ma, con un circuito appropriato, può esse-
re usato per controllare motori, produrre suoni e molto altro ancora.
Output analogico
Ci offre la possibilità di controllare la luminosità del LED, non solo di accenderlo e
spegnerlo. Con questo possiamo addirittura controllare la velocità di un motore.
Input digitale
Questo ci permette di leggere lo stato di sensori semplici, come pulsanti o inter-
ruttori a mercurio.
Input analogico
Possiamo leggere i segnali continui inviati dai sensori che non si limitano a segna-
lare gli stati acceso/spento, come i potenziometri o i sensori di luce.
Comunicazione seriale
Ci permette di comunicare con un computer e scambiare dati o semplicemente
controllare cosa sta succedendo nello sketch che viene eseguito su Arduino.
In questo capitolo, vedremo come comporre un’applicazione funzionante usan-

do quanto abbiamo imparato nei capitoli precedenti. Questo capitolo dovrebbe
mostrarvi come ciascun singolo esempio può fungere da blocco costitutivo di un
progetto complesso. Qui viene fuori l’aspirante designer che è in noi. Creeremo la
versione del ventunesimo secolo della classica lampada del mio designer italiano
preferito, Joe Colombo. L’oggetto che stiamo per costruire si ispira a una lampada
di nome “Aton” del 1964.
Comunicare con la Rete 71

Figura 6-1.
La lampada finita
La lampada, come potete vedere nella Figura 6-1, è una semplice sfera collocata
su una base con un ampio buco che le impedisca di rotolare sul tavolo. Questo
design permette di orientare la lampada in varie direzioni.
In termini di funzionalità, vogliamo costruire un dispositivo che si colleghi a Inter-

net, ricavi l’elenco aggiornato di articoli del blog Make (blog.makezine.com) e
conti quante volte sono citate le parole “peace”, “love” e “Arduino”. Con questi
valori, genereremo un colore e lo mostreremo nella lampada. La lampada è dotata
di un pulsante che possiamo usare per accenderla e spegnerla e di un sensore di
luce per la sua attivazione automatica.

Pianificazione
Diamo un’occhiata a dove vogliamo arrivare e a cosa ci serve. Innanzitutto, ci ser-
ve che Arduino possa collegarsi a Internet. Dato che la scheda Arduino è dotata
solo di una porta USB, non possiamo collegarla direttamente a una connessione
a Internet, quindi dobbiamo scoprire come costruire un ponte tra le due cose. Di
solito si esegue un applicazione su un computer che si colleghi a Internet, elabori i
dati e mandi ad Arduino solo alcune informazioni selezionate.
Arduino è un computer semplice con poca memoria; non è in grado di elaborare

facilmente file molto grandi e quando ci colleghiamo a un feed RSS ricaviamo
lunghi file XML che avrebbero bisogno di molta più RAM. Quindi implementeremo
un proxy che semplifichi l’XML usando il linguaggio Processing.
Processing
Processing è l’origine di Arduino. Questo linguaggio ci piace moltissimo e
lo usavamo per insegnare la programmazione ai principianti oltre che per
costruire codice bellissimo. Processing e Arduino sono una combinazione
perfetta. Un altro vantaggio è che Processing è open source e gira su tutte le
piattaforme principali (Mac, Linux e Windows). È in grado anche di generare
applicazioni indipendenti per queste stesse piattaforme. Inoltre, la comunità
di Processing è attiva e generosa e permette di trovare molti programmi di
esempio già pronti.
Ecco cosa fa il proxy per noi: scarica il feed RSS da makezine.com ed estrae
tutte le parole dal file XML che ottiene. Quindi, analizzandolo, conta il numero di
volte che nel testo appaiono le parole “peace”, “love” e “Arduino”. Con questi
tre numeri, calcoleremo il valore di un colore e lo invieremo ad Arduino. La sche-
da ci restituirà la quantità di luce misurata dal sensore e la mostrerà sullo scher-
mo del computer.
Dal lato hardware, combineremo l’esempio del pulsante, quello del sensore di
luce, il controllo del LED via PWM (moltiplicato per 3!) e la comunicazione seriale.
Dato che Arduino è un dispositivo semplice, dovremo codificare il colore in un
modo semplice. Useremo il modo standard in cui si rappresentano i colori in
HTML: # seguito da sei cifre esadecimali. I numeri esadecimali sono pratici, per-
ché ciascun numero di 8 bit viene rappresentato esattamente da due caratteri; nel
caso dei numeri decimali, variano da uno a tre caratteri. Prevedibilmente, anche il
codice diventa quindi più semplice: aspettiamo di vedere un #, poi leggiamo i sei
caratteri che seguono in un buffer (una variabile usata come contenitore temporaneo
per questi dati). Infine, convertiamo ciascun gruppo di due caratteri in un byte che
rappresenti la luminosità di uno di tre LED.

Il codice
Eseguiremo due sketch: uno sketch di Processing e uno di Arduino. Ecco il
codice dello sketch di Processing. Potete scaricarlo da www.makezine.com/
getstartedarduino.
// Esempio 08A: Arduino, lampada in rete

// parti del codice sono ispirate
// a un post di Tod E. Kurt (todbot.com)
import processing.serial.*;
String feed = "http://blog.makezine.com/index.xml";
int interval = 10; // estrae il feed ogni 60 secondi;

int lastTime; // l'ultima volta che abbiamo estratto il contenuto
int love = 0;
int peace = 0;
int arduino = 0;
int light = 0; // livello della luce misurato dalla lampada
Serial port;
color c;
String cs;
String buffer = ""; // Accumula i caratteri che provengono da Arduino
PFont font;
void setup() {
size(640,480);
frameRate(10); // non ci servono aggiornamenti troppo veloci
font = loadFont("HelveticaNeue-Bold-32.vlw");
fill(255);
textFont(font, 32);
// NOTA IMPORTANTE:
// La prima porta seriale ricavata da Serial.list()
// dovrebbe essere quella del vostro Arduino. Se no, togliete

// le linee di commento // che precedono la riga che segue questo
// commento ed eseguite di nuovo lo sketch per vedere un elenco
// di porte seriali. Quindi, sostituite lo 0 tra [ e ]
// con il numero di porta cui è collegato il vostro Arduino.
//println(Serial.list());
String arduinoPort = Serial.list()[0];
port = new Serial(this, arduinoPort, 9600); // si collega ad Arduino
lastTime = 0;
fetchData();
}
void draw() {
background( c );
int n = (interval - ((millis()-lastTime)/1000));
// Costruisce un colore basato su 3 valori

c = color(peace, love, arduino);
cs = "#" + hex(c,6); // Prepara una stringa da inviare ad Arduino
text("Arduino Networked Lamp", 10,40);

text("Reading feed:", 10, 100);
text(feed, 10, 140);
text("Next update in "+ n + " seconds",10,450);

text("peace" ,10,200);
text(" " + peace, 130, 200);
rect(200,172, peace, 28);
text("love ",10,240);
text(" " + love, 130, 240);
rect(200,212, love, 28);
text("arduino ",10,280);
text(" " + arduino, 130, 280);
rect(200,252, arduino, 28);
// scrive la stringa del colore sullo schermo

text("sending", 10, 340);
text(cs, 200,340);

text("light level", 10, 380);
rect(200, 352,light/10.23,28); // converte 1023 in 100
if (n <= 0) {
fetchData();
lastTime = millis();
}
port.write(cs); // invia i dati ad Arduino
if (port.available() > 0) { // controlla se ci sono dei dati in attesa

int inByte = port.read(); // legge un byte
if (inByte != 10) { // se il byte non è un LINE FEED
buffer = buffer + char(inByte); // lo aggiunge nel buffer
}
else {
// raggiunto il LINE FEED, elaboriamo i dati

if (buffer.length() > 1) { // verifichiamo che ci siano
// abbastanza dati
// elimina l’ultimo carattere, che è un a capo

// (un a capo è il carattere alla fine di una linea di testo)
buffer = buffer.substring(0,buffer.length() -1);
// converte il buffer da stringa a numero intero

light = int(buffer);
// svuota il buffer per il prossimo ciclo di lettura

buffer = "";
// Probabilmente nel leggere i dati che invia Arduino

// stiamo rimanendo indietro. Quindi svuotiamo il backlog
// delle letture che provengono dal sensore in modo che
// la prossima sia aggiornata.
port.clear();
}
}
}

void fetchData() {
// usiamo queste stringhe per fare il parsing del feed
String data;
String chunk;
// azzeriamo i contatori
love = 0;
peace = 0;
arduino = 0;
try {
URL url = new URL(feed); // un oggetto per rappresentare l'URL
// prepariamo un collegamento
URLConnection conn = url.openConnection();
conn.connect(); // ora ci colleghiamo al sito web
// si tratta di un'azione idraulica virtuale, dato che colleghiamo

// i dati che provengono dalla connessione a un lettore dotato
// di buffer che legge i dati una linea alla volta.
BufferedReader in = new
BufferedReader(new InputStreamReader(conn.getInputStream()));
// legge ciascuna linea del feed

while ((data = in.readLine()) != null) {
StringTokenizer st =
new StringTokenizer(data,"\"<>,.()[] ");// la suddivide
while (st.hasMoreTokens()) {
// ogni porzione di dati viene scritta tutta in minuscole
chunk= st.nextToken().toLowerCase() ;
if (chunk.indexOf("love") >= 0 ) // trovato "love"?

love++; // incrementa love di 1
if (chunk.indexOf("peace") >= 0) // trovato "peace"?
peace++; // incrementa peace di 1
if (chunk.indexOf("arduino") >= 0) // trovato "arduino"?
arduino++; // incrementa arduino di 1
}
}
// Imposta 64 come numero massimo di occorrenze che ci interessano.

if (peace > 64) peace = 64;

if (love > 64) love = 64;
if (arduino > 64) arduino = 64;
peace = peace * 4; // moltiplica per 4 in modo che il massimo

// sia 255,
love = love * 4; // che si rivela utile quando
// dobbiamo costruire
arduino = arduino * 4; // un colore composto da 4 byte (ARGB)
}
catch (Exception ex) { // Se si verifica un errore,
// interrompe lo sketch
ex.printStackTrace();
System.out.println("ERROR: "+ex.getMessage());
}
Perché lo sketch di Processing venga eseguito correttamente, prima dovete fare

due cose. Innanzitutto, dovete chiedere a Processing di generare il font utilizzato
per lo sketch. Per farlo, create e salvate questo sketch. Quindi, con lo sketch
ancora aperto, fate clic sul menu Tools di Processing e scegliete Create Font.
Selezionate il font di nome HelveticaNeue-Bold, assegnate al font una dimensione
pari a 32 e fate clic su OK.
Secondo, dovete confermare che lo sketch sta usando la porta seriale corretta per
comunicare con Arduino. E per farlo dovete aspettare di aver assemblato il circuito
di Arduino e caricato lo sketch di Arduino. Nella maggior parte dei sistemi, questo
sketch di Processing non darà problemi. Ma se non vedete succedere niente
su Arduino e sullo schermo non vi appare nessun dato proveniente dal sensore
di luce, cercate il commento dal titolo “NOTA IMPORTANTE” nello sketch di
Processing e seguite le istruzioni che fornisce.
Ecco lo sketch di Arduino (disponibile anche su www.makezine.com/

getstartedarduino):

// Esempio 08B: Arduino, lampada in rete
#define SENSOR 0
#define R_LED 9
#define G_LED 10
#define B_LED 11
#define BUTTON 12
int val = 0; // variabile per conservare il valore che proviene dal sensore
int btn = LOW;

int old_btn = LOW;
int state = 0;
char buffer[7] ;
int pointer = 0;
byte inByte = 0;
byte r = 0;
byte g = 0;
byte b = 0;
void setup() {
Serial.begin(9600); // apre la porta seriale
pinMode(BUTTON, INPUT);
}
void loop() {
val = analogRead(SENSOR); // legge il valore proveniente dal sensore
Serial.println(val); // stampa il valore sulla
// porta seriale
if (Serial.available() >0) {
// legge il byte che arriva:

inByte = Serial.read();
// Se trova il marcatore, i 6 caratteri seguenti sono il colore

if (inByte == '#') {
while (pointer < 6) { // accumula 6 caratteri

buffer[pointer] = Serial.read(); // li inserisce nel buffer
pointer++; // sposta il puntatore avanti di 1
}

// ora disponiamo dei 3 numeri salvati come numeri esadecimali
// dobbiamo decodificarli in 3 byte r, g e b
r = hex2dec(buffer[1]) + hex2dec(buffer[0]) * 16;
g = hex2dec(buffer[3]) + hex2dec(buffer[2]) * 16;
b = hex2dec(buffer[5]) + hex2dec(buffer[4]) * 16;
pointer = 0; // resetta il puntatore per riutilizzare il buffer
}
}
btn = digitalRead(BUTTON); // legge il valore dell’input e lo conserva

if ((btn == HIGH) && (old_btn == LOW)){
state = 1 - state;
}
old_btn = btn; // memorizza il valore precedente di btn
if (state == 1) { // se la lampada è accesa
analogWrite(R_LED, r); // i led si accendono

analogWrite(G_LED, g); // con il colore
analogWrite(B_LED, b); // inviato dal computer
} else {
analogWrite(R_LED, 0); // altrimenti si spengono

analogWrite(G_LED, 0);
analogWrite(B_LED, 0);
}
delay(100); // aspetta 100ms tra ogni invio

}
int hex2dec(byte c) { // converte un carattere esadecimale in un numero

if (c >= '0' && c <= '9') {
return c - '0';
} else if (c >= 'A' && c <= 'F') {
return c - 'A' + 10;
}
}

Assemblare il circuito
La Figura 6-2 mostra come assemblare il circuito. Per tutte le resistenze che ap-
paiono nel diagramma, dovete usare una resistenza 10K, anche se nel caso delle
resistenze collegate ai LED potreste cavarvela con valori inferiori.
Ricordate che nell’esempio della PWM nel Capitolo 5 abbiamo visto che i LED
sono polarizzati: in questo circuito, il pin lungo (positivo) dovrebbe andare a destra
e quello corto (negativo) a sinistra (la maggior parte dei LED nel lato negativo sono
appiattiti, come si vede nella figura).
Figura 6-2.
Il circuito della “Lampada in rete fatta con Arduino”

Costruite il circuito come mostrato, usando un LED rosso, uno verde e uno blu.
Poi, caricate gli sketch in Arduino e Processing, eseguiteli e provate. Se si verifica
qualche problema, consultate il Capitolo 7, “Risoluzione dei problemi”.
Ora completiamo la costruzione inserendo la breadboard in una sfera di vetro. Il

modo più semplice ed economico per farlo è comprare da IKEA una lampada da
tavolo “FADO”, che costa circa 15 €.
Invece di usare tre LED separati, potete usare un unico LED RGB, che presenta
quattro terminali. Dovete collegarlo più o meno allo stesso modo dei LED mostrati
nella Figura 6-2, con una differenza: invece di tre collegamenti separati al pin della
messa a terra di Arduino, avrete un unico terminale (detto “catodo comune”) che
andrà alla terra.
Potete utilizzare un LED RGB a 4 terminali come l’articolo COM-00105 di Spark-

Fun (www.sparkfun.com). Inoltre, in questo tipo di LED, a differenza di quelli a
un solo colore, il terminale che va alla terra è quello più lungo. I terminali più corti
devono essere collegati ai pin 9, 10 e 11 (con una resistenza tra i terminali e i pin,
proprio come nel caso dei LED rosso, verde e blu separati).
Ecco come assemblarlo

Estraete la lampada dalla confezione ed eliminate il cavo che entra nella lampada
dalla base. Non ci sarà più bisogno di collegarla a una presa sul muro.
Assicurate Arduino su una breadboard e incollate la breadboard sulla parte poste-

riore della lampada.
Saldate i cavi più lunghi al LED RGB e incollatelo dove prima c’era la lampadina.
Collegate i cavi che provengono dal LED alla breadboard (dove era collegato prima
della rimozione). Ricordate che se state usando un LED RGB a 4 terminali vi servi-
rà un solo collegamento alla messa a terra.
Come base per la lampada, potete usare un pezzo di legno con un buco o sem-
plicemente ritagliare la parte superiore della scatola di cartone in cui si trovava
la lampada approssimativamente per 5 cm e ritagliarvi un buco con un diametro
adatto ad accogliere la lampada. Rinforzate l’interno della scatola di cartone usan-
do della colla lungo i suoi margini interni, per rendere la base più stabile.

Inserite la sfera sulla base, fate uscire il cavo USB e collegatelo al computer.
Lanciate il codice di Processing, premete l’interruttore e guardate la lampada

prendere vita.
Come esercizio, provate ad aggiungere del codice che faccia accendere la lampa-
da quando la stanza diventa buia. Altri miglioramenti possibili sono:
» Aggiungere dei sensori di inclinazione per fare in modo che la lampada si ac-
cenda o si spenga ruotandola in diverse direzioni.
» Aggiungere un piccolo sensore PIR per rilevare quando vi si avvicina qualcuno

e farla accendere quando non c’è nessuno intorno.
» Creare modalità diverse in modo da poter controllare manualmente il colore o

farlo sfumare in molti altri colori.
Pensate ad altre cose, fate esperimenti e divertitevi!!

7/Risoluzione
dei problemi
Durante le vostre sperimentazioni giungerà un
momento in cui non funzionerà niente e dovrete
scoprire come risolvere la situazione. La risoluzione
dei problemi e il debugging sono arti antiche
governate da poche regole semplici, ma la maggior
parte dei risultati si ottengono con molta fatica.
Più si lavora con l’elettronica e Arduino, più si impara e si acquisisce esperienza,
che alla fine renderà il processo meno faticoso. Non fatevi scoraggiare dai proble-
mi che incontrerete: tutto è molto più facile di come sembra all’inizio.
Dato che tutti i progetti basati su Arduino sono composti sia da hardware che da
software, se qualcosa va storto dovrete cercare in diversi posti. Nel cercare un
bug, dovete seguire tre linee:
Comprensione
Cercate di capire il più possibile come funzionano le parti che state usando e
come dovrebbero contribuire al progetto finale. Questo approccio permetterà di
escogitare un modo per testare separatamente ciascun componente.
Semplificazione e segmentazione
Gli antichi Romani dicevano divide et impera: dividi e comanda. Provate a dividere
(mentalmente) il progetto nei suoi componenti usando quello che avete capito e
scoprite dove comincia e dove finisce la responsabilità di ciascun componente.
Esclusione e certezza
Mentre investigate, testate separatamente ciascun componente in modo da poter
essere assolutamente certi che ciascuno da solo funziona. Gradatamente divente-
rete più sicuri di quali parti del progetto fanno il loro lavoro e quali sono sospette.
Il termine che si usa per descrivere questo processo è debugging, come nel caso
del software. La leggenda dice che lo usò per la prima volta Grace Hopper negli
Risoluzione dei problemi 85

anni 40, quando i computer erano perlopiù elettromeccanici e uno di loro smise di
funzionare perché degli insetti rimasero intrappolati nei meccanismi.
Molti dei bug di oggi non sono più fisici, ma, almeno in parte, sono virtuali e
invisibili. Quindi richiedono un processo in un certo senso più lungo e noioso per
essere riconosciuti.
Testare la scheda
Cosa si dovrebbe fare se il primo esempio, “Far lampeggiare un LED,” non funzio-
nasse? Non sarebbe un po’ deprimente? Vediamo come intervenire.
Prima di cominciare a maledire il vostro progetto, dovreste controllare che alcune

cose siano a posto, come fanno i piloti degli aerei quando, prima del decollo, ripas-
sano una lista di controllo per assicurarsi che l’aereo volerà come si deve:
Collegate Arduino in una porta USB del vostro computer.
» Verificate che il computer sia acceso (sì, può suonare stupido, ma succede).
Se si accende la luce verde con etichetta PWR, significa che il computer sta
alimentando la scheda. Se la luce del LED appare debole, qualcosa non va
nell’alimentazione: provate un altro cavo USB e ispezionate la porta USB del
computer e il connettore USB di Arduino per vedere se c’è qualche guasto.
Se nessuna di queste soluzioni funziona, provate un’altra porta USB sul vostro
computer o un computer completamente diverso.
» Se Arduino è nuovo di zecca, il LED giallo con etichetta L comincerà a lampeg-
giare nervosamente; si tratta del programma di test che è stato caricato dalla
fabbrica per testare la scheda.
» Se state usando un alimentatore esterno e un vecchio Arduino (Extreme,

NG o Diecimila), verificate che l’alimentazione sia collegata e che il jumper
contrassegnato con SV1 stia collegando i due pin più vicini al connettore di
alimentazione esterna.
NOTA: Quando avete problemi con altri sketch e dovete confermare che
la scheda stia funzionando, aprite il primo esempio, “Far lampeggiare un
LED”, nell’IDE Arduino e caricatelo sulla scheda. Il LED integrato dovrebbe
lampeggiare a ritmo regolare.

Se avete concluso tutti questi passaggi con successo, potete essere certi che il
vostro Arduino funziona correttamente.
Testare il circuito sulla breadboard

Ora collegate la scheda alla vostra breadboard con un cavo che vada dalle connes-
sioni 5 V e GND alle piste positiva e negativa della breadboard. Se la luce verde del
LED PWR si spegne, rimuovete immediatamente questo cavo. Questo significa
che nel vostro circuito c’è un grave errore e che da qualche parte c’è un “corto
circuito”. Quando questo accade, la scheda richiede troppa corrente e l’alimenta-
zione viene interrotta per proteggere il computer.
NOTA: Se avete paura di danneggiare il computer, ricordate che molti com-

puter sono dotati di una protezione che generalmente è buona e risponde
con prontezza. Inoltre, nella scheda Arduino è inserito un “PolyFuse”, un
dispositivo di protezione dalla corrente che si resetta da solo quando il
guasto viene riparato.
Se siete molto paranoici, potete sempre collegare la scheda Arduino a un

hub USB autoalimentato. In questo caso, se tutto va orribilmente storto,
sarà l’hub USB a farne le spese e non il computer.
Se si verifica un corto circuito, dovete avviare il processo di “semplificazione e

segmentazione”. Ciò che dovete fare è prendere tutti i sensori del progetto e
collegarli uno alla volta.
La prima cosa da cui cominciare è sempre l’alimentazione di corrente (le connes-

sioni 5 V e GND). Guardate in giro e verificate che tutte le parti del circuito siano
correttamente alimentate.
Procedere un passo alla volta ed eseguire una sola modifica alla volta è la regola
numero uno per correggere gli errori. Questa regola mi è stata messa in testa dal
mio professore di scuola e primo datore di lavoro Maurizio Pirola. Ogni volta che
sto facendo il debugging di qualcosa e le cose non si mettono bene (e, credetemi,
succede spesso), mi torna in mente la sua faccia mentre dice “una modifica alla
volta . . . una modifica alla volta” e normalmente è in quel momento che riesco
a risolvere tutto. È molto importante, perché così saprete come avete risolto il
problema (perdere le tracce di quale modifica è stata effettivamente risolutiva è fin
troppo facile e per questo è così importante eseguirne una alla volta).

Ogni esperienza di debugging contribuirà a cementare la vostra conoscenza dei
difetti e delle possibili soluzioni. E, prima che ve ne rendiate conto, diventerete
degli esperti. E questo vi farà apparire fantastici, perché appena un principiante
dirà “Non funziona!”, vi basterà dare un’occhiata e gli fornirete la risposta in una
frazione di secondo.
Isolare i problemi
Un’altra regola importante è trovare un modo affidabile di riprodurre un problema.
Se il vostro circuito si comporta in modo strano in momenti disparati, provate a
individuare con precisione il momento esatto in cui si verifica il problema e cosa lo
sta causando. Questo processo vi permetterà di immaginare una causa possibile.
È anche molto utile quando dovete spiegare a qualcuno cosa sta succedendo.
Descrivere il problema nel modo più preciso possibile è un altro buon modo di
trovare una soluzione. Cercate di spiegare il problema a qualcuno: in molti casi,
mentre lo articolate, vi verrà in mente improvvisamente la soluzione. Brian W.
Kernighan e Rob Pike, in The Practice of Programming (Addison-Wesley, 1999),
raccontano di un’università dove “vicino all’help desk tenevano un orsacchiotto di
peluche. Agli studenti che incontravano bug misteriosi veniva chiesto di spiegarli
all’orsetto, prima di rivolgersi a un consulente umano”.
Problemi con l’IDE

In alcuni casi, potreste avere problemi a usare l’IDE Arduino, specie su Windows.
Se quando fate doppio clic sull’icona di Arduino appare un messaggio di errore o

non succede niente, in alternativa a lanciare Arduino provate a fare doppio clic sul
file run.bat.
Gli utenti Windows possono imbattersi in un problema anche se il sistema operati-

vo assegna ad Arduino un numero di porta COM da COM10 in su. Quando questo
accade, di solito potete convincere Windows ad assegnare ad Arduino un numero
di porta inferiore. Innanzitutto, aprite Gestione dispositivi facendo clic su menu
Start, poi facendo clic con il pulsante destro su Computer (Vista) o Risorse del
computer (XP) e infine scegliendo Proprietà. Su Windows XP, fate clic su Hardwa-
re e scegliete Gestione dispositivi. Su Vista, fate clic su Gestione dispositivi (che
appare nell’elenco di attività sulla sinistra della finestra).
Cercate i dispositivi seriali nell’elenco sotto “Porte (COM e LPT)”. Trovate un dispo-
sitivo seriale che non state usando e che sia numerato COM9 o inferiore. Fatevi clic

con il pulsante destro e nel menu scegliete Proprietà. Quindi, fate clic sulla scheda
Impostazioni della porta e poi su Avanzate. Impostate il numero di porta COM su
COM10 o superiore, fate clic su OK e di nuovo su OK per chiudere la finestra di
dialogo Proprietà.
Ora fate la stessa cosa con il dispositivo USB Serial Port che rappresenta Arduino,
con una modifica: assegnatevi il numero di porta COM (COM9 o inferiore) che avete
appena liberato.
Se questi consigli non aiutano o se vi imbattete in un problema non descritto qui,

consultate la pagina sulla risoluzione dei problemi di Arduino su www.arduino.cc/
en/Guide/Troubleshooting.
Come ottenere aiuto online

Se rimanete bloccati, non perdete giorni a cercare di farcela da soli: chiedete aiuto.
Una delle cose più belle di Arduino è la sua comunità. Se sapete spiegare bene il
problema, potete sempre trovarvi aiuto.
Prendete l’abitudine di tagliare e incollare le cose in un motore di ricerca e di

scoprire se qualcuno ne sta già parlando. Per esempio, quando l’IDE Arduino
comunica strani messaggi di errore, copiateli e incollateli in una ricerca di Google e
vedete cosa trovate. Fate lo stesso con le parti di codice con cui state lavorando o
solo con il nome di una funzione in particolare. Guardatevi intorno: tutto è già stato
inventato e si trova da qualche parte in una pagina web.
Per ulteriori indagini, partite dal sito web www.arduino.cc/it e consultate le sue
FAQ (www.arduino.cc/it/Main/FAQ), quindi spostatevi sul playground (www.
arduino.cc/playground), una wiki che gli utenti possono modificare liberamente
per contribuire alla documentazione. Si tratta di una delle parti migliori dell’intera
filosofia dell’open source. La gente fornisce documentazione ed esempi di tutto
ciò che fa con Arduino. Prima di dare inizio a un progetto, cercate nel playground e
troverete una porzione di codice o il diagramma di un circuito da cui cominciare.
Se neanche in questo modo riuscite a trovare una risposta, cercate nel forum
(www.arduino.cc/cgi-bin/yabb2/YaBB.pl). Se non vi trovate niente che vi aiuti,
inviate una domanda. Scegliete l’area corretta in cui rientra il vostro problema:
ne esistono diversi per problemi software o hardware e perfino forum in cinque
lingue diverse. Inviate più dati possibile:

» Quale scheda Arduino state usando?
» Che sistema operativo state usando per eseguire l’IDE Arduino?
» Offrite una descrizione generale di cosa state cercando di fare. Aggiungete link
alle schede tecniche delle parti più strane che state usando.
Il numero di risposte che si ottengono dipende da quanto bene si formula la

domanda. Le probabilità aumentano se si evitano assolutamente queste cose
(queste regole valgono per qualsiasi forum online, non solo per quello di Arduino):
» Digitare il vostro messaggio tutto in CARATTERI MAIUSCOLI. Questo infasti-

disce molto la gente ed è come andare in giro con la parola “novellino” tatuata
in fronte (nelle comunità online, scrivere tutto in caratteri maiuscoli è conside-
rato “gridare”).
» Inviare lo stesso messaggio in diverse parti del forum.

» Fare il “bumping” del messaggio inviando commenti che chiedono “Ehi, com’è
che non mi risponde nessuno?” o, ancora peggio, limitandosi a inviare il testo
“bump”. Se non avete ottenuto nessuna risposta, date un’occhiata al vostro
messaggio. L’argomento era chiaro? Avete fornito una descrizione ben formula-
ta del problema che avete? Siete stati gentili? Dovete sempre esserlo.
» Scrivere messaggi come “Voglio costruire uno space shuttle usando Arduino:
come faccio?”. Questo significa chiedere agli altri di lavorare al posto vostro e
questo approccio non è divertente per un vero tinkerer. È meglio spiegare cosa
volete costruire e poi formulare domande specifiche su una parte del progetto
e partire da lì.
» Una variazione del punto precedente è quando la domanda è chiaramente qual-

cosa per cui chi la pone viene pagato. Se ponete domande specifiche la gente
è lieta di aiutarvi, ma se chiedete agli altri di fare tutto il lavoro al posto vostro
(senza dividere con loro il compenso), le risposte hanno meno probabilità di
essere gentili.
» Inviare messaggi che sembrano sospettosamente compiti scolastici e chiede-

re al forum di farveli. I professori come me frequentano i forum e puniscono
severamente gli studenti che si comportano così.

Appendice A/
La breadboard
Il processo necessario per far funzionare un circuito include effettuare moltissime
modifiche finché non si comporta come dovrebbe; si tratta di un processo molto
veloce e iterativo, simile a un equivalente elettronico della creazione di schizzi.
Il design evolve nelle vostre mani mentre provate diverse combinazioni. Per
ottenere i risultati migliori, usate un sistema che vi permetta di cambiare i collega-
menti tra i componenti nel modo più rapido, più pratico e meno distruttivo. Questi
requisiti chiaramente tagliano fuori la saldatura, una procedura che richiede tempo
e mette sotto stress i componenti ogni volta che li scaldate e raffreddate.
La risposta a questo problema è un dispositivo molto comodo detto breadboard

che non richiede saldature. Come potete vedere nella Figura A-1, si tratta di una
piccola scheda di plastica piena di buchi, ciascuno dei quali contiene un contatto a
molla. Se inserite il piedino di un componente in uno dei buchi, questo stabilirà un
contatto elettrico con tutti gli altri buchi della stessa colonna verticale. Ogni buco
dista 2,54 mm dagli altri.
Dato che i piedini (noti nel gergo tecnico come “pin”) della maggior parte dei com-
ponenti distano tra loro una misura standard, i chip con più piedini vi si adattano
bene. Non tutti i contatti della breadboard nascono uguali: ci sono alcune diffe-
renze. Le righe in alto e in basso (colorate di rosso e blu e contrassegnate con +
e –) sono collegate orizzontalmente e si usano per condurre l’alimentazione nella
scheda in modo che, quando serve l’alimentazione o la terra, la possiate fornire
molto rapidamente con un cavo di connessione (un pezzettino di cavo che collega
due punti di un circuito). L’ultima cosa che dovete sapere delle breadboard è che
nel centro presentano una separazione più larga, di ampiezza pari alla dimensione
di un piccolo chip. Ciascuna linea verticale di buchi è interrotta nel centro, quindi,
quando si inserisce un chip, non si crea un corto circuito tra i pin che si trovano sui
due lati del chip. Astuto, no?
Appendice A 91

Figura A-1.
La breadboard che non richiede saldature

Appendice B/Resistenze
e condensatori
Per poter usare i componenti elettronici, dovete saperli riconoscere, cosa che
per i principianti può risultare difficile. La maggior parte delle resistenze che si
trovano in vendita hanno un corpo cilindrico dal quale fuoriescono due gambette
e che presentano delle strisce di diversi colori. Quando furono create le prime re-
sistenze da mettere in commercio, non esisteva un modo per stampare i numeri
così piccoli da potervi essere contenuti, quindi degli ingegneri astuti decisero di
limitarsi a rappresentarne i valori con delle strisce colorate.
I principianti di oggi devono scoprire il modo di interpretare questi segni. La “chia-

ve” è piuttosto semplice: generalmente le strisce sono quattro e ciascun colore
rappresenta un numero. Uno degli anelli di solito è color oro; questo rappresenta
la precisione della resistenza. Per leggere le strisce nell’ordine corretto, tenete
in mano la resistenza in modo che la striscia color oro (o in alcuni casi argento) si
trovi sulla destra. Quindi, leggete i colori e mappateli sui numeri corrispondenti. In
questa tabella, troverete una traduzione tra i colori e i loro valori numerici.
Colore Valore
Nero 0
Marrone 1
Rosso 2
Arancione 3
Giallo 4
Verde 5
Blu 6
Viola 7
Grigio 8
Bianco 9
Argento 10%
Oro 5%
Per esempio, una sequenza di strisce marrone, nero, arancione e oro significa
1 0 3 ±5%. Facile, no? Non esattamente, perché c’è una difficoltà: il terzo anello
rappresenta il numero di zeri del valore. Quindi 1 0 3 in realtà significa 1 0 seguito
da 3 zeri e quindi il risultato finale è 10.000 ohm ±5%. I geek dell’elettronica ten-
dono ad abbreviare i valori esprimendoli in kilo ohm (migliaia di ohm) e mega ohm
Appendice B 93

(milioni di ohm), quindi una resistenza 10.000 ohm in realtà si abbrevia 10k, men-
tre 10.000.000 diventa 10M. Notate che, dato che agli ingegneri piace ottimizzare
tutto, in alcuni schemi potete trovare valori espressi come 4k7, che significa
4,7 kilo ohm, o 4700.
I condensatori sono un po’ più facili: i condensatori cilindrici (condensatori elettro-

litici) di solito presentano stampati i loro valori. Il valore di un condensatore si mi-
sura in farad (F), ma la maggior parte dei condensatori che si incontrano saranno
misurati in microfarad (µF). Quindi, se vedete un condensatore con etichetta 100
µF, si tratta di un condensatore da 100 microfarad.
Molti dei condensatori a disco (condensatori ceramici) non presentano elenca-

te le loro unità e usano un codice numerico di tre cifre che indica il numero di
picofarad (pF). In un µF ci sono 1.000.000 di pF. Analogamente ai codici delle re-
sistenze, il terzo numero serve a determinare il numero di zeri da mettere dopo i
primi due, ma con una differenza: se leggete 0–5, questo indica il numero di zeri.
6 e 7 non si usano e 8 e 9 si usano in modo diverso. Se leggete 8, moltiplicate il
numero formato dalle prime due cifre per 0,01, mentre, se leggete 9, moltiplica-
telo per 0,1.
Quindi, un condensatore con etichetta 104 sarebbe 100.000 pF o 0,1 µF. Un

condensatore con etichetta 229 sarebbe 2,2 pF.

Appendice C/Arduino:
Guida rapida
Ecco una spiegazione veloce di tutte le istruzioni standard supportate dal linguag-
gio Arduino. Per un riferimento più dettagliato, visitate: arduino.cc/it/Reference/
HomePage.
STRUTTURA
Gli sketch di Arduino si dividono in due parti:
void setup()
Qui si inserisce il codice di inizializzazione, le istruzioni che impostano la scheda
prima che cominci il ciclo principale dello sketch.
void loop()
Contiene il codice principale dello sketch. Contiene una serie di istruzioni che si
ripetono continuamente finché la scheda non viene spenta.
SIMBOLI SPECIALI
Arduino comprende diversi simboli che servono a distinguere righe di codice,
commenti e blocchi di codice.
; (punto e virgola)
Ciascuna istruzione (linea di codice) termina con un punto e virgola. Questa
sintassi permette di formattare il codice liberamente. Potete perfino inserire due
istruzioni su una stessa riga, purché le separiate con un punto e virgola (ma questo
renderebbe il codice più difficile da leggere).
Esempio:
delay(100);
{} (parentesi graffe)
Si usano per contrassegnare blocchi di codice. Per esempio, quando scrivete il
codice della funzione loop(), dovete usare le parentesi graffe prima e dopo il codice.
Esempio:
void loop() {
Serial.println("ciao");
}
Appendice C 95

commenti
Sono porzioni di testo che vengono ignorate dal processore di Arduino, ma che
sono estremamente utili per ricordare a se stessi (e agli altri) a cosa serve una
determinata parte del codice.
In Arduino i commenti possono essere di due tipi:

// una sola riga: questo testo viene ignorato fino alla fine della riga
/* più righe:
qui potete scrivere
un intero poema
*/
COSTANTI
Arduino comprende una serie di parole chiave predefinite con valori speciali. HIGH
e LOW si usano, per esempio, quando si vuole accendere o spegnere un pin di
Arduino. INPUT e OUTPUT si usano per impostare un determinato pin come
input o output.
true e false indicano esattamente ciò che dicono i loro nomi: il fatto che una con-
dizione o un’espressione sia vera o falsa.
VARIABILI
Le variabili sono aree della memoria di Arduino dotate di nome dove potete
conservare dati da usare e manipolare nel vostro sketch. Come suggerisce il
nome, possono essere cambiate tutte le volte che si vogliono. Dato che Arduino
è un processore molto semplice, quando si dichiara una variabile si deve anche
specificarne il tipo, cioè indicare al processore la dimensione del valore che si
vuole conservare.
Ecco i tipi di dati disponibili:
boolean
Può avere uno di due valori: true o false.
char
Contiene un solo carattere, come per esempio A. Come tutti i computer, Arduino
lo conserva in forma di numero, anche se quello che vedete è un testo. Quando
queste variabili vengono usate per conservare numeri, possono contenere valori
compresi tra –128 e 127.

NOTA: Nei sistemi dei computer sono disponibili principalmente due serie
di caratteri: ASCII e UNICODE. ASCII è una serie di 127 caratteri che tra
l’altro venivano usati per trasmettere testo tra terminali seriali e sistemi
informatici time-shared come mainframe e minicomputer. UNICODE è una
serie molto più ampia di valori usata dai sistemi operativi dei computer
moderni per rappresentare i caratteri di una vasta gamma di lingue. ASCII
serve ancora per scambiare brevi quantità di informazioni in lingue come
l’italiano o l’inglese, che usano caratteri latini, numeri arabi, simboli di
punteggiatura comuni e così via.
byte
Contiene un numero compreso tra 0 e 255. Come nel caso di char, byte usa solo
un byte di memoria.
int
Usa 2 byte di memoria per rappresentare un numero compreso tra –32.768 e
32.767; è il tipo di dato che si usa più spesso in Arduino.
unsigned int
Come int, usa 2 byte ma il prefisso unsigned significa che non può contenere
numeri negativi, quindi il suo intervallo va da 0 a 65.535.
long
La sua dimensione è doppia rispetto a quella di int e contiene numeri compresi tra
–2.147.483.648 e 2.147.483.647.
unsigned long
Versione senza numeri negativi di long; va da 0 a 4.294.967.295.
float
È piuttosto grande e può contenere valori a virgola mobile, un modo originale di
definire i numeri seguiti da valori decimali. Occuperà 4 byte della vostra preziosa
RAM e le funzioni che la possono gestire usano anche loro molta memoria. Quindi
float va usato con parsimonia.
double
Numeri a virgola mobile a doppia precisione, con un valore massimo pari a
1,7976931348623157 x 10 308. Enorme!
string
Una serie di caratteri ASCII che si usano per conservare informazioni testuali
(potete usare una stringa per inviare un messaggio attraverso una porta seriale,
Appendice C 97

o per mostrarla su un monitor LCD). Come memoria, usano un byte per ciascun
carattere della stringa, più un carattere null per indicare ad Arduino la fine della
stringa. Questi esempi sono equivalenti:
char string1[] = "Arduino"; // 7 caratteri + 1 carattere null
char string2[8] = "Arduino"; // come sopra
array
Un elenco di variabili cui si può accedere attraverso un indice. Si usano per creare
tabelle di valori cui si possa accedere facilmente. Per esempio, se volete conser-
vare diversi livelli di luminosità da usare quando si spegne o accende gradatamen-
te un LED, potete creare sei variabili di nome light01, light02 e così via. Ancora
meglio, potete usare un array semplice come:
int light[6] = {0, 20, 50, 75, 100};
La parola “array” in realtà non si usa esplicitamente nella dichiarazione delle varia-
bili: ci pensano già i simboli [] e {}.
STRUTTURE DI CONTROLLO
Arduino comprende parole chiave che controllano il flusso logico degli sketch.
if . . . else
Questa struttura prende decisioni nel programma. if deve essere seguito da una
domanda specificata in forma di espressione e contenuta tra parentesi. Se l’espres-
sione è vera, viene eseguito ciò che segue. Se è falsa, viene eseguito il blocco di
codice che segue else. È possibile usare solo if senza fornire la clausola else.
Esempio:
if (val == 1) {
digitalWrite(LED,HIGH);
}
for
Permette di ripetere un blocco di codice un numero specifico di volte.
Esempio:
for (int i = 0; i < 10; i++) {
Serial.print("ciao");
}
switch case
L’istruzione if è come un bivio sulla strada del programma. switch case è come
una rotonda, che permette al programma di prendere una varietà di direzioni a se-

conda del valore assunto da una variabile. È piuttosto utile per mantenere il codice
breve perché sostituisce lunghi elenchi di istruzioni if.
Esempio:
switch (sensorValue) {
case 23:
digitalWrite(13,HIGH);
break;
case 46:
break;
default: // se nessun valore corrisponde, è eseguito questo codice
digitalWrite(12,LOW);
digitalWrite(13,LOW);
}
while
Simile a if, esegue un blocco di codice mentre è vera una determinata condizione.
Esempio:
// fa lampeggiare il LED finché il sensore è al di sotto di 512
sensorValue = analogRead(1);
while (sensorValue < 512) {
delay(100);
delay(100);
}
do . . . while
È come while, ma in questo caso il codice viene eseguito subito prima che la con-
dizione venga valutata. Questa struttura si usa quando si vuole che il codice all’in-
terno del blocco venga eseguito almeno una volta prima di verificare la condizione.
Esempio:
do {
delay(100);
delay(100);
} while (sensorValue < 512);
Appendice C 99

break
Questo termine permette di uscire da un ciclo e di proseguire con l’esecuzione
del codice che appare dopo il ciclo. Si usa anche per separare sezioni diverse di
un’istruzione switch case.
Esempio:
// fa lampeggiare il LED finché il sensore è al di sotto di 512
do {
// esce dal ciclo se si preme un pulsante
if (digitalRead(7) == HIGH)
break;
delay(100);
delay(100);
} while (sensorValue < 512);
continue
Quando viene usato all’interno di un ciclo, continue permette di saltare il resto del
codice al suo interno e costringe a ricontrollare la condizione.
Esempio:
for (light = 0; light < 255; light++)
{
// salta le intensità comprese tra 140 e 200
if ((x > 140) && (x < 200))
continue;
analogWrite(PWMpin, light);
delay(10);
}
return
Interrompe l’esecuzione di una funzione e ne restituisce il risultato. La si può usare
anche per restituire un valore dall’interno di una funzione. Per esempio, se c’è una
funzione di nome computeTemperature() e volete riportarne il risultato nella parte
di codice che ha invocato la funzione, dovete scrivere qualcosa di simile:
int computeTemperature() {
int temperature = 0;
temperature = (analogRead(0) + 45) / 100;
return temperature;
}

CALCOLI ARITMETICI E FORMULE
Arduino può essere usato per eseguire calcoli complessi usando una sintassi
speciale. + e – funzionano come avete studiato a scuola, mentre la moltiplicazione
è rappresentata da * e la divisione da /. Esiste un ulteriore operatore che si chiama
“modulo” (%) e che restituisce il resto di una divisione come intero. Per raggrup-
pare le espressioni, si possono usare tutti i livelli di parentesi necessari. Contra-
riamente a quanto si è imparato a scuola, le parentesi quadre e quelle graffe sono
riservate per altri scopi (rispettivamente array e blocchi).
Esempi:
a = 2 + 2;
light = ((12 * sensorValue) - 5 ) / 2;
remainder = 3 % 2; // restituisce 2 perché 3 / 2 produce il resto 1
OPERATORI DI CONFRONTO
Quando si specificano le condizioni per le istruzioni if, while e for, si devono usare
questi operatori:
== uguale a
!= diverso da
< minore di
> maggiore di
<= minore di o uguale a
>= maggiore di o uguale a
OPERATORI BOOLEANI
Si usano quando si vogliono combinare diverse condizioni. Per esempio, se volete
controllare se il valore fornito da un sensore è compreso tra 5 e 10, dovete scrivere:
if ((sensor => 5) && (sensor <=10))
Esistono tre operatori: and, rappresentato da &&; or, rappresentato da ||; e infine
not, rappresentato da !.
OPERATORI Compound
Si tratta di operatori speciali che si usano per rendere più conciso il codice di ope-
razioni molto comuni come incrementare un valore. Per esempio, per incrementa-
re value di 1 potete scrivere:
Appendice C 101

value = value +1;
ma, usando un operatore compound, diventa:
value++;
incremento e decremento (–– e ++)

Incrementano o decrementano un valore di 1. Attenzione, però. i++ prima valuta i
poi lo incrementa di 1; ++i prima incrementa i di 1, poi lo valuta. Lo stesso vale
per ––.
+= , –=, *= e /=
Permettono di scrivere più brevemente alcune espressioni. Queste due espressio-
ni sono equivalenti:
a = a + 5;
a += 5;
FUNZIONI DI INPUT E OUTPUT

Arduino comprende funzioni che servono a gestire l’input e l’output. Ne avete già
viste alcune nei programmi di esempio del libro.
pinMode(pin, mode)
Riconfigura un pin digitale in modo che si comporti come un input o un output.
Esempio:
pinMode(7,INPUT); // converte il pin 7 in un input
digitalWrite(pin, value)
Attiva o disattiva un pin digitale. Perché digitalWrite abbia effetto, i pin devono
essere resi esplicitamente degli output usando pinMode.
Esempio:
digitalWrite(8,HIGH); // attiva il pin digitale 8
int digitalRead(pin)
Legge lo stato di un pin di input, restituisce HIGH se al pin è applicato un voltaggio
o LOW se non ve ne è applicato nessuno.
Esempio:
val = digitalRead(7); // inserisce il valore di pin 7 in val

int analogRead(pin)
Legge il voltaggio applicato a un pin di input analogico e restituisce un numero
compreso tra 0 e 1023, che rappresenta i voltaggi compresi tra 0 e 5 V.
Esempio:
val = analogRead(0); // inserisce il valore dell'input analogico 0 in val
analogWrite(pin, value)
Cambia la percentuale PWM su uno dei pin contrassegnati PWM. pin può essere
11,10, 9, 6, 5, 3. value può essere un numero compreso tra 0 e 255 che rappresen-
ti la scala tra il voltaggio di output 0 e 5 V.
Esempio:
analogWrite(9,128); // attenua al 50% il LED sul pin 9
shiftOut(dataPin, clockPin, bitOrder, value)

Invia dati a uno shift register, un dispositivo che si usa per espandere il numero di
output digitali. Questo protocollo usa un pin per i dati e uno per il clock. bitOrder
indica l’ordinamento dei byte (meno significativo o più significativo) e value è il
byte vero e proprio che deve essere inviato.
Esempio:
shiftOut(dataPin, clockPin, LSBFIRST, 255);
unsigned long pulseIn(pin, value)

Misura la durata di un impulso proveniente da uno degli input digitali. Questo è uti-
le, per esempio, per leggere alcuni sensori a infrarossi o accelerometri che inviano
i loro valori in forma di impulsi di durata variabile.
Esempio:
time = pulsein(7,HIGH); // misura il tempo in cui rimane attivo
// l'impulso successivo
FUNZIONI TEMPORALI
Arduino comprende alcune funzioni che servono a misurare il tempo trascorso e
anche per mettere in pausa lo sketch.
unsigned long millis()

Restituisce il numero di millisecondi che sono passati da quando è partito lo sketch.
Esempio:
duration = millis()-lastTime; // conta il tempo trascorso a partire
// da "lastTime"
Appendice C 103

delay(ms)
Mette in pausa il programma per la quantità di millisecondi specificata.
Esempio:
delay(500); // interrompe il programma per mezzo secondo
delayMicroseconds(us)
Mette in pausa il programma per la quantità specificata di microsecondi.
Esempio:
delayMicroseconds(1000); // aspetta 1 millisecondo
FUNZIONI MATEMATICHE
Arduino comprende molte funzioni matematiche e trigonometriche comuni:
min(x, y)
Restituisce il più piccolo tra x e y.
Esempio:
val = min(10,20); // val ora è 10
max(x, y)
Restituisce il più grande tra x e y.
Esempio:
val = max(10,20); // val ora è 20
abs(x)
Restituisce il valore assoluto di x, che trasforma in positivi i numeri negativi. Se x è
5 restituirà 5, ma se x è –5, restituirà comunque 5.
Esempio:
val = abs(-5); // val ora è 5
constrain(x, a, b)
Restituisce il valore di x, compreso tra a e b. Se x è minore di a, restituirà a e se x
è maggiore di b, restituirà b.
Esempio:
val = constrain(analogRead(0), 0, 255); // rifiuta valori superiori a 255

map(value, fromLow, fromHigh, toLow, toHigh)
Mappa un valore dell’intervallo compreso tra fromLow e maxLow sull’intervallo
compreso tra toLow e toHigh. Molto utile per elaborare valori che provengono da
sensori analogici.
Esempio:
val = map(analogRead(0),0,1023,100, 200); // mappa il valore di
// analog 0 su un valore
// compreso tra 100 e 200
double pow(base, exponent)

Restituisce il risultato che si ottiene elevando un numero (base) a una potenza
(esponente).
Esempio:
double x = pow(y, 32); // imposta x al valore y elevato alla 32a potenza
double sqrt(x)
Restituisce la radice quadrata di un numero.
Esempio:
double a = sqrt(1138); // approssimativamente 33,73425674438
double sin(rad)
Restituisce il seno di un angolo specificato in radianti.
Esempio:
double sine = sin(2); // approssimativamente 0,90929737091
double cos(rad)
Restituisce il coseno di un angolo specificato in radianti.
Esempio:
double cosine = cos(2); // approssimativamente -0,41614685058
double tan(rad)
Restituisce la tangente di un angolo specificato in radianti.
Esempio:
double tangent = tan(2); // approssimativamente -2,18503975868
Appendice C 105

FUNZIONI DI GENERAZIONE DI NUMERI CASUALI
Se dovete generare dei numeri random, potete usare il generatore di numeri pseu-
docasuali di Arduino.
randomSeed(seed)
Reimposta il generatore di numeri pseudocasuali di Arduino. Anche se la distribu-
zione dei numeri restituiti da random() è essenzialmente casuale, la sequenza è
prevedibile. Quindi, dovreste reimpostare il generatore su un valore a caso. Se vi
resta un pin analogico scollegato, raccoglierà del disturbo casuale dall’ambiente
circostante (onde radio, raggi cosmici, interferenze elettromagnetiche da telefoni
cellulari e lampade a fluorescenza e così via).
Esempio:
randomSeed(analogRead(5)); // genera un numero a caso usando
// il disturbo che proviene dal pin 5
long random(max)
long random(min, max)
Restituisce un valore intero long pseudocasuale compreso tra min e max – 1.
Se min non viene specificato, il limite minimo è 0.
Esempio:
long randnum = random(0, 100); // un numero compreso tra 0 e 99
long randnum = random(11); // un numero compreso tra 0 e 10
COMUNICAZIONE SERIALE
Come abbiamo visto nel Capitolo 5, possiamo comunicare con dei dispositivi attra-
verso la porta USB usando un protocollo di comunicazione seriale.
Ecco le funzioni seriali.
Serial.begin(speed)
Prepara Arduino a cominciare a spedire e ricevere dati seriali. Generalmente con il
monitor seriale dell’IDE Arduino userete 9600 bit al secondo (bps), ma sono dispo-
nibili anche altre velocità, di solito non superiori a 115.200 bps.
Esempio:
Serial.begin(9600);
Serial.print(data)
Serial.print(data, encoding)
Invia dei dati alla porta seriale. La codifica è facoltativa; se non viene fornita, i dati
vengono trattati come testo semplice.

Esempi:
Serial.print(75); // stampa "75"
Serial.print(75, DEC); // lo stesso di prima.
Serial.print(75, HEX); // "4B" (75 in esadecimale)
Serial.print(75, OCT); // "113" (75 in ottale)
Serial.print(75, BIN); // "1001011" (75 in binario)
Serial.print(75, BYTE); // "K" (il carattere corrispondente
// al byte 75 nella serie ASCII)
Serial.println(data)
Serial.println(data, encoding)
Uguale a Serial.print(), ma aggiunge un a capo e un line feed (\r\n) come se si
fossero digitati i dati e poi si fosse premuto Invio.
Esempi:
Serial.println(75); // stampa "75\r\n"
Serial.println(75, DEC); // lo stesso di prima.
Serial.println(75, HEX); // "4B\r\n"
Serial.println(75, OCT); // "113\r\n"
Serial.println(75, BIN); // "1001011\r\n"
Serial.println(75, BYTE); // "K\r\n"
int Serial.available()
Restituisce quanti byte non letti sono disponibili sulla porta seriale da leggere
attraverso la funzione read(). Dopo che si è letto tutto il possibile con read(), Serial.
available() restituisce 0 finché sulla porta seriale non arrivano nuovi dati.
Esempio:
int count = Serial.available();
int Serial.read()
Ricava un byte di dati seriali in arrivo.
Esempio:
int data = Serial.read();
Serial.flush()
Poiché i dati possono arrivare dalla porta seriale più rapidamente di quanto il
programma sia in grado di elaborarli, Arduino conserva in un buffer tutti i dati che
arrivano. Se dovete svuotare il buffer per permettere che venga riempito da dati
nuovi, usate la funzione flush().
Esempio:
Serial.flush();
Appendice C 107

Appendice D/
Leggere gli schemi
Finora, per descrivere come assemblare i circuiti abbiamo usato illustrazioni molto
dettagliate, ma, come potete immaginare, disegnarne una per ciascuno degli espe-
rimenti che vogliamo documentare non sarebbe esattamente un’operazione rapida.
Questioni simili prima o poi emergono in tutte le discipline. Nella musica, dopo che
si è composta una bella canzone, la si deve scrivere usando la notazione musicale.
Gli ingegneri, essendo persone pratiche, hanno sviluppato un modo rapido di cat-
turare l’essenza di un circuito per poterlo documentare e poi ricostruire o passare a
qualcun altro.
Nel campo dell’elettronica, gli schemi permettono di descrivere un circuito in

modo che possa essere compreso dal resto della comunità. I singoli componenti
sono rappresentati da simboli che sono una specie di astrazione della forma del
componente o della sua essenza. Per esempio, i condensatori sono composti da
due placche di metallo separate da aria o plastica; quindi, il loro simbolo è:
Un altro esempio chiaro sono gli induttori, che si costruisco-

no arrotolando un filo di rame intorno a una forma cilindrica;
di conseguenza, il loro simbolo è:
I collegamenti tra i componenti di solito si creano usando

cavi o tracce su schede a circuito stampato e nel diagram-
ma si rappresentano con semplici linee. Quando due cavi
sono collegati, il collegamento si rappresenta con un grosso
punto posizionato dove si incrociano le due linee:

Questo è quanto dovete sapere per capire gli schemi di base. Ecco un elenco più
esteso di simboli con i loro significati:
RESISTenza CONDENSATORE TERMISTORE SENSORE DI LUCE LDR
DIODO LED PULSANTE POTENziometro
In questi simboli si possono incontrare delle variazioni (per esempio, qui sono
mostrate entrambe le varianti del simbolo della resistenza). Per un elenco più va-
sto di simboli elettronici, visitate en.wikipedia.org/wiki/Electronic_symbol. Per
convenzione, gli schemi si disegnano da sinistra a destra. Per esempio, una radio
si disegna partendo con l’antenna a sinistra e poi seguendo il percorso del segnale
radio mentre procede verso l’altoparlante (che si disegna sulla destra).
Questo schema descrive il circuito del pulsante mostrato prima in questo libro:
+5 V
ARDUINO
PIN 7
GND GND
Appendice D 109

Indice analitico
; (punto e virgola), 44, 95 pin GND, 58

// (delimitatore di un commento), 32–33, 34–35, 96 pin IO analogici, 18–19, 62–65
-- (operatore di decremento), 102 pin IO digitali, 18–19
/* (delimitatore di un commento), 96 pin, transistor MOSFET, 68
&& (operatore and), 101 PolyFuse, 87
{} (parentesi graffe), 32–33, 95 porte, identificazione, 23–25
== (uguale a), 42–43, 101 risoluzione dei problemi della scheda, 86–87
= (operatore di uguaglianza), 42–43 scheda Diecimila, 18, 86
> (maggiore di), 101 scheda Duemilanove, 18–19
>= (maggiore di o uguale a), 101 scheda Extreme, 86
++ (operatore di incremento), 102 scheda NG, 18–19, 86
< (minore di), 101 sito web, 1, 89
<= (minore di o uguale a), 101 sito web, risoluzione dei problemi, 89
% (modulo), 101 software, 20
!= (diverso da), 101 argomenti, 34
! (operatore not), 101 aritmetica, 101
|| (operatore or), 101 array di variabili, 98
() (parentesi), 34 ASCII, 97
LED RGB a 4 terminali, 82 aspirapolvere, 6
assemblare una lampada sferica, 82–83
ATmega168, 17–19
A Aton, lampada, 71
abs, funzione, 104 attuatori
accelerometri, 68–69 LED, 35
adattatori AC, 18 panoramica, 28
Ampère, André-Marie, 39 spazzatura, 14
ampere, 39
analogia con l’acqua, elettricità, 37–40
analogico B
analogRead, funzione, 62–65, 103 Barragan, Hernando, 2
analogWrite, funzione, 54–56, 63–65, 103 The Betrothed, 34
input, 62–65, 71 bitOrder, 103
output, 54–60, 71 Boolean, variabile, 96
pin, scheda Arduino, 18–19, 62–65 booleani, operatori, 101
sensori, 62–66 bouncing, 47–49
sintetizzatori, 8 breadboard (che non richiede saldature), 41, 58,
analogWrite, funzione, 54–56, 63–65, 103 87–88, 91–92
and, operatore, 101 break, struttura di controllo, 100
Arduino buffer, 73
alimentatori, 18 byte, variabile, 97
definizione, 1
filosofia, 5–16
forum, 89–90 C
hardware, 17–19 C, linguaggio, 20
IDE, panoramica, 20 calcoli, 101
IDE, risoluzione dei problemi, 88–89 caratteri speciali
IDE, scaricare, 20 // (delimitatore di commenti), 32–33, 34–35, 96
IDE, sito web, 1 /* (delimitatore di commenti), 96
installare, 20–25 != (diverso da), 101
jumper per selezionare l’alimentatore, 18 = (istruzione if), 42–43
Linux, 20 > (maggiore di), 101
panoramica, 1–3

>= (maggiore di o uguale a), 101 D
< (minore di), 101 Dante, 34
% (modulo), 101 dataPin, 103
&& (operatore and), 101 debugging
++ (operatore di incremento), 102 aiuto online, 89–90
-- (operatore di decremento), 102 circuito sulla breadboard, 87–88
! (operatore not), 101 definizione, 85
|| (operatore or), 101 IDE (Integrated Development Environment),
() (parentesi), 34 88–89
{} (parentesi graffe), 32–33, 95 riprodurre i problemi, 88
; (punto e virgola), 44, 95 scheda Arduino, 86–87
== (uguale a), 42–43, 101 Windows, 88–89
ASCII, 97 #define, 34, 44
simboli aritmetici, 101 define, comando, 34, 44
UNICODE, 97 delay, funzione, 35, 104
caricare uno sketch, 31 delayMicroseconds, funzione, 104
carichi, gestire, 68 delimitatori
carpet switch, 51 blocchi di codice, 32–33
cartella, salvare sketch, 30 commento, 33
cavi di connessione, 41–42 Diecimila, scheda, 18
char, variabile, 96 digitali
circuit bending, 10–11 input, 34–36, 71
circuiti IO, pin della scheda Arduino, 18–19
costruire, materiali necessari, 40–42 output, 34–36, 71
far lampeggiare un LED, 63 digitalRead, funzione, 40, 62, 102
lampada sferica, 81–82 digitalWrite, funzione, 35, 102
LED controllato da un pulsante, 40–41 diodo, simbolo, 109
modulazione di larghezza di impulso (PWM), dispositivo interattivo, 27
56–58 divide et impera, 85
simboli, schemi, 108–109 Divina Commedia, 34
testare, 87–88 documentazione, online, 89–90
clockPin, 103 double cos, funzione, 105
codice. Vedere anche programmazione double pow, funzione, 105
blocchi, nomi, 32–33 double sin, funzione, 105
far lampeggiare un LED, 30–36, 62–65 double tan, funzione, 105
lampada sferica, 73–80 double, variabile, 97
LED controllato da un pulsante, 42–49 do...while, struttura di controllo, 99
oggetti seriali, 66–67 drain, pin dei transistor MOSFET, 68
codici di colore, resistenze, 93–94 driver, installazione, 21–22
collaborazione, 16 driver per iMac, 21
collegamenti, simboli, 108 driver per Intel, 21
Colombo, Joe, 71 Duemilanove, scheda, 18–19
colori, codifica HTML, 73 Dyson, James, 6
comando, #define, 34, 44
commenti, 33, 34–35, 96
commenti di più righe, 96 E
commenti di una sola riga, 96 elettricità, 37–40
comunicazione dati, oggetti seriali, 66–67, 71 errata corrige, ix
comunicazione, seriale, 23–25, 66–67, 71, 88–89, esadecimali, 73
106–107 eseguire sketch, 32
condensatori Extreme, scheda, 86
leggere, 93–94
simbolo, 108, 109
continue, struttura di controllo, 100 F
compilare gli sketch, 31, 44 FALSE, 43
componenti necessari per costruire un circuito, far lampeggiare un LED, 28–36, 62–65
40–42 feed RSS, controllare una lampada, 73
constrain, funzione, 104 filosofia, Arduino, 5–16
corrente, 39–40 float, variabile, 97
corto circuito, 87 font, generazione, 78
cos, funzione, 105 for, istruzione, 101
costanti, 34 for, struttura di controllo, 98
formule, 101
Indice analitico 111

forum, Arduino, 89–90 I
fotoresistenze, 28. Vedere anche LDR (light- I promessi sposi, 34
dependent resistors) IDE (Integrated Development Environment)
funzioni panoramica, 20
abs, 104 risoluzione dei problemi, 88–89
analogRead, 62–65, 103 scaricare, 20
analogWrite, 54–56, 63–65, 103 sito web, 1
che restituiscono un risultato, 42–43 identificazione delle porte, 23–25, 78, 88–89
constrain, 104 if, istruzione, 42–43, 98, 101
cos, 105 if, struttura di controllo. Vedere if, istruzione
delay, 104 if...else, struttura di controllo, 98
delay, funzione, 35 Igoe, Tom, 69
delayMicroseconds, 104 IKEA, lampada, 82
digitalRead, 40 induttore, simbolo, 108
digitalWrite, 35, 102 informazioni di contatto, ix
loop, 33, 35 INPUT, 34, 96
map, 105 input
matematiche, 104–105 analogici, 62–65, 71
max, 104 digitali, 34–36, 71
millis, 103 funzioni, 102–106
min, 104 installare
panoramica, 32–33, 34–35 Arduino, 20–25
pinMode, 34, 102 driver per Macintosh, 21
pow, 105 driver per Windows, 21–22
pulseln, 103 int analogRead, funzione, 103
random, 106 int digitalRead, funzione, 102
random, numeri, 106 int Serial.available, funzione, 107
randomSeed, 106 int Serial.read, funzione, 107
seriali, 106–107 int, variabile, 97
Serial.available, 107 Integrated Development Environment (IDE). Vedere
Serial.begin, 106 IDE (Integrated Development Environment)
Serial.flush, 107 Interaction Design, 2–3
Serial.print, 106–107 interruttore a pulsante tattile, 41
Serial.println, 107 interruttori
Serial.read, 107 a inclinazione, 52, 54, 83
setup, 33, 34 bouncing, 47–49
shiftOut, 103 magnetici, 51
sin, 105 on/off, 51
tan, 105 pulsanti, 41
temporali, 103–104 reed relay, 51
void, tipo, 34–35 sensori a tappeto, 51
funzioni matematiche, 104–105 transistor MOSFET, 68
funzioni temporali, 103–104 interruttori a inclinazione, 52, 54, 83
funzioni trigonometriche, 104–105 interruttori magnetici, 51
inviare dati, oggetti seriali, 66–67, 71
IO, pin della scheda Arduino, 18–19, 62–65
G isolare i problemi, 88
gate, transistor MOSFET, 68
generatore di numeri pseudocasuali, 106
gestire carichi grandi, 68 J
giocattoli, modificare, 15 jumper, scelta dell’alimentazione, 18
Ghazala, Reed, 10
GND, pin, 58
K
Kernighan, Brian W., 88
H
Haque, Usman, 15
hardware, Arduino, 17–19 L
HIGH, 35, 96 lampada sferica, 72–83
Hopper, Grace, 86 lampade
HTML, codifica dei colori, 73 Aton, 71
gestire, 68
interattive, 36

sferiche, 72–83 numeri
lampade a incandescenza, gestire, 68 aritmetici e formule, 101
lampade interattive, 36 funzioni di generazione di numeri casuali, 106
LDR (light-dependent resistenze), 28, 61, 109 funzioni matematiche, 104–105
LED funzioni trigonometriche, 104–105
controllato da un pulsante, 40–49 variabili, 96–98
far lampeggiare, 28–36 numeri casuali, funzioni di generazione di, 106
lampada sferica, 72–83
modulazione di larghezza di impulso (PWM),
54–60 O
RGB a 4-terminali, 82 oggetti, seriali, 66–67, 71
sensori di luce, 60–61 ohm, 39
simboli, 109 Ohm, Georg, 39
LED controllati da un pulsante, 40–49, 109 Olivetti, 14
LED RGB a 4 terminali, 82 operatore di decremento, 102
legge di Ohm, 39–40 operatore di incremento, 102
leggere resistenze e condensatori, 93–94 operatore di uguaglianza, 42–43
Linux, 20 operatori
long random, funzione, 106 booleani, 101
long, variabile, 97 compound, 101–102
loop, funzione, 33, 35 di confronto, 101
LOW, 35, 96 operatori di confronto, 101
Low Tech Sensors and Actuators, 15 or, operatore, 101
luce. Vedere anche lampade; LED OUTPUT, 34–35, 96
gialla che lampeggia, 86 output
giocare con la, 36 analogici, 54–60, 71
LDR (light-dependent resistenze), 28, 61 digitali, 34–38, 71
misuratori a infrarossi, 68–69 funzioni, 102–106
modulazione di larghezza di impulso (PWM),
54–60
luce lampeggiante gialla, 86 P
parentesi, 34
parentesi graffe, 32–33, 95
M Pentland, Alex, 13
Macintosh persistenza della visione, 54–60
driver, installazione, 21 Physical Computing, definizione, 3
identificazione delle porte, 23 Physical Interaction Design, 3
Making Things Talk, 69 Pike, Rob, 88
map, function, 105 pinMode, funzione, 34, 102
matematiche, funzioni, 104–105 pin, scheda Arduino
Max, 8 analogici IO, 18–19
max, funzione, 104 digitali IO, 18–19
messa a terra, pin, 58 terra, 58
millis, funzione, 103 transistor MOSFET, 68
min, funzione, 104 PIR (sensori a infrarossi passivi), 53, 54, 83
misuratori a infrarossi, 68–69 Pirola, Maurizio, 87
misuratori a ultrasuoni, 68–69 piste, breadboard, 58
modificare Playground, Wiki, 16, 89
circuit bending, 10–11 PolyFuse, 87
giocattoli, 15 porte COM, Windows, 24–25, 88–89
rifiuti, 14 potenziometro, simbolo, 109
tastiere, 12–13 pow, funzione, 105
modulazione di larghezza di impulso (PWM), 54–60 The Practice of Programming, 88
modulo, 101 Processing, 1, 20, 67, 73–80
Moog, Robert, 8 programmazione
MOSFET, transistor, 68 abs, funzione, 104
motori, gestire, 68 analogRead, funzione, 62–65, 103
analogWrite, funzione, 54–56, 63–65, 103
argomenti, 34
N bouncing, 47–49
nomi, blocchi di codice, 32–33 calcoli, 101
NG, scheda, 18–19, 86 caratteri speciali, 95–96
not, operatore, 101 ciclo, 20

commenti, 33, 34–35 PWM (modulazione di larghezza di impulso), 54–60
constrain, funzione, 104 PWR_SEL, 18
costanti, 34, 96
cos, funzione, 105
#define, 34, 44 R
delay, funzione, 35, 104 RAM, 44
delayMicroseconds, funzione, 104 random, funzione, 106
digitalRead, funzione, 40, 62, 102 randomSeed,funzione, 106
digitalWrite, funzione, 35, 102 Reas, Casey, 2
far lampeggiare un LED, 28–36, 62–65 reed relay, 51
far lampeggiare un LED, spiegazione del codice, register, shift, 103
34–36 resistenza, 39–40, 66
funzioni, 32–33, 102–106 resistenze
funzioni di generazione di numeri casuali, 106 leggere, 93–94
funzioni seriali, 106–107 light-dependent (LDR), 28, 61
funzioni temporali, 103–104 necessarie per costruire un circuito, 41
if, istruzione, 42–43 simbolo, 109
lampada sferica, 73–80 variabile, 39
LED controllato da un pulsante, 40–49 resistenze variabili, 39
loop, funzione, 33, 35 return, struttura di controllo, 100
map, funzione, 105 ricevere dati, oggetti seriali, 66–67, 71
matematiche, funzioni, 104–105 rifiuti, 14
max, funzione, 104 rilevare il movimento
millis, funzione, 103 accelerometri, 68–69
min, funzione, 104 carpet switch, 51
modulazione di larghezza di impulso (PWM), interruttori a inclinazione, 52, 54
54–60 interruttori magnetici, 51
oggetti seriali, 66–67, 71 reed relay, 51
operatori booleani, 101 sensori a infrarossi passivi, 53, 54
operatori compound, 101–102 riprodurre i problemi, 88
operatori di confronto, 101 risoluzione dei problemi
parentesi graffe, 32–33, 95 aiuto online, 89–90
pinMode, funzione, 34, 102 circuito su breadboard, 87–88
pow, funzione, 105 IDE (Integrated Development Environment),
pulseln, funzione, 103 88–89
RAM, 44 panoramica, 85–86
random, funzione, 106 riproduzione dei problemi, 88
randomSeed, funzione, 106 scheda Arduino, 86–87
Serial.available, funzione, 107 Windows, 88–89
Serial.begin, funzione, 106
Serial.flush, funzione, 107
Serial.print, funzione, 106–107 S
Serial.println, funzione, 107 schemi, circuiti, 108–109
Serial.read, funzione, 107 schemi, simboli, 108–109
setup, funzione, 33, 34 selezionare le porte, 23–25
shiftOut, funzione, 103 sensori
sin, funzione, 105 a infrarossi, 53, 54, 83
stato, 45–46 accelerometri, 68–69
struttura, 95 analogici, 62–66
strutture di controllo, 98–100 carpet switch, 51
tan, funzione, 105 complessi, 68–69
tipi di dati, 96–98 far lampeggiare un LED, 62–65
val, 44–46 interruttori a inclinazione, 52, 54, 83
variabili, 43–44, 96–98 interruttori magnetici, 51
visuale, 8 luci, 60–61
void, tipo di funzione, 34–35 misuratori a infrarossi, 68–69
programmazione visiva, 8 misuratori a ultrasuoni, 68–69
protezione dalla corrente, 87 modificare tastiere, 13
prototipazione, 6 on/off, 51–54
proxy, 73 panoramica, 28
pulseln, funzione, 103 pulsante, 40
punto e virgola, 44, 95 reed relay, 51
Pure Data, 8 schema di un circuito, simboli, 109

termistori, 66 oggetti seriali, 66–67, 71
termostati, 51, 54 operatori booleani, 101
sensori a infrarossi, 53, 54 operatori compound, 101–102
sensori a infrarossi passivi (sensori PIR), 53, 54, 83 operatori di confronto, 101
sensori complessi, 68–69 parentesi graffe, 32–33, 95
sensori on/off, 51–54 pinMode, funzione, 34, 102
Serial.available, funzione, 107 pow, funzione, 105
Serial.begin, funzione, 106 pulseln, funzione, 103
Serial.flush, funzione, 107 RAM, 44
Serial.print, funzione, 106–107 random, funzione, 106
Serial.println, funzione, 107 randomSeed, funzione, 106
Serial.read, funzione, 107 scaricare, 30
seriale sensori a infrarossi passivi, 54–60
comunicazione, 23–25, 66–67, 71, 88–89, Serial.available, funzione, 107
106–107 Serial.begin, funzione, 106
oggetti, 66–67, 71 Serial.flush, funzione, 107
porte, 23–25, 88–89 Serial.print, funzione, 106–107
setup, funzione, 33, 34 Serial.println, funzione, 107
shift register, 103 Serial.read, funzione, 107
shiftOut, funzione, 103 setup, funzione, 33, 34
simboli shiftOut, funzione, 103
programmazione (Vedere caratteri speciali) sin, funzione, 105
schemi, 108–109 stato, 45–46
sin, funzione, 105 struttura, 95
sintetizzatori, analogici, 8 strutture di controllo, 98–100
sketch tan, funzione, 105
abs, funzione, 104 tipi di dati, 96–98
analogRead, funzione, 62–65, 103 val, 44–46
analogWrite, funzione, 54–56, 63–65, 103 variabili, 43–44, 96–98
argomenti, 34 void, tipo di funzione, 34–35
bouncing, 47–49 Sniffin’ Glue, 11
calcoli, 101 Somlai-Fischer, Adam, 15
caratteri speciali, 95–96 Source, pin del transistor MOSFET, 68
caricare, 31 stato, 45–46
commenti, 33, 34–35 string, variabile, 97–98
compilare, 31, 44 struttura, sketch, 95, 98–100
constrain, funzione, 104 strutture di controllo, 98–100
cos, funzione, 105 suono, misuratori a ultrasuoni, 68–69
costanti, 34, 96 SV1, jumper, 86
#define, 34, 44 switch case, struttura di controllo, 98–99
delay, funzione, 35, 104
delayMicroseconds, funzione, 104
digitalRead, funzione, 40, 62, 102 T
digitalWrite, funzione, 35, 102 tan, funzione, 105
eseguire, 32 tastiere, modificare, 12–13
far lampeggiare un LED, 28–36, 62–65 termistori, 66, 109
far lampeggiare un LED, spiegazione del codice, termostati, 51, 54
34–36 testare un programma, Arduino, 86
funzioni, 32–33, 102–106 tinkering, 7
funzioni di generazione di numeri casuali, 106 tipi di dati, 96–98
funzioni seriali, 106–107 transistor, MOSFET (transistor a effetto di campo
funzioni temporali, 103–104 metallo-ossido- semiconduttore), 68
if, istruzione, 42–43 TRUE, 43
lampada sferica, 73–80
LED controllato da un pulsante, 40–49
loop, funzione, 33, 35 U
map, funzione, 105 UNICODE, 97
matematiche, funzioni, 104–105 unsigned int, variabile, 97
max, funzione, 104 unsigned long millis, funzione, 103
millis, funzione, 103 USB
min, funzione, 104 alimentazione, 18
modulazione di larghezza di impulso (PWM), oggetti seriali, 66–67
54–60

porte, Windows, 24–25, 88–89 W
testare, 86 while, istruzioni, 101
while, struttura di controllo, 99
Wiki, Playground, 16, 89
V Windows
val, 44–46 driver, installazione dei, 21–22
variabili, 42–44, 96–98 identificazione delle porte, 23, 24–25
Verify, pulsante, 31 risoluzione dei problemi, 88–89
Vista, Windows
driver, 22
identificazione delle porte, 24–25, 88–89 X
risoluzione dei problemi, 88–89 XML, proxy, 73
void, tipo di funzione, 34–35 XP, Windows
volt, 39 driver, 21–22
Volta, Alessandro, 39 identificazione delle porte, 24–25, 88–89
voltaggio, 39–40 risoluzione dei problemi, 88–89
VVVV, 8

della stessa collana
Aggiorna e ripara il tuo PC La sicurezza delle applicazioni web
Robert Bruce Thompson, Barbara Tecniche di testing e prevenzione
Fritchman Thompson Paco Hope e Ben Walther
480 pag. • ISBN: 978-88-481-1976-4 328 pag. • ISBN 978-88-481-2317-4
34,90 € 34,90 €
Costruire Reti Wireless - II ed. Linux Networking Cookbook

Rob Flickenger Carla Schroder
176 pag. • ISBN: 978-88-481-1579-7 632 pag. • ISBN: 978-88-481-2223-8
24,90 € 49,90 €
Creare siti web ad alte prestazioni Linux – Guida per l’amministratore

Steve Souders di rete
160 pag. • ISBN: 978-88-481-2089-0 Tony Bautts, Terry Dawson,
16,90 € Gregor N. Purdy
352 pag. • ISBN: 978-88-481-1844-6
Don’t make me think - II Ed. 34,90 €
Un approccio di buon senso all’usabilità
web Ruby Cookbook con elementi di Rails
Steve Krug Lucas Carlson, Leonard Richardson
216 pag. • ISBN: 978-88-481-1866-8 688 pag. • ISBN: 978-88-481-1981-8
24,90 € 44,90 €
I segreti della fotografia digitale Programmare in C++ - II ed.

Tim Grey Steve Oualline
256 pag. • ISBN: 978-88-481-2292-4 592 pag. • ISBN: 978-88-481-1868-2
29,90 € 39,90 €
Imparare Python - III Ed. Programmare in JavaScript

Mark Lutz Shelley Powers
770 pag. • ISBN: 978-88-481-2090-6 352 pag. • ISBN: 978-88-481-2058-6
54,90 € 29,90 €
iPod e iTunes Reti domestiche

Missing Manual Missing Manual
J.D. Biersdorfer Scott Lowe
344 pag. • ISBN: 978-88-481-1977-1 250 pag. • ISBN: 978-88-481-1843-9
29,90 € 24,90 €

LI 09 2424 9

Massimo Banzi
Questo piccolo ma prezioso manuale offre un’ottima introduzione alla è il progettista e co-fondatore
piattaforma open source per la prototipazione elettronica basata su del progetto. Ha trascorso
quattro anni presso
hardware e software flessibili e facili da usare. l’IDII (Interaction Design
È stata creata per artisti, designer, hobbisti e chiunque sia interessato a Institute Ivrea), tiene corsi
creare oggetti o ambienti interattivi. e conferenze presso le più
La scheda Arduino è in grado di interagire con l’ambiente in cui si trova prestigiose istituzioni.
È stato software architect
ricevendo informazioni da una grande varietà di sensori e controllando
per clienti del calibro di
luci, motori e altri attuatori. Italia Online, Sapient,
L’autore, creatore e co-fondatore del progetto Arduino, è l’italiano BT, MCI WorldCom,
Massimo Banzi, quindi non c’è persona migliore di lui che possa spiegare SmithKlineBeecham,
le idee di base e fornire spunti creativi per nuovi progetti. Storagetek, Prada, Artemide,
Persol, Whirlpool e Adidas.
L’idea di fondo è che con strumenti a basso costo (la scheda)
e gratuiti (il software) si possono realizzare progetti interessanti,
originali e anche divertenti.
Gli argomenti trattati:
A progettazione delle interazioni e physical computing;
A l’hardware Arduino e l’ambiente di sviluppo software;
A concetti di elettronica;
A i fondamenti della prototipazione e della progettazione
… e molto altro ancora.

Banzi, Massimo - Arduino, Guida Ufficiale

Caricato da

Informazioni sul documento

Titolo originale

Copyright

Formati disponibili

Condividi questo documento

Condividi o incorpora il documento

Opzioni di condivisione

Hai trovato utile questo documento?

Questo contenuto è inappropriato?

Copyright:

Formati disponibili

Banzi, Massimo - Arduino, Guida Ufficiale

Caricato da

Copyright:

Formati disponibili

LA PIATTAFORMA

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

© Tecniche Nuove 2009

Traduzione di Barbara Sansone

Stampa: Andersen, Borgomanero (NO)

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

2/La filosofia di Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 5

3/La piattaforma Arduino. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 17

4/Cominciare a lavorare davvero con Arduino . . . . . . . . . . . . . . . . . . . . . . . 27

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

5/Input e output avanzati. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 51

6/Comunicare con la Rete. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . .71

7/Risoluzione dei problemi. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 85

Indice analitico. . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . . 110

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Alcuni anni fa mi fu proposta una sfida molto

In realtà, quando andavo a scuola avevo già imparato qualcosa di elettronica in un

Cominciai a pensare al processo grazie al quale avevo imparato concretamente i

» Smontavo tutti i dispositivi elettronici su cui riuscivo a mettere mano.

» Cominciai a costruire alcuni kit allegati a riviste di elettronica.

Da bambino, sono stato sempre incuriosito da come funzionavano le cose e

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Dopo molte dissezioni, imparai a conoscere i componenti elettronici e le loro

vi Arduino – La guida ufficiale

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Tinkering, fondamentalmente, è un processo che coniuga gioco e ricerca.

Al mio ritorno cominciai a risparmiare, perché volevo comprare un computer e

Più di vent’anni dopo, mi piace pensare che questa esperienza mi permette di

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Bill Verplank per avermi insegnato molto sul Physical Computing.

Hernando Barragan per il lavoro svolto su Wiring.

Adam Somlai-Fisher, Ailadi Cortelletti, Alberto Pezzotti, Alessandro Germinasi,

viii Arduino – La guida ufficiale

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Per acquistare la scheda e la componentistica necessaria alla realizzazione dei

Il sito del libro

Il sito web O’Reilly di Arduino – La guida ufficiale presenta esempi, errata

Avvertenze importanti per il lettore

L’utilizzo delle istruzioni e dei suggerimenti in Arduino – La guida ufficiale è a

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Arduino è una piattaforma open source di physical

» È un ambiente multipiattaforma; disponibile per Windows, Macintosh e Linux.

» È un hardware e software open source: volendo, si può scaricare il diagramma

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

» Esiste un’attiva comunità di utenti, pertanto si possono trovare moltissime

» Il Progetto Arduino è stato sviluppato in un ambiente didattico e quindi è ideale

Quando Arduino cominciò a diffondersi, mi accorsi che sperimentatori, hobbisti

L’Interaction Design è il design di tutte le esperienze interattive.

2 Arduino – La guida ufficiale

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Il campo specifico dell’Interaction Design che interessa Arduino è il Physical

Cos’è il Physical Computing?

Il suo scopo è la progettazione di oggetti interattivi che possano comunicare

In passato, usare l’elettronica significava doversi rivolgere a degli ingegneri e

Con Arduino, un designer o un artista può imparare molto rapidamente i concetti

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

La filosofia di Arduino si basa sul concetto di

L’ingegneria classica si basa su un processo rigido che porta da A a B; la filosofia

Questo è il processo di “tinkering” cui siamo tanto affezionati: giocare con il

E-Book acquistato da Alessandro Meloni (Cod. Ordine 364)

Moltissimi principianti che si avvicinano all’elettronica per la prima volta pensano di

Ecco perché abbiamo sviluppato una “prototipazione opportunistica”: perché perde-

» Smontavo tutti i dispositivi elettronici su cui riuscivo a mettere mano.

» Cominciai a costruire alcuni kit allegati a riviste di elettronica.

Tinkering, fondamentalmente, è un processo che coniuga gioco e ricerca. 

» È un ambiente multipiattaforma; disponibile per Windows, Macintosh e Linux.

» È un hardware e software open source: volendo, si può scaricare il diagramma

» Esiste un’attiva comunità di utenti, pertanto si possono trovare moltissime

» Il Progetto Arduino è stato sviluppato in un ambiente didattico e quindi è ideale

» Collegate la scheda a una porta USB del vostro computer.

» La scheda esegue lo sketch che avete scritto.

Installare Arduino sul computer  