Page 1


Questo ebook contiene materiale protetto da copyright e non può essere copiato, riprodotto, trasferito, distribuito, noleggiato, licenziato o trasmesso in pubblico, o utilizzato in alcun altro modo a eccezione di quanto è stato specificamente autorizzato dall’editore, ai termini e alle condizioni alle quali è stato acquistato o da quanto esplicitamente previsto dalla legge applicabile. Qualsiasi distribuzione o fruizione non autorizzata di questo testo così come l’alterazione delle informazioni elettroniche sul regime dei diritti costituisce una violazione dei diritti dell’editore e dell’autore e sarà sanzionata civilmente e penalmente secondo quanto previsto dalla Legge 633/1941 e successive modifiche. Questo ebook non potrà in alcun modo essere oggetto di scambio, commercio, prestito, rivendita, acquisto rateale o altrimenti diffuso senza il preventivo consenso dell’editore. In caso di consenso, tale ebook non potrà avere alcuna forma diversa da quella in cui l’opera è stata pubblicata e le condizioni incluse alla presente dovranno essere imposte anche al fruitore successivo.


di Brock Craft

EDITORE ULRICO HOEPLI MILANO


Wiley, the Wiley Logo, For Dummies, the Dummies Man Logo, The Dummies Way and related trade dress are trademarks or registered trademarks of John Wiley& Sons, Inc. and/or its affiliates in the United States and/or other countries. Windows is a registered trademarks of Microsoft Corporation. Wiley, il logo Wiley, For Dummies, il logo Dummies Man, Il metodo For Dummies e la relativa grafica sono marchi o marchi registrati di John Wiley& Sons, Inc. e/o dei suoi affiliati negli Stati Uniti e/o in altri paesi. Windows è un marchio registrato di Microsoft Corporation. Titolo originale: Arduino® Projects For Dummies Copyright © 2013 John Wiley & Sons, Ltd, Chichester, West Sussex, England All rights reserved, including the right of reproduction in whole or in part in any form Per l’edizione italiana Copyright © Ulrico Hoepli Editore S.p.A. 2014 via Hoepli 5, 20121 Milano (Italy) tel. +39 02 864871 – fax +39 02 8052886 e-mail hoepli@hoepli.it www.hoepli.it Seguici su Twitter: @Hoepli_1871 Tutti i diritti sono riservati a norma di legge e a norma delle convenzioni internazionali

ISBN EBOOK 978-88-203-6408-3 Traduzione: Paolo Poli Realizzazione: Maurizio Vedovati – Servizi editoriali (info@iltrio.it) Realizzazione digitale: Promedia, Torino


L’autore Brock Craft è docente presso il dipartimento Computing della Goldsmiths University of London. È anche Senior Tutor presso il Royal College of Art. È specialista in uso applicativo del computer, visualizzazione dei dati e Internet of Things. La formazione di Brock è nel campo delle interazioni uomo-macchina, con oltre un decennio di esperienza nella creazione di oggetti interattivi da utilizzare, esplorare e con cui giocare. È stato co-direttore della società di consulenza di design Tinker London, insieme ad Alexandra Deschamps-Sonsino e Massimo Banzi, uno dei fondatori del progetto Arduino. Ha insegnato a centinaia di persone a creare oggetti con schede Arduino. Quando non è impegnato a insegnare o a studiare, Brock ama realizzare oggetti interattivi e installazioni artistiche digitali.


Dedica A Barbara, che mi ha sostenuto così fermamente in questo incredibile viaggio e senza la quale questo libro non sarebbe nato. Ha messo almeno tanto impegno quanto me nella sua realizzazione. Inoltre dedico questo libro a mia madre, Lea Gaydos, che mi ha insegnato che posso realizzare tutto ciò che mi viene in mente. Con riconoscenza, dedico questo libro anche alla memoria di Craig Veal, il migliore insegnante che abbia mai avuto. E in particolare questo libro è per Eleanor, che riesca a crescere per creare tutto ciò che desidera nel suo mondo, con creatività.


Ringraziamenti Innanzitutto vorrei ringraziare Massimo Banzi e l’intero staff di Arduino. La loro lungimiranza ha regalato la gioia della programmazione e dell’elettronica a milioni di persone e ha rivitalizzato i miei studi e i miei insegnamenti. La realizzazione di questo libro è stata un processo difficile, ma ricco di soddisfazioni, che non sarebbe stato possibile senza il supporto di molti colleghi e amici. Voglio esprimere particolari ringraziamenti ad Alexandra Deschamps-Sonsino, senza i cui consigli questo libro non avrebbe visto la luce. Inoltre voglio esprimere la mia gratitudine a tutti i membri di TinkerLondon, lo straordinario Nick Weldin e anche Peter Knight, da cui ho imparato così tanto grazie al lavoro che abbiamo svolto insieme. L’acume meccanico di mio padre è, senza dubbio, all’origine della mia passione e lo ringrazio per le molte ore trascorse a riflettere e lavorare insieme. Apprezzo anche i contributi e il supporto dei miei amici Jason Geistweidt, James Larsson, Patrick Burkart e Carl Wiedemann, le cui domande mi hanno sollecitato a riflettere meglio dal punto di vista dei lettori. Molti dei miei studenti hanno offerto utili suggerimenti, alcuni dei quali sono contemplati in queste pagine. Un particolare ringraziamento al mio editor tecnico e collega di TinkerLondon, Daniel Soltis, che ha dedicato molte ore alla realizzazione dei progetti partendo da zero e a scoprirne gli errori. Ha offerto utili suggerimenti per migliorare sia i progetti sia il codice. Le eccellenti intuizioni di Daniel sul modo in cui si realizzano i progetti, insieme alle sue correzioni e ai suoi trucchi del mestiere, hanno rappresentato un contributo immenso. Voglio inoltre manifestare la mia gratitudine al team di Wiley, compreso Craig Smith, così paziente e motivatore, e a Beth Taylor per i suoi eccellenti consigli editoriali.


A colpo d’occhio

Parte I: Introduzione ai progetti Arduino Capitolo 1: Il mondo di Arduino Capitolo 2: Predisposizione dello spazio e degli strumenti di lavoro Capitolo 3: Elementi di base

Parte II: Semplici progetti con Arduino Capitolo 4: L’occhio a scanner Capitolo 5: Un pupazzetto luminoso Capitolo 6: Un’insegna scorrevole Capitolo 7: Un orologio sveglia

Parte III: Casa e giardino interattivi Capitolo 8: Un sistema di controllo degli accessi Capitolo 9: Un lettore di RFID Capitolo 10: Un terrazzo automatizzato Capitolo 11: Controllare l’andirivieni di un gatto Capitolo 12: Una stazione di rilevamento domestica

Parte IV: Progetti avanzati con Arduino Capitolo 13: Registratore di percorsi GPS Capitolo 14: Un’automobilina telecomandata Capitolo 15: Un cubo a LED Capitolo 16: Dieci soluzioni per dieci problemi

Indice analitico


Indice

Introduzione Perché Arduino? Ma voi... chi siete? La sicurezza e i progetti Arduino Organizzazione del libro Il sito web del libro Icone utilizzate Parte I: Introduzione ai progetti Arduino Capitolo 1: Il mondo di Arduino Che cos’è Arduino A chi serve Arduino? Che cosa sono i microcontroller Per iniziare Capitolo 2: Predisposizione dello spazio e degli strumenti di lavoro Preparativi Procurarsi gli strumenti Scelta del saldatore e degli accessori Scatole e contenitori per i progetti Scelta della scheda o del kit Arduino Configurazione di Arduino sul computer Capitolo 3: Elementi di base I concetti chiave Le basi dell’elettronica Identificare i componenti elettronici Sensori e attuatori Mettere in funzione i progetti Parte II: Semplici progetti con Arduino Capitolo 4: L’occhio a scanner I componenti


Realizzazione del circuito Il funzionamento del codice Come funziona l’hardware Il potenziale di un potenziometro Capitolo 5: Un pupazzetto luminoso I componenti Costruzione del circuito Come funziona il codice Come funziona l’hardware Capitolo 6: Un’insegna scorrevole I componenti Realizzazione del circuito Il funzionamento del codice Come funziona l’hardware Capitolo 7: Un orologio sveglia Tutta una questione di tempo! I componenti Parte III: Casa e giardino interattivi Capitolo 8: Un sistema di controllo degli accessi I componenti Assemblaggio e installazione del sistema Capitolo 9: Un lettore di RFID Che cosa sono i codici RFID Realizzazione di un lettore RFID ID-Innovations Collaudo e configurazione del lettore RFID Capitolo 10: Un terrazzo automatizzato Creazione di un sistema di annaffiatura I componenti Realizzazione del sistema Programmazione, calibrazione e collaudo Capitolo 11: Controllare l’andirivieni di un gatto I componenti Collaudo del circuito Preparazione dell’account Twitter Realizzazione del codice Modifiche allo sportello del gatto Capitolo 12: Una stazione di rilevamento domestica Costruzione dei sensori


Creazione di un account Xively Programmazione della stazione di rilevamento Parte IV: Progetti avanzati con Arduino Capitolo 13: Registratore di percorsi GPS Il sistema GPS I componenti Realizzazione del progetto Raccolta e tracciamento dei dati GPS Capitolo 14: Un’automobilina telecomandata I componenti Il rilevatore e il sistema di guida Realizzazione del telaio Capitolo 15: Un cubo a LED I componenti Realizzazione del cubo Programmazione del cubo Il software di progettazione di animazioni per il cubo a LED Capitolo 16: Dieci soluzioni per dieci problemi Soluzioni per problemi hardware Controllo delle connessioni Verifica dell’alimentazione Alla ricerca di odori molesti e di componenti bollenti Controllare le uscite per i dispositivi esterni Verifica dei pin digitali Soluzione dei problemi software Controllare la sintassi Uso del Monitor seriale Controllate gli input e gli output Uso di un simulatore o di un emulatore Se, nonostante tutto, non funziona Indice analitico Informazioni sul Libro


Introduzione

A

vete sentito parlare di Arduino e volete provare a utilizzarlo? Magari avete un amico che ha utilizzato una scheda per realizzare uno strano progetto o un apparecchietto interattivo. O magari avete una scheda Arduino da qualche parte e avete sempre pensato di doverla mettere all’opera, ma non avete mai avuto il tempo per farlo. Bene! È tempo di rispolverarla! Magari avete solo bisogno di qualche spunto interessante e di progetti divertenti da realizzare nel tempo libero o nei weekend. Se è così, questo può essere un libro che fa al caso vostro. I progetti presentati mostrano alcune delle incredibili capacità di Arduino e possono essere realizzati anche da chi è senza esperienza e completamente a digiuno di elettronica. Può essere ottimo anche come compagno di altri libri su Arduino che potete aver acquistato o sfogliato. Questo libro è una ricca raccolta di oggetti curiosi e divertenti che potete realizzare con una scheda Arduino. In queste pagine offro un’intera gamma di spunti interessanti che potrete realizzare senza troppa fatica. Soprattutto, ho selezionato i progetti in modo che la loro realizzazione vi darà tutte le competenze tecniche per creare tutti i gadget, gli oggetti e gli apparecchi interattivi che possono venirvi in mente. Che siate principianti o esperti conoscitori di Arduino, questi progetti sono molto divertenti da realizzare e vi solleciteranno a esplorare nuove idee creative.

Perché Arduino? Arduino è sempre più popolare, specialmente fra hobbisti, smanettoni e modellisti. Tutte persone che si occupano di oggetti curiosi e interessanti, che potrete creare con Arduino. Ed è rivolto a tutti, dai bambini ai ricercatori universitari, fino agli artisti e ai progettisti. Una cosa che distingue Arduino da molte altre piattaforme è il fatto che chiunque può scrivere nuovi programmi da utilizzare sulla scheda e da condividere online. Ancora più interessante è il fatto che esistono moltissime librerie di codice con le quali potrete estendere ciò che Arduino è in grado di fare, consentendogli di connettere fotocamere, motori, stampanti, scanner, telecomandi e quasi ogni altro apparecchio, per tante applicazioni fra l’utile e il divertente. Tutti sono in grado di creare codice per Arduino e di condividerlo online, e così la comunità cresce a vista d’occhio. Arduino ha rinnovato l’interesse nel campo dell’elettronica e ha dato origine a spazi in cui chiunque può realizzare oggetti interessanti, come robot autonomi, stampanti 3D e opere d’arte interattive.

Ma voi... chi siete? Probabilmente avete un’idea di che cos’è Arduino e forse ci avete già anche giocherellato un po’. Magari avete anche qualche rudimento di elettronica, ricordi delle scuole superiori, ma non ve ne rendete neanche conto o ricordate a malapena i principi. Bene, non è un problema, poiché affronteremo tutto ciò che è necessario sapere e spiegheremo le basi del funzionamento dei circuiti elettronici, in particolare di ciò che utilizzeremo per far funzionare i progetti. Sicuramente avete già provato a scrivere del codice. Ma anche se non avete mai programmato prima d’ora, il funzionamento dei programmi verrà descritto in dettaglio. In tal modo imparerete a programmare con Arduino per svolgere non solo le operazioni descritte in questo libro, ma tutto ciò che desiderate. Suppongo anche che vogliate utilizzare Arduino per fargli fare qualcosa per conto proprio, senza che debba contare su un computer per l’alimentazione o la connessione dati. Ebbene, tutti i progetti di questo libro possono operare anche senza che la scheda Arduino sia connessa al computer. Un’altra cosa: sicuramente avete un computer e sapete utilizzarlo piuttosto bene, quanto meno per copiare e trasferire file e, in generale, sapete come funziona un computer. Suppongo anche che sappiate scaricare dei file compressi da Internet ed estrarli.


La sicurezza e i progetti Arduino Quando si utilizza l’elettricità, la sicurezza è fondamentale. Se connettete qualcosa in modo errato, potreste danneggiare l’hardware o voi stessi, specialmente se state operando con l’alimentazione domestica. Questo è il motivo per cui nessuno dei progetti proposti sarà connesso direttamente alla presa di rete. Tutti i progetti usano bassa tensione e componenti a corrente continua. È semplicemente il modo più sicuro di operare. Tuttavia, potreste comunque bruciare qualcosa. Dovreste dedicare particolare attenzione a eseguire i contatti sulla base degli schemi elettrici forniti. A margine del testo trovate delle icone che richiamano l’attenzione su determinati passaggi. Alcuni progetti richiedono piccole operazioni di fabbricazione, per le quali occorre indossare occhiali di sicurezza. Quando dovrete eseguire saldature, fate attenzione alla punta del saldatore. Fate sì che la vostra postazione di lavoro sia un ambiente sicuro e produttivo.

Organizzazione del libro Ho organizzato il libro partendo dai progetti più semplici, per poi passare a quelli più complessi. Ma se vi sentite particolarmente attratti da un progetto, potete anche saltarvi direttamente. Date un’occhiata all’indice, per vedere cosa affrontare per primo e se potete trascurare qualcosa. Le parti del libro sono divise in capitoli che aiutano a trovare con maggiore facilità ciò che state cercando.

Parte I: Introduzione ai progetti Arduino Dovreste consultare la Parte I prima di iniziare, per assicurarvi di essere pronti per partire e che lo spazio di lavoro abbia il necessario per svolgere le attività richieste. Qui troverete le basi per la configurazione dell’ambiente di lavoro; nel Capitolo 2 vedremo come procurarci gli elementi e gli attrezzi necessari. Vedremo anche come collegare la scheda Arduino a un computer.

Parleremo anche delle altre schede Arduino e suggeriremo quali sono più adatte alle varie applicazioni, anche se tutti i progetti del libro possono essere realizzati con la scheda più popolare : Arduino UNO. Esamineremo anche la configurazione di Arduino, fornendo alcuni suggerimenti sulla preparazione di un progetto. Molte guide online su Arduino trascurano la realizzazione di un contenitore, mentre qui troverete alcuni suggerimenti creativi in proposito. Il Capitolo 3 descrive le basi della realizzazione del codice Arduino e della realizzazione fisica dei progetti. Se non sapete proprio nulla di programmazione per Arduino, dovreste assolutamente leggere questo capitolo. Tutti coloro che hanno utilizzato una scheda Arduino sono partiti da un LED lampeggiante e questo è ciò che faremo nel Capitolo 3. Vedremo anche il genere di cose che potete fare con Arduino: rilevare valori ambientali ed eseguire varie attività. Troverete anche una panoramica del tipo di componenti elettronici che potete trovare sul mercato, con alcuni suggerimenti sulla saldatura e la realizzazione dei progetti.

Parte II: Semplici progetti con Arduino La Parte II si occupa di luci e calcolo dei tempi. Il Capitolo 4 impiega ancora dei LED, descrivendo la creazione di un display simile a quello di K.I.T.T. o dei Cylon di Battlestar Galactica. Il Capitolo 5 crea con tre LED lampeggianti un animaletto dotato di personalità. Il Capitolo 6 usa i LED per un’applicazione più funzionale: la scrittura con la luce, in cui la temporizzazione è un fattore chiave. Il Capitolo 7 conclude il tutto con un’altra applicazione che riguarda il tempo: la realizzazione di un orologio sveglia. Questo è il progetto più avanzato della Parte II e dunque, se siete alle prime armi, lasciatelo per ultimo.


Parte III: Casa e giardino interattivi La Parte III è dedicata a chi è affascinato dai sensori e dall’automazione domestica. La mania dell’automazione delle abitazioni è nata negli anni Ottanta, ma con Arduino si aprono nuovi orizzonti. Il Capitolo 8 insegna a realizzare un sistema di controllo degli accessi a tastierino, una cosa molto “James Bond”. Quando lo avrete completato, potrete estenderne le funzionalità con il lettore di badge del Capitolo 9. Potrà entrare in casa solo chi è dotato della tessera appropriata. Dopo aver semplificato l’accesso in casa, potrete realizzare il sistema di irrigazione delle piante del Capitolo 10. In tal modo, anche quando ve ne andrete per un lungo viaggio, le vostre piante o anche il vostro piccolo giardino domestico, resterà in salute. Già che state rendendo più intelligente la casa, darete una nuova voce anche ai vostri animali domestici. Lo sportello Twitter per animali domestici del Capitolo 11 darà al vostro cane o gatto una voce online. Sarete così in grado di sapere quando entra e quando esce e Arduino si connetterà direttamente a Internet, senza alcun computer. L’ultimo progetto della Parte III si spinge ancora più avanti e mostra come connettere i dati prodotti dai sensori domestici a un sistema online. Nel Capitolo 12 realizzerete una stazione di rilevamento domestica che invia informazioni relative alla temperatura e ai livelli di luminosità accessibile via Internet. Potete perfino incorporarne i grafici nel vostro sito web. Una volta che vi sarete impratichiti del codice, potrete collegare a Internet praticamente ogni sensore di casa, del giardino o della casa sull’albero.

Parte IV: Progetti avanzati con Arduino Ho riservato alcuni dei miei progetti preferiti per l’ultima parte. Il Capitolo 13 insegna a realizzare un registratore di dati GPS. Non dovrete più contare sul GPS dell’auto o dello smartphone. Potete utilizzarlo per registrare i dati su una scheda Micro SD. Il progetto ha moltissimi impieghi, compreso il tracciamento di veicoli, pacchetti, animali domestici e la registrazione delle esplorazioni della città o del territorio. Nessun libro di progetti elettronici può dirsi completo senza un apparecchio telecomandato. Il Capitolo 14 insegna a realizzare un’automobilina utilizzando due confezioni di patatine. La cosa interessante è che potrete controllarla con un vecchio telecomando. Dopo aver realizzato questo progetto, avrete fra le mani un interessante veicolo, ma avrete anche appreso le basi dell’uso dei servomotori e di una scheda Arduino per controllare praticamente tutto ciò che è controllabile. Il Capitolo 15 torna a giocare con la luce. I cubi LED sono sempre più popolari e se non ne avete ancora visti in giro, vi accadrà ben presto. Questo capitolo mostra come realizzarne e programmarne uno. Troverete anche uno strumento online per la realizzazione di schemi colorati animati. Sia il codice sia la realizzazione pratica sono piuttosto complessi, ma i risultati sono veramente impressionanti. Se, come me, siete affascinati dalle luci lampeggianti, questo progetto vi piacerà moltissimo.

Il sito web del libro Associato a questo libro vi sono alcune risorse online utili per lo svolgimento dei progetti: http://www.hoeplieditore.it/6323-9.

Molti progetti richiedono delle librerie di codice aggiuntive per poter funzionare. Potete trovare queste librerie in file compressi sul sito web del libro. Oltre al sito web di questo libro, potete anche visitare il mio sito web personale, www.brockcraft.com. Chiunque conosca Arduino è felice di aiutare gli altri a migliorare il codice e i progetti. E se avete suggerimenti per migliorare o estendere i miei progetti, fatemelo sapere!

Icone utilizzate


Le icone seguenti evidenziano delle informazioni particolarmente utili, anche se talvolta indicano le parti dove c’è un po’ da sudare. Ecco il significato di ogni simbolo:

Questo bersaglio vi aiuterà a risparmiare tempo e denaro o semplicemente vi aiuterà a semplificare le cose. Vi divertirete molto di più se terrete conto di questi suggerimenti.

La realizzazione di progetti può essere problematica e anche pericolosa. Queste note sono collocate là dove è possibile commettere errori e bruciare qualcosa o complicarsi la vita. Queste icone vi aiutano a non imparare le cose nel modo più duro... probabilmente perché è quello che è capitato anche a me.

Talvolta ci sono elementi importanti che dovreste tenere in considerazione quando si lavora su un progetto o si programma uno sketch. Questa icona evidenzia alcuni punti critici. In tal modo li potrete trovare con facilità quando realizzerete un progetto o costruirete qualcosa di nuovo.

Quest’omino un po’ nerd compare vicino alle parti che potete tranquillamente saltare, se siete interessati solo ai fondamenti e a vedere il risultato. Le basi tecniche sono utili, ma non essenziali per realizzare i progetti. Tuttavia ho incluso queste note per farvi conoscere meglio il funzionamento delle cose.


Parte I Introduzione ai progetti Arduino

I listati e le risorse grafiche dei capitoli sono disponibili sul sito www.hoeplieditore.it/6323-9.


In questa parte‌ Predisporre lo spazio di lavoro di Arduino. I vari tipi di schede Arduino. Elementi di base della programmazione di Arduino. Componenti elettronici e tecniche di saldatura.


Capitolo 1

Il mondo di Arduino In questo capitolo Scoprire Arduino Chi usa Arduino I microcontroller Le funzionalità di Arduino

P

robabilmente non avreste neppure acquistato questo libro se non aveste già almeno sentito parlare del favoloso “Mondo di Arduino”. Anzi, probabilmente già ne fate parte. Arduino è una comunità di persone creative, interessate a far sì che degli oggetti inanimati facciano cose interessanti e utili impiegando un computer, un po’ di programmazione e un po’ di elaborazione, ovvero tramite “ricette”. Si tratta di considerare i problemi, valutare le soluzioni possibili e cercare di determinare il modo migliore per realizzare queste soluzioni. Normalmente occorre decidere quali sono i passi migliori da compiere (e in quale ordine) e considerare le decisioni necessarie per giungere alla soluzione oppure ottenere le informazioni necessarie per prendere una decisione. Può trattarsi di fare qualcosa di semplice come cuocere un dolce (nel qual caso probabilmente non avrete neppure bisogno di un computer). Ma è comunque necessaria una minima potenza di calcolo per eseguire una semplice sequenza di passi e per prendere le decisioni necessarie per ottenere qualcosa di veramente creativo. Magari volete solo sapere quando il vostro gatto entra ed esce di casa; oppure volete sapere se le piante del vostro giardino hanno bisogno di un po’ di acqua in più e quando fornirla automaticamente; forse vorreste poter aprire la porta di casa con un codice o un ciondolo, invece di una chiave. Ognuna di queste operazioni richiede di sapere, almeno un po’, cosa accade nel mondo reale, e la capacità di prendere decisioni e di svolgere determinate azioni. Nel caso dell’annaffiatura delle piante, si tratta di una tipica attività che gli esseri umani tendono a trascurare, e alla quale si tende a non dedicare troppe attenzioni quotidiane. Sembra invece un compito perfetto per un computer. E in effetti è proprio in queste situazioni che Arduino può venire in nostro soccorso.

Che cos’è Arduino Arduino UNO (Figura 1.1) è una piattaforma di programmazione e per la realizzazione di prototipi; è dotata di un microcontroller ed è possibile programmarla con facilità, in modo che reagisca agli eventi del mondo reale. Potete anche collegare il mondo reale al mondo virtuale, connettendo Arduino a Internet, per far sì che invii dati alla Rete, che risponda ai dati provenienti da essa o per fare entrambe le cose. Potete utilizzare Arduino per rilevare praticamente qualsiasi entità per la quale esista un sensore elettronico: luce, temperatura, pressione, suono e perfino odori (se consideriamo l’inquinamento dell’aria come un odore). Potete perfino costruire i vostri particolari nuovi sensori. Arduino può reagire ai valori rilevati e agli eventi del mondo reale in base al modo in cui lo programmate. Potete utilizzare le sue funzionalità di output per attivare allarmi, per aprire porte e finestre o per attivare luci e motori: le possibilità sono praticamente infinite.


Figura 1.1 La scheda Arduino UNO.

Arduino viene utilizzato per sviluppare prototipi: approntare un meccanismo e provare se funziona. Realizzare prototipi significa collaudare più alternative che derivano dall’individuazione di soluzioni creative dei problemi. Potete collaudare una parte di un progetto per vedere come rispondono i sensori e poi cambiare il funzionamento del programma Arduino, in base a ciò di cui avete bisogno. Potete considerare i progetti presentati in queste pagine un po’ come piccole ricette, punti di partenza. Nulla vi impedisce di utilizzare questi progetti per sviluppare idee e progetti più elaborati.

A chi serve Arduino? La famiglia di schede Arduino viene utilizzata da hobbisti, hacker, progettisti, artisti, architetti e perfino tecnici professionisti con lo scopo di provare con facilità e rapidità i progetti interattivi di cui hanno bisogno. La scheda Arduino UNO è molto economica, facile da utilizzare, ed è supportata da una grande comunità di sostenitori, appassionati e sviluppatori che scoprono continuamente nuovi modi di utilizzarla e migliorarla. Nei prossimi paragrafi, parleremo proprio dei tipi di persone e di comunità che utilizzano quotidianamente Arduino.

Studiare con Arduino Arduino rappresenta un metodo molto semplice per imparare a programmare i microcontroller in modo che rilevino e reagiscano agli eventi del mondo reale e perfino agli eventi che accadono online. Essendo stata concepita come uno strumento per progettisti e creativi, persone che non hanno particolare dimestichezza con la programmazione dei computer, Arduino è una piattaforma molto facile da apprendere e da impiegare. Si tratta di una piattaforma veramente adatta a tutti, dai bambini agli adulti: è possibile predisporre semplici programmi in meno di mezz’ora; nell’arco di un weekend potete acquisire un livello di abilità tale da consentirvi di creare progetti piuttosto elaborati. Come vedrete dai progetti presentati in questo libro, non ci vuole poi molto per far sì che Arduino svolga qualche operazione piuttosto interessante. Più tempo dedicherete alla sperimentazione, più cose riuscirete a fare. Nei corsi di arte e progettazione, Arduino viene impiegato per realizzare nuovi prototipi interattivi, opere d’arte interattive, performance e perfino abiti. Nelle scuole secondarie, Arduino viene impiegato per insegnare i concetti di base della programmazione dei computer. Nei corsi universitari di ingegneria e informatica, si può utilizzare Arduino per creare modelli interattivi e prototipi e per introdurre sofisticati concetti di ingegneria nel campo del controllo numerico.

Lavorare con Arduino Sempre più professionisti utilizzano schede Arduino in ambito aziendale per realizzare progetti interattivi da impiegare nel lavoro. Chi si occupa di progettazione può utilizzare Arduino per sviluppare nuovi prodotti interattivi. Gli sviluppatori di software possono utilizzarlo per collaudare sistemi software che hanno la necessità di interagire con il mondo fisico. Chi si occupa di pubblicità


può utilizzare schede Arduino per realizzare campagne pubblicitarie creative e interattive. Schede Arduino vengono comunemente utilizzate per controllare i grandi pannelli impiegati in mostre e conferenze, ma anche nel campo della produzione e dei media digitali. Vengono utilizzate anche come strumenti di supporto per aiutare i team a coordinare la soluzione dei problemi e per promuovere la collaborazione.

Le comunità di hobbisti Un po’ in tutto il mondo sta emergendo una nuova comunità di hobbisti, sperimentatori e hacker. Arduino è la linfa vitale di questo nuovo rifiorire di creatività, e continua a essere una delle principali piattaforme di prototyping hardware: sempre più persone la usano per creare progetti e sempre più appassionati ne parlano e condividono idee.

Di cosa si occupano? Vi sono stati club di hobbisti hardware fin dai primi anni del Ventesimo secolo, quando i giovani venivano incoraggiati a costruire piccole radio per ascoltare le stazioni che sorgevano un po’ dappertutto. Nel corso dei decenni, si è così sviluppata una grande comunità di appassionati di elettronica e radioamatori, patiti delle onde corte. Questi radioamatori arrivavano a costruire i propri ricetrasmettitori e dedicavano ore e ore ad ascoltare le onde radio, cercando di captare nuove trasmissioni da amici o da emittenti lontane. Negli anni Settanta, viene il tempo di una nuova generazione di appassionati dell’elettronica, che cominciano a ritrovarsi non solo per costruire radio, ma anche per lavorare sui primi home computer. Quante notti sono state consumate nel tentativo di correggere il codice e di scambiarsi idee sulle prime rudimentali BBS online! Questo è stato il terreno fertile che ha visto sbocciare alcuni dei giganti di oggi, fra cui Apple. Poi è esploso il fenomeno di Internet e tutto è cambiato. Mentre veniva concepito Arduino, nel 2005 [Arduino è una realizzazione italiana, N.d.T], emerse una piccola sottocultura, una emanazione dei gruppi di appassionati di computer e fai-da-te. Grazie a Internet, vi è stato una sorta di rinascimento di gruppi di sviluppatori e appassionati, il Web ha reso più semplice connettere insieme computer e apparecchi elettronici per creare interessanti oggetti interattivi, fino a generare un vero e proprio “movimento”. Arduino si è collocato perfettamente in questi gruppi di hobbisti, hacker e appassionati. Esistono ormai centinaia di gruppi in tutto il mondo. Se vivete in una città di medie dimensioni, probabilmente ne troverete uno non troppo lontano. Controllate se ne esiste uno nella vostra zona. Questi sono i luoghi migliori per imparare a realizzare oggetti interessanti con Arduino.

Il mondo open-source Il termine open-source è perfino abusato di questi tempi. Se non lo avete ancora incontrato, vi capiterà presto, poiché Arduino è uno degli aspetti del mondo open-source. Open-source è sia una filosofia sia un approccio allo sviluppo di software che promuove la più completa trasparenza in ogni fase dello sviluppo. In questo modo chiunque può vedere come è stato realizzato un programma e perfino contribuire al suo sviluppo. Il movimento open-source è sorto per reazione al rigido controllo che le case produttrici di software impongono sui propri prodotti. Il loro codice è loro proprietà intellettuale e le case ne mantengono il controllo per impedire a chiunque di sottrarre loro le idee e per mantenere costante la qualità dei loro prodotti. Tuttavia, l’aspetto negativo è che i consumatori sono scoraggiati dall’apportare modifiche e addirittura talvolta sono costretti ad acquistare costosi aggiornamenti di cui non hanno affatto bisogno. In linea di principio, chiunque abbia le competenze tecniche necessarie può intervenire e contribuire allo sviluppo di software open-source, in quanto il codice è tutto online e liberamente scaricabile. Il sistema operativo Linux, il sistema operativo Google Android e il browser web Mozilla Firefox sono alcuni degli esempi più noti di software opensource. L’idea che anche l’hardware del computer possa essere open-source è relativamente recente e Arduino è in prima linea in questo senso. È stato concepito come uno strumento che chiunque può utilizzare per creare prototipi utilizzando il microcontroller ATmega328. Tutti gli schemi per produrre una scheda Arduino sono liberamente disponibili online e potete realizzarla senza mai dover pagare nulla a nessuno. Nei fatti è normalmente più economico acquistare una scheda già montata e pronta all’uso, ma rimane il principio che gli schemi sono liberamente disponibili.

Contribuire al progetto Arduino Nello spirito dello sviluppo collaborativo, tutti sono anche invitati a partecipare allo sviluppo della piattaforma Arduino e una nutrita comunità di appassionati ha contribuito sia allo sviluppo dell’hardware sia alla realizzazione delle molte librerie software oggi disponibili, che estendono le funzionalità di Arduino. Se volete mettervi all’opera, non dovete fare altro che unirvi a una


conversazione di sviluppatori online, ma potete anche scrivere nuove librerie per conto vostro. Se siete veramente abili, potreste anche contribuire allo sviluppo della prossima scheda Arduino.

Che cosa sono i microcontroller Il cuore di una scheda Arduino è un microcontroller, un piccolo computer che svolge umili compiti decisionali che possono essere troppo noiosi, troppo rapidi, troppo lenti o comunque inadatti a un essere umano. Potete far sì che il microcontroller resti in ascolto di determinati eventi del mondo reale e vi reagisca in qualche modo. Una scheda non ha alcun problema a rimanere in attesa per giorni e giorni, finché non arriverà quel periodo di estrema calura, quando si attiverà per dare alle piante di casa quel goccio di acqua in più. Dovete semplicemente dirle cosa aspettare e quali azioni intraprendere. E potrete realizzare il tutto in dimensioni veramente minime. Essendo un microcontroller, è molto piccolo e non ha neppure bisogno di molta energia; pertanto può essere inserito in qualsiasi spazio, per esempio in una scatola da progetti. Quanto sono piccoli i microcontroller? Fisicamente, quello installato sulla scheda Arduino è grande più o meno la metà delle dimensioni di un pacchetto di gomme da masticare (Figura 1.2). Il microcontroller è un circuito integrato (IC – Integrated Circuit) rettangolare, installato su un circuito stampato (PCB – Printed Cuircuit Board). Ha quelle dimensioni per poter essere facilmente afferrabile con le dita, in modo da poterlo sostituire sulla scheda Arduino qualora dovesse guastarsi per qualsiasi motivo. Ma i microcontroller possono avere dimensioni variabili. I fattori che determinano le loro dimensioni sono le funzionalità che offrono e il costo. In realtà l’effettivo microprocessore (core) presente nel chip di Arduino è molto, molto più piccolo rispetto alle dimensioni esterne del circuito integrato. Insieme al microprocessore, che elabora le istruzioni fornite, il chip è dotato di una piccola area per la memorizzazione dei comandi, chiamata memoria del programma o RAM (Random-Access Memory), utilizzata per memorizzare i valori impiegati dal programma. Inoltre ha delle periferiche di input e di output, per gestire lo scambio di dati con il mondo reale, con altri computer e, impiegando codice appropriato, con Internet. I microcontroller sono stati inventati all’inizio degli anni Settanta per svolgere ogni genere di compito di automazione per l’industria. Arduino usa il microcontroller single-chip ATmega328, che fa parte della famiglia di prodotti AVR del produttore Atmel, ed è stato sviluppato, originariamente, a metà degli anni Novanta. Il grande vantaggio dei microcontroller è che sono estremamente economici, a differenza dei loro fratelli maggiori, i microprocessori che sono presenti nei computer, nei portatili, nei tablet e negli smartphone. I microcontroller sono economici in quanto offrono funzionalità limitate. Sono progettati principalmente per controllare qualcosa o per rispondere all’input di sensori e sono chiamati sistemi embedded. I computer, al contrario, offrono funzionalità più generali e richiedono più energia; pertanto sono anche molto più costosi e impiegano microprocessori di utilizzo generale.

Figura 1.2 Il “cervello” di Arduino: un microcontroller ATmega328.

Proprio per il fatto che sono economici, potete utilizzarli per ogni genere di compito per il quale non avete bisogno di impiegare un intero computer, per esempio, per aprire la porta di casa con un


codice. Il microcontroller presente su una scheda Arduino è estremamente economico. Il resto del prezzo di una scheda Arduino è dovuto a tutti gli elementi che vi sono presenti e che aiutano il microcontroller a ricevere i programmi e a interagire con il mondo.

Usare piccoli computer per compiti utili I microcontroller sono come piccoli cavalli da soma invisibili che ci circondano un po’ dappertutto, lavorando instancabilmente e continuativamente per rendere la vita moderna ancora più confortevole. Ci aprono le porte (letteralmente), ci divertono e sono in grado di preparare un’ottima tazza di caffè. Ci assicurano anche di poter andare dal punto A al punto B in piena sicurezza, essendo presenti su aerei, treni e, naturalmente, automobili e motociclette. Ecco alcuni esempi dei modi in cui già li utilizziamo e dei progetti che troverete in questo libro. Non è un elenco esaustivo, ma dovrebbe darvi un’idea degli scopi per cui vengono utilizzati i microcontroller e della loro grande diffusione.

Giocattoli e passatempi Provate a visitare un negozio di giocattoli: troverete centinaia di dispositivi che camminano, parlano, lampeggiano, fanno l’occhiolino e addirittura rispondono al modo in cui posizionate le loro parti o al modo in cui parlate. Perfino i giocattoli interattivi più economici includono dei microcontroller che svolgono le stesse funzionalità di una scheda Arduino. Generalmente sono microscopici e progettati in modo specifico per la produzione di massa; spesso sono nascosti sotto una goccia di resina epossidica nera sul circuito stampato di un giocattolo (Figura 1.3). Alcuni prodotti utilizzano addirittura un microcontroller della stessa famiglia Atmel. Sono stati programmati in fabbrica per rispondere agli input attivando luci, suoni e movimenti.

Figura 1.3 Qui il microcontroller è nascosto sotto una resina epossidica.

Anche se non è interattivo, il pupazzetto luminoso che realizzerete nel Capitolo 5 è un semplice giocattolo preprogrammato, non diverso da quelli che potete trovare in commercio. Non è interattivo, ma prima di portare a termine alcuni dei progetti presentati in questo libro, potrete farlo rispondere in modo interattivo alla luce, al tocco, alla temperatura e ad altri tipi di input.

Elettrodomestici La vostra cucina è letteralmente il centro di controllo di una fondamentale missione digitale. Molti degli elettrodomestici che utilizzate quotidianamente per preparare pranzo e cena contengono microcontroller. Il forno a microonde ha un timer per controllare i livelli di potenza e i tempi. Il forno tradizionale offre funzionalità analoghe. La macchina del caffè ha funzioni di temporizzazione e programmi differenti per preparare vari tipi di infusi e caffè. I sistemi di cottura più avanzati percepiscono la consistenza del cibo e hanno sistemi di spegnimento di sicurezza. Tutte queste funzionalità sono dovute alla presenza di microcontroller che rilevano una serie di valori e


reagiscono a ciò che avviene attorno a loro. L’orologio Arduino del Capitolo 7 dà un’idea di ciò che è possibile fare, e realizza una vera sveglia programmabile. Con poca fatica potrete connettere il suo allarme a una macchina per il caffè.

Produzione automatizzata Se state utilizzando più componenti per costruire un prodotto, è fondamentale ricorrere a sistemi di automazione e i microcontroller saranno di grande aiuto. Che si tratti di un’automobilina telecomandata o di una vera automobile, i microcontroller impiegati nella catena di montaggio garantiscono la corretta collocazione delle parti, verificano eventuali errori di produzione, controllano l’alimentazione dei componenti, calcolano automaticamente gli inventari e svolgono tante altre attività utili. La loro capacità di rilevare le caratteristiche dell’ambiente in cui operano e di rispondere rapidamente e sulla base di un programma garantiscono che i prodotti costruiti abbiano tutti lo stesso livello qualitativo e che gli inventari dei prodotti siano sempre aggiornati. Il lettore di radiofrequenze realizzato nel Capitolo 9 utilizza la stessa tecnologia RFID impiegata da molti sistemi di controllo degli inventari per gestire materie prime, componenti e interi magazzini.

Rilevamento e intervento I microcontroller possono essere collocati in situazioni in cui sarebbe poco pratico o pericoloso impiegare una persona. Immaginate di voler garantire che una fuga in una condotta di gas non generi un’esplosione. Un microcontroller incorporato nella condotta può garantire la chiusura dell’erogazione qualora venga rilevato un calo anomalo di pressione. Analogamente, non vorrete certo pagare qualcuno che controlli costantemente il livello di umidità in giardino. Un microcontroller può attivare l’impianto di irrigazione a intervalli fissi e anche sulla base delle condizioni misurate nell’ambiente. Il sistema di irrigazione automatica realizzato nel Capitolo 10 è una versione domestica ricca di utili funzionalità.

Produzione automatizzata Sapete certamente che esistono sistemi di sicurezza che hanno lo scopo di tenere lontani gli intrusi. Oltre questi, molti edifici utilizzano sensori per rilevare il clima nell’abitazione e le condizioni di efficienza energetica. Gli architetti progettano edifici sempre più moderni e dotati di un intero “sistema nervoso” di sensori in grado di regolare automaticamente la temperatura in specifiche zone o nelle singole stanze, impiegando riscaldamento, condizionamento e ventilazione ad alta efficienza. Il progetto presentato nel Capitolo 12 è una versione ridotta di una rete di sensori che potete disporre in casa per controllare questo genere di apparecchi.

Controllo dei processi I microcontroller vengono utilizzati nell’industria per attività di controllo e rilevamento nelle catene di montaggio. Per esempio, i microcontroller possono controllare che tutte le bottiglie della linea di produzione vengano riempite fino al livello corretto. I microcontroller, dotati di opportuni sensori, possono rilevare con facilità e rapidità eventuali problemi e comunicarli a un computer centrale o attivare un sistema in grado di rimuovere la bottiglia mal riempita. L’operazione può essere svolta con molta più rapidità e affidabilità rispetto a quanto possa fare un essere umano. Molti processi di produzione utilizzano microcontroller per il fatto che sono economici e affidabili. Analogamente la miscelazione delle materie prime per la produzione di pane, caramelle, prodotti petroliferi o cementizi può essere monitorata con precisione e controllata grazie a microcontroller, esattamente identici a quello presente in una scheda Arduino. Sebbene nessuno dei progetti di questo libro svolga questo genere di attività, dopo aver realizzato alcuni dei progetti capirete come sia facile modificarli, rielaborarli e scegliere le funzionalità desiderate per costruire un progetto in grado di controllare ogni tipo di processo o attività.

Per iniziare Se non vi siete già gettati a capofitto sui capitoli centrali del libro, per scoprire che cosa potete fare, provate a sfogliarli ora. Ho scritto questo libro per farvi apprezzare alcuni interessanti progetti realizzati con Arduino e per consentirvi di costruire qualcosa di straordinario, che nessuno si sognerebbe mai. Spero che questi progetti vi siano di ispirazione. Una ricerca online vi aiuterà sicuramente a trovare nuovi spunti e stimoli per sviluppare la vostra creatività. Ma prima di iniziare, è opportuno che vi dotiate di alcuni strumenti che renderanno molto più


semplici le vostre avventure con Arduino. Tutti i progetti di questo libro richiedono alcuni strumenti molto semplici (e una scheda Arduino). Se siete già pronti a iniziare, tanto meglio! Ma dedicate almeno un minuto al Capitolo 2, per scoprire cosa dovete procurarvi. Se non avete mai usato Arduino prima d’ora, date un’occhiata anche al Capitolo 3, che presenta le basi di cui avete bisogno, prima di gettarvi nella realizzazione dei progetti.


Capitolo 2

Predisposizione dello spazio e degli strumenti di lavoro In questo capitolo Configurazione dello spazio di lavoro per la preparazione dei progetti Scelta degli strumenti adatti Scelta della scheda o del kit Arduino Configurazione del progetto Arduino

L’ approntamento dello spazio di lavoro è il primo passo per la creazione di un progetto con Arduino. Potete svolgere i primi progetti presentati in questo libro praticamente ovunque, ma per realizzare qualcosa di più complicato, è meglio creare una postazione di lavoro dedicata, dove avrete a portata di mano tutti gli strumenti di cui avete bisogno. In questo capitolo impareremo a creare uno spazio di lavoro adatto, con tutti gli strumenti necessari per svolgere i progetti presentati nel libro. I capitoli dedicati ai progetti presuppongono che abbiate già approntato lo spazio di lavoro e gli strumenti necessari e dunque verranno elencati solo i componenti di cui avrete bisogno per realizzare il progetto. Una volta che avrete iniziato a svolgere un progetto, il fatto di dovervi interrompere per procurarvi uno strumento importante e che avete dimenticato può essere un problema. Ma se avete già raccolto la maggior parte degli strumenti di cui avete bisogno (meglio ancora, tutti gli strumenti), non avrete mai bisogno di interrompere il lavoro per procurarvi quel tale strumento o per recarvi in un negozio di hobbistica. Qui vedremo anche come configurare il software di Arduino e come connettere la scheda Arduino al computer.

Preparativi Potete iniziare a lavorare su progetti Arduino ovunque abbiate la possibilità di accedere a un computer. Ho personalmente svolto alcuni dei progetti proposti al tavolino di un caffè, anche se qualcuno, in effetti, mi guardava un po’ storto! Tuttavia, per realizzare i progetti presentati in queste pagine, è meglio predisporre un ambiente di lavoro appropriato. Trovate una zona in cui possiate lavorare in modo confortevole, in cui possiate avere la completa visione di tutto ciò che state facendo e configuratelo in modo che diventi un laboratorio perfetto per le vostre creazioni.

Predisposizione dello spazio di lavoro Avete bisogno di un’area dedicata, nella quale costruire e collaudare i vostri progetti, specialmente quelli più articolati fra quelli presentati in questo libro, la cui realizzazione può richiedere anche alcune ore. Trovate in casa, in laboratorio, in garage o in studio, un luogo in cui possiate lavorare indisturbati. La Figura 2.1 mostra la mia postazione di lavoro per la realizzazione di progetti con Arduino.


Figura 2.1 Un buon ambiente di lavoro con alcuni semplici strumenti.

Scegliere uno spazio di lavoro adatto Uno spazio di lavoro adatto per la realizzazione di progetti con Arduino deve avere le seguenti caratteristiche. Essere un ambiente comodo e non umido. Un tavolo o una scrivania ben solidi, con una sedia confortevole. Una certa abbondanza di prese di corrente. Uno spazio sufficiente per un computer fisso o portatile. Una connessione di rete o un luogo in cui possiate connettervi alla rete. Essere ben illuminato e ventilato (in particolare per la dispersione dei fumi di saldatura). Mensole e contenitori per collocarvi i progetti su cui state lavorando. Piccole scatole e cassettiere per sistemare in modo ordinato componenti e strumenti. L’ambiente (illuminazione, riscaldamento, comfort e così via) deve essere piuttosto comodo e permettere di lavorare anche a lungo. Se dovesse essere troppo freddo o caldo, troppo rumoroso o troppo ricco di distrazioni, avrete bisogno di più tempo per terminare il lavoro. Inoltre, se verrete interrotti, avrete bisogno di un po’ di tempo per riprendere il filo delle attività.

Ricavatevi una zona tranquilla, in cui possiate rimanere concentrati. Io, per esempio, amo ascoltare musica elettronica mentre lavoro, per creare una sorta di “barriera sonora” in grado di creare una zona privata nella quale possa concentrarmi completamente sul lavoro. La presenza di un computer è fondamentale per le attività di creazione dei progetti; dunque assicuratevi di avere spazio per il computer fisso o portatile nel vostro spazio di lavoro. Inoltre ne avrete bisogno per andare alla ricerca di informazioni online, per ricercare datasheet e per inviare domande ai forum; pertanto è fondamentale che vi sia anche una connessione a Internet.


Ottimizzazione della zona Arduino I progetti più semplici presentati in questo libro possono essere completati in un’ora o anche meno. Ma quelli più complessi richiederanno parecchie ore. Inevitabilmente subirete interruzioni e dunque avrete bisogno di un luogo in cui possiate anche lasciare progetti incompleti, sui quali ritornare in seguito.

La sicurezza è sempre un fattore importante quando si lavora su circuiti elettrici. Anche se i progetti di questo libro non impiegano l’alta tensione erogata dalla presa di corrente domestica, dovete sempre trattare i progetti elettronici come se operassero con tensioni potenzialmente pericolose. Se in casa vi sono bambini, dovrete dedicare particolari precauzioni, per proteggerli. È naturale che le loro piccole dita curiose siano irresistibilmente attratte dai fili colorati e da tutti quei piccoli e strani componenti. Se un bambino dovesse aggrapparsi a un cavo che penzola, potrebbe tirarsi tutto quanto in testa. Un saldatore lasciato incustodito può procurare gravi ustioni. Non è esattamente il modo migliore per introdurre i piccoli ai piaceri di Arduino e dell’elettronica. Difficilmente sul piano di lavoro potranno mancare lattine di bibite e snack vari. Tuttavia è meglio tenerli un po’ discosti, per evitare costosi incidenti.

Il semplice cartone vuoto di una pizza può nascondere dei componenti importanti, che potreste impiegare ore a trovare. Anche le bibite rovesciate da una lattina, in genere non vanno troppo d’accordo con i circuiti sotto tensione. Ora che avete predisposto lo spazio necessario, avete bisogno di procurarvi gli strumenti adatti per il lavoro.

Procurarsi gli strumenti Sono necessari alcuni semplici strumenti per fabbricare i progetti descritti in questo libro. Sostanzialmente rientrano in due categorie: strumenti elettronici e utensili. Potrete procurarvi la maggior parte dei componenti necessari presso i rivenditori di componenti elettronici. In genere i rivenditori che operano via Internet sono un po’ più economici rispetto ai rivenditori fisici e molti componenti possono essere acquistati su eBay e Amazon. Ecco un elenco degli strumenti di cui avrete bisogno, e che descriveremo più in dettaglio nel resto del libro. Un tester (multimetro). È uno strumento essenziale per la maggior parte dei progetti Arduino ed elettronici in genere. Ne avrete bisogno per svolgere semplici test per assicurarvi che arrivi alimentazione ai circuiti elettronici. Potete impiegarlo per misurare le caratteristiche di un circuito elettrico e scoprire che cosa non funziona. Un tester è comodo anche per controllare e misurare le caratteristiche dei componenti elettronici. È importante averlo a disposizione anche per risolvere i problemi dei progetti. Una breadboard e una serie di ponticelli. Tutti i progetti di questo libro prevedono la connessione alla scheda Arduino di componenti elettronici, LED, sensori o attuatori. A volte basta collegare uno o due fili, ma alcuni dei progetti richiedono decine di connessioni. Una breadboard è un semplice strumento che facilita la connessione dei componenti elettronici. I ponticelli sono utili per eseguire le connessioni quando si mette insieme un progetto. Esistono ponticelli realizzati con filo rigido e filo a treccia (costituita da più fili sottili). Per lavorare con una breadboard è necessario impiegare ponticelli realizzati con fili rigidi. Un saldatore. Una breadboard è l’ideale per eseguire connessioni temporanee e per realizzare


prototipi, ma in generale è necessario realizzare contatti più permanenti. Per farlo è necessario un saldatore. Un saldatore consente di eseguire contatti fissi e duraturi fra i componenti del circuito elettrico. Se volete installare dei pulsanti sul contenitore del progetto, probabilmente vorrete saldare dei fili ai pulsanti, da connettere poi alla scheda Arduino. Potete anche realizzare parte del circuito su una breadboard e utilizzare connessioni saldate per gli interruttori e i sensori che sono posti a una certa distanza. Potete completare tutti i progetti presentati in questo libro senza mai utilizzare un saldatore, ma è sempre meglio averne uno a disposizione. Una fonte di alimentazione. Arduino è grado di fornire l’energia necessaria per alimentare alcuni LED, ma per fare qualcosa di più, probabilmente avrete bisogno di un’altra fonte di alimentazione. In questo libro, alcuni progetti richiedono un’alimentazione esterna. Le specifiche sono indicate nell’elenco dei componenti. Avrete inoltre bisogno di alcuni utensili leggeri. Non tutti sono indispensabili, ma spesso scoprirete di aver bisogno proprio dello strumento che vi manca e dunque è sempre opportuno attrezzarsi un po’ di tutto in anticipo. Questi strumenti, rappresentati nella Figura 2.2, sono elencati di seguito secondo il mio personale ordine di importanza, anche se le necessità, in realtà, dipendono da persona a persona. Una certa selezione di cacciavite. Avrete bisogno di alcuni cacciavite a taglio e a stella. È bene avere una buona selezione di entrambi i tipi. Un supporto “terza mano” dotato di due coccodrilli per trattenere l’oggetto su cui state lavorando. Normalmente questo oggetto è dotato anche di una lente di ingrandimento. È un oggetto fondamentale per tutti coloro che… non sono dotati di tre mani.

Figura 2.2 Alcuni attrezzi fondamentali per lavorare.

Spelafili. Si usa per tagliare i fili e per spelare l’isolante dai fili. Ne esistono di vari tipi e anche i prezzi sono molto variabili. Una buona regola empirica suggerisce di scegliere un attrezzo di prezzo medio. Un attrezzo troppo economico potrebbe non fornire i risultati desiderati e, alla lunga, essere frustrante da usare. Piccola pinza a becchi conici. Comoda per trattenere oggetti sottili. Potete procurarvene di due diverse dimensioni. Piccolo tronchesino. Potete utilizzarlo per tagliare i piedini dei componenti e i fili. Coltellino. È importante per eseguire tagli precisi. Taglierina. Utile per tagliare materiali di un certo spessore. Piano di taglio. Utile per proteggere la superficie di lavoro. Matita e pennarello indelebile. Strumenti essenziali per tracciare segni di taglio e segni permanenti. Nessuna postazione di lavoro può dirsi completa senza un pennarello indelebile.


Scelta e uso di un tester Un tester, come quello rappresentato nella Figura 2.3, è uno strumento essenziale per collaudare i circuiti, per eseguire misurazioni e per diagnosticare i problemi nei circuiti elettronici. I vecchi tester impiegavano un ago e una scala graduata per la visualizzazione, mentre quelli più moderni usano un display digitale. Potete utilizzare un tester per misurare alcune caratteristiche di base di un circuito, fra cui le seguenti. Continuità. Determina se esiste un buon contatto fra due punti. Tensione. Misura la differenza di potenziale elettrico tra due punti in un circuito. Corrente. Misura il flusso continuo e uniforme di elettroni attraverso un percorso non interrotto in un circuito elettrico. Resistenza. Misura l’opposizione di un conduttore al passaggio della corrente elettrica.

Figura 2.3 Un tester digitale è uno strumento essenziale per il funzionamento di un progetto Arduino.

Potete inoltre usare il tester per misurare la tensione fornita da batterie e alimentatori e le caratteristiche dei componenti elettronici, come le resistenze e i diodi. Come nel caso del saldatore, tester differenti possono offrire funzionalità differenti e quelli più costosi possono offrire funzionalità di cui non avrete mai bisogno. I tester di prezzo più elevato consentono inoltre di misurare i transistor e i condensatori e offrono funzionalità utili, come l’individuazione automatica dei livelli. Gli apparecchi più economici richiedono invece una stima dell’intervallo di misurazione, da impostare preventivamente con una manopola. Sui tester automatici non avrete invece bisogno di impostare tramite la manopola l’intervallo di misurazione appropriato. Si tratta di apparecchi molto comodi, ma generalmente un po’ più costosi.

Probabilmente, l’attività per cui utilizzerete più comunemente un tester è il controllo della continuità: assicurarvi che due elementi che dovrebbero essere connessi siano effettivamente… connessi. Non avete bisogno di procurarvi la Ferrari dei tester, ma può essere utile spendere qualcosa di più per un tester dotato di un segnale acustico di continuità. Non è affatto facile controllare la continuità tenendo le punte del tester su un circuito e osservando


contemporaneamente il display. È molto più facile toccare qua e là con le punte e sentire se si produce il segnale acustico.

Scelta e uso di un alimentatore Alcuni dei progetti presentati richiedono l’impiego di più energia rispetto a quella che può essere fornita direttamente dalla scheda Arduino e potreste aver bisogno di costruire un progetto che controlla un motore, un solenoide o un altro dispositivo che deve poter contare su una propria fonte di alimentazione. Potete utilizzare delle batterie o un alimentatore dedicato, ognuno dei quali ha un utilizzo differente. Un portabatterie è utile per i progetti che richiedono una quantità limitata di energia per periodi di tempo relativamente brevi. I portabatterie sono anche essenziali se volete disconnettervi dal computer e lasciare che la scheda Arduino se ne vada in giro da sola non connessa, come nel caso dell’automobilina robotica realizzata nel Capitolo 14. Potete trovare portabatterie di tutti i tipi, per batterie compatte, in formato stilo (AA) o ministilo (AAA) o per le grosse batterie a torcia C e D. Naturalmente, potete impiegare batterie ricaricabili. In generale, più grosso è il portabatterie, maggiore è la durata. La maggior parte delle batterie cilindriche fornisce una tensione di 1,5 Volt (V) e sono necessari come minimo 6 V per alimentare i progetti Arduino. Dunque procuratevi un pacco batterie che contenga almeno quattro elementi (quattro batterie da 1,5 V l’una = 6 V). Se avete bisogno di una fonte di alimentazione più duratura, per qualcosa che andrà installato in modo permanente da qualche parte, dovreste utilizzare un alimentatore fisso, connesso a una presa di corrente domestica. Per esempio, se dovete utilizzare molti motori, questi dovranno essere alimentati in qualche modo. La corrente può provenire da un alimentatore da parete, in grado di offrire un livello di corrente sufficiente per le esigenze. Potete acquistare alimentatori dedicati in grado di fornire tensioni variabili e correnti regolabili tramite un display digitale, utili per costruire e collaudare progetti che verranno poi installati e alimentati in modo differente. Gli alimentatori più complessi sono anche più costosi, anche molto più costosi! Se decidete di procurarvene uno, un alimentatore in grado di fornire una tensione compresa fra i 12 e i 30 V in corrente continua (CC o DC) e da 3 a 5 Ampere (A) dovrebbe essere sufficiente (Figura 2.4). Potete però anche cavarvela con un alimentatore in grado di fornire dai 7 ai 12 V e 500 milliAmpere (mA) di corrente, sufficienti per alimentare la scheda Arduino offrendo anche un po’ di margine di sicurezza. Indipendentemente dal progetto su cui state lavorando, l’alimentatore deve fornire la tensione corretta e tutta la corrente assorbita dai dispositivi che state utilizzando. Dovrete utilizzare l’alimentatore fornito con gli apparecchi che state tentando di controllare o, in alternativa, dovrete scegliere un alimentatore che offra lo stesso livello di tensione e un livello di corrente pari o superiore rispetto ai dispositivi che intendete alimentare.

Figura 2.4 Un alimentatore professionale, un compatto alimentatore a 12 Volt e un piccolo alimentatore a parete.


Elettricità e norme di sicurezza Quando si lavora con i componenti elettronici, la sicurezza è un aspetto fondamentale. Dovrete prendere particolari precauzioni per proteggervi. Nessuno dei progetti presentati in questo libro prevede la connessione diretta all’alta tensione della rete domestica, ma dovreste comunque adottare particolari precauzioni e sviluppare corrette abitudini di sicurezza. Anche se vi troverete a lavorare solo con basse tensioni in corrente continua, impiegherete anche componenti, come motori e solenoidi, che richiedono molta corrente, più che sufficiente per darvi una “scossa” tutt’altro che piacevole. Pertanto è sempre opportuno seguire alcune regole di sicurezza quando si lavora su progetti elettronici.

Buone abitudini Eseguite sempre i test con una mano piegata dietro la schiena. In particolare curate almeno che una mano non poggi sul piano di lavoro. Se la corrente dovesse scorrere fra una mano e l’altra, attraverso il cuore, potrebbe provocarvi un’aritmia. Si tratta di una situazione molto improbabile date le basse tensioni in corrente continua che utilizzeremo, ma è sempre meglio lavorare in sicurezza e acquisire questa buona abitudine. I circuiti integrati di Arduino e gli altri componenti elettronici impiegati sono sensibili alle correnti spurie e all’elettricità statica. Sulla superficie del corpo potete sviluppare anche alcune migliaia di V di elettricità statica, specialmente se state lavorando su un tappeto o sulla moquette, e il tutto senza che possiate rendervene conto. Se ciò dovesse capitare e in quel momento toccate un progetto hardware, lo brucerete istantaneamente. Per scongiurare questa eventualità, potete acquistare un economico braccialetto antistatico, che scaricherà a terra ogni differenza di tensione. Indossate sempre un paio di occhiali di sicurezza. Il componente che state utilizzando può saltare via attraversando tutta la stanza, portando con sé i materiali di saldatura. Non è il caso di gettarsi lo stagno fuso negli occhi.

Cosa non fare Non toccate mai i contatti metallici o i fili di un circuito alimentato. Non lavorate mai su un circuito alimentato. Disconnettete sempre l’alimentazione prima di togliere o aggiungere componenti alla scheda Arduino o alla breadboard. Non lavorate mai a piedi scalzi. Aumentate la resistenza fra voi e il pavimento indossando calzature con suola di gomma. L’acqua è un ottimo conduttore e non è certo il caso di farsi trovare coi piedi immersi nell’acqua nel caso qualcosa dovesse andare storto.

Breadboard e basette millefori (perfboard e stripboard) Per comporre rapidamente e con facilità i circuiti dei vostri progetti, iniziate a utilizzare una breadboard. Una breadboard è una piccola tavoletta di plastica che offre righe e colonne di piccoli fori nei quali potete inserire direttamente ponticelli e componenti. Tutti i progetti di questo libro utilizzano una breadboard per la fase di realizzazione e collaudo. Una volta che il circuito funziona a dovere, potrete collocare la scheda Arduino e la breadboard in un contenitore oppure scegliere qualcosa di più permanente e costruire il vostro circuito direttamente su una basetta millefori, anche se ciò richiede un po’ più di lavoro con il saldatore (maggiori dettagli si possono trovare più avanti in questo stesso capitolo).

Che cosa sono le breadboard Sotto i piccoli fori di una breadboard, vi sono tanti piccoli morsetti metallici che trattengono i fili e i piedini dei componenti. Poiché i morsetti sono di materiale metallico, se connettete ponticelli o componenti alla stessa fila di morsetti, questi saranno connessi elettricamente.


Poiché le breadboard usano dei morsetti per trattenere i fili, dovreste sempre utilizzare ponticelli di fili solidi. I sottili fili a treccia si piegano e attorcigliano nel momento in cui vengono inseriti nei fori della breadboard. In sostanza i fili a treccia possono rappresentare un problema, che è meglio evitare. Nell’area di lavoro principale della scheda, i piccoli fori sono organizzati in file di 5 (normalmente), raggruppate in due colonne. Normalmente vi è un separatore centrale fra le due colonne di fori, per consentire l’inserimento di un circuito integrato; in tal modo ognuno dei suoi piedini sarà servito dai 4 fori adiacenti sulla stessa riga. Le breadboard sono dotate di due colonne di fori che ne percorrono l’intera lunghezza ai due lati della scheda. Si tratta di fori non connessi elettricamente all’area di lavoro principale e che riportano l’indicazione + (positivo) e - (negativo o terra), in genere colorata in modo appropriato. Utilizzatele come linee di sevizio per l’alimentazione e la terra. Quando usate una breadboard con Arduino, connettete sempre con un filo il pin 5V di Arduino alla colonna + e con un altro filo il pin GND (Ground, ovvero terra) alla colonna - . Potreste dover connettere molti componenti con un punto o l’altro della linea di alimentazione o di terra e dunque spesso avrete bisogno di una grande quantità di ponticelli. Dovreste procurarvi una grossa breadboard dotata di 830 punti di contatto e un paio di breadboard di medie dimensioni con 400 punti di contatto. Se doveste esaurire lo spazio, potrete sempre collegare fra loro due breadboard utilizzando gli incastri posti ai lati. Ma attenzione, tali incastri non sono standard e dunque le breadboard, in genere, devono essere dello stesso produttore.

Basette millefori (stripboard e perfboard) Le basette millefori sono simili alle breadboard, nel senso che offrono una grande quantità di fori per connettere tra loro i componenti. Tuttavia sono progettate per connessioni permanenti, saldate. Stripboard. Schede che posteriormente sono rivestite di piste di rame conduttivo, che garantiscono una buona connessione elettrica e un forte legame fisico. Perfboard. In queste schede ogni foro è circondato da un’area metallica. Potete saldare i componenti ai fori e poi saldare fra loro i fori per creare i vostri circuiti elettrici. Esistono basette millefori (perfboard e stripboard) in una grande varietà di dimensioni e configurazioni e dunque quando vorrete creare una soluzione più permanente, potrete acquistare basette delle dimensioni e del tipo più adatto (Figura 2.5).


Figura 2.5 Due esempi di breadboard (piccola in alto a sinistra e grande in basso) e un esempio di basetta millefori di tipo stripboard.

Scelta del saldatore e degli accessori Il saldatore, come potete immaginare, ha lo scopo di sciogliere la lega di stagno, che ha un punto di fusione relativamente basso (circa 185°C). Una volta raffreddato, lo stagno crea un forte legame conduttivo. Potete saldare due o più fili fra loro o saldare fili a componenti. Potete saldare fili e componenti alle basette millefori, creando così una connettività elettrica in grado di rendere un progetto più solido, duraturo e permanente. Potete anche saldare alcuni dei componenti (come gli interruttori e i display) a fili connessi poi alla breadboard. In tal modo, potrete collocarli nel contenitore che ospiterà il progetto. In alcuni progetti di questo libro, è il caso di spostare pulsanti e interruttori dalla breadboard al contenitore del progetto e a tale scopo dovrete saldare dei fili di estensione per i componenti, in modo da collegarli alla scheda. Inoltre, probabilmente vorrete acquistare dei kit in grado di dotare i progetti Arduino di ulteriori funzionalità. L’orologio Arduino del Capitolo 7 utilizza un kit che richiede la saldatura di alcuni componenti su un piccolo circuito stampato. Il fatto di vendere questi oggetti sotto forma di kit ne abbatte il costo, ma avrete bisogno di fare un po’ di lavoro con il saldatore. Il saldatore serve per riscaldare sia lo stagno sia i componenti che devono essere saldati. Quando i componenti sono sufficientemente caldi, lo stagno fonderà attorno ad essi e a quel punto potrete staccare la punta del saldatore (e pertanto la fonte di calore). Lo stagno si raffredda rapidamente e, se la saldatura è eseguita correttamente, forma un solido legame elettrico. I principali strumenti di saldatura sono i seguenti. Saldatore. Lo strumento principale per eseguire le saldature. Esistono saldatori molto economici, mentre quelli professionali possono essere anche molto costosi. Evitate di risparmiare troppo con i saldatori più economici e puntate sul massimo che potete permettervi nella fascia bassa di prezzo. È opportuno acquistarne uno da almeno 30 Watt (W). I saldatori possono avere una potenza fissa o regolabile. La possibilità di utilizzare una potenza regolabile è naturalmente positiva, ma non fondamentale per la maggior parte delle attività di saldatura che svolgeremo. Lega di stagno. Questo è il materiale grezzo che utilizzerete per saldare. Esistono varietà con e senza piombo. I puristi preferiscono utilizzare stagno con piombo in una percentuale 60/40 (60% di stagno e 40% di piombo), ma il piombo è tossico. Dunque, se non avete particolari esigenze, scegliete la varietà senza piombo, con nucleo di colofonia (rosin core). Il nucleo di colofonia fonde e aiuta a detergere le superfici da saldare. Esistono leghe di vari diametri, ma quello da 0,8 mm di diametro è ideale per la maggior parte delle esigenze di saldatura. Punte di ricambio. Esistono punte di varie forme e dimensioni. Per la maggior parte dei lavori avrete bisogno di una punta conica piuttosto che una punta piatta. Alla fine, quando l’avrete usata per molto tempo, la punta si consumerà. I vari produttori usano sistemi di fissaggio differenti della punta e dunque è sempre opportuno acquistare un paio di punte in più nel momento in cui si acquista il saldatore, per evitare di dover cercare in seguito il prodotto adatto. Supporto. Una forcella che sostiene il saldatore in sicurezza quando è caldo e dotata di una spugnetta per la pulizia della punta. Normalmente il supporto è incluso nel kit di saldatura. Normale spugna e spugna metallica. Queste spugne vengono utilizzate per pulire la punta del saldatore. La punta deve essere pulita mentre il saldatore è caldo. La normale spugna può essere una comune spugna da cucina, che potete acquistare ovunque. La spugna metallica ha il vantaggio di non raffreddare la punta del saldatore mentre la pulisce. Se pulita regolarmente, la punta può durare molto a lungo. Strumenti di dissaldatura. Potete trovare sia la treccia per dissaldatura sia la pompetta succhia-stagno (Figura 2.6). La pompetta è una sorta di penna caricata a molla che potete utilizzare per aspirare lo stagno liquefatto dal punto di lavoro. Una treccia per dissaldatura è semplicemente una treccia di rame che potete premere sulla saldatura mentre la state riscaldando. L’azione capillare attrae lo stagno liquefatto fra i fili della treccia. Personalmente preferisco usare la treccia, che è più economica e normalmente più efficace. Pasta di pulizia. È sempre importante averla a disposizione. La punta può sviluppare un rivestimento di ossido, specialmente se non viene pulita regolarmente. L’ossido ostacola la


fusione dello stagno. La pasta di pulizia aiuta a eliminare l’ossido e i detriti. È sempre una buona idea pulire la punta con la pasta di tanto in tanto, per garantire sempre che la superficie della punta sia pulita.

Le basi della saldatura sono descritte nel Capitolo 3, qualora vogliate fare un primo tentativo o affinare le vostre abilità.

Figura 2.6 Un saldatore economico e gli accessori essenziali.

Scatole e contenitori per i progetti Tutti i progetti di questo libro sono realizzati su breadboard, poiché questo è un modo rapido e semplice di procedere. Se però volete proteggere il vostro progetto, potete trasferirlo in un contenitore appropriato. Anche se non affronteremo questo argomento per i progetti più semplici presentati nella Parte II, potreste volerli racchiudere in una scatolina appropriata. In questo caso, procuratevi un contenitore che sia in grado di ospitare sia la scheda Arduino sia i componenti elettronici. Esistono moltissime possibilità per ospitare i progetti Arduino e quasi ogni contenitore sarà adatto alle esigenze. Alcuni dei “contenitori” più creativi e interessanti non sono stati neppure concepiti per ospitare progetti Arduino. Ho visto vecchi orologi da comò riutilizzati come display per la temperatura e pressione barometrica. Esiste anche un’intera sottocultura di persone che realizzano progetti Arduino utilizzando le scatolette metalliche delle caramelle Altoids o scatole da tabacco! Quando entrate in un negozio, iniziate a immaginare cosa potreste utilizzare per ospitare il vostro progetto. Quasi subito inizierete a vedere che praticamente tutto può essere considerato un contenitore per un progetto. È un’abitudine un poco malsana, ma inizierete davvero a vedere le cose in un modo differente. È sempre divertente trafficare con le confezioni di prodotti. I grandi magazzini e i negozi di arredamento come l’IKEA, vendono ogni genere di piccoli oggetti con un occhio all’estetica e al design. Ogni piccola scatola e confezione può essere riutilizzata per


ospitare un progetto Arduino e per dargli un po’ di stile. La Figura 2.7 mostra una piccola lampada acquistata al reparto bambini dell’IKEA. Estraete tutto il contenuto e questa diverrà un perfetto contenitore per un progetto Arduino.

Figura 2.7 Un simpatico contenitore per un progetto Arduino.

A parte i contenitori “creativi”, i fornitori di materiale elettronico offrono un’intera gamma di scatole generiche, in materiale metallico o plastico. Nella scelta, assicuratevi di possedere gli strumenti necessari per fabbricare il tutto. Se pensate di installare interruttori, pulsanti o un display su un pannello della scatola, avrete la necessità di forare e ritagliare il materiale in modo appropriato. È davvero difficile praticare un foro in un materiale spesso e di metallo senza utilizzare trapano e punte. Dunque scegliete una scatola sulla quale siate in grado di lavorare. Un’ultima fonte di contenitori per progetti è rappresentata dai nuovi servizi di taglio laser o di stampa 3D, come Thingiverse, Ponoko, Pololu e Shapeways. Inviate loro il vostro progetto e vi forniranno il risultato finale. Molte di loro offrono anche modelli che potete scaricare per progettare scatole e contenitori. Ma non pensate solo a ciò che potete acquistare. Potrete realizzare una scatola perfettamente efficiente per un progetto Arduino anche utilizzando cartone, cartoncino, plastica e un po’ di nastro adesivo.

Scelta della scheda o del kit Arduino Il progetto Arduino si è molto evoluto nel corso di pochissimi anni. È nato come una singola scheda che offriva solo poche funzionalità di base e non era neppure dotata di un connettore USB. Ora invece trovate in commercio oltre una decina di schede Arduino, ognuna con caratteristiche e funzionalità proprie. Tutti i progetti di questo libro sono stati scritti per la scheda più popolare: Arduino UNO. L’elenco completo dei prodotti Arduino si può trovare sul sito web http://arduino.cc. Scegliete la versione più adatta alle vostre esigenze e al vostro budget. Le schede più importanti e popolari, rappresentate nella Figura 2.8, sono le seguenti. Arduino UNO. Questo è il vero cavallo da soma della famiglia Arduino. Tutti i progetti di questo libro sono stati realizzati e collaudati utilizzando questa scheda. Arduino UNO si basa sul microcontroller ATmega328, che opera a 16 MHz. Offre 14 pin di input/output digitale e 6 pin per input analogici. L’alimentazione può essere fornita tramite la connessione USB o un alimentatore a corrente continua oppure utilizzando i pin di alimentazione. Il regolatore di tensione interna è sufficientemente intelligente da capire quale fonte viene utilizzata. Offre anche un comodo LED di servizio connesso al pin digitale 13 e un pulsante di reset cui ricorrere quando le cose non funzionano più.


Una differenza fondamentale fra Arduino UNO e tutti i suoi progenitori è la presenza di un controller USB. Questa funzionalità ne semplifica moltissimo la gestione, poiché basta connettere la scheda al computer e questa verrà immediatamente riconosciuta. Le versioni precedenti di Arduino richiedevano l’installazione di driver software appositi per un’interfaccia USB fornita da FTDI. Arduino MEGA. La scheda Arduino MEGA 2560 è la sorella maggiore di Arduino UNO. Ne offre tutte le funzionalità ed è perfettamente compatibile con la prima, ma in più offre una grande quantità di connessioni: ben 54 pin di input/output digitale e 16 pin di input analogico! Inoltre ha più pin che offrono la modulazione PWM (Pulse-Width Modulation), utile per controllare la luminosità dei LED e il funzionamento dei motori. Costa un po’ di più, ma se avete la necessità di controllare molti dispositivi o di connettere una grande quantità di sensori, Arduino MEGA è ciò che fa per voi. Arduino LEONARDO. La scheda LEONARDO è simile alla UNO ma offre più input/output digitali (20) e più input analogici (12). Tuttavia il suo grande vantaggio è la presenza di una seconda porta seriale. Può fare anche qualcosa di interessante, come emulare una tastiera e un mouse. Può essere programmata per controllare questi dispositivi di input utilizzando le classi Keyboard e Mouse e il computer si comporterà come se stesse ricevendo un input dalla tastiera e dal mouse. Notevole! Arduino DUE. Questa scheda offre un processore più potente ed è davvero un piccolo computer su scheda, simile al Raspberry Pi o alla BeagleBoard. È dotato di una CPU Atmel SAM3X8E ARM Cortex-M3 operante a ben 84 MHz e offre 54 porte digitali. È molto più potente di quanto potrete mai aver bisogno per i progetti di questo libro e utilizza un’alimentazione da 3,3 V DC interni, invece di 5 V DC e dunque dovreste evitare di utilizzarla per realizzare i progetti descritti nel libro. LilyPad Arduino. LilyPad è la scheda Arduino con più “personalità”. È la preferita da chi cerca un po’ di stile ed è progettata per essere cucita su tessuti e abiti. Offre quasi lo stesso numero di input/output digitali di una normale scheda Arduino, ma i contatti sono disposti a formare un cerchio e le connessioni possono essere cucite sull’abito utilizzando filo conduttivo. Operando a 8 MHz, è la scheda Arduino più “alla moda”! Arduino MICRO. La MICRO è una piccola meraviglia, perfetta per spazi angusti. Offre solo i requisiti di base: un connettore MicroUSB e 20 connessioni di input/output digitale. Non offre alcun pin e dunque le connessioni devono essere saldate direttamente sulla scheda. Potete anche saldarle dei connettori a pettine, per poterla inserire direttamente sulla breadboard.


Figura 2.8 Le schede Arduino attualmente più utilizzate.

Potete trovare anche vecchie schede da utilizzare per i progetti. Tra le vecchie schede Arduino che potete ancora trovare vi sono la Diecimila, la Duemilanove, la NG (Nuova Generazione) e la BT (Bluetooth).

L’ambiente di sviluppo (IDE) di Arduino è un po’ cambiato a mano a mano che l’hardware delle schede si evolveva, e non tutte le vecchie schede sono in grado di funzionare con l’IDE più recente. Inoltre, alcune nuove librerie software non sono più compatibili con alcune delle schede più vecchie. Se avete problemi a realizzare un progetto di questo libro e state utilizzando una vecchia scheda, provate a realizzare il progetto con una scheda Arduino UNO.

Che cosa sono gli shield Arduino Esistono molti prodotti basati sulla piattaforma Arduino, che dotano la scheda di particolari funzionalità nel campo dei sensori e dei controller. Le schede Arduino hanno due file di pin che consentono di inserire dei ponticelli e di eseguire semplici collegamenti elettrici. La disposizione di questi contatti costituisce un layout semplice e standardizzato per l’aggiunta di piccole schede che offrono funzionalità aggiuntive, come connettività Ethernet, Wi-Fi, ricetrasmissione wireless, ricezione GPS, riproduzione audio e controllo di motori, solo per nominarne alcune. Questi accessori vengono chiamati dalla comunità Arduino con il nome di shield. Gli shield Arduino sono dotati di tutta l’elettronica necessaria per la funzionalità che offrono e hanno piedini inferiori corrispondenti ai contatti presenti sulla scheda Arduino. Lo shield Ethernet rappresentato nella Figura 2.9 consente di connettere una scheda Arduino a un router e da qui a Internet. Dato che ha gli stessi contatti presenti sulla scheda Arduino, basta collocare lo shield sopra la scheda Arduino UNO (o Arduino MEGA) per creare un piccolo “sandwich” ricco di funzionalità.


La maggior parte degli shield offre comunque l’accesso alle connessioni digitali e analogiche di Arduino (non sempre tutte). Tuttavia, le funzionalità aggiuntive offerte da uno shield richiedono l’utilizzo di alcuni di questi pin. Dovrete consultare il datasheet dello shield per assicurarvi che i pin che volete utilizzare per un progetto non siano già impiegati dallo shield stesso. Oltre agli shield, troverete altri dispositivi noti come schede breakout. Si tratta di mini circuiti stampati basati su un circuito integrato, i quali offrono funzioni dedicate, come un orologio in tempo reale (vedere il Capitolo 7), un controller per LED o un accelerometro. Esistono letteralmente decine di schede breakout, che facilitano la connessione di tali componenti alle breadboard, alle schede Arduino e ad altri componenti.

Figura 2.9 Lo shield Arduino Ethernet.

I Capitoli 7, 9, 11 e 13 contengono progetti che utilizzano schede shield o breakout.

Configurazione di Arduino sul computer Questa parte del capitolo è stata scritta considerando l’impiego di una scheda Arduino UNO o MEGA, ma dovrebbe funzionare anche con le schede MICRO, LilyPad e qualche scheda più vecchia, come la Duemilanove e la Diecimila (se utilizzate la LilyPad avrete però bisogno di un connettore speciale). Se state installando un’altra scheda Arduino, controllate le istruzioni di installazione sul sito web ufficiale di Arduino (http://arduino.cc). Le vecchie schede Arduino sono dotate di un particolare chip interno, realizzato da FTDI, che gestisce le connessioni USB. La configurazione di vecchie schede Arduino (come la Diecimila e la Duemilanove) richiede l’installazione dei driver per questo chip. Dopo esservi procurati tutto il necessario e una volta che avrete una scheda Arduino con cui lavorare, dovrete occuparvi della configurazione. Connettetela alla porta USB del computer tramite l’apposito cavo, che fornisce l’alimentazione alla scheda e crea un canale di comunicazione per inviare e ricevere programmi e dati. Il canale di comunicazione è una porta seriale e può essere


utilizzato per monitorare le attività durante l’esecuzione di un programma. Alcune delle piccole schede speciali Arduino, come la MINI, la Pro Mini e la LilyPad, non offrono un connettore USB interno. In questo caso, dovrete procurarvi uno speciale connettore per collegare la scheda al computer. Normalmente il rivenditore sarà in grado di fornire un connettore adatto.

Installazione dell’IDE Arduino Per scrivere il codice per i progetti Arduino, dovete utilizzare un particolare software di programmazione, chiamato IDE (Integrated Development Environment). L’IDE Arduino (Figura 2.10) compila anche il codice per il microcontroller sulla scheda Arduino e quando sarete pronti per lanciarlo, ne gestirà anche il trasferimento sulla scheda.

Figura 2.10 Aspetto dell’IDE di Arduino.

Ecco come installare l’ambiente di sviluppo. 1. Scaricate l’IDE Arduino direttamente dal sito web ufficiale di Arduino (http://arduino.cc). Il software è open-source e pertanto è gratuito. Scegliete la versione corretta per il vostro sistema operativo: Windows, Mac OS X o Linux. È sempre bene controllare regolarmente il sito web Arduino, in quanto il software viene aggiornato frequentemente nel momento in cui il team di sviluppo rende disponibili nuovi miglioramenti.

2. Fate doppio clic sull’archivio per estrarre i file compressi. 3. Trasferite i file estratti nella cartella corretta del computer. Su un Mac, l’archivio estratto avrà l’icona di Arduino, che potete trascinare sulla cartella Applicazioni. Questo conclude le operazioni di installazione. Su un computer Windows, vi troverete con una cartella che contiene numerose sottocartelle.


Potete collocarla dove preferite, ma in genere la cartella viene inserita nella cartella Programmi del sistema. Su macchine Windows, avrete bisogno di installare alcuni driver per connettere la scheda.

Installazione dei driver su computer Windows Su Windows 8, 7, Vista e XP, dovete dire al sistema operativo che cos’è la scheda Arduino e fornire i driver corretti. 1. Dopo aver connesso la scheda, Windows rileverà il nuovo hardware e avvierà il processo di installazione dei driver. Il processo potrebbe rimanere apparentemente bloccato per qualche tempo, ma non preoccupatevi. È tutto normale. 2. Aprite il Pannello di controllo. 3. Nel Pannello di controllo, fate clic sull’icona Sistema e sicurezza nell’angolo superiore sinistro. In Windows XP, dovrete passare alla visualizzazione Classica per trovare l’icona Sistema). 4. Sotto la voce Sistema (o l’icona Sistema su XP), aprite Gestione dispositivi. Ricercate sotto la voce Porte (COM & LPT) la scheda Arduino appena connessa. Dovreste trovare una porta aperta chiamata Arduino UNO (COMxx). In caso contrario, significa che il computer non ha ancora rilevato la connessione della scheda Arduino. Disconnettetela e riconnettetela. 5. Fate clic destro sulla porta Arduino UNO (COMx) e selezionate Aggiornamento software driver. L’operazione lancia la procedura Aggiornamento software driver. Non scegliete l’opzione Cerca automaticamente un driver aggiornato, che si connette a Windows Update per ricercare il software. Selezionate Cerca il software del driver nel computer, e fate clic sul pulsante Avanti. 6. Fate clic sul pulsante Sfoglia per individuare le cartelle che avete appena estratto dall’archivio compresso. 7. Infine raggiungete e poi selezionate il file del driver per Arduino UNO, che si chiama ArduinoUNO.inf. Sarà situato nella cartella Drivers (non la cartella FTDI USB Drivers). Infine Windows completerà l’installazione. Se tutto procede come si deve, ora sarete pronti per connettere la scheda.

Connessione della scheda Arduino A questo punto siete pronti per provare Arduino e iniziare a realizzare un progetto.

Assicuratevi che la scheda poggi su una superficie non conduttiva. I contatti sulla faccia inferiore della scheda sono infatti esposti e dunque, se la scheda dovesse poggiare su una superficie metallica di qualsiasi genere (per esempio anche il coperchio di certi computer portatili), entrerà subito in corto circuito. Come minimo, la scheda sarà malfunzionante e, alla peggio, brucerete il microcontroller. Quando connettete la scheda, il LED ON (PWR sulle schede più vecchie) si accenderà in verde e rimarrà stabilmente acceso. Noterete anche che il LED “L” si metterà a lampeggiare nel momento in cui si avvia il microcontroller. Dovrebbe lampeggiare regolarmente a una frequenza di circa mezzo secondo. Questo perché sta eseguendo un programma dimostrativo (Blink) precaricato in fabbrica.


Se state realizzando un grosso progetto, potreste aver bisogno di più schede Arduino connesse ad altrettante porte USB. Tuttavia, pur connesse in questo modo, le schede Arduino non potranno comunicare fra loro.

Installazione dei driver Arduino in Linux Ubuntu, Fedora, Debian, openSUSE: Linux viene fornito in tante versioni, dette distribuzioni. Per questo motivo, esiste una notevole variabilità nella procedura di installazione per le varie distribuzioni Linux. Generalmente, gli utenti Linux sono abituati a gestire le cose a un livello piuttosto avanzato e dunque è lecito presumere che chi sta utilizzando Linux non avrà certo problemi a connettere la scheda Arduino. Rimandiamo per le istruzioni di installazione ai forum, dove potete cercare la vostra specifica distribuzione e versione: specificare dettagliatamente ogni singola variante della procedura di installazione richiederebbe decisamente troppo spazio. Ora che avete installato Arduino e avete sotto gli occhi un piccolo LED lampeggiante, siete pronti per creare i progetti presentati in questo libro. A questo punto potete saltare direttamente al capitolo che più vi interessa. Tuttavia, se non siete particolarmente esperti di programmazione, potete dare almeno un’occhiata al Capitolo 3, che vi aiuterà a mettere le mani sull’ambiente di sviluppo e a fare la conoscenza con il linguaggio di programmazione di Arduino.


Capitolo 3

Elementi di base In questo capitolo Concetti di base di Arduino Elementi di base dell’elettronica e dei componenti elettronici Sensori e attuatori Basi della saldatura

A

questo punto, probabilmente avrete già connesso la scheda Arduino al computer e avrete provato alcuni degli schemi di esempio presentati nel kit, ma forse non sapete ancora nulla delle utili funzionalità che potete sfruttare dall’ambiente di sviluppo di Arduino. Inoltre, vi sono alcuni elementi da tenere in considerazione quando si connette Arduino a un circuito elettronico e si inserisce il tutto in un contenitore. Questo capitolo spiega tutto ciò che è necessario sapere per iniziare a lavorare in sicurezza con Arduino e introduce i concetti di base della programmazione, da utilizzare per approntare un progetto. Poiché lavoreremo con l’elettricità, saranno necessarie alcune basi del funzionamento di circuiti elettronici. Vedremo quindi come identificare i componenti elettronici e come leggere gli schemi elettrici che troverete nei prossimi capitoli. Talvolta la realizzazione di un progetto richiede qualche operazione di saldatura. Se non avete mai provato a saldare qualcosa prima d’ora, questi progetti saranno per voi un buon punto di partenza. Dopo aver affinato le vostre abilità, potrete affrontare progetti di maggiore complessità e perfino aggiungere altri componenti esterni. In questo capitolo ci limiteremo, però, ai soli elementi di base.

I concetti chiave Occorre introdurre alcuni concetti di base per iniziare a utilizzare Arduino, per scrivere programmi e per caricarli sulla scheda Arduino. Come abbiamo già visto nel Capitolo 2, si deve utilizzare l’ambiente di sviluppo integrato (IDE) di Arduino, che consente di scrivere codice in un linguaggio semplificato, facile da programmare e interpretare. Quando caricate il codice sulla scheda Arduino, l’IDE lo converte in codice macchina nativo del microcontroller, decisamente ostico per la maggior parte degli esseri umani. Questo processo è chiamato compilazione e l’IDE offre un compilatore chiamato avrdude (AVR Downloader/UploaDEr). Se il compilatore ha problemi a leggere le righe di codice che abbiamo inserito e a trasformarle in codice macchina (magari perché manca una lettera o un carattere), ve lo comunicherà, in modo che evitiate di inviare alla scheda codice che, semplicemente, non avrebbe modo di funzionare. La Figura 3.1 mostra l’aspetto dell’ambiente di sviluppo (IDE) di Arduino. Sopra la finestra di programmazione trovate alcune icone. Facendo clic sul segno di spunta (Verifica), il compilatore controlla che il codice funzioni. La freccia rivolta a destra (Carica) invia il codice alla scheda. L’icona della pagina (Nuovo) crea un nuovo programma per Arduino. La freccia rivolta verso l’alto (Apri) apre un programma, mentre la freccia rivolta verso il basso (Salva) salva il programma corrente.


Figura 3.1 L’ambiente di sviluppo (IDE) di Arduino.

Sotto questi controlli si trova un riquadro vuoto, nel quale potete scrivere e modificare il codice. Sotto la finestra di editing si trova un riquadro di controllo con uno sfondo nero. Se il compilatore vuole comunicarvi qualcosa, utilizzerà questo spazio. I messaggi di stato vengono visualizzati in bianco, mentre gli errori vengono visualizzati in arancione. L’IDE identifica anche la scheda connessa e la porta di comunicazione impiegata. L’IDE rappresentato nella Figura 3.1 è connesso a una scheda Arduino UNO (che utilizza una CPU ATmega328) tramite la porta COM3 su una macchina Windows.

Connessione ad Arduino Potete connettere la scheda Arduino al computer utilizzando un cavo USB, come descritto nel Capitolo 2. Questa connessione offre sia l’alimentazione necessaria per il funzionamento della scheda sia un canale di comunicazione: una porta seriale attraverso la quale potete inviare e ricevere dati alla scheda Arduino.

La fonte di alimentazione La scheda Arduino è dotata di un proprio sistema interno di alimentazione, che è sufficientemente intelligente per capire se la scheda è connessa a una porta USB di un computer, a una batteria o a una fonte di alimentazione esterna. Quando è connessa a un computer, trae l’alimentazione dalla porta USB. Per utilizzare la scheda senza connessione a un computer, dovete semplicemente fornire una fonte di alimentazione da 7 a 12 V CC all’apposito connettore. Potete impiegare una batteria o un alimentatore.

Per l’alimentazione, potete utilizzare i piedini appositi della scheda Arduino. Si trovano in corrispondenza dell’indicazione POWER della scheda. Inserite i fili di alimentazione nei piedini 5V e GND e fornite una tensione da 7 a 12 V CC alla scheda Arduino. Potete anche fornire tensioni superiori, fino a quasi 20 V, ma il regolatore di tensione della scheda comincerà a surriscaldarsi e dunque è abbastanza sconsigliabile raggiungere tensioni così elevate. Inoltre, dovete fare estrema attenzione a non connettere l’alimentazione in modo errato, poiché questi piedini aggirano i componenti di Arduino che proteggono la scheda dall’inversione di corrente e dai cortocircuiti.

Comunicare con Arduino


Per la programmazione della scheda si usa la porta seriale e si può programmare Arduino in modo che invii dati ad altri programmi operanti sul computer e perfino in Internet. La porta seriale è inoltre comoda per eseguire il debugging, quando i programmi non funzionano correttamente. A destra dei controlli della barra superiore dell’IDE si trova l’icona della lente di ingrandimento (Monitor seriale). Facendo clic su questa icona si apre una finestra che visualizza il contenuto del canale di comunicazione seriale impiegato dalla scheda Arduino. Potete programmare Arduino in modo che mostri qualcosa su questa finestra. Questo può essere utile per visualizzare dati provenienti dai sensori e per il debugging del codice.

Programmazione di Arduino tramite l’IDE I programmi Arduino vengono chiamati sketch, ed è possibile modificarli con facilità e usarli per provare il software e l’hardware. Il metodo di lavoro di Arduino consiste nel fatto che è possibile mettere in bozza gradualmente le idee per il progetto interattivo, arrivando gradualmente a una soluzione, provando nuove strade, conservandone alcune, scartandone altre e raffinando così l’intero lavoro. Come per ogni altra attività di progettazione, anche sviluppare in Arduino è un processo iterativo. Sebbene i progetti di questo libro siano completi e funzionanti, è proprio il caso di provare a estenderli. Considerateli un po’ come suggerimenti per un’idea finale, che potrete raffinare e sviluppare a piacere. Ma per farlo è necessario sapere come funziona il codice di Arduino.

Comprendere il codice di Arduino Tutti gli sketch di Arduino hanno una struttura standard. Questo fa sì che il codice risulti facile da leggere e da riprendere e modificare in un secondo tempo. Il compilatore non fa troppo caso all’ordine in cui disponete gli elementi ma, per convenzione, si tende a strutturare il codice Arduino nel seguente modo. 1. Commenti. La descrizione iniziale delle operazioni svolte dal codice. 2. Librerie. Dovete specificare quali librerie intendete utilizzare nel codice. Tutte le librerie devono trovarsi nella cartella delle librerie di Arduino o il compilatore non riuscirà a trovarle. 3. Dichiarazioni di variabili. Dovete specificare quali variabili intendete utilizzare nel codice e i loro valori iniziali. Più avanti, quando realizzeremo i progetti del libro, vedremo i vari tipi di variabili che è possibile utilizzare. 4. Configurazione (setup). Qui si deve definire il modo in cui verrà utilizzata la scheda Arduino e configurare i pin e le comunicazioni che userete. Questa sezione è indicata dall’istruzione setup(){ e si conclude sempre con una parentesi graffa chiusa: }. Il codice di questa parte viene eseguito per primo e una sola volta. 5. Ciclo (loop). Qui inserite le istruzioni principali del codice. Il ciclo viene eseguito dopo la configurazione iniziale e per tutto il tempo in cui Arduino rimane alimentato. Tutto il codice compreso fra le parentesi graffe { } viene elaborato sequenzialmente e poi ripetuto continuativamente. Il ciclo viene eseguito il più velocemente possibile: Arduino può svolgere circa 16 milioni di calcoli al secondo. 6. Funzioni definite dall’utente. Potete creare nuove funzioni, che descrivono come svolgere un’operazione utile. Se vi capita di dover eseguire un’operazione o un calcolo in più punti durante l’esecuzione, è opportuno creare una funzione per svolgere l’operazione. Questo tipo di programmazione modulare facilita gli interventi sul codice. setup e loop sono due funzioni speciali. Potete individuare le funzioni presenti nel codice Arduino per il fatto che sono seguite da parentesi, fra le quali potete trovare dei parametri. Le funzioni setup() e loop() non impiegano parametri e dunque queste parole sono precedute dalla parola riservata void. Il codice che viene eseguito da una funzione è sempre contenuto in una coppia di parentesi graffe { }.

Il codice che avete inviato a una scheda Arduino non può essere “estratto” dalla scheda. In altre parole non potete leggere il codice che avete già inviato alla scheda e dunque assicuratevi di salvare


e mantenere sempre organizzati i vostri sketch. Una possibilità consiste nell’applicare del nastro adesivo sul progetto Arduino, per ricordare che cosa vi avete caricato. Ogni capitolo di questo libro impiega del codice, che occorre caricare sulla scheda Arduino per consentire il funzionamento del progetto. Il codice viene presentato e spiegato in dettaglio, per mostrare come funziona; ciò vi consentirà di imparare a migliorare i progetti e di creare nuovi programmi Arduino. Quello che segue è un esempio che utilizza lo sketch più semplice di Arduino: Blink.

Lo sketch Blink Tutti i linguaggi di programmazione hanno quello che si chiama un programma “Hello World!”, che illustra che il codice del programma è attivo e funziona correttamente. Anche Arduino ne ha uno, che si chiama Blink, poiché fa lampeggiare il LED connesso al piedino 13 della scheda.

Poiché utilizzare un LED come indicatore è piuttosto comodo, il team di Arduino ha collocato un LED direttamente sulla scheda, contrassegnandolo con l’etichetta L. Si trova appena a destra del pin GND e dovrebbe lampeggiare continuativamente, se avete connesso la scheda Arduino per la prima volta e l’avete alimentata. Ciò è dovuto al fatto che la scheda sta eseguendo lo sketch Blink, programmato nella CPU direttamente in fabbrica. Per provarne il funzionamento, caricate lo sketch Blink nell’IDE di Arduino. Dal menu dell’applicazione, scegliete File Esempi Basics Blink, per caricare lo sketch dimostrativo. Otterrete la situazione rappresentata nella Figura 3.2. La prima sezione contiene dei commenti, che descrivono le operazioni svolte dal codice. È sempre buona norma scrivere all’inizio del codice un breve riepilogo delle operazioni svolte dallo sketch.

Figura 3.2 Il programma Blink caricato nell’IDE di Arduino.

Potete creare commenti nel codice, aggiungendo la sequenza /* a una riga, scrivendo i commenti anche su più righe e terminando con una sequenza */. Il compilatore ignorerà tutti i commenti


compresi fra questi simboli. Se invece volete aggiungere un commento su un’unica riga, iniziate con la sequenza //: /* Blink Turns on an LED for one second, then off for one second, repeatedly. This example code is in the public domain. */ // Pin 13 has an LED connected on most Arduino boards. // give it a name:

La sezione successiva crea una variabile. Si tratta di una variabile intera (int), ovvero in grado di contenere solo un numero intero. Alla variabile viene assegnato il valore 13, utilizzando il segno di uguaglianza (=): int led = 13;

La funzione setup() dice ad Arduino come deve configurarsi. Questo codice chiede ad Arduino di utilizzare il pin digitale 13 per inviare in output della corrente, utilizzando una funzione chiamata pinMode(). Il flusso di corrente su questo pin è quello che fa accendere e spegnere il LED, in quanto il LED della scheda è connesso proprio a questo pin. I parametri di pinMode() indicano quale pin è interessato (in questo caso utilizza la variabile led che il programma ha appena definito con il valore 13) e il fatto che venga utilizzata per un input o output (in questo caso si tratta di un OUTPUT). Se osservate la scheda Arduino, troverete un pin “13” nell’area DIGITAL. Il codice, dunque, controlla l’output su tale pin. // the setup routine runs once when you press reset: void setup() { // initialize the digital pin as an output. pinMode(led, OUTPUT); }

Notate che la funzione setup() termina con una parentesi graffa chiusa. Successivamente la funzione loop specifica ciò che accade durante il funzionamento di Arduino. La sezione di codice successiva contiene due funzioni. La prima consente di controllare l’elettricità su un piedino digitale: digitalWrite(). Indicate a quale pin inviare l’elettricità (nuovamente il pin 13) e il fatto che l’elettricità sia attiva o no. Quando è HIGH, al pin vengono inviati 5 V di elettricità, ovvero i componenti connessi al pin avranno a disposizione 5 V di tensione. Quando è LOW, l’elettricità verso questo pin viene spenta. La seconda funzione, delay(), fa in modo che Arduino sospenda l’esecuzione del codice per un certo numero di millisecondi (ms). Il codice imposta un ritardo di 1000 ms, ovvero un secondo: // the loop routine runs over and over again forever: void loop() { digitalWrite(led, HIGH); // turn the LED on (HIGH is the voltage level) delay(1000); // wait for a second digitalWrite(led, LOW); // turn the LED off by making the voltage LOW delay(1000); // wait for a second }

Quando Arduino esegue questa sezione di codice, innanzitutto attiva l’alimentazione al LED (connesso al pin 13). Poi attende un secondo prima di disattivare l’alimentazione su quello stesso pin. Infine attende un altro secondo prima di ripetere, indefinitamente, l’intero processo.

Invio del codice Ora che sapete come funziona il codice del progetto, potete decidere di inviarlo alla scheda. Se non lo avete ancora fatto, provate questo codice su Arduino, svolgendo le seguenti operazioni. 1. Dite all’IDE quale scheda Arduino state utilizzando. Dal menu dell’IDE scegliete Strumenti Tipo di Arduino e scegliete la scheda che state impiegando. La Arduino UNO utilizzata per tutti i progetti di questo libro è la prima dell’elenco. 2. Dite all’IDE a quale porta seriale è connessa la scheda Arduino, scegliendo il comando Strumenti Porta seriale.


In Windows, si tratterà molto probabilmente della porta COM con il numero più elevato riportato nell’elenco. Potete provare a inviare il codice a più porte COM prima di trovare quella corretta che il computer ha assegnato alla scheda. Su Mac OS X e Linux, la porta seriale sarà probabilmente simile a /dev/tty.usbserial-A800euub e, in genere, sarà la prima o l’ultima voce dell’elenco. 3. Dopo aver selezionato la scheda e la porta, fate clic sul pulsante Carica (l’icona della freccia rivolta a destra). Sulla scheda Arduino dovreste vedere i due LED TX e RX lampeggiare per qualche istante. Se tutto funziona, il codice dovrebbe essere lanciato automaticamente, subito dopo il caricamento nella scheda.

Dovete eseguire i passi 1 e 2 solo la prima volta che connettete una scheda Arduino al computer. L’IDE, infatti, ricorda la scelta eseguita finché non connetterete un’altra scheda. Quando acquistate una scheda Arduino UNO, questa contiene già, precaricato, il programma Blink. Per questo motivo, potreste non notare alcun cambiamento al LED se avete inviato alla scheda il programma Blink. Provate ora a cambiare i valori delay per vedere quale effetto ha questa modifica sul comportamento del LED.

Debugging Uno degli aspetti più difficoltosi della realizzazione di progetti con Arduino è scoprire che cosa è accaduto quando qualcosa non funziona a dovere. Questo è dovuto al fatto che i problemi possono essere dovuti all’hardware, al software o a entrambi. Dunque per correggere gli errori talvolta dovrete controllare entrambi questi aspetti del progetto. Per risolvere eventuali problemi, procedete nel seguente modo. 1. Controllate le connessioni. Assicuratevi che l’hardware sia connesso correttamente. Ogni capitolo offre lo schema elettrico e uno schema di disposizione dei componenti, per aiutarvi a verificare che il progetto sia costruito correttamente. Anche un solo ponticello dimenticato o fuori posto può provocare risultati inattesi o errati. 2. Controllate il software. Se vi è un grave problema, il compilatore dell’IDE ve lo comunicherà, evidenziando in arancione la riga in cui si trova il problema. Visualizzerà anche un messaggio in arancione nella parte inferiore della finestra. Inizialmente i messaggi possono sembrare criptici e difficili da comprendere. Ma leggendoli attentamente e consultando i forum online, in genere è facile scoprire che cosa è andato storto. Molti problemi derivano da banali errori di battitura o da lettere scritte in maiuscolo quando avrebbero dovuto essere in minuscolo o viceversa, dal caricamento del programma su una scheda che non è connessa o non è pronta, dal caricamento di un programma su una scheda di tipo errato o dal tentativo di caricare il programma su una scheda che non è connessa alla porta seriale impostata nell’IDE.

Il Capitolo 17 offre dieci suggerimenti che aiutano a diagnosticare e correggere i più comuni problemi di Arduino.

Ampliare gli orizzonti con le librerie


Uno degli aspetti più interessanti di Arduino è il fatto che, se volete utilizzarlo per fare qualcosa di nuovo o per controllare un display o un motore o un altro dispositivo, probabilmente ci ha già pensato qualcun altro, che ha già reso le cose più semplici. Invece di dover scrivere tutto il codice necessario per controllare i dispositivi, spesso online potete trovare del codice già scritto da altri e inserito all’interno di librerie di codice. Esistono molte librerie di largo uso, che vengono frequentemente nominate nei forum dedicati ad Arduino.

Le librerie Includendo le librerie nel codice di un vostro progetto, potete estendere ciò che Arduino è in grado di fare. Dopo aver installato una libreria, potete accedere al suo codice tramite il menu Sketch Import Library dell’IDE di Arduino, in modo da aggiungere la libreria al vostro codice. Alcune librerie sono così utili da essere state incluse direttamente nell’IDE di Arduino. Fra queste vi sono le seguenti. EEPROM, per la scrittura sulla memoria interna, che conserva le informazioni anche quando la

scheda Arduino viene spenta. Ethernet, per comunicare con una rete locale e Internet. Firmata, per comunicare con le applicazioni attive sul computer. LiquidCrystal, per scrivere su display a cristalli liquidi (LCD). SD, per leggere e scrivere su schede di memoria SD. Servo, per controllare i servomotori. SPI, per utilizzare il bus Serial Peripheral Interface, un particolare standard di comunicazione. SoftwareSerial, per creare ulteriori canali di comunicazione seriale oltre a quello fornito da

Arduino. Stepper, per controllare motori passo-passo. WiFi, per comunicare tramite reti Wi-Fi. Wire, per utilizzare l’interfaccia Two-Wire e i protocolli I2C per connettersi a dispositivi o

sensori. Alcune librerie sono state scritte da programmatori e condivise con tutta la comunità. Tali librerie possono svolgere un’incredibile varietà di operazioni, che possono andare dal controllo di LED, alla gestione di lettori di tessere, alla gestione di una videocamera e molto altro ancora. L’elenco è sterminato. Se una libreria è molto popolare, potrete quasi certamente scaricarla dal sito web di Arduino. Le librerie meno note possono essere trovate sul sito web del loro autore, su un sito web di condivisione di codice, come Github o Google Code, e talvolta sui siti web di fornitori di materiali speciali per Arduino. Per esempio, Adafruit Industries e SparkFun forniscono librerie di codice da utilizzare con i loro prodotti specializzati per Arduino.

Installazione delle librerie Per aggiungere a un progetto una libreria non standard, dovete innanzitutto scaricarla, normalmente sotto forma di un archivio compresso. Potete estrarre il file Zip facendo doppio clic su di esso. Normalmente viene generata una cartella che ha lo stesso nome della libreria. All’interno della cartella troverete dei file il cui nome termina con .h e .cpp, i quali contengono il codice della libreria. Potreste anche trovare una cartella Examples, che contiene alcuni sketch di esempio che illustrano l’uso della libreria. Se nella cartella non trovate i file .h e .cpp, significa che vi è un problema e la libreria non funziona. Dovete collocare questa cartella e il suo contenuto in un punto in cui l’IDE di Arduino possa trovarla. La posizione in cui collocarla dipende dal sistema operativo. Se utilizzate Windows, normalmente si tratta della cartella Documenti\Arduino\libraries. Se utilizzate Mac OS X, normalmente si tratta della cartella Documenti/Arduino/libraries. Se utilizzate Linux, la posizione sarà simile a quella del Mac.


I file .h e .cpp devono trovarsi all’interno di una cartella che ha lo stesso nome della libreria. Non possono essere semplicemente copiati nella cartella che contiene Arduino, in quanto da quella posizione la libreria non può funzionare. Proveremo a utilizzare delle librerie di codice che estendono le funzionalità di base di Arduino nei Capitoli 7, 8, 11, 13 e 14.

Alimentazione di Arduino Per applicazioni che devono funzionare per un certo tempo, avrete bisogno di una fonte di alimentazione costante in corrente continua (CC o DC). Potete ottenerla dal computer tramite la porta USB, ma molto probabilmente vorrete alimentare la scheda Arduino indipendentemente dal fatto che il computer sia connesso. In questo caso, avrete bisogno di un alimentatore in grado di convertire la corrente alternata ad alta tensione della rete domestica in corrente continua, quella che la scheda Arduino si aspetta di ricevere da una batteria.

Scelta di un alimentatore Esiste un’ampia varietà di alimentatori di ogni forma e prezzo, ma nella scelta dovete tenere in considerazione due aspetti: la tensione fornita e la corrente massima. Potete utilizzare con Arduino un qualsiasi alimentatore in grado di fornire una tensione compresa fra 6 e 20 V, ma è consigliabile mantenere la tensione sempre fra 7 e 12 V. Fornendo un valore superiore a 12 V, il regolatore di tensione presente sulla scheda si surriscalderà. Se utilizzate lo stesso alimentatore anche per alimentare altri componenti utilizzati da Arduino, dovrete assicurarvi che le tensioni siano appropriate. Per esempio, un motore che operi a 12 V può utilizzare la stessa fonte di alimentazione di Arduino, poiché entrambi possono utilizzare una fonte di alimentazione da 12 V. Tuttavia, se per alimentare un motore avete bisogno di impiegare un alimentatore a 24 V, avrete bisogno di ridurre tale tensione per la scheda Arduino utilizzando un altro alimentatore o un regolatore di tensione. Inoltre dovete dedicare una certa attenzione all’amperaggio fornito dall’alimentatore. Il requisito minimo è di circa 250 mA, ma se pensate di connettere ai pin digitali molti LED, sensori e altri dispositivi, avrete bisogno di più corrente.

La migliore regola empirica consiste nello scegliere un alimentatore in grado di fornire un livello di tensione adeguato per Arduino e che superi abbondantemente le richieste di corrente del progetto.

Scelta di un’alimentazione a batterie Se il progetto deve poter operare in modo autonomo, avrete bisogno di una fonte di alimentazione a batterie. Ancora una volta dovrete dedicare attenzione alla tensione e all’amperaggio fornito dalla batteria. Per Arduino avrete bisogno di una batteria in grado di fornire da 7 a 12 V, anche se potete uscire un po’ da questi limiti, in quanto il regolatore di tensione interno è in grado di adattare l’alimentazione in modo che Arduino possa utilizzarla. L’amperaggio fornito da una batteria si misura in mAh (milliAmpere/ora). Più elevato è questo valore, maggiore sarà la durata della batteria. Tuttavia, l’indicazione dei mAh non indica esattamente quanto durerà la batteria, poiché la corrente fornita varia a seconda di quanto è carica la batteria. La scheda Arduino ha bisogno di circa 250 mA per funzionare e ogni componente aggiuntivo incrementa questo consumo. È difficile scoprire quale potrebbe essere l’autonomia di una batteria. Una batteria rappresenta sempre un compromesso fra costi, durata e dimensioni. La velocità di scarica della batteria dipende


da quanta corrente viene assorbita da Arduino e dai componenti connessi. Ma il tempo di scarica della batteria dipende anche da altri fattori, fra cui il numero di dispositivi esterni, le variazioni di funzionamento dei sensori e la temperatura ambiente. Il modo migliore per scoprirlo consiste nello svolgere alcuni test.

A parità di tensione, più grande è la batteria, maggiore sarà la sua durata.

Le basi dell’elettronica Utilizzare Arduino significa lavorare sia con il software sia con l’hardware. Lavorando con l’hardware, dovrete utilizzare l’elettricità per rilevare un valore tramite un sensore o per attivare qualcosa o per fare entrambe le cose insieme. Dunque è importante iniziare con il piede giusto e introdurre le basi dei circuiti elettrici.

Tensione (V) La tensione si misura in Volt (V) e indica l’energia potenziale in grado di svolgere un lavoro in un circuito, in particolare in grado di far circolare gli elettroni. Poiché la tensione misura un potenziale di trasferimento degli elettroni da un punto a un altro, questo potenziale viene misurato come un riferimento fra due punti. Immaginate di far cadere una palla a terra. La palla precipiterà in modo più intenso se viene lanciata da un punto più elevato. La quantità di energia rilasciata dipende dal punto in cui viene lasciata la palla e da dove colpisce il terreno. Il potenziale di un flusso di elettroni viene espresso in modo analogo: fra il punto di origine e il punto in cui il flusso di elettroni termina. Pertanto la tensione viene spesso espressa come una “caduta” fra due punti di un circuito. La misura della tensione in un determinato punto di un circuito è un modo per esprimere quanto potenziale vi è per spostare degli elettroni da tale punto a un altro punto.

Corrente (I) La corrente (misurata in Ampere) indica il flusso di elettroni attraverso un circuito elettrico. La corrente elettrica è costituita dai singoli elettroni che si spostano all’interno di un materiale conduttore, spingendo gli altri elettroni che vi si trovano, un po’ come il flusso dell’acqua attraverso un tubo. Un’altra analogia è costituita dalle biglie in un tubo, che si spingono l’una con l’altra. Queste analogie non valgono per tutte le situazioni ma, in generale, forniscono un buon modello del flusso della corrente in un circuito. La quantità di flusso è la stessa in ogni parte del circuito. Se poteste osservare gli elettroni che scorrono in un circuito, ne vedreste la stessa quantità in ogni punto del circuito. La corrente si misura in Ampere, equivalenti a 6.250.000.000.000.000.000 elettroni che passano in un secondo da un determinato punto. In genere, la corrente viene espressa in mA (milliampere).

Resistenza (R) La resistenza misura l’opposizione al flusso di elettroni all’interno di un circuito. La resistenza dipende da alcuni fattori, fra cui il mezzo: normalmente un filo, la sua sezione e la sua temperatura. La resistenza limita il flusso di corrente, in un circuito che ha una determinata quantità di tensione fornita da una batteria o da un alimentatore. L’opposizione al flusso di elettroni genera attrito, e così come l’attrito meccanico, anche l’attrito elettronico genera calore. Se una resistenza genera molta opposizione a una forte corrente, può sviluppare molto calore, tanto che può essere impossibile toccarla senza scottarsi. Questo calore può essere visto come un’inefficienza del circuito. La resistenza è misurata in Ohm, espressi con lettera lettera greca omega: Ω.

La Legge di Ohm La tensione, la corrente e la resistenza sono legate fra loro nei circuiti elettronici. La relazione fra il movimento della corrente in un circuito e la tensione disponibile è stata descritta per la prima volta da Georg Simon Ohm ed è espressa con una semplice equazione algebrica: la tensione è uguale alla


corrente per la resistenza: V = I × R. Utilizzando le regole base dell’algebra, potete manipolare questa equazione per generare due varianti, risolvendola per I o per R: I = V / R e R = V / I.

E allora?!?! Molti di noi cercano di evitare in tutti modi i calcoli matematici per mettersi solo a sviluppare progetti. I progetti di questo libro sono stati tutti collaudati per funzionare alle tensioni e correnti specificate. I componenti elettronici utilizzati in questi progetti sono tutti studiati per utilizzare una determinata tensione e corrente. Tuttavia potreste voler utilizzare componenti differenti rispetto a quelli specificati oppure potreste voler aggiungere nuovi componenti per rendere ancora più interessanti i vostri progetti. In questo caso, dovete assicurarvi che le tensioni e le correnti dei componenti che volete utilizzare corrispondano a quelle del progetto. Certamente non vorrete bruciare il vostro progetto Arduino o l’intera casa. Assicuratevi sempre che i componenti aggiuntivi operino alla tensione del progetto e che non richiedano più corrente di quanta il progetto possa fornire. Alcuni componenti assorbono tanta corrente quanta gliene fornite. Dovrete pertanto utilizzare delle resistenze per limitare la corrente che le raggiunge. Per esempio, supponete di avere un LED che volete accendere con un pin digitale e che richiede una corrente massima di 30 mA. I pin digitali forniscono una tensione di output di 5 V. Per fornire una corrente non superiore a 30 mA, potete calcolare il valore della resistenza di cui avete bisogno nel circuito, utilizzando la Legge di Ohm: Resistenza = Tensione / Corrente (in Ampere) Dunque la resistenza in ohm è uguale a 5 V diviso per 30 mA, ovvero 0,03 Ampere: 5 / 0,03 = 166. Avrete pertanto bisogno di una resistenza da 166 ohm per proteggere il LED da un eccesso di corrente. In pratica, si tende a utilizzare un valore di resistenza superiore del 10% o del 20%. Un po’ per sicurezza e un po’ perché le resistenze vengono fornite a valori fissi. Pertanto una resistenza da 180 o 200 ohm garantirà la limitazione di corrente corretta senza ridurre il flusso di corrente al punto che il LED non riesca ad accendersi.

Se aggiungete al progetto nuovi elementi o componenti elettronici, assicuratevi di utilizzare resistenze appropriate, per non sovraccaricare i componenti. Altrimenti finireste per danneggiare i componenti o l’intera scheda Arduino.

Identificare i componenti elettronici Per realizzare i progetti di questo libro, si connettono i componenti sulla base di schemi elettrici e diagrammi di collocazione. I primi mostrano come devono essere connessi i componenti nei circuiti elettronici. I secondi indicano come collocare fisicamente le parti in una breadboard in modo da ottenere le connessioni indicate dagli schemi.

Il Capitolo 2 fornisce dettagli sul funzionamento delle breadboard e di vari altri tipi di schede disponibili. Potete realizzare progetti facendo riferimento agli schemi di posizionamento dei componenti, ma gli schemi elettrici forniscono un altro modo per confermare di aver costruito i circuiti correttamente.

Leggere gli schemi


Mentre lavorerete ai progetti di questo libro, potete far riferimento ai diagrammi che mostrano come connettere Arduino e i componenti elettronici. Uno schema elettrico è una rappresentazione astratta dei componenti che sono connessi nel circuito e dei loro contatti. Questo schema aiuta a comprendere come deve scorrere l’elettricità nel circuito e aiuta a diagnosticare i problemi. Inoltre aiuta ad assicurarsi che tutto sia connesso e che non abbiate trascurato nulla. Date un’occhiata al semplice schema rappresentato nella Figura 3.3. Mostra un LED connesso ad Arduino. Lo schema elettrico dispone tutti i pin di input e di output privilegiando la chiarezza più che la posizione fisica dei pin sulla scheda Arduino. Il LED è connesso al pin 13 e al pin di terra di Arduino, GND. Non viene mostrata la breadboard utilizzata per connettere i componenti. La breadboard fornisce semplicemente le connessioni fisiche mostrate dallo schema elettrico. Per realizzare i progetti, dovete essere in grado di identificare i vari componenti di uno schema elettrico. La Figura 3.4 mostra un riepilogo dei componenti che incontrerete e dei simboli utilizzati per identificarli.

Leggere gli schemi di collocazione dei componenti Molto del lavoro che vi troverete a fare riguarda la connessione dei componenti sulla base degli schemi elettrici. Ma per farlo con facilità, in modo da far funzionare un progetto, si usa una breadboard. Potete semplicemente connettere i componenti sulla breadboard, senza neppure accendere il saldatore. Quando sarete sicuri che il circuito funziona sulla breadboard, potrete trasferirlo su un circuito stampato, da saldare.

Figura 3.3 Un semplice schema elettrico di Arduino connesso a un LED.


Figura 3.4 I simboli dei componenti che utilizzerete in questo libro.

I capitoli dei progetti contengono gli schemi di disposizione dei componenti, come quello rappresentato nella Figura 3.5, che mostra come collocare i componenti sulla breadboard. Tutto è stato ben collaudato, in modo che se collocherete i componenti esattamente nei fori indicati, il progetto si comporterà secondo lo schema elettrico. Potete scegliere di utilizzare fori differenti nella breadboard, se impiegate breadboard differenti rispetto a quella rappresentata. In tal caso, dovrete fare riferimento allo schema elettrico per assicurarvi di aver connesso i componenti in modo corretto.

Figura 3.5 Un diagramma di collocazione dei componenti di una scheda Arduino e di un LED su una breadboard.

Sensori e attuatori


Si usa Arduino per svolgere fondamentalmente due operazioni: rilevare cosa sta accadendo nel mondo e rispondere a ciò che sta accadendo spostando o cambiando qualcosa, ovvero attuando qualcosa. Per realizzare alcuni dei progetti di questo libro, dovrete utilizzare vari sensori e attuatori. Sebbene non vi troverete a utilizzare tutti i componenti dell’elenco sottostante, è opportuno conoscere le varie grandezze che si possono rilevare con un sensore e i tanti modi con cui si può attuare qualcosa.

Leggere i datasheet Se state cercando un sensore o un attuatore per un determinato problema, vi troverete a dare un’occhiata al suo datasheet. Fornito dal produttore, il datasheet di un prodotto dice esattamente che cosa esso può e non può fare.

Trovate i datasheet dei sensori e degli attuatori sui siti web dei fornitori; potete individuarli con facilità tramite una ricerca web, utilizzando il numero di codice del sensore e il termine datasheet.

I sensori Gli esseri umani sono sensori di carattere generale piuttosto buoni. Possiamo rilevare un’ampia gamma di valori su ciò che vediamo, annusiamo, tocchiamo… ma discernere qualcosa con molta precisione (per esempio l’esatta lunghezza d’onda della luce o una temperatura precisa) per noi può essere difficoltoso. E poi ci sono le cose che, semplicemente, non siamo in grado di rilevare, come la presenza di monossido di carbonio. I sensori elettronici possono occuparsi di tutti i cinque sensi di cui siamo dotati: vista, udito, tatto/vibrazione, olfatto e, in un certo senso, gusto. Ma i dispositivi elettronici possono essere molto più sensibili. I sensori elettronici vengono spesso ottimizzati per rilevare valori molto precisi entro un determinato intervallo. Un elenco dei sensori e delle loro funzionalità potrebbe riempire un catalogo di centinaia di pagine, dunque è impossibile descrivere anche solo una minima parte dei sensori che potete trovare sul mercato. Nei prossimi paragrafi parleremo dei sensori che utilizzeremo in questo libro, e ne aggiungeremo un paio, probabilmente, troverete interessanti.

Vista Questi sensori rilevano la luce: un livello generale di luminosità o specifiche lunghezze d’onda. Vi sono sensori di colore che vi diranno la lunghezza d’onda che stanno rilevando, sensori che rilevano l’intensità luminosa e sensori LDR (Light-Dependent Resistors) che rispondono ai livelli di luce in un senso più generale. Le fotocamere digitali sono, sostanzialmente, sofisticati sensori della luce e potete trovare shield per fotocamere che potrete utilizzare con Arduino per scattare fotografie. Utilizzerete un sensore LDR nel Capitolo 12 e un rilevatore di “luce” infrarossa per l’automobilina telecomandata del Capitolo 14.

Vibrazione/tatto Oggi abbiamo a disposizione smartphone e tablet, e sappiamo bene cosa significhi interagire con un touch screen, un display sensibile al tatto. Ma anche un umile commutatore può essere considerato come un semplice sensore tattile. Altri sensori possono rilevare deformazioni e vibrazioni. Un sensore piezoelettrico può essere utilizzato per rilevare le vibrazioni. Anche i sensori di temperatura possono essere collocati in questa categoria. Utilizzeremo un sensore di temperatura nel Capitolo 12 e i commutatori nei Capitoli 7 e 8.

Udito Il sensore di onde sonore più semplice è il microfono, che utilizza una sottile membrana per rilevare le vibrazioni dell’aria. Potete connettere un microfono a una scheda Arduino per analizzare le vibrazioni a bassa frequenza nella gamma audio. E sebbene non possiamo utilizzare una scheda Arduino UNO per registrare audio di alta qualità, possiamo registrare suoni a una qualità adatta per


realizzare un divertente e sofisticato biglietto di auguri o un giocattolo. Ma anche il fatto di rilevare le frequenze radio è sostanzialmente equivalente all’udito, semplicemente un “udito” che si estende oltre le capacità umane. Tutto questo rientra perfettamente nelle capacità di Arduino, se si utilizza hardware specializzato come il lettore RFID. Il sensore RFID (Radio Frequency ID) del Capitolo 9 appartiene proprio a questa categoria.

Olfatto L’olfatto prevede il rilevamento di flebili tracce di molecole in sospensione nell’aria. Gli esempi più comuni sono i rilevatori di fumo e gli etilometri. In questo libro non vi sono progetti che impieghino questo genere di sensori, ma questo non dovrebbe impedirvi di esplorare ciò che è possibile fare. Perché non connettere un sensore di CO2 alla stazione di rilevamento domestico realizzata nel Capitolo 12? Con un po’ di studio e di ingegno, potrete connettere un etilometro commerciale all’automobilina telecomandata realizzata nel Capitolo 14 e garantire così la sicurezza della “guida”, portandola a livelli record!

Gusto Nel campo della produzione, vengono impiegati sensori molto specializzati per rilevare le sostanze chimiche in una varietà di composti, riscaldandoli e rilevando poi la loro composizione molecolare. Si tratta un po’ di una forzatura, ma forse il rilevamento del livello di umidità è una specie di equivalente elettronico del gusto. Nel Capitolo 10 realizzerete un sensore di umidità in grado di “gustare” l’umidità del suolo, per capire se avviare o meno l’impianto di irrigazione.

Gli attuatori Quando volete che gli oggetti svolgano determinate operazioni, avete bisogno di un attuatore. Gli attuatori emettono luci e suoni, riscaldano gli oggetti, li raffreddano e li spostano rapidamente, lentamente o con precisione. Ecco un elenco del genere di attuatori che incontrerete nel libro.

Indicazione visiva L’attuatore più semplice è un indicatore visivo. Può trattarsi di una semplice lampada a incandescenza o, con maggiore probabilità, di un LED. Sono disponibili LED di tutte le forme, dimensioni e colori. Potete trovarli come unità singole o connessi, a formare lettere e numeri in sette segmenti, o a formare una matrice. Vi troverete a utilizzare i LED in molti progetti di questo libro. Nel Capitolo 6 utilizzerete una matrice di LED per creare una piccola insegna scorrevole, che potete far crescere fino a renderla un pannello da collocare davanti a un autobus cittadino. Il Capitolo 15 insegna a combinare i LED a formare un cubo luminoso, animato e programmabile.

Indicazioni udibili Un altro semplice indicatore è rappresentato dagli attuatori audio: altoparlanti e buzzer. Questi attuatori utilizzano la corrente elettrica per produrre vibrazioni nell’aria. La generazione di qualcosa che vada al di là dei semplici suoni richiede l’aggiunta di altri componenti. Per riprodurre suoni registrati, dovrete utilizzare particolari componenti come il Wave Shield, prodotto da Adafruit Industries. Ma una semplice elaborazione audio è comunque possibile. La sveglia realizzata nel Capitolo 7 utilizza un altoparlante piezoelettrico per tirarvi su dal letto. Potete aggiungerne uno a qualsiasi progetto in cui abbiate bisogno di un’indicazione audio.

Movimento Sono molti i dispositivi in grado di trasformare un potenziale elettrico in movimento. Quello più semplice è un motore. I motori convertono la corrente in un campo elettrico in rotazione, grazie all’attrazione e repulsione dei campi magnetici. Esistono motori specializzati, come i servomotori e i motori passo-passo, che possono essere programmati per spostare oggetti in posizioni precise. Utilizzerete i servomotori nel Capitolo 14 per guidare l’automobilina telecomandata. I solenoidi sono particolari cilindri elettromagnetici in grado di spingere o tirare un pistone. Impiegano un campo magnetico per creare una forza lineare attrattiva o repulsiva. Utilizzerete un solenoide connesso a una valvola per attivare e disattivare il flusso dell’acqua nell’impianto di irrigazione realizzato nel Capitolo 10. I relè sono dispositivi che contano su una corrente elettromagnetica per attivare un commutatore. All’interno dei relè, un piccolo contatto metallico viene spostato in modo da chiudere un contatto, consentendo pertanto il passaggio dell’elettricità in un circuito. Utilizzerete i relè nel Capitolo 8 per attivare un meccanismo di chiusura delle porte.


Mettere in funzione i progetti La maggior parte dei progetti presentati in questo libro usa una breadboard, lo strumento perfetto per creare prototipi di circuiti e progetti. Una breadboard semplifica enormemente la connessione dei componenti elettronici alla scheda Arduino e l’utilizzo di sensori e attuatori nei progetti. L’intero scopo di una breadboard consiste nel semplificare la realizzazione di oggetti: potete provare circuiti, commettere errori e cambiare idea rapidamente e con facilità senza mai dover saldare e dissaldare nulla. Per realizzare prototipi, una breadboard è probabilmente uno strumento insostituibile. Ma talvolta i circuiti devono essere resi più permanenti. A questo punto si possono considerare due soluzioni: saldare i componenti fra loro e mettere il tutto in un contenitore.

Passare dalla breadboard a un contenitore Creerete prototipi e realizzerete la maggior parte dei progetti di questo libro su una breadboard. Ma quando e se vorrete fare qualcosa di più permanente, potrete farlo con facilità trasferendo i circuiti su una basetta millefori o creando un vostro shield Arduino. Per provare, la stazione di sensori domestici del Capitolo 12 è un buon punto di partenza, poiché mostra come iniziare il progetto su una breadboard e poi spostarlo su una basetta millefori. Dopo averlo realizzato, riuscirete a fare lo stesso con altri progetti con altrettanta facilità. Potete anche creare un circuito stampato. Per realizzare tutti i circuiti e gli schemi di questo libro è stato impiegato il software Fritzing, che offre anche la possibilità di creare circuiti stampati personalizzati. Potete realizzare il circuito stampato da soli o potete inviare il progetto a un produttore specializzato, che sarà in grado di realizzare, forare e serigrafare i disegni sulla scheda. Mentre un tempo questa operazione era molto costosa e risultava pratica solo per realizzare centinaia di copie, oggi esistono nuove soluzioni a prezzi molto vantaggiosi. Questo argomento non rientra negli scopi di questo libro, ma esistono moltissime risorse online che vale la pena di esplorare. Per rendere il progetto più permanente, dovete anche considerare il tipo di contenitore in cui inserirlo. Il Capitolo 2 contiene una guida al genere di contenitori che potete utilizzare e alcune considerazioni importanti per sceglierli.

Le basi della saldatura Potete realizzare tutti questi progetti su una breadboard, facile da utilizzare, correggendo eventuali errori. Quando sarete soddisfatti dei risultati, potrete connettere i componenti in modo più permanente utilizzando una basetta millefori e saldando il tutto insieme. Per saldare i componenti, occorre un saldatore, la punta del quale si riscalda fino a quasi 200°C, quanto basta per fondere lo stagno da utilizzare per unire i componenti. Lo stagno fuso aderisce ai componenti metallici e si raffredda con una certa rapidità una volta che non si applica più il calore del saldatore. Il risultato è un forte contatto, elettricamente conduttivo, che rimane permanente finché non si applicherà nuovamente il saldatore. Le prime volte che si eseguono saldature, è opportuno fare pratica con qualche oggetto “sacrificabile”, per evitare di commettere errori. La pratica rende perfetti, recita il proverbio. Occorre qualche tentativo per scoprire quanto tempo è necessario per avviare il saldatore, come unire i componenti e come eseguire una buona saldatura. Potete utilizzare una piccola basetta millefori per i primi test, senza correre il rischio di danneggiare nulla. Potete provare a saldare delle resistenze, che sono economiche e facili da maneggiare. Oltretutto non hanno particolari problemi di surriscaldamento: potete semplicemente rimetterle a posto una volta che avrete finito di fare pratica. Se avete qualche circuito stampato da qualche parte, potete anche mettere alla prova le vostre capacità di dissaldatura, utilizzando i sistemi menzionati nel Capitolo 2. Provate a togliere i componenti dalle schede. Ben presto vi renderete conto perché è importante acquisire buone tecniche di saldatura: togliere i componenti da un circuito è molto più difficile che saldarli! La Figura 3.6 mostra un esempio di saldatura di un componente su una basetta millefori. Durante la saldatura, si poggia la punta sui componenti e poi si fonde lo stagno sull’area riscaldata. Dovete assicurarvi che i componenti siano sufficientemente caldi perché lo stagno vi aderisca. Non scaldate mai lo stagno per poi farlo gocciolare sui componenti. Quando avrete riscaldato i componenti, lo stagno fonderà attorno a essi e li rivestirà. Quando saranno rivestiti di stagno fuso, togliete lo stagno e la punta del saldatore e lasciate che i componenti si raffreddino. Il risultato sarà una ottimo


contatto elettrico, che sarà impossibile separare.

Figura 3.6 Saldatura di componenti su una perfboard o una stripboard.

Ecco alcuni suggerimenti da tenere sempre in considerazione. Assicuratevi che i componenti e le superfici siano puliti. In particolare, assicuratevi di pulire la punta del saldatore con una spugnetta umida.

Rivestite la punta del saldatore con un po’ di stagno, quanto basta a renderla lucida. Questa tecnica è chiamata tinning e semplifica la saldatura dei componenti. Non surriscaldate i componenti. Dovete riscaldarli quanto basta per eseguire una buona saldatura. Se applicate troppo calore, alcuni componenti più sensibili potrebbero bruciarsi.

La sicurezza innanzitutto. Non eseguite saldature sopra le mani o altre parti del corpo. Se lo stagno fuso dovesse cadervi addosso, vi brucereste. Inoltre indossate degli occhiali di protezione: capita che lo stagno fuso schizzi in direzioni imprevedibili.

Fate attenzione a non respirare i fumi della saldatura. Sebbene lo stagno con piombo (che è una neurotossina) sia ormai bandito in molti Paesi, i vapori di saldatura non sono esattamente salutari. Assicuratevi inoltre di lavorare in un ambiente ben ventilato.


Parte II Semplici progetti con Arduino

I listati e le risorse grafiche dei capitoli sono disponibili sul sito www.hoeplieditore.it/6323-9.


In questa parte‌ Le basi della programmazione di Arduino Programmare e controllare dei LED Creare e programmare un’insegna scorrevole Costruire un orologio sveglia Visualizzare testo su un display LCD


Capitolo 4

L’occhio a scanner In questo capitolo Alimentazione e controllo dei LED Uso di array e cicli Contare il tempo Usare un potenziometro per regolare la velocità

S

e non avete mai realizzato alcun progetto Arduino prima d’ora, questo è il momento giusto per iniziare. In questo capitolo descriveremo le basi della realizzazione di un progetto Arduino, dalla scrittura del codice alle attività necessarie per assicurarsi che tutto funzioni a dovere. Se state leggendo questo libro, è abbastanza probabile che abbiate una certa passione per la fantascienza. Questo progetto si ispira a certi telefilm di fantascienza di qualche tempo fa. Sto pensando ai guerrieri Cylon di Battlestar Galactica, e alla straordinaria auto K.I.T.T. di Supercar. Per me il vero personaggio principale della serie era proprio K.I.T.T., non certo David Hasselhoff! I Cylon e K.I.T.T. avevano una cosa in comune: il loro “occhio” era sostanzialmente una fascia orizzontale di lucine rosse che correvano avanti e indietro, una sorta di occhio-scanner che vedeva tutto. In questo progetto, realizzeremo esattamente questo, utilizzando una serie di LED (Light Emitting Diode). Potete anche cambiare il comportamento delle luci per emulare un display a scritte mobili o una palla che rimbalza. Nel realizzarlo, acquisirete molti importanti concetti chiave sul funzionamento di Arduino, fra cui il conteggio del tempo, la memorizzazione e lettura dei dati e l’aggiunta di una manopola per controllare la velocità dell’animazione. Queste basi verranno poi utilizzate in molti altri progetti del libro e saranno in generale utili per preparare altri progetti.

Se non avete ancora connesso Arduino, tornate al Capitolo 2, che spiega come predisporre la scheda. Tale capitolo parla anche dell’ambiente di sviluppo (IDE) di Arduino, che si utilizza per scrivere programmi. Il Capitolo 3 presenta le basi della programmazione di Arduino: la struttura del codice e una descrizione sommaria del modo in cui il codice viene elaborato dal compilatore, in modo che possa funzionare una volta caricato in Arduino.

I componenti Iniziate predisponendo i componenti elettronici di cui avete bisogno per creare l’occhio (Figura 4.1). Si tratta di componenti piuttosto semplici. Innanzitutto assicuratevi di avere a disposizione quanto segue. La scheda Arduino UNO. Una breadboard. Dieci LED dello stesso tipo e colore. In questo caso abbiamo usato LED rossi, come quelli dei Cylon e di K.I.T.T. Dieci resistenze da 250 o 270 ohm.


Un potenziometro lineare da 4,7 Kohm. Ponticelli di varie lunghezze.

Non è necessario che vi procuriate esattamente le resistenze dei valori appena elencati. I siti di materiale per Arduino tendono a offrire resistenze che vanno dai 220 ai 470 ohm, che andranno benissimo. Potete anche utilizzare valori superiori, che tuttavia possono ridurre il flusso di corrente al punto che i LED potrebbero accendersi appena o non accendersi affatto.

Figura 4.1 Procuratevi il necessario per realizzare il progetto.

Come è fatto un LED Ormai troviamo i LED praticamente ovunque e in qualsiasi tipo di apparecchio. I nuovi LED sono talmente luminosi da poter essere impiegati anche al posto delle tradizionali fonti di illuminazione. Ma che cosa fa accendere un LED? Questi diodi a emissione di luce (LED = Light Emitting Diode) si basano su un particolare materiale semiconduttore che permette alla corrente elettrica di scorrere in una sola direzione. Questo componente è chiamato diodo. Tutti i LED contengono una parte di materiale semiconduttore che forma il diodo. Il diodo è circondato da un piccolo specchio concavo che concentra la luce. La luce attraversa poi una lente in materiale epossidico che ha anche lo scopo di proteggere le parti interne. Sono disponibili vari tipi di lenti per controllare la luce generata. Oltre alle caratteristiche elettriche, altri elementi chiave da considerare nella scelta di un LED sono la luminosità e l’angolo di emissione. La luminosità, normalmente misurata in microcandele (mcd), può andare da poche migliaia fino a 25.000 o più mcd. L’angolo di emissione fa riferimento all’angolo con cui la luce del LED può essere dispersa: può andare da pochi gradi a 180°. Il piedino più lungo rappresenta l’anodo e deve essere connesso al polo positivo (+). Il piedino più corto è il catodo e si connette al polo negativo (-), a terra. L’involucro epossidico ha un lato piatto che corrisponde al catodo. Dunque, se non siete sicuri del significato dei piedini (magari perché li avete accorciati ed è diventato impossibile distinguerli), potete fare riferimento a questo schema.


Realizzazione del circuito Dopo aver preparato i componenti, iniziate a connetterli alla breadboard. Si tratta di venti componenti; la scheda Arduino andrà connessa per ultima. Una volta che tutti i componenti sono in posizione, connettete il polo negativo (la “terra” del circuito), alla scheda Arduino e infine connettete il polo positivo del circuito a ciascun LED. Seguite questi passi per la realizzazione, facendo riferimento alla Figura 4.2. 1. Inserite le dieci resistenze da 250 ohm nella breadboard. Se avete resistenze di valore un po’ più elevato, per esempio 270 ohm, nessun problema. I piedini di ciascuna resistenza dovranno trovarsi ai due lati del separatore posto al centro della breadboard. Non vi è alcun passaggio di elettricità attraverso questo separatore, e dunque potete inserire i piedini nella stessa riga senza connetterli elettricamente. Non dovete neppure preoccuparvi del fatto che le fasce colorate siano orientate allo stesso modo: le resistenze si comportano ugualmente in entrambe le direzioni. 2. Inserite i LED. Connettete il piedino più lungo (l’anodo) dei LED alla stessa riga della resistenza e il piedino più corto alla riga adiacente. A differenza delle resistenze, i LED funzionano in una sola direzione (hanno una polarità) e il piedino positivo, più lungo, deve sempre essere connesso al lato da +5 V del circuito. La tensione proverrà dai pin digitali della scheda Arduino.

La corrente scorre in una sola direzione per accendere il LED: dall’anodo al catodo. 3. Utilizzate un ponticello per connettere il piedino negativo di ciascun LED a un foro della lunga colonna di fori posti sul lato della breadboard, per creare la connessione a


terra. Il piedino negativo di tutti i LED andrà collegato al pin GND della scheda Arduino. I fori dell’intera colonna laterale sono tutti connessi elettricamente. Potete utilizzare come volete le due colonne ma, per convenzione, si tende a utilizzare la colonna con la riga blu o nera per la linea di terra e l’altra per l’alimentazione. Alcune breadboard non impiegano alcun colore, ma si applica comunque lo stesso ragionamento. La codifica colorata serve solo per aiutarvi a ricordare quali connessioni sono impiegate. 4. Utilizzate un ponticello per connettere uno dei fori inutilizzati della linea di terra al pin GND della scheda Arduino. 5. Connettete il polo positivo del circuito. Dovete inviare l’alimentazione a ognuno dei LED, attivando e disattivando il relativo pin digitale. Partendo dal pin 4, connettete l’anodo di ciascun LED a un pin digitale della scheda Arduino. La Figura 4.2 mostra l’aspetto della breadboard dopo aver completato il circuito.

Figura 4.2 Collocazione dei componenti.

In questo modo avete stabilito una connessione elettrica che consente all’elettricità di scorrere dai singoli pin digitali (da 4 a 13) attraverso i singoli LED e poi a terra. Dovreste essere in grado di tracciare un percorso immaginario dal pin 4 attraverso una resistenza, attraverso un LED e poi alla connessione di terra fino al pin GND della scheda Arduino. Lo stesso vale per tutti gli altri pin. Ogni LED usa un proprio percorso distinto, mentre la connessione a terra è comune. Sulle resistenze, le fasce colorate indicano il valore della resistenza in ohm.

Controllate l’illustrazione per assicurarvi di aver collegato tutto correttamente. Per il momento non preoccupatevi del potenziometro, lo aggiungerete in seguito.

Il funzionamento del codice Ora che abbiamo cablato il tutto, possiamo occuparci del codice. I diagrammi di flusso sono sempre utili per comprendere ciò che accade in ogni fase, mentre Arduino elabora il codice. Il diagramma rappresentato nella Figura 4.3 mostra la serie di eventi e di decisioni che si svolgono nel corso del programma.


Figura 4.3 La sequenza di operazioni svolte dal codice.

Tutto al momento giusto Il clock interno di Arduino gioca un ruolo chiave in questo progetto. Arduino registra il tempo trascorso dall’avvio del programma, misurandolo in millisecondi (ms). Potete sfruttare questa risorsa per svolgere parecchie operazioni utili, fra cui realizzare orologi ed eventi temporizzati. Qui lo useremo per controllare il ritardo di accensione di ciascun LED. Potete aumentare o ridurre tale ritardo per cambiare la velocità di scorrimento della luce verso sinistra e verso destra. Si introduce un ritardo per regolare il tempo durante il quale ciascun LED rimane acceso. Passate da un LED al successivo spegnendo il LED corrente, accendendo quello a fianco e lasciando acceso ciascun LED per un certo tempo. Quando arrivate alla fine della fila di LED, cambiate direzione e ripetete l’intero processo.

Tutto il codice utilizzato in questo libro può essere copiato dalla scheda Downloads del sito Web www.hoeplieditore.it/6323-9, a meno che abbiate voglia di digitare tutto il listato a mano. Per capire cosa sta accadendo, inserite il codice seguente in un nuovo sketch. Potete anche scaricare il codice dal sito web del libro all’indirizzo www.hoeplieditore.it/6323-9. // Chapter 4: The All-Seeing Eye // Sequentially lights up a series of LEDs


// A variable to set a delay time between each LED int delayTime = 40; // A variable to store which LED we are currently working on int currentLED = 4; // A variable to store the direction of travel int dir = 1; // A variable to store the last time we changed something long timeChanged = 0; // An array to hold the value for each LED pin byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13}; void setup() { // Set all pins for OUTPUT for (int i=0; i<10; i++) { pinMode(ledPin[i], OUTPUT); } // Record the time once the setup has completed timeChanged = millis(); } void loop() { // Check whether it has been long enough if ((millis() - timeChanged) > delayTime) { //turn off all of the LEDs for (int i=0; i<10; { digitalWrite(ledPin[i], LOW); } // Light the current LED digitalWrite(ledPin[currentLED], HIGH); // Increase the direction value (up or down) currentLED = currentLED + dir; // If we are at the end of a row, change direction if (currentLED == 9) { dir = -1; } if (currentLED == 0) { dir = 1; } // store the current time as the time we last changed LEDs timeChanged = millis(); } }

Configurazione del codice All’inizio del codice, alcune righe di commento descrivono le operazioni svolte. In una riga di codice, tutto ciò che segue la barra (/) verrà ignorato dal compilatore. I commenti sono una buona posizione per descrivere le operazioni svolte dal codice, in modo che chiunque (anche noi stessi in un secondo tempo) possa risalire al significato delle istruzioni. Ciò risulterà sorprendentemente utile una volta trascorso qualche mese, quando avrete dimenticato tutti i dettagli del modo in cui avete risolto uno specifico problema con quel particolare frammento di codice e intendete utilizzarne qualche parte per realizzare un altro progetto. Il codice inizia definendo alcune variabili, che sono semplicemente aree di memoria nelle quali memorizzare e dalle quali richiamare un valore. Ogni variabile ha un proprio nome, che dovrebbe essere il più possibile “parlante”, in modo che aiuti a interpretare il significato del codice, sia in fase di programmazione sia, successivamente, in fase di rilettura. Poiché vi sono vari tipi di variabili, dovete dire ad Arduino quale tipo di variabile state utilizzando. La prima è una variabile intera, int, ovvero una variabile che può ospitare un valore intero compreso fra -32.768 e 32.767. Questa variabile è stata chiamata delayTime, poiché viene utilizzata per memorizzare il tempo in ms che Arduino attende prima di accendere il LED successivo: int delayTime = 40;

int è la parola riservata che crea una variabile intera. Tutte le parole riservate vengono evidenziate

automaticamente in arancione dall’IDE di Arduino e non potete utilizzarle per altri compiti o otterrete un errore. Poi è indicato il nome della variabile, delayTime. Nei nomi di variabili le lettere maiuscole sono


considerate diverse dalle lettere minuscole e dunque è importante ricordarsi di digitare il nome sempre correttamente. Nella seconda parte del nome della variabile, la lettera “T” è maiuscola per facilitare la lettura del nome. In programmazione, questa convenzione è chiamata camel case, poiché le lettere maiuscole creano nel nome della variabile delle “gobbe” come quelle di un cammello. Il simbolo = significa che il valore che segue, sulla destra, verrà memorizzato nell’area di memoria contrassegnata dal nome delayTime. Può essere più facile interpretare il segno di uguaglianza come un simbolo di assegnamento, poiché con questa istruzione stiamo assegnando alla variabile specificata a sinistra il valore specificato a destra del segno di uguaglianza. In pratica assegniamo alla variabile delayTime il valore 40. Più avanti, il codice determinerà se sono trascorsi 40 ms, per controllare se è il momento di accendere il LED successivo. L’assegnamento di un valore di partenza a una variabile viene chiamato inizializzazione della variabile. Ora occorre determinare quale LED deve essere acceso e ciò viene fatto da una variabile denominata in modo appropriato: currentLED. Questa variabile conserva il numero di pin relativo al LED di cui ci stiamo occupando. Attualmente è impostata a 4, poiché è sempre una buona abitudine inizializzare le variabili con un valore e il primo LED da accendere è collegato al pin 4. int currentLED = 4;

Un’altra variabile intera, dir, controlla la direzione delle luci: int dir = 1;

Un semplice trucco incrementa currentLED finché non raggiunge il pin 13 e poi la decrementa. Come potete vedere, la variabile dir viene inizializzata con il valore 1. Dopo che Arduino accende il primo LED collegato al pin 4, currentLED ha il valore 4. Aggiungendo dir a currentLED si cambia il valore in 5 e dunque, al ciclo successivo, si accenderà il LED successivo e così via fino al pin 13. Nel momento in cui il programma raggiunge il pin 13, si cambia il valore di dir in -1 e si esegue nuovamente la somma a currentLED ottenendo però il valore 12. Ora ogni volta che aggiungerete dir a currentLED, il valore si decrementerà di una unità. La cosa procede fino al pin 4, e poi il ciclo si ripete. Un trucco interessante, vero? I dettagli di funzionamento vengono spiegati un po’ più avanti in questo stesso capitolo. Poi avete un intero per registrare l’ultima volta che è stato eseguito un cambiamento. Tale intero viene utilizzato per determinare se è giunto il momento di portarsi sul LED successivo. Questo valore viene inizializzato a 0: long timeChanged = 0;

Eleganza, economia, semplicità Vi sono molti metodi per incrementare e decrementare una fila di LED. Per esempio, potreste scrivere del codice che utilizza un ciclo per contare da 4 a 13, seguito da un altro ciclo per contare da 13 a 4 e così via. L’effetto sarebbe lo stesso, ma richiederebbe due cicli invece di uno. Il fatto di utilizzare un approccio o l’altro è una questione di eleganza e di economia di memoria del microcontroller. Molte discussioni nei forum sono animate da dibattiti sul modo in cui rendere più elegante e compatto il codice. Spesso è puramente una questione di stile. Nei microcontroller, la RAM disponibile è molto limitata. Se riuscite a scrivere del codice un po’ più efficiente e un po’ più compatto, tanto meglio. Per esempio, il tipo di dati byte può memorizzare un numero compreso fra 0 e 255, mentre il tipo di dati int può memorizzare un numero compreso fra -32.768 e 32.767. Una variabile byte usa un solo byte di RAM, mentre una variabile int ne usa due. Può non sembrare molto, ma quando il programma cresce di dimensioni, lo spazio di memoria disponibile può diventare molto limitato. Dunque è sempre importante scegliere il tipo di variabile più adatto ai dati che intendete memorizzare. Quando vi troverete con grossi programmi che occupano quasi tutta la memoria disponibile, ricorrerete a ogni genere di trucco per risparmiare anche un solo byte!


Il tipo di dati long è simile a int, ma è in grado di memorizzare valori compresi fra –2.147.483.648 e 2.147.483.647. Poiché il valore di changeTime viene incrementato di 1000 unità ogni secondo, un valore int raggiungerebbe il massimo possibile dopo 32767 millisecondi (ovvero dopo una trentina di secondi); a quel punto il timer smetterebbe di funzionare correttamente. L’ultimo elemento è un nuovo tipo di dati, un array. Gli array sono estremamente utili, in quanto possono essere impiegati per memorizzare più variabili insieme. In questo programma si utilizza un array per memorizzare il numero di pin per ciascuno dei dieci pin digitali connessi ai LED. Gli array devono avere un nome e il nome dell’array di byte è ledPin. Ogni valore memorizzato in un array ha un proprio indirizzo, o indice. Potete richiedere il valore contenuto in tale indirizzo dell’array oppure potete memorizzare un valore in uno specifico indirizzo. Potete considerare un array come una fila di scatoline numerate in modo sequenziale, in cui potete inserire dei dati. Ogni “scatolina” è un elemento dell’array. Per accedere al contenuto di un elemento di un array, è sufficiente conoscere il suo indice. Oltre al nome ledPin, dovete dire al compilatore quale genere di dati intendete inserire in questo array. L’array in questo caso conterrà byte: byte ledPin[] = {4, 5, 6, 7, 8, 9, 10, 11, 12, 13};

Abbiamo inizializzato questo array con dieci elementi, specificati fra parentesi graffe, che sono i numeri corrispondenti ai pin digitali della scheda Arduino. In tal modo il compilatore potrà contare quanti elementi sono disponibili.

In alcuni casi potreste voler creare un array senza inizializzare i suoi elementi. In tal caso dovete solo specificare fra le parentesi quadre di quanti elementi è composto l’array, come in byte ledPin[10]. L’indice dell’array parte da 0. Dunque l’indice del primo valore di questo array, 4, è 0. Per accedere al valore di uno degli elementi dell’array, basta specificare l’indice fra le parentesi quadre: pertanto ledPin[0] conterrà il valore 4, ledPin[1] conterrà il valore 5 e così via. Per utilizzare il valore di uno degli elementi dell’array basta specificare quale si intende utilizzare, nel seguente modo: i = ledPin[3];

ledPin[3] contiene il valore 7 e dunque questa riga del programma assegna alla variabile i il valore 7.

Dopo aver dichiarato e inizializzato tutte le variabili, è il momento di configurare le condizioni iniziali da cui partirà il codice, operazione svolta dalla funzione setup(): void setup() { // Set all pins for OUTPUT for (int i=0; i<10; i++) { pinMode(ledPin[i], OUTPUT); }

}

// Set up the current timeChanged timeChanged = millis();

Come già detto, le funzioni sono frammenti di codice che eseguono tutto ciò che si trova fra le


parentesi graffe. Tutti i programmi Arduino devono contenere una funzione setup() e una funzione loop(). Ciò che si trova nella funzione setup() viene eseguito una sola volta, prima che inizi il ciclo principale. Tutto ciò che si trova nella funzione loop() viene invece eseguito per tutto il tempo in cui Arduino è in funzione. Il compilatore deve sapere quali pin digitali devono essere utilizzati e per cosa vengono utilizzati (per inviare o per ricevere un segnale). Ciò deve essere svolto tramite la funzione interna pinMode(). Per configurare un singolo pin digitale, per esempio il 13, per l’output digitale (come nell’esempio del programma Blink), basta specificare il pin e la direzione di output, nel seguente modo: pinMode(13, OUTPUT);

Tuttavia, questa volta vi sono ben dieci pin da configurare. Potremmo riscrivere questa istruzione per dieci volte, specificando ogni volta un numero di pin differente, ma vi è un modo più elegante per farlo, utilizzando una tecnica chiamata ciclo for. In programmazione, vi sono molte situazioni in cui occorre ripetere più volte una determinata operazione e il ciclo for è uno dei metodi più comuni per farlo. Un ciclo for è definito da tre elementi: una variabile inizializzata sulla quale avverrà il conteggio, una condizione di test per determinare se siamo giunti alla fine del ciclo e il tipo di incremento della variabile. Questi parametri definiscono le condizioni del ciclo che deve essere eseguito e devono essere specificati fra parentesi. Il ciclo continua a eseguire il codice contenuto fra le parentesi graffe e a eseguire l’incremento fintantoché la condizione di test permane vera. Qui stiamo creando una variabile che viene utilizzata solo in questo ciclo (una variabile locale). Si tratta di una variabile intera da incrementare; per brevità, la chiameremo i e le assegnamo il valore 0: for (int i=0; i<10; i++) { pinMode(ledPin[i], OUTPUT); }

Si inizializza la variabile intera i a 0 utilizzando la parte int i=0 del ciclo. Il punto e virgola indica la fine della parte di inizializzazione della variabile e a questo punto il ciclo deve sapere fino a quando continuare a contare. Pertanto, dopo il punto e virgola va specificata la condizione di test: i<10;

A ogni iterazione del codice racchiuso fra le parentesi graffe, il ciclo controlla se la condizione di test rimane vera. È come se si domandasse: “La variabile i è ancora minore di 10?”. Il simbolo < è l’operatore di confronto. Se il confronto risulta vero, il ciclo incrementa il valore di i di 1: i++

Dopo questa istruzione non va specificato il punto e virgola. Se il confronto è falso, perché i diventa uguale a 10 o supera tale valore, il ciclo termina e Arduino passa a esaminare il codice successivo del programma. Utilizziamo questo ciclo per contare da 0 a 9. Ogni volta che la variabile del ciclo si incrementa, indica il pin digitale da utilizzare per l’output, utilizzando un valore tratto dall’array ledPin[i]. Il valore utilizzato è specificato dal numero dell’indice dell’array, ovvero dall’intero i che viene continuamente incrementato dal ciclo for: pinMode(ledPin[i], OUTPUT);

Quando i è uguale a 0, dall’array ledPin[] viene estratto il valore 4. Quando i è uguale a 1, dall’array viene estratto il valore 5 e così via. Usare un ciclo è un po’ più complesso rispetto a scrivere esplicitamente le dieci dichiarazioni di pinMode(), ma aiuta a risparmiare memoria. Questo è un frammento di codice che si tende a tagliare e incollare da un progetto all’altro, modificando i parametri in base alle esigenze. L’ultima parte di setup() prende nota del tempo trascorso in millisecondi, che verrà utilizzato per determinare se è il momento di accendere il LED successivo. L’ora corrente viene prelevata dalla


CPU tramite la funzione interna millis(). Questo valore viene poi memorizzato nella variabile intera timeChanged (anche se non è ancora cambiato nulla).

Operatori di confronto Il linguaggio di Arduino offre numerosi operatori di confronto. == significa uguale != significa diverso < significa minore <= significa minore o uguale > significa maggiore >= significa maggiore o uguale Dedicate particolare attenzione al primo operatore di confronto, ==. Un singolo segno = viene utilizzato per assegnare un valore. Un doppio segno == viene utilizzato per eseguire un confronto. Utilizzare un simbolo = al posto di un doppio == è un errore molto grave e comune, non solo per i principianti. Fortunatamente, il compilatore è in grado di rilevare con facilità questo genere di errori.

L’evento principale Le cose si fanno più interessanti all’interno della funzione principale loop(). Tutto ruota attorno alla domanda: “Sono trascorsi 40 ms dall’ultimo controllo?”. Questa domanda è espressa da una particolare istruzione, chiamata istruzione if. Un’istruzione if è una struttura di controllo che verifica se un certo fatto è vero o no e, in caso affermativo, esegue il codice racchiuso fra le parentesi graffe. Come potete vedere, l’intero codice del programma è contenuto fra le parentesi graffe dell’istruzione if: if ((millis() - timeChanged) > delayTime) { }

Come nei cicli, la domanda viene formulata in una coppia di parentesi. Qui utilizziamo la funzione millis() per ottenere il tempo trascorso (in ms) da quando il programma ha iniziato a funzionare. if ((millis() - timeChanged) > delayTime) {

Sottraendo l’ora corrente da timeChanged si ottiene un valore; se questo valore è maggiore del valore di delayTime (che abbiamo inizializzato a 40), allora viene eseguito il codice che cambia il LED acceso. Indipendentemente dal tempo in cui Arduino è in funzione e da quanto elevato diventa il numero di millis(), il test verificherà sempre se l’ultima volta che un LED è cambiato è stato più di 40 ms rispetto all’ora attuale. Ogni volta che cambia il LED, il valore di timeChanged viene aggiornato, pronto per il test successivo. L’effetto consiste nel creare una sorta di “battito cardiaco” in cui il test sarà vero ogni 40 ms, nel qual caso verrà eseguito il codice che cambia LED. Vediamo come funziona.

Incrementare e decrementare Il codice che cambia LED inizia spegnendo tutti i LED che possono essere rimasti accesi a causa dell’iterazione precedente del ciclo: //turn off all of the LEDs for (int i=0; i<10; i++) { digitalWrite(ledPin[i], LOW); }


Qui si usa nuovamente un ciclo for, ma questa volta con la funzione digitalWrite(), che viene utilizzata per cambiare la tensione applicata ai pin digitali. HIGH applica al pin 5 V e LOW applica 0 V. Per esempio, per inviare il valore LOW al pin 13 (come accade nel codice del programma Blink) si utilizza la seguente istruzione: digitalWrite(13, LOW);

Ma in questo caso si utilizza l’indice del ciclo anche come indice dell’array ledPin[], esattamente come abbiamo fatto per la funzione pinMode() in setup(). Ora che i LED sono tutti spenti, il è momento di accendere il successivo: digitalWrite(ledPin[currentLED], HIGH);

In setup() abbiamo inizializzato currentLED a 4 e dunque all’inizio Arduino aumenterà la tensione sul pin 4 con HIGH e il LED si accenderà. Perfetto! Occorre preoccuparsi solo di qualche altro dettaglio. Innanzitutto applicate il seguente trucco alla variabile dir per incrementarla e decrementarla, passando al LED successivo, aggiungendo +1 o -1 al valore di currentLED: currentLED = currentLED + dir;

Poi dobbiamo controllare se abbiamo raggiunto un’estremità della fila di LED e, in questo caso, cambiare segno di dir. Notate che in questa istruzione if controlliamo se un valore è uguale a un altro e dunque dobbiamo utilizzare due segni di uguale per svolgere questa valutazione: if (currentLED == 9) { dir = -1; } if (currentLED == 0) { dir = 1; }

Dopo queste operazioni, rimane una sola cosa da fare, ovvero prendere nota del momento in cui è stato eseguito questo cambiamento: timeChanged = millis();

Il programma, a questo punto, è pronto per controllare nuovamente se sono passati altri 40 ms e l’intero ciclo si ripete, tornando all’inizio di loop().

Come funziona l’hardware Dal punto di vista elettronico, questo progetto è molto semplice. Si utilizza la scheda Arduino per fornire una tensione dai pin digitali per accendere ognuno dei LED, in successione. Accenderemo un solo LED per volta e tutti i LED condividono la stessa connessione a terra. La Figura 4.4 mostra lo schema elettrico di questo progetto. Il problema principale consiste nel fornire il livello di corrente adeguato per ciascun LED. Le resistenze servono proprio a impedire che la corrente in eccesso, in uscita dai pin digitali della scheda Arduino, possa raggiungere i LED e danneggiare i LED stessi, la scheda Arduino o entrambi. Per la maggior parte dei classici LED da 5 millimetri, la corrente operativa è compresa fra 15 e 30 mA. Per determinare la resistenza da utilizzare, si utilizza la Legge di Ohm. I pin digitali danno 5 V. Dovete dividere 5 V per la quantità di corrente accettata dai LED. Quelli utilizzati in questo caso erano da 20 mA. Un mA è un millesimo di Ampere. Dunque, per ottenere un valore di 20 mA dovete spostare il punto decimale di tre posizioni verso sinistra, ottenendo 0,02 Ampere: 5 Volt / 0,02 Ampere = 250 ohm Il risultato è 250 ohm. Se non avete a portata di mano delle resistenze da 250 ohm, utilizzate un valore leggermente superiore, per esempio 270 ohm. Potete utilizzare con sicurezza anche valori


superiori, ma più elevato sarà il valore, minore sarà la luminosità dei LED, poiché minore sarà la quantità di corrente che li attraversa.

Figura 4.4 Lo schema del progetto.

Il potenziale di un potenziometro Ora che il progetto funziona, possiamo provare a modificarlo un po’. Un modo per farlo consiste nel mutare la variabile delayTime in modo che il valore sia maggiore o minore. Più piccolo è il valore, più velocemente si “muoveranno” i LED. Impostando il valore a 20, l’animazione dei LED sarà due volte più veloce. Riducendolo ulteriormente, l’animazione sarà talmente veloce che renderà perfino difficile percepire l’effetto di avanti-indietro. i LED sembreranno sempre accesi, anche se non a piena luminosità. Potete provare ad alterare i valori nel codice, per osservare questo effetto. Tuttavia è una noia dover ogni volta cambiare il valore, caricare il nuovo codice sulla scheda, controllare il risultato e poi cambiare nuovamente il valore. Sarebbe molto più comodo aggiungere semplicemente una manopola al progetto, in modo da poter cambiare con rapidità la velocità dei LED. Esiste un modo semplice per farlo? Naturalmente! Finora abbiamo utilizzato Arduino per controllare l’output, utilizzando i pin digitali e la funzione digitalWrite(). Come potete immaginare, i pin digitali sono anche in grado di accettare un input. Tuttavia, poiché si tratta di pin digitali, possono essere utilizzati solo per input e output digitali. In pratica solo 1 o 0, acceso o spento, +5 V o 0 V. Per cambiare continuativamente la velocità dei LED fino a ottenere il risultato desiderato, dovete fare in modo che Arduino rilevi un cambiamento continuo fra un valore HIGH e un valore LOW, con un input analogico. Esistono sei pin dedicati a questo scopo, in corrispondenza dell’angolo inferiore destro della scheda, chiamati ANALOG IN A0-A5. Possiamo utilizzarli per leggere una tensione compresa fra 0 e 5 V. Per farlo utilizzeremo la funzione analogRead(), specificando fra parentesi il pin da leggere. Per esempio, per leggere dal pin 0, possiamo utilizzare la seguente istruzione:


analogRead(0);

Inserendo questa funzione nel codice, otterremo un valore numerico che corrisponde alla tensione rilevata da Arduino su tale pin. Un valore di tensione che può essere solo 0 o 5 non sarebbe molto utile e dunque Arduino è progettato per restituire un valore in un intervallo più preciso, compreso fra 0 e 1023. Potete utilizzare questo valore nel codice per cambiare il comportamento del codice stesso. In questo caso, intendiamo variare il ritardo fra ogni passaggio da un LED all’altro, modificando il valore di delayTime. Per farlo ci basta aggiungere il seguente frammento alla fine del codice, appena prima dell’ultima riga di codice che termina il ciclo principale loop(): delayTime = analogRead(0); delay(5); }

Tutto ciò che serve, ora, è un modo per fornire una tensione compresa fra 0 e 5 V al pin analogico 0. Possiamo ricorrere a un potenziometro.

Esiste una relazione proporzionale fra la tensione e la resistenza. Maggiore è la resistenza in un determinato punto di un circuito, minore è la tensione misurata dopo tale punto. Variando la proporzione di resistenza in un circuito varia anche la tensione misurabile. Un potenziometro non è altro che una resistenza variabile. È dotato di tre punti di connessione o piedini. All’interno vi è un materiale resistitivo fra il piedino sinistro e quello destro. Il piedino centrale è controllabile tramite un albero: un contatto interno scorre sul materiale resistivo. Ruotando l’albero, cambierà la posizione del contatto. Se si applica una tensione fra il piedino a destra e quello a sinistra, il piedino centrale fornirà una tensione variabile, poiché la resistenza del piedino centrale dipende da dove è posizionato il contatto. Al piedino analogico 0 invieremo proprio la tensione variabile fornita dal piedino centrale. Il pin 5V della sezione POWER di Arduino fornisce la tensione per il piedino sinistro del potenziometro. Ogni circuito deve avere un percorso continuo fra la fonte di alimentazione e la terra e questo è il motivo per cui il piedino destro deve essere connesso a terra. Il piedino centrale è connesso al pin 0, dove Arduino leggerà la tensione variabile con la funzione analogRead(0). Assicuratevi di disconnettere la connessione USB prima di aggiungere o rimuovere qualsiasi componente!

Aggiungete alla breadboard il potenziometro e i ponticelli. La Figura 4.5 mostra come deve essere connesso il potenziometro e la Figura 4.6 mostra l’intero circuito comprendente i LED e il potenziometro. La spaziatura dei fori della maggior parte delle breadboard è in genere di 0,1 pollici (2,54 mm). A seconda della spaziatura o dello spessore dei piedini, potreste non riuscire a inserire direttamente il potenziometro nella breadboard. Se i piedini non entrano, potete utilizzare dei coccodrilli per connettere il potenziometro a dei fili che conducono alla scheda Arduino e alla breadboard oppure saldare i fili direttamente al potenziometro. Per informazioni sulla saldatura, consultate il Capitolo 3.


Figura 4.5 Uso di un potenziometro per creare un semplice circuito con input analogico.

Ora che avete connesso tutti i componenti, riconnettete il cavo USB per alimentare Arduino. Se non avete ancora inviato alla scheda il codice modificato, fatelo in questo momento. Se tutto funziona correttamente, dovreste poter cambiare la velocità dei LED ruotando il potenziometro. Se il potenziometro non sembra funzionare, disconnettete l’alimentazione e ricontrollate le connessioni. Potete provare con diversi valori di resistenze e potenziometri per studiare la relazione fra la resistenza applicata al circuito di input e la velocità dell’animazione. Potete anche impiegare dei potenziometri a cursore, di quelli che potete trovare su un mixer audio.

Figura 4.6 Aggiunta di un potenziometro per controllare la velocità.

Ora che sapete come controllare la velocità dell’animazione, potete provare qualche altra idea. Provate a creare altri effetti, come la collisione di due luci che partono dalle estremità o provate a creare un effetto di rimbalzo. Dopo aver compreso alcuni degli elementi di base della costruzione del circuito e della programmazione, potrete sviluppare ogni genere di effetto.


Capitolo 5

Un pupazzetto luminoso In questo capitolo I componenti Costruzione del circuito Il codice di controllo Varialuce per LED con la modulazione PWM

L

e luci sanno essere calde o fredde, in una parola “emotive”. Basta variare o spostare delle luci, che sembreranno assumere una personalità tutta loro. Forse non avete mai pensato di considerare delle luci come un pupazzetto, ma con un po’ di creatività e seguendo le istruzioni fornite in questo capitolo, potrete creare un grazioso pupazzetto dotato di colori che ne esprimono l’umore. Il pupazzetto luminoso attraverserà un ciclo di colori casuali ottenuti miscelando la luce di tre LED: rosso, verde e blu. Potete ottenere quasi ogni sfumatura di colore impiegando le varie combinazioni di luminosità di questi tre LED. In questo capitolo vedremo come procurarci i componenti necessari, come connettere tali componenti, come costruire il circuito e come controllare che tutto sia connesso correttamente. Dopo aver caricato il codice sulla scheda Arduino, potremo modificarlo per dare al pupazzetto una personalità divertente. L’ultimo passo consisterà nel collocare il tutto in un contenitore originale, che renda l’insieme più interessante. La mia versione di questo progetto è un pupazzetto che ho soprannominato Lux. Ho scelto questo nome perché è l’unità standard internazionale per la misurazione della luce e anche perché mi è sembrato un nome appropriato. Tutti gli animaletti hanno un loro umore e così anche Lux. Per farlo sembrare più reale, ogni tanto fa le fusa, pulsando lentamente. Casualmente, Lux assume un umore felice, indicato da una pulsazione verde; oppure si arrabbia, nel qual caso la pulsazione è rossa. La cosa interessante è che una volta che scoprirete come funziona il codice di Lux, potrete modificarlo per creare nuove “espressioni” per il pupazzetto luminoso.

I componenti Per prima cosa occorre procurarsi i componenti necessari per costruire il pupazzetto luminoso. Se non avete ancora predisposto uno spazio di lavoro per Arduino, consultate il Capitolo 2 per ulteriori informazioni sul modo in cui connettere la scheda Arduino al computer e utilizzare l’ambiente di sviluppo (IDE) di Arduino per caricare programmi su di essa. Mettere insieme i componenti per il pupazzetto luminoso è abbastanza semplice. Come potete vedere nella Figura 5.1, avrete bisogno dei seguenti elementi. La scheda Arduino. Una breadboard. Tre LED a elevata luminosità: uno rosso, uno verde e uno blu. Tre resistenze da 250 ohm. Ponticelli di varie lunghezze. Un alimentatore compreso fra 7 e 12 Volt in corrente continua. Un contenitore, qualcosa di trasparente, in cui inserirlo.


Figura 5.1 Tutti i componenti necessari per creare il pupazzetto luminoso. Siate creativi nella scelta del contenitore.

Il contenitore che ospiterà il progetto è importante, poiché dà alla vostra realizzazione un tocco di personalità e ne nasconde gli elementi interni. Può essere qualsiasi cosa che sia trasparente e opaca, per esempio potrebbe essere una piccola scatola di plastica, un contenitore per il cibo o un cubo origami. Usate un po’ di immaginazione, poiché è proprio il contenitore a dare stile al pupazzetto. Create un vostro contenitore o cercate qualcosa che sia di dimensioni sufficienti per ospitare la scheda Arduino e la breadboard. Se il contenitore utilizzato è troppo piccolo, potete riporre questi elementi separatamente e saldare dei fili per raggiungere i LED. Dopo aver iniziato a riflettere in questi termini sui prodotti di largo consumo, potrete trovare praticamente dappertutto dei potenziali contenitori.

Costruzione del circuito Assicuratevi che l’alimentazione sia staccata mentre realizzate il circuito. La sicurezza è importante in quanto, operando sui circuiti sotto tensione, potreste danneggiare la scheda Arduino, il computer o anche voi stessi. Dunque assicuratevi che la scheda Arduino non sia connessa al computer o all’alimentatore. Quando sarete sicuri che la scheda Arduino non è alimentata, iniziate connettendola alla breadboard. Applicate i ponticelli nel seguente modo. 1. Connettete un ponticello al pin GND che si trova in fondo alla riga dei pin digitali nella parte superiore della scheda Arduino. Potete anche utilizzare uno dei pin GND nell’area POWER sul bordo inferiore della scheda. La scheda Arduino UNO ne offre due, che potete utilizzare indifferentemente. 2. Connettete l’altra estremità del ponticello al primo foro in una delle lunghe colonne sul lato della breadboard. Questo contatto è quello di terra, che fornisce una connessione condivisa per tutti i componenti da connettere a terra. Su alcune breadboard, le colonne laterali hanno un codice a colori. Per convenzione, si usa la colonna nera (o blu) per la terra e quella rossa per il positivo. Nelle figure di questo libro, per comodità, la breadboard viene mostrata sempre ruotata di 90 gradi e dunque le colonne vanno da sinistra a destra e le righe vanno dall’alto verso il basso (Figura 5.2).


Figura 5.2 Posizionamento dei componenti sulla breadboard

Ora dovete aggiungere al circuito le resistenze e i LED. 1. Connettete alla breadboard le tre resistenze. Ognuno dei piedini delle resistenze dovrà trovarsi in una riga differente della breadboard, come illustrato nella Figura 5.2. Disponete le resistenze in modo ordinato. Nessuno dei piedini dovrà essere connesso ad altri fori della stessa riga. 2. Inserite i tre LED in modo che il piedino più lungo sia nella stessa riga dell’estremità opposta di ciascuna resistenza e il piedino corto sia in una riga inutilizzata di fori. 3. Utilizzate un ponticello corto per connettere il piedino di ogni resistenza che non è connesso ai LED, rispettivamente ai pin digitali 9, 10 e 11 della scheda Arduino. 4. Utilizzate qualche ponticello corto per connettere il piedino corto di ciascun LED alla linea di terra che avete approntato nel Passo 2. In questo modo avete stabilito una connessione elettrica che consente alla corrente di passare dal pin 9 attraverso una delle resistenze verso il LED rosso e poi a terra. Dovreste essere in grado di tracciare un percorso immaginario dal pin 9 in modo continuo verso il pin GND della scheda Arduino. La stessa cosa vale per i pin 10 e 11.

Il piedino lungo del LED si chiama anodo e il piedino corto si chiama catodo. L’energia scorre in una sola direzione per accendere il LED: dall’anodo verso il catodo. Riesaminate la Figura 5.2 per assicurarvi di aver eseguito correttamente tutte le connessioni. Dedicate particolare attenzione all’orientamento dei LED. Se un LED è inserito al contrario, non si accenderà. Fortunatamente non si danneggerà neppure, ma è sempre meglio controllare prima di dare alimentazione. Ora che avete realizzato il circuito, potete inserire il codice, dare un’occhiata a come funziona e poi caricarlo sulla scheda.

Come funziona il codice Il codice di controllo definisce direttamente il comportamento del pupazzetto luminoso e dunque è importante comprendere le decisioni prese dal codice e i comportamenti risultanti.


È sempre comodo creare dei flowchart (diagrammi di flusso) per cercare di descrivere il comportamento del codice e per indicare cosa accade quando si verificano determinati eventi. Il diagramma di flusso della Figura 5.3 spiega la sequenza delle decisioni che verranno prese dal codice.

Cambiare umore Per Lux, la prima decisione consiste nello scegliere il proprio umore. Può scegliere fra quattro diversi umori: fusa, felice, arrabbiato e normale, l’umore che manifesta il più delle volte. Per scegliere un umore, la scheda Arduino estrae un numero casuale compreso fra 0 e 20. Se il numero è 0, il pupazzetto fa le fusa, ovvero Lux riduce lentamente il colore attuale per dieci volte. Se il numero è 1, Lux è felice e fa lampeggiare il LED verde per dieci secondi, per poi ricominciare. Se il numero selezionato è 2, Lux è arrabbiato: fa lampeggiare il LED rosso per 10 secondi e poi torna alla normalità. Se il numero è maggiore di 2, Lux ha un umore normale e in questa condizione cambia lentamente i tre colori, miscelandoli. Come potete vedere nella Figura 5.3, l’85% delle scelte porta all’umore normale. Lux farà qualcosa di diverso solo una volta ogni tanto. Potete cambiare questo comportamento alterando questi valori, come vedremo più avanti nel capitolo.

Figura 5.3 La sequenza di passi eseguiti da Lux.


Il codice pezzo per pezzo Potete inserire il codice che configura il funzionamento del pupazzetto luminoso e controllare il comportamento “normale” delle luci, che prevede passaggi graduali di colore. Poi potete aggiungere delle funzioni in più per controllare gli altri umori. Iniziate inserendo il codice seguente in un nuovo sketch. Potete anche scaricare lo sketch del sito web del libro all’indirizzo www.hoeplieditore.it/6323-9 o tagliare e incollare il codice dello sketch dal sito web. // The Light Pet - A Color Changing Mood Light // Randomly selects and fades through colors of three LEDs // Set which pins will use each color const int redLED = 9; const int greenLED = 10; const int blueLED = 11; // Assign variables for the LEDs int redValue = 0; // the current value of brightness int newRedValue = 0; // the new value of brightness int blueValue = 0; int newBlueValue = 0; int greenValue = 0; int newGreenValue = 0; // Assign “utility” variables for the random number, and the fading speed int randomValue = 0; int fadeSpeed = 50; // Setup the three LED pins for OUTPUT void setup(){ pinMode(redLED, OUTPUT); pinMode(blueLED, OUTPUT); pinMode(greenLED, OUTPUT); } // The main loop of the program void loop() { mood = random(20); // pick a number from 0-19 to set the mood of the pet if (mood > 2){ // if the number picked was anything higher than 2, // run the color blending function blendColors(); } }

Vediamo un attimo che cosa accade. All’inizio vi sono alcune dichiarazioni di variabili. Le tre variabili intere contengono i numeri dei pin che la scheda Arduino attiverà e disattiverà per accendere e spegnere i LED (pin 9, 10 e 11). I valori interi si chiamano in modo appropriato, sulla base del colore di ciascun LED: const int redLED = 9; const int greenLED = 10; const int blueLED = 11;

Questi interi sono costanti (parola riservata const), ovvero mantengono sempre lo stesso valore per l’intera durata del programma. L’impiego di costanti riduce lo spazio occupato dal programma. Anche se questo non rappresenta un problema per questo piccolo progetto, è sempre opportuno abituarsi a utilizzare le costanti quando è il caso, ovvero quando i valori non cambiano da un’esecuzione all’altra del codice. In questo caso ci troveremo sempre a usare i pin 9, 10 e 11 per i LED rosso, verde e blu e dunque è naturale impiegare delle costanti. A questo punto il codice crea ulteriori variabili per ognuno dei LED. Per miscelare i colori a livelli differenti di luminosità, bisogna cambiare progressivamente i valori di luminosità di ciascun LED impostando un nuovo valore. La prima variabile è redValue, che contiene il valore di luminosità attuale del LED rosso. È sempre opportuno assegnare un valore a ogni variabile nel momento in cui viene creata e dunque anche questa variabile verrà inizialmente impostata a 0, un valore che cambierà non appena verrà eseguito il programma. La variabile newRedValue contiene il nuovo valore di luminosità che verrà assunto dal LED. Questo nuovo valore è impostato a 0, ma nel momento in cui il programma inizierà a funzionare, verrà estratto casualmente scegliendo un valore compreso fra 0 (LED completamente spento) e 255 (massima luminosità): int redValue = 0;

// the current value of brightness


int newRedValue = 0; // the new level of brightness

Infine vi sono due variabili di servizio che controllano il funzionamento del programma. Il comportamento del pupazzetto luminoso è tale per cui i colori cambiano gradualmente. A ogni ciclo del programma, ogni LED assume un nuovo livello di luminosità. La prima variabile è randomValue. Come si può facilmente immaginare, il codice usa questa variabile per contenere un valore casuale che verrà scelto più avanti, nel ciclo principale. La seconda variabile è fadeSpeed. La utilizzerete più avanti per controllare la velocità di riduzione della luce: int randomValue = 0; int fadeSpeed = 50;

Procedendo, il codice di inizializzazione definisce il modo in cui Arduino usa i pin digitali. Qui occorre dichiarare quali dei tre pin digitali verranno utilizzati e il fatto che verranno utilizzati per l’output. Poiché abbiamo specificato precedentemente che redLED è una variabile con il valore 9, la prima istruzione imposta il pin 9 per l’output. Le variabili blueLED e greenLED svolgono la stessa operazione, rispettivamente per i pin 10 e 11: pinMode(redLED, OUTPUT); pinMode(blueLED, OUTPUT); pinMode(greenLED, OUTPUT);

Ora osservate il corpo principale del codice, che contiene il loop. È tutto piuttosto semplice. Qui accadono solo due cose: la generazione del numero casuale e poi la fusione del colore quando il valore è maggiore di 2: void loop() { mood = random(20); if (mood > 2){ blendColors(); } }

Definizione di nuove funzioni nel codice Potete notare un aspetto interessante nel modo in cui viene organizzato questo codice. Spesso, all’interno del ciclo principale, si inseriscono tutte le istruzioni che Arduino deve svolgere fra le due parentesi graffe della funzione loop. Tuttavia, se il codice deve svolgere molte operazioni, può diventare molto complesso da leggere. A questo punto è opportuno rendere il codice più modulare, in modo che le singole sequenze di eventi siano contenute in altrettante funzioni. Ciò semplifica la leggibilità e la manutenibilità del codice. Inoltre, nei programmi più complessi, in cui una funzione viene eseguita più volte in punti differenti, dovrete modificare una funzione una sola volta, cambiando però il suo comportamento in tutti punti del codice in cui tale funzione viene impiegata.

La parte importante consiste nell’assegnare alla variabile mood un numero casuale che verrà utilizzato per cambiare i colori della luce. Per farlo si usa la funzione random() che sceglierà un numero casuale compreso fra 0 e il numero specificato fra parentesi, escluso però tale estremo. Dunque, in questo codice, chiediamo ad Arduino di scegliere un numero casuale compreso fra 0 e 19. Possiamo anche specificare un intervallo fra due numeri, nel qual caso, il primo numero stabilisce il limite inferiore (incluso) e il secondo il limite superiore (sempre escluso). Per esempio, la funzione random (5,10) sceglierà un numero casuale compreso fra 5 e 9.

Il segno = chiede ad Arduino di assegnare alla variabile mood il valore scelto dalla funzione random(). Quindi non significa veramente “uguale” ma, più precisamente, “assegna”. Per valutare se due


elementi sono uguali, dovete usare il doppio segno di uguale: ==. L’istruzione successiva è un’istruzione if che controlla se il valore di mood che è appena stato scelto è maggiore di 2, il che accadrà la maggior parte delle volte. Se è maggiore, viene eseguita la funzione blendColors(). Successivamente, vedremo che cosa fare se il numero è pari a 2 o meno, ma innanzitutto vediamo come si formano i colori, ovvero come si comporterà il pupazzetto luminoso la maggior parte delle volte. blendColors() è una funzione definita dall’utente, che cambia la luminosità di ognuno dei tre LED. Arduino offre molte funzioni predefinite che abbiamo già usato, come setup(), loop() e random(). Ma

potete anche creare nuove funzioni per organizzare il codice e facilitarne l’interpretazione. La descrizione delle operazioni svolte dalla funzione è situata nella sua sezione di codice, dopo il ciclo principale. Dunque, non dovete includere queste funzioni nel ciclo principale, le dovete solo richiamare dal ciclo principale. Potete vedere in questo codice che una volta che viene eseguita la funzione blendColors(), il ciclo principale termina e Arduino torna all’inizio del ciclo, per scegliere il successivo numero casuale.

Miscelare la luce Dopo aver specificato il ciclo principale, tutto è pronto per aggiungere ciò che deve svolgere la funzione definita dall’utente. Si tratta di qualche riga in più di codice, ma il tutto serve sostanzialmente a svolgere due operazioni: impostare il nuovo livello di luminosità e applicare tale livello a un LED, e questo per ogni singolo LED. Dedicate qualche istante a inserire oppure a copiare e incollare il seguente codice nello sketch. void blendColors(){ newRedValue= random(255); // Pick a random value for the red LED if (redValue < newRedValue){ for (int x=redValue; x<newRedValue; x++) { analogWrite(redLED, x); delay(fadeSpeed); } } else { for (int x=redValue; x>newRedValue; x--) { analogWrite(redLED, x); delay(fadeSpeed); } } redValue=newRedValue; // set the value for the green LED newGreenValue= random(255); if (greenValue < newGreenValue){ for (int x=greenValue; x<newGreenValue; x++) { analogWrite(greenLED, x); delay(fadeSpeed); } } else { for (int x=greenValue; x>newGreenValue; x--) { analogWrite(greenLED, x); delay(fadeSpeed); } } greenValue=newGreenValue; // set the value for the blue LED newBlueValue= random(255); if (blueValue < newBlueValue){ for (int x=blueValue; x<newBlueValue; x++) { analogWrite(blueLED, x); delay(fadeSpeed); } } else { for (int x=blueValue; x>newBlueValue; x--) { analogWrite(blueLED, x); delay(fadeSpeed); } } blueValue=newBlueValue; }

Ecco come si crea una nuova funzione. Create una funzione definita dall’utente assegnandole un nome, in questo caso blendColors. La parola riservata void significa che la funzione fa solo ciò che è specificato all’interno delle parentesi graffe e questo è tutto. Non restituisce nulla e dunque si specifica void. Poi si inserisce qualcosa di utile da fare all’interno della coppia di parentesi graffe:


void blendColors(){ something useful gets done here! }

Spesso è opportuno scrivere una funzione che prenda dei dati, faccia qualcosa con tali dati e poi invii il risultato al ciclo principale. Ma blendColors() non richiede alcun particolare input e non deve restituire dati alla parte successiva del programma; non deve fare altro che cambiare la luminosità dei LED. Le parentesi vuote () significano che questa funzione non si aspetta di ricevere nulla con cui lavorare. Basta usare blendColors() per cambiare il livello di luminosità dei tre LED. La prima cosa utile che fa blendColors() è scegliere un valore casuale per impostare un nuovo livello di luminosità e assegnarlo alla variabile newRedValue. Questo è lo stesso metodo già visto in precedenza per scegliere un umore casuale: newRedValue = random(255);

Non volete che il livello di luminosità salti semplicemente a questo nuovo valore. Volete che passi gradualmente dal valore corrente lungo tutti i valori intermedi fino ad arrivare a newRedValue(). Per farlo, dovete sapere se il nuovo valore è maggiore o minore di quello corrente. Dunque il codice controlla se il valore casuale è superiore o inferiore rispetto al valore corrente, utilizzando l’istruzione if: if (redValue < newRedValue){ for (int x=redValue; x<newRedValue; x++) { analogWrite(redLED, x); delay(fadeSpeed); } } else { for (int x=redValue; x>newRedValue; x--) { analogWrite(redLED, x); delay(fadeSpeed); }

Se il test è verificato (true) e redValue è minore di newRedValue, allora viene eseguito il codice contenuto nel primo gruppo di parentesi graffe. Altrimenti (la parte indicata da else), il test è falso (false) e viene eseguito il codice che segue la parola riservata else. Ora arriva la parte più complessa. La gradualità è ottenuta tramite un ciclo for, che abbiamo già impiegato nel Capitolo 4, e un particolare metodo chiamato analogWrite(). Il ciclo for inizia assegnando il valore corrente di redValue alla variabile locale x: for (int x=redValue; x<newRedValue; x++) { analogWrite(redLED, x); delay(fadeSpeed); }

Fintantoché x è minore di newRedValue, ogni ciclo incrementa il valore di x di una unità (x++) finché non raggiunge newRedValue. Si deve incrementare il valore di x fra il valore corrente di redValue e newRedValue. Si utilizzerà questo valore crescente di x per impostare il livello di luminosità dei LED. Il livello è impostato tramite il metodo analogWrite().

Piccoli trucchi con la modulazione PWM Per cambiare il livello di luminosità di ognuno dei tre LED si impiega una tecnica chiamata PWM (Pulse-Width Modulation). Il Capitolo 4 descrive come accendere e spegnere, semplicemente, i LED e se avete provato l’esempio Blink, potete vedere che l’operazione è abbastanza semplice. Più complesso è far sì che Arduino faccia incrementare o decrementare gradualmente il livello di luminosità. I LED sono dispositivi digitali, che offrono solo due stati possibili. Per natura, un LED può essere solo interamente acceso o solo interamente spento e dunque non ci sono passaggi intermedi, ma potete simulare una minore luminosità con un piccolo trucco. Basta accendere e spegnere ripetutamente il LED con una frequenza tale da simulare una gradualità. Per farlo si usa la modulazione PWM. Normalmente, per accendere o spegnere un LED si usa la funzione digitalWrite(), applicata a uno dei pin digitali (0-13). Tuttavia, la velocità con cui può operare è limitata, specialmente se si devono controllare più pin digitali. Inoltre, se il microprocessore deve occuparsi anche di altre operazioni,


non riuscirà ad accendere e spegnere il LED con la dovuta rapidità e questo farà sì che i LED sembreranno lampeggiare piuttosto che aumentare gradualmente di luminosità. PWM è una speciale funzionalità del processore che risolve questo problema. Utilizzate i pin 9, 10 e 11 per un buon motivo: sono tre dei sei pin disponibili per la modulazione PWM. Si usa la modulazione PWM per generare un output analogico da un pin digitale. PWM cambia le proporzioni di tempo in cui un pin digitale rimane ON o OFF, ovvero lo commuta fra 5 e 0 V. Questa proporzione di tempo è chiamata duty-cycle. Variando la durata del duty-cycle o modulandola, potete variare la durata con cui l’impulso digitale è ON o OFF, un fattore chiamato pulse width. Un 50% di duty-cycle significa che il pin digitale è portato a 5 V per la metà del tempo e così via. Un duty-cycle del 100% significa che il pin digitale è sempre ON.


Figura 5.4 Uso della modulazione PWM per cambiare il livello di luminosità su un pin digitale. In verticale sono rappresentati gli intervalli di tempo, normalmente di 700 cicli al secondo.

Per utilizzare la modulazione PWM si utilizza il metodo analogWrite() su un pin digitale. Si chiama analogWrite() poiché vengono impiegati i pin digitali per simulare una variazione continua (ovvero analogica) dei valori, sebbene non si faccia altro che accendere e spegnere in rapida successione i LED. Utilizzando analogWrite si specifica quale pin deve essere attivato e il duty-cycle (0-100%) utilizzando un valore che va da 0 a 255. Le cose, in effetti, sono un po’ complesse. Per esempio, per attivare il pin 3 per un duty-cycle del 50% si usa: analogWrite(3,127);

Questo perché 127 è uguale a 255 / 2, equivalente al 50%. Un duty-cycle dell’80% richiede il valore 204 (ovvero 255 * 0,80). Per simulare la gradualità dei tre LED del pupazzetto luminoso, si usa la modulazione PWM per cambiare il duty-cycle del relativo pin digitale. L’impostazione del pin digitale del LED rosso a un duty-cycle del 100% significa che sarà sempre a piena luminosità, mentre con un duty-cycle dello 0%, sarà sempre spento. Per confondere ulteriormente le cose, la luminosità apparente del LED non corrisponde all’output rigidamente lineare della modulazione PWM. Gli occhi non percepiscono la luminosità in modo lineare. In particolare gli occhi percepiscono i vari colori con livelli differenti di sensibilità. Pertanto un duty-cycle del 50% non avrà una luminosità apparente pari a metà del 100%, ma per un progetto semplice come il nostro questo non rappresenta un problema. Vogliamo solo che la luminosità


relativa dei colori sembri cambiare gradualmente. L’architettura della scheda Arduino UNO limita il numero di pin PWM a 6. Su una scheda Arduino UNO, solo i pin 3, 5, 6, 9, 10 e 11 possono gestire la modulazione PWM. La scheda Arduino MEGA offre 15 pin PWM, nel caso abbiate bisogno di più pin di questo tipo. Ora che sapete come funziona la modulazione PWM, vediamo come impiegarla nel codice, facendo riferimento alla Figura 5.4. Nel codice, usiamo analogWrite per cambiare il valore di ciascun LED. Il valore x proviene dal ciclo for in cui viene lanciata la funzione analogWrite: for (int x=redValue; x<newRedValue; x++) { analogWrite(redLED, x); delay(fadeSpeed); }

L’ultima cosa che accade qui è l’esecuzione della funzione delay(), utilizzata per regolare la rapidità di esecuzione del ciclo for. Cambiate la velocità di variazione della luminosità intervenendo sul valore della variabile fadeSpeed, che è stata impostata all’inizio del programma a 30 ms. A ogni ciclo, il microprocessore attende 30 ms. In tal modo potrete effettivamente vedere l’effetto di dissolvenza. Senza questo ritardo, la dissolvenza sarebbe troppo rapida per poter essere colta dagli occhi. Abbiamo introdotto fin troppi contenuti. È giunto il momento di mettere a frutto tutto questo lavoro.

Collaudo del codice Dopo aver inserito questo codice nell’ambiente di sviluppo di Arduino, assicuratevi di collaudarlo facendo clic sul pulsante Verifica. Il compilatore dirà se il codice contiene errori e visualizzerà i risultati nella finestra di stato che si trova nella parte inferiore dell’IDE. Evidenzierà inoltre il problema nella prima posizione del codice in cui incontra un ostacolo. Inizialmente può essere piuttosto complesso capire ciò che sta dicendo il compilatore. I problemi più comuni sono legati all’uso di punti e virgola (dimenticati o in eccesso) e parentesi graffe (dimenticate o in eccesso). Se avete problemi a identificare immediatamente l’errore, una rapida ricerca sui forum vi aiuterà a risolvere il problema.

Potete risparmiare tempo e trovare errori nel codice compilandolo subito, prima di caricarlo sulla scheda Arduino.

Caricamento del codice È giunto il momento di premere il pulsante di lancio! Se il compilatore non si oppone, connettete la scheda Arduino al computer tramite il cavo USB. Fate clic sul pulsante Carica e per qualche istante le spie TX e RX della scheda lampeggeranno. Quando smetteranno di lampeggiare, i tre LED del circuito inizieranno ad accendersi a diversi livelli di luminosità e dovrebbero cambiare lentamente di intensità. Il “pupazzetto” ha preso vita! Provate a osservarlo per qualche istante. Controllate il modo in cui cambiano i livelli. Proveremo ad aggiungergli un po’ di personalità definendo alcuni comportamenti tramite nuove funzioni che inseriremo nel codice.

Interventi sul codice Quando sarete soddisfatti di osservare i colori che cambiano gradualmente, potete dare un tocco di personalità al pupazzetto aggiungendogli un umore. Potete farlo creando una variabile per la durata dell’espressione e una nuova funzione per ogni nuovo umore. L’aggiunta di nuove funzioni è piuttosto semplice. Seguono lo stesso formato di blendColors(). Innanzitutto aggiungete la variabile globale per la durata dell’umore:


// Assign variables to select the mood and the time to wait in a mood int mood = 0; const int moodTime = 10000; // time to wait in milliseconds, 10000 = 10 seconds

Non rimane che specificare quando deve verificarsi il cambiamento di umore, di nuovo nel ciclo principale. // The main loop of the program void loop() { mood = random(20); // pick a number from 0-20 to set the mood of the pet if (mood == 0){ // if the number picked was 0, run the purr function purr(); } if (mood == 1){ // if the number picked was 1, run the happy function happy(); } if (mood == 2){ // if the number picked was 2, run the sad function sad(); } if (mood > 2){ // if the number picked was anything higher than 2, // run the color blending function blendColors(); } }

A seconda del numero casuale assegnato a mood, il programma lancia una funzione differente. Se il numero casuale è 0, viene eseguita la funzione purr(); se è 1, viene eseguita la funzione happy(); se è 2, viene eseguita la funzione sad(). Notate che il test che verifica se due valori sono equivalenti impiega due segni di uguaglianza e non uno solo! Ora potete aggiungere le funzioni che cambiano le luci a seconda dell’umore. Aggiungetele alla fine del programma, dopo la funzione blendColors(). Utilizzano le stesse tecniche impiegate dalla funzione blendColors(). La funzione purr() è particolare. Contiene due cicli for uno dentro l’altro: quello interno controlla la gradualità dei cambiamenti di colore con PWM; quello esterno ripete il ciclo interno per dieci volte. La funzione purr() cambia il duty-cycle di tutti i LED da 0 a 255 e poi ricomincia da capo. Il ciclo esterno utilizza la variabile count per controllare quante volte si verifica questa operazione. Se desiderate che il pupazzetto faccia le fusa più a lungo, aumentate il valore di count. La funzione delay(10) rallenta un po’ l’azione, per consentire di osservare la gradualità delle variazioni luminose: void purr(){ for (int count=0;count<10;count++){ for(int x=0;x<255;x++){ analogWrite(redLED, x); analogWrite(greenLED, x); analogWrite(blueLED, x); delay(10); } for(int x=255;x>0;x--){ analogWrite(redLED, x); analogWrite(greenLED, x); analogWrite(blueLED, x); delay(10); } } }

Infine occorre descrivere gli altri due umori, happy() e sad(). A questo punto dovrebbe essere abbastanza chiaro come funzionano. Entrambi usano la modulazione PWM per variare la luminosità dei LED dal loro livello attuale a un nuovo livello. Per happy(), il LED verde viene portato dal suo livello attuale, greenValue, a piena luminosità, duty-cycle del 100%, mentre gli altri due LED vengono portati a un duty-cycle dello 0%. La funzione sad() svolge la stessa operazione, ma operando sul LED rosso. Il pupazzetto permane in questo umore per il moodTime impostato all’inizio del codice, ovvero per 10.000 ms (10 secondi). Vi è un ultimo ciclo alla fine di ogni funzione che riporta a zero, prima che la funzione termini e tutto torni al ciclo principale: void happy(){ for(int x=greenValue;x<255;x++){ analogWrite(greenLED, x); delay(fadeSpeed); } for(int x=redValue;x>0;x--){ analogWrite(redLED, x); delay(fadeSpeed);


} for(int x=blueValue;x>0;x--){ analogWrite(blueLED, x); delay(fadeSpeed); } delay(moodTime); // sets how long the pet will wait in this mood for(int x=255;x>0;x--){ // fade to black analogWrite(greenLED, x); delay(fadeSpeed); } } // the sad function turns on only the red LED for the mood time void sad(){ for(int x=redValue;x<255;x++){ analogWrite(redLED, x); delay(fadeSpeed); } for(int x=greenValue;x>0;x--){ analogWrite(greenLED, x); delay(fadeSpeed); } for(int x=blueValue;x>0;x--){ analogWrite(blueLED, x); delay(fadeSpeed); } delay(moodTime); // sets how long the pet will wait in this mood for(int x=255;x>0;x--){ // fade to black analogWrite(redLED, x); delay(fadeSpeed); } }

Notate che state utilizzando nuovamente la variabile fadeSpeed per rendere graduale la transizione. Provate a utilizzare valori differenti per queste variabili, per modificare l’umore del pupazzetto. Cercate di essere creativi! Scoprirete ben presto che sarete in grado di dare al pupazzetto la personalità che desiderate.

Come funziona l’hardware Ora che il codice è caricato nella scheda Arduino e che avete visto qualche variazione di umore e di colore, è il momento di ricapitolare ciò che avviene nell’hardware, dal punto di vista elettronico. In tal modo, quando vi occuperete di progetti più avanzati, vi sarà più chiaro ciò che sta accadendo. Il fatto di mettere il tutto in un contenitore dà al progetto del pupazzetto un’identità più precisa. Non preoccupatevi troppo di procurarvi esattamente gli stessi LED indicati nell’elenco dei componenti ma, possibilmente, utilizzate LED ad alta luminosità. La luminosità dei LED viene misurata in microcandele (mcd). Scegliete LED con valori elevati di mcd. Più elevata è la luminosità, più luminoso sarà anche il pupazzetto. Lo schema della Figura 5.5 mostra la frequenza di emissione luminosa di ciascun LED, in nanometri. Molto spesso troverete queste indicazioni sui datasheet dei LED, insieme ad altre specifiche. È particolarmente importante dedicare attenzione alla massima corrente dei LED, misurata in milliampere (mA). Se non conoscete il valore massimo, potete ricercare i datasheet della maggior parte dei componenti elettronici in Internet. Per i LED più comuni, normalmente si tratta di 20 mA o anche meno. Le resistenze limitano la quantità di corrente che scorre da ciascun pin digitale di Arduino verso terra. Poiché i pin digitali forniscono 5 V, potete determinare quali resistenze sono necessarie utilizzando la Legge di Ohm, che stabilisce che la tensione di un circuito è uguale alla corrente moltiplicata per la resistenza (ovvero V = I * R): 5 volt / 0,02 ampere = 250 ohm.


Figura 5.5 Schema elettrico del pupazzetto luminoso.

Dividete 5 V per il livello di corrente massimo per cui sono tarati i LED, ovvero per 20 mA. Un mA è un millesimo di Ampere e dunque per ottenere il valore in mA dovete spostare il punto decimale di tre posizioni a sinistra: 0,02 A. Il risultato è 250 ohm. Se non avete a disposizione una resistenza da 250 ohm, utilizzatene una di un valore leggermente superiore, per esempio 270 ohm. Più elevato è il valore, meno luminosi saranno i LED, poiché saranno raggiunti da meno corrente. Naturalmente, non avete bisogno di utilizzare tre LED singoli per miscelare i colori. Esistono LED tricolori esattamente per questo scopo, che incorporano i tre LED rosso, verde e blu in un unico LED dotato di quattro piedini: tre anodi e un catodo. Questa configurazione è chiamata a catodo comune, in quanto i LED condividono un catodo che va connesso a terra all’interno del circuito. Dopo aver collocato tutti i componenti sulla breadboard e aver programmato la scheda Arduino, potete disconnetterla dal computer, staccando il cavo USB e connetterla a un alimentatore. La scheda Arduino lancerà il codice subito dopo essere stata alimentata. Quando sarete soddisfatti, collocate la scheda Arduino e la breadboard nel contenitore che avete scelto. Per ospitare questo progetto ho utilizzato un piccolo alieno acquistato all’IKEA (Figura 5.6).

Figura 5.6 Potete utilizzare un giocattolo in commercio come contenitore per il progetto.


Questo giocattolo contiene già dell’elettronica al suo interno, comprendente un LED, un microcontroller e un commutatore, che ho messo da parte per futuri utilizzi. Il contenitore, in plastica morbida e traslucida, reca anche un comodo foro posteriore per l’alimentatore. Riuscire a infilarci tutto l’hardware è stato un po’ problematico e dunque ho utilizzato dei fili per connettere la scheda Arduino alla breadboard e poi ho ripiegato il tutto a formare un piccolo sandwich. Se il contenitore non è di dimensioni sufficienti, affinate le vostre abilità di saldatori, come descritto nel Capitolo 3, e saldate dei fili ai tre LED. In tal modo potrete nascondere la scheda Arduino e la breadboard dove vorrete. Non vi rimane che trovare un luogo adatto per il pupazzetto, che inizierà a tenervi compagnia.


Capitolo 6

Un’insegna scorrevole In questo capitolo Scelta dei componenti Realizzazione del circuito Come funziona il codice di scorrimento del testo Come funziona l’hardware

D

ato che il costo dei LED è ormai davvero irrisorio, e che la loro gamma di colori e di luminosità si è estesa enormemente, le insegne a LED sono ormai ovunque e molte hanno dimensioni gigantesche. È praticamente impossibile non trovare per strada insegne animate. Ne siamo letteralmente circondati, anche nelle cittadine più piccole. Le insegne animate che campeggiano a Times Square, New York e a Piccadilly Circus, Londra, impiegano milioni e milioni di LED. Con una scheda Arduino e pochi componenti di “contorno”, possiamo creare con facilità un’insegna con la quale comunicare al mondo il nostro messaggio. Questo capitolo sviluppa un progetto che si basa su una matrice di 8 × 8 LED controllata da Arduino. Creeremo un’immagine sul display utilizzando uno sprite, un elemento grafico con cui è possibile creare font personalizzati e caratteri. Scopriremo poi come passare da uno sprite all’altro per creare animazioni e come cambiare la velocità di animazione. Quando vi sarete impadroniti delle tecniche di controllo degli sprite, potrete unire più moduli a matrice per visualizzare più caratteri, a formare un intero messaggio.

I componenti Questo progetto richiede pochi componenti, ma molti collegamenti. Prima di iniziare, procuratevi i seguenti componenti, rappresentati nella Figura 6.1. La scheda Arduino. Una breadboard. Un display a matrice di 8 × 8 LED a catodo comune (per esempio Jameco 2132349, BetLux BLM23B881UHR-11 o Sure LE-MM103 disponibili dai rivenditori online). Otto resistenze da 1 Kohm. Trentadue ponticelli. Piedini separati, connettori a pettine (come SparkFun PRT-09280) o cavo a nastro (opzionale). In questo progetto non creeremo un display da milioni di LED, ci limiteremo a usarne 64. Disporre questo numero di LED in poco spazio può essere un problema e questo è il motivo per cui i produttori hanno creato delle matrici di LED. Si tratta di singoli blocchetti di materiale plastico che contengono tutti i LED. Data la presenza di ben 64 LED, sarebbero necessari 128 piedini, uno per l’alimentazione e uno per la terra per ciascun LED. Sarebbe problematico doversi preoccupare di 128 piedini e dunque, per ridurre il numero dei piedini della matrice di LED, in genere tutti i LED condividono la connessione a terra (configurazione a catodo comune) o la connessione alla fonte di alimentazione (configurazione ad anodo comune). La matrice utilizzata per questo progetto è a catodo comune.


Figura 6.1 I componenti necessari per il progetto dell’insegna scorrevole.

Potete utilizzare una matrice a LED dotata della stessa piedinatura, ma che impiega una configurazione ad anodo comune (SparkFun COM-00681 o NKC Electronics COM-0018). In questo caso dovrete modificare il codice in modo che operi in senso inverso, dove l’alimentazione viene applicata alle colonne inviando loro il livello HIGH e alle righe connesse a terra inviando loro il livello LOW. L’alimentazione verrà fornita dai pin digitali della scheda Arduino. Le resistenze sono necessarie per limitare la corrente che attraversa i LED e sono state calcolate per fornire un po’ meno corrente rispetto a quella massima consentita. Secondo il datasheet, si tratta di 20 mA. L’impiego di resistenze da 1 Kohm garantisce un sostanziale margine e potreste utilizzare resistenze più piccole, fino a 150 ohm, in caso di necessità. Più basso è il valore della resistenza, più luminosa sarà la matrice, in quanto maggiore sarà la corrente che scorre attraverso i LED. I connettori a pettine e il cavo a nastro sono opzionali. I connettori a pettine sono semplicemente un modo per estendere i connettori della matrice un po’ rispetto al piano della breadboard, facilitando l’inserimento dei fili nei fori. Se poi intendete collocare la matrice a una certa distanza dalla breadboard e dalla scheda Arduino, dovete semplicemente stendere 24 fili dalla scheda Arduino al display. La connessione di 24 fili indipendenti può essere un problema e il cavo a nastro è un modo comodo per eseguire tutte le connessioni. In questo caso dovrete saldare i pin a ciascuno dei fili del cavo a nastro, in modo da poter collegare il tutto alla breadboard e alla scheda Arduino.

Realizzazione del circuito Questo progetto usa una matrice di LED a catodo comune. La Figura 6.2 mostra l’aspetto del display e il modo in cui sono connessi i piedini, ovvero la sua piedinatura. La matrice Sure LE-MM103 è un display bicolore con LED rossi e verdi. Ognuno dei punti frontali della matrice contiene in realtà due LED al proprio interno. Potete scegliere l’uno o l’altro poiché non vi sono sufficienti pin di output su una scheda Arduino UNO per gestire entrambi i colori. Poiché questo progetto usa solo i LED rossi, la Figura 6.2 mostra solo i numeri dei piedini di cui avrete bisogno per utilizzare solo tali LED.


Il display Jameco contiene solo LED rossi e dunque vi troverete meno piedini nella faccia inferiore.

Figura 6.2 Schema e aspetto della matrice di LED. Sono indicati solo i piedini per i LED rossi.

Date un’occhiata alla Figura 6.2. Troverete un gran numero di piedini. Notate che sulla sinistra sono indicati i pin da 2 a 9 della scheda Arduino. Ognuno di questi va connesso agli output digitali di Arduino tramite una resistenza da 1 Kohm. In ognuna delle righe, tutti i catodi dei LED sono connessi allo stesso output digitale. Questo è il motivo per cui questa configurazione è chiamata a catodo comune. Ognuna delle colonne è inoltre connessa ai pin di output digitale di Arduino. La riga superiore (etichette da 10 ad A3) indica a quale pin di Arduino è connessa la colonna. L’indicazione Display Pin Number dice quali piedini sul lato inferiore della matrice sono connessi a ciascun LED (sono indicati solo i piedini per i LED rossi). Il codice accende e spegne i singoli LED inviando corrente alle colonne e fornendo un percorso per connettere a terra le righe. Per esempio, impostando a LOW il pin 2 (output digitale) di Arduino e a HIGH il pin 10 di output digitale si genera un percorso per l’elettricità, che scorrerà attraverso il LED e lo accenderà. Se impostate i pin in modo errato, il LED non si accenderà. Vi sono due LED per ognuna delle 64 posizioni della matrice. In questo progetto, il codice gestisce ogni singolo LED rosso per accenderlo o spegnerlo. Quando cablate delle colonne su una matrice di LED bicolore, connettete i piedini dei LED rossi (per esempio, 23, 20, 17, 14, 2, 5, 8 e 11). Nelle illustrazioni, vedremo come connettere solo i LED rossi. Se preferite, potete connettere i LED verdi (per esempio 24, 21, 18, 15, 1, 4, 7 e 10).

Se volete utilizzare entrambi i colori dei LED, potete impiegare una scheda Arduino MEGA, che offre 54 pin di I/O digitale, ma in questo caso occorrerà modificare in modo appropriato il codice. Fate particolare attenzione alla differenza fra il numero di pin di Arduino, i numeri di riga e colonna della matrice di LED e i numeri di piedini della matrice di LED. Se utilizzate una matrice di LED diversa da quella rappresentata nell’esempio, dovrete identificare i piedini corrispondenti alla riga e alla colonna dei LED e quindi connettere tali piedini (dunque non quelli indicati nello schema) ai pin corretti della scheda Arduino. Osservando la faccia inferiore della matrice, noterete che i piedini sono disposti su due file. Ognuno dei LED è connesso a un piedino per l’anodo e utilizza un unico piedino condiviso per il catodo. Osservando attentamente potete vedere che il piedino 1 si trova all’angolo inferiore destro del display, in corrispondenza di un segno. Se la matrice di LED non riporta indicazioni, controllate il


datasheet per individuare il piedino 1. La Tabella 6.1 mostra il modo in cui i piedini del display Sure LE-MM103 sono connessi ai LED.

Non esiste una piedinatura standard per le matrici di LED. Potreste trovare che sul vostro display, anche se adotta una configurazione a catodo comune, i piedini non corrispondono a quelli indicati in questo progetto, nel qual caso il codice non funzionerà. Fate riferimento al datasheet della matrice di cui siete in possesso per determinare quali piedini devono essere connessi. Se anche non trovate il datasheet, dovreste comunque trovare un PDF sul sito web del fornitore.

Si può trovare il datasheet di un prodotto con una semplice ricerca in Internet, specificando il codice del componente e aggiungendo il termine “datasheet”. A volte il display a matrice non si adatta alla breadboard. In tal caso, utilizzate dei connettori dotati di fori a un’estremità, e dei piedini all’estremità opposta. Basterà inserire i piedini del display nei fori. In alternativa, potete saldare dei piedini a pettine ai piedini della matrice, come illustrato nella Figura 6.3. Se volete separare la matrice dalla breadboard potete saldare un cavo a nastro ai piedini, in modo da poterla tenere a una certa distanza.


Figura 6.3 La matrice di LED dotata di estensioni a pettine saldate.

Se utilizzate il display a matrice dell’esempio, seguite il layout rappresentato nella Figura 6.4. Altrimenti fate riferimento al datasheet del componente per scoprire quali piedini dei LED connettere ai pin della scheda Arduino. Seguite il layout rappresentato nella Figura 6.4 per connettere i pin di Arduino alle resistenze e alla matrice di LED. In questa fase è importante fare estrema attenzione ai dettagli e controllare bene tutte le connessioni! È improbabile che possiate danneggiare qualcosa utilizzando un cablaggio errato, ma la matrice di LED non si accenderà correttamente.

Figura 6.4 L’aspetto della breadboard e dei componenti per la realizzazione del progetto.

Il funzionamento del codice


La matrice è ora cablata e pronta per funzionare, ma cosa intendete visualizzare? Ogni LED è, sostanzialmente, un pixel di un piccolo display. Con i pixel della matrice potete creare disegni statici o icone. Ma potete anche creare animazioni, costituite in pratica da immagini statiche visualizzate in rapida successione. Vi sono due modi per visualizzare qualcosa su una matrice: tramite un algoritmo o tramite una bitmap. Nel primo caso occorre calcolare matematicamente quali LED accendere. Questo è l’approccio utilizzato per funzionalità come gli indicatori di picco dei livelli audio o il rimbalzo di una palla. Se avete realizzato il progetto presentato nel Capitolo 4, sostanzialmente avete usato un semplice algoritmo per determinare quale LED accendere. Si possono applicare gli stessi principi anche a una matrice di LED. Il secondo modo per visualizzare qualcosa consiste nel memorizzare una mappa di tutti i LED, la quale specifica quali accendere e quali no. Poiché ciascun LED può essere solo acceso o spento, la sua condizione può essere memorizzata come un bit: 1 o 0; da qui il termine bitmap, che sicuramente avete già sentito nominare. Per visualizzare un oggetto, basta caricare la sua bitmap in memoria e poi inviarla alla matrice di LED, che potete considerare come una sorta di piccolo monitor. Predisponendo cicli che usano le immagini bitmap conservate in memoria, potete creare animazioni e questo è ciò che farete per creare l’insegna scorrevole, utilizzando bitmap delle lettere dell’alfabeto. Ma innanzitutto occorre scrivere il codice per creare la bitmap e visualizzarla sulla matrice.

Gli sprite In gergo informatico, gli sprite sono piccole immagini bitmap che conservano disegni predefiniti, i quali possono essere integrati in una scena di maggiori dimensioni. Anche se non è esattamente quello che faremo con la matrice di LED, in genere si tende a chiamare con il nome di sprite tutte le piccole immagini bitmap. Per visualizzare qualcosa di interessante sulla matrice di LED, probabilmente avrete in mente qualche carattere o un’icona. Memorizzerete queste bitmap come un array di valori: un 1 accende un LED e uno 0 lo spegne. La Figura 6.5 mostra uno sprite visualizzato sulla matrice di LED. Inserite il codice seguente per creare lo sprite. Questo esempio crea una piccola faccia sorridente: /* * Chapter 6: Making a Scrolling Sign (a Sprite) * Adapted from Oomlout.com http://www.tinyurl.com/yhwxv6h * Displays a smiley face */ // Arduino Pin Definitions int rowPin[] = {2,3,4,5,6,7,8,9}; //An Array defining which Arduino pin each row is attached to


Figura 6.5 Visualizzazione di uno sprite sulla matrice di LED..

//(The rows are common anode (driven HIGH)) int colPin[] = {17,16,15,14,13,12,11,10}; //An Array defining which pin each column is attached to //(The columns are common cathode (driven LOW)) byte smile[] = { B00111100, B01000010, B10100101, B10000001, B10100101, B10011001, B01000010, B00111100};

//The array used to hold a bitmap of the display

void setup() { for(int i = 0; i <8; i++){ //Set the Arduino pins to be OUTPUTs pinMode(rowPin[i], OUTPUT); //These refer to the Arduino pins in the arrays pinMode(colPin[i], OUTPUT); } } void loop() { displaySprite(); }

// display the Sprite

void displaySprite(){ for(int count = 0; count < 8; count ++){ //A utility counter for(int i = 0; i < 8; i++){ digitalWrite(rowPin[i], LOW); //Turn off all row pins } for(int i = 0; i < 8; i++){ //Activate only the Arduino pin of the column to light up if(i == count){ digitalWrite(colPin[i], LOW); } else{ digitalWrite(colPin[i], HIGH); //Turns all the other rows off } } for(int row = 0; row < 8; row++){ //Iterate through each pixel in the current column int bit = (smile[count] >> row) & 1; //Use a bit shift in the smile[] array to do a bitwise comparison //And assign the result of the comparison to the bit if(bit == 1){ //If the bitwise comparison is 1, digitalWrite(rowPin[row], HIGH); //Then light up the LED } } } }

Per accendere un LED è necessario fornirgli corrente e prevedere una connessione a terra per garantire alla corrente la possibilità di attraversarlo. Pertanto dovete specificare quali righe e quali


colonne verranno utilizzate da ciascun LED e selezionare la riga e la colonna appropriate nel codice. I pin utilizzati per le righe e le colonne sono definiti tramite due array di interi proprio all’inizio del codice: int rowPin[] = { 2, 3, 4, 5, 6, 7, 8, 9}; int colPin[] = {17,16,15,14,13,12,11,10};

La scheda Arduino UNO non offre i pin digitali da 14 a 17. Per ottenere i quattro pin aggiuntivi di cui avete bisogno, potete utilizzare come output digitali i pin analogici da 0 a 3. I due elementi chiave di questo codice sono i dati, memorizzati sotto forma di bitmap, e la funzione che li visualizza. È inoltre importante specificare quali pin verranno utilizzati per fornire tensione ai LED e quali pin verranno utilizzati per fornire una connessione a terra. Sul display, le righe sono connesse all’anodo dei LED e dunque basta fornire loro un’alimentazione portandole al livello HIGH e le colonne sono connesse a terra portandole al livello LOW. Le sequenze numeriche sono in ordine inverso a causa del modo in cui vengono indirizzate nella funzione displaysprite(). Ora inizia la parte più interessante. La bitmap è semplicemente un array di dati che codificano un valore pari a 1 o a 0 per ogni LED. Poiché ogni valore è un bit, e vi sono 8 bit in 1 byte, è possibile codificare l’intera faccia sorridente in 8 byte. In totale fanno 64 bit, uno per ogni pixel (che corrisponde a un singolo LED). Nel listato seguente i simboli 1 sono evidenziati, per facilitare l’individuazione della faccia sorridente: byte smile[] = { B00111100, B01000010, B10100101, B10000001, B10100101, B10011001, B01000010, B00111100};

Questo codice crea un array di elementi di tipo byte, il cui nome è smile. I valori per ognuno degli 8 byte di questo array di byte sono conservati fra parentesi graffe. La lettera maiuscola “B” indica che questi dati devono essere memorizzati in formato binario. Il fatto di disporre ciascun byte su una riga distinta ne semplifica l’interpretazione. Anche la forma seguente funzionerebbe, ma sarebbe più difficile da interpretare: byte smile[] = {B00111100, B01000010, B10100101, B10000001, B10100101, B10011001, B01000010, B00111100};

Dopo aver definito tutte le variabili, la funzione setup() usa gli array di interi appena creati per configurare tutti i pin dei LED per l’output utilizzando un semplice ciclo for. Ora occorre particolare attenzione! La visualizzazione del sorriso viene ottenuta tramite la funzione displaySprite() che è l’unica operazione svolta nel loop() principale del programma. È opportuno organizzare il codice in questo modo, scrivendo una nuova funzione per visualizzare lo sprite, poiché successivamente potreste volerle aggiungere altre funzioni. Osservando attentamente il codice, potete vedere che viene acceso un solo LED per volta (questo è il modo in cui possiamo cavarcela con solo 8 resistenze). Operate sempre su un solo LED per volta, ma le cose si verificano così velocemente che i LED sembrano costantemente accesi. Per svolgere questa accensione rapida, la funzione displaySprite() è costituita da quattro cicli che controllano quali pin spegnere e quali pin accendere, nel seguente modo. 1. Il primo ciclo opera sul contatore count, che registra il punto in cui ci si trova tra 0 e 7. Questo contatore di servizio indica in quale byte dell’array smile[] ci si trova.


La numerazione degli array parte sempre da 0 e dunque i numeri da 0 a 7 eseguono otto iterazioni del ciclo. 2. Il secondo ciclo si occupa dei pin delle singole righe e li imposta a LOW. Ciò interrompe l’alimentazione per tutti gli otto LED di ciascuna riga. Poiché l’alimentazione di tutti i pin viene interrotta, tutto ciò che poteva essere precedentemente acceso verrà spento e questo è importante per ogni genere di animazione che si svolgerà in seguito. 3. Ora il ciclo successivo porta a LOW gli anodi dei LED della colonna su cui si sta lavorando. Tuttavia tutte le altre colonne verranno impostate a HIGH: in pratica nessuna corrente potrà scorrere fra di essi. Ciò isola la riga corrente, in modo che sia l’unica che può effettivamente essere attiva. 4. L’ultimo ciclo accende il LED in questione. Iniziando con il primo LED della colonna corrente, alla riga 0, occorre confrontarlo con i dati del bitmap (smile[count]). Se i dati in questa posizione contengono un 1, occorre impostare la riga corrente a HIGH. La parte più ostica di tutte è l’ultimo ciclo, dove l’array smile[] viene utilizzato per determinare se accendere il LED corrente. Ciò viene svolto con due operazioni, uno scorrimento di bit e un confronto bit-a-bit. Ecco come fare: int bit = (smile[count] >> row) & 1;

Viene creata una variabile temporanea intera per memorizzare il risultato di queste operazioni. Il simbolo >> esegue un’operazione di scorrimento di bit, che seleziona quali degli 8 bit del byte corrente devono essere confrontati, partendo dal bit 0 (riga 0) e continuando fino alla riga 7. Il byte viene fatto scorrere a destra del numero di bit che corrispondono alla riga corrente.

Un confronto bit-a-bit è semplicemente un modo per confrontare valori 1 e 0. In questo confronto, occorre semplicemente confrontare se il bit è uguale a 1 e, in questo caso, accendere un LED. Ciò viene svolto con un confronto AND bit-a-bit utilizzando il simbolo di e commerciale (&). Se il bit dei dati è 1, corrisponderà con il bit di test a 1, con un risultato finale pari a 1. Si possono eseguire quattro confronti bit-a-bit: AND, OR, NOT e XOR (OR esclusivo). L’utilizzo dell’AND bit-a-bit garantisce che venga restituito un valore 1 solo quando anche il bit di dati del bitmap è uguale a 1. Per esempio, immaginate di esaminare il primo byte di dati (che, ricordatelo, parte da 0), smile[0]. Questo primo byte della faccia sorridente è B00111100, che corrisponde alla prima riga del display. Il primo bit è 0. Questo viene confrontato con il valore 1 utilizzando un confronto bit-a-bit. Se il primo bit memorizzato nel bitmap fosse stato 1, il test sarebbe stato vero e il LED si sarebbe acceso. Ma poiché è 0, il test sarà falso e il LED non si accenderà. Nell’iterazione successiva, il byte viene fatto scorrere a destra di un bit, in modo che possa essere esaminato il valore successivo. Anche questo è 0. Lo scorrimento di bit continua per ognuno degli 8 bit che compongono il byte e ogni volta viene eseguito un confronto bit-a-bit, in modo che il LED corrispondente venga acceso, se necessario. L’operazione viene svolta nel modo seguente: if(bit == 1){ //If the bitwise comparison is 1, digitalWrite(rowPin[row], HIGH); //Then light up the LED }

Ricordate che il confronto richiede un doppio segno di uguaglianza. Se il confronto è vero, true, il pin Arduino della riga corrente può essere impostato su HIGH. Poiché la colonna è stata già impostata a LOW in precedenza, il LED selezionato si accenderà. Ricordate che si deve accendere un solo LED per volta. Il LED si spegnerà nel corso della successiva iterazione.


Animazione degli sprite Ora che abbiamo visualizzato una singola immagine, possiamo provare a scambiarla con un’altra. Possiamo aggiungere un’altra bitmap ai dati e modificare la funzione displaySprite in modo che passi dall’una all’altra. Aggiungete il codice seguente dopo l’array smile[] e prima del ciclo setup(): byte frown[] = { B00111100, B01000010, B10100101, B10000001, B10011001, B10111101, B01000010, B00111100};

Ciò crea un secondo array di byte per memorizzare un’altra faccina. A questo punto, potete aggiungere il codice che determina quale bitmap visualizzare e per quanto tempo: void loop() { displaySprite(smile, 1000); // display the Smile for 1 second displaySprite(frown, 1000); // display the Frown for 1 second }

Ora la funzione loop deve gestire due richieste a displaySprite() impiegando due parametri: il byte da visualizzare e la durata della visualizzazione. La funzione viene pertanto modificata per accettare questi parametri: void displaySprite(byte * data, unsigned long duration){ unsigned long start = millis(); while (start+duration>millis()){ … } }

Assicuratevi inoltre di cambiare il nome dell’array utilizzato per la bitmap: int bit = (data[count] >> row) & 1;

Dopo aver inserito il codice, provatelo e osservate l’espressione cambiare. Ora avete tutte le basi per creare un’insegna scorrevole.

Ricordatevi di aggiungere la parentesi graffa chiusa per il ciclo while alla fine di questa funzione o la funzione non verrà accettata e il compilatore se ne lamenterà. La funzione displaySprite() ora accetta due parametri. Il primo è il byte di dati da visualizzare, che corrisponde al byte nell’array di dati contenente la bitmap. Il secondo parametro è la durata di visualizzazione: void displaySprite(byte * data, unsigned long duration){

L’asterisco è un puntatore, un operatore di deindirizzamento del linguaggio di programmazione C, il linguaggio nativo del microprocessore ATmega328. Non rientra negli scopi di questo libro spiegare approfonditamente il funzionamento dei puntatori e, in ogni caso, si tratta di uno degli argomenti di


programmazione più complessi. Quello che è importante capire, qui, è che questo parametro consente di specificare con facilità la bitmap corrente per la funzione displaySprite(). Un unsigned long è un valore intero che non può essere negativo, ma è una variabile di grandi dimensioni, per la memorizzazione di numeri molto grossi. Viene comunemente utilizzato per memorizzare il tempo espresso in ms. La durata di visualizzazione di uno sprite viene gestita dalle due righe successive di codice. La prima accetta un’indicazione oraria (timestamp) in millisecondi dell’ora attuale del sistema e la salva in una variabile chiamata start: unsigned long start = millis();

Poi, un ciclo while controlla per quanto tempo eseguire la funzione displaySprite(), somma i valori start e duration e confronta il risultato con l’ora corrente. Se l’ora corrente ha raggiunto un valore superiore, la funzione si ferma e il programma torna al ciclo principale. Per esempio, se la durata specificata era di 80 ms e il tempo iniziale, start, era 2000, il ciclo while continuerà a ripetersi finché l’ora di sistema non supererà i 2080 ms.

Visualizzazione di testo a scorrimento Dopo aver realizzato tutti gli elementi chiave, non rimane che mettere insieme le cose, definire le bitmap per i caratteri e aggiungere la funzionalità di scorrimento. Potete considerare il testo a scorrimento come una sequenza di frame di un’animazione. Tutti i 64 LED di ciascuna lettera, indipendentemente dal fatto che siano accesi o spenti, vengono caricati in memoria e poi inviati al frame di animazione corrente. Poi, in memoria, la bitmap del carattere viene spostata di un pixel a sinistra. Contemporaneamente, il carattere successivo viene spostato in memoria e, se necessario, tutti pixel visibili vengono accesi sul display. La struttura viene poi cancellata e sarà pronta per l’iterazione successiva. Può essere visualizzato un solo carattere per volta e mentre le lettere scorrono, vengono mostrate le parti appropriate di due caratteri.

Il codice seguente è molto lungo ed è meglio scaricarlo dal sito web del libro all’indirizzo www.hoeplieditore.it/6323-9 e copiarlo nello sketch di Arduino. Questo sketch si chiama APFD_Chapter6_Text_Scrolling.

Creazione delle variabili Per mostrare il testo a scorrimento sul display, sono necessarie molte più variabili. Dovete memorizzare il messaggio da visualizzare, quale lettera state attualmente visualizzando, quali LED devono essere accesi per creare ogni singolo carattere e così via. Per ottenere tutto ciò, dovete creare parecchie variabili, come indicato nella Tabella 6.2.

Tabella 6.2 Variabili globali necessarie per realizzare il testo a scorrimento. Tipo e nome variabile

Significato

char message[]

Il messaggio da visualizzare.

int index

La lettera corrente da visualizzare.

int offset

Il numero di colonne di LED di cui le lettere devono essere spostate (per lo scorrimento).

const int da _A[] a _Z[]

Le bitmap di tutti i caratteri.

const int letters[]

Le bitmap di tutte le lettere in un array.

const int da A a Z

La posizione di ciascuna lettera nell’array di tutte le lettere.

byte data[]

Le bitmap dei caratteri visualizzati.

powers[]

Le potenze di 2: un modo comodo per determinare quali LED accendere.


Innanzitutto occorrono alcune variabili globali per memorizzare i messaggi e controllare quale lettera viene visualizzata e dove si trova nella matrice nel frame corrente. Poiché le lettere scorrono, spesso verrà visualizzata solo una parte di ogni lettera. Dunque occorre anche una variabile per memorizzare la posizione del carattere nella matrice, il suo offset: char message[] = “HELLO WORLD” int index = 0; int offset = 0; …

Dopo queste variabili, si crea una variabile intera per ciascuna lettera dell’alfabeto da visualizzare: const int A = 0; const int B = 1; const int C = 2; … fino alla lettera Z con qualche segno di punteggiatura

Il numero corrisponde alla posizione di ciascun carattere nell’array letters[], che contiene tutti i caratteri del messaggio che deve essere visualizzato. Ogni carattere è un array dei byte che compongono i caratteri bitmap. Si crea anche un array di byte chiamato data[], che conterrà le bitmap mentre vengono elaborate. Tuttavia, i dati verranno caricati in questo array a seconda delle necessità, in base al messaggio da visualizzare, in modo che l’array venga visualizzato con valori 0: byte data[] = {0,0,0,0,0,0,0,0};

La parte successiva del codice aggiunge tutti i caratteri dell’alfabeto come bitmap, con alcuni simboli in più, come segni di punteggiatura, lo spazio e una scacchiera. La bitmap di ogni carattere viene specificata e memorizzata come un array di interi. Questo è il punto in cui il codice si allunga terribilmente, poiché occorre definire ciascun pixel di ogni singola lettera. Ma qui si può anche essere creativi. Avete sempre desiderato diventare progettisti di font? Questa è la vostra occasione. Potete utilizzare tutti i simboli che desiderate. Il codice seguente mostra le bitmap per le lettere A e B: const int _A[] = {B0001000, B0010100, B0100010, B1000001, B1111111, B1000001, B1000001, B0000000}; const int _B[] = {B1111110, B0100001, B0100001, B0111110, B0100001, B0100001, B1111110, B0000000}; …

Per abbreviare il codice, vengono utilizzate solo le lettere maiuscole (anche se potete comunque aggiungerle, in quanto avete comunque a disposizione altro spazio sulla scheda Arduino). Quando il messaggio è stato memorizzato, tutti i caratteri minuscoli vengono resi maiuscoli e i caratteri sconosciuti vengono prodotti come schemi a scacchiera. L’ultima parte della configurazione consiste nel creare l’array che conterrà tutti i caratteri bitmap, il quale verrà utilizzato per ricercare ognuna delle bitmap quando il messaggio da mostrare verrà memorizzato nella variabile message[]: const int * letters[] = {_A,_B,_C,_D,_E,_F,_G,_H,_I,_J,_K,_L,_M,_N,_O,_P,_Q,_R, _S,_T,_U,_V,_W,_X,_Y,_Z,_COL,_DASH,_BRA2,__, _FULL, _CHECK, _B2, _TEMP, _LINE, _SMILE, _DOT, _COLDOT};

Infine, viene utilizzata una variabile di servizio per contenere le potenze di 2. Questa variabile verrà utilizzata per lo scorrimento di bit, quando lo sprite del frame corrente verrà caricato nell’array data[].


const int powers[] = {1,2,4,8,16,32,64,128};

Caricamento e visualizzazione delle lettere Il ciclo principale svolge solo due attività. Carica il frame corrente con uno sprite e poi visualizza tale frame. Per caricare lo sprite si utilizza la funzione loadSprite(): void loadSprite(){ int currentChar = getChar(message[index]); int nextChar = getChar(message[index+1]); for(int row=0; row < 8; row++){ //iterate through each row data[row] = 0; //reset the row we’re working on for(int column=0; column < 8; column++){ //iterate through each column data[row] = data[row] + ((powers[column] & (letters[currentChar][row] << offset))); //loads the current character (offset) data[row] = data[row] + (powers[column] & (letters[nextChar][row] >> (8-offset) )); //loads the next character (offset) } } offset++; //increment the offset by one row if(offset==8){offset = 0; index++; if(index==sizeof(message)-2) {index=0;}} //if offset is 8 load the next character pair for the next time through }

La funzione loadSprite mette i pixel appropriati sul display nel frame corrente, lavorando solo con due caratteri per volta. L’intero messaggio viene memorizzato nell’array message[] e pertanto l’indice può essere utilizzato per ricercare il carattere corrente e quello successivo del messaggio (index+1). Quando vengono caricati questi due caratteri, vengono gestiti allo stesso modo delle facce impiegate in precedenza. I cicli for delle righe e delle colonne eseguono un’iterazione attraverso tutti i pixel e li caricano nell’array data[] per la riga corrente. L’elemento chiave di questo codice è l’operazione di scorrimento di bit, eseguita utilizzando <<, che seleziona il pixel appropriato da visualizzare ricercando la potenza di 2 della colonna da visualizzare, traendolo dalla bitmap del carattere. L’array powers[] fornisce sempre semplicemente un modo comodo per impostare la posizione successiva dei byte da cui partire per accendere i LED: data[row] = data[row] + ((powers[column] & (letters[currentChar][row] << offset)))

Infine, l’offset (lo scostamento) dei caratteri viene incrementato e se ci siamo scostati di 8 pixel, è tempo di ripartire da 0, in quanto è il momento di caricare il carattere successivo. Dopo aver caricato il frame corrente dello sprite, è ora di visualizzarlo. Si utilizza la stessa funzione displaySprite() impiegata in precedenza. L’unico cambiamento necessario riguarda l’uso dell’array data[], invece dell’array smiley[]: int bit = (data[column] >> row) & 1;

Potete impostare la velocità di scorrimento del testo tramite la funzione displaySprite, modificando il parametro duration di displaySprite(), così come avete fatto per i sorrisi. Eseguendo il codice, dovreste vedere i caratteri che avete memorizzato nell’array message[]. Nell’esempio che segue e che potete scaricare dal sito web del libro (www.hoeplieditore.it/6323-9), il codice dice HELLO WORLD!. La Figura 6.6 mostra l’aspetto della lettera A.


Figura 6.6 Visualizzazione del testo a scorrimento.

Come funziona l’hardware Dal punto di vista elettronico, il progetto è molto semplice. Le resistenze sono calcolate in base alla massima corrente che può attraversare ciascun LED. Per il display Sure LE-MM103, la massima corrente che può passare attraverso un LED è di 20 mA. Poiché è acceso un solo LED, si possono utilizzare resistenze piuttosto basse, da circa 180 ohm per dare una tensione di passaggio di 1,8 V. Tuttavia, un po’ per sicurezza e un po’ perché si tende ad averne parecchie in giro, si possono utilizzare resistenze da 1 Kohm. La luminosità non risulterà troppo attenuata sul display. Controllate sul datasheet quali resistenze utilizzare per la vostra matrice.

Problemi e soluzioni È molto importante controllare le connessioni, è il caso di ripeterlo. Se una delle righe o delle colonne non si accende o se sulla matrice compaiono righe strane, probabilmente le connessioni sono errate. Ricontrollatele. Anche un esperto può essere ingannato da un collegamento incrociato e dedicare molto tempo a capire quale possa essere il problema. Se non riuscite a risolvere il problema, potete staccare tutto e ricominciare da capo. Più volte è capitato di doverlo fare per risolvere un problema intricato. D’altra parte, può capitare che anche un singolo LED non si accenda o che una riga sia notevolmente più scura o più chiara delle altre. Se avete controllato tutte le connessioni e non riuscite a identificare il problema, potreste avere una connessione errata nell’unità o, più probabilmente, un LED bruciato. Non capita molto spesso, ma talvolta si acquista un oggetto già guasto in fase di produzione. In questo caso, l’unico modo per correggere il problema consiste nel farsi sostituire il pezzo.

Spazio alla creatività Ora che il display funziona, potete sperimentare nuove idee. Giocate con la direzione dello scorrimento, modificando la variabile indice o la sequenza con cui i pin di Arduino vengono utilizzati nell’array colPins[]. Se avete un display bicolore, provate a cablare insieme entrambi i LED per miscelare il colore rosso e il colore verde, ottenendo un giallo. Avrete bisogno di alcuni jumper in più per connettere le altre colonne di LED. Potete anche sperimentare con i registri a scorrimento per accendere la matrice. Un registro a scorrimento è un circuito integrato che può essere utilizzato per ridurre il numero di pin Arduino necessari per controllare i LED. Con un MAX7221 potete ridurre il tutto a tre soli pin.


Capitolo 7

Un orologio sveglia In questo capitolo Uso di un modulo RTC Uso di un display 16 × 2 Programmazione dell’orologio Aggiunta di un commutatore per la sveglia e di un altoparlante piezoelettrico

C

i sembra di non aver mai abbastanza tempo. Anche se Arduino non è in grado di farcene risparmiare, ci può consentire di creare almeno un progetto che tiene l’ora e che consente di impostare una sveglia esattamente del tono e della durata che desideriamo.

La scheda Arduino rappresenta il cuore di questo progetto, ma qui il suo braccio destro è il modulo RTC (Real Time Clock). Dopo esservi fatti un’idea di come funziona un RTC, potrete aggiungere l’ora e la gestione del tempo ad altri progetti in cui è utile, per esempio per contrassegnare con un’indicazione oraria (timestamp) i dati raccolti. Dopo aver terminato con questo progetto, avrete fra le mani un orologio piuttosto preciso. Programmeremo una sveglia e un messaggio da visualizzare e scopriremo come utilizzare un modulo RTC, come visualizzare del testo su un display a cristalli liquidi 16 × 2 e come accettare un input dall’utente tramite pulsanti e commutatori. Questo progetto verrà realizzato in più fasi. Si aggiunge un po’ di hardware, poi si scrive del codice per verificare che l’hardware funzioni, quindi si aggiunge ulteriore hardware e così via fino a completare l’orologio. In tal modo risulterà più facile individuare i problemi nel corso del lavoro. Connettendo tutto subito si correrebbe il rischio di scoprire solo troppo tardi di avere problemi nel funzionamento dell’intero orologio.

Potete scaricare gli schemi elettrici e i diagrammi di collocazione dei componenti a colori dal sito web del libro (www.hoeplieditore.it/6323-9).

Tutta una questione di tempo! Per registrare in modo accurato il trascorrere del tempo in un progetto Arduino, occorre dotarsi di un orologio in tempo reale (RTC = Real Time Clock). La scheda Arduino stessa è in grado di registrare il tempo con una discreta precisione, utilizzando la funzione millis(), ma solo dall’ultimo momento in cui l’apparecchio è stato alimentato. Nel momento in cui si disconnette l’alimentazione alla scheda Arduino, la funzione millis() viene riportata a 0: una situazione non molto comoda quando si desidera registrare l’ora in modo preciso. Quello che occorre è un modulo aggiuntivo per registrare il tempo, che consumi meno energia possibile. Quello che ci vuole è un orologio in tempo reale. Il progetto realizza qualcosa di simile a un orologio da polso. Per l’alimentazione si usa una piccola batteria a bottone, in modo che il modulo possa funzionare anche quando viene tolta l’alimentazione alla scheda Arduino. Poiché è molto efficiente, la piccola batteria del RTC durerà parecchi anni. Sebbene il RTC sia un perfetto orologio, occorre Arduino per gestire il display che visualizza l’ora e per rispondere agli input e agli output mentre si cambiano le impostazioni. Le funzionalità principali dell’orologio sono le seguenti:


registrare l’ora; visualizzare l’ora; memorizzare una sveglia e poi suonarla.

Questo progetto utilizza parecchi cablaggi e dunque è importante controllare bene tutti i progressi nel corso dello sviluppo. Metteremo insieme il progetto in quattro fasi. 1. Assemblaggio del modulo RTC e impostazione dell’ora corrente. 2. Aggiunta del display a cristalli liquidi e verifica del funzionamento. 3. Aggiunta dei pulsanti e di un commutatore per la programmazione della sveglia. 4. Aggiunta del modulo per il suono della sveglia. Innanzitutto occorre però procurarsi tutti i componenti.

I componenti La Figura 7.1 mostra i componenti necessari per questo progetto, che verrà realizzato su una breadboard, anche se potreste volerlo trasferire in un contenitore adatto una volta che sarà finito. In questo caso, assicuratevi che tale contenitore possa ospitare la breadboard oppure pensate di trasferire il circuito su una stripboard, una volta completato. Ecco i componenti di cui avete bisogno. Una scheda Arduino. Una breadboard intera oppure due mezze breadboard, che possano essere connesse tra loro. Una scheda breakout Adafruit Industries Real Time Clock DS1307. Un display a cristalli liquidi 16 × 2 HD44780 standard parallelo (per esempio Adafruit ID: 181 o Jameco 2118598). Un potenziometro da 10 Kohm per controllare il contrasto (incluso con i display di Adafruit e Oomlout). Due pulsanti momentanei (ampiamente disponibili, per esempio Jameco 2076148). Un interruttore a cursore SPDT (Single-Pole Dual Throw) o DPDT (Double-Pole DoubleTthrow) con posizioni ON-NONE-ON (per esempio Jameco 1915801, Farnell 1813681 o 1437711). Un altoparlante piezoelettrico (per esempio Jameco 1956776 o Maplin N16CL). 4 resistenze da 220 ohm. Un contenitore adatto per il progetto. Sul mercato sono disponibili molti moduli RTC in una grande varietà di dimensioni fisiche. In termini di facilità d’uso, uno dei migliori è il modulo RTC DS1307 Breakout Board prodotto da Adafruit Industries. La Figura 7.2 mostra la foto ingrandita dei suoi componenti. Si basa sul circuito integrato Dallas Semiconductor DS1307, molto economico e robusto. Si tratta di una soluzione decisamente economica e pertanto può accumulare un certo ritardo o anticipo nel corso di un periodo piuttosto esteso. Sono disponibili prodotti più precisi, ma anche più costosi. Potete anche fare a meno di procurarvi il kit, acquistare i vari componenti necessari per utilizzare il DS1307 e poi costruirvelo da soli, ma il kit contiene tutti i componenti e un piccolo circuito stampato, molto comodo per connettere il tutto correttamente.


Figura 7.1 I componenti necessari per questo progetto.

Figura 7.2 I componenti del kit RTC DS1307 Breakout Board di Adafruit Industries.


Una breakout board è un qualsiasi circuito stampato che faciliti l’accesso fisico a tutti i piedini di un circuito integrato o un altro dispositivo per la creazione di prototipi e la costruzione e il collaudo di un progetto. In un certo senso, anche la scheda Arduino è una breakout board per il circuito integrato microcontroller ATmega328. Il modulo RTC Breakout Board di Adafruit Industries viene fornito sotto forma di kit con tutti i componenti necessari e dunque dovrete ricorrere a qualche saldatura per sfruttarne i vantaggi. Ma vale veramente la pena di fare queste poche saldature! Il kit è molto economico e disponibile ovunque, offre eccellenti istruzioni di assemblaggio online e una ricca documentazione. Di più: include perfino la batteria! La cosa migliore di un RTC con una batteria di supporto è che non vi troverete mai con l’indicazione 12:00 quando l’alimentazione se ne va. Il kit RTC breakout board rappresenta il cuore dell’orologio, ma dovete anche essere in grado di visualizzare l’orario. Esistono decine di modi per farlo, ma il più semplice consiste nell’utilizzare un display a cristalli liquidi 16 × 2. Si tratta di un componente molto economico e facile da controllare. Inoltre esistono librerie di codice Arduino per controllare i display a cristalli liquidi, che semplificano enormemente l’aggiornamento del testo sul display. Un altro vantaggio legato all’uso di un display a cristalli liquidi 16 × 2 è il fatto che è possibile aggiungere del testo sul display, per rendere l’orologio un po’ più “parlante” e interessante rispetto al solito display a sette segmenti presente sulla maggior parte degli orologi.

Il termine “16 × 2” fa riferimento al numero di caratteri visualizzabili sul display. Questo genere di display a cristalli liquidi è in grado di visualizzare due righe di testo, ognuna delle quali è composta da sedici caratteri. Sono necessari due commutatori. I pulsanti momentanei per incrementare le ore e i minuti della sveglia. I componenti elencati sono adatti per l’inserimento in breadboard, ma potreste volervi procurare altri tipi di pulsanti se pensate di collocare l’orologio in un contenitore differente.

Il commutatore a cursore deve poter assumere tre stati: modalità di visualizzazione dell’ora, modalità di impostazione della sveglia e modalità di sveglia attiva. Questo significa che il commutatore deve avere tre posizioni e dunque assicuratevi che sia di tipo ON-NONE-ON e non semplicemente a due posizioni, ON-ON. Per la sveglia, avete bisogno di un altoparlante piezoelettrico. Vengono forniti con o senza guscio plastico. Dovreste procurarvene uno già racchiuso nel guscio, progettato per amplificare il suono dell’elemento piezoelettrico. Se il vostro non ne è dotato, potete poggiarlo su una superficie rigida (come la parete interna del contenitore) ma è meglio assicurarsi che l’allarme sia chiaramente udibile.

Assemblaggio del modulo RTC L’assemblaggio del modulo RTC è piuttosto semplice, se avete un po’ di dimestichezza con la saldatura. In caso contrario, questa è una buona opportunità per fare pratica. Dopo aver assemblato il kit, potrete aggiungergli la batteria e connetterlo alla scheda Arduino. Poi imposterete l’ora con


uno sketch Arduino realizzato esattamente per questo scopo. Il kit RTC è costituito da nove componenti. Circuito stampato del Real–time clock. Chip Dallas Semiconductor Real Time Clock (DS1307). Quarzo da 32,768 KHz. Due resistenze (2,2 Kohm). Condensatore (100 nF). Connettore a pettine (maschio, a 5 pin). Batteria (CR1220). Portabatteria. Il modulo RTC offre un’eccellente documentazione per l’assemblaggio, ricca di fotografie disponibili online e potete approntarlo molto rapidamente. Il circuito stampato del kit riporta la posizione di tutti i componenti e di come devono essere collocati. Fate riferimento alla Figura 7.2 e saldate il tutto nell’ordine seguente. 1. Saldate un po’ di stagno sulla base del portabatterie, in modo che vi sia un buon contatto fra la batteria a bottone e i fori sul circuito stampato. 2. Saldate le resistenze R1 e R2. L’orientamento dei piedini non è importante. 3. Aggiungete il condensatore (C1) e il quarzo (Q1). Anche in questo caso, l’orientamento dei piedini non è importante. 4. Aggiungete il circuito integrato DS1307.

Assicuratevi che l’incavo sul circuito integrato punti verso il basso e che corrisponda alle indicazioni serigrafate sul circuito stampato. Se doveste saldarlo al contrario, non funzionerà affatto e sarebbe un bel problema dissaldarlo! 5. Saldate in posizione i contatti cromati del portabatterie. 6. Inserite il connettore a pettine nella breadboard e collocatevi sopra il modulo RTC, per facilitare l’operazione di saldatura. I piedini devono essere inseriti dalla faccia inferiore del circuito stampato, in modo che le estremità più corte fuoriescano appena dal lato superiore del circuito stampato. Ora che avete completato le operazioni di saldatura, potete inserire la batteria, con il polo positivo rivolto verso l’alto. Assicuratevi di collocare la batteria nel RTC o non funzionerà correttamente e non potrete programmarlo. Dopo aver inserito la batteria, è tempo di collegare il modulo RTC alla scheda Arduino, per poter impostare l’ora. Fate riferimento alla Figura 7.3 per eseguire le seguenti connessioni. 1. Create una linea di terra e una linea di alimentazione sulla breadboard, collegando i pin 5V e GND alle lunghe colonne di fori che si trovano ai lati della breadboard. 2. Connettete il pin di terra (GND) dell’RTC alla linea di terra della breadboard. 3. Connettete il pin 5 dell’RTC alla linea +5V della breadboard. 4. Connettete il pin SDA al pin analogico 4 della scheda Arduino. 5. Connettete il pin SCL al pin analogico 5 della scheda Arduino. L’ultimo pin si chiama SQW e può essere utilizzato per ottenere un’onda quadra dal chip RTC. Non ne abbiamo bisogno in questo progetto e dunque possiamo ignorarlo.


Ora che il modulo è connesso, è il momento di programmarlo con l’ora corretta. Possiamo farlo con la libreria Arduino RTClib, fornita da Adafruit Industries per il kit. Potete scaricare la libreria dalla scheda Downloads del sito web di questo libro (www.hoeplieditore.it/6323-9) o direttamente dal sito web di Adafruit Industries.

Figura 7.3 Cablaggio del modulo RTC.

Le librerie Arduino contengono codice che offre specifiche procedure. Per informazioni sull’installazione e l’uso di una libreria, consultate il Capitolo 3. Dopo aver installato la libreria per l’RTC, troverete che nel menu Examples si trova il nuovo elemento RTClib. Caricate quello chiamato Examples RTClib ds1307. Questo sketch imposta l’ora sul modulo RTC. La parte più importante di questo codice è in setup(): RTC.adjust(DateTime(__DATE__, __TIME__));

In questa riga, la funzione RTC.adjust() richiede al computer l’ora di sistema nell’istante in cui il programma viene compilato, appena prima del caricamento sulla scheda Arduino. Tale ora viene utilizzata per impostare l’ora sul modulo RTC. Se desiderate cambiare l’ora del modulo RTC (per esempio nel momento del passaggio dall’ora solare all’ora legale e viceversa) o se lo scarto di misurazione del modulo RTC diviene eccessivo), dovete rimuovere la batteria per tre secondi, ricollocarla e poi ripetere l’esecuzione di questo sketch. Se non l’avete già fatto, caricate questo codice sulla scheda Arduino e fate clic sul pulsante Serial Monitor nell’ambiente di sviluppo. L’output dovrebbe essere simile a quello rappresentato nella Figura 7.4. Assicuratevi che il Monitor seriale sia impostato a 57.600 baud nell’angolo inferiore destro, altrimenti otterrete risultati incomprensibili.


Figura 7.4 Programmazione dell’ora sul modulo RTC e controllo con il Monitor seriale.

Potete anche impostare in modo arbitrario l’ora sul modulo RTC. L’operazione è un po’ più complessa, poiché l’ora è impostata come tempo di sistema Unix, che è semplicemente il numero di secondi trascorsi dal giorno 1 gennaio 1970. Per esempio, il codice seguente imposta l’ora alle 15:00 del 11 giugno 2014: RTC.adjust(DateTime(1402491668));

Un sito molto interessante che parla di ora Unix è il seguente: www.onlineconversion.com/unix_time.htm.

Dopo aver impostato il modulo RTC con l’ora di sistema, siete pronti per collegare il display e accenderlo.

Aggiunta e collaudo del display a cristalli liquidi Ora che avete programmato e collaudato il cuore dell’orologio Arduino, avete bisogno di un modo per visualizzare l’ora senza ricorrere al Monitor seriale. Qui entra in gioco il display a cristalli liquidi. Quello che impiegheremo è piuttosto economico e utilizza il comunissimo driver HD44780. Questi moduli a cristalli liquidi vengono riconosciuti con facilità, poiché hanno 16 piedini su un’unica fila e utilizzano un’interfaccia parallela. Per questo motivo, Arduino usa parecchi pin digitali per far funzionare questo display. L’operazione è piuttosto complicata, ma, fortunatamente, esiste una libreria che semplifica molto l’invio di testo sul display senza doversi preoccupare troppo dei comandi a basso livello che sarebbero altrimenti necessari. Si utilizza la modalità a 4 bit per visualizzare il testo, la quale richiede solo 7 pin digitali di Arduino per controllare l’intero display. Avrete anche bisogno di alimentazione per il display e per la retroilluminazione. Infine, potete controllare il contrasto del display utilizzando il potenziometro. Connettete i componenti nel seguente modo. 1. Aggiungete il display a cristalli liquidi e il potenziometro alla breadboard, più o meno nelle posizioni indicate nella Figura 7.5. 2. Connettete i piedini di alimentazione e di terra del display, che sono, rispettivamente, il 15 e il 16.


3. Connettete la terra dell’alimentazione per la retroilluminazione del display, corrispondenti, rispettivamente, ai piedini 1 e 2. 4. Connettete i piedini di controllo per il display a cristalli liquidi ai pin digitali della scheda Arduino, in base alla seguente tabella. Piedino sul display LCD 16 x 2

Pin digitale di Arduino

1 (alla linea GND della breadboard)

2 (alla linea +5V della breadboard)

3

2

4

3

5

4

6

5

7 (nessuna connessione)

8 (nessuna connessione)

9 (nessuna connessione)

10 (nessuna connessione)

11

11

12 (alla linea GND della breadboard)

13

12

14 (al piedino centrale del potenziometro)

15 (alla linea +5V della breadboard)

16 (alla linea GND della breadboard)

5. Ora connettete il potenziometro, che controlla il contrasto del display. Il piedino centrale del potenziometro dovrà essere connesso al piedino 14 del display a cristalli liquidi e gli altri due piedini del potenziometro dovranno essere connessi all’alimentazione e a terra, in qualsiasi ordine. Ora che avete connesso il display a cristalli liquidi, potete fare qualcosa di più interessante! Innanzitutto però dovete caricare del codice per assicurarvi che il display funzioni correttamente. Questo codice rappresenta la prima parte dello sketch per la sveglia. Successivamente lo estenderete per aggiungere tutte le altre funzionalità all’orologio.

Potete anche copiare l’intero codice per l’orologio dal sito web associato al volume (www.hoeplieditore.it/6323-9), ma è preferibile aggiungere il codice parte dopo parte, come descritto in queste pagine. Ciò semplificherà la soluzione dei problemi e consentirà di collaudare l’orologio in più fasi, a mano a mano che lo realizzerete. Inserite il codice seguente nell’IDE di Arduino o scaricatelo dal sito web e caricatelo nella scheda Arduino: // Chapter 7: Arduino Alarm Clock // An alarm clock that uses the Adafruit Industries DS1307 RTC Breakout board // and a 16 × 2 Parallel LCD Display #include <Wire.h> // I2C Wire Library for communicating with the DS1307 RTC #include “RTClib.h” // Date and time functions for the DS1307 RTC connected #include <LiquidCrystal.h> // Display functions for the LCD Display RTC_DS1307 rtc; // Create a realtime clock called rtc LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Create an LCD called lcd void setup () { Wire.begin(); // Enables the communication for the LCD rtc.begin(); // Enables the RTC lcd.begin(16, 2); // Enables the LCD lcd.print(“ It’s Alive!”); // Print a message, centered, to the LCD // to confirm it’s working delay(500); // Wait a moment so we can read it lcd.clear(); // Clear the LCD } void loop(){ }


Dopo aver caricato il codice, sul display dovrebbe comparire il messaggio “It’s Alive!”, che verrà visualizzato per circa mezzo secondo. Se non vedete nulla o se il display mostra informazioni senza senso, significa che qualcosa è collegato in modo errato. Tornate alla tabella dei cablaggi (mostrata in precedenza, nel Passo 4) e alla Figura 7.5.

Figura 7.5 Collocazione dei componenti per l’aggiunta del display a cristalli liquidi 16 × 2.

Le prime tre righe di questo codice caricano le librerie che devono essere utilizzate per l’orologio. La prima include la libreria I2C che attiva la comunicazione con il modulo RTC. Si tratta di un bus di comunicazione fra i circuiti integrati, in questo caso l’Arduino e il Dallas DS1307. È utile anche per comunicare con una grande quantità di accessori, come moduli GPS. La cosa interessante dell’I2C è il fatto che richiede due soli pin, più l’alimentazione e la terra. Questa libreria semplifica notevolmente le comunicazioni con la maggior parte dei dispositivi I2C. La libreria successiva è la RTCLib. Si tratta di una versione di una libreria scritta da JeeLab e modificata da Adafruit Industries per comunicare con il modulo RTC. Viene utilizzata per trarre l’ora dal modulo RTC e utilizza la libreria I2C per negoziare tale comunicazione. L’ultima libreria è quella del display a cristalli liquidi, che gestisce le comunicazioni parallele con il display. A differenza della libreria RTC, che deve essere aggiunta manualmente, questa è inclusa come libreria standard nella distribuzione software di Arduino. Dopo aver incluso le librerie, il codice crea due oggetti: un oggetto orologio chiamato rtc e un oggetto di tipo LiquidCrystal chiamato lcd. Questo oggetto ha dei parametri che determinano quali pin digitali vengono utilizzati da Arduino per comunicare con il display. Dopo aver creato questi oggetti, la funzione setup() predispone le cose. Attiva le librerie Wire, rtc e lcd, tramite le rispettive funzioni begin(). La funzione lcd.begin() accetta due parametri: il numero di colonne e il numero di righe, che in questo caso sono, rispettivamente, 16 e 2. A questo punto è possibile scrivere dei messaggi sul display, utilizzando semplicemente la funzione lcd.print(): lcd.print(“ It’s Alive!”);

I due spazi che si trovano all’inizio del testo centrano approssimativamente il messaggio di 11 caratteri nello spazio di 16 caratteri disponibile sulla prima riga. Normalmente si controlla la posizione del testo utilizzando la funzione setCursor(), ma qui non sembra necessario (un’istruzione


in meno da inserire in setup()). Dopo un breve ritardo, che consente di leggere il messaggio presentato sullo schermo, la funzione lcd.clear() cancella tutto il testo, in modo da entrare nel ciclo principale: loop().

Se non siete riusciti a visualizzare il messaggio di test, controllate tutte le connessioni. Assicuratevi che tutti i componenti siano collegati in modo corretto e di aver fornito le connessioni di alimentazione e di terra sia al display a cristalli liquidi sia alla retroilluminazione. Queste funzionalità sono infatti alimentate separatamente.

Visualizzazione dell’ora Ora che abbiamo accesso al display, è tempo di leggere l’ora dal modulo RTC e di visualizzarla. Successivamente aggiungeremo i pulsanti per la programmazione della sveglia e un commutatore per la visualizzazione dell’ora, l’impostazione della sveglia e l’attivazione della sveglia. In realtà vi sono solo due cose da visualizzare con questo orologio: l’ora corrente o l’ora della sveglia. Invece di includere il codice di entrambe le visualizzazioni nel ciclo loop(), ha più senso collocare la procedura di visualizzazione in una propria funzione, in modo da rendere tutto più modulare e più facile da modificare. Aggiungete il codice seguente alla sezione di dichiarazione delle variabili in cima al codice (il nuovo codice è riportato in grassetto): RTC_DS1307 rtc; // Create a realtime clock called rtc LiquidCrystal lcd(12, 11, 5, 4, 3, 2); // Create an LCD called lcd DateTime now;

Ciò crea un oggetto now di tipo DateTime. Il tipo oggetto DateTime fa parte della libreria RTC ed è l’unico modo per chiedere l’ora al modulo RTC, anche se offre una grande quantità di opzioni ed è in grado di fornire ore, minuti, secondi e anche anno, mese e giorno. Ora aggiungete il codice nel ciclo principale, per leggere l’ora corrente dal modulo RTC, e aggiungete una funzione per aggiornare il display con l’ora corrente: void loop(){ now = rtc.now(); // Get the current time // Refresh the display updateDisplay(); }

L’oggetto DateTime now memorizza l’ora corrente tratta dalla funzione rtc.now() per visualizzare l’ora sul display e per controllare se è giunto il momento di attivare la sveglia. Per mantenere il codice modulare, l’aggiornamento del display viene eseguito da una specifica funzione, posta all’esterno del ciclo principale. Dopo aver chiuso il ciclo principale, aggiungete la funzione updateDisplay() inserendo il codice seguente: void updateDisplay(){ int h = now.hour(); // Get hours now and store in an integer called h int m = now.minute(); // Get minutes now and store in an integer called m int s = now.second(); // Get seconds now and store in an integer called s lcd.setCursor(0, 0); // Set cursor at column zero, upper row with spaces… lcd.print(“ The time is: “); // …to clear characters from setting alarm. lcd.setCursor(4, 1); // Move the cursor to column four, lower row if (h<10){ // Add a zero, if necessary, as above lcd.print(0); } lcd.print(h); // Display the current hour lcd.setCursor(6, 1); // Move to the next column lcd.print(“:”); // And print the colon


lcd.setCursor(7, 1); // Move to the next column if (m<10){ // Add a zero, if necessary, as above lcd.print(0); } lcd.print(m); // Display the current minute lcd.setCursor(9, 1); // Move to the next column lcd.print(“:”); // And print the colon lcd.setCursor(10, 1); // Move to the next column if (s<10){ // Add a zero, if necessary, as above lcd.print(0); } lcd.print(s); // Display the current second }

Caricate il codice alla scheda Arduino e osservate ciò che accade. Se tutto funziona e il codice viene compilato correttamente, il display dovrebbe mostrare l’ora del computer (essendo stata impostata con lo sketch DS1307 inviato precedentemente). Congratulazioni! Avete appena realizzato il vostro primo, semplice, orologio! Nel codice, l’ora corrente viene richiesta all’oggetto now e collocata in tre variabili intere, utilizzate solo dalla funzione updateDisplay. Queste variabili hanno una visibilità locale, ovvero possono essere utilizzate solo all’interno di updateDisplay(): tutto il resto del programma non saprà neppure della loro esistenza, il che spiega perché non vengono dichiarate all’inizio del codice. Si richiedono i minuti, le ore e i secondi separatamente tramite le funzioni now.hours(), now.minutes() e now.seconds(). Assegnare ognuno di questi valori separatamente alla rispettiva variabile intera (h, m e s) è molto più semplice rispetto a chiedere l’ora corrente tutta insieme con rtc.now(); e poi estrarre da essa (con complesse operazioni di parsing) le ore, i minuti e i secondi. Avendo suddiviso l’ora in tre variabili, in updateDisplay() non resta altro che posizionare il cursore sul display a cristalli liquidi e visualizzare il testo appropriato. Il posizionamento del cursore viene svolto tramite la funzione setCursor(), che accetta due parametri: il numero di colonna e il numero di riga. La funzione non fa altro che collocare il cursore nella posizione desiderata. Dovrete poi dire al display che cosa visualizzare. La numerazione parte da 0 e dunque il carattere posto nell’angolo superiore sinistro si trova nella colonna 0 e riga 0. Il cursore viene posizionato all’angolo superiore sinistro del display e la prima riga di testo viene visualizzata con lcd.print(“ The time is:”). Vi sono due spazi prima e uno dopo il testo. Questi sovrascrivono l’eventuale testo già presente sul display, il che non è un problema in questo momento, ma potrebbe esserlo in un altro momento, quando si passerà alla modalità di impostazione della sveglia. I caratteri visualizzati da tale modalità devono essere cancellati. La scrittura di spazi cancella ogni altro testo che potrebbe essere rimasto sul display dalla modalità di impostazione dell’allarme. Potreste utilizzare al suo posto la funzione lcd.clear(), che cancella tutto il testo dall’intero display. Tuttavia, l’orologio è in costante aggiornamento e dunque il fatto di cancellare il display ogni volta con la funzione updateDisplay() introduce uno sfarfallio sgradevole. Un approccio più semplice (che utilizza anche un’istruzione in meno) consiste nello scrivere degli spazi sopra ciò che potrebbe già trovarsi sul display. Quindi il cursore viene spostato di quattro posizioni a destra e sulla seconda riga, in modo che l’ora risulti centrata sul display: lcd.setCursor(4,1);

Un aspetto problematico del fatto di utilizzare interi per ottenere ore, minuti e secondi, è il fatto che non prevedono lo zero iniziale per i valori minori di 10. Occorre pertanto aggiungerlo manualmente, sia per far sì che la visualizzazione dell’orologio risulti corretta (per esempio 01:05), sia per mantenere le ore, i minuti e i secondi sempre nella stessa posizione del display. Altrimenti, tenderebbero a spostarsi all’interno dei caratteri del display e ciò li renderebbe difficili da leggere. Per esempio, senza gli “0” iniziali, quando ci troveremo a cinque minuti dopo l’una di notte, l’orario verrebbe visualizzato come 1:5.

Ci si potrebbe chiedere perché non utilizzare il tipo di dati char, dato che il metodo now() restituisce valori char, ma ciò rende più complesso confrontare logicamente l’ora corrente con l’ora della


sveglia. È molto più semplice utilizzare valori int. L’aggiunta dello 0 iniziale viene svolta nello stesso modo per le ore, i minuti e i secondi, quindi parleremo solo delle ore, per semplicità: if (h<10){ lcd.print(0); } lcd.print(h);

// Add a zero, if necessary, as above // Display the current hour

L’istruzione condizionale if controlla se l’ora attuale è minore di 10 e, in questo caso, l’istruzione print() mostra uno 0. Di conseguenza, il display a cristalli liquidi avanza automaticamente di una posizione, dove si può visualizzare l’ora (compresa fra 0 e 9) memorizzata nella variabile intera h, che avrà uno 0 iniziale. Lo stesso vale per i minuti e i secondi. Occorre anche far avanzare il cursore alla posizione corretta per lo 0 iniziale dei minuti e dei secondi. Si inserisce un simbolo “:” fra di loro utilizzando l’istruzione lcd.print(“:”);. A questo punto avete tutte le informazioni necessarie per visualizzare l’ora e per spostare il cursore sul display e potete anche modificare il testo. Forse preferite un orologio che parli italiano o Klingon. Dopo aver visualizzato l’ora, potete predisporre l’hardware di input e output necessario per gestire la sveglia.

Aggiunta dei pulsanti e del commutatore di input Innanzitutto, aggiungeremo un pulsante e una resistenza, da utilizzare come input per incrementare i valori. Fate riferimento alla Figura 7.6 per assicurarvi di aver eseguito le connessioni corrette. Il pulsante funziona applicando 5 V al pin 7 quando viene premuto. Quando la corrente scorre attraverso l’interruttore, incontra la resistenza e, invece di attraversarla, prende il percorso più diretto verso terra, attraverso il pin 7 (vi sono connessioni a terra interne all’interno del microcontroller ATmega328). La lettura del pin 7 con la funzione digitalRead() restituisce un valore HIGH (+5 V). Quando non è premuto, il pin 7 viene connesso tramite la resistenza a GND con il collegamento della breadboard. La lettura del pin 7 con la funzione digitalRead() restituirà quindi il valore LOW (0 V). Ora aggiungete il secondo pulsante e la relativa resistenza, per incrementare i minuti. Dovrà essere connesso al pin digitale 8. Infine, aggiungete il commutatore a cursore, che ha tre posizioni e due resistenze. Potete vedere nella Figura 7.7 che le connessioni elettriche per il commutatore a cursore sono molto simili a quelle dei due pulsanti. Ma poiché si tratta di un cursore, rimane nella posizione in cui lo collocate. Nella posizione sinistra, porta +5 V sul pin digitale 10. Nella posizione destra, porta +5 V sul pin digitale 6. Al centro, non effettua alcuna connessione ed entrambi i pin digitali sono connessi solo alla terra comune.


Figura 7.6 Collocazione del pulsante di avanzamento dei valori.

Leggendo questi pin potete determinare se l’orologio è in modalità di impostazione allarme (pin 6 HIGH), in modalità di attivazione sveglia (pin 10 HIGH) o semplicemente in modalità di visualizzazione dell’ora (nessuna connessione, pin 6 e 10 entrambi LOW). Ora si deve aggiungere il codice necessario per leggere il tutto e per rispondere all’hardware. Occorrono alcune variabili per la memorizzazione dello stato del sistema e per registrare quando attivare la sveglia. Nella sezione di dichiarazione delle variabili, aggiungete il codice seguente: … DateTime now; boolean displayAlarmSet = false; // Whether we are in the show time mode // or show alarm set mode boolean alarm = false; // Whether the alarm is currently happening boolean armed = false; // Whether the alarm is armed or not int alarmHrs = 12; // You can set the alarm time in code, here int alarmMins = 00;


Figura 7.7 Collocazione dei pulsanti di input e del commutatore a cursore.

La variabile displayAlarmSet consente di passare dalla visualizzazione dell’ora alla visualizzazione dell’ora di sveglia che utilizzerete nella funzione updateDisplay() fra un po’. Potete utilizzare il commutatore a cursore per cambiare il valore di questa variabile. La variabile alarm registra il fatto che la sveglia sia attualmente in corso, per consentirvi di attivare l’altoparlante piezoelettrico, se necessario. Inoltre, dovete registrare quando attivare la sveglia. L’operazione viene svolta da due interi, alarmHrs e alarmMins. Se volete impostare l’ora di sveglia via software e non tramite i pulsanti, potete modificare il valore iniziale di queste variabili. Per iniziare sono state impostate a 12 ore e 00 minuti. Il conteggio dei due pulsanti e il controllo dei due stati che possono essere impostati tramite il commutatore a cursore (modalità di visualizzazione dell’ora o di visualizzazione della sveglia) prevede quattro input. Pertanto avrete bisogno di quattro pin digitali per leggere lo stato. Questi sono i vostri input e dunque devono essere attivati nella parte setup() del codice. Successivamente utilizzerete anche l’altoparlante piezoelettrico in output, ma può essere aggiunto già adesso. Pertanto aggiungete il codice seguente: // User input to set alarm time const int alarmSetPin=6; const int incrementAlarmHrsPin=7;

// Used to change to alarm set mode // Used to increment the alarm hours // in alarm set mode const int incrementAlarmMinsPin=8; // Used to increment the alarm minutes // in alarm set mode const int piezoPin = 9; // Used for the piezoelectric sounder const int alarmArmedPin=10; // Use to enable the alarm to go off … setup(){ … lcd.clear(); // Set several pins for input and output pinMode(alarmSetPin, INPUT); pinMode(incrementAlarmHrsPin, INPUT); pinMode(incrementAlarmMinsPin, INPUT); pinMode(alarmArmedPin, INPUT); pinMode(piezoPin, OUTPUT);


Notate la presenza dei punti di sospensione (…) per indicare il codice che avete aggiunto in precedenza (non è il caso di ripeterlo ogni volta). Vi sono cinque nuovi interi, che gestiscono i pin di input. Questi non cambiano nel corso del programma e dunque sono costanti intere. Avete connesso il commutatore a cursore ai pin 6 e 10 per gestire l’attivazione o la disattivazione della sveglia. Avete connesso i pulsanti ai pin 7 e 8. Ognuno di questi controlla, separatamente, l’incremento delle ore e dei minuti. L’incremento avviene solo verso l’alto. Altrimenti avreste bisogno di ulteriori pulsanti per decrementare le ore e i minuti oppure di un modo per commutare i pulsanti fra incremento e decremento, il che renderebbe le cose inutilmente complicate. Infine, questi pin vengono utilizzati per l’input e dunque devono essere impostati esplicitamente per essere utilizzati come INPUT tramite la funzione pinMode(). Più avanti nel capitolo connetteremo l’altoparlante piezoelettrico al pin 9, in modo che possa essere predisposto anche lui, già impostato su OUTPUT.

Controllo, impostazione e visualizzazione della sveglia Potete aggiungere il codice del loop() principale che gestisce l’orologio. Questo controlla l’ora, decide se avviare la sveglia e aggiorna il display (il nuovo codice è rappresentato in grassetto): void loop(){ now = rtc.now(); // Get the current time int alarmArmed=digitalRead(alarmArmedPin); if (alarmArmed==HIGH){ armed=true; } else { armed=false; } // Determine whether to sound the alarm or not if(armed){ // If the alarm is armed and… if (!alarm){ // If we are not currently sounding the alarm checkAlarm(); // Check to see if it is the time it should be triggered } else { soundAlarm(); // Otherwise, we should be sounding the alarm, so do it. } } // Check whether we are in Alarm Set mode int setMode = digitalRead(alarmSetPin); // Read the pin // that the switch is on if (setMode==HIGH){ // If the pin is high displayAlarmSet=true; // Set displayAlarmSet true. Used by updateDisplay // to switch between showing alarm or current time setAlarm(); // Go read the switches to set the alarm } else { // If we aren’t in set mode displayAlarmSet=false; // We are not in set mode, make sure flag is correct } // Refresh the display updateDisplay(); }

Sono parecchie le operazioni svolte qui! Dopo che la funzione rtc.now() (aggiunta precedentemente) riceve l’ora corrente, utilizzate la variabile locale alarmArmed per memorizzare il valore di alarmArmedPin e poi utilizzate l’istruzione condizionale if (alarmArmed==HIGH) per vedere se è HIGH. In questo caso, è perché il cursore è nella posizione di attivazione della sveglia e fa sì che 5 V siano presenti al pin 10 di Arduino. In tal caso, la variabile booleana armed è true. Altrimenti è false. Questa variabile determina se produrre suoni dalla sveglia quando giunge l’orario corretto. Probabilmente non vorrete che suoni ogni giorno della settimana… Poi si trova un ciclo nidificato, che determina se avviare l’allarme. L’istruzione condizionale if controlla questa condizione valutando il fatto che l’orologio sia in posizione di attivazione: if(armed){

Si tratta di un’abbreviazione. Avremmo potuto scriverla anche come: if(armed==TRUE){

e avrebbe funzionato allo stesso modo.


Se la sveglia è attiva e attualmente non sta suonando, è tempo di controllare se debba suonare, utilizzando la funzione checkAlarm(). L’operazione viene controllata tramite la condizione !alarm. Il segno “!” indica un NOT logico. Al contrario, se siamo già in uno stato di allarme, è tempo di lanciare il suono, utilizzando la funzione soundAlarm, che potete aggiungere al codice successivamente, quando aggiungeremo l’altoparlante piezoelettrico. La funzione checkAlarm() confronta l’ora corrente con l’ora della sveglia. In fondo al codice, aggiungete la funzione seguente: void checkAlarm(){ if(alarmHrs==now.hour() && alarmMins==now.minute() && now.second()==0){ // If the alarm time is now, and it’s zero seconds alarm=true; // set the alarm flag to be true. The next time // the main loop executes, the alarm will be activated } }

Questa funzione usa le variabili intere globali create all’inizio del codice per memorizzare l’ora di sveglia: alarmHrs e alarmMins. Si ottengono l’ora e il minuto correnti utilizzando now.hour() e now.minute() e si controlla se entrambi contengono lo stesso valore di alarmHrs e alarmMinutes utilizzando l’operatore di AND logico: “&&”. Si vuole eseguire questo controllo solo nel secondo in cui viene raggiunta l’ora della sveglia e dunque si usa l’operazione && anche per controllare questa condizione. Senza questo, la variabile booleana alarm rimarrebbe true per un intero minuto, anche se avete già spento la sveglia, il che significa che vi impedirebbe di spegnere la sveglia per un intero minuto! Questo è tutto ciò che è necessario per il funzionamento di checkAlarm(). Non rimane che aggiungere la funzione soundAlarm(). Ora occorre controllare se l’utente sta impostando la sveglia. Si usa la variabile locale setMode per leggere e memorizzare alarmSetPin(Pin 6). Memorizzate il tutto utilizzando la variabile booleana displayAlarmSet. Questa variabile è true quando la posizione del commutatore a cursore invia +5 V al pin 6 di Arduino. Se il cursore è in posizione di impostazione dell’allarme, dovete leggere i pulsanti utilizzando la funzione setAlarm(). Pertanto, i pulsanti vengono letti solo se il commutatore a cursore è nella posizione corretta, il che previene eventuali interventi accidentali sull’ora della sveglia. Inoltre aggiornate il display in modo appropriato utilizzando la funzione updateDisplay(), non mostrando l’ora corrente, ma l’ora della sveglia. Vedremo come farlo fra poco, ma innanzitutto occorre aggiungere la funzione setAlarm(), in modo da poter rispondere alle pressioni dei pulsanti e memorizzare in modo appropriato l’ora di sveglia. Aggiungete la parte seguente in fondo al codice: void setAlarm(){ int hrs=digitalRead(incrementAlarmHrsPin); int mins=digitalRead(incrementAlarmMinsPin); if (hrs==HIGH){ // If the hours switch is pressed alarmHrs+=1; // Increment the hours upward delay(200); // Wait a moment between incrementing the numbers if(alarmHrs>23){ // if the hour is over 23, set it back to 0 alarmHrs=0; } } if (mins==HIGH){ // If the minutes switch is pressed alarmMins+=1; // Increment the minutes upward delay(200); // Wait a moment between incrementing the numbers if(alarmMins>59){ // if the minute is over 59, set it back to 0 alarmMins=0; } } }

In questa funzione, utilizzate due variabili locali intere, hrs e mins, per leggere e memorizzare il valore sui pin digitali che sono connessi ai pulsanti. Se viene premuto il pulsante delle ore, hrs conterrà il valore HIGH e dovrete aggiornare la variabile alarmHrs aggiungendo un’ora: alarmHrs+=1. Introducete una pausa in modo che l’utente non si trovi a incrementare i valori troppo rapidamente. L’istruzione delay(200) attende 200 ms (un tempo sufficiente perché l’utente incrementi il valore e poi si fermi). Vi sono solo 24 ore in un giorno e dunque l’ultima istruzione if riporta l’orario a 00 dopo aver raggiunto le ore 23. La stessa operazione si impiega per rilevare e incrementare i minuti della sveglia. Ora occorre vedere cosa sta accadendo. Per aggiornare il display con l’ora dell’allarme, aggiungete il codice seguente (rappresentato in grassetto) all’inizio della funzione updateDisplay() creata in precedenza: void updateDisplay(){


if(displayAlarmSet){ // If we are in alarm set mode, DISPLAY ALARM SET TEXT lcd.setCursor(0, 0); // Set the cursor at the column zero, upper row lcd.print(“Set alarm time: “); lcd.setCursor(4, 1); // Move the cursor to column four, lower row lcd.print(“ “); // Write over digits of the time previously displayed lcd.setCursor(5, 1); // Move to next column so the time will be centered if (alarmHrs<10){ // Integers of 0-9 are only one digit. If so… lcd.print(0); // … add a zero in front of it } lcd.print(alarmHrs); // Print the current alarm hour lcd.setCursor(7, 1); // Move to the next column lcd.print(“:”); // And print the colon lcd.setCursor(8, 1); // Move to the next column if (alarmMins<10){ // Integers of 0-9 are only one digit. If so… lcd.print(0); // … add a zero in front of it } lcd.print(alarmMins); // Print the current alarm minutes lcd.setCursor(10, 1); // Move to the next column lcd.print(“ “); // Write spaces over digits previously displayed } else { int h = now.hour(); // Get hours and store them in an integer h int m = now.minute(); // Get minutes and store them in an integer m int s = now.second(); // Get seconds and store them in an integer s lcd.setCursor(0, 0); // Set the cursor at the column zero, upper row… if(armed){ lcd.print(“* The time is: “); } lcd.print(“ The time is: “); // …with spaces to clear alarm lcd.setCursor(4, 1); // Move the cursor to column four, lower row if (h<10){ // Add a zero, if necessary, as above lcd.print(0); } lcd.print(h); // Display the current hour lcd.setCursor(6, 1); // Move to the next column lcd.print(“:”); // And print the colon lcd.setCursor(7, 1); // Move to the next column if (m<10){ // Add a zero, if necessary, as above lcd.print(0); } lcd.print(m); // Display the current minute lcd.setCursor(9, 1); // Move to the next column lcd.print(“:”); // And print the colon lcd.setCursor(10, 1); // Move to the next column if (s<10){ // Add a zero, if necessary, as above lcd.print(0); } lcd.print(s); // Display the current second } }

Qui non si fa altro che aggiornare il display con le ore e i minuti correnti dell’orario di impostazione della sveglia. La prima istruzione if condizionale controlla se ci si trova in modalità di attivazione della sveglia. In questo caso, mostrerà l’orario di sveglia. In caso contrario, si salta all’istruzione else. Avete già creato il codice che deve trovarsi dopo l’istruzione else: è quello che visualizza semplicemente l’ora corrente. La visualizzazione dell’ora della sveglia è sostanzialmente la stessa operazione della visualizzazione dell’ora, posizionando il cursore e poi mostrando il testo sul display. La differenza è che il messaggio dice “Set alarm time:” (con uno spazio iniziale) e poi vengono mostrate le ore e i minuti della sveglia, separati dal segno “:”. Notate che viene gestita anche l’aggiunta dello 0 iniziale, come abbiamo già fatto per l’ora. A updateDisplay() manca solo un’ultima modifica. Occorre indicare in qualche modo che la sveglia è attiva, ovvero che la variabile armed è true. Una soluzione semplice consiste nell’aggiungere un asterisco quando viene visualizzata l’ora corrente. Modificate pertanto il codice rimanente di updateDisplay(): lcd.setCursor(0, 0); if(armed){ lcd.print(“* The time is: “); } else lcd.print(“ The time is: “);

Non rimane che una cosa da fare: provare il funzionamento.

Aggiunta della sveglia


Dal punto di vista hardware, questa è la modifica più semplice. Dovete solo collegare l’altoparlante piezoelettrico come rappresentato nella Figura 7.8. Dopo questa aggiunta, create semplicemente una funzione che riproduca la sveglia. Aggiungete il codice seguente nella parte inferiore dello sketch di Arduino: void soundAlarm() { float alarmFrequency=1400; // The value for the alarm tone in Hz float period = (1.0 / alarmFrequency) * 1000000; long beepDuration=250000; // the time in microseconds (0.25 seconds) long elapsedTime = 0; while (elapsedTime < beepDuration) { digitalWrite(piezoPin,HIGH); delayMicroseconds(period / 2); digitalWrite(piezoPin, LOW); delayMicroseconds(period / 2); elapsedTime += (period); } digitalWrite(piezoPin, LOW); delayMicroseconds(beepDuration); // Listen for either button to be pressed and if so, turn off the alarm int hrs=digitalRead(incrementAlarmHrsPin); int mins=digitalRead(incrementAlarmMinsPin); if (hrs==HIGH || mins==HIGH){ alarm=false; } }

Questo codice usa la formula standard per ottenere il periodo di una frequenza; il periodo è la durata di un singolo ciclo in un evento a ripetizione ed è il reciproco della frequenza. Potete specificare la frequenza del tono della sveglia in Hertz (Hz) e assegnarla alla variabile alarmFrequency, di tipo float. La sveglia riproduce a ripetizione un tono a questa frequenza (in questo caso abbiamo scelto 1440 Hz). Due interi long, beepDuration ed elapsedTime, memorizzano il tempo trascorso in cui il tono viene riprodotto e la durata di riproduzione. Il ciclo while usa questi valori per limitare il tempo di riproduzione della nota a 0,25 secondi (durata del bip). Dopo aver calcolato il periodo, utilizzate questo valore per scrivere rapidamente i valori HIGH e LOW su piezoPin. Un ciclo include i tempi di attivazione e disattivazione e dunque la quantità di tempo da scrivere sui pin HIGH e LOW sarà pari alla metà del periodo totale. Il tutto viene scritto sui pin digitali utilizzando la seguente parte:


Figura 7.8 L’aggiunta dell’altoparlante piezoelettrico.

digitalWrite(piezoPin,HIGH); delayMicroseconds(period / 2); digitalWrite(piezoPin,LOW); delayMicroseconds(period / 2);

La funzione delayMicroseconds() introduce un ritardo temporale nell’elaborazione della scheda Arduino ed è necessaria per generare un tono. Dopo che il tono è stato riprodotto, le due righe seguenti creano un silenzio della stessa durata, 0,25 secondi, mantenendo piezoPin LOW: digitalWrite(piezoPin, LOW); delayMicroseconds(beepDuration);

L’ultima cosa che rimane da fare è fornire un modo per spegnere la sveglia. Se premete uno dei pulsanti, gli interi locali hrs e mins memorizzano il valore del pulsante utilizzato per programmare la sveglia. Se il pulsante di impostazione delle ore o dei minuti va HIGH poiché è stato premuto, la condizione alarm viene impostata a false. Le barre verticali || rappresentano l’operatore di OR logico: int hrs=digitalRead(incrementAlarmHrsPin); int mins=digitalRead(incrementAlarmMinsPin); if (hrs==HIGH || mins==HIGH){ alarm=false; } }

In effetti si tratta di una grande quantità di codice, ma ora l’orologio è pronto per un giro di prova. Nel codice, impostate l’ora di sveglia nei prossimi minuti, poi caricate il codice sulla scheda Arduino. Assicuratevi che il commutatore a cursore sia nella posizione di attivazione della sveglia e che venga visualizzato l’asterisco. Ben presto dovreste ricevere il segnale acustico della sveglia. Se le cose non dovessero funzionare a dovere, controllate le connessioni. La Figura 7.9 mostra uno schema elettrico che dovrebbe aiutarvi a individuare eventuali problemi.

Figura 7.9 Schema elettrico dell’orologio sveglia Arduino.

Poi controllate il codice, per assicurarvi che tutto sia corretto. Se tutto sembra a posto, potete leggere i suggerimenti per la soluzione dei problemi riportati nel Capitolo 17. È ora di darvi da soli una pacca sulla spalla per aver costruito dal nulla una sveglia Arduino perfettamente funzionante.


Parte III Casa e giardino interattivi

I listati e le risorse grafiche dei capitoli sono disponibili sul sito www.hoeplieditore.it/6323-9.


In questa parteâ&#x20AC;Ś Uso dei sensori e automazione domestica Realizzazione di un impianto automatico di innaffiatura Lettura di temperature e livelli di luce con una scheda Arduino Realizzazione di uno shield Arduino Istruire la scheda Arduino per inviare dati via Internet Programmazione della scheda Arduino per inviare tweet


Capitolo 8

Un sistema di controllo degli accessi In questo capitolo Lettura di un tastierino numerico Uso di un display a LED Attivazione di un relé Uso degli array di caratteri

N

essun genio che si rispetti lascerebbe il proprio covo in balìa degli invasori. Il progetto presentato in questo capitolo prevede la realizzazione di un sistema di controllo degli accessi che sblocca una porta solo introducendo il codice corretto in un tastierino numerico standard, a dieci tasti. Il sistema visualizza in tempo reale il codice su un display LED a sette segmenti e una volta inserito il codice corretto mostra un messaggio di benvenuto. Il progetto utilizza un display a sette segmenti di quattro cifre, del tipo che avete sicuramente visto nei film di spionaggio degli anni Sessanta e un tastierino standard con una disposizione dei tasti di tipo telefonico. La porta viene chiusa con un meccanismo di bloccaggio elettrico che si sblocca solo inserendo il codice corretto. Potete acquistare sistemi di questo tipo presso i negozi di ferramenta e serrature, ma è molto più divertente costruirselo da soli e sfruttare l’occasione per acquisire ancora più competenze nell’utilizzo di Arduino. È inoltre possibile modificare il sistema in modo che accetti l’input da un lettore di schede RFID (lo vedremo nel Capitolo 9).

I componenti La Figura 8.1 mostra i componenti necessari per il progetto. Creeremo il prototipo su una breadboard per assicurarci che tutto funzioni correttamente e poi inseriremo il tutto in un contenitore appropriato una volta che saremo sicuri che funzioni. Per l’inserimento nel contenitore, vorrete probabilmente ricostruire il circuito su una basetta millefori (una stripboard), nel qual caso dovrete procurarvene una di piccole dimensioni. Vi sono molti collegamenti in questo progetto e dunque dovreste procurarvi anche del cavo a nastro per eseguire tutte le connessioni richieste. Ecco di cosa avete bisogno. Una scheda Arduino. Un tastierino numerico (SparkFun COM-08653 o Rapid 78-0305). Un display a LED a sette segmenti per quattro cifre, a catodo comune (Lite-ON LTC-4727JR di Digi-Key; 160-1551-5ND o HDSP-B09G di Farnell 1003341). Un driver per display a LED a otto cifre Max 7219 o 7221. Due condensatori: un condensatore elettrolitico da 10 μF (microfarad) e un condensatore ceramico a disco da .01 μF. Due resistenze: da 2.2 Kohm e 33 Kohm. Queste possono variare a seconda del modulo a LED e del tipo di relé. Un relé in miniatura da 5 V CC (come Hamlin HE721A0510 da Jameco #1860109 o Farnell #9561757). Un transistor NPN 2N2222 o simile. Un diodo 1N4001 o simile. Una striscia di piedini.


Una serratura elettrica da 12 V CC. Ve ne sono molte fra cui scegliere (articolo #5192 su SmartHome.com o GAE Series Electric Strike su onlinesecurityproducts.co.uk). Un cavetto a due conduttori per bassa tensione (18-22 AWG) per portare l’alimentazione dal trasformatore al contenitore del progetto e da qui alla serratura. Un contenitore appropriato per inserire il tutto (per esempio Serpac A27BK, Jameco #373456 o Farnell #775538). Le dimensioni minime sono circa di 15 × 8 × 4 cm.

Figura 8.1 I componenti necessari per questo progetto.

Una piccola basetta millefori di tipo stripboard (opzionale). Qualche pezzo non troppo lungo di cavo a nastro (opzionale). Fascette di fissaggio a parete. Pistola per colla a caldo. Un metro per le misurazioni. Piccoli utensili per eseguire fori nel contenitore e per installare la serratura sulla porta.

Potete scaricare gli schemi elettrici e i diagrammi a colori di collocazione dei componenti dal sito Web del libro (www.hoeplieditore.it/6323-9. Come per altri progetti, anche questo si basa su Arduino UNO. Ma non c’è niente di particolare sul codice e quindi dovreste poterlo realizzare con qualsiasi versione della scheda Arduino. Il tastierino contiene delle piste conduttive sul circuito stampato interno. La pressione di un pulsante connette due di queste piste, una per la riga e una per la colonna che si incrociano sotto il pulsante. Ogni riga e colonna è connessa a un piedino di output del tastierino, che potete connettere ai pin digitali della scheda Arduino. Quando premete un pulsante, si attiva una connessione fra una riga e una colonna. Potete pertanto rilevare il tasto premuto, leggendo lo stato dei pin digitali di Arduino. I vari produttori assegnano piedini di output differenti alle righe e alle colonne del loro tastierino. Due dei tastierini più popolari sono stati elencati precedentemente e verranno utilizzati per il codice di esempio. La Figura 8.2 mostra il loro schema elettrico. Se utilizzate un tastierino differente, dovrete collaudarlo o consultare il suo datasheet per determinare come connettere i piedini di


output ai pin digitali di Arduino. Vedremo come collaudare il tastierino più avanti in questo capitolo.

Figura 8.2 Contatti dei piedini di un tastierino a matrice.

La fonte di alimentazione dovrà essere a 12 V CC. La maggior parte dei produttori di serrature elettroniche offre modelli a 12 V CC, una tensione di alimentazione perfetta anche per la scheda Arduino. Inoltre, assicuratevi che il trasformatore fornisca un livello di corrente sufficiente per alimentare sia la scheda Arduino, sia la serratura elettronica. La scheda Arduino consuma solo 250 mA, ma è meglio stimare un consumo totale dei componenti elettronici a 500 mA. Il foglietto delle caratteristiche della serratura dovrebbe dire quanta corrente ha bisogno per funzionare. In caso contrario, potete utilizzare un tester per misurare la corrente attraverso la bobina dell’attuatore, mentre sta funzionando. La serratura GAE specificata nell’elenco dei componenti opera a 12 V CC e consuma 400 mA. Sommando il consumo di Arduino, si raggiungono i 950 mA. È opportuno prevedere un po’ di margine e dunque l’alimentatore deve fornire un output minimo di 1 A. Naturalmente potete utilizzare un alimentatore più potente, ma assolutamente non può essere di potenza inferiore. Il display impiegato è a quattro cifre di sette segmenti, un tipo di display che si trova praticamente ovunque. Impiegare un display a quattro cifre è molto più semplice rispetto a impiegare quattro display distinti a sette segmenti, poiché il tutto è ospitato da un unico oggetto. Tutti i catodi saranno comuni, e ciò riduce il numero di piedini necessari per utilizzarlo. I catodi e gli anodi per le cifre e il punto decimale (su display Lite-On) sono connessi solo a pochi piedini. In ogni caso, produttori differenti impiegano piedinature differenti. Il datasheet mostrerà quali piedini sono connessi a ciascun segmento. Potete utilizzare un modulo differente da quelli elencati per questo progetto, ma fate attenzione a utilizzare un display a catodo comune (CC), in quanto il codice di questo capitolo è realizzato per questa configurazione di display. Un display ad anodo comune (CA) non funzionerà.

Esistono anche display a sette segmenti che potete gestire direttamente tramite l’interfaccia seriale di Arduino (per esempio lo SparkFun COM-11442). Questo semplifica notevolmente la connessione e il cablaggio con il display, ma il costo sarà superiore. Il codice presentato in questo capitolo non funzionerà con questi moduli, ma una volta che ne comprenderete il funzionamento, non sarà difficile modificarlo per farlo funzionare a dovere. Il display è pilotato dal driver Maxim 7219 o 7221 (in sostanza 72xx). Questo circuito integrato consente di controllare un display fino a otto cifre. Gestisce l’indirizzamento di ciascun segmento, memorizzando lo stato di ogni cifra e controllando perfino la luminosità tramite la modulazione PWM (Pulse-Width Modulation). Per comodità, potete inviare comandi utilizzando la libreria Arduino SPI (Serial Peripheral Interface). Il chip richiede solo una resistenza per controllare la corrente per il LED e richiede due condensatori, che riducono le fluttuazioni di corrente per impedire che lo possano danneggiare. Meglio ancora: utilizza solo tre pin digitali della scheda Arduino.


La serratura è controllata da un relé. L’accensione del relé fa sì che la corrente scorra dalla fonte di alimentazione alla serratura. Il relé è controllato da un transistor di commutazione, una resistenza e un diodo. Il transistor è un transistor di commutazione NPN 2n2222. La resistenza da 2.2 KΩ impedisce che arrivi troppa corrente alla base del transistor.

Il diodo impedisce un fenomeno che si verifica quando la corrente sulla bobina del relé viene disattivata e il suo campo magnetico si interrompe. È importante che le correnti parassite non raggiungano il microcontroller.

Scelta di una serratura Considerate attentamente la porta che pensate di utilizzare per questo progetto. Dovrete intervenire sulla porta e sullo stipite per applicare un meccanismo di bloccaggio elettrico e questo può richiedere una certa capacità di eseguire lavori di falegnameria e l’impiego di appositi attrezzi, in quanto dovrete sagomare la porta o lo stipite per fissare la serratura. Vi sono vari tipi di sistemi di chiusura e dovrete sceglierne uno adatto alla vostra porta e allo stipite. I meccanismi più comuni sono le serrature elettriche, le serrature magnetiche e le serrature a chiavistello. Potete scegliere un meccanismo qualsiasi per questo progetto, ma sceglietene uno che siate in grado di installare. Le serrature elettriche, in genere, sono più facili da utilizzare e impiegano un relé interno per attivare un piedino che consente al chiavistello di aprirsi. La Figura 8.3 ne rappresenta una smontata. Tenete anche in considerazione che avrete bisogno di portare l’alimentazione alla porta e dunque dovrete prevedere appositi cablaggi.

Figura 8.3 I componenti interni di una serratura elettrica.

Esistono due tipi di serrature elettriche. Sblocco in mancanza di alimentazione. Questi sistemi aprono la porta quando non vengono alimentati. In tal modo, se vi fosse un incendio o un’altra situazione di pericolo, potrete comunque aprire la porta. Sono le più sicure, perché in caso di problemi consentono di uscire. Sblocco con alimentazione. Questi sistemi funzionano in modo opposto. Quando non sono alimentati, rimangono chiusi. Questo significa anche che non richiedono alcuna alimentazione per rimanere chiusi. Il vantaggio è che non è necessaria alimentazione per mantenere chiusa la porta. Ma se scegliete una serratura di questo tipo, dovrete assicurarvi che vi sia un modo per aprire la porta in caso di emergenza, per esempio un chiavistello che possa essere attivato a mano.


Per questo progetto viene impiegata una serratura elettrica poiché è più facile da installare. Si tratta di una piastra metallica contenente un incavo con una superficie smussata per ricevere il chiavistello. La serratura ha, al proprio interno, un meccanismo a relé. Quando si applica corrente al relé, il chiavistello rientra e consente di aprire la porta. La porta ha anche una manopola di sicurezza. Ruotando la manopola posta all’interno della porta è possibile aprire manualmente il chiavistello, il quale, tuttavia, ritorna in posizione automaticamente. Questo significa che, in caso di blackout, la porta rimarrà chiusa, ma può comunque essere aperta manualmente in caso di emergenza.

Esistono serrature elettriche con alimentazione in corrente continua e alternata. Scegliete un dispositivo in corrente continua a 12 volt (o quanto meno selezionabile fra 12 e 24 volt CC). In tal modo potrete utilizzare la stessa fonte di alimentazione che impiegate per la scheda Arduino. Avrete inoltre bisogno di alcuni cavi che vadano dal contenitore del tastierino alla serratura e, opzionalmente, del cavo a nastro se prevedete di trasferire il circuito dalla breadboard a una basetta millefori. Un cavo standard a bassa tensione da 0,5-1 mm dovrebbe essere sufficiente, poiché si tratta di un sistema a bassa tensione. Potete anche utilizzare del cavo telefonico o un vecchio cavo Ethernet. La connessione con la serratura dovrebbe richiedere solo pochi centimetri di cavo, quello che basta per attraversare la parete e raggiungere la serratura. Non ne avrete bisogno molto, poiché il tastierino verrà installato non troppo distante dallo stipite. La lunghezza del cavo di alimentazione dipende invece dalla distanza dalla presa di corrente. Misurate con un metro la distanza fra la porta e la presa di corrente più vicina per stimare la lunghezza dei cavi di cui avrete bisogno. Prevedete un po’ di cavo in più, in quanto lo dovrete far correre lungo gli angoli, per poi fissarlo con le fascette da parete.

È assolutamente importante che l’intero progetto sia ospitato da un contenitore che protegga tutti i componenti. Il contenitore dovrà essere di dimensioni sufficienti per ospitare il tastierino, il display, la scheda Arduino e una piccola breadboard o una basetta multifori per il MAX72xx. È difficile specificare esattamente il tipo di contenitore di cui avrete bisogno. Occorre considerare anche questioni di gusto personale e di finitura (in legno, metallo o plastica) e dovrete procurarvi gli attrezzi necessari per praticare le aperture quadrate per il display a LED e il tastierino, più i fori di passaggio dei cavi. Un piccolo trapano e un seghetto da hobbistica dovrebbero essere sufficienti per praticare le aperture necessarie. Le dimensioni minime approssimative di un contenitore in grado di ospitare il display, il tastierino, la scheda Arduino e il circuito a relé sono di circa 15 × 8 × 4 cm. Inoltre avrete bisogno di una pistola per colla a caldo e probabilmente di un piccolo martello e di uno scalpello da legno per installare la serratura nello stipite.

Realizzazione del prototipo con tasterino e display Questo progetto prevede l’impiego di una grande quantità di connessioni e dunque è opportuno partire da un prototipo realizzato su una breadboard. Dopo che avrete realizzato e collaudato il prototipo, potrete installare la breadboard in un contenitore oppure trasferire il circuito su qualcosa di più permanente, come una stripboard. La Figura 8.4 mostra lo schema elettrico dei componenti del sistema.


Figura 8.4 Schema elettrico del sistema di controllo con tastierino e display.

Dovrete saldare dei connettori a pettine al tastierino, per consentirne l’inserimento nella breadboard per il collaudo, come rappresentato nella Figura 8.5. Successivamente, questi connettori faciliteranno la connessione al cavo a nastro (saldando direttamente i pin oppure tramite un connettore femmina saldato al cavo stesso). Dopo aver saldato i pin, potrete iniziarne l’assemblaggio sulla breadboard.

Figura 8.5 Saldatura dei piedini del tastierino.

La Figura 8.6 mostra la disposizione dei componenti sulla breadboard, impiegando il tastierino Rapid e il display a LED Avago. Se utilizzate componenti differenti, anche le connessioni saranno probabilmente un po’ differenti. Aggiungete i componenti alla breadboard con i seguenti passi. 1. Inserite nella breadboard i piedini saldati al tastierino. 2. Inserite sul lato sinistro della breadboard il display a LED. 3. Aggiungete alla breadboard l’integrato 7219. 4. Connettete il tastierino ai pin digitali della scheda Arduino, assicurandovi che i piedini per le righe e le colonne del tastierino corrispondano ai pin digitali corretti della scheda Arduino. 5. Ricontrollate tutte le connessioni. È molto facile commettere errori in un progetto così complesso.


Figura 8.6 Disposizione dei componenti (tastierino Rapid 78-0305 e display a LED Avago HDSPB09G).

Vale sempre la pena di controllare il datasheet per assicurarsi che le connessioni siano corrette. Talvolta le unità hanno piedini aggiuntivi non connessi. Dipende dal produttore. La Tabella 8.1 mostra come connettere la scheda Arduino a due dei tastierini più popolari. Se utilizzate un’unità differente, controllatene la piedinatura per determinare come connetterla alla scheda Arduino. Le istruzioni sono specificate nel riquadro “Identificare i piedini del tastierino”, più avanti in questo capitolo.

Tabella 8.1 Piedinatura e connessioni del tastierino all’Arduino Pin digitale Arduino

Piedino SparkFun/Rapid Keypad

Riga/colonna

2

7

Riga 1

3

6

Riga 2

4

5

Colonna 2

5

4

Riga 3

6

3

Colonna 0

7

2

Riga 0

8

1

Colonna 1

Al momento attuale, il datasheet del Rapid Keypad 78-0305 sul sito mostra una piedinatura errata. Ora connettete tramite ponticelli il circuito integrato Max 72xx alla scheda Arduino, come descritto nella Tabella 8.2. È abbastanza semplice, poiché utilizzerete la libreria SPI per comunicare con il circuito integrato e sono necessari solo tre ponticelli!

Tabella 8.2 Connessione del circuito integrato Max 72xx Pin digitale Arduino

Piedino Max 72xx

10

1


11

12

13

13

Collocate i condensatori sulla breadboard. Come potete vedere nella Figura 8.6, il condensatore da .01 μF va sopra il circuito integrato. Per essere particolarmente efficace nel proteggere il circuito integrato dal rumore elettrico, deve trovarsi più vicino possibile ai piedini di output 9 e 19. La disposizione rappresentata in figura rappresenta il modo più semplice per farlo. Il condensatore elettrolitico da 10 μF deve semplicemente essere collocato fra la terra e il positivo, come nella Figura 8.6.

Il condensatore da 10 μF è “polarizzato”, ovvero funziona correttamente solo in una direzione. Assicuratevi che il piedino negativo sia connesso alla linea di terra della breadboard. Potete identificare il negativo dal simbolo “–” stampato su un lato del condensatore. Il piedino corrispondente è quello negativo.

Potreste essere tentati di lasciar perdere i due condensatori, specialmente se non li avete a disposizione. Non fatelo! Ciò potrebbe portare a strani comportamenti e perfino a danni permanenti. Evitano la presenza di un rumore sull’input di alimentazione e dovrebbero essere collocati il più vicino possibile ai piedini V+ e Ground del circuito integrato. Ora aggiungete le resistenze fra i piedini 18 e 19 del circuito integrato Max 72xx. Queste resistenze limitano la corrente che raggiunge ogni segmento del LED. Il valore della resistenza è determinato dalla massima corrente accettata dal display, che indica quanta corrente può attraversare i LED. Il datasheet del 72xx ha una tabella che specifica i valori delle resistenze da utilizzare per il display a LED. Il HDSP-B09G ha un massimo di 25 mA per segmento a una tensione di 2,2 V. Controllando la tabella, ciò indica che occorre una resistenza compresa fra 17 e 28 KΩ, ma è meglio prevedere un certo margine di sicurezza e dunque è meglio impiegare una resistenza da 33 KΩ. Questa ha funzionato per i display Lite-On e Avago, ma potreste aver bisogno di una resistenza differente se utilizzate un altro display. L’utilizzo di una resistenza insufficiente potrebbe ridurre la durata dei LED o del circuito integrato. Ora connettete il Max 72xx al display a LED. Il modo in cui si connette il display a LED al Max 72xx dipende dalla disposizione dei piedini. Lo schema rappresentato nella Figura 8.4, non mostra entrambi i display. La piedinatura dei display LED a quattro cifre varia in base al produttore e dunque nel diagramma non sono indicati i numeri di piedini. La Tabella 8.3 elenca le connessioni per il display a quattro cifre e sette segmenti riportato nell’elenco dei componenti. Fate riferimento alla Figura 8.6 per vedere la collocazione sulla breadboard del display Avago.

Identificare i piedini del tastierino Se utilizzate un tastierino di un altro produttore, potete controllare con facilità quali piedini sono assegnati alle righe e alle colonne utilizzando un tester. Se avete problemi a utilizzare le punte del tester sul tastierino, connettete dei coccodrilli alle punte e connettete l’altra estremità ai piedini. Poi procedete nel seguente modo. 1. Create un diagramma del tastierino come quello rappresentato nella Figura 8.2, ma senza indicare i numeri. 2. Regolate il tester in modo che misuri la continuità. 3. Partendo da sinistra e procedendo verso il lato destro del tastierino, connettete le punte ai piedini più a sinistra (1 e 2, ma non necessariamente sono contrassegnati da un numero). 4. Premete in successione tutti i pulsanti del tastierino, fino a rilevare la continuità.


5. Prendete nota della riga e della colonna del tasto che ha generato continuità. Per esempio, se siete connessi ai piedini 1 e 3 e il tester reagisce quando premete il tasto 7, scrivete un 1 per il piedino 1 sotto COLONNA 0 e un 3 a lato di RIGA 2. 6. Se non rilevate nessuna continuità, nessun problema, significa semplicemente che i due pin sono entrambi colonne o entrambi righe (dunque non saranno mai connessi). Spostate una delle punte dal piedino 2 al piedino 3 e ripetete i Passi 4 e 5. 7. Procedete in questo modo finché non avrete raggiunto la fine con la seconda punta del tester. 8. Ora iniziate a spostare verso destra la prima punta e procedete con il test. 9. Alla fine avrete trovato tutte le connessioni e potrete impostare i piedini corretti per le variabili rowPins e colPins.

Tabella 8.3 Connessioni fra il MAX72xx e i display a LED più comuni. MAX 7219/7221

Lite-On LTC-4727JR

Avago HDSP-B09G

1

2

1

12

3

4

5

6

6

8

7

8

6

8

9

10

11

2

9

12

13

14

14

11

15

11

10

16

16

7

17

15

5

18

19

20

13

4

21

5

1

22

7

2

23

3

3

24

Codifica e collaudo del tastierino A questo punto, avete collocato tutto, tranne il relé e la serratura. Ora che il tastierino e il display sono installati sulla breadboard, è il momento di caricare il codice sulla scheda Arduino. Nell’ambiente di sviluppo, aprite il codice di questo capitolo dalla scheda Downloads del sito web del libro (www.hoeplieditore.it/6323-9). Date un’occhiata al codice per comprendere il funzionamento e poi caricatelo sulla scheda Arduino.

Dichiarazione delle variabili Nella prima sezione, prima della configurazione, dichiarate le variabili per il tastierino e il display. const int numberOfDigits = 4; // The number of digits in the 7-segment display const int numRows = 4; // Number of rows in the keypad const int numCols = 3; // Number of columns in the keypad const int debounceTime = 20; // Number of ms for switch to become stable const int doorOpenTime = 5000; // How long you want the door strike remain open const int strikePin = 9; // Pin that actuates the relay for door strike const int slaveSelect = 10; // Pin used to enable the slave pin on MAX72xx char code[4]= {‘1’,’2’,’3’,’4’}; // Set your code here char codeBuffer[4]; // Stores the code that currently is being entered boolean DEBUG=true; // Set to true to print status messages to the serial port int keypressCount=0; // Counts how many times a key has been pressed


// The keyMap defines the character returned when its key is pressed const char keyMap[numRows][numCols] = { { ‘1’, ‘2’, ‘3’ }, { ‘4’, ‘5’, ‘6’ }, { ‘7’, ‘8’, ‘9’ }, { ‘*’, ‘0’, ‘#’ } }; const int rowPins[numRows] = { 7, 4, 2, 5 }; // Keypad Rows 0 through 3 const int colPins[numCols] = { 6, 8 ,3 }; // Keypad Columns 0 through 2

La variabile numberOfDigits imposta nel circuito integrato di controllo del display a LED il numero di cifre corrette. numRows e NumCols indicano il numero di righe e colonne del tastierino, rispettivamente 4 e 3. Le utilizzerete per determinare quale tasto è stato premuto. La variabile debounceTime (20 ms) garantisce che il tasto premuto venga rilevato con sicurezza. Tramite la variabile doorOpenTime impostate il tempo in cui la porta rimarrà aperta. Potete modificare questo valore fino a trovare quello più adatto. La variabile strikePin definisce quale pin digitale verrà attivato quando verrà immesso il codice corretto. Questo fa sì che al relé venga applicata alimentazione e il relé si chiuderà per attivare la serratura. slaveSelect definisce il pin digitale utilizzato per indicare che si stanno inviando dati. Il piedino slave select (SS) o chip select è un piedino di comando del circuito integrato che connette i piedini esterni ai circuiti interni.

Nelle applicazioni in cui vi sono più driver per LED tutti connessi agli input, volete essere in grado di selezionare se attivare o meno un determinato circuito integrato di controllo. Il circuito integrato risponde ai comandi solo quando il suo piedino slave select viene attivato; questo consente di distinguere fra questo driver e gli altri che utilizzate. In questo progetto utilizzeremo un unico circuito integrato, ma occorre comunque far sapere al chip quando dobbiamo inviargli dei dati; questo è lo scopo del pin SS. Vengono impiegate due variabili char per la gestione del codice d’accesso. La prima, code[], memorizza le cifre del codice d’accesso. Potete impostarla come preferite. La seconda, codeBuffer[], memorizza in un buffer i tasti premuti. Se i due valori coincidono, tutto a posto: l’Arduino può attivare strikePin. Non è previsto alcun modo per impostare il codice di sicurezza dal tastierino, solo da programma. Ma quando comprenderete come funziona il codice, potrete creare con facilità una sequenza di tasti segreta che vi consentirà di memorizzare un nuovo codice d’accesso direttamente dal tastierino. Questo programma offre anche una comoda funzionalità di debug. Questo è il motivo per cui è stata prevista la variabile successiva: una variabile boolean chiamata DEBUG. Le variabili booleane possono contenere solo un valore vero (true) o falso (false). Potete utilizzare un’istruzione condizionale if per eseguire determinate righe di codice solo se la variabile è impostata a true. Per esempio, in questo codice inviate molte variabili sulla porta seriale per verificare che il tastierino funzioni correttamente. Ma una volta che il sistema è installato sulla porta, non dovrete più verificare nulla. Invece di cancellare a mano tutte queste istruzioni Serial.println(), potete semplicemente impostare a false la variabile DEBUG. Quando l’istruzione viene valutata a false, il codice contenuto fra le parentesi graffe condizionali non verrà eseguito. La variabile keypressCount conserva il numero di cifre che sono state digitate finora. L’azione si svolge solo dopo che sono state premute quattro cifre. La variabile keyMap[][] è un array bidimensionale di char. Un array bidimensionale è semplicemente un array di array. Immaginate il menu di un ristorante particolarmente fornito. Potreste avere decine di prelibatezze fra cui scegliere: antipasti, zuppe, pizze, lasagne, insalate, vini e così via. Potete elencare il tutto alla rinfusa in un unico array, ma potete anche organizzarli per tipo: antipasti (stuzzichini, zuppa), primi (pizza, lasagna, pasta), bevande (acqua, vino rosso, vino bianco). In questo modo potete far riferimento agli elementi singolarmente oppure a gruppi. Un array monodimensionale, come l’array code[], memorizza gli elementi (i singoli valori) nel seguente modo: Int unArray[] = { 0,1,2,3 };


Un array bidimensionale memorizza gli elementi nel seguente modo: Int unArray[][] = { {0,1,2,3}, {3,2,3,0}, {4,3,8,1}, {2,3,4,5} };

Quando leggete un array bidimensionale, il primo valore fra le parentesi quadre specifica quale elemento volete leggere. Il secondo valore specifica un sottoelemento all’interno dell’elemento che avete specificato. Ricordate che negli array, il sistema di numerazione inizia sempre da 0. Dunque, per esempio, nell’array bidimensionale precedente, unArray[2][0] contiene il valore 4. keyMap è utilizzato semplicemente per memorizzare le cifre che vi sono sul tastierino. È letteralmente

una mappa di tasti.

Considerate questo fatto: la scheda Arduino non sa quale numero si trova in ogni singola posizione del tastierino. Non ha modo di sapere che sul tasto in alto a sinistra è stampigliato il numero 1: la scheda Arduino non ha alcun indizio per conoscere il significato di ogni singola chiusura di contatti. Quando viene premuto un tasto, utilizzate keyMap per identificare quale numero si trova in quella posizione e così potete confrontarlo con il codice predeterminato. Le ultime due variabili sono array che memorizzano a quali pin digitali della scheda Arduino sono collegate le righe e le colonne del tastierino. Questo è il codice che implementa il contenuto della Tabella 8.2.

La sezione setup Nella sezione setup() del codice, dovete preparare Arduino a eseguire questo sketch. Innanzitutto si configura il chip Max Display Driver. La funzione sendCommand(), verso la fine del codice, semplifica un po’ l’invio di istruzioni al chip, utilizzando l’interfaccia SPI. Ogni volta che inviate un’istruzione, dovete impostare a LOW il pin SlaveSelect, inviare al chip il byte corrispondente al comando che volete eseguire, poi inviare il byte con il valore per il comando e infine riportare SlaveSelect a HIGH. Non è il caso di ripetere questa sequenza ogni volta che dovete comunicare con il chip Max e dunque la funzione sendCommand() raggruppa questa sequenza LOW, comando, valore, HIGH, per renderla più comoda: void sendCommand(int command, unsigned char value) { digitalWrite(slaveSelect,LOW); SPI.transfer(command) SPI.transfer(value); digitalWrite(slaveSelect,HIGH); }

Si deve solamente inviare alla funzione il codice di comando desiderato e il relativo valore. Per esempio, il comando 10 controlla la luminosità. La seguente riga imposta la luminosità al livello 8 (su 15): sendCommand(10, 8);

Poi si imposta il chip alla modalità normale (pronto per visualizzare qualcosa), si disattiva la sua funzionalità di test, si imposta la luminosità al livello intermedio e si dice quante cifre vi sono sul display (4). Quindi si imposta il chip in modalità di decodifica. Questo significa che decodificherà automaticamente il byte inviato e accenderà i segmenti corrispondenti dei LED: i numeri da 0 a 9, i caratteri H, E, L, P, il trattino “–” e lo spazio (se voleste accendere i singoli segmenti a LED, dovreste impostare il display in modalità di non-decodifica). Quindi si deve configurare il pin che controlla il relé che alimenta la serratura. Deve essere impostato in output. Occorre anche configurare i pin che verranno utilizzati per la lettura del tastierino. Si utilizza una


particolare tecnica, che spiegheremo nella prossima sezione di codice e che sfrutta il vantaggio delle resistenze di “pull-up” che si trovano sull’Arduino. Queste resistenze sono sul chip ATmega328 stesso e possono essere configurate in modo da mantenere un pin HIGH. Successivamente, se dovesse andare LOW per qualche motivo (la pressione di un tasto), Arduino può rispondere in modo appropriato. Si impostano tutte le righe per l’input e si portano questi pin HIGH, per attivare le resistenze pull-up. Quindi si impostano tutte le colonne per l’output. Per il momento portiamo tutti questi pin su HIGH; penseremo successivamente a cambiarli. L’ultima operazione da fare consiste nel cancellare il display. Talvolta, quando si accede al sistema (specialmente quando si carica il codice), sul display possono comparire caratteri spuri. La funzione clearDisplay(), in fondo al codice, azzera tutte le cifre in modo che risultino vuote: void clearDisplay(){ sendCommand(1, ‘_’); sendCommand(2, ‘_’); sendCommand(3, ‘_’); sendCommand(4, ‘_’); }

Esecuzione del ciclo principale Il ciclo principale esegue solo poche operazioni per gestire l’inserimento del codice. Il ciclo principale si comporta nel seguente modo. 1. Resta in ascolto di un tasto. 2. Se è stato premuto un tasto, lo invia al display. 3. Incrementa di un’unità il numero di pressioni di tasti. 4. Inserisce il numero in un buffer, nella prima posizione disponibile. 5. Determina se sono state inserite quattro cifre. In questo caso verifica che il codice sia valido. 6. Se il codice è valido, apre la porta e riazzera tutto per la prossima occasione. La cosa principale da fare è controllare se è stato premuto un tasto. La prima istruzione crea la variabile locale key di tipo char per memorizzare il carattere restituito dalla funzione getKey(), che vedremo fra breve. Vi ricordate di keyMap? È da lì che proviene questo numero. Il valore char di key viene assegnato anche all’array codeBuffer[], che potete utilizzare per controllare se il codice è valido. Questo viene aggiunto alla posizione memorizzata da keypressCount, che viene incrementata ogni volta che viene rilevato un nuovo carattere. Ricordate che la numerazione di un array parte da Ø e dunque il primo carattere inserito andrà nella posizione “Øma”. Pertanto codeBuffer[0] contiene il primo tasto inserito, codeBuffer[1] contiene il secondo e così via. La successiva istruzione condizionale if viene eseguita solo quando è stato premuto un tasto, nel qual caso vengono eseguiti i passi da 2 a 6 dell’elenco precedente. Se non è stato premuto alcun tasto, il programma non fa altro che attendere l’inserimento. Quando viene premuto un tasto, viene eseguita la funzione sendCommand: sendCommand(keypressCount+1, key);

La funzione sendCommand accetta due parametri: quale cifra a sette segmenti impiegare e quale numero rappresentare. Si usa keypressCount non solo per registrare il numero di pressioni di tasti, ma anche per dire quale cifra a sette segmenti impiegare. Tuttavia, keypressCount parte da 0, poiché gli array di char code[] e buffer[] iniziano la numerazione da 0 e i valori devono essere memorizzati nella posizione corretta. Ma il chip Max inizia la numerazione delle cifre da 1, pertanto, per utilizzare keypressCount e accendere la cifra a sette segmenti corretta, occorre aggiungere al valore un’unità (+1) . L’istruzione successiva implementa quella comoda funzionalità di debugging di cui abbiamo parlato in precedenza. Se la variabile booleana DEBUG è true, il codice invia il contenuto di tutte le variabili alla porta seriale. Poi si incrementa keypressCount di un’unità e si verifica se sono stati inseriti quattro numeri. In caso affermativo succedono alcune cose. L’istruzione delay(500) introduce una pausa di mezzo secondo per consentire di osservare l’ultima cifra inserita, in quanto il contenuto del display cambierà a seconda del fatto che sia stato inserito il codice d’accesso valido. Questo testo viene eseguito con un


frammento di codice C: if (memcmp(codeBuffer, code,4)==0) { if(DEBUG){Serial.println(“MATCH!”);} unlock(); }

La funzione memcmp() confronta due elementi e accetta come parametri i due elementi e la loro lunghezza. In questo caso, si confronta l’array codeBuffer con il codice code memorizzato all’inizio del programma. Entrambi hanno una lunghezza di 4 byte. Se coincidono, la funzione memcmp() restituisce 0 e questo è esattamente ciò che occorre controllare nell’istruzione condizionale. Se coincidono (e DEBUG è true), sulla porta seriale viene inviata l’indicazione MATCH! e viene eseguita la funzione unlock(). Se il confronto non ha successo, la funzione non restituisce 0, ovvero è stato inserito il codice errato. In entrambi i casi, occorre cancellare il display, per prepararlo per il successivo inserimento. Pertanto si richiama la funzione clearDisplay(). Un’altra istruzione nativa del linguaggio C esegue una piccola operazione di gestione della memoria: memset(codeBuffer, 0, 4);

Questa istruzione ha lo scopo di cancellare esplicitamente codeBuffer impostandolo a 0. La sua lunghezza è 4, il secondo parametro. Qualcuno potrebbe pensare che questa istruzione non sia necessaria, ma è sempre opportuno gestire esplicitamente la memoria, invece di lasciare tutto al caso. Infine, poiché questa era la quarta pressione e occorre valutare solo quattro cifre, keypressCount deve essere riportata a 0, per prepararla alla successiva iterazione.

Le nuove funzioni La parte finale del codice contiene quattro funzioni che gestiscono l’identificazione del tasto premuto, l’invio di comandi al chip Max, la cancellazione del display e l’attivazione della serratura. La parte veramente interessante di questo codice è il modo in cui viene determinata la pressione dei tasti. Utilizza del codice sviluppato da Michael Margolis e tratto dal suo volume Arduino Cookbook (pubblicato da O’Reilly Media). Come ricorderete, i pin digitali delle righe sono stati portati a HIGH in setup(). Questo significa che la lettura di questi pin darà sempre HIGH, a meno che sia stato premuto un tasto che li ha portati a LOW (come la pressione di un tasto che connette i pin di una riga e di una colonna). La funzione getKey controlla tutti i pin digitali connessi ai piedini delle colonne del tastierino e imposta il pin per LOW. Quindi controlla se vi sono anche dei piedini delle righe impostati a LOW. Le resistenze pull-up utilizzate in setup() mantengono i piedini delle righe al livello HIGH, a meno che sia stato premuto un tasto, che attiva una connessione con una colonna LOW. Si introduce un breve ritardo di 20 ms che evita doppi inserimenti (eliminazione dei rimbalzi). L’istruzione while funziona solo mentre rimane verificata la sua condizione, in questo caso quando uno dei pin delle righe è diventato LOW a causa della pressione di un tasto. A questo punto, viene consultata keyMap per trovare il numero corrispondente a tale riga/colonna e questo viene memorizzato nella variabile key. Poi occorre svolgere alcune operazioni di gestione, riportando i pin di tutte le colonne a HIGH per il tasto successivo. Infine il valore del tasto viene restituito alla parte del programma che lo ha richiesto. Questo è tutto! L’unica operazione che rimane da fare, consiste nell’aprire la serratura della fortezza/castello/laboratorio. Se non l’avete già fatto, aggiungete l’ultima parte del codice. Nella funzione unlock(), le quattro istruzioni sendCommand() mostrano sul display il messaggio “HI”. È sempre preferibile ricevere un caldo benvenuto, anche se breve. Poi avviene il tutto. Sul pin strikePin viene inviato HIGH, che fornisce alimentazione al transistor che controlla il relé (lo aggiungerete nel prossimo paragrafo). Quando si attiva, l’alimentazione passa alla serratura per la durata specificata da doorOpenTime. Poi si imposta strikePin a LOW per tenere fuori dalla porta ogni intruso, spia o miscredente. Se non l’avete già fatto, caricate il codice sulla scheda Arduino e incrociate le dita. Quando premete un tasto, sul modulo a LED dovrebbe comparire il numero corrispondente. Aprite il Monitor seriale nell’ambiente di sviluppo di Arduino e osservate ciò che accade quando premete un tasto. Se tutto è connesso correttamente, dovreste vedere che i tasti vengono correttamente identificati e in codeBuffer[] vengono gradualmente inseriti i valori digitati. Se non vedete comparire le cifre sul modulo a LED, controllate le connessioni. Se non vedete i valori corretti nel Monitor seriale,


assicuratevi che non vi siano errori nel codice e che i valori di rowPins e colPins siano corretti. Se tutto è corretto, potete procedere, aggiungendo il relé e la serratura. Altrimenti non sarete in grado di collaudare il relé e il meccanismo di chiusura della porta. Per preparare la scheda Arduino per questo lavoro di “guardia di porta”, impostate DEBUG a false e caricate sulla scheda il codice un’ultima volta. Disconnettete anche il cavo USB, in quanto non ne avrete più bisogno. L’alimentazione verrà fornita direttamente dall’alimentatore.

Aggiunta e collaudo del relé Ora occorre aggiungere il relé che controlla la serratura e provvedere all’alimentazione del sistema. Utilizzeremo la stessa alimentazione che impieghiamo per Arduino, poiché non la riceveremo più dalla connessione USB. Seguite il layout sulla breadboard rappresentato nella Figura 8.6 ed eseguite le connessioni. Non inserite ancora l’alimentatore nella presa di corrente finché non sarete pronti per accendere e collaudare il sistema.

Connessione dell’alimentatore Configurate la breadboard con due linee di alimentazione: una linea 12 V CC in alto per la scheda Arduino e la serratura e una linea 5 V CC in basso per il Max 72xx. Innanzitutto connettete i fili di uscita dell’alimentatore 12 V CC alle due colonne in alto della breadboard. Probabilmente dovrete tagliare e spelare i fili in uscita dall’alimentatore. Poi saldate ai fili elettrici dei piedini per semplificarne la connessione alla breadboard.

Utilizzate un tester per controllare l’uscita dell’alimentatore, in modo da identificare il polo positivo e quello negativo. Non fidatevi troppo dell’indicazione riportata sull’alimentatore o dei segni sui fili. Se doveste invertire la polarità, potreste bruciare la scheda Arduino. A questo punto potete fornire l’alimentazione alla scheda Arduino. Utilizzate i pin Vin e GND che si trovano nella sezione POWER, nella fila di pin in basso della scheda, invece della porta USB o del connettore nero che si trova sul lato sinistro. Utilizzate dei ponticelli per connettere la linea 12 V al pin Vin e la linea di terra a GND. L’ultimo passo consiste nel creare una terra comune fra le due linee di alimentazione. Utilizzate un ponticello per connettere sulla breadboard il negativo della linea 12 V CC al negativo della linea 5 V CC.

Connessione del transistor e del relé Occorre energia anche per attivare il relé da 5 V. Utilizzate un ponticello per connettere il pin 5 V dell’Arduino al positivo 5 V della breadboard. Come potete vedere nella Figura 8.6, il relé non fa altro che controllare l’alimentazione della serratura; quando la riceve, la porta si apre. La serratura richiede circa 400 mA per funzionare, che è pari a circa dieci volte la quantità di corrente che i pin digitali di Arduino sono in grado di fornire. La commutazione della corrente è uno dei compiti più semplici e comuni per un circuito elettronico e pertanto esistono molti modi per controllare l’alimentazione. In questo progetto si usa un pin digitale di Arduino per applicare energia a un transistor (anch’esso è un commutatore a stato solido) il quale attiva il relé. La Figura 8.7 mostra un transistor come quello presente nell’elenco dei componenti. Il transistor ha tre piedini: un emettitore, una base e un collettore, rispettivamente E, B e C. La corrente passa fra il collettore e l’emettitore solo quando alla base viene applicata la corrente in arrivo da un pin digitale.


Figura 8.7 Connessioni nel transistor 2N2222.

La corrente in uscita dal collettore attiva il relé, chiudendo i contatti e consentendo alla corrente in arrivo dall’alimentatore di attivare la serratura. In pratica avete un commutatore digitale (il pin di Arduino) che controlla un altro commutatore digitale (il transistor) che a sua volta controlla un commutatore elettromeccanico, il quale attiva la serratura! È anche possibile utilizzare direttamente un transistor di potenza per controllare la serratura (eliminando completamente il relé), ma il transistor 2N2222 è più economico ed è facile procurarselo. In più vi sono molte applicazioni in cui è comodo impiegare un controllo a relé, specialmente quando si vuole isolare elettricamente il circuito controllato da Arduino (per controllare l’elettricità della rete domestica, per fare un esempio). Sarà facile adattare questa parte del progetto anche ad altre applicazioni. Aggiungete alla breadboard il relé, il diodo e il transistor, come illustrato nella Figura 8.6. Assicuratevi che il transistor abbia l’orientamento corretto. L’emettitore deve essere connesso a terra. Aggiungete la resistenza da 2,2 kΩ come indicato. Ciò evita che troppa corrente scorra verso la base del transistor. Connettete il collettore al relé e connettete il pin 9 di Arduino alla base del transistor. A questo punto ricontrollate tutte le connessioni, dedicando particolare attenzione alle polarità positiva e negativa. È noioso, ma alimentando il circuito in modo errato potreste danneggiare l’hardware. Dopo aver controllato le connessioni, alimentate il circuito. Una volta che Arduino si accende, siete pronti per partire. Inserite il codice col tastierino per verificare il funzionamento del relé. Probabilmente sentirete un piccolo clic nel momento in cui la bobina del relé riceve energia. Aggiungete dei ponticelli ai piedini di output del relé e connettetevi le punte del tester. Quando inserite il codice corretto, il tester dovrebbe rilevare la connessione. Il passo finale consiste nel connettere i due fili elettrici della serratura da un lato alla linea di terra e dall’altro all’uscita del relé. Provate a farlo e inserite nuovamente il codice di accesso. Se tutto funziona correttamente, otterrete un “clic” ben più udibile, in quanto Arduino avrà compiuto il suo dovere e avrà aperto la serratura.

Assemblaggio e installazione del sistema Lo schema dei componenti di questo capitolo (Figura 8.6) mostra una breadboard di dimensioni intere, e semplifica la realizzazione del prototipo. Ma per trasferire il circuito in un contenitore, è meglio impiegare una mezza breadboard, che occupa meno spazio e può essere ospitata, insieme al driver Max72xx, al transistor e al circuito del relé nel contenitore rappresentato nella Figura 8.8. Il display a LED e il tastierino possono essere collocati sul pannello frontale del contenitore e dunque non occuperanno più spazio sulla breadboard. Alternativamente, potete trasferire il circuito su una piccola stripboard e saldare i componenti fra loro, in modo da ottenere un progetto più solido e definitivo.


Figura 8.8 Installazione degli elementi nel contenitore.

Indipendentemente dal fatto che teniate il progetto su una breadboard o lo trasferiate su una basetta millefori (stripboard o perfboard), l’impiego di cavi a nastro semplifica moltissimo le connessioni fra il circuito integrato: il contenitore non finirà per diventare un groviglio di fili. Se utilizzate una breadboard, collegate dei connettori a pettine al cavo a nastro per garantire una solida connessione, come illustrato nella Figura 8.9. Se utilizzate una stripboard, potete saldare il cavo a nastro direttamente sulla scheda. Una goccia di colla a caldo applicata nel punto in cui il cavo a nastro raggiunge la basetta renderà il tutto più solido, in modo che non possiate danneggiare le saldature durante l’installazione. Potete anche utilizzare della colla a caldo per fissare il display, la scheda Arduino, il tastierino e il circuito. Per una finitura professionale, utilizzate un contenitore dotato di incavi, utili per fissare la scheda Arduino, la basetta e il tastierino. Tuttavia scegliere un contenitore per i componenti può essere problematico e molti contenitori possono essere costosi. A volte una goccia di colla a caldo risolve economicamente tanti piccoli problemi.

Figura 8.9 Uso di un cavo a nastro e di un connettore a pettine per semplificare il cablaggio.

Se utilizzate una basetta stripboard per montare il circuito integrato di pilotaggio dei LED, le piste di rame sul lato inferiore collegheranno elettricamente fra loro i pin dell’integrato, e non è esattamente ciò che vogliamo. Per evitarlo, utilizzate un coltello X-ACTO o uno strumento per il taglio delle piste di stripboard (Rapid #34-0600), come indicato nella Figura 8.10. Potete anche impiegare una punta da trapano da 3 millimetri.


Figura 8.10 Saldatura del circuito integrato su stripboard. Ricordatevi di tagliare le piste sotto il circuito integrato.

Dovete stendere il cavo di alimentazione dalla presa a parete al contenitore e poi dal contenitore e alla serratura o comunque al meccanismo attuatore, come illustrato nella Figura 8.11. Potete aver bisogno di un trapano per praticare un foro tra lâ&#x20AC;&#x2122;interno e lâ&#x20AC;&#x2122;esterno. Come farlo dipende dal tipo di porta che dovete mettere sicurezza. Si tratta di una porta interna o della porta di casa? Dovete forare mattoni pieni o forati? In base alla situazione dovrete determinare come montare il contenitore e stendere i cavi.

Figura 8.11 Percorso dei cavi di alimentazione per la scatola di controllo e la serratura.

Il cavo di alimentazione passa attraverso fori praticati sul contenitore e dovrete fissarlo per assicurarvi che non venga strappato o trasferisca ogni trazione ai componenti interni. Potete utilizzare un sistema apposito di bloccaggio interno o potete crearne uno fissando una fascetta ai cavi allâ&#x20AC;&#x2122;interno del contenitore, come rappresentato nella Figura 8.12. In tal modo si ottiene una tenuta efficace ed estremamente economica. Una goccia di colla a caldo che la fissi al pannello interno del contenitore impedirĂ poi al cavo di spostarsi.


Figura 8.12 Fissaggio dei cavi con una fascetta.

Non rimane che installare la serratura elettronica alla porta. Probabilmente dovrete utilizzare degli utensili da legno per sagomare la porta e lo stipite in modo da ospitare la serratura elettronica. Rimuovete la serratura attuale per rivelare il vano sottostante. Tracciate sul legno il profilo del nuovo fermo e utilizzate un piccolo scalpello e un martello per togliere il legno in eccesso, come illustrato nella Figura 8.13. Dovete anche assicurarvi di avere abbastanza spazio nello stipite della porta per fissare la serratura. Lâ&#x20AC;&#x2122;ultima operazione consiste nel fissare la serratura allo stipite e collaudare il tutto. Assicuratevi che la porta si apra liberamente. Nella maggior parte dei modelli, potete regolare la profonditĂ di fissaggio della serratura.

Figura 8.13 Installazione della chiusura sulla porta.

Ora chiudete la porta per il test finale e, per sicurezza, chiudetevi fuori dalla porta e non dentro!


Capitolo 9

Un lettore di RFID In questo capitolo Come si usano i codici RFID Realizzazione di uno shield per RFID Programmazione di uno shield per RFID Connessione dello shield ad altri progetti tramite un relé

È

molto probabile che abbiate già sentito parlare di codici RFID (radio frequency ID) e che sappiate che vengono utilizzati per registrare il passaggio di pacchi e piccoli oggetti inanimati. Ma possono essere impiegati anche per identificare oggetti animati, come animali domestici, bestiame e perfino persone! Oltre che per applicazioni come il controllo degli inventari e la sicurezza, la tecnologia RFID può anche essere un meccanismo pratico e semplice per gestire piccoli pagamenti e altre semplici transazioni. Potete far sì che la scheda Arduino legga le etichette (tag) RFID e si comporti sulla base del codice preimpostato su di esse. In questo capitolo scopriremo quali tipi di sistemi RFID esistono e come funzionano. Utilizzeremo la scheda Arduino per controllare un modulo di lettura di RFID e rispondere alle informazioni che fornisce quando un tag viene collocato in prossimità del lettore. Con le conoscenze acquisite, potrete collegare un RFID praticamente a tutto, compresi altri progetti del libro, come il sistema di accesso a tastierino che abbiamo realizzato nel Capitolo 8. In commercio si trovano vari tipi di lettori di RFID. Quale utilizzare dipende dai requisiti del progetto e da quanto intendete spendere. Per il progetto di questo capitolo ne useremo uno molto popolare e relativamente economico, in grado di leggere oggetti come RFID. Opera a una frequenza di 125 kHz e con un circuito relé di facile costruzione è in grado di controllare qualsiasi cosa, dalla serratura realizzata nel Capitolo 8 a un tostapane e molto altro ancora!

Potete scaricare gli schemi elettrici e gli schemi di collocazione delle parti a colori dal sito web del libro (www.hoeplieditore.it/6323-9)

Che cosa sono i codici RFID RFID è un sistema a radiofrequenze, come si può facilmente dedurre dal nome. Per certi versi è simile ad altri sistemi a radio frequenze, come la radio FM, ma opera a un intervallo di frequenza differente. A differenza dei sistemi di trasmissione radiofonica, con RFID i segnali radio vengono scambiati fra due oggetti, un lettore e un tag. Si tratta di una comunicazione bidirezionale che si può svolgere solo a una distanza molto più breve rispetto ai normali sistemi di trasmissione radiofonica. L’acronimo RFID può essere impiegato per indicare il lettore, il tag o entrambi. La distanza operativa di un sistema RFID dipende dal particolare standard di frequenze impiegato. Dipende poi dalle dimensioni dell’antenna e dalla potenza del segnale. Il lettore invia il segnale radio. Ogni tag RFID contiene un proprio codice univoco, che invia al lettore mentre si scambiano la sequenza corretta di comandi. Nei tag RFID possono essere memorizzate anche altre informazioni e alcuni sistemi supportano anche la scrittura oltre alla lettura dei tag, il che significa che con RFID è anche possibile svolgere semplici transazioni come il


pagamento del biglietto sui mezzi pubblici. Il tag è un circuito elettronico che normalmente è inglobato in un piccolo contenitore fisico, a seconda dell’applicazione per cui viene impiegato. La Figura 9.1 ne mostra alcuni esempi. Per gli accessi di sicurezza, il circuito viene inserito in tessere che hanno le stesse dimensioni delle carte di credito e che sono facili da trasportare nel portafogli o in borsetta.

Figura 9.1 Esempi di tag RFID.

Ma i tag possono essere inclusi anche in portachiavi ed etichette autoadesive; la varietà è praticamente infinita. I sistemi più sottili ed economici vengono utilizzati per il controllo degli inventari. I sistemi più costosi e ingombranti vengono impiegati per applicazioni come il monitoraggio dei container e i sistemi di pagamento delle autostrade, come il ben noto Telepass. Esistono varie frequenze RFID, impiegate da due categorie di sistemi: RFID passivi e attivi. Il sistema descritto in questo capitolo è passivo.

Che cos’è un RFID passivo Un tag RFID passivo opera solo a distanze relativamente brevi, da pochi centimetri a circa un metro. Si chiama passivo poiché non fornisce alimentazione e può inviare informazioni solo quando entra nel campo elettromagnetico di un lettore. L’ingresso nel campo dà energia a un piccolo circuito radio ricetrasmettitore tramite una piccola antenna contenuta nel tag passivo; l’energia che ne trae è sufficiente per ricevere i segnali dal lettore e rispondervi. Poiché il campo è relativamente debole e l’energia indotta nel tag è molto scarsa, la distanza operativa è breve. Normalmente devono trovarsi a pochi centimetri dal lettore o al massimo, a un metro. I sistemi passivi sono generalmente più economici rispetto ai sistemi attivi. I tag passivi, poi, normalmente sono realizzati in modo da essere il più possibile economici, così da poter essere prodotti e venduti in grandi quantità e sono, in linea di massima, sacrificabili. I lettori a lungo raggio, in grado di rilevare i tag fino a più di un metro di distanza, possono costare migliaia di euro. I sistemi di questo capitolo sono a breve raggio (solo pochi centimetri) e costano meno di 40 euro.

I sistemi RFID passivi non devono essere confusi con i sistemi EAS (Electromagnetic Article Surveillance) utilizzati per assicurarsi che gli articoli più costosi dei grandi magazzini non vengano rubati. In questi casi si tratta di sistemi acustico-magnetici, a microonde o, in alcuni casi, a radiofrequenza, che non contengono alcun meccanismo di identificazione.

I RFID attivi I sistemi RFID attivi impiegano un lettore alimentato e anche un tag alimentato. Quando il tag riceve


un messaggio dal lettore, risponde con le informazioni che vi sono codificate. Questi sistemi sono più costosi, ma anche più precisi e veloci. Possono leggere i tag a una distanza superiore rispetto ai sistemi passivi. C’è bisogno di queste funzionalità solo se occorre prelevare denaro da un conto corrente mentre il titolare si sposta anche a una certa velocità. Tuttavia, dato il costo più elevato, risulta poco pratico utilizzare questi sistemi per applicazioni semplici, come il sistema di controllo degli accessi descritto in questo capitolo.

Frequenza e protocolli RFID I sistemi passivi possono operare a basse o alte frequenze. Due fra i più comuni che descriveremo in questo capitolo sono quelli a bassa frequenza (125 kHz) e ad alta frequenza (13,56 MHz). I sistemi ad alta frequenza sono più veloci in fase di lettura e scrittura. Offrono anche una portata maggiore, ma costano leggermente di più. Oltre a impiegare frequenze differenti, impiegano anche protocolli di comunicazione differenti, ovvero le regole di conversazione utilizzate fra il lettore e il tag e che governano il modo in cui essi comunicano. Questi standard sono definiti dall’ISO (International Standards Organization), anche se produttori differenti implementano standard ISO differenti nei propri prodotti. Il lettore utilizzato in questo capitolo è un chip a 125 KHz ID-Innovations e un sistema a tag che utilizza il protocollo EM4001. Il lettore è facile da utilizzare e molto economico. Addirittura perfino l’antenna è contenuta direttamente nel chip. Il sistema ad alta frequenza è il 13,56MHz Philips MiFare/MiFare UltraLight, il quale utilizza lo standard ISO 14443 ed è un po’ più costoso. Questo sistema è utilizzato da molti apparecchi di controllo dei passaggi e dunque con questo sistema potreste riuscire a leggere un pass di transito. SparkFun vende un comodissimo Arduino basato sul lettore SonMicro SM130. Offre un’antenna esterna inclusa nello stesso shield. Basta saldargli il lettore e avviare la scansione. Offre anche una piccola area di prototyping nella quale potete aggiungere altri componenti, come un relé.

Non tutti i lettori e i tag operano con le stesse frequenze o protocolli. Nell’acquisto di un sistema RFID, assicuratevi che il lettore e il tag RFID siano dello stesso tipo, altrimenti il sistema non funzionerà affatto.

Realizzazione di un lettore RFID ID-Innovations Questo progetto usa il chip ID-Innovations ID-20, estremamente facile da utilizzare, in quanto già dotato di una propria antenna interna. Potete realizzare il circuito sulla breadboard e poi trasferirlo su una basetta millefori da fissare all’Arduino se volete dargli un assetto più permanente.

I componenti I componenti necessari per costruire il lettore sono rappresentati nella Figura 9.2. Questo elenco comprende solo i componenti del lettore, ma, naturalmente, avrete anche bisogno di uno o più tag da leggere. Potete scegliere fra centinaia di tag RFID. Il portachiavi RFID a 125 kHz rappresentato nella Figura 9.1 è perfetto per questo genere di utilizzi.


Figura 9.2 I componenti necessari per realizzare il lettore RFID.

Il relé è utile per attivare e disattivare un dispositivo. È opzionale, ma è necessario per controllare l’attivazione di qualcosa al passaggio del tag RFID. Avrete bisogno dei seguenti componenti. Una scheda Arduino. Una breadboard piccola o grande. Un modulo RFID ID Innovations 12 o ID Innovations 20 (SparkFun SEN-08628 / Cool Components #000155). Una scheda breakout SparkFun SEN-08243 (SparkFun SEN-08423 / Cool Components #000108). 11 connettori lunghi a pettine. Un LED. Una resistenza da 220 Ω. Un assortimento di ponticelli. Un relé miniaturizzato Dual In-Line (DIL) (Jameco #138431 o Rapid #60-2400). Un tag RFID da 125 kHz, come il portachiavi rappresentato nella Figura 9.1 (Cool Components #000648). SparkFun vende un tag con l’aspetto e le dimensioni di una carta di credito (SparkFun #COM-08310). ID Innovations offre vari lettori RFID da 125 kHz; i modelli ID-12 e ID-20 contengono una propria antenna interna e, secondo le specifiche, sono in grado di leggere tag rispettivamente a 12 e a 16 cm di distanza. Tuttavia per raggiungere questa portata occorre realizzare un circuito a condensatore.

L’ottimizzazione per ottenere una portata ottimale dovrebbe essere svolta tramite un oscilloscopio, uno strumento che non tutti avranno a disposizione. Tuttavia è anche possibile tralasciare il circuito di ottimizzazione e leggere comunque i tag a qualche centimetro di distanza. Questo è il motivo per cui il circuito di ottimizzazione non verrà impiegato in questo progetto. Se però puntate al massimo, il circuito di ottimizzazione è descritto nel datasheet ID Innovations per questa serie di chip. Il LED funge da indicatore, per confermare che il tag è stato letto. La resistenza da 220 Ω limita la corrente in arrivo al LED. La scheda breakout SparkFun consente di collocare il chip del lettore sulla breadboard e può


ospitare uno qualsiasi dei lettori ID Innovations (anche se riporta l’indicazione ID-12). I loro piedini hanno un passo di 2 mm e dunque non sono adatti alla collocazione su una breadboard, i cui fori sono spaziati di 2,54 mm, e dunque dovrete utilizzare la scheda breakout per realizzare il prototipo. In realtà, anche se non prevedete di utilizzare una breadboard, la scheda breakout è comoda, poiché i piedini posti a una distanza di due mm sono piuttosto scomodi. La scheda breakout è inoltre predisposta per ospitare il lettore RFID solo con l’orientamento corretto. Uno dei pin del lettore non c’è, e la scheda breakout si allinea proprio con questo piedino mancante, come si può vedere nella Figura 9.3.

Figura 9.3 La scheda SparkFun è predisposta per ospitare i lettori ID Innovations.

Per utilizzare la scheda SparkFun, occorrono anche dei connettori a pettine di tipo normale o lungo; meglio i secondi, in quanto sulla breadboard, il lettore si sovrappone ai ponticelli, rendendo più difficoltoso il controllo delle connessioni e, soprattutto, a seconda del tipo di ponticelli che utilizzate) si possono produrre falsi contatti che provocherebbero il malfunzionamento del sensore. Connettete i piedini alla scheda breakout in modo da poterla fissare alla breadboard. Potete anche saldare dei fili direttamente sulla scheda breakout se pensate di collocare il lettore a qualche distanza dalla scheda Arduino. Il relé è un componente estremamente comodo chiamato relé Reed, in configurazione DIL (Dual InLine), e può essere collocato perfettamente sulla breadboard. Il relé ha una propria bobina interna, il che significa che potete connetterlo direttamente a un pin digitale della scheda Arduino. Con questo relé potete controllare qualsiasi altro progetto del libro.

Questo relé Reed può eseguire commutazioni solo fino a 100 V CC con una corrente massima di 1 A. Non connettetelo a un circuito elettrico in corrente alternata, come la rete domestica. Per farlo, dovrete utilizzare un relé più grosso oppure un transistor di potenza.

Assemblaggio del lettore RFID Una volta che vi sarete procurati tutti i componenti, sarete pronti per assemblare il lettore. Innanzitutto dovete costruire la scheda breakout e poi connetterla al lettore RFID. Poi potrete aggiungere l’intero lettore alla breadboard e completare il tutto con i componenti aggiuntivi.

Adattare il lettore alla breadboard Ecco i passi necessari per costruire la scheda breakout.


1. Rompete da un connettore a pettine un gruppo di cinque contatti e un gruppo di sei, che andranno nei fori della scheda breakout SparkFun. 2. Inserite i piedini nella breadboard in modo da potervi poggiare sopra la scheda breakout, come illustrato nella Figura 9.3. Questa precauzione aiuta a mantenere i piedini fissi mentre li saldate sulla scheda breakout. È una tecnica molto comoda per saldare i piedini, in caso di necessità (Figura 9.4).

Figura 9.4 Potete usare la breadboard per trattenere i pin.

3. Poggiate la scheda sui piedini, con il logo SparkFun rivolto verso l’alto. Dovete assicurarvi che i piedini siano puntati correttamente o non riuscirete ad aggiungere il lettore RFID. Fate attenzione a saldare i piedini alla scheda breakout con il logo SparkFun rivolto verso l’alto!

4. Saldate attentamente le due file di piedini, come illustrato nella Figura 9.5.

Figura 9.5 Saldatura dei piedini sulla scheda breakout con il logo SparkFun rivolto verso l’alto.


5. Rimuovete la scheda breakout dalla breadboard. Inserite con cautela il lettore RFID sulla scheda breakout cui avete appena fissato i connettori a pettine, come illustrato nella Figura 9.6. Potrete collocarla solo con l’orientamento corretto. Dedicate particolare attenzione al fatto che la scheda breakout sia solida e allineata con il lettore o non si posizionerà correttamente sulla breadboard: avrà un aspetto un po’ strano. 6. Saldate con attenzione la scheda breakout sul lettore.

Dovete lavorare con attenzione, ma rapidamente quando saldate un circuito integrato. I piedini possono sopportare una determinata quantità di calore durante la saldatura, ma indugiando troppo a lungo su un piedino potreste danneggiare il lettore. Se lavorate troppo lentamente, attendete qualche istante fra un piedino e l’altro, in modo da non accumulare calore durante l’operazione. Non abbiate fretta. Saldate con cura il lettore alla scheda breakout, come illustrato nella Figura 9.7. Il circuito integrato del lettore RFID non ha alcuna intenzione di scappare!

Figura 9.6 Inserimento del lettore sulla scheda breakout.

Figura 9.7 Saldatura dei piedini del lettore RFID.


Realizzazione del circuito Ora che il lettore è pronto, potete completare la parte rimanente del circuito. Lo schema elettrico rappresentato nella Figura 9.8 mostra come deve essere connesso il lettore. Si tratta di connessioni piuttosto semplici, che richiedono solo quattro fili di connessione con la scheda Arduino. Il resto delle connessioni va al LED e al relé. Lo schema di montaggio rappresentato nella Figura 9.9 mostra come collegare il tutto alla breadboard. Notate i due fili in uscita nella parte superiore. Qui potete collegare “qualcosa” al relé, in modo da poterlo accendere e spegnere. Il circuito del relé è opzionale, naturalmente. Per iniziare, potete utilizzare semplicemente un indicatore a LED. Potrete comunque aggiungere il relé in un secondo tempo.

Figura 9.8 Schema elettrico del lettore RFID.


Figura 9.9 Schema di montaggio dei componenti sulla breadboard.

Programmazione del lettore RFID Dopo aver realizzato il circuito sulla breadboard, potete caricare sulla scheda Arduino il codice (lo scaricate dal sito web www.hoeplieditore.it/6323-9). Dategli un’occhiata prima di caricarlo sulla scheda Arduino. Occorre configurarlo con il tag RFID corretto prima che possa attivare il LED e il relé. La maggior parte dei tag RFID non riporta alcuna indicazione del proprio ID univoco. Fortunatamente, potete utilizzare il Monitor seriale per conoscere l’ID codificato sul tag. Date un’occhiata al codice per scoprire come estrarre i codici dai tag prima di caricare lo sketch sulla scheda Arduino ed eseguire un test del lettore.

Le dichiarazioni di variabili Si parte con le quattro variabili seguenti: const int relayPin = 11; const int ledPin = 12; const int RFIDResetPin = 13; const int relayOntime = 5000;

Si tratta di quattro costanti intere che contengono valori che non cambiano nel corso del programma (infatti sono “costanti”). Per questo progetto utilizzerete tre pin digitali della scheda Arduino. Due controllano, rispettivamente, l’output verso il LED e il relé. Il terzo è il pin di reset. Il lettore non esegue un reset automatico prima di leggere il tag successivo e dunque dovete comunicargli esplicitamente che siete pronti per farlo, inviandogli un segnale di reset su questo pin. Basta commutarlo da HIGH a LOW. L’ultima costante dice per quanto tempo si vuole attivare il relé, una volta che viene rilevato il tag. Poi si aggiungono alcuni array di char che conservano i numeri di ID: char tag1[13] = “3B00DDBF9FB6”; // Your scanned tag ID goes here char tag2[13] = “010203AABBCC”; // these are example Iag IDs only char tag3[13] = “020304BBCCDD”; // these are example Iag IDs only // etc. for more tags ….

Qui vengono presentati tre tag di esempio, ma dovrete aggiungere quelli che avete, l’unico limite è la memoria disponibile nella scheda Arduino. I tag sono costituiti da 13 byte. I dati sono costituiti da 12 valori, più un carattere di fine riga (che negli array di char occupa normalmente l’ultimo carattere).

I codici ID sono conservati come numeri esadecimali, non come normali numeri decimali compresi fra 0 e 9. I numeri esadecimali comprendono anche i valori da 10 a 15, corrispondenti alle lettere da 4 a F. Dunque ogni cifra dell’ID rappresenta un numero compreso fra 0 e 15 (in termini decimali) o fra 0 e F (in termini esadecimali). Notate che questi codici sono unicamente esempi. Dovrete sostituirli con i vostri ID che, probabilmente, ancora non conoscete. Questo è il motivo per cui il codice comprende un modo per risalire ai codici presenti nei tag. Tuttavia, non è possibile eliminarli completamente. Dovete specificare almeno un array di caratteri, poiché il codice del programma si aspetta di trovare qualcosa da confrontare con ogni nuovo tag che incontra. Lasciate dunque questi codici al loro posto, anche se non conoscete ancora i codici dei vostri tag. Potrete sostituire i valori dei vostri tag in un secondo tempo.

Setup Ora siete pronti per configurare l’ambiente di esecuzione di Arduino per la lettura dei tag. Date un’occhiata alla parte successiva del codice. Dovrebbe essere abbastanza familiare se avete già svolto i progetti presentati in questo libro:


void setup(){ Serial.begin(9600); pinMode(RFIDResetPin, OUTPUT); pinMode(ledPin, OUTPUT); pinMode(relayPin, OUTPUT); digitalWrite(RFIDResetPin, HIGH); Serial.println(“Ready.”); }

La prima riga configura una porta seriale per la comunicazione con il computer a 9600 bps (attraverso la porta USB). Sia il computer sia il lettore RFID comunicano con la scheda Arduino utilizzando un protocollo di comunicazione seriale. La porta seriale di Arduino è connessa alla porta USB e la stessa porta è condivisa con i pin digitali 0 e 1. Il pin 1 viene utilizzato per trasmettere le informazioni e il pin 0 per riceverle. Questo è il motivo per cui sulla scheda sono identificati, rispettivamente come TX e RX . Avete connesso il lettore al pin 0 in modo che Arduino potesse anche ricevere informazioni dal lettore sul pin RX. Poiché condividete la connessione seriale con il computer e con il lettore RFID, dovrete utilizzare la stessa velocità sia per Arduino sia per il lettore di tag, che si aspetta di utilizzare una velocità di 9600 baud. Le tre istruzioni pinMode impostano per l’output il pin di reset del lettore, il pin del LED e il pin del relé. L’istruzione con il messaggio Ready conferma semplicemente che il tutto funzioni.

Il ciclo principale Ora siete pronti per fare “qualcosa”. Ecco il codice del ciclo principale: void loop(){ Serial.println(“Looking for a tag…”); char tagString[13]; int index = 0; boolean reading = false; while(Serial.available()){ int readByte = Serial.read(); if(readByte == 2) reading = true; if(readByte == 3) reading = false; if(reading && readByte != 2 && readByte != 10 && readByte != 13){ tagString[index] = readByte; index ++; } } checkTag(tagString); clearTag(tagString); resetReader(); }

Volete avere una conferma che tutto procede secondo i piani e il messaggio “Looking for a tag…” fornisce proprio questa conferma a ogni ciclo. Quindi create un array di char chiamato tagString[] che contiene i 13 byte di tutto ciò che il lettore rileva e li invia alla porta seriale. Scrivete su questo array ogni singolo byte, una posizione per volta. Per tener traccia del byte che state scrivendo nell’array, create una variabile int chiamata index. Ogni volta che scrivete un nuovo byte, la incrementate di 1. Il valore booleano reading registra il fatto che siete stati avvisati che vi è un nuovo tag da elaborare. Poi si trova un’istruzione while. Fintantoché la condizione specificata fra parentesi permane verificata, esiste una connessione valida dalla porta seriale e si stanno ricevendo dati; dunque viene eseguito ciò che si trova fra le parentesi graffe. Innanzitutto si crea una variabile locale per memorizzare il byte successivo, letto dalla porta seriale con il comando Serial.read(). Il lettore di tag invia innanzitutto il valore 2 se ha letto un tag. Altrimenti leggerete un 3. A seconda di questo valore impostate il valore booleano a true (se il valore è 2) o a false (se è 3). Qui si svolge tutta l’azione: if(reading && readByte != 2 && readByte != 10 && readByte != 13){ tagString[index] = readByte; index ++; }

Il segno && rappresenta l’operatore di AND logico e il segno != è un confronto di disuguaglianza logica. Questa riga dice che se è stato letto qualcosa (in quanto la variabile booleana reading è stata impostata a true, e il byte letto non è 2 e non è neppure 10 e non è neppure 13, occorre fare ciò che è racchiuso fra le parentesi graffe. I valori 2, 10 e 13 significano, rispettivamente, l’inizio, la fine e l’avanzamento di riga. Se il byte non è uno di questi, deve trattarsi dei dati del tag di cui abbiamo


bisogno. Dunque, nella riga successiva, memorizzate il valore di readByte nell’array tagstring[] alla posizione index. Occorre registrare questa posizione di index per ogni carattere letto. Il passo successivo consiste nell’incrementare il valore di index di 1 unità, in modo che il prossimo valore venga memorizzato nella prossima posizione dell’array.

Ricordate che la numerazione degli array parte da 0 e dunque l’indice del primo byte sarà 0, quello del secondo 1 e così via fino al byte 11. Dopo aver letto tutti i 12 byte dell’ID, ognuno dei byte letti avrà una propria posizione numerata nell’array tagString[] e potrete confrontare un elenco di tag validi. Vi sono tre passi finali nel ciclo principale che vengono svolti con tre funzioni definite dall’utente. Il ciclo principale termina poi con la parentesi graffa chiusa finale.

Funzioni definite dall’utente Questo programma impiega sei funzioni definite dall’utente, alcune delle quali vengono richiamate all’interno di altre funzioni. Può sembrare un po’ complicato saltare a una funzione da un’altra funzione in questo modo, ma questo assetto aiuta a rendere modulare il codice e rappresenta una buona pratica di programmazione. Dovreste far sì che le funzioni siano il più possibile modulari, in modo che, se dovrete cambiare il comportamento di una determinata funzione, dovrete modificarla in un solo posto: ogni volta che è richiesto l’impiego della funzione, questa si comporterà sempre allo stesso modo. La funzione checkTag() confronta ciò che si trova nell’array tagString[] con l’elenco dei tag validi. Questa funzione accetta come input un array di char. Questo viene specificato fra parentesi, definendo ciò che la funzione si aspetta di ricevere, in modo che possa valutarla. In questo caso, si tratta di un array di caratteri. Nel ciclo principale, con checkTag(tagString) passate alla funzione l’array di caratteri tagString, in modo che possa valutare ciò che si trova in tagString: void checkTag(char tag[]){ if(strlen(tag) == 0) return; if(compareTag(tag, tag1)){ lightLED(); triggerRelay(); } else if(compareTag(tag, tag2)){ lightLED(); } else if(compareTag(tag, tag3)){ lightLED(); } else { Serial.println(“New tag found: “); Serial.println(tag); delay(5000); } }

Se la lunghezza della stringa è pari a 0, significa che la stringa non contiene nulla. È improbabile che ciò accada, ma è meglio verificare questa condizione. Si controlla questa condizione con una funzione strlen(). Il valore (tag) è l’array di caratteri appena passato a questa funzione. Vi sono due segni == poiché questo test è una valutazione di uguaglianza. L’istruzione return esce completamente da questa funzione se nell’array non c’è nulla. La successiva istruzione if controlla se i dati passati a questa funzione corrispondono a uno dei tag che avete memorizzato. Utilizza una funzione definita dall’utente chiamata compareTag(), che accetta in input due array di caratteri. Funziona confrontando i due array: quello che avete appena letto e quello memorizzato all’inizio del programma, tag1. Entreremo nei dettagli del funzionamento più avanti in questo capitolo. Se il confronto è valido, avete trovato un tag noto. Così eseguite le funzioni lightLED() e triggerRelay() elencate nel successivo frammento di codice. Quindi ripetete questo test per ogni tag contenuto nella sezione di dichiarazione delle variabili che si trova in cima al programma: tag2, tag3 e così via. Potete aggiungere a questa sezione ogni nuovo


tag che volete accettare. Se nessuno di questi tag corrisponde, deve trattarsi di un tag nuovo e non conosciuto. In tal caso, è utile conoscerne il codice, in modo da poterlo inviare al Monitor seriale con l’istruzione Serial.prinln. Il ritardo dà cinque secondi per trascriverlo. Ora date un’occhiata al funzionamento di compareTag(). Si tratta di una funzione booleana e dunque restituisce un valore true o false sulla base del confronto che le chiedete di fare: boolean compareTag(char one[], char two[]){ if(strlen(one) == 0) return false; for(int i = 0; i < 12; i++){ if(one[i] != two[i]) return false; } Serial.println(“Valid tag found!”); return true; }

Questa funzione accetta come input due array di caratteri (quello che avete letto e uno tratto dall’elenco dei tag validi) e se trova una corrispondenza restituisce il valore true alla parte del programma che l’ha richiamata (la funzione checkTag()). Se la lunghezza della stringa è pari a 0, il contenuto è nullo, nel qual caso la funzione restituisce il valore false. Anche in questo caso è opportuno considerare anche situazioni insolite. Altrimenti, il ciclo for esamina ciascun carattere dei due array e li confronta. Se uno qualsiasi di questi caratteri è diverso dall’altro, allora i tag non corrispondono e il confronto ha come risultato false. Tuttavia, se tutti i caratteri vengono confrontati e considerati uguali, allora i due array sono uguali e la funzione restituisce true. Questa notizia viene inviata al Monitor seriale. Questo è il modo in cui si confrontano i due codici ID. La funzione lightLED() accende il pin digitale per il LED (ledPin), attende un quarto di secondo (250 ms) e poi lo spegne. In tal modo avrete una conferma che è stato correttamente letto un tag, anche quando Arduino non è più connesso a un computer: void lightLED(){ digitalWrite(ledPin, HIGH); delay(250); digitalWrite(ledPin, LOW); }

La funzione triggerRelay() funziona allo stesso modo, utilizzando però relayPin e mantiene il relé aperto per la durata specificata da relayOnTime nella dichiarazione delle variabili: void triggerRelay(){ digitalWrite(relayPin, HIGH); // Turn on the ledPin delay(relayOntime); // Wait a moment digitalWrite(relayPin, LOW); // Turn off the ledPin }

Poi si cancella l’array tagString[] in modo che possa essere eseguita la successiva lettura, utilizzando la funzione clearTag(). Si utilizza un ciclo for per attraversare ogni posizione index dell’array che le è stato passato (che è sempre tagString), e si imposta il valore di ogni posizione a Ø: void clearTag(char one[]){ // Clear the tag reading char array by filling it with ASCII 0 // If not null, it could indicate another tag read for(int i = 0; i < strlen(one); i++){ one[i] = 0; } }

Con questa funzione, cancellate l’ultimo tag letto dalla memoria. Infine la funzione resetReader() chiede di prepararsi per la successiva lettura, portando il pin di reset LOW e poi HIGH. Il ritardo garantisce che l’operazione venga eseguita correttamente, ma probabilmente non è necessario: void resetReader(){ // Toggle the reset pin so the RFID reader will read again digitalWrite(RFIDResetPin, LOW);


digitalWrite(RFIDResetPin, HIGH); delay(150); }

Collaudo e configurazione del lettore RFID Ora che avete realizzato il lettore e avete appreso il funzionamento del codice, la prima cosa che dovete fare è leggere il codice dei tag RFID di cui siete in possesso. Ricordate che il filo elettrico connesso al pin digitale 0 è connesso anche alla porta seriale USB. Se tentate di inviare del codice alla scheda Arduino mentre questo filo elettrico è connesso, otterrete degli errori, poiché il lettore di tag e la connessione USB scriveranno contemporaneamente sulla stessa porta seriale. Non volete che il lettore possa inviare dati spuri su questa connessione mentre state caricando uno sketch sulla scheda Arduino.

Per evitare problemi durante il caricamento del codice, disconnettete sempre il filo dal pin 0 prima di caricare il codice e riconnettetelo subito dopo aver ricevuto conferma del trasferimento. Se dimenticherete questa precauzione, non danneggerete nulla, ma probabilmente otterrete dei messaggi d’errore arancioni e dovrete riavviare la scheda Arduino, l’ambiente di sviluppo Arduino o entrambi. Dunque disconnettete quel contatto e poi caricate il programma sulla scheda Arduino. Poi riconnettete il filo e fate clic sull’icona del Monitor seriale nell’ambiente di sviluppo di Arduino. Passate il tag sopra il lettore ID Innovations, come illustrato nella Figura 9.10. Basta passare il tag a una distanza di tre o quattro centimetri dal lettore.

Figura 9.10 Prima scansione di un nuovo tag.

Poiché probabilmente non avrete ancora elencato questo tag nel codice, comparirà qualcosa come il contenuto della Figura 9.11. La finestra indica il codice del nuovo tag in numeri esadecimali. Trascrivete questo numero in modo da poterlo aggiungere come tag valido fra le dichiarazioni delle variabili. Leggete allo stesso modo tutti gli altri tag che volete memorizzare sul sistema. Dopo aver completato la scansione di tutti i tag da far conoscere al sistema, modificate gli array tag[]: char tag1[13] = “0123456789AB”;


Figura 9.11 Rilevamento del valore di un nuovo tag nel Monitor seriale.

Cambiate i numeri specificati fra i doppi apici, indicando il valore esadecimale dei tag. Deve trattarsi di 12 cifre. Occasionalmente possono esservi dei valori errati alla fine, ma ignorate queste situazioni. Procedete fino ad aggiungere nuovi array per ogni tag che volete far riconoscere.

Assicuratevi di aggiornare anche la funzione checkTag() alla fine del codice, in modo che controlli lo stesso numero di tag che avete memorizzato allâ&#x20AC;&#x2122;inizio del programma. Ora disconnettete il lettore di tag dal pin 0, caricate sulla scheda Arduino il nuovo codice e controllate che funzioni. Dovrebbe comparire qualcosa di simile a ciò che è rappresentato nella Figura 9.12. Anche il LED dovrebbe accendersi per un istante e il relĂŠ attivarsi. Per conferma, potete connettere il multimetro ai suoi fili per vedere se risultano connessi.

Figura 9.12 Lettura con successo di un tag valido.

Ora siete pronti per iniziare a utilizzare i tag per aprire, chiudere e attivare qualsiasi cosa.


Capitolo 10

Un terrazzo automatizzato In questo capitolo Realizzazione di un sensore di umidità del terreno Uso dei transistor di potenza Impiego di una valvola a solenoide Realizzazione del sistema di irrigazione

Q

uante delle vostre piante dovranno sacrificarsi prima che deciderete di aver bisogno di una mano? Personalmente, dopo aver avuto tre o quattro “caduti” in terrazzo, il senso di colpa ha preso il sopravvento. Quando anche l’ulivo bonsai di mia moglie si è seccato, ho dato sfogo a tutta la mia vena creativa. Una scheda Arduino è perfetta per attendere pazientemente (e di pazienza ne ha tanta) che accada qualcosa a cui rispondere in modo rapido e affidabile. Ho messo insieme questo sistema per impedire che altre piante raggiungessero prematuramente il grande Compost-Santo che sta nei Cieli. Anche se io e mia moglie vediamo quotidianamente le piante del terrazzo, talvolta dimentichiamo di annaffiarle. Ma il mio fidato Arduino sarà in grado di rendere felice il nuovo ulivo bonsai di mia moglie. Il fatto che Arduino pensi ad annaffiare le piante nel momento del bisogno può essere comodo anche quando dovete andare via per qualche giorno e non potete garantire che le piante possano essere annaffiate a dovere.

Potete scaricare gli schemi elettrici e i diagrammi a colori di collocazione dei componenti dal sito web del libro (www.hoeplieditore.it/6323-9).

Creazione di un sistema di annaffiatura In questo progetto, realizzeremo un sistema per annaffiare automaticamente le piante del terrazzo quando il terreno nei vasi diviene troppo secco. Per monitorare l’umidità del terreno, utilizzeremo materiali molto economici e disponibili ovunque, tramite i quali realizzeremo un semplice sensore fatto in casa in grado di misurare l’umidità del terreno (tramite variazioni di tensione). Questo sensore va inserito nel terreno di una pianta assetata. Potete calibrare questo sensore in modo che comunichi alla scheda Arduino quando annaffiare. L’acqua proviene da una riserva costituita da una bottiglia da due litri collocata sopra il vaso. Serve poi un piccolo tubo che dalla bottiglia conduca al vaso. Dovremo programmare la scheda Arduino in modo che, quando il sensore rileva che il terreno è troppo secco, apra una valvola a solenoide connessa al tubo per l’irrigazione. La bottiglia da due litri dovrebbe essere sufficiente per garantire il funzionamento dell’impianto per un po’ di tempo e potete riempire la riserva all’incirca ogni settimana, a seconda di quanto è assetata la pianta. Potete estendere questo sistema con facilità, in modo che monitorizzi più vasi e li annaffi in modo indipendente.


I componenti La Figura 10.1 mostra i componenti di cui avrete bisogno per realizzare il progetto. Componenti elettronici a parte, molti sono facilmente acquistabili presso i negozi di ferramenta e di hobbistica. La scheda Arduino può controllare fino a sei impianti di irrigazione indipendenti. I componenti elencati sono sufficienti per realizzare un sensore e un meccanismo. Se avete bisogno di annaffiare più vasi (fino a sei), dovrete procurarvi anche del materiale aggiuntivo per i sensori e le riserve d’acqua. Gli esatti requisiti dipendono dal numero di piante che dovete monitorare e dal fatto che utilizziate un’unica riserva da due litri. Ecco in particolare di cosa avete bisogno. Una scheda Arduino. Una pianta assetata. Un trasformatore da 9-12 V CC, da 1 A per l’Arduino. Un po’ di filo a due conduttori per alimentazione a bassa tensione (22–24 AWG), per portare l’alimentazione dal trasformatore al contenitore del progetto e alla valvola a solenoide (non illustrato). Un piccolo vaso in terracotta riempito di riso. Un piccolo contenitore per la scheda Arduino. Per ogni sensore avrete bisogno dei seguenti elementi. Una resistenza da 10 kΩ. Un po’ di filo a due conduttori, per bassa tensione (non rappresentato). Un pezzo molto corto di tubo da irrigazione da 15 millimetri (non presentato in figura). Due chiodi zincati da 50 mm. Circa 50 g di gesso in polvere (non rappresentato in figura). Nastro adesivo.

Figura 10.1 Alcuni dei componenti di cui avrete bisogno per realizzare questo progetto.

Per ogni irrigatore e riserva d’acqua avrete bisogno dei seguenti componenti. Un transistor di potenza TIP120/TIP121. Un diodo 1N4001 o simili.


Due piedini da un connettore a pettine. Una valvola a solenoide aria/acqua a 12 volt CC come SMC VDW21-6G-2-M5-Q, per esempio RS#701-3233 (Figura 10.2). Due connettori maschio a gomito M5x6 mm (Figura 10.2). Circa un metro di tubo in nylon con diametro esterno da 6 mm (Newark # 95M4630 o RS #386-6190). Una bottiglia per bibite da 2 L e un vaso di terracotta piccolo o medio da utilizzare come supporto (non illustrato). Non conta quale scheda Arduino utilizzerete per questo progetto. Va benissimo una Arduino UNO. Potrete utilizzare una qualsiasi pianta assetata, ma idealmente dovrebbe essere particolarmente assetata… L’alimentatore dovrebbe essere da 9-12 V CC. Dovrà rispondere alle esigenze di alimentazione sia della scheda Arduino sia di una valvola a solenoide (anche se sono più d’una). La scheda Arduino richiede 500 mA per funzionare e ciascuna valvola a solenoide richiede circa 300 mA. Si tratta di un consumo totale di 800 mA. Dovrete attivare una sola valvola per volta e dunque l’alimentatore di cui avete bisogno deve fornire come minimo 800 mA. Naturalmente non c’è nessun problema se utilizzate un alimentatore in grado di offrire più corrente, mentre se ne utilizzerete uno di potenza inferiore, potrebbe non esservi sufficiente energia per far funzionare il tutto e, nel momento in cui si attiva la valvola, la scheda Arduino potrebbe eseguire un reset. I fili a due conduttori possono essere utilizzati sia per i sensori, sia per alimentare le valvole. Il tipo a “piattina” è facile da tagliare e utilizzare. Dovrete stimare la lunghezza del cavo fra ciascun sensore e la scheda Arduino e un secondo tratto di cavo per alimentare la valvola a solenoide (o più valvole). La somma di queste distanze determina di quanto cavo dovrete disporre per realizzare l’intero sistema. Dovete acquistare la quantità di componenti corretta per il numero di sensori e irrigatori che intendete realizzare. Per realizzare il sensore, l’unico componente elettronico di cui avrete bisogno è una resistenza da 10 kΩ (e il filo). Per realizzare i sensori avrete bisogno di un grosso tubo vinilico, di chiodi zincati, di stucco in polvere e di nastro adesivo. Assicuratevi di procurarvi dei chiodi zincati, in quanto il trattamento superficiale evita che si arrugginiscano. I chiodi rimarranno conficcati nel suolo umido e dunque sarebbe normale che dei comuni chiodi arrugginissero. Sempre per i sensori, avrete bisogno di un po’ di riso e di un piccolo vaso di terracotta. Dopo l’uso potrete comunque riutilizzare il riso per farvi un ottimo risotto alla milanese. La valvola a solenoide (Figura 10.2) controlla il flusso dell’acqua dalla riserva dell’impianto. All’interno è dotata di una bobina elettromagnetica che apre un meccanismo a valvola nel momento in cui viene alimentata. Si tratta di oggetti ampiamente utilizzati in applicazioni industriali per controllare il passaggio di fluidi o aria compressa.

Figura 10.2 Una valvola a solenoide e i relativi adattatori.

Un noto esempio è il dispenser per bibite, che controlla il flusso di sciroppo e acqua gasata per


preparare al volo un bicchiere di bibita quando premete un pulsante. Sono rapide, silenziose, relativamente economiche e ne esistono di tutti i tipi, forme e opzioni. Assicuratevi che abbiano due porte (una per l’ingresso e l’altra per l’uscita dell’acqua) e che abbiano le dimensioni corrette per il tubo di irrigazione. La valvola di questo progetto è dotata di filetti M5, e utilizzate degli adattatori a gomito per collegare i tubi dell’acqua alla valvola. Un lato dell’adattatore ha un filetto corrispondente a quello della valvola e l’altro è dotato di un sistema a pressione (6 mm) nel quale potete inserire il tubicino di irrigazione. Un’altra considerazione riguardante la valvola è costituita dalle sue caratteristiche elettriche. La valvola presentata nell’elenco dei componenti è da 24 V CC, ma può operare anche a 12 V CC. Se avete difficoltà a reperire esattamente questa valvola, utilizzatene un’altra, sempre che le sue esigenze di alimentazione rientrino nelle possibilità dell’alimentatore e che i connettori siano adatti al tubicino da irrigazione. Ogni valvola a solenoide e riserva d’acqua richiede un proprio set di componenti elettronici: componenti discreti (come il transistor, il diodo e le resistenze) che controllano l’alimentazione di ciascuna valvola a solenoide. Ogni connessione richiede una coppia di connettori a pettine per consentirne l’alimentazione dall’Arduino. Il numero di valvole dipende da voi, ma ne avrete bisogno di una per ogni riserva d’acqua. Potete anche realizzare un’unica, grande, riserva d’acqua dotata di più valvole a solenoide con le quali irrigare più piante da un unico sistema di controllo a sensori e irrigazione. Sarete voi (e in ultima istanza le vostre piante) a determinare la configurazione più adatta. Inoltre avrete bisogno di un tubo flessibile da irrigazione che vada dalle riserve alle piante. Potete acquistarlo dai fornitori elencati in precedenza, potete anche procurarvelo (sia questo tubo sia un tubo più grosso per realizzare i sensori) presso un negozio di materiale per animali domestici ben fornito. Queste parti vengono infatti frequentemente utilizzate per realizzare acquari. Oltre ai soliti attrezzi che dovrebbero far parte di qualsiasi cassetta degli attrezzi (per questo rimandiamo al Capitolo 2) avrete bisogno anche di un piccolo trapano a mano e di una punta da 6 millimetri da legno o comunque di un modo per praticare un foro “pulito” sul tappo della bottiglia da due litri.

Realizzazione del sistema Per realizzare il sistema, dovete innanzitutto costruire i sensori, fabbricare e assemblare la riserva d’acqua e le valvole e poi stendere le linee di alimentazione. Quando il sistema sarà funzionante e collaudato, potrete predisporre il codice per calibrarlo.

Realizzazione del sensore di umidità Il sensore di umidità è semplicemente un blocco di gesso contenente due chiodi zincati. Quando il terreno si secca, anche il blocco in gesso si secca e ciò produce una resistenza infinita fra i due chiodi (chiamiamole sonde, per usare un gergo più tecnico). Quando il terreno è ben annaffiato, parte dell’umidità penetrerà nel gesso e si troverà fra i due chiodi, consentendo il passaggio di elettroni fra le due sonde. Potete misurare questo flusso di elettroni utilizzando un pin analogico della scheda Arduino. Più acqua c’è, minore è la resistenza. Quando il terreno è completamente bagnato, vi sarà ben poca resistenza o addirittura resistenza Ø. Utilizzando la gamma di valori misurati sul pin analogico di Arduino potete determinare se è tempo o meno di annaffiare i vasi.

Non è il caso di utilizzare questo sistema per misurare un valore preciso di umidità, poiché quando il gesso si inumidisce, la sua resistenza precipita molto in basso. Non è quindi un buon modo per misurare dei cambiamenti graduali e continui nell’umidità del terreno (per esempio, per tracciare un grafico); al contrario, il sensore è perfetto per determinare semplicemente quando è il momento di annaffiare la pianta. Per costruire le sonde, collegherete dei fili alla testa dei chiodi e li inserirete in uno stampo di gesso fatto con un tubo di plastica vinilica. Se pensate di realizzare più sensori, costruiteli tutti insieme. In tal modo dovrete preparare il gesso una sola volta. Create almeno un paio di sensori, per averne uno di riserva. Accendete il saldatore e la pistola per la colla a caldo. Se avete un saldatore a bassa potenza (meno di 35 watt), potreste non riuscire a scaldare i chiodi a sufficienza per consentire la fusione dello stagno. In tal caso, saltate la fase di saldatura (Passi 1 e 2) e avvolgete i cavi attorno


alla testa dei chiodi una volta che il gesso avrà fatto presa. Ecco i passi da svolgere. 1. Spelate e attorcigliate le estremità di un pezzo di filo a due conduttori di lunghezza sufficiente per raggiungere la pianta dal punto in cui intendete collocare la scheda Arduino. 2. Rivestite le estremità del filo con una piccola quantità di stagno fuso. Quest’operazione è chiamata stagnatura. 3. Fissate i chiodi (uno alla volta) alla “terza mano” e applicate una grande quantità di calore per riscaldare la testa del chiodo con il saldatore, applicando poco a poco un po’ di stagno, fino a farlo sciogliere. Questa operazione può richiedere anche venti o trenta secondi, perché occorre scaldare tutta la testa del chiodo (Figura 10.3). 4. Quando lo stagno si fonde sulla testa del chiodo, applicate il filo, per saldarlo al chiodo e mantenete tutto fermo per qualche istante, finché lo stagno non si solidifica. 5. Una volta che i chiodi si sono raffreddati, teneteli a circa 5 mm di distanza e applicate della colla a caldo in modo che mantengano questa distanza. Ciò evita che i chiodi si tocchino quando poi aggiungerete il gesso.

Figura 10.3 Saldatura dei fili alla sonda.

Per preparare lo stampo, procedete nel seguente modo. 1. Tagliate una piccola sezione del grosso tubo vinilico (un paio di centimetri in più rispetto alla lunghezza dei chiodi, come illustrato nella Figura 10.4). 2. Praticate un taglio verticale per l’intera lunghezza del tubo, in modo che sia facile sfilare il gesso dal tubo.

Figura 10.4 Taglio dello stampo in tubo vinilico.

3. Collocate un pezzo di nastro adesivo nella parte inferiore del tubo, per evitare che il gesso fuoriesca dall’estremità inferiore. Il nastro mantiene anche chiuso il tubo tagliato. 4. Inserite delicatamente il tubo nel vasetto di riso, che lo terrà verticale mentre il gesso si secca (Figura 10.5). 5. Utilizzate un bastoncino e un bicchiere di carta per preparare il gesso con un rapporto di due parti di gesso e una parte di acqua.


Bastano 50 g di gesso per realizzare due sonde. Miscelate bene il gesso finché la pasta sarà uniforme e morbida. Attendete un paio di minuti, mentre il gesso inizia a solidificarsi. Dovrebbe avere la consistenza di una specie di budino.

Figura 10.5 Applicazione del nastro adesivo allo stampo.

6. Riempite con attenzione i tubi vinilici con il gesso, lasciando circa 5 mm nella parte superiore, in quanto una parte del gesso verrà forzato nel tubo quando inserirete i chiodi, come illustrato nella Figura 10.6.

Figura 10.6 Riempimento dello stampo con il gesso.

7. Inserite i chiodi nel gesso e teneteli fermi in posizione per un paio di minuti, mentre il gesso fa presa. Assicuratevi che siano centrati verticalmente nel tubo e che non ne tocchino le estremità. Potete utilizzare un piccolo pezzo di legno, per tenere in posizione il filo mentre il gesso si secca, oppure appoggiate il filo su un lato del vasetto. 8. Dopo un’ora, prendete la sonda e rimuovete il tubo vinilico, come illustrato nella Figura 10.7. Potete buttarlo via o metterlo da parte per realizzare ulteriori sonde. 9. Se avete scelto di attorcigliare i fili, liberate circa 25 mm di isolante dal filo e avvolgetelo delicatamente attorno alla testa di ciascun chiodo, come illustrato nella Figura 10.8. 10. Applicate un grosso spessore di colla a caldo sopra la sonda, facendo riferimento alla Figura 10.9.


Figura 10.7 Rimozione della sonda dallo stampo.

Figura 10.8 Avvolgimento del filo attorno ai chiodi.

Figura 10.9 Finitura della sonda con la colla a caldo.

Questo proteggerĂ i contatti sopra la sonda e garantirĂ  uno stabile isolamento per il cavo. Il gesso ha bisogno di un poâ&#x20AC;&#x2122; di tempo per seccarsi completamente. Dovete assicurarvi che sia ben secco prima di poter calibrare la sonda con la scheda Arduino. Mettete da parte le sonde ad asciugare per almeno ventiquattrâ&#x20AC;&#x2122;ore. Potete impiegare questo tempo per procedere nella realizzazione della riserva e nella preparazione del codice.


Realizzazione della riserva d’acqua La riserva d’acqua è economica e facile da realizzare. L’unica parte difficoltosa consiste nel forare il tappo. Avrete bisogno di un piccolo trapano a mano o elettrico e di una punta da legno da 6 mm, in grado di forare la plastica con facilità. Potete pensare anche di forare un lato della bottiglia, tuttavia le pareti di una bottiglia sono molto sottili e il raccordo con il tubo non potrà essere altrettanto solido. Ecco le operazioni da svolgere per realizzare la riserva d’acqua. 1. Praticate un foro al centro del tappo della bottiglia, come illustrato nella Figura 10.10. Procedete lentamente con il trapano, in modo che la pressione verso il basso sul tappo eviti che il tappo stesso si metta a ruotare o sfugga via.

Figura 10.10 Pratichiamo un foro sul tappo della bottiglia.

2. Inserite nel foro un’estremità del tubo di plastica, in modo che una piccola parte fuoriesca all’interno del tappo, come illustrato nella Figura 10.11. Questo dovrebbe garantire una buona tenuta.

Figura 10.11 Inserimento del tubo per l’irrigazione.

3. Alla parte interna del tappo, applicate una piccola quantità di colla a caldo per fissare il tubo. Fate attenzione a non far cadere la colla sul filetto del tappo o nella sottile parte che lo sigilla, altrimenti vi saranno perdite. 4. Applicate una quantità analoga di colla a caldo sul lato esterno e mantenete fermo il tubo finché la colla non si asciuga. 5. Praticate un piccolo foro sul fondo della bottiglia, che consentirà l’ingresso dell’aria una volta capovolta. In caso contrario l’alimentazione a gravità non funzionerà molto bene, poiché il vuoto tratterrà l’acqua nella bottiglia. 6. Praticate un grosso foro in fondo al vaso in plastica di dimensioni medie, che fungerà


da supporto per la bottiglia da due litri (Figura 10.12). 7. Se necessario, praticate un foro su un lato del vaso, per consentire il passaggio del tubo. Una volta che avrete terminato, installate la riserva d’acqua sulla base per verificare che sostenga la bottiglia, come illustrato nella Figura 10.12. Per gli ultimi test, riempite la bottiglia d’acqua, coprendo il piccolo foro in fondo. Fissate tutti gli elementi della riserva d’acqua e ruotatela per verificare che non perda.

Figura 10.12 Fissaggio della riserva sulla base.

Portare l’acqua al vaso Determinate esattamente dove collocare il sistema di irrigazione. Perché funzioni il sistema a gravità, la riserva d’acqua deve trovarsi in posizione elevata sopra la pianta che intendete annaffiare. Potreste doverla collocare su una piccola scatola o su una mensola, per garantire l’altezza corretta. Dovete anche determinare una posizione adatta per la valvola a solenoide. Non conta molto dove la collocherete, sempre che si trovi su una superficie stabile. Dovete anche verificare che i fili di attivazione del solenoide possano raggiungere agevolmente la scheda Arduino. Per esempio, potete fissare la valvola al contenitore della scheda Arduino, in modo da poter utilizzare i cavi già esistenti sulla valvola. Ora potete misurare la distanza corretta per le linee di alimentazione. Tagliate il tubo alla lunghezza desiderata per raggiungere il luogo in cui è situata la valvola e da lì al fondo del vaso. Assicuratevi di portare l’imboccatura sul fondo del vaso, vicino alle radici.

Realizzazione del circuito sulla breadboard Questo progetto presenta uno schema elettrico molto semplice, rappresentato nella Figura 10.13. È costituito da un circuito partitore di tensione connesso al pin analogico della scheda Arduino e da un circuito attuatore connesso a un pin digitale, che controlla l’attivazione della valvola a solenoide.


Figura 10.13 Schema elettrico del sistema di irrigazione.

Lo schema di collocazione dei componenti (Figura 10.14) mostra la configurazione per un sensore e una valvola a solenoide, ma potete estenderlo per gestire fino a sei sensori su unâ&#x20AC;&#x2122;Arduino UNO (per situazioni piĂš complesse, potete collegare fino a quindici sensori su una scheda Arduino MEGA).

Figura 10.14 Collocazione dei componenti sulla breadboard.


Dopo aver completato i cablaggi e il collaudo, potrete realizzare questo progetto su una breadboard piccola per chiudere il tutto nel contenitore rappresentato nella Figura 10.15. Qui si vede una sorta di “sandwich Arduino” in cui la breadboard è collocata sotto la scheda all’interno del contenitore. Dovrete praticare un paio di piccoli fori per l’ingresso dell’alimentazione e per i cavi del sensore e dunque assicuratevi di procurarvi un contenitore che possiate forare con facilità con gli attrezzi che avete a disposizione. Un piccolo contenitore da 7,5 × 10 × 5 cm in ABS o legno dovrebbe essere sufficiente per ospitare sia la scheda Arduino sia la breadboard del circuito.

Figura 10.15 Inserimento del circuito nel contenitore.

Programmazione, calibrazione e collaudo Il codice di questo progetto è piuttosto semplice. Ora che avete collocato tutti i componenti sulla breadboard, date un’occhiata al codice per scoprire come funziona. Poi, impostate i valori come specificato di seguito e caricate il tutto sulla scheda Arduino. Nella prima sezione di codice si devono dichiarare le variabili: int sensorPin = A0; int valvePin = 9; const int dryThreshold = 900; const long sampleInterval = 6000000; const int irrigationTime = 5000; boolean DEBUG=true;

Il sensore è connesso al pin analogico 0, al quale viene assegnato un nome appropriato. La valvola è connessa al pin digitale 9. Se utilizzate più valvole o più sensori, dovete semplicemente aggiungere ulteriori variabili per la loro gestione. Il valore intero dryThreshold specifica il livello di “aridità” in cui Arduino deve entrare in azione. Quando il valore dell’ingresso analogico A0 è maggiore di questo valore, viene avviata l’irrigazione. La variabile sampleInterval viene utilizzata per ritardare il tempo fra le letture. Non vi è alcuna necessità di monitorare costantemente la porta analogica, poiché in questo progetto il tempo non è un fattore così critico. L’evaporazione è un processo lento e la sonda si seccherà in un tempo misurabile in ore o giorni. Utilizzate irrigationTime per specificare il tempo in millisecondi in cui deve passare l’acqua. Dovrete determinare questo valore durante le fasi di collaudo e calibrazione. Normalmente si include nel codice una variabile booleana DEBUG. In molti casi, l’unico modo per capire cosa accade in Arduino (i valori delle variabili o delle letture dei sensori) consiste nell’usare istruzioni di visualizzazione sulla porta seriale, utilizzando il comando Serial.println(). Ma non ne avrete più bisogno dopo aver perfezionato il codice. Non è il caso di congestionare la porta seriale (o


comunque di utilizzarla) una volta che avrete eliminato tutti i bug. Se inserirete tutte le istruzioni di debugging in un’istruzione condizionale if che controlla se siamo in modalità DEBUG, potete assicurarvi che tali istruzioni verranno eseguite solo durante la fase di debugging. Poi, una volta che avrete concluso i collaudi, dovrete semplicemente cambiare il valore DEBUG in false. In realtà, è solo una questione di stile, ma può essere molto comodo se state realizzando un progetto che utilizza la porta seriale per la comunicazione e volete anche essere in grado di eseguire il debugging del codice.

Configurazione in setup() La sezione setup() del codice prepara la scheda Arduino al funzionamento del sistema. void setup(){ if(DEBUG){Serial.begin(9600);} pinMode(sensorPin, INPUT); pinMode(valvePin, OUTPUT); digitalWrite(valvePin, LOW); }

L’istruzione if controlla se avete impostato a true la variabile booleana DEBUG e, in questo caso, attiva la porta seriale. Quindi utilizzate la funzione pinMode per dire alla scheda Arduino di utilizzare il pin sensorPin per l’input e il pin valvePin per l’output. Volete assicurarvi che la valvola sia chiusa quando lanciate lo sketch; l’ultima riga di setup si occupa proprio di questo, utilizzando digitalWrite() per portare esplicitamente valvePin al valore LOW.

Esecuzione del ciclo principale Dovete solo far sì che Arduino controlli il sensore e, se il terreno è troppo secco, apra il flusso d’acqua. Ecco il funzionamento del ciclo principale. 1. Eseguire una lettura dal pin analogico 0. 2. Confrontare questa lettura con un valore soglia. 3. Se il valore letto è superiore rispetto alla soglia di aridità, attivare il pin digitale connesso alla valvola a solenoide. 4. Attendere alcuni secondi. 5. Chiudere la valvola. 6. Attendere il successivo tempo di campionamento e ricominciare da capo. Ecco l’aspetto del codice: void loop() { int sensorValue = analogRead(sensorPin); if(DEBUG){ Serial.print(“Sensor value: “); Serial.println(sensorValue); } if (sensorValue>dryThreshold){ digitalWrite(valvePin, HIGH); // Open the water valve delay(irrigationTime); // Keep it open for the irrigation time digitalWrite(valvePin, LOW); // Close the valve } delay(sampleInterval); // wait until the next time to take a reading }

Utilizzate la variabile locale intera sensorValue per memorizzare una lettura dalla variabile sensorPin che avete già inizializzato con il pin analogico 0. L’istruzione successiva controlla se avete impostato la variabile booleana DEBUG a true e, in questo caso, invia la lettura alla porta seriale. L’istruzione condizionale if controlla poi se la lettura eseguita sul pin analogico 0 è inferiore o superiore rispetto al livello di aridità specificato da dryThreshold. Se è superiore, la valvola viene


aperta, applicando una tensione a valvePin. Questo fa sì che il transistor apra la valvola, così che l’acqua possa passare. La durata del flusso d’acqua è impostata da irrigationTime. Una volta trascorso questo tempo, la valvola viene chiusa scrivendo su valvePin la condizione LOW. L’ultima istruzione chiede ad Arduino di attendere la durata sampleInterval, dopodiché deve essere eseguita una nuova lettura e il processo ricomincia.

Calibrazione del sensore e del livello di flusso Ora che il codice è funzionante, adattatelo alle caratteristiche del vostro impianto. Dovete determinare la gamma di valori prodotta dal sensore e il flusso dell’unità di irrigazione. All’inizio, impostate la variabile sampleInterval a un tempo breve, per esempio di 100 ms in modo da poter vedere l’output del sensore e inviarlo alla scheda. Quando parte il codice, aprite il Monitor seriale e prendete nota delle letture. Quando la sonda è completamente secca, il valore del sensore dovrebbe essere all’incirca di 1023: ciò indica una resistenza infinita. Se è differente o leggete un valore molto basso, avete un problema con il cablaggio o la sonda. Deve essere molto secca. Provate un’altra sonda (per esempio quelle di riserva che avete preparato in precedenza) e controllate se avete lo stesso problema. In questo caso, controllate bene i collegamenti e riprovate. Ora prendete un bicchiere e immergetevi il sensore. Verificate che i fili sulla parte superiore del sensore non siano esposti all’acqua o avrete un corto circuito e non potrete misurare nulla. Ora osservate le letture rilevate dalla sonda, le quali dovrebbero scendere progressivamente. Ricordate che i valori misurati sui pin analogici vanno da 0 a 1023. Questa gamma corrisponde al valore della tensione presente sul PIN mentre va da 0 a 5 Volt. Se vi è più resistenza (il terreno è arido), vi sarà poco passaggio di corrente e, di conseguenza, una tensione bassa a causa dell’elevata resistenza del suolo secco. Questo valore potrebbe essere superiore a 1000. Se vi è meno resistenza fra le sonde, vi sarà un maggiore passaggio di corrente fra di esse. Pertanto, la tensione misurata sarà più elevata. La misurazione di una tensione elevata significa che il terriccio è molto umido e rappresenta un buon conduttore di elettricità. In tal caso, difficilmente il valore andrà a 0, ma sarà di poche centinaia di unità. Nei test, i sensori partivano dalla lettura 1023 e, nel giro di un paio di minuti, scendevano fino a una lettura di 110 o valori analoghi. Ora che avete osservato il sensore in azione, toglietelo dall’acqua e lasciatelo nuovamente asciugare. A seconda delle condizioni atmosferiche e ambientali, la sonda potrebbe asciugarsi completamente in poche ore, tempo entro il quale le letture dovrebbero tornare intorno a 1023. Nel frattempo, riempite la riserva d’acqua (ricordandovi sempre di coprire con un dito la presa d’aria che avete praticato sul fondo), avvitate il tappo e tenete il dito sull’estremità del tubo. Ora annaffiate la pianta manualmente e contate quanti secondi sono necessari per ottenere un buon riempimento. Prendete nota di questo tempo e impostatelo (in millisecondi) nella variabile irrigationTime. Annaffiare le mie piante richiede circa 7 secondi di irrigazione e dunque il tempo impostato è stato di 7000 ms.

Con un po’ di collaudo, potete anche scrivere il codice diversamente, in modo che il flusso d’acqua si chiuda non appena sensorPin rileva una condizione di umidità, ma saranno necessari parecchi secondi prima che il sensore rilevi questa condizione e dunque il rischio è quello di annaffiare eccessivamente il vaso solo perché state ancora aspettando che il sensore rilevi il livello di umidità. Per maggiore sicurezza, ho scelto di impiegare un tempo fisso. Ora che tutto è collaudato e calibrato, potete scollegare la scheda Arduino dal computer, installare il contenitore nei pressi dell’impianto e collegare l’alimentazione. Assicuratevi di collocare la sonda in profondità nel suolo, in modo che la misurazione dell’umidità venga presa in un punto vicino alle radici (Figura 10.16). Ma non seppellitela interamente, altrimenti potreste mandarla in cortocircuito se l’acqua dovesse toccare i fili in cima ai chiodi.


Figura 10.16 Il sistema di irrigazione della mia piccola giungla domestica, la finestra della cucina.

Aggiunta di ulteriori valvole Se dovete annaffiare più di una pianta, potete farlo senza aggiungere ulteriori fonti di alimentazione. Potete alimentare tutti solenoidi con un’unica fonte di alimentazione, sempre che svolgiate l’operazione sequenzialmente. Non vi è alcuna necessità di annaffiare le piante tutte insieme e dunque potete attivare le valvole in successione, una alla volta. Grazie a questo piccolo stratagemma non avrete bisogno di un alimentatore più potente. Se doveste tentare di alimentare tutte le valvole insieme, la scheda Arduino potrebbe trovarsi sottoalimentata, andare in reset e non attivare nulla. Ora sedetevi, rilassatevi e godetevi la crescita riconoscente delle vostre piante!


Capitolo 11

Controllare l’andirivieni di un gatto In questo capitolo Utilizzo di sensori a effetto Hall Connessione di uno shield Ethernet alla scheda Arduino Uso della libreria Twitter Invio di un tweet

A

l giorno d’oggi, sono in tanti a inviare tweet e ha senso che anche un animale domestico possa farlo! Questo progetto fornisce una scusa (abbastanza) credibile per creare un account Twitter per il gatto e presenta il vantaggio pratico di far sapere quando il gatto è in casa o fuori casa anche se voi non siete a casa. Ho un gatto piuttosto pigro, ma che ama anche andare a spasso. Vivendo in città, vogliamo essere sicuri che stia bene e sapere dove si trova in ogni momento. Cosa c’è di meglio che utilizzare Internet per garantirci un monitoraggio continuo dei suoi andirivieni? In questo progetto, modificherete l’ingresso del gatto con sensori che rilevano il passaggio di un magnete. Un magnete installato sullo sportello d’accesso controlla quando il gatto (o il cane o il tasso) entra o esce. La scheda Arduino utilizza questo segnale per selezionare un messaggio casuale da inviare direttamente a Twitter sotto forma di tweet. Non è necessario lasciare un computer connesso alla scheda Arduino, in quanto tutto sarà contenuto su un’unica scheda. Molti esempi disponibili in Internet usano un server di supporto per eseguire il login a Twitter e inviare il tweet. Ma se il server si spegne, non saremo più in grado di inviare tweet. Il grande vantaggio di questo progetto è che Arduino comunica direttamente con Twitter senza appoggiarsi a un server intermedio. Una volta che avrete finito questo progetto, sarete in grado di rilevare quando l’animale domestico entra in casa o se ne va utilizzando dei sensori a effetto Hall. Imparerete a connettere la scheda Arduino alla rete domestica e da lì a Internet, un’operazione utile per ogni altro progetto che ha la necessità di connettersi a Internet.

I componenti La porta per animali domestici con Twitter usa un magnete e due sensori a effetto Hall. Quando la porta si apre verso l’interno o verso l’esterno, un campo magnetico altera il flusso di elettroni all’interno dei sensori e cambia la tensione di uscita. Misurando questa tensione potete rilevare i movimenti dello sportello. La Figura 11.1 mostra i componenti necessari per il progetto (tranne lo sportello stesso). Inizialmente si può realizzare su una breadboard, ma poi il tutto andrà trasferito in un contenitore da collocare nei pressi del router, magari dietro il divano. Ecco che cosa è necessario per realizzare il progetto. Una scheda Arduino UNO. Uno shield Arduino Ethernet (si può trovare presso molti fornitori, fra cui sparkfun.com, shop.arduino.cc, coolcomponents.co.uk e oomlout. co.uk). Uno sportello per animali domestici (non illustrato nella figura), che potete procurarvi presso un rivenditore specializzato. Un sensore lineare a effetto Hall come Allegro A1324 (Digikey 620-1432-ND, RS Online 6807507) in formato SIP (Single In-line Package). Alcuni metri di cavo a quattro conduttori, 22 AWG o simili (Radio Shack, Maplin).


Quattro piedini da un connettore a pettine. Un piccolo magnete da 3-5 mm ad alta potenza, come un magnete al neodimio (lo trovate su eBay). Un cavo Ethernet non troppo lungo (non rappresentato nella figura). Un alimentatore da 7-12 volt CC per la scheda Arduino. Un contenitore appropriato, se volete proteggere dalla polvere la scheda Arduino e lo shield Ethernet (SparkFun PRT-09682, Farnell 1848692). Due piccoli blocchi di legno o di materiale plastico di recupero (cubi da 2 cm), per esempio un blocco Lego (non illustrato nella figura). Biscottini per animali domestici (non illustrati nella figura)!

Figura 11.1 I componenti necessari per questo progetto.

Naturalmente avrete bisogno di alcuni accessori per realizzare il progetto, come fascette per cavi e taglierina, colla a caldo e relativa pistola e la “terza mano”. Supporemo di utilizzare una scheda Arduino UNO, uno shield Ethernet e l’ultima versione dell’ambiente di sviluppo. Le versioni più aggiornate dell’hardware e dell’ambiente di sviluppo sono particolarmente affidabili. Se non avete ancora una porta per il gatto, sarà più facile eseguire questo progetto, poiché potrete collegare i sensori prima ancora di installare la porta. Tuttavia questo progetto può essere adattato a una qualsiasi porta per gatti che potete avere già in funzione. I due sensori a effetto Hall misurano l’intensità di un campo magnetico e producono un’uscita che dipende dal sensore utilizzato. Esistono vari tipi di sensori a effetto Hall, in grado di fornire un output digitale o analogico. Alcuni possono rimanere impostati (latch) sull’ultima polarità magnetica rilevata (nord o sud) finché non vengono sbloccati da un campo magnetico nella direzione opposta. Non è necessario procurarsi un sensore Hall di tipo latch, dato il modo in cui verranno installati i magneti di attivazione. Meglio scegliere sensori a effetto Hall lineari, in quanto possono essere utilizzati senza componenti aggiuntivi, come resistenze o condensatori, e ciò semplifica notevolmente la realizzazione del progetto. Molto probabilmente, la porta per il gatto non sarà proprio nei pressi del router. Avrete bisogno di alcuni metri di filo da stendere fra i sensori installati sullo sportello e la scheda Arduino. Utilizzerete due sensori, ognuno dei quali avrà un proprio segnale di output, e dovrete fornire anche alimentazione e connessione di terra. Si tratta di un totale di quattro conduttori elettrici in un cavo. Poiché si tratta di un circuito a bassa potenza, potete anche utilizzare del cavo telefonico o un cavo di rete Ethernet che potreste avere già a disposizione. Altrimenti, qualsiasi economicissimo cavo a quattro conduttori per applicazioni a bassa tensione (22 AWG o superiore) funzionerà alla perfezione. Avrete bisogno di un magnete piccolo (3-5 mm) ma di grande intensità per attivare sensori a effetto Hall. Potete impiegare un magnete al neodimio, uno di quei magneti nichelati, estremamente potenti, che potete aver già visto in precedenza. Sono ampiamente disponibili ed è facile


procurarseli tramite eBay. Si devono montare i sensori e il magnete su un lato dello sportello. Utilizzate poi della colla a caldo per fissarli in posizione. Il loro vantaggio è anche quello di non temere l’acqua e dunque non dovrete preoccuparvi del fatto che l’umidità potrebbe rovinare i sensori. Si può veramente dire che “la colla a caldo è la migliore amica dell’uomo” (gatto a parte, naturalmente). Poiché non vi sono pulsanti da premere o altre interazioni con la scheda Arduino, potete nasconderla dietro il divano, dove nessuno la vedrà. In tal modo, il contenitore non dovrà necessariamente avere un aspetto ricercato. Tuttavia è sempre opportuno inserire l’Arduino e il suo shield in un contenitore, per evitare che accumuli polvere. Potete anche utilizzare una scatolina di cartone o una confezione piccola di Pringles. I biscottini sono per convincere l’animale ad attraversare la porta, per il collaudo e il “lancio finale”!

Le linee del campo magnetico devono essere perpendicolari alla piastra del sensore a effetto Hall. Occorrerà eseguire dei test con il magnete al neodimio per determinare l’orientamento corretto.

Potete scaricare lo schema elettrico e i diagrammi a colori di collocazione dei componenti dal sito web del libro (www.hoeplieditore.it/6323-9).

Collaudo del circuito Prima di iniziare a montare il tutto sullo sportello e utilizzare i sensori, iniziate a cablare il circuito sulla breadboard per valutare i valori soglia. A tale proposito, seguite il diagramma di collocazione dei componenti rappresentato nella Figura 11.2.

Figura 11.2 Schema di collocazione dei componenti per il circuito di test.

Innanzitutto, fissate lo shield Ethernet sopra la scheda Arduino. I pin sotto lo shield entreranno esattamente nei pin dell’Arduino. La scheda Ethernet dovrebbe andare a fissarsi sull’Arduino in


modo progressivo ma sicuro. Fate attenzione a non piegare i pin dello shield mentre lo fissate. I pin dello shield Ethernet saranno ora connessi direttamente alla scheda Arduino sottostante. Quindi dovete aggiungere i due sensori a effetto Hall ai pin Analog IN A0 e A1 della scheda Arduino e connettere alimentazione, terra e segnali.

Assicuratevi di collocare i sensori a effetto Hall con l’orientamento corretto. Il lato smussato e stampato con del testo è quello anteriore del sensore. Assicuratevi di connettere la fonte di alimentazione +5 al pin a sinistra, visto da davanti. Altrimenti il sensore potrà scaldarsi anche molto e danneggiarsi in modo permanente. Se utilizzate un sensore che non compare nell’elenco dei componenti, consultate sul suo datasheet la sua piedinatura. I sensori A1324 forniscono un output lineare e richiedono 5 V, forniti direttamente dalla scheda Arduino. Quando non viene rilevato alcun campo magnetico, forniscono una tensione di uscita pari alla metà della tensione di ingresso, ovvero circa 2,5 V. Quando al sensore si avvicina il polo nord del magnete, la tensione aumenta a circa 5 V. Quando al sensore si avvicina il polo sud del magnete, la tensione precipita quasi a Ø V. Potete utilizzare questa proprietà per rilevare quando il cane o il gatto passa attraverso lo sportello. Il primo passo consiste nel collaudare la configurazione per ottenere i valori soglia che riceverete dai sensori a effetto Hall. Nel frattempo, potete assicurarvi che i sensori funzionino correttamente prima di installarli. Utilizzate il codice seguente per collaudare i sensori: /* Chapter 11 Sketch to test Hall effect sensors for a tweeting pet door */ const int entryPin = A0; // Define the input pin for entry sensor const int exitPin = A1; // Define the input pin for the exit sensor int entryValue = 0; // Define variable to store the entry value int exitValue = 0; // Define variable to store the exit value void setup() { Serial.begin(9600); // Open a serial connection to display the data pinMode(entryPin, INPUT); pinMode(exitPin, INPUT); } void loop() { entryValue = analogRead(entryPin); // Read the value from entry sensor exitValue = analogRead(exitPin); // Read the value from exit sensor Serial.print(“Sensor values: “); Serial.print(entryValue); // Print the entry sensor value Serial.print(“, “); Serial.println(exitValue); // Print the exit delay(1000); // Wait a moment, so we can read what’s been printed }

Il codice è piuttosto semplice. Innanzitutto definite due variabili per i pin di ingresso e di uscita. Il loro valore non cambierà e dunque sono definite come costanti intere. Quindi dichiarate due interi in cui leggere i valori forniti dai sensori a effetto Hall. Il pin del segnale di ciascun sensore produce in output una tensione che invia ai pin A0 e A1.

L’ATmega328 contiene al proprio interno un converter analogico/digitale a sei canali con una risoluzione di 10 bit (1024 valori), il che significa che l’effettiva risoluzione in termini di tensione è di 0,004 V. La scheda Arduino legge la tensione in arrivo ai pin di input analogico e la converte in un valore numerico compreso fra 0 e 1023. La tensione di input dei sensori a effetto Hall è costantemente di 5 V e sono progettati in modo che quando non viene rilevato alcun campo magnetico producono in uscita circa 2,5 V. Quando il polo sud del magnete passa nelle vicinanze, la tensione in ingresso


precipita e la scheda Arduino riceve un valore numerico prossimo a 0. Quando il polo nord passa nelle vicinanze, il valore cresce in direzione del massimo, 1023. Potete utilizzare questo cambio di valore per determinare quando inviare un tweet. Ora collaudate la configurazione per leggere i valori di uscita e assicuratevi che tutto funzioni correttamente, come illustrato nella Figura 11.3.

Figura 11.3 Collaudo dei sensori.

Fate clic sul pulsante del Monitor seriale nell’ambiente di sviluppo di Arduino (la lente di ingrandimento che occupa l’angolo superiore destro della finestra), il quale apre la finestra di monitoraggio dell’output, per consentirvi di vedere i valori ricevuti. Fate passare il magnete davanti a ciascun sensore e i valori dovrebbero cambiare da circa 500 a 0 o 1023, proporzionalmente a quanto avvicinate il magnete al sensore. Ho fissato una pila di magneti a una punta per poterli tenere comodamente in mano. L’effettiva distanza operativa dei sensori è piuttosto limitata, circa un centimetro per ottenere una lettura significativa. Osservate il lato del magnete che fa scendere il valore verso Ø, come illustrato nella Figura 11.4, che mostra ciò che accade quando il magnete passa nei pressi del sensore. Non arriverà a 0, in quanto una piccola tensione rimarrà comunque presente sul pin analogico. Fate un segno “S” sul magnete con il pennarello indelebile, per identificare il suo polo sud. Lo monterete con il polo sud rivolto verso lo sportello, in modo che sia rivolto verso il sensore e gli passi vicino. Potete anche scegliere il polo nord, ma dovete modificare in modo appropriato il codice.

Non è importante che otteniate valori troppo vicini a Ø o a 1023. Basta rilevare una differenza significativa verso l’alto o verso il basso quando il magnete passa nei pressi del sensore.


Figura 11.4 Verifica delle letture sul Monitor seriale.

Preparazione dell’account Twitter Dopo aver verificato che i sensori funzionano, è tempo di configurare lo sportello con l’account Twitter del vostro animale domestico. Ora dovete far sì che il programma Arduino possa utilizzare Twitter; a tale scopo impiegherete gli strumenti della particolare area Developers del sito web di Twitter. Sono in molti a sviluppare app e funzionalità personalizzate basate su Twitter e pertanto Twitter ha predisposto particolari strumenti e metodi: le app possono utilizzare Twitter tramite una specifica interfaccia di programmazione delle applicazioni (API – Application Programming Interface). Dovete accreditarvi sull’area Developer con l’account Twitter del vostro animale domestico e potrete accedere a queste funzionalità, come descritto in seguito. Lo sportello del gatto deve avere un modo per autenticarsi su Twitter in modo che possa inviare tweet. Twitter usa uno schema di autenticazione sicuro chiamato OAuth (Open Standard for Authentication) che richiede delle credenziali, le quali consentono alla scheda Arduino di utilizzare l’account dell’animale domestico. Può sembrare un po’ complicato, ma non è necessario essere esperti di sicurezza per utilizzare questo sistema. In pratica delegate alla scheda Arduino l’accesso in lettura e scrittura di tweet per conto del vostro animale domestico. L’operazione, dietro le quinte, è piuttosto complicata e dovete usare la crittografia per evitare che le password circolino in Internet senza protezione. Ma, molto semplicemente, è come prestare alla scheda Arduino la password dell’animale domestico ogni volta che deve inviare un tweet. Le credenziali di cui avete bisogno sono le seguenti. Una chiave consumer. Un segreto consumer. Un token di accesso. Un segreto per token di accesso. Fortunatamente, potete ottenere il tutto con un clic, una volta che l’account sarà pronto. Ecco come richiedere l’account (Figure 11.5 e 11.6). 1. Naturalmente, è possibile che il vostro animale domestico utilizzi già un account Twitter. In caso contrario, andate sul sito Twitter.com e impostatene uno per lui; già che ci siete, perché non preparare anche una foto per il profilo? 2. Raggiungete http://dev.twitter.com e create l’account per l’animale domestico.


Figura 11.5 Creazione di una applicazione sul sito Developers.

Figura 11.6 Creazione di un token di accesso e relativa chiave.

3. Passate sull’immagine del profilo nell’angolo superiore destro e selezionate My Applications dalle opzioni che compariranno nel menu. 4. Fate clic sul pulsante Create New App. 5. Nel campo Name, specificate un nome per l’app. Quella del mio gatto Muon si chiama MyPetDoor. Non inserite spazi nel nome. 6. Nel campo successivo, Description, scrivete una breve descrizione. Per esempio potete scrivere “Tweet dello sportello del gatto”. 7. In Website specificate un link verso un sito web vostro o del vostro animale domestico. La maggior parte degli sviluppatori specifica qui la home page della propria app, per garantire gli aggiornamenti e il supporto agli utenti. Il vostro gatto probabilmente non deve fornire alcun supporto utente e dunque ciò che specificate qui non è importante. Ma non potete lasciarlo


vuoto e tutto ciò che inserirete deve iniziare con “http://”. 8. Selezionate la casella Yes, I agree e leggete le Developers Rules of the Road se avete un’oretta o due di tempo che vi avanzano. Eccovene un riassunto: “Comportatevi bene!”. 9. Inserite le frasi di test “Captcha” che vengono utilizzate per garantire che siate una persona vera e non un sistema automatico. 10. Fate clic su Create Your Twitter Application. Se tutto funziona a dovere, dovreste vedere la nuova pagina Details dell’applicazione, rappresentata nella Figura 11.6. Ora tutto quello che dovete fare è richiedere il token d’accesso e la chiave di accesso segreta, in modo che l’app possa inviare tweet. 1. Nella parte inferiore della pagina, fate clic sul pulsante Create My Access Token. Un’indicazione verde nella parte superiore dello schermo confermerà che l’operazione è stata svolta con successo. 2. Fate clic sulla scheda Settings e scorrete fino ai campi Application Type per iniziare il processo che concede all’app il permesso di scrivere tweet. Qui selezionate il pulsante Read and Write. In fondo a questa pagina, fate clic sul pulsante Update This Application’s Twitter Settings. Un indicatore verde nella parte superiore dello schermo confermerà che l’operazione si è svolta con successo. 3. Per confermare le nuove impostazioni, tornate alla scheda Details e assicuratevi che Access sia ora Read and Write. 4. Andate in fondo la pagina dei dettagli, dove troverete l’indicazione Your Access Token; fate clic su Recreate My Access Token. Il livello di accesso in fondo a questa sezione dovrebbe aggiornarsi per riflettere lo status Read and Write. Avete generato tutto ciò di cui avete bisogno per operare. 5. Fate clic sulla scheda OAuth per visualizzare i codici. Mantenete aperta questa finestra oppure copiate il contenuto da qualche parte, poiché ne avrete bisogno nel codice. Assicuratevi di conservare queste informazioni in un luogo sicuro: non vorrete certamente che dei gatti randagi possano violare l’account Twitter del vostro gatto!

Realizzazione del codice Ora aggiungete il codice di collaudo del sensore per creare i tweet, per attivare la connessione di rete e per configurare la scheda Arduino in modo che comunichi via Twitter. Innanzitutto occorre modificare il codice di test in modo che selezioni casualmente un tweet da un elenco di opzioni possibili. Poi potrete configurare il tutto con i sensori. Infine dovrete aggiungere alcune librerie Arduino per collaudare l’invio dei tweet prima di rimontare il tutto sullo sportello basculante.

Specificare i tweet Iniziate a modificare il codice per aggiungere alcuni tweet, che verranno inviati quando la bestiola entrerà in casa o se ne andrà. Aggiungete il seguente codice alla sezione di dichiarazione delle variabili, prima di setup() (le nuove parti sono indicate in grassetto): … unsigned long timestamp; boolean entering = false; char* entryMessage = “I’m baaaack!”; char* exitMessage = “I’m outta here!”; const int entryPin = A0; // the number of the pushbutton pin const int exitPin = A1; // the number of the pushbutton pin int entryValue = 0; // Define variable to store the entry value int exitValue = 0; // Define variable to store the exit value void setup(){ …

La prima variabile unsigned long viene utilizzata per ottenere l’ora da Twitter nel ciclo principale.


Aggiungetela all’inizio di un tweet per creare un messaggio univoco ogni volta che inviate un tweet.

L’APP di Twitter richiede che ogni tweet sia univoco, in modo che gli zombie, i robot e i programmi più pericolosi non sovraccarichino Twitter con messaggi fasulli. Questo significa che dovrete rendere ogni tweet almeno un po’ differente. Il modo più facile per farlo è quello di aggiungere a ogni messaggio un contatore univoco. Il programma invia tweet differenti a seconda del fatto che la creatura stia entrando o uscendo. I tweet sono conservati in due variabili di tipo char*, chiamate entryMessage ed exitMessage. La parte divertente consiste nello scrivere i messaggi per i tweet dell’animale. Il nostro gatto è un po’ scorbutico e dunque ho creato dei messaggi che riflettono il suo carattere. Qui potete essere davvero molto creativi. Ricordatevi solo che il limite di Twitter è di 140 caratteri.

Aggiunta delle librerie Ethernet e Twitter Ora, all’inizio del codice, occorre aggiungere le librerie che estendono le funzionalità di Arduino in modo da fargli supportare la connessione di rete con Twitter. Per attivare Twitter, dovete aggiungere la relativa libreria, sviluppata da Markku Rossi, che potete scaricare dal sito del libro, www.hoeplieditore.it/6323-9. Ecco come installarla. 1. Scaricate la libreria di Twitter e salvatela dove preferite, per esempio sul desktop. 2. Chiudete l’ambiente di sviluppo di Arduino se lo state utilizzando 3. Estraete i file compressi, che creeranno una cartella chiamata /Chapter_11 contenente le tre sottocartelle Twitter, Time e Sha. La libreria di Twitter usa Time per ottenere l’ora corrente e Sha per le funzionalità di crittografia. 4. Trascinate o copiate queste tre cartelle nella cartella delle librerie di Arduino. Sulle macchine Windows, probabilmente si tratterà di “Documenti\Arduino\libraries”. Su Mac, probabilmente si chiamerà “Documenti/ Arduino/libraries”. Su Linux, sarà sicuramente la cartella “libraries” in sketchbook. Se la cartella “libraries” non esiste, createla. 5. Ora riavviate l’ambiente di sviluppo di Arduino. Assicuratevi che le nuove librerie compaiano nel menu Sketch Import Library del software. In questo caso avete installato le librerie correttamente. Potete aggiungere le funzionalità Twitter allo sketch richiamando queste librerie all’inizio e poi configurando lo shield Ethernet di Arduino utilizzando la relativa libreria, che attiva la connessione di rete. Se utilizzate l’ambiente di sviluppo di Arduino più aggiornato, la libreria Ethernet sarà già inclusa e non dovrete fare altro che aggiungere il codice all’inizio dello sketch. Inoltre avrete bisogno della libreria SPI (Serial Peripheral Interface) per scambiare i dati con lo shield, ma anche questa libreria dovrebbe essere già inclusa. Ora, aggiungete il codice seguente all’inizio dello sketch (il nuovo codice è rappresentato in grassetto): #include <Ethernet.h> #include <SPI.h> #include <EEPROM.h> #include <sha1.h> #include <Time.h> #include <Twitter.h> byte mac[] = { 0x00, 0xAA, 0xBB, 0xCC, 0xDE, 0x01 }; EthernetClient client; IPAddress twitter_ip(199, 59, 149, 232); uint16_t twitter_port = 80; char buffer[512]; const static char consumer_key[] PROGMEM = “*****YOUR CONSUMER KEY*****”; const static char consumer_secret[] PROGMEM = “*****YOUR CONSUMER SECRET*****”;


Twitter twitter(buffer, sizeof(buffer)); unsigned long timestamp; …

Le librerie vengono incluse nello sketch tramite il comando #include. Sicuramente sapete che cos’è un indirizzo IP, ma sotto di esso, a livello hardware, esiste anche un indirizzo. MAC (Media Access Control). La variabile mac[] è un array di unsigned int contenente i sei byte dell’indirizzo MAC.

Tutti i dispositivi di rete hanno un proprio indirizzo MAC univoco e il vostro indirizzo MAC è stato codificato nello shield Ethernet in fase di produzione. Lo trovate stampato in un adesivo applicato sotto lo shield. Potete utilizzare il numero indicato sull’adesivo ma, in realtà, non è importante e potete anche utilizzare l’indirizzo Mac presente nel codice.

Se sapete che nella vostra rete state utilizzando un indirizzo IP statico, potete aggiungerlo al codice dopo l’indirizzo MAC. Questo può essere utile solo se sulla vostra rete non siete in grado di utilizzare il protocollo DHCP (Dynamic Host Configuration Prototcol) . Per utilizzare un indirizzo IP statico, aggiungete la seguente riga, sostituendo all’indirizzo IP quello che intendete utilizzare: IPAddress ip(192,168,1,43); // the IP address may be different on your network

Poi, utilizzate l’oggetto EthernetClient della libreria Ethernet per creare un client Ethernet chiamato “client”. Ciò consente di inviare e ricevere messaggi con lo shield Ethernet. L’indirizzo IP di Twitter è specificato nella variabile IPAddress. Questo è l’attuale indirizzo IP di Twitter e difficilmente cambierà. Potete anche utilizzare il servizio DNS (Domain Name Service) per trovare (o “risolvere”) l’indirizzo IP di Twitter, ma sarebbe solo uno spreco di memoria sull’Arduino e dunque abbiamo deciso di mantenere le cose brevi e semplici. Inoltre, occorre specificare la porta TCP 80, memorizzata nella variabile twitter_port. Ora il passo più importante consiste nello specificare i valori ottenuti dal sito Twitter Developer, rappresentati nella Figura 11.6. Questo è il modo in cui Arduino si autentica su Twitter per inviare tweet per conto del vostro animale domestico. Nel codice precedente, svolgete le seguenti operazioni. Sostituite a *****YOUR CONSUMER KEY***** la lunga stringa di cifre elencata a lato del campo Consumer Key nella scheda OAuth del vostro account. Sostituite a ******YOUR CONSUMER SECRET****** la lunga stringa di cifre elencata a lato del campo Consumer Secret nella scheda OAuth del vostro account. Le ultime due variabili sono un array di caratteri chiamato buffer che contiene il testo del messaggio e un oggetto Twitter chiamato Twitter, che fornisce la connettività e le funzionalità di Twitter. In setup(), dovete ora attivare la connessione Ethernet dello shield. A meno che abbiate scelto di utilizzare un indirizzo IP statico, questo sketch utilizza DHCP, che rappresenta un modo per chiedere al router di fornire automaticamente un indirizzo IP. La maggior parte dei router domestici è configurata in questo modo, poiché semplifica l’aggiunta alla rete di nuovi dispositivi, come stampanti, ricevitori TV, tablet e telefoni mobili. Aggiungete a setup() il codice rappresentato in grassetto: void setup(){ Serial.begin(9600); Serial.println(“Attempting to get an IP address using DHCP:”); if (!Ethernet.begin(mac)) {


Serial.println(“Failed to get an IP address using DHCP, trying the static IP”); Ethernet.begin(mac, ip); }

Questo codice invia messaggi al Monitor seriale, in modo che possiate assicurarvi che la connessione alla rete Ethernet sia avvenuta. Le ultime due righe sono necessarie solo se nella rete potete utilizzare un indirizzo IP statico e avete configurato il codice per farlo. Infine, aggiungete alla fine della sezione setup() il codice che specifica gli ultimi dettagli di cui Twitter ha bisogno per autenticare la vostra scheda Arduino in modo che possa inviare tweet per conto dell’animale domestico: void setup(){ Serial.begin(9600); Serial.println(“Attempting to get an IP address using DHCP:”); if (!Ethernet.begin(mac)) { Serial.println(“Failed to get an IP address using DHCP, trying the static IP”); Ethernet.begin(mac, ip); twitter.set_twitter_endpoint(PSTR(“api.twitter.com”), PSTR(“/1/statuses/update.json”), twitter_ip, twitter_port, false); twitter.set_client_id(consumer_key, consumer_secret); #if 0 // Read OAuth account identification from EEPROM. twitter.set_account_id(256, 384); #else // Set OAuth account identification from program memory. twitter.set_account_id(PSTR(“******YOUR ACCESS TOKEN******”), PSTR(“******YOUR ACCESS TOKEN SECRET******”)); #endif }

Nel codice precedente, la funzione twitter.set_client_id usa i valori definiti all’inizio del programma, e dunque dovreste lasciare le cose come sono. Ora dovete aggiungere il token di accesso e il segreto forniti da Twitter: Sostituite a *****YOUR ACCESS TOKEN***** la lunga stringa di cifre elencata a lato del campo Access Token nella scheda OAuth del vostro account. Sostituite a ******YOUR ACCESS TOKEN SECRET****** la lunga stringa di cifre elencata a lato del campo Access Token Secret nella scheda OAuth del vostro account.

Aggiunta della logica di programmazione Nell’ultima parte della preparazione del codice si deve collegare quella parte che rileva il magnete che provoca il lancio del tweet. Sostituite il codice di test del ciclo principale con il seguente: void loop(){ entryValue = analogRead(entryPin); Serial.println(entryValue); // Uncomment this line to monitor the readings if (entryValue < 50){ entering=true; sendTweet(); } exitValue = analogRead(exitPin); if (exitValue < 50){ entering=false; sendTweet(); } delay(10); } void sendTweet(){ if (twitter.is_ready()) { char tweet[140]; timestamp = twitter.get_time(); if(entering){ sprintf(tweet, “%02d:%02d:%02d: %s”, hour(timestamp), minute(timestamp), second(timestamp), entryMessage); } else { sprintf(tweet, “%02d:%02d:%02d: %s”, hour(timestamp), minute(timestamp),


second(timestamp), exitMessage); } Serial.println(tweet); Serial.print(“Posting to Twitter: “); if (twitter.post_status(tweet)){ Serial.println(“Status updated”); } else{ Serial.println(“Update failed”); } } delay(10000); // wait 10 seconds to avoid double triggering }

Questo è il punto in cui si svolge tutta l’azione. Come nel codice scritto per collaudare i sensori a effetto Hall, il ciclo principale controlla se il magnete è stato rilevato al pin di ingresso o al pin di uscita, utilizzando un’istruzione condizionale if. Qui è stato impiegato un valore minore di 50, ma il vostro magnete potrebbe produrre valori leggermente differenti, che dovrete pertanto regolare in modo appropriato. Utilizzate semplicemente un valore che sia significativamente inferiore rispetto al valore intermedio rilevato quando non è presente alcun magnete durante il collaudo. Se il magnete viene rilevato da uno dei due sensori, la variabile booleana entering viene impostata a true o a false e viene richiamata la funzione sendTweet(). La funzione sendTweet() seleziona quale tweet inviare e lo invia a Twitter. Prima di inviare il tweet, occorre comporlo. Utilizzate un array di caratteri temporanei chiamato tweet per memorizzare il contenuto del messaggio, che è costituito da un numero e da un testo. Ogni tweet deve inoltre essere univoco o Twitter lo rifiuterà, considerandolo un messaggio duplicato. Potete farlo prelevando l’ora da Twitter tramite la funzione twitter.get_time() e assegnando il risultato alla variabile timestamp. Ciò produce un valore in tempo Unix che è possibile convertire in ore, minuti e secondi in fase di assemblaggio del tweet. Questo timestamp viene collocato all’inizio di ciascun messaggio, garantendo pertanto che ogni tweet sia univoco. L’istruzione if condizionale decide se inviare messaggi di ingresso o di uscita, controllando il valore della variabile entering. Il messaggio, di ingresso o di uscita, viene assemblato in modo analogo utilizzando la particolare funzione C sprintf(). Date un’occhiata alla seguente funzione nel caso di entryMessage: sprintf(tweet, “%02d:%02d:%02d: %s”, hour(timestamp), minute(timestamp), second(timestamp), entryMessage);

La funzione sprintf() concatena il timestamp e il testo del messaggio nell’array di caratteri tweet, che è il primo elemento inviato fra parentesi. Poi si trova il messaggio stesso, fra doppi apici. Il messaggio viene costruito dai risultati della conversione del tempo Unix della variabile timestamp in ore, minuti e secondi, utilizzando le funzioni hour(timestamp), minute(timestamp) e second(timestamp) che seguono gli apici. I risultati di queste conversioni vengono inseriti in ordine sequenziale fra gli apici. I caratteri %02d specificano che le ore, i minuti e i secondi sono valori decimali costituiti da due posizioni decimali. I segni “:” sono separatori e vengono inseriti come normale testo. Infine, %s è il punto in cui viene inserita la stringa entryMessage. Questo è il testo che state inviando nel tweet. Il messaggio exitMessage viene composto allo stesso modo. Il tweet risultante viene inviato al Monitor seriale, in modo che sia facile da correggere, insieme al timestamp e ai messaggi di stato di Twitter. Il codice attiva una comunicazione Twitter utilizzando la funzione twitter.is_ready(). Quando il risultato è true, Twitter è pronto a ricevere il tweet. La funzione twitter.post_status() invia il tweet memorizzato nella variabile temporanea tweet. La risposta inviata da Twitter viene restituita al Monitor seriale, come indicato nella Figura 11.7, in modo che abbiate la conferma del fatto che il tweet è stato inviato e, in caso contrario, del motivo per cui non è stato accettato.


Figura 11.7 Invio di un tweet. Si vedono anche i messaggi di stato restituiti da Twitter.

L’istruzione delay() alla fine di questa funzione garantisce dieci secondi di tempo di passaggio prima che lo sportello venga nuovamente ricontrollato. Questo impedisce false attivazioni nel caso in cui l’animale sia un po’ incerto sul da farsi, se entrare o uscire!

Per evitare un flusso eccessivo di attività, Twitter limita le comunicazioni a non più di 350 messaggi l’ora. Se l’animale invia più tweet, avete un problema. Tuttavia, durante il collaudo potreste voler fare attenzione a non superare questo limite, il che può essere facile qualora dimenticaste una riga di codice, per esempio l’istruzione delay(). Dopo che avrete inserito tutto il codice, dovreste collaudare il tutto prima di installare i sensori sullo sportello. È molto semplice risolvere i problemi “in laboratorio” piuttosto che una volta che la porta è fisicamente installata. Connettete l’Arduino al router con il cavo Ethernet. Lasciate Arduino connesso al computer tramite il cavo USB, in modo da poter monitorare le comunicazioni sul Monitor seriale e verificare che, al passaggio di un magnete davanti ai sensori, venga effettivamente inviato un tweet. Utilizzate il magnete al neodimio per inviare un tweet o due, per confermare che tutto funzioni correttamente. Quando sarete soddisfatti e avrete visto che tutto funziona correttamente, potrete disconnettere il cavo USB e fornire l’alimentazione alla scheda Arduino tramite un alimentatore apposito.

Modifiche allo sportello del gatto Dopo aver scritto e collaudato il codice, è il momento di preparare lo sportello e di togliere il circuito dalla scheda breadboard. Innanzitutto fissate temporaneamente i sensori in posizione sulla struttura della porta, per riuscire a stimare quanto dovrà essere lungo il cavo da utilizzare, come si può vedere nella Figura 11.8. Il sensore d’ingresso andrà collocato all’interno della struttura e il sensore di uscita all’esterno.


Figura 11.8 Fissaggio con nastro dei sensori in posizione per stimare la lunghezza del cavo.

Scegliere dove collocare i sensori e il magnete richiede un po’ di attenzione. Dovete montarli in una posizione che garantisca che il magnete passi sempre davanti ai sensori, in modo che possa rilevare con affidabilità il movimento dell’animale attraverso lo sportello. Assicuratevi di collocare entrambi i sensori alla stessa altezza, in modo che il magnete possa attivare l’uno e anche l’altro. Non montatelo troppo vicino al perno o la porta non oscillerà a sufficienza per attivare i sensori. Avrete bisogno di fare un giro di prova con l’animale per vedere qual è l’ampiezza di basculamento dello sportello. In questa fase è particolarmente utile avere a disposizione i biscottini. Dopo aver stimato la posizione dei sensori, fate correre i fili dalla posizione in cui si trova lo sportello alla scheda Arduino e al router. Assicuratevi di avere cavo a sufficienza per collegarlo allo zoccolino della parete e allo stipite della porta. Ora tagliate il cavo alla lunghezza giusta, lasciando solo un po’ di agio per lavorare con tranquillità. Successivamente potrete eventualmente accorciare un altro po’ il cavo. Il cavo ha quattro conduttori. L’alimentazione e la terra sono condivisi dai due sensori a effetto Hall. Il terzo e il quarto conduttore sono per i segnali provenienti dai sensori. Dovrete saldare il cavo di estensione a entrambi i sensori. All’estremità di Arduino, utilizzate lo spelafili per rimuovere un po’ di isolante e saldate dei contatti ai fili. La Figura 11.9 mostra come connettere il tutto alla scheda Arduino e allo sportello del gatto.

Figura 11.9 Connessione dei sensori e dei cavi alla scheda Arduino.


Controllate il colore dell’isolante, in modo da sapere quali cavi utilizzare per l’alimentazione, la terra, il sensore di ingresso e il sensore di uscita. Già che avete acceso il saldatore, saldate i sensori all’estremità opposta del cavo. Utilizzate la “terza mano” per trattenere con sicurezza i sensori in modo da eseguire una buona saldatura. Nella figura, le linee che si incrociano sono connesse solo in due punti sulla struttura dello sportello vicino ai sensori, dove indicato da piccoli punti. Dovete saldare questi fili insieme per creare un contatto elettrico affidabile.

Quando saldate i fili ai sensori, fate attenzione a non surriscaldare i componenti. Applicando la punta per più di un paio di secondi, provochereste un surriscaldamento del sensore, in grado di danneggiarlo. Dopo aver saldato i sensori al cavo, è opportuno collaudare nuovamente il tutto, per assicurarsi che il circuito funzioni ancora. A questo punto potete montare i sensori sullo sportello. 1. Connettere i sensori allo sportello con la colla a caldo. Potreste aver bisogno di un piccolo oggetto in plastica, in legno o in altro materiale (per esempio un blocchetto Lego) per sostenere il sensore in modo da poterlo montare sulla superficie della porta. Nel caso rappresentato nella figura, è stato utilizzato un semplice pezzetto di plastica. 2. Rivestite attentamente il sensore con uno strato di colla a caldo, per proteggerlo dall’umidità. 3. Incollate il blocchetto di plastica alla struttura dello sportello, come indicato nella Figura 11.10. In base alla struttura dello sportello, dovrete determinare esattamente come montare il sensore; assicuratevi solo che non intralci il movimento dello sportello, il quale deve poter basculare liberamente. 4. L’ultimo passo consiste nel montare il magnete sullo sportello. Fate basculare lo sportello finché non passerà davanti ai sensori. Assicuratevi che il polo contrassegnato con la “ S “ sia rivolto verso i sensori. Utilizzate una goccia di colla per collegare il magnete alla porta. Il tutto dovrebbe avere l’aspetto rappresentato nella Figura 11.10. Ora a sedetevi, rilassatevi, e godetevi i tweet in arrivo!


Figura 11.10 Montaggio del sensore e del magnete.


Capitolo 12

Una stazione di rilevamento domestica In questo capitolo Realizzazione di sensori personalizzati di temperatura e luce Realizzazione di uno shield “fatto in casa” per Arduino Programmazione della stazione di rilevamento Invio dei dati via Internet

M

olte persone utilizzano schede Arduino per collegare a Internet una varietà sconfinata di oggetti. Il risultato è che abbiamo luci, stazioni meteorologiche e perfino interi edifici cablati in modo da inviare dati online. La scheda Arduino è dotata di un piccolo microcontroller di potenza non banale, in grado di gestire con facilità la raccolta di dati ambientali e il loro invio via Internet. In questo capitolo creeremo una stazione di rilevamento domestica, che raccoglie i dati relativi a luce e temperatura, che invia poi online. La stazione di rilevamento usa uno shield Ethernet per Arduino, in modo che, dopo aver realizzato la stazione, non sarete costretti a lasciare costantemente acceso il computer. La scheda comunicherà direttamente con Internet attraverso il router di casa. Imparerete anche a realizzare dei sensori di temperatura e di luce e a impiegare uno shield fatto in casa per connettervi alla scheda Arduino. Vedremo anche come utilizzare Xively, un servizio Internet, per memorizzare i dati e creare interessanti grafici. Potete condividere i vostri dati con chiunque, sfogliare i dati inviati da altri e generare una pagina web che visualizza automaticamente i grafici dei vostri dati.

Potete scaricare gli schemi elettrici e gli schemi a colori di collocazione dei componenti dal sito del libro (www.hoeplieditore.it/6323-9).

Costruzione dei sensori La stazione di rilevamento utilizza due sensori di temperatura (uno per l’esterno e uno per l’interno) e un sensore di luminosità. Dopo averla realizzata, potrete aggiungere ulteriori sensori analogici. Potete aggiungerne uno anche al frigorifero o anche aggiungere altri tipi di sensori, per esempio per rilevare l’umidità o un sensore del biossido d’azoto, per rilevare la qualità dell’aria.

I componenti Per realizzare il progetto, cominciate a procurarvi tutti i componenti di cui avete bisogno, rappresentati nella Figura 12.1. Una scheda Arduino UNO. Uno shield Ethernet per Arduino. Un cavo Ethernet. Un alimentatore a 12 V CC per la scheda Arduino (non rappresentato in figura). Una certa quantità di cavo elettrico, con un minimo di tre conduttori (avete ampia libertà di


scelta presso i negozi di elettroforniture, di faidate e di hobbistica). Un contenitore modello A000009 per la scheda Arduino (vedi Figura 12.16). Due sensori di temperatura TMP36 (Jameco #278387 o Farnell #1438760). Una fotoresistenza LDR (Light-Dependent Resistor). Una resistenza da 10 kΩ. Una cannuccia grossa. Una basetta stripboard piccola da 10 × 20 fori. Un connettore a pettine per circuito stampato da 6 contatti (Jameco #103393 o Rapid #220520). Una breadboard per il prototipo (opzionale).

Figura 12.1 I componenti necessari per la stazione di rilevamento domestica.

È consigliabile utilizzare una scheda Arduino UNO e uno shield Arduino Ethernet relativamente recenti. Entrambi i prodotti sono leggermente cambiati nel corso degli anni e questo sistema non è stato collaudato con il vecchio hardware. I nuovi shield Ethernet Arduino sono anche più affidabili rispetto ai più vecchi. Avrete bisogno di una fonte di alimentazione a 12 V CC per la scheda Arduino, perché dopo averla programmata non avrete più bisogno di collegarla a un computer.

Se avete un hub o un router dotato di funzionalità POE (Power Over Ethernet), potete realizzare questo progetto senza impiegare alcuna fonte di alimentazione esterna per la scheda Arduino. Il tutto può infatti essere alimentato direttamente dallo shield Ethernet. Attualmente la tecnologia POE non è ancora comunissima, ma sempre più produttori la stanno incorporando nei propri hub e router Ethernet e dunque è sempre opportuno controllare la possibilità di sfruttare questa nuova tecnologia. Avrete bisogno di cavi per collegare i sensori alla scheda Arduino e poi di un cavo per collegare lo shield Ethernet al router. La lunghezza di questi cavi deve essere determinata esattamente sulla


base della posizione in cui dovranno essere collocati i sensori e la scheda Arduino. In particolare è consigliabile utilizzare un cavo Ethernet piuttosto corto (più economico) e collocare la scheda Arduino nei pressi del router, dove è anche più probabile che si possa trarre l’alimentazione.

Assicuratevi che il router abbia una connessione Ethernet disponibile per Arduino e che sia disponibile anche una presa di corrente per l’alimentazione dell’apparecchio. Procuratevi un cavo multicore (ovvero un cavo dotato di più fili interni) per il sensore. Ne esistono in versioni con filo a treccia o solido. Vanno bene entrambe, ma il filo a treccia è più flessibile ed è più facile farlo correre lungo pareti e angoli. Avete bisogno di almeno tre conduttori interni, ma il cavo non deve essere ad alta tensione (va bene da 22 a 24 AWG). Non è il caso di spendere troppo per questo cavo. Per esempio il normale cavo telefonico funziona bene ed è economico. Assicuratevi solo di averne a sufficienza per raggiungere i sensori dalla scheda Arduino. Per il progetto potete utilizzare qualsiasi contenitore. Una qualsiasi piccola scatola è adatta. Se volete fare le cose “per bene”, Newark e Farnell offrono un contenitore speciale per la scheda Arduino e lo shield Ethernet (Figura 12.16, più avanti in questo capitolo) che sarebbe perfetto per questo progetto. Utilizzeremo dei sensori di temperatura TMP36 per rilevare la temperatura ambientale. Sono costituiti da piccoli elementi plastici cilindrici di colore nero chiamati TO-92 e dotati di tre piedini. Questi sensori misurano la temperatura determinando il calo di tensione attraverso un diodo interno, che cambia di una quantità fissa proporzionale alle fluttuazioni di temperatura. Sono economici, molto affidabili e possono essere utilizzati per eseguire misure in gradi Celsius o Fahrenheit. Poiché sono alimentati da Arduino, i sensori TMP36 possono essere soggetti a leggere variazioni di precisione a seconda della quantità di corrente assorbita dalla scheda Arduino e dallo shield Ethernet. Ma in termini di prezzo sono imbattibili. Utilizzeremo poi un LDR (Light Dependent Resistor) e una resistenza da 10 kΩ per rilevare le variazioni nei livelli di luminosità. Il LDR ha un composto chimico depositato sulla superficie, che ne cambia la resistenza a seconda della quantità di luce incidente. Come i sensori TMP36, anche il LDR trae alimentazione da Arduino e dunque il valore che produce in uscita è proporzionale alla luce ambiente, ma può essere leggermente influenzato dal consumo di corrente della scheda Arduino. Il LDR non fornisce misurazioni in unità standard, come microcandele o lumen. Sono disponibili sensori in grado di farlo, che tuttavia sono più costosi. Il progetto produce in uscita valori che vanno da 0 (completa oscurità) a 100 (massima luminosità). Questo è, tuttavia, ciò che vi interessa in realtà sapere. Se avete la possibilità di procurarvi un misuratore di luce, potrete calibrare questi valori in modo che rappresentino precise misurazioni di lumen (oppure potete procurarvi un sensore più sofisticato). Occorre una cannuccia da utilizzare come capsula impermeabile per i sensori, utilizzando la colla a caldo per sigillarla. Nelle tipiche cannucce “grosse” avrete un sacco di spazio per i sensori. Una pistola per colla a caldo dovrebbe già far parte della vostra cassetta degli attrezzi, ma se non ne avete una, è proprio il caso di procurarsela per questo progetto. Sono molto economiche e facili da reperire presso ogni negozio di hobbistica e fai da te. La piccola stripboard sarà la piattaforma per realizzare uno shield autocostruito per i sensori. Non vengono fornite in dimensioni 10 × 20 fori e dunque dovrete acquistarne una più grande e tagliarla fino a raggiungere dimensioni appropriate. È abbastanza facile farlo con un coltellino da hobbistica e un righello in metallo. Basta passare alcune volte sui fori e poi piegarla. Poi potrete saldare il piccolo connettore a pettine a sei contatti per collegare lo shield direttamente ai pin dello shield Ethernet e saldare i cavi provenienti dai sensori direttamente alla stripboard. Prima si devono realizzare le sonde e poi lo shield per i sensori. Quindi potrete saldare i sensori allo shield e collegare il tutto alla scheda Arduino per collaudare il sistema.

Costruzione e collaudo del circuito Prima di realizzare lo shield, è meglio utilizzare una breadboard per collaudare il circuito, da trasferire poi sulla stripboard una volta che il tutto funziona. Lo schema elettrico e il diagramma di collocazione delle parti sono rappresentati, rispettivamente, nelle Figure 12.2 e 12.3. A questo


punto collocate lo shield Ethernet sopra la scheda Arduino. Poi, dopo aver eseguito il collaudo sulla breadboard, vi connetterete ai pin sullo shield, non direttamente sull’Arduino. Per semplicità, lo shield non è illustrato nello schema elettrico, né sullo schema di collocazione delle parti. Create sulla breadboard una linea di terra e una linea di alimentazione, collegando le uscite 5 V e GND a una colonna laterale della breadboard. Aggiungete i due sensori di temperatura e il sensore di luminosità, come indicato nella Figura 12.3. Assicuratevi di non connettere i sensori ai pin analogici 0 e 1, che vengono utilizzati dallo slot per schede SD dello shield Ethernet. Anche se lo slot non verrà utilizzato per questo progetto, è meglio connettere i sensori solo agli ingressi di Arduino e non ad altre parti dell’hardware.

Figura 12.2 Schema elettrico del circuito con i sensori.


Figura 12.3 Esempio di disposizione dei componenti sulla breadboard.

Assicuratevi di utilizzare la resistenza per il LDR. Il LDR fornisce una resistenza che dipende dalla quantità di luce che lo colpisce. Questa parte del circuito è un partitore di tensione, poiché il rapporto fra il LDR e la resistenza fissa fornisce una tensione variabile che potete misurare sul pin analogico 2. Ho collaudato il circuito in piena luce e in completa oscurità e ho trovato che una resistenza da 10 kΩ fornisce una buona gamma di letture, da circa 10 ad appena più di 1000. Potete eseguire i test con il codice sottostante e determinare se la resistenza da 10 kΩ è adatta alla vostra configurazione. Il piedino centrale dei sensori TMP36 fornisce il segnale per i pin analogici 3 e 4. Dopo aver realizzato il circuito sulla breadboard, inserite il seguente codice di test dei sensori nell’ambiente di sviluppo di Arduino: const int lightSensorPin=2; const int tempPin1=3; const int tempPin2=4; void setup() { Serial.begin(9600); } void loop() { float lightLevel = map(analogRead(lightSensorPin),0,1023,0,100); float temperature1 = ((getVoltage(tempPin1) -.5) * 100L); float temperature2 = ((getVoltage(tempPin2) -.5) * 100L); Serial.print(“Temp 1 (‘C): “); Serial.print(temperature1); Serial.print(“, Temp 2 (‘C): “); Serial.print(temperature2); Serial.print(“, Light (V): “); Serial.println(lightLevel); delay(250); } float getVoltage(int pin){ return (analogRead(pin) * .004882814); }

Prima di caricare il codice sulla scheda Arduino, dedicate un istante a capire come funziona. Per


prime vengono le dichiarazioni di variabili per i tre pin degli input analogici utilizzati per i sensori. Si tratta di costanti intere, poiché questi valori non cambiano durante l’esecuzione del programma. La sezione Setup() deve solo preparare la porta seriale. I pin analogici vengono utilizzati come input per impostazione predefinita e dunque non è necessario definirli esplicitamente come INPUT. Il ciclo principale non fa altro che prendere le letture dai tre pin analogici, convertirle in valori numerici utili e inviarle sullo schermo.

Conversione del livello di luminosità Come abbiamo detto in precedenza, il livello di luminosità non è calibrato in lumen o microcandele. È semplicemente un valore compreso fra 0 e 100, adattissimo a dare un’idea del livello di luminosità e oscurità; nel corso del tempo potrete dire quanta luce c’è semplicemente osservando la scala. La lettura della tensione sul pin analogico 2 viene memorizzata come un valore float, lightLevel: float lightLevel = map(analogRead(lightSensorPin),0,1023,0,100);

Il valore fornito da un pin analogico va da 0 a 1023, in incrementi di circa 5 mV. Tuttavia, la funzione map() converte il tutto in valori da 0 a 100, per comodità: il suo primo parametro è il valore numerico sul pin analogico; i due parametri successivi specificano l’intervallo previsto di questo valore (01023); gli ultimi due parametri specificano l’intenzione di convertire il valore rilevato in un valore tratto dall’intervallo 0-100. Potete utilizzare la funzione map() in molte situazioni in cui volete eseguire una conversione da una gamma di valori a un’altra. Pertanto è importante conoscerne il funzionamento.

Conversione della temperatura I sensori di temperatura forniscono un valore in mV (millivolt) proporzionale alla temperatura rilevata: float temperature1 = ((getVoltage(tempPin1) -.5) * 100L);

Questa conversione ottiene innanzitutto la tensione sul pin analogico, utilizzando la funzione getVoltage() che si trova proprio alla fine dello sketch. Fra parentesi si specifica da quale pin si vuole ottenere la tensione. Convertite poi la tensione in gradi Celsius, sottraendo un offset di 500 mV e moltiplicando il risultato per 100. La “L” chiede ad Arduino di utilizzare un intero a 32 bit per calcolare il valore. Il risultato in gradi Celsius viene poi memorizzato nel valore temperature1, di tipo float. Poi potete inviare i valori memorizzati per la temperatura e la luce al Monitor seriale, in modo da poter verificare che i sensori funzionino correttamente. La funzione getVoltage() prende come input un intero. L’intero “pin” è una variabile locale che memorizza il numero del pin analogico che si vuole leggere. Richiamando questa funzione, le passate tale numero (che è memorizzato nella variabile tempPin1 o tempPin2). Questa legge il pin specificato e ottiene un valore compreso fra 0 e 1023, moltiplicandolo per 0,004882814 per convertirlo in una tensione. Viene utilizzato il moltiplicatore 0,004882814 poiché i numeri fra 0 e 1023 rappresentano in realtà valori di tensione compresi fra 0 e 5 V, con incrementi di circa 5 mV. Il risultato viene poi passato alla parte del programma in cui avete richiamato la funzione. Ora provate a eseguire il codice sulla scheda Arduino. Caricate lo sketch e aprite il Monitor seriale. L’output sarà simile a quello rappresentato nella Figura 12.4.


Figura 12.4 L’output prodotto dal test dei sensori.

Calibrazione dei livelli di luminosità Esaminate i valori ottenuti per il livello di luminosità coprendo il LDR con la mano e poi spostandola. Prendete nota dei valori che ottenete quando il sensore è completamente coperto e quando è completamente esposto alla luce solare nel punto in cui il sensore verrà situato. I valori andranno tra circa 0 (oscurità) a un valore pari a circa 1023. Sostituite i valori nel codice in modo che questi numeri siano nell’intervallo di valori adatto per la conversione del livello di luminosità. Supponete di aver letto il valore 5 quando il sensore è completamente coperto e 980 in piena luce. Potete modificare la mappa delle conversioni di luminosità nel seguente modo: float lightLevel = map(analogRead(lightSensorPin),5,980,0,100);

Questa riga converte i valori che riceverete come livello di luminosità in un intervallo standard compreso fra 0 e 100. Una volta che sarete soddisfatti e che il codice funzionerà correttamente, potrete realizzare le sonde per i sensori e lo shield a cui connetterli. Successivamente, creerete un account Xively e caricherete il codice per i tre sensori. Se l’output non sembra corretto, controllate innanzitutto i collegamenti e poi verificate che il codice sia esatto prima di procedere. Dovete assicurarvi che questo circuito funzioni a dovere, prima di costruire i sensori e lo shield. Salvate lo sketch. Ne avrete bisogno quando dovrete scrivere il codice da inviare a Xively.

Realizzazione delle sonde per i sensori Per questo progetto realizzerete tre sonde e dunque potete risparmiare tempo creandole tutte e tre insieme. Per ogni sensore di temperatura che realizzate, dovrete saldare tre fili del cavo multifilo al sensore TMP36 e poi racchiudere il tutto in una cannuccia accorciata, per proteggerlo. Il sensore di luce funziona più o meno allo stesso modo, ma usa solo due fili.

Prima di iniziare, misurate la lunghezza del cavo per raggiungere il punto in cui volete collocare i sensori dal punto in cui è situata la scheda Arduino. È opportuno che queste lunghezze siano abbastanza corrette prima di iniziare le operazioni di taglio dei fili e saldatura. Per fabbricare le sonde, procedete nel seguente modo.


1. Tagliate il cavo per le sonde di temperatura alle lunghezze corrette. 2. Spelate circa 2 cm di isolamento dal cavo e separate tre dei fili interni. Potete tagliare anche tutti gli altri fili, perché avrete bisogno solo di tre conduttori per ogni sensore di temperatura: alimentazione, terra e segnale. Se il cavo contiene fili con isolante rosso, nero e giallo, utilizzate questi fili, in modo da non confonderli nel momento in cui realizzerete lo shield. Il colore dell’isolante è arbitrario, ricordate solo quale filo elettrico utilizzate per quale piedino. 3. Utilizzate la punta del saldatore per saldare un po’ di stagno sulle estremità dei fili, per migliorare l’adesione sui piedini dei sensori. Può essere difficile saldare i fili direttamente sui piedini del sensore, specialmente per chi non ha quattro mani. Un metodo consiste nello sciogliere una goccia di stagno sul filo del sensore. Quando lo salderete al sensore, questa goccia si fonderà insieme al piedino del sensore e avrete così un forte contatto elettrico. Potrete sempre ritornare e aggiungere un altro po’ di stagno. Quando la saldatura si sarà raffreddata, controllatela per assicurarvi che sia efficace e poi tirate delicatamente il cavo per verificarne la resistenza. 4. Allargate un po’ piedini del TMP36 e saldatevi i tre fili, come illustrato nella Figura 12.5. Con il lato piatto del sensore rivolto a voi, l’ordine di saldatura, da sinistra a destra è: positivo, segnale, negativo.

Figura 12.5 Saldatura del sensore di temperatura.

5. Saldate il secondo sensore di temperatura allo stesso modo. 6. Per il sensore di luminosità, saldate solo due fili al LDR, uno per l’alimentazione e uno per il segnale, come indicato nella Figura 12.6. In questo caso ho utilizzato i fili rosso e giallo. 7. Per ognuna delle tre sonde, tagliate un pezzo di cannuccia da 5 cm. Ogni pezzo di cannuccia dovrà essere lungo a sufficienza per ospitare il sensore e i contatti esposti. 8. Per ciascun sensore, utilizzate una goccia di colla a caldo per evitare che i contatti si tocchino, come illustrato nella Figura 12.7. Non mettete troppa colla o i sensori non scorreranno più nella cannuccia. Inoltre attendete che la colla sia completamente fredda.


Figura 12.6 Saldatura del sensore di luminosità.

Figura 12.7 Potete tenere i piedini in posizione con un po’ di colla a caldo.

9. Una volta che la colla si sarà raffreddata, controllate che ogni sensore scorra tranquillamente nella cannuccia, come indicato nella Figura 12.8. Assicuratevi però che i contatti non si tocchino fra loro o avrete un cortocircuito. La goccia di colla a caldo che avete apposto nel Passo 8 dovrebbe evitare proprio questo.


Figura 12.8 Collaudo dello scorrimento dei sensori.

10. Fate scorrere i sensori nelle cannucce, in modo che il sensore si trovi a un’estremità. Applicate una goccia di colla a caldo all’estremità di ogni sensore, come illustrato nella Figura 12.9. Fate attenzione a non applicare troppa colla sul sensore di luminosità. 11. Prima che la colla si raffreddi, trascinate ciascun sensore verso l’interno della cannuccia appena un pochino, per creare una piccola depressione concava sulla superficie della colla. Ciò rivela eventuali bolle d’aria. Volete assicurarvi che la goccia di colla a caldo blocchi l’acqua. Aggiungete un altro po’ di colla, se necessario, e attendete che si raffreddi. 12. Capovolgete il sensore e applicate altra colla a caldo nel punto in cui il cavo entra nella cannuccia, assicurandovi ancora di avere una chiusura impermeabile, come illustrato nella Figura 12.10.

Figura 12.9 Sigillate le estremità dei sensori di temperatura e di luminosità.


Figura 12.10 Il sensore terminato con la chiusura impermeabile.

Realizzazione dello shield per i sensori Lo shield per i sensori offre un modo ordinato per connettere le sonde alla scheda Arduino e semplifica la loro rimozione quando non ne avrete più bisogno. Lo shield svolge una funzione simile a una piccola breadboard, offrendo più connessioni di alimentazione e di terra, ma è una soluzione più permanente e affidabile. Potete espanderlo, su una scheda Arduino UNO, con un massimo di altri due sensori.

Dopo aver realizzato questo shield, potete adottare la stessa tecnica anche per rendere più definitivi altri progetti Arduino. Per creare lo shield per i sensori, procedete nel seguente modo. 1. Utilizzate la scheda Arduino per mantenere dritti i contatti a pettine, mentre li saldate sulla stripboard. Se i contatti sono connessi fra loro, suddivideteli in gruppi di 2, 2 e 3. 2. Inserite i pin nei contatti Arduino oppure nello shield Ethernet, come illustrato nella Figura 12.11. Due pin andranno ai pin digitali 6 e 7. Due pin andranno ai pin +5V e GND. Tre pin andranno ai pin analogici 2, 3 e 4. 3. Collocate con delicatezza la basetta stripboard sui piedini che avete appena fissato, con le piste in rame rivolte verso l’alto. Fate attenzione a non piegarli.


Figura 12.11 Utilizzate una scheda per collocare con sicurezza i piedini, in modo da saldarli alla basetta stripboard.

I pin corrispondenti ai pin digitali 6 e 7 non saranno connessi al circuito dei sensori. Sono stati previsti solamente per dare allo shield dei sensori la necessaria stabilità meccanica. 4. Saldate con cura i pin alle piste di rame, come illustrato nella Figura 12.12, assicurandovi di non creare ponticelli di stagno fra due piste di rame adiacenti. Non volete che le piste siano connesse elettricamente le une alle altre. 5. Rimuovete lo shield dalla scheda Arduino e ispezionate i pin per assicurarvi che i contatti siano ben saldati. I due pin a sinistra rappresentano le linee di alimentazione e di terra. I tre pin a destra rappresentano gli input analogici. Gli altri due non sono connessi al circuito. 6. Ora aggiungete alla basetta millefori la resistenza da 10 kΩ. Un lato della basetta avrà ora cinque pin saldati. Ponendo questi pin in alto, inserite i piedini della resistenza attraverso il lato della basetta senza piste di rame. Dovete inserirne i piedini sulla seconda e sull’ottava pista di rame, come illustrato nella Figura 12.13. Non conta, in realtà, su quale riga collocate la resistenza. Potete utilizzare una riga qualsiasi, ma dovete lasciare spazio per i cavi dei sensori.


Figura 12.12 Saldatura dei pin in posizione.

7. Piegate leggermente i piedini della resistenza per tenerla in posizione. Quindi ruotate la basetta e saldate la resistenza sulle piste di rame, come illustrato nella Figura 12.13.

Figura 12.13 Aggiunta della resistenza allo shield dei sensori.

8. Ora collegate il sensore di luminosità alla basetta millefori. Spelate circa 5 mm di isolante dal filo del sensore e inserite uno dei due fili nella colonna più a sinistra dei fori, la linea di alimentazione. Inserite l’altro filo nella stessa colonna, proprio a lato del piedino della resistenza, che è connessa al pin che va all’input analogico 2 della scheda Arduino. L’aspetto dovrebbe essere quello rappresentato nella Figura 12.14. 9. Ruotate la basetta e saldate il cavo sulla pista di rame sul lato opposto. 10. Connettete i cavi del sensore di temperatura sotto il cavo del sensore di luminosità, come illustrato nella Figura 12.14. Inserite il filo attraverso i fori e saldate i fili di alimentazione a 5 V sulla linea di alimentazione a sinistra.


Figura 12.14 Saldatura dei cavi dei sensori allo shield dei sensori.

11. Saldate i fili di terra alla successiva colonna di fori, che è la linea di terra. 12. Saldate i fili del segnale alle colonne per i pin analogici, rispettivamente, 3 e 4. Controllate la Figura 12.14 per assicurarvi di avere saldato correttamente tutti i contatti. 13. Inserite lo shield dei sensori sopra lo shield Ethernet connesso ad Arduino. Assicuratevi che i pin analogici si allineino con i fori degli input analogici 2, 3 e 4, come illustrato nella Figura 12.15.

Fate estrema attenzione a non sbagliare: verificate bene di aver inserito correttamente lo shield dei sensori! Quando avrete terminato di realizzare e installare lo shield, potrete inserire la stazione di rilevamento in un contenitore. Quello rappresentato nella Figura 12.16 non solo ospita i cavi, ma ha anche una particolare sagomatura per lo shield Ethernet.


Figura 12.15 Inserimento dello shield dei sensori. Verificate con cura di aver inserito lo shield nei pin corretti!

Figura 12.16 Installazione della stazione di rilevamento nell’apposito contenitore.

Solo questo giustifica il prezzo d’acquisto. Fissate i cavi del sensore nel contenitore. con una fascetta e una goccia di colla a caldo. Anche un po’ di nastro isolante può funzionare. Una volta terminata la realizzazione, collaudate lo shield dei sensori utilizzando il codice. Quando ne sarete soddisfatti e avrete verificato che tutto funziona correttamente, come sulla breadboard, potrete creare un account su Xively per inviare i dati a Internet.

Creazione di un account Xively Certamente è possibile predisporre un sito web che riceva dati dalla scheda Arduino e li visualizzi in tempo reale, ma per farlo occorre un certo know-how, molto impegno e una certa pazienza. Perché allora fare tutto questo lavoro quando qualcun altro si è già occupato di tutti gli aspetti più noiosi? Potete utilizzare un servizio gratuito fornito da Xively.com che svolge tutto il lavoro di raccolta dei dati. Potete perfino realizzare diagrammi e grafici sulla base dei dati inviati, che potete condividere con amici o includere in un vostro sito web. E il tutto a un prezzo imbattibile! Su Xively configurate dei device e assegnate loro uno o più canali. Configurate il vostro Arduino come un device e assegnate a ogni sensore un canale. Il tutto viene visualizzato sulla pagina web del device o feed. Gestite il tutto utilizzando un vostro Xively Workbench. Per configurare la scheda Arduino per l’invio dei dati a Xively, avete bisogno di un account da sviluppatori. Xively fornirà un Feed ID per l’account e una chiave API (Application Programming Interface) per il device (la scheda Arduino). La chiave API consente di inviare i dati del sensore domestico e offre un po’ di sicurezza: solo voi avrete accesso ai dati inviati. Per configurare il tutto procedete nel seguente modo. 1. Aprite con il browser web il sito Xively.com e fate clic sul pulsante Get Started per creare un Developer Account. Riceverete per posta elettronica un link per l’attivazione dell’account. All’attivazione, vedrete una pagina Test Drive che, inizialmente, potete ignorare. Potrete comunque consultare la guida più avanti, quando avrete maggiori dettagli del funzionamento di base di Xively. 2. Per connettere la scheda Arduino, fate clic sul pulsante Develop in cima alla pagina. Nella pagina Development Devices, fate clic sul pulsante Add Device (Figura 12.17). 3. Digitate un nome descrittivo per la stazione di rilevamento domestica.


Figura 12.17 Aggiunta di un device allo Xively Developer Workbench.

4. Scegliete la privacy dei dati prodotti dal device: privata o pubblica. Quando un dispositivo è privato, tale dispositivo genera dati che sono accessibili solo a voi (e a coloro ai quali consentite l’accesso). Le informazioni non verranno elencate nella directory pubblica online di Xively. Quando invece il dispositivo è pubblico, tutti i dati creati possono essere copiati, condivisi e modificati da chiunque, anche per scopi commerciali. 5. Fate clic sul pulsante Add Device, in fondo alla pagina. Dopo aver aggiunto il device Arduino, vi troverete in Xively Workbench. Questo è il luogo in cui gestirete il device e i suoi canali. Nella pagina troverete un Feed ID e una chiave API (Figura 12.18). 6. Fate clic sul pulsante Add Channel per creare al device un canale per il livello di luminosità. 7. Configurate l’ID del canale, come illustrato nella Figura 12.19. Il primo sensore è quello del livello di luminosità, pertanto potete digitare la parola light nel campo ID. 8. Configurate le caratteristiche del canale. Potete aggiungere i tag che volete, che tuttavia sono opzionali. Lasciate il campo Units vuoto. Poiché state misurando i livelli di luminosità con una scala arbitraria, compresa fra 0 e 100, digitate of 100 nel campo Symbol. 9. Fate clic sul pulsante Save Channel.


Figura 12.18 Configurazione dei canali per i dati. Prendete nota del Feed ID e della chiave API.

10. Ripetete i passi da 6 a 9 per aggiungere altri due canali per la temperatura, assegnando loro il nome temp1 e temp2. In questo progetto, viene impiegata la scala Celsius. Ma potete utilizzare la scala Fahrenheit modificando il codice. Nel campo Units digitate Celsius (o Fahrenheit) e nel campo Symbol digitate C (o F). I nomi dei canali vengono utilizzati nel codice. Assicuratevi di utilizzare esattamente lo stesso nome di canale che utilizzate qui. Se utilizzate nomi differenti, dovrete modificare il codice specificando tali nomi o i dati del sensore non verranno inviati a Xively. 11. Prendete nota del valore Feed ID e della chiave API. Nell’angolo inferiore destro della pagina (Figura 12.19), saranno indicati i codici Feed ID e API di Arduino. Ne avrete bisogno per il codice. Il codice API è molto lungo e dunque è opportuno copiarlo e incollarlo in un documento vuoto o direttamente nel codice. Dopo aver iniziato a inviare dati, potrete accedere ai grafici all’indirizzo Feed URL indicato all’angolo superiore destro della pagina. 12. Per prepararvi per la programmazione, aprite il codice di esempio per il Capitolo 12 dal sito web del libro, copiatelo, incollatelo in un nuovo sketch di Arduino e salvate lo sketch. Prendete il codice di esempio dal sito web del libro (www.hoeplieditore.it/6323-9). Lo modificherete nel prossimo paragrafo del capitolo. Ora avete un account Xively abilitato con tre canali, ma senza dati. Questi verranno aggiornati automaticamente quando invierete i dati per la prima volta.

Figura 12.19 Configurazione del device su Xively.

Programmazione della stazione di rilevamento


Quando avete configurato Arduino come device su Xively, vi sono stati assegnati automaticamente il Feed ID per l’account e la chiave API del device. Dovete programmare la scheda Arduino in modo che specifichi la chiave API univoca del sito a ogni aggiornamento dei dati. Dovrete pertanto modificare il codice d’esempio di questo capitolo in modo che invii i dati utilizzando i codici univoci Feed ID e API che vi sono stati assegnati da Xively. Per programmare Arduino in modo che invii dati a Xively, dovete ottenere due librerie di codice: una per la connessione a Xively e l’altra per utilizzare il protocollo HTTP (HyperText Transport Protocol), chiamata HttpClient, che consente ad Arduino di inviare dati tramite il Web. Le librerie di codice Xively e HttpClient sono incluse nel sito web del libro insieme agli esempi di codice di tutti i progetti all’indirizzo www.hoeplieditore.it/6323-9. Installate le librerie nella cartella libraries di Arduino adatta al vostro sistema operativo. Se non sapete esattamente come fare, la procedura è descritta nel Capitolo 3.

Le librerie di codice Xively e HttpClient vengono aggiornate regolarmente. Potete anche scaricarle dall’archivio di codice di un servizio chiamato github, dove gli sviluppatori memorizzano sempre le versioni più recenti. Gli indirizzi URL di github per le due librerie sono anche ricchi di commenti per il codice.

Il funzionamento del codice Dopo aver installato le librerie, occorre intervenire sul codice di esempio per farlo comunicare con il proprio file e device. Il listato che segue mostra il modo in cui modificare il codice di esempio: #include <SPI.h> #include <Ethernet.h> #include <HttpClient.h> #include <Xively.h> #define API_KEY “***** YOUR API KEY GOES HERE *****” #define FEED_ID ***** YOUR FEED ID GOES HERE ***** byte mac[] = { 0xDE, 0xAD, 0xBE, 0xEF, 0xFE, 0xED }; const int lightSensorPin=2; const int tempPin1=3; const int tempPin2=4; unsigned long lastConnectionTime = 0 const unsigned long connectionInterval = 15000 char sensorId1[] = “light”; char sensorId2[] = “temp1”; char sensorId3[] = “temp2”; // Create three datastreams for the feed XivelyDatastream datastreams[] = { XivelyDatastream(sensorId1, strlen(sensorId1), DATASTREAM_FLOAT), XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT), XivelyDatastream(sensorId3, strlen(sensorId3), DATASTREAM_FLOAT), }; // Wrap the 3 datastreams into one feed XivelyFeed feed(FEED_ID, datastreams, 3); // Create the ethernet client and Xively client EthernetClient client; XivelyClient xivelyclient(client); void setup() { Serial.begin(9600); Serial.println(“Initializing network”); while (Ethernet.begin(mac) != 1) { Serial.println(“Error getting IP address via DHCP, trying again…”); delay(15000); } Serial.println(“Network initialized”); Serial.println(“Ready.”); }

È importante notare nel codice precedente le parti FEED_ID e API_KEY. Dovete sostituirle con quelle


assegnate da Xively rispettivamente al vostro account e device. Tagliatele dalla pagina web e poi incollatele nel codice, per assicurarvi di non commettere errori. La scheda Arduino le utilizza ogni volta che aggiornate i dati sul feed, per autenticarsi sui server Xively. Prima di queste vi sono le quattro librerie incluse nello sketch. Oltre a Xively e HttpClient si utilizzano anche SPI ed Ethernet, per garantire le comunicazioni con lo shield Ethernet e specificarne il funzionamento. Ogni dispositivo connesso a una scheda Ethernet ha un proprio indirizzo MAC (Media Access Control). Sicuramente avrete sentito parlare degli indirizzi IP; gli indirizzi MAC si situano “sotto” gli indirizzi IP, a livello hardware. Ogni elemento hardware di una rete ha un proprio indirizzo MAC univoco. Normalmente questi vengono codificati direttamente sulla scheda dal produttore, ma potete assegnarne loro uno specifico, come è illustrato dal codice seguente. I nuovi shield Ethernet hanno un’etichetta nella parte inferiore, dove è riportato l’indirizzo MAC. Potete specificare tale codice o semplicemente ignorarlo.

Dato che ogni indirizzo MAC è univoco nella rete, non avrete problemi. Solo se nella rete avete due shield Ethernet che eseguono lo stesso codice, dovrete assegnare loro due diversi indirizzi MAC. Dopo l’indirizzo MAC, l’esempio usa gli stessi tre interi per i tre pin analogici tratti dallo sketch di test: const int lightSensorPin=2; const int tempPin1=3; const int tempPin2=4;

Poi il codice dichiara due interi Long per memorizzare in ms il tempo di connessione e il tempo in cui avete inviato per l’ultima volta dati a Xively. Utilizzate questo sistema per stabilire un intervallo di aggiornamento. Il codice specifica 15.000 ms (15 secondi). Per eseguire l’aggiornamento a una frequenza differente, cambiate questo valore. I sensori hanno un proprio ID, che corrisponde ai canali creati su Xively: char sensorId1[] = “light”; char sensorId2[] = “temp1”; char sensorId3[] = “temp2”;

Assicuratevi che i nomi fra doppi apici siano identici ai nomi dei tre canali creati sul device.

I canali vengono aggiornati da un oggetto data stream Xively chiamato datastreams, che è un array contenente i tre sensori. Le tre variabili char identificano univocamente ciascun flusso di dati utilizzato dal feed del vostro account Xively; ogni flusso corrisponde a uno dei tre canali configurati quando avete creato il dispositivo: XivelyDatastream datastreams[] = { XivelyDatastream(sensorId1, strlen(sensorId1), DATASTREAM_FLOAT), XivelyDatastream(sensorId2, strlen(sensorId2), DATASTREAM_FLOAT), XivelyDatastream(sensorId3, strlen(sensorId3), DATASTREAM_FLOAT), };

Ogni flusso di dati è costituito dal proprio sensorID, creato in precedenza, da una variabile per specificare la lunghezza dei dati inviati e da una variabile float che contiene i dati stessi (potete anche utilizzare altri tipi di variabili). Questi valori vengono aggiunti nel momento in cui le letture vengono inviate a Xively. Potete creare molti altri stream, avendo come limite solo la memoria di


Arduino.

Ogni flusso di dati corrisponde ai canali configurati per i dispositivi Xively e dunque avrete bisogno di un flusso di dati (data stream) per ciascun canale. Inserite questi tre flussi insieme per inviarli al feed. Il FEED_ID deriva dalla dichiarazione di variabile in cima al codice che Xively ha creato per voi. L’ultimo valore fra parentesi (3) specifica quanti flussi di dati vi sono: XivelyFeed feed(FEED_ID, datastreams, 3);

Le righe successive creano un client Ethernet e un client Xively che Arduino utilizzerà per l’invio dei dati. La sezione setup() crea una porta seriale in modo da poter visualizzare ciò che accade, per le attività di collaudo e debugging. Inoltre stabilisce la connessione Ethernet sulla rete, utilizzando un indirizzo IP assegnato automaticamente. Potete anche utilizzare un indirizzo IP statico. Il Capitolo 11 descrive come utilizzare un indirizzo IP statico con lo shield Ethernet.

Il funzionamento del ciclo principale Nel loop() principale, le letture vengono inviate a Xively con la funzione sendData(), che si trova proprio dopo loop(). Vi è anche una funzione getData() che verifica ciò che è stato inviato a Xively e lo invia al Monitor seriale. La funzione getData() non è essenziale, ma è comoda per le attività di debugging o di monitoraggio dal vivo. Successivamente si usa la funzione getVoltage() dello sketch di test. Innanzitutto si usano i tre sensori e le funzioni sendData() e getData() in modo da poter inviare tre diverse letture. Ricordate di cambiare i valori nella funzione map() della lettura lightLevel (in grassetto) sulla base dei valori ottenuti dal collaudo dei sensori, come descritto in un paragrafo precedente. void loop() { if (millis() - lastConnectionTime > connectionInterval) { float lightLevel = map(analogRead(lightSensorPin),0,1023,0,100); sendData(0, lightLevel); getData(0); float temperature1 = ((getVoltage(tempPin1) -.5) * 100L); sendData(1, temperature1); getData(1); float temperature2 = ((getVoltage(tempPin2) -.5) * 100L); sendData(2, temperature2); getData(2); Serial.println(“Waiting for next reading”); Serial.println(“========================”); lastConnectionTime = millis(); } }

In questo codice, utilizzate lo stesso metodo per ottenere le letture dei sensori che avete utilizzato nello sketch di prova e impiegate le funzioni sendData() e getData() per inviare i valori a Xively. La funzione sendData() invia i valori a ciascun canale e la funzione getData() consente di leggere i dati da Xively per verificare che il codice funzioni correttamente. Il primo parametro della funzione sendData è il sensore a cui inviare i dati, seguito dal valore da inviare. Ricordate che i valori del sensore vengono memorizzati in un array chiamato datastreams[]. Ogni sensore ha una propria posizione nell’array, partendo dal sensore di luminosità, che è alla posizione 0. Questo numero è il primo valore inserito nella chiamata a funzione sendData(), seguito dalla lettura lightLevel appena presa. La funzione getData() contiene lo stesso numero, 0, che fa riferimento al sensore di luce: sendData(0, lightLevel); getData(0);


Per prendere le letture di temperatura, utilizzate lo stesso codice dello sketch di test. Poiché le posizioni per i flussi di dati della temperatura nell’array datastreams[] sono la 1 e la 2, utilizzate questi numeri per le chiamate a funzione sendData() e getData(): sendData(1, temperature1); getData(1);

Vediamo ora come si comportano le funzioni sendData() e getData(). La funzione sendData() accetta due valori: uno per la posizione del sensore nell’array datastreams[] e il secondo per la lettura eseguita. La variabile locale intera streamIndexNumber contiene il numero utilizzato nella chiamata a funzione sendData(): void sendData(int streamIndexNumber, float sensorValue) { datastreams[streamIndexNumber].setFloat(sensorValue); Serial.print(“Sensor value is: “); Serial.println(datastreams[streamIndexNumber].getFloat()); Serial.println(“Uploading to Xively”); int ret = xivelyclient.put(feed, API_KEY); }

La riga successiva memorizza nell’array datastreams[] il valore della lettura appena eseguita, alla posizione specificata dalla chiamata a funzione (0, 1 o 2 a seconda del sensore letto) e imposta il valore letto come un float: datastreams[streamIndexNumber].setFloat(sensorValue);

Il valore viene poi inviato al Monitor seriale. L’ultima riga della funzione invia infine i dati a Xively, utilizzando una funzione tratta dalla libreria Xively, xivelyclient.put(). Questo è il luogo in cui occorre utilizzare la chiave API. Viene utilizzata per verificare che abbiate il permesso di inviare dati al feed. Non comunicate ad altri questa chiave o anche a loro verrà consentito l’invio e la lettura di dati su questo feed. La funzione getData() consente di rileggere ciò che avete appena inviato (o leggere dati da altri feed, se ne avrete la chiave API). Accetta come input un intero e tale intero specifica la posizione del flusso di dati (ovvero del canale) nel feed che contiene i dati del sensore: void getData(int stream) { Serial.println(“Reading the data back from Xively”); int request = xivelyclient.get(feed, API_KEY); if (request > 0) { Serial.print(“Datastream: “); Serial.println(feed[stream]); Serial.print(“Sensor value: “); Serial.println(feed[stream].getFloat()); Serial.println(“========================”); } }

Questa funzione utilizza un’altra funzione interna della libreria Xively, xivelyclient.get(), che accetta il feed Xively utilizzando FEED_ID e API_KEY. Nell’output per il Monitor seriale, specificate esattamente quale stream del feed volete inviare al Monitor seriale: Serial.println(feed[stream]);

Lo stream che inviate è uno dei tre che avete inviato nell’array datastreams[]. Infine, utilizzate semplicemente la funzione getVoltage() dello sketch di test e, finalmente, il codice è completo.

Il senso delle letture dei sensori Ora eseguite un giro di prova. Caricate il codice sulla scheda Arduino e attivate il Monitor seriale. Dovrebbe comparire nella finestra qualcosa di simile all’output rappresentato nella Figura 12.20.


Figura 12.20 Il monitoraggio dei post del feed di Xively nel Monitor seriale.

Per vedere l’aspetto di Xively, andate all’indirizzo URL del vostro feed su Xively. Potete trovare l’URL del vostro feed nell’angolo superiore destro di Xively Developer. Il mio feed è https://xively.com/feeds/1424780519. Sostituite semplicemente al numero finale il vostro FEED_ID. La schermata dovrebbe avere un aspetto simile alla mia, rappresentata nella Figura 12.21. Potete anche alterare l’aspetto del grafico e usare un codice personalizzato, che potete includere in un vostro sito web, blog o pagina Facebook. Sarete sicuramente concordi che questo utilizzo di Arduino e Xively per raccogliere dati da vari sensori e inviarli su Internet apre molte possibilità!

Figura 12.21 Visualizzazione dei dati del sensore su Xively.


Parte IV Progetti avanzati con Arduino

I listati e le risorse grafiche dei capitoli sono disponibili sul sito www.hoeplieditore.it/6323-9.


In questa parteâ&#x20AC;Ś Utilizzo del sistema GPS con Arduino Realizzazione di un registratore di percorsi GPS Costruzione di un cubo led programmabile Uso dei vecchi telecomandi di casa Programmazione dei servomotori


Capitolo 13

Registratore di percorsi GPS In questo capitolo Il sistema GPS Realizzare uno shield GPS Raccogliere i dati tramite il registratore di percorsi GPS Tracciamento del percorso su mappe online e Google Earth

S

enza dubbio avrete già utilizzato il sistema GPS (Global Positioning System) in auto o sul cellulare. Ormai il GPS è ovunque, letteralmente sopra la nostra testa, sempre disponibile. Progettato dalle forze armate degli Stati Uniti per il supporto dei sistemi di difesa, il GPS usa un’intera costellazione di satelliti in grado di fornire precise informazioni di localizzazione a qualsiasi apparecchio capace di ricevere e decodificare il segnale GPS. Questo compito poteva essere complesso, prima del GPS. I primi apparecchi GPS erano grandi come valigette, mentre al giorno d’oggi un ricevitore GPS occupa lo spazio di un orologio da polso! L’unico problema è che gli apparecchi GPS di largo consumo non offrono sufficiente flessibilità per fare ciò che si vuole con i dati GPS. Ecco dove viene in nostro soccorso Arduino! In questo progetto, potete utilizzare una scheda Arduino e un kit per shield GPS per realizzare un ricevitore alimentato a batterie che registra i dati GPS su una scheda SD per parecchie ore. Potete programmare la scheda Arduino per la raccolta dei dati, che poi potete utilizzare come volete. Potete registrare i vostri giri in bicicletta, le vostre escursioni in montagna, le vostre camminate… Potete perfino installare il registratore di percorsi in auto, per registrare le abitudini di guida e le destinazioni. Faticate a ricordare quali parti di una città avete esplorato in vacanza? Non più. Poiché i dati vengono memorizzati in formato standard, potrete anche tracciare un grafico del vostro percorso, utilizzando strumenti online o applicazioni, come Google Earth. La realizzazione di uno shield GPS, in sè, è facile e richiede meno di un’ora. Se non avete mai provato a saldare nulla, questo progetto rappresenta un buon punto di partenza, poiché è piuttosto semplice da realizzare e non correrete troppi rischi di danneggiare nulla, anche se doveste avere problemi di saldatura. Successivamente potrete collaudare il sistema per verificare che funzioni correttamente. Un’altra ora, all’incirca, potrete dedicarla a inserire il tutto, ordinato, in un contenitore. Infine, non dovete fare altro che uscire e raccogliere i dati GPS. Quindi potrete tracciare una mappa online, convertire i dati per utilizzarli con software come Google Earth e perfino scaricare un’immagine del percorso, in caso di necessità.

Il sistema GPS GPS (Global Positioning System) è una costellazione di 32 satelliti che orbitano attorno a noi a una quota di circa 20.200 km. Eseguono un’orbita ogni dodici ore e sono disposti in modo che almeno sei satelliti siano sempre visibili da qualsiasi punto della Terra. Ogni satellite invia segnali che includono la sua esatta posizione e l’ora di invio del messaggio. Ricevendo queste informazioni da un minimo di tre satelliti, un ricevitore GPS è in grado di calcolare la propria posizione, sulla base del tempo impiegato per ricevere i messaggi. Poiché il sistema GPS conta sui segnali provenienti da più satelliti, può essere necessario del tempo prima che il ricevitore GPS si “sincronizzi”. Il GPS conta su connessioni dirette, a vista, e dunque i segnali provenienti dai satelliti possono essere bloccati da palazzi e montagne. Se dalla posizione corrente sono visibili solo due satelliti, non sarà possibile calcolare la posizione geografica in termini di latitudine, longitudine e quota finché non entrerà nel campo un altro satellite. La prima volta che accenderete il progetto, sarà necessario del tempo per determinare la posizione e dunque può essere opportuno collocare il ricevitore (o l’antenna opzionale) in un luogo in cui possano godere di una vista aperta sul cielo.


I componenti Innanzitutto, raccogliete i componenti e gli attrezzi di cui avrete bisogno per realizzare il registratore di dati. Il tutto andrà collocato in un proprio contenitore e dunque sarà necessario praticare qualche foro per l’alimentazione e l’antenna esterna opzionale, se deciderete di usarla. Avrete bisogno dei seguenti componenti, rappresentati nella Figura 13.1. Una scheda Arduino UNO. Uno shield Adafruit Industries Ultimate GPS. Una scheda Micro SD o Micro SDHC. Una batteria da 9 V e relativo connettore. Un interruttore SPST – single pole, single throw (Jameco #316451 o Maplin # N19CL). Un contenitore (Jameco #2134926 o Farnell #1848692), meglio se trasparente (Maplin #N07GC). Una piccola tavoletta di legno da 1 cm di spessore, che entri nel contenitore (opzionale). Tre o quattro viti autofilettanti da circa 1 cm. Un’antenna GPS esterna a montaggio magnetico da 3-5 V, disponibile presso Adafruit o Jameco #2153297 (opzionale). Un cavetto adattatore uFL/u.FL/IPX/IPEX RF (opzionale) che potete trovare da Adafruit o altri rivenditori online. Un adattatore, per leggere la scheda Micro SD dal computer. Potete realizzare questo progetto con una scheda Arduino UNO, Arduino Duemilanove o Arduino Diecimila. Potete anche utilizzare una scheda Arduino LEONARDO o MEGA, ma dovrete modificare il codice. Se pensate di utilizzare una di queste ultime, controllate sul sito web di Adafruit le istruzioni dettagliate per l’utilizzo di schede Arduino diverse dalla UNO. Il cavallo da soma di questo progetto è lo shield Adafruit Ultimate GPS Logger, che contiene tutti i componenti necessari per ricevere e registrare i dati GPS, compreso il ricevitore GPS e uno slot per schede Mini SD. Offre anche un’utile area millefori per l’aggiunta di funzionalità al registratore di dati. La realizzazione del modulo GPS può essere complicata, poiché potrebbero essere necessari alcuni componenti in più per poterlo connettere all’Arduino. Il vantaggio di questo shield è che tutti questi componenti sono già connessi, collaudati e pronti all’uso, e dunque potrete concentrarvi unicamente sulla realizzazione del progetto, evitando di dovervi concentrare sul funzionamento del ricevitore GPS.

Potete scaricare gli schemi elettrici e i diagrammi a colori di collocazione dei componenti dal sito web del libro (www.hoeplieditore.it/6323-9).


Figura 13.1 I componenti necessari per questo progetto.

Al giorno d’oggi, potete trovare una scheda Micro SD o SDHC praticamente ovunque. Potete acquistarne una in un negozio di elettronica di consumo per pochi euro. Dovete solo registrarci dei dati e dunque non avrete bisogno di una scheda troppo capiente. Puntate a qualcosa di economico. Anche una scheda da 2 GB non particolarmente veloce sarà perfetta per memorizzare milioni di posizioni prima di esaurire lo spazio; si esaurirà molto prima la batteria. Dovete assicurarvi di avere un adattatore per schede Micro SD in modo da poter copiare i dati dalla scheda al computer. Potete anche procurarvi un adattatore da SD a USB a poco prezzo su Amazon o eBay. Per poter portare a spasso il registratore di dati GPS, senza un computer appresso, dovrete alimentarlo e dovrete prevedere un modo per accenderlo e spegnerlo. Pertanto avrete bisogno di un’alimentazione a batteria e di un interruttore. Per mantenere il tutto in un contenitore portatile e di dimensioni compatte, utilizzate una batteria standard a 9 V, con relativo connettore. Alimenterete la scheda Arduino direttamente dal clip della batteria, che salderete allo shield GPS. Secondo i test, una normale batteria da 9 V può durare all’incirca cinque ore e mezza. Poiché l’autonomia della batteria è legata all’azione chimica dei materiali che la compongono, batterie di maggiori dimensioni avranno una durata maggiore. Per avere una maggiore autonomia, sostituite la singola batteria da 9 V con un pacco di batterie da 9 V contenente sei batterie in formato stilo (AA), utilizzando sempre lo stesso connettore. Questo vi consentirà di aumentare notevolmente la quantità di dati che potrete raccogliere. Per accendere e spegnere l’apparecchio, potete utilizzare un interruttore slimline, che darà al progetto un tocco professionale ed è molto economico. Il problema dell’utilizzare un interruttore di questo tipo consiste nel fatto che occorre praticare un foro rettangolare nel contenitore. Potete anche utilizzare semplici interruttori a levetta che utilizzano un foro rotondo, ma la levetta sporgerà di lato e potrà quindi essere azionata accidentalmente. Avrete bisogno di un piccolo contenitore in materiale plastico per proteggere il progetto. Un contenitore di plastica ABS è resistente e facile da ritagliare per praticare i fori per l’interruttore e l’antenna. Jameco e Farnell offrono un ottimo contenitore personalizzato per Arduino, che però non consente di vedere le spie di stato e obbliga a impiegare un’antenna esterna. Maplin ne offre una versione trasparente azzurra, che consente di vedere le spie di stato sullo shield. Se utilizzate un contenitore trasparente, potrete evitare del tutto di utilizzare l’antenna esterna, ma è sempre meglio provare, per sicurezza. Un contenitore metallico blocca tutti i segnali e pertanto obbliga a utilizzare un’antenna esterna. La scheda Arduino dovrà essere fissata in modo sicuro nel contenitore, ma raramente i contenitori per progetti offrono i supporti interni corretti per la scheda Arduino. Invece di avvitarla alla plastica, incollerete una tavoletta di legno nel contenitore del progetto, in modo da potervi collegare la scheda Arduino con tre o quattro viti autofilettanti da legno. La lunghezza delle viti dovrebbe coincidere con lo spessore della tavoletta o appena superiore, in quanto l’Arduino non poggerà proprio “contro” il legno.


Se utilizzate un contenitore realizzato in modo specifico per schede Arduino, non avrete bisogno di utilizzare né tavolette di legno, né viti. Il GPS richiede una connessione a vista con i satelliti che forniscono i segnali di tracciamento. Il modulo GPS è dotato di un’antenna integrata, la cui sensibilità, però, è limitata. Un contenitore di materiale plastico non dovrebbe interferire con l’antenna, ma impiegando un’antenna esterna avrete una sensibilità molto superiore, a fronte però di un consumo maggiore. Esistono molte antenne di estensione GPS e quelle con base magnetica possono essere fissate con facilità alla carrozzeria o alla bici. Se la vostra antenna GPS è dotata di un connettore SMA, dovrebbe funzionare.

Lo shield è dotato di un piccolo connettore u.FL, che aiuta a mantenerne la compattezza. Tuttavia, la maggior parte delle antenne GPS usa un connettore coassiale SMA (Sub-Miniature A) filettato. Dunque, per connettere l’antenna GPS allo shield, avrete anche bisogno di un piccolo cavetto adattatore da SMA a u.FL.

Il connettore u.FL è noto con vari nomi industriali, fra cui IPX, IPEX e UMCC, ma la sua struttura è sempre la stessa. È facile trovare un adattatore per questi connettori su eBay o Amazon; anche Adafruit ne vende uno. Se utilizzate un contenitore in plastica come quello presentato nell’elenco dei componenti, avrete bisogno di alcuni attrezzi per praticare nel contenitore i fori per l’alimentatore e l’antenna. Avrete bisogno di un trapano a mano o elettrico e di una punta da circa 7 mm. Se usate un interruttore di forma quadrata, avrete anche bisogno di sagomare il foro con una piccola lima.

Realizzazione del progetto La realizzazione del progetto si svolge in tre fasi. Innanzitutto occorre assemblare lo shield GPS e collaudarlo per assicurarsi che funzioni correttamente. Poi si deve programmare e caricare il codice per attivare il registratore di dati. Infine occorre controllare che funzioni la registrazione dei dati sulla scheda SD. Questo progetto è veramente semplice, non richiede alcuno schema elettrico, nè la realizzazione di un prototipo su breadboard.

Assemblaggio e collaudo dello shield GPS Predisporre questo shield è veramente molto semplice. Non dovete fare altro che collegare i pin e inserire una batteria. Niente di complicato. Innanzitutto, accendete il saldatore e attendete che sia pronto per funzionare. Poi procedete nel seguente modo.


1. Separate i piedini forniti con lo shield in gruppi che corrispondano ai pin di Arduino. Ă&#x2C6; opportuno utilizzare il pin della scheda Arduino e una piccola pinza ad angolo per spezzare esattamente il numero richiesto di piedini, come illustrato nella Figura 13.2. In tal modo, sarete sicuri di ottenere esattamente il numero corretto di pin per ciascun segmento e di spezzare il pettine in modo perfetto. Non correrete il rischio di rompere inavvertitamente il pettine nel punto sbagliato. Fate attenzione a contare con precisione. I connettori Arduino non hanno lo stesso numero di fori!

Figura 13.2 Separazione del pettine nel punto corretto.

2. Utilizzate la scheda Arduino come supporto per i piedini, mentre li saldate allo shield. Inserite i piedini nei pin della scheda Arduino, come indicato nella Figura 13.3.

Figura 13.3 Uso della scheda Arduino come supporto di saldatura.


3. Collocate lo shield GPS sui piedini, bloccati dalla scheda Arduino. Potreste dover “convincere” delicatamente i piedini a entrare nei fori dello shield. Assicuratevi che tutti i pin attraversino lo spessore dello shield e che non vi siano pin mancanti (Figura 13.4).

Figura 13.4 Collocazione dello shield in posizione pronto per la saldatura.

4. Ora saldate i pin allo shield. Se siete “destri”, partite dal lato sinistro (e, viceversa, se siete mancini partite dal lato destro). In tal modo potrete vedere bene il lavoro mentre lo svolgete (Figura 13.5). Dopo aver saldato lo shield ai pin, siete quasi pronti per il viaggio: un collaudo per assicurarsi che lo shield GPS funzioni. Lo shield ha due modalità operative: connessione diretta e software seriale, che si possono selezionare tramite un piccolo commutatore presente sullo shield, rappresentato nella Figura 13.6. In modalità di connessione diretta, l’Arduino non esegue alcun codice. Si comporta come un intermediario per lo shield, in modo che possiate comunicare direttamente con l’interfaccia seriale del modulo GPS. Utilizzate il Monitor seriale dell’ambiente di sviluppo di Arduino per inviare e ricevere direttamente comandi al modulo GPS installato sullo shield. Questa modalità è utile per collaudare l’unità GPS e per inviare i comandi di configurazione qualora vogliate modificarne il comportamento. Quando sarete soddisfatti dei test, potrete riportare lo shield GPS in modalità software seriale.


Figura 13.5 Saldatura dello shield sui piedini.

Figura 13.6 Commutazione delle modalità di comunicazione.

La scheda Arduino ha una porta seriale che utilizza per comunicare con il computer. È connessa fisicamente sia alla porta USB sia ai pin digitali 0 e 1. Tuttavia, quando la scheda Arduino deve controllare il modulo GPS, avrete bisogno di una seconda porta seriale per connetterlo e per inviargli comandi. Ecco dove è comoda la porta seriale. SoftwareSerial è una libreria che consente alla scheda Arduino di utilizzare altri pin per le comunicazioni seriali. È l’unico modo con cui potrete scambiare dati con altri dispositivi mentre, contemporaneamente, dovete monitorare la scheda Arduino tramite il computer. La posizione Soft. Serial del commutatore consente di selezionare questa modalità.

A causa della disposizione dei pin digitali, la connessione diretta utilizzando questo commutatore funziona solo su schede Arduino UNO, Duemilanove, Diecimila, compatibili Arduino o Arduino MEGA. Per utilizzare modalità di connessione diretta per il collaudo del modulo GPS, dovete innanzitutto caricare sulla scheda Arduino uno sketch “vuoto”. Aprite l’ambiente di sviluppo di Arduino e digitate i seguenti comandi in un nuovo sketch: void setup() {} void loop() {}

Salvate questo sketch con un nome facile da ricordare, per esempio “Vuoto”. Portate lo shield in modalità Soft. Serial in modo da poter inviare questo codice alla scheda Arduino. Poi connettete il cavo USB e caricate lo sketch vuoto. Ora che il codice è caricato sulla scheda Arduino, potete collaudare il modulo GPS e monitorare il suo output direttamente dal chip GPS. Riportate il commutatore dello shield di nuovo in posizione Direct, come illustrato nella Figura 13.7. Ciò connette la porta seriale USB direttamente al modulo


GPS. Successivamente, quando sarete pronti per utilizzare lo shield per la registrazione dei dati, lo riporterete nella posizione Soft. Serial.

Se avete caricato il codice dello sketch vuoto, il led rosso FIX dello shield dovrebbe lampeggiare a una frequenza di un secondo. In caso contrario, potreste dover spegnere e riaccendere la scheda. Disconnettete il cavo USB, assicuratevi di aver posizionato il commutatore nella posizione Direct e riconnettete la porta USB. Se il led rosso non lampeggia ancora, probabilmente avete un problema con la saldatura della scheda. Aprite l’ambiente di sviluppo di Arduino e fate clic su Monitor seriale, assicurandovi di configurarlo a 9600 baud tramite il menu a discesa. Dovreste vedere un output simile a quello rappresentato nella Figura 13.8. In questo caso, il modulo funziona correttamente, anche se non ha ancora rilevato satelliti. Però invia dati, e questo ci basta per sapere che sta funzionando.

Figura 13.7 Commutazione in modalità Direct Connection per il collaudo del modulo GPS.

Figura 13.8 Visualizzazione dell’output diretto dal modulo GPS.


Il testo è abbastanza difficile da interpretare, a meno che sappiate esattamente ciò che sta dicendo il modulo GPS. Utilizza il formato NMEA (National Marine Electronics Association) e produce in output dati per quattro diversi standard GPS, ognuno su una riga distinta, preceduta dal segno $. Siamo interessati alle righe $GPRMC (Global Positioning Recommended Minimum). Questa riga fornisce le seguenti informazioni, il cui significato è rappresentato nella Figura 13.9.

Figura 13.9 Interpretazione dei dati grezzi NMEA inviati dal modulo GPS.

Il formato NMEA utilizzato. L’ora del meridiano di Greenwich (GMT – Greenwich Mean Time). Un codice di “aggancio” dei satelliti: A (Attivo) o V (Void/non valido). La longitudine in gradi decimali. L’emisfero della longitudine: N (nord) o S (sud). La latitudine in gradi decimali. L’emisfero della latitudine: E (est) o (W) (west, ovest).

La latitudine, la longitudine e gli emisferi non contengono nulla se non è ancora avvenuto l’aggancio e dunque otterrete solo virgole, senza dati, a meno che siate all’esterno e abbiate già agganciato dei satelliti. La velocità di spostamento (in nodi). L’azimut o direzione di viaggio. Un azimut è solo una direzione a “bussola”, ovvero un angolo orizzontale attorno all’orizzonte, misurato in gradi (0-360): 0 è il nord, 90 è l’est, 180 è il sud e 270 è l’ovest. La data UTC (Coordinated Universal Time), a partire dalla settimana 1 del “tempo GPS” (che è iniziato nel gennaio 1980). Questo dato verrà aggiornato non appena il GPS riceverà l’effettiva ora dai satelliti, ma per il momento non ne ha ancora contattato nemmeno uno. Un checksum, preceduto da un asterisco, che controlla che i dati non contengano errori. Se ricevete queste informazioni, sapete che l’unità GPS è operativa e siete pronti per andare a


caccia di satelliti! Se utilizzate un PC portatile, potete andare all’esterno per agganciare i satelliti GPS. Se utilizzate un sistema desktop e il cavo di estensione opzionale con relativo adattatore, potreste riuscire a ottenere un segnale anche poggiando l’antenna su un davanzale. Collegate l’antenna come descritto alla fine del capitolo, per assicurarvi che il modulo funzioni, prima di realizzare il contenitore. Abbiate pazienza! Può volerci un po’ per riuscire ad agganciare i satelliti GPS. Nel migliore dei casi, il tutto richiederà solo un minuto. Tuttavia potreste dover attendere anche dieci o quindici minuti o anche di più, a seconda della situazione momentanea. Ma dopo aver agganciato i satelliti, riceverete i dati aggiornati ogni secondo. Il modulo GPS inizierà anche a inviare al Monitor seriale i dati relativi alla posizione.

Il led rosso FIX dello shield lampeggerà con una frequenza di un secondo fino all’aggancio. Successivamente lampeggerà una volta ogni quindici secondi, sempre che abbia mantenuto l’aggancio ai satelliti. Se perderà l’aggancio, tornerà a lampeggiare una volta al secondo. Se riuscite a portare il modulo GPS all’esterno o se state utilizzando l’antenna esterna opzionale, potreste riuscire ad agganciare satelliti mentre siete connessi direttamente al modulo GPS. Il codice di stato passerà a “A” e comincerete a ricevere le informazioni relative a latitudine e longitudine.

Lo shield GPS è dotato di un orologio interno in tempo reale (RTC – Real Time Clock). La batteria a bottone lo alimenta anche da spento. Tuttavia, il modulo GPS preleva l’ora dai satelliti e dunque non avrete bisogno dell’orologio, a meno che lo impieghiate nel codice di supporto. Se inserite la batteria a bottone, il modulo GPS potrebbe smettere di funzionare dopo circa venti secondi, a meno che abbiate configurato il RTC. Dunque non installate la batteria durante il collaudo.

Programmazione del registratore di dati Ora che avete attivato la comunicazione diretta con il modulo GPS, potete caricare il codice per la registrazione dei dati sul modulo SD.

Dovete riportare il modulo GPS in modalità Soft. Serial se non state comunicando direttamente con il modulo GPS. Tutto il codice caricato sulla scheda deve operare in modalità Soft. Serial. Il codice di questo progetto si trova nel sito web del libro (www.hoeplieditore.it/6323-9), in un file compresso nel quale troverete i seguenti file. Lo sketch di registrazione dei dati da eseguire sulla scheda Arduino, shield_sdlog. Una libreria di interfacciamento con il modulo GPS, Adafruit_GPS. Una libreria di scrittura dei dati sulla scheda, SD. Una libreria per la creazione di porte seriali “virtuali”, SoftwareSerial.


SoftwareSerial è una “libreria base” e dunque fa parte dell’installazione dell’ambiente di sviluppo

Arduino 1.0. Se utilizzate una versione meno recente dell’ambiente di sviluppo, dovreste aggiornarla. Potete trovare queste librerie online o su github, il sito web di condivisione del codice (https://github.com/adafruit/Adafruit-GPS-Library). Ma per semplificare le cose, trovate tutto nel file compresso del Capitolo 13, scaricabile dal sito web del libro. Potete scaricarlo ora ed estrarre i file sul sistema.

Per semplificare le cose, ho nominato la libreria Adafruit del sito web del libro come Adafruit_GPS. La libreria Adafruit su github si espande in Adafruit-GPS-Library-master e dovrete rinominarla perché il codice funzioni correttamente. Per informazioni sull’installazione delle librerie, consultate il Capitolo 3. Dopo aver scaricato i file, lanciate l’ambiente di sviluppo di Arduino. Se è già in funzione, dovrete riavviarlo, in modo che le nuove librerie compaiano nel menu. Ora selezionate il comando File Esempi Adafruit_GPS shieldlog_sd. Non è necessario entrare in tutti i dettagli del funzionamento del codice, ma dovreste concentrarvi sulle seguenti righe: // see if the card is present and can be initialized: if (!SD.begin(chipSelect, 11, 12, 13)) { //if (!SD.begin(chipSelect)) { // if you’re using an UNO, // you can use this line instead Serial.println(“Card init. failed!”); error(2); }

Questo progetto utilizza una scheda Arduino UNO e dunque dovrete aggiungere due barre per commentare la prima riga e rimuovere il commento dalla seconda riga, che inizia con if (!SD.begin. Altrimenti otterrete un errore. La parte rimanente del codice svolge le seguenti operazioni. Crea la variabile GPSECHO, che deve essere lasciata impostata a true mentre si esegue il collaudo del modulo. Invia tutti i dati alla porta seriale, per consentirvi di vedere ciò che sta accadendo. Successivamente, potete disattivare questa funzionalità. Crea la variabile LOG_FIXONLY, che si assicura che le voci vengano registrate sulla scheda SD solo se il modulo GPS ha agganciato i satelliti. Lasciate questa variabile a false per tutta la durata del collaudo. Si assicura che siate in grado di scrivere sulla scheda SD un nuovo file, che verrà numerato in modo sequenziale. Stabilisce la comunicazione con il modulo GPS e poi lo avvia. Scrive sulla scheda SD i dati ricevuti dal modulo GPS, all’interno del file che ha appena creato. Ogni volta che accendete il modulo viene creato un nuovo file con un numero sequenziale di due cifre. Dedicate un istante a studiare il funzionamento del codice, prima di caricarlo sulla scheda Arduino.


Se prevedete di provare altri sketch d’esempio inclusi nella libreria Adafruit (un esercizio altamente raccomandabile), assicuratevi di modificare le righe che fanno riferimento a SoftwareSerial nella parte superiore dello sketch, in modo da utilizzare i pin 7 e 8 al posto dei pin 2 e 3. Altrimenti non vedrete alcun output sul monitor seriale.

Collaudo del registratore di dati Dopo aver apportato le modifiche al codice, connettete alla scheda Arduino il cavo USB, selezionate la porta seriale corretta nell’ambiente di sviluppo e caricate il codice. Non avete bisogno di togliere lo shield GPS prima di caricare il codice. Assicuratevi solo che il commutatore sia impostato su Soft. Serial. Quando il caricamento sarà terminato, attivate il Monitor seriale nell’ambiente di sviluppo. Assicuratevi che il baud rate sia impostato a 115200 o, nel Monitor seriale, otterrete caratteri senza senso. Se siete ancora al chiuso, dovreste ricevere un output molto simile a quello che avete ottenuto quando eravate connessi direttamente al modulo GPS durante il collaudo. Se invece siete all’aperto o se avete utilizzato un’antenna GPS esterna collocata fuori dalla finestra, potreste iniziare a vedere alcuni dati GPS in arrivo. La Figura 13.10 mostra un diagramma dell’output prodotto dal modulo GPS quando riceve i dati. Dovreste vedere dell’output simile a questo nel Monitor seriale.

Figura 13.10 Ricezione dei dati GPS.

Si tratta di informazioni simili a quelle ottenute con il test precedente, ma ora al posto dei campi vuoti si trovano le informazioni.

Possono essere necessari da un minuto fino a quindici minuti prima di iniziare a ricevere dati GPS. Quando avrete verificato che tutto funziona correttamente, eseguite le ultime due modifiche al codice. 1. Impostate la variabile GPSECHO a false.


Non avete più bisogno di inviare i dati al Monitor seriale quando registrerete i dati, e senza essere più connessi a un computer. 2. Impostate LOG_FIXONLY a true. Volete registrare i dati solo quando vi siete agganciati ai satelliti GPS. Dopo aver modificato questi due valori, potrete disconnettere il registratore di dati dal computer. Verificate che il commutatore sullo shield GPS sia impostato su Soft. Serial. Ora siete pronti per realizzare il contenitore che ospiterà il modulo GPS.

Creazione del contenitore L’assemblaggio e la programmazione dello shield è stata semplice. La creazione del contenitore è quasi altrettanto semplice. Dovete solo praticare dei fori per l’interruttore e per il connettore dell’antenna, e poi saldare l’interruttore e il connettore. Avrete bisogno di utilizzare colla a caldo per svolgere queste operazioni e dunque connettete la pistola alla presa di corrente e attendete che si riscaldi. Nel frattempo potete svolgere i seguenti passi, facendo riferimento alle Figure da 13.11 a 13.14. 1. Utilizzate una punta da trapano per praticare il foro per l’interruttore. Il tutto è più facile praticando due fori adiacenti ed eliminando poi il materiale plastico che li separa. 2. Se utilizzate l’antenna opzionale, ricavate un foro utilizzando sempre la stessa punta. Potete praticare il foro a fianco dell’interruttore, come illustrato nella Figura 13.11. 3. Utilizzate una piccola lima per sagomare il foro per l’interruttore quadrato (Figura 13.12).

Figura 13.11 I fori per l’interruttore e l’antenna.


Figura 13.12 Adattamento del foro alla forma dell’interruttore.

Non è il caso di praticare un foro per il connettore USB, poiché l’apparecchio dovrà essere utilizzato in esterni. Può essere più comodo praticare un foro per il connettore USB se prevedete di programmare frequentemente il modulo GPS. Ma questo è più un apparecchio di tipo “accendilo e dimenticatene” e dunque non è il caso di praticare nel contenitore un ulteriore foro per il connettore USB. 4. Inserite l’interruttore di alimentazione nel contenitore. 5. Se utilizzate un’antenna esterna, inserite l’adattatore nel contenitore. Fate attenzione a utilizzare le rondelle fornite per l’interno e l’esterno del contenitore, come illustrato nella Figura 13.13. 6. Ora inserite nel contenitore la tavoletta di legno per stimare dove collocherete la scheda Arduino. Dovete lasciare abbastanza spazio per la batteria da 9 V e assicurarvi anche che l’interruttore non tocchi la scheda Arduino. 7. Utilizzate la pistola per applicare la colla a caldo alla base in legno e premetela con forza sul fondo del contenitore in plastica (Figura 13.14).

Figura 13.13 Montaggio dell’interruttore e dell’adattatore per l’antenna esterna.

8. Verificate la posizione della scheda Arduino e dello shield GPS sul legno all’interno del contenitore, assicurandovi che nessuno dei due tocchi i piedini dell’interruttore.


Figura 13.14 Posizionamento della scheda Arduino e incollaggio della base in legno nel contenitore.

Aggiunta dell’alimentazione L’alimentazione è data dalla batteria a 9 V, connessa all’interruttore. Il positivo è connesso a un lato dell’interruttore. L’altro piedino è connesso al pin Vin dello shield GPS, che è connesso al pin di alimentazione della scheda Arduino (attraverso un piedino dello shield). Il negativo va direttamente dalla pila al pin GND. Svolgete le seguenti operazioni, illustrate nelle Figure 13.15 e 13.16. 1. Saldate il filo positivo, rosso, del clip della batteria a 9 V a un contatto qualsiasi dell’interruttore. 2. Saldate un ponticello o un piccolo frammento di filo elettrico (meglio se di colore rosso) all’altra estremità dell’interruttore. 3. Separate lo shield GPS dalla scheda Arduino e utilizzate tre o quattro viti da legno per fissare la scheda Arduino alla tavoletta di legno, come illustrato nella Figura 13.15.

Figura 13.15 Fissaggio della scheda Arduino al blocchetto di legno sottostante.

4. Inserite la scheda Mini SD nello shield, come indicato nella Figura 13.16. Fate attenzione durante l’inserimento. La molletta che si trova all’interno dello slot tende a far volare via la schedina, se non la trattenete con cura. Non inserite la piccola batteria a bottone finché non avrete terminato il collaudo.


Figura 13.16 Installazione della scheda Mini SD e della batteria (dopo il collaudo).

5. Ora ricollocate lo shield GPS sulla scheda Arduino, assicurandovi di fissarla ai pin corretti. 6. Se utilizzate un’antenna esterna, inserite il connettore u.FL nella presa sullo shield GPS, come illustrato nella Figura 13.17. Si tratta di un piccolo connettore situato appena sotto lo slot della scheda Mini SD. Il connettore u.FL non è fatto per utilizzi pesanti. È ottimizzato soprattutto per le dimensioni. Dopo aver collegato l’adattatore, dovreste lasciarlo in posizione e cercare di evitare di connetterlo e disconnetterlo ripetutamente. Per tenere il cavo fuori vista, l’ho piegato sotto, fra lo shield e la scheda Arduino.

Figura 13.17 Connessione dell’adattatore per l’antenna esterna.

7. Ora saldate il filo rosso di alimentazione dall’interruttore al pin Vin, come illustrato nella Figura 13.18.

Figura 13.18 Saldatura dei fili di alimentazione.

8. Saldate attentamente la connessione nera dal connettore della batteria (ancora senza batteria!) al pin GND dello shield, che è connesso direttamente al pin GND della scheda Arduino.


In realtà vi sono due pin GND. Potete utilizzare quello che volete, ma quello più lontano dal pin Vin è più facile da saldare. 9. Assicuratevi che l’interruttore sia spento e connettete la batteria, come illustrato nella Figura 13.19.

Figura 13.19 Connessione della batteria e dell’antenna esterna.

10. Avvitate il coperchio sul contenitore. 11. Connettete l’anterna GPS esterna. 12. Accendete l’alimentazione.

Raccolta e tracciamento dei dati GPS Ora siete pronti per andare “a zonzo” e iniziare a raccogliere dati. Se vi siete procurati un’antenna esterna, potete collocarla sulla carrozzeria o su un particolare in ferro della bici. I pannelli d’acciaio di un’auto sono perfetti. Ho fatto passare l’antenna attraverso il tetto apribile dell’auto e me ne sono andato a spasso.

Tracciamento del percorso Prima di iniziare l’avventura della registrazione dei dati, assicuratevi che il LED FIX lampeggi ogni quindici secondi. Se lampeggia ogni secondo, significa che non ha ancora agganciato il segnale o quanto meno non ha ancora agganciato tre satelliti e dunque non scriverà dati sulla scheda SD. Se utilizzate un’unica batteria da 9 V, potete aspettarvi un tempo di registrazione compreso fra le tre e le cinque ore. Se spegnete il ricevitore durante il viaggio, il codice creerà automaticamente un nuovo file di registrazione. In particolare incrementerà automaticamente il numero nel suffisso del nome del file. Dopo aver raccolto i dati, potete spegnere l’unità ed estrarre la scheda Micro SD.

Tracciamento dei dati A seconda della durata del giro che avete registrato, il file potrebbe contenere un lungo elenco di istruzioni GPRMC, ognuna su una riga distinta. Dovreste trovarvi del testo come quello rappresentato nella Figura 13.10, con le coordinate geografiche corrispondenti al percorso. Se il file registrato ha questo aspetto, siete pronti per tracciare i dati su una mappa. Vi sono molti modi per farlo, ma la frase GPRMC grezza non è in un formato che possa essere facilmente letto dalla maggior parte dei siti web o dei software di mappaggio. Per tracciare le coordinate utilizzando uno strumento come Google Earth, dovrete convertire i dati grezzi in formato .kml. Potete fare questo e molto altro sull’eccellente sito web gpsvisualizer.com, di Adam Schneider. Per tracciare la mappa, usate i seguenti passi, illustrati nella Figura 13.20. 1. Aprite il browser web e raggiungete il sito gpsvisualizer.com. 2. Nella casella Get Started Now, fate clic sul pulsante Choose File e individuate sul


computer il vostro file di dati. 3. Scegliete un formato di output nel menu a discesa. L’impostazione predefinita è Google Maps. Se volete ottenere un’immagine da scaricare, dovrete selezionare il formato Image. A seconda delle dimensioni del file, possono essere necessari alcuni istanti per elaborare tutti i dati. Alla fine dovreste avere un output simile a quello rappresentato nella Figura 13.20. 4. Potete selezionare il collegamento ipertestuale in cima alla pagina per scaricare un file HTML che contiene un link verso Google Maps, che traccerà la mappa per voi.

Figura 13.20 Tracciamento dei dati su gpsvisualizer.com.

Se volete esplorare la mappa in Google Earth, che consente anche di salvare un’immagine, potete selezionare l’output come un file .kml nella pagina principale di gpsvisualizer.com. I file di testo generati dal registratore di dati GPS sono piuttosto compatti. La registrazione di un giro di cinque ore e mezza generato per la Figura 13.20, conteneva 24.380 righe di testo, ma occupava solo 1,7 MB sulla scheda. Pertanto, anche una piccola scheda da 2 GB ospiterà una grande quantità di dati, che potrete conservare per molto tempo. Tuttavia, è sempre una buona idea copiarli occasionalmente sul sistema locale, come misura di sicurezza. Ora è giunto il momento di andarsene a spasso e registrare percorsi fino alla noia.


Capitolo 14

Un’automobilina telecomandata In questo capitolo Decodifica di un telecomando Uso dei servomotori Programmazione dei comandi di sterzata Realizzazione di un telaio a tre ruote

C

ertamente potete acquistare un’automobilina telecomandata presso qualsiasi negozio di hobbistica, ma realizzarne una da soli è molto più divertente. E poi è molto facile crearla con una scheda Arduino e un po’ di ingegno. In questo progetto creerete un’automobilina a controllo remoto utilizzando un comune telecomando, una scheda Arduino e due servomotori. Utilizzerete Arduino per decodificare i segnali in arrivo dal telecomando e poi utilizzerete il segnale decodificato per dire alla vostra auto di procedere diritto, andare indietro, svoltare e mettere il turbo! Una cosa interessante di questo progetto è che, dopo aver scoperto come utilizzare un qualsiasi vecchio telecomando con la scheda Arduino, potrete trasferire questa funzionalità a qualsiasi altro progetto.

Potete scaricare lo schema elettrico e il diagramma di collocazione a colori dei componenti per questo progetto dal sito del libro (www.hoeplieditore.it/6323-9).

I componenti I componenti di cui avrete bisogno sono rappresentati nella Figura 14.1. Dovreste procurarvi i seguenti componenti per realizzare l’automobilina, la cui realizzazione dovrebbe richiedere all’incirca cinque ore. Una scheda Arduino. Un vecchio telecomando. Un sensore a infrarossi TSOP2438 o TSOP4838 di Vishay Semiconductor (Mouser Electronics 782-TSOP2438 o RS Components #708-5070). Alternativamente, utilizzate un modulo PNA4602. Due servomotori a rotazione continua (come GoTeck GS-3360BB, Futaba 900-00008, Jameco #283039 o Arduino Servo Module, Rapid #73-4464). Un portabatterie per sei batterie stilo (AA) e un connettore per batterie a 9 V. Sei batterie stilo (AA). Otto piedini da un connettore a pettine. Una breadboard. Per il telaio.


Due confezioni cilindriche di patatine Pringles. Due strisce di gomma del diametro di circa 8 cm. Un pezzetto di legno di balsa di almeno di 11 × 17 cm. Un kit Ball Caster (Tamiya o Jameco #358336 o Cool Components #000984). Il necessario per il montaggio (o colla a caldo). Banda di Velcro autoadesivo (opzionale). Per questo progetto potete utilizzare qualsiasi scheda Arduino. In questo caso verrà però impiegata una scheda Arduino UNO. La cosa più divertente di questo progetto è che potete utilizzare qualsiasi vecchio telecomando di casa. Non avete bisogno di utilizzare un telecomando Toshiba come quello rappresentato nella Figura 14.1. Noi ne abbiamo sei, ma ne usiamo solamente due e quindi ho preso uno dei telecomandi di riserva. Dovete solo usare un telecomando che abbia delle frecce direzionali: sinistra, destra, avanti, indietro e, soprattutto, stop! Molti telecomandi per apparecchi televisivi hanno un tasto circolare, con un tasto al centro, una posizione perfetta per i “freni”. È possibile che, durante il collaudo, il telecomando non sia rilevabile. Nel caso, potete provarne un altro.

Figura 14.1 I componenti necessari per questo progetto.

Il componente principale di questo sistema è il sensore a infrarossi (IR), Vishay Electronics TSOP2438, che opera alla frequenza di 38 kHz. Vengono utilizzate anche altre frequenze, ma quella è la frequenza più comune nei telecomandi domestici. Il componente rileva i codici a luce infrarossa emessi dal telecomando e li traduce in segnali digitali che la scheda Arduino può leggere utilizzando una particolare libreria IR.

Il sensore può rilevare solo la luce infrarossa: la sua copertura in materiale epossidico filtra tutte le altre frequenze della luce. Tuttavia, anche la luce domestica contiene infrarossi. Per esempio, un caminetto è una grande fonte di calore e anche di luce nello spettro degli infrarossi. Pertanto, questo componente è progettato in modo da ignorare questo “rumore infrarosso”. Esistono due tipi di servomotori: motori a 180° e motori a rotazione continua. Poiché dovrete utilizzare questi motori per la propulsione, dovrete procurarvi servomotori a rotazione continua, come quelli elencati. I servomotori operano a 5 V CC e possono essere piuttosto voraci di corrente. Sono anche dotati di un kit di accessori che contiene le piastre di montaggio e le armature, più un


assortimento di viti. Avrete bisogno anche di una squadretta se vorrete montare stabilmente i servomotori. Potete però montarli sull’automobilina utilizzando solo un po’ di colla a caldo. Per il progetto utilizzerete un pacco batterie da 9 V. Potete utilizzare un’unica batteria rettangolare da 9 V, che però non durerà a lungo. I servomotori consumano molta corrente. Dovreste pertanto procurarvi un pacco batterie da 9 V che contenga sei batterie stilo (AA), le quali rappresentano un buon compromesso fra autonomia e peso. Le pesanti batterie a torcia (D) e mezza-torcia (C), durano più a lungo, ma sono troppo pesanti e non consentirebbero all’automobilina di muoversi con facilità. Procuratevi un portabatterie dotato di un connettore per batterie a 9 V. Questo semplificherà la disconnessione del pacco batterie dall’automobilina quando sarà tempo di ricaricarlo. La Figura 14.1 mostra un pacco batterie contenente due batterie, ma questo è perché le altre quattro batterie sono dietro. Avrete anche bisogno di otto piedini. Quelli più lunghi sono più facili da utilizzare. Ne userete due per il pacco batterie e gli altri sei per connettere i servomotori alla breadboard. Normalmente i piedini vengono forniti in una fila a pettine e dunque rompetene una piccola sezione di due pin e due piccole sezioni di tre pin ciascuna. Per il telaio, potete utilizzare un qualsiasi pezzo di legno che avete a disposizione. Lo stile dipende da voi, ma il telaio dovrà portare il peso dei componenti e più peso avrete, più solido dovrà essere il telaio. Un pezzo di legno dovrebbe fare il proprio dovere. Potete anche utilizzare un pezzo di plastica, un pezzo di legno di balsa o perfino un pezzo di cartoncino, sempre che siano di dimensioni sufficienti per sopportare tutti i componenti e che il materiale non sia troppo pesante. Probabilmente la parte più gustosa del progetto è costituita dai due barattoli di Pringles, che utilizzerete come ruote dell’automobile (purtroppo non come carburante). Potete utilizzare qualsiasi tipo di disco come ruota, ma le patatine Pringles (oltre a essere commestibili) sono di “facile reperibilità”, sono economiche e i barattoli hanno una base metallica. Avete bisogno di due ruote e dunque dovrete procurarvi due lattine. Potete utilizzare lattine grandi o piccole, poiché occorre solo utilizzare la base metallica. Consiglio di utilizzare le lattine grandi (che contengono più patatine). Avrete inoltre bisogno di due fascette di gomma che potrete avvolgere attorno alle lattine. Senza di esse, le “ruote” non potranno garantire una grande trazione.

Potete anche acquistare una grande varietà di ruote per auto radiocontrollate presso i negozi di hobbistica. Assicuratevi solo di poterle collegare ai perni dei servomotori. Avrete anche bisogno di un martello e di una piccola lima per collegare le ruote ai servomotori e anche di una pistola per colla a caldo se volete incollare i servomotori allo chassis invece di montarli con i dadi. Il vantaggio della colla a caldo consiste nel fatto che sarà possibile installarli con rapidità e facilità sul telaio. Il difetto è che dovrete staccarli fisicamente per poter utilizzare i servomotori per un altro progetto. Potete utilizzare una piccola sezione di Velcro autoadesivo per fissare il pacco batterie.

Il rilevatore e il sistema di guida Cominciamo dal passo più importante: mangiatevi una scatola di Pringles! Per realizzare l’automobilina avrete bisogno di due scatole vuote. Una volta svolto questo compito fondamentale, potrete procedere e fare in modo che il telecomando comunichi con Arduino. Dopo aver decodificato il telecomando, potrete collaudare i servomotori e programmarli per la guida dell’auto.

Realizzazione del circuito su breadboard Lo schema elettrico rappresentato nella Figura 14.2 mostra il circuito dell’automobilina. Si tratta di un circuito molto semplice, in quanto sia il sensore a infrarossi, sia i servomotori possono essere controllati senza utilizzare componenti aggiuntivi. Seguite il diagramma di collocazione dei componenti rappresentato nella Figura 14.3 per connettere il sensore e il motore alla scheda Arduino. Il sensore a infrarossi viene inserito nella breadboard,


rivolto verso l’alto, in modo che possa captare i segnali emessi dal telecomando. Durante l’assemblaggio finale, fisserete la breadboard direttamente al telaio dell’automobilina e pertanto, se volete che abbia un aspetto gradevole, curate i cablaggi. Il sensore a infrarossi richiede solo connessioni per l’alimentazione, la terra e il segnale di uscita. Il sensore rileva i segnali inviati dal telecomando. Nel telecomando vi è un led a infrarossi (normalmente è coperto da una piccola finestra in materiale plastico) che invia impulsi di luce a infrarossi (invisibile all’occhio umano) diversi per ciascun tasto. Gli infrarossi vengono rilevati dal sensore a infrarossi, che è in grado di decodificarli producendo tensioni alte (+5 V) e basse (0 V), che vengono poi inviate al piedino di uscita.

Per verificare che il telecomando funzioni, potete puntarlo verso una fotocamera, anche di uno smartphone, che è in grado di rilevare gli impulsi.

Figura 14.2 Schema elettrico dell’automobilina telecomandata a infrarossi.


Figura 14.3 Collocazione dei componenti sulla breadboard.

Connettete il sensore a infrarossi come illustrato nella Figura 14.3, con la connessione di uscita diretta verso il pin digitale 2. Assicuratevi che la cupola del sensore a infrarossi sia rivolta verso l’alto o non sarà in grado di rilevare il telecomando quando gli invierete comandi. Utilizzando dei piedini sarà più facile mettere e togliere i servomotori. Utilizzate tre piedini di un connettore a pettine per connettere i servomotori alla breadboard. Connettete i cavi dei segnali ai pin digitali 9 e 10. In realtà, dato che sarà il codice a specificare i pin utilizzati, potete utilizzare uno qualsiasi dei pin etichettati con il simbolo tilde “~”, in quanto solo questi pin possono impiegare la modulazione PWM (Pulse-Width Modulation) che consente di controllare i movimenti dei servomotori.

La scheda Arduino impiega un’uscita a variazione continua, simile a un segnale logico. La modulazione PWM è descritta in dettaglio nel Capitolo 5. Aggiungerete il pacco batterie successivamente. Per il momento, dovete connettere la scheda Arduino al computer in modo da poter utilizzare la porta seriale per visualizzare gli impulsi decodificati dal ricevitore a infrarossi.

Decodifica degli infrarossi Dopo aver collocato i componenti, dovrete collaudare il telecomando in modo da conoscere i valori che produce premendo i vari tasti. Date un’occhiata al codice seguente per assicurarvi che vi risulti chiaro il suo funzionamento e poi caricatelo sulla scheda Arduino, in modo da poter verificare il funzionamento del telecomando. #include <IRremote.h> const int irReceivePin = 2; // pin connected to IR detector output IRrecv irrecv(irReceivePin); // create the IR library decode_results results; // IR results are stored here void setup()


{ Serial.begin(9600); irrecv.enableIRIn();

// Start the IR receiver

} void loop() { if(irrecv.decode(&results)) { showReceivedData(); irrecv.resume(); // Receive the next value } delay(250); } void showReceivedData() { if (results.decode_type == UNKNOWN) { Serial.println(“-Could not decode message”); } else { if (results.decode_type == NEC) { Serial.print(“- decoded NEC: “); } else if (results.decode_type == SONY) { Serial.print(“- decoded SONY: “); } else if (results.decode_type == RC5) { Serial.print(“- decoded RC5: “); } else if (results.decode_type == RC6) { Serial.print(“- decoded RC6: “); } Serial.print(“Value = “); Serial.println(results.value, DEC); // Print the results as a decimal value } }

La prima riga importa la libreria del sensore a infrarossi. Questa libreria è un’eccellente risorsa scritta da Ken Shirriff. La libreria decodifica gli impulsi grezzi che il ricevitore a infrarossi invia al pin 2. Potete scaricare il file compresso della libreria dal sito web del libro (www.hoeplieditore.it/63239) o da https://github.com/shirriff/Arduino-IRremote, dove trovate la versione più aggiornata delle librerie. Ecco come installarla. 1. Estraete l’archivio compresso. 2. Rinominate la directory, che dovrebbe avere un nome simile shirriff-Arduino-IRremote-xxx, in IRremote. 3. Trasferite la directory IRremote nella cartella delle librerie di Arduino. Su Mac, in genere si tratta di Documenti/Arduino/libraries/nome-ibreria/nomelibreria.cpp e su Windows di My Documents/Arduino/libraries/nome-libreria/nome-libreria.cpp. 4. Riavviate l’ambiente di sviluppo di Arduino. Dovreste trovare alcuni sketch d’esempio sotto File

Esempi

IRRemote.

Per installare le librerie nella cartella corretta del sistema, fate riferimento al Capitolo 3, che offre istruzioni generali sulle operazioni da svolgere. Questa libreria gestisce quattro dei tipi più comuni di segnali prodotti dai telecomandi: NEC, SONY, RC5 e RC6. Produttori differenti usano protocolli di codifica differenti, ma è molto probabile che il vostro telecomando usi uno di questi standard. Nella libreria troverete anche il supporto per altri tipi di telecomandi, ma dovrete consultare il codice della libreria per attivarli. La prima variabile, irReceivePin, memorizza il numero di pin cui è connesso il modulo a infrarossi. Poi create un oggetto ricevitore a infrarossi chiamato irrecv, che accetta come parametro la variabile che specifica il pin (pin 2) al quale è connesso il modulo. I dati decodificati dalla libreria vengono inviati con uno speciale oggetto di tipo decode_results, chiamato results. Dopo aver specificato queste variabili, utilizzate setup() per aprire un canale di comunicazione seriale, in modo da poter rilevare i codici decodificati. Quindi attivate l’input utilizzando una funzione dell’oggetto irrecv, chiamata irrecv.enableIRIn(). Il ciclo principale decodifica i risultati e li visualizza. L’oggetto irrecv creato ha una funzione decode() che determina se vi sono valori decodificati. L’istruzione if verifica se vi sono risultati da gestire e, in caso affermativo, esegue la funzione showReceivedData(). Poi, la funzione irrecv.resume() prepara il


modulo per ottenere il codice del successivo tasto premuto. Il ritardo nel ciclo dà il tempo di leggere i risultati sulla finestra di output. Se non vi fosse questo ritardo, il tasto premuto sfuggirebbe molto rapidamente dall’ambiente di sviluppo di Arduino. Normalmente questo non rappresenta un problema, tuttavia se mantenete premuto un tasto o premete lo stesso tasto più volte, alcuni telecomandi inviano un codice “ripeti tasto precedente” invece di ripetere il tasto. La funzione showReceivedData() svolge il lavoro di visualizzare il codice relativo al tasto premuto. Il valore dell’ultimo tasto premuto viene memorizzato in una classe che conosce i vari tipi di protocolli dei telecomandi. L’istruzione if controlla se i risultati decodificati sono di un tipo di protocollo noto e, in caso contrario, segnala un errore. Altrimenti, la successiva serie di istruzioni if determina quale tipo di risultato è stato ricevuto e lo invia al Monitor seriale. L’ultima istruzione invia l’effettivo valore che è stato decodificato. Serial.println(results.value, DEC);

Potete produrre in output vari formati di dati e dunque il DEC finale specifica che intendete prelevarlo come un buon vecchio numero decimale.

Lettura dei codici del telecomando Per controllare il telecomando, aprite il Monitor seriale nell’ambiente di sviluppo di Arduino e premete alcuni tasti sul telecomando. Dovreste vedere qualcosa di simile a quanto rappresentato nella Figura 14.4. Questo è il risultato della pressione dei numeri da 0 a 9 del telecomando per un TV a cristalli liquidi di marca Toshiba.

Figura 14.4 Esempio di output dei codici di un telecomando.

Dopo aver eseguito alcune letture sul monitor, premete i tasti che volete utilizzare per controllare l’automobilina. Avete bisogno di Avanti, Indietro, Sinistra, Destra e, soprattutto, Stop, essenziale per evitare collisioni. Ho anche aggiunto un ultimo tasto (di colore rosso) per la modalità “Turbo”, che aggiunge un po’ di velocità. Scegliete un buon tasto per la modalità Turbo. Prendete nota dei codici generati dal telecomando, poiché ne avrete bisogno per la parte successiva dello sketch.

Codifica dei motori Una volta che avrete determinato i sei codici, dovete solo associarli alle azioni che controllano i motori. Aggiungete la parte successiva dello sketch Arduino, in modo da poter collaudare i motori. Prima di setup(), aggiungete il codice seguente (il nuovo codice è rappresentato in grassetto): #include <Servo.h> #include <IRremote.h> IRrecv irrecv(irReceivePin); decode_results results; const int rightMotorPin = 9; const int leftMotorPin = 10; Servo rightServo;


Servo leftServo; int rightSpeed=90; int leftSpeed=90; long keyCode=0;

La prima istruzione aggiunge la libreria Servo, la libreria standard di controllo dei servomotori, inclusa nell’ambiente di sviluppo di Arduino. Questa libreria contiene tutte le istruzioni necessarie per inviare impulsi ai servomotori con la modulazione PWM. Non vorrete davvero riscrivere tutto da soli?! Sarebbe, letteralmente, come reinventare la ruota! È buona abitudine specificare tutte le librerie in cima al codice. In tal modo, potrete farvi riferimento in seguito, quando creerete oggetti che ne usano le funzionalità. Quindi si creano due costanti intere che memorizzano i pin cui sono connessi i due servomotori e si assegnano loro i valori dei pin digitali utilizzati: 9 e 10. Due righe difficili da interpretare creano due oggetti di tipo Servo chiamati rightServo e leftServo. A questo punto diventa possibile inviare istruzioni agli oggetti Servo, cui essi risponderanno. La principale istruzione che inviate è la direzione di rotazione degli oggetti. I motori servo a rotazione continua accettano valori compresi fra 0 e 180 (gradi). Il punto centrale, 90, significa stazionamento. L’invio di un valore inferiore a 90 esegue una rotazione dell’albero in senso antiorario, mentre un valore superiore a 90 esegue una rotazione oraria. Più il valore è lontano da 90, più veloce è la velocità di rotazione, fino ai limiti intrinseci dei servomotori. Dovete memorizzare il valore che inviate ai motori servo; di questo si occupano le variabili leftSpeed e rightSpeed. Per far girare i servomotori, incrementate e decrementate questi valori. Impostandoli, per iniziare, a 90, all’avvio la macchinina rimarrà ferma. L’ultima variabile intera long, keyCode, memorizza il valore decodificato che otterrete dalla libreria IRremote. Utilizzate questo valore per determinare quale rotazione applicare ai servomotori. Se notate che uno dei servomotori è costantemente più lento dell’altro, potete compensare l’effetto aumentando il valore della sua velocità. Assicuratevi solo di utilizzare numeri interi. Per i motori utilizzate la modulazione PWM, e tali valori possono solo impiegare numeri interi compresi fra 0 e 255. Ora aggiungete il codice seguente alla parte setup() (il nuovo codice è rappresentato in grassetto): void setup() { Serial.begin(9600); irrecv.enableIRIn();

// Start the IR receiver

leftServo.attach(9); rightServo.attach(10); pinMode(rightMotorPin, OUTPUT); pinMode(leftMotorPin, OUTPUT); }

Come potete dedurre, dovete “attaccare” (attach) i servomotori per poterli gestire dalla scheda Arduino. Poi specificate che i pin rightMotorPin e leftMotorPin verranno utilizzati per OUTPUT, poiché questi sono i pin che usate per inviare i segnali di controllo PWM ai servomotori. Ora potete assegnare i codici dei tasti ai movimenti dei motori. Aggiungete i seguenti elementi al ciclo principale: void loop() { if(irrecv.decode(&results)) { showReceivedData(); keyCode=results.value; if(keyCode != -1) { switch (keyCode){ case 50174055: // Replace this code with the one from your remote! Serial.println(“Forward”); leftSpeed-=1; // Opposite values propel the wheels forward rightSpeed+=1; break; case 50182215: // Replace this code with the one from your remote! Serial.println(“Backward”); leftSpeed-=1; // Opposite values propel the wheels backward rightSpeed+=1;


break; case 50168955: // Replace this code with the one from your remote! Serial.println(“Stop”); leftSpeed=90; // A value of 90 stops the servos from turning rightSpeed=90; break; case 50152125: // Replace this code with the one from your remote! Serial.println(“Turn Left”); // Wheels move in opposite directions leftSpeed-=1; rightSpeed-=1; break; case 50135805: // Replace this code with the one from your remote! Serial.println(“Turn Right”); // Wheels move in opposite directions leftSpeed+=1; rightSpeed+=1; break; case 50139885: // Replace this code with the one from your remote! Serial.println(“TURBO!!”); // need to move left servo to go right leftSpeed=leftSpeed-50; rightSpeed=rightSpeed+50; break; } } } delay(250); }

In questo codice, innanzitutto il valore results.value decodificato viene assegnato all’intero keyCode. Se il valore non è -1, occorre fare qualcosa: è stato premuto un tasto. Per determinare quale tasto è stato premuto, si utilizza la successiva istruzione if. Occorre controllare se si tratta di uno dei tasti scelti per controllare il movimento; a tale scopo si utilizza un’istruzione switch…case. La struttura condizionale switch…case viene utilizzata per confrontare una variabile con un certo numero di “casi” (case) possibili. La variabile di test è keyCode e il suo valore viene passato alla funzione switch, la quale determina quale sezione case deve applicare. I vari case sono definiti fra le parentesi graffe di switch. Potete specificare il numero di case che volete (l’unico limite è la memoria disponibile). Verrà eseguito solo il case corrispondente al criterio che si è verificato. Il primo case permette di spostare in avanti l’automobilina: switch (keyCode){ case 50174055: // Replace this code with the one from your remote! Serial.println(“Forward”); leftSpeed-=1; rightSpeed+=1; break;

Il telecomando Toshiba, ogni volta che viene premuta la freccia in alto invia un segnale a infrarossi con il valore 50174055 . Questo è il case che occorre confrontare. L’istruzione switch ricerca il valore di keyCode e, nel caso in cui corrisponda al numero 50174055, esegue tutto ciò che si trova dopo il segno di due punti, fino alla prima istruzione break. Giunta al break, l’esecuzione non valuta altri case e salta oltre l’ultima parentesi graffa chiusa che conclude l’intera istruzione switch(). Tutta la parte rimantente di questa istruzione verrà pertanto ignorata. Se viene premuto il tasto avanti, occorre ruotare i servomotori nella direzione appropriata, in base al modo in cui sono installati sul telaio. Tuttavia, quando si montano i servomotori sul telaio, saranno rivolti l’uno verso l’altro, ovvero punteranno in direzioni opposte. Pertanto, per spingere l’automobilina in avanti, il servomotore a sinistra deve ruotare in senso antiorario, mentre il servomotore a destra deve ruotare in senso orario. In pratica, le velocità dei servomotori devono cambiare della stessa entità, ma in direzioni opposte. Per andare avanti, leftSpeed deve essere decrementato di 1 e rightSpeed deve essere incrementato di 1 e, per andare indietro, deve avvenire esattamente l’opposto. Potete farlo con la seguente istruzione case: case 50182215: // Replace this code with the one from your remote! Serial.println(“Backward”); leftSpeed+=1; // Opposite values propel the wheels backward rightSpeed-=1; break;

Il terzo case della struttura switch…case è relativo a quando l’auto deve fermarsi. Entrambi i valori di velocità vengono impostati a 90, un valore che il servomotore interpreta come stazionamento.


Le due istruzioni successive gestiscono la svolta, e questa automobilina può letteralmente girare su se stessa. Ciò è dovuto al fatto che le ruote possono ruotare in direzioni opposte. Per andare a sinistra, la velocità del servomotore a sinistra viene decrementata, per ruotare in senso antiorario. Il servomotore a destra invece deve ruotare in senso orario. Se entrambi i servomotori fossero rivolti nella stessa direzione, la variabile rightSpeed dovrebbe essere incrementata. Tuttavia, poiché il servomotore a destra è montato all’opposto del servomotore a sinistra, anche la sua variabile di velocità deve essere decrementata. È poco intuitivo, ma corretto. E quando volete svoltare a destra, dovete fare esattamente il contrario, aumentando la variabile della velocità di entrambe le ruote. L’ultima istruzione case è per la modalità Turbo. Aggiunge una velocità in avanti con un incremento di 50 anziché di 1.

Assicuratevi di cambiare i codici dei tasti, affinché coincidano con quelli prodotti dal vostro specifico telecomando. Ora che avete programmato le variabili di controllo della velocità, dovete inviare i valori ai servomotori. Potete farlo con una funzione che “aggiorna” i motori. Aggiungete un’istruzione per richiamare questa funzione alla fine del ciclo principale: Void loop(){ … updateMotors(); delay(10); }

Potete anche impostare il ritardo a 10 ms. Non avete più bisogno di un ritardo di 250 ms. Potete anche cancellare la funzione showReceivedData, se volete, poiché non avrete più bisogno. Ora definite la funzione updateMotors() che si trova in fondo al codice: void updateMotors(){ leftServo.write(leftSpeed); rightServo.write(rightSpeed); }

Collaudo dei motori Dopo aver controllato il codice, caricatelo sulla scheda Arduino e verificatene il funzionamento. Dovreste essere in grado di puntare il telecomando in generale verso la breadboard per far girare i motori. Quando il codice è in funzione, potreste notare che i motori girano leggermente, anche quando dovrebbero stare fermi. Probabilmente vi è un leggero problema di calibrazione. Individuate il piccolo foro sopra i servomotori: qui trovate un piccolo potenziometro che potete utilizzare per calibrare i servomotori. Inserite un piccolo cacciavite in questo foro fino a farlo incastrare nella testa del potenziometro. Ruotatelo a sinistra e a destra e il motore inizierà a girare. Fatelo per rendervi conto dell’intervallo di movimento. Poi centrate il potenziometro in modo che l’albero non si muova più. Potreste udire un leggero “clic” nel momento in cui avete centrato il potenziometro, ma è normale: è il rumore del motore che si ferma. Verificate che tutti i tasti del telecomando vengano rilevati perfettamente e che i servomotori si comportino correttamente. I servomotori sono voraci di corrente. Se provate i motori in modalità Turbo, è probabile che la corrente richiesta sia eccessiva per la porta USB, nel qual caso la scheda Arduino potrebbe entrare in reset. Dovrete riavviare la scheda e lo sketch. In questo caso, non sarete in grado di provare la modalità Turbo finché non connetterete il pacco batterie. L’ultimo test riguarda il funzionamento disconnesso del mezzo. Dovrete connettere il pacco batterie. Accendete il saldatore e prendete i due piedini rimanenti. Fissateli nella terza mano e stagnateli. Poi stagnate i fili del connettore della batteria e saldateli ai piedini, come indicato nella Figura 14.5.


Figura 14.5 Saldatura dei piedini di alimentazione.

Dovete svolgere questa operazione con rapidità e precisione. Se scaldate troppo a lungo i piedini, la plastica che li trattiene fonderà e dovrete ricominciare da capo. Lasciate ai piedini il tempo di raffreddarsi fra la saldatura e la connessione dei fili di alimentazione. Dopo aver saldato i piedini, siete pronti per un test. Disconnettete l’Arduino dal computer. Poi connettete il pacco batterie ai pin Vin e GND della scheda Arduino.

È assolutamente importante rispettare le polarità! Non inserite i fili di alimentazione nelle posizioni errate, e non invertiteli: potreste danneggiare in modo permanente la scheda Arduino. Quando l’alimentazione è connessa, dovreste essere in grado di eseguire un test senza connessione al computer (Figura 14.6). Dopo aver terminato di realizzare il “cervello” e l’impianto di alimentazione, è il momento di passare all’assemblaggio del telaio dell’automobilina.


Figura 14.6 Collaudo del sistema prima dell’assemblaggio.

Realizzazione del telaio Ora poggiate la scheda Arduino, la breadboard e il pacco batterie su una tavoletta di legno per valutarne le dimensioni. Segnate sulla tavoletta le dimensioni e ritagliatela. Poiché l’automobilina poggia su tre ruote, e un “carrello” fungerà da ruota frontale, dovete assicurarvi di aver bilanciato tutti i componenti e che il peso sia distribuito equamente. Contrassegnate la linea centrale della tavoletta di legno, come illustrato nella Figura 14.7. Poi, verso un’estremità, contrassegnate la linea centrale degli assi dei servomotori. Ci dovrebbe essere spazio sufficiente per montare i servomotori sul telaio. Se utilizzate viti o bulloni, assicuratevi che siano fissabili alla tavoletta in modo che gli alberi dei servomotori siano sullo stesso asse. Dovrete anche assicurarvi che siano ben allineati. Se le ruote non sono parallele, i motori saranno disallineati e l’automobilina sarà difficile da controllare.

Figura 14.7 Tracciamento della linea centrale.

Se volete fissare meglio la scheda Arduino alla tavoletta (invece di utilizzare nastro adesivo o colla a caldo), segnate i fori sopra il telaio. Utilizzate la scheda Arduino come dima e disegnate i fori che si trovano alle estremità del circuito stampato. Ora assemblate e montate la terza ruota a sfera, come illustrato nella Figura 14.8. Utilizzate le istruzioni fornite nel kit e rispolverate il vostro giapponese! Il carrello usa un modo interessante per regolare l’altezza. Vi sono vari spessori sulla base in plastica. A seconda del modo in cui orientate la piastra che tiene la sfera in posizione, potete ottenere un’altezza finale di 25 o 35 mm. Poiché le ruote realizzate con la lattina di Pringles sono piuttosto alte, utilizzate il valore da 35 mm. Il kit è dotato di alcune viti di montaggio. Potete utilizzarle per montare il carrello sul telaio o potete usare colla a caldo, che non è altrettanto affidabile ma è più facile da applicare. Montate il carrello a sfera sulla linea centrale, come illustrato nella Figura 14.9.


Figura 14.8 Assemblaggio e regolazione del carrello a sfera.

Figura 14.9 Montaggio del carrello a sfera.

Ora preparate le ruote: se non lâ&#x20AC;&#x2122;avete giĂ fatto, mangiate i Pringles contenuti nella seconda lattina, tenendo da parte il tappo di plastica. Segnate una riga a circa 1 cm dal fondo della lattina. Ă&#x2C6; facile farlo poggiando il pennarello su un libro dello spessore adatto. Poi dovrete semplicemente ruotare la lattina per fare un segno lungo tutta la circonferenza. Utilizzando la stessa linea come guida, tagliate il fondo di entrambe le lattine, utilizzando una taglierina da hobbistica, come illustrato nella Figura 14.10. Dopo aver rimosso le ruote, utilizzate la taglierina per praticare un piccolo foro nel tappo di plastica, nel piccolo rigonfiamento che si trova proprio al centro. Dovrebbe essere sufficientemente grande per far passare la punta del pennarello. Poi utilizzate il tappo forato come modello per tracciare un segno del centro sul fondo della lattina, come illustrato nella Figura 14.11.


Figura 14.10 Tagliamo una fetta per ricavare le ruote dalla lattina.

Figura 14.11 Un sistema per trovare il centro delle ruote.

Ora prendete il martello e un chiodo. Individuate anche la vite di montaggio che fissa il perno dei servomotori. Dovrebbe trovarsi nel pacchetto degli accessori forniti con i servomotori. La vite di montaggio del perno è normalmente di colore nero, mentre tutte quelle utilizzate per il montaggio del servomotore sono di colore argento.

Il chiodo dovrebbe essere dello stesso diametro della vite di montaggio e comunque non più grande della sua testa, altrimenti la ruota si sfilerà. Usate il martello e il chiodo per praticare un foro al centro del disco metallico, come illustrato nella Figura 14.11. Poggiatevi su una superficie “sacrificabile”. Quando avrete ricavato il foro, piegate con cura la bavetta metallica e poi usate un martello per appiattirla.

Fate attenzione a queste bavette acuminate. È molto facile tagliarsi. Non dite che non vi ho avvertito. Ora che avete un foro per il perno, fissate le bande gommate attorno alla circonferenza delle ruote e attaccate il supporto del kit di accessori a ciascun albero dei servomotori. Dovrebbero entrare


perfettamente, ma sono rimovibili, se doveste sostituire le ruote. Fate passare la vite di montaggio dell’albero attraverso la ruota e avvitatela bene sull’albero del servomotore, come illustrato nella Figura 14.12.

Figura 14.12 Montaggio delle ruote sui servomotori.

Ora collegate i servomotori al telaio (ma prima disconnettete l’alimentazione dalla scheda Arduino). Utilizzate la linea di allineamento degli assi come guida per collocare i motori, come indicato nella Figura 14.13.

Figura 14.13 Fissaggio dei servomotori al telaio.

I motori vanno montati all’opposto, in quanto stiamo osservando l’automobilina da sotto. Il motore sinistro va montato a destra e quello destro va montato a sinistra. Potete utilizzare della colla a caldo per fissarli oppure utilizzare gli accessori del kit di montaggio, come illustrato nella Figura 14.13. Se utilizzate gli accessori del kit, dovrete praticare dei fori aggiuntivi nel telaio.


Quando avrete finito, l’automobilina sarà simile a quella rappresentata nella Figura 14.14. Notate come è inclinata in avanti. Questo, naturalmente, ha il solo scopo di migliorarne l’aerodinamica. Da notare la presenza dell’adesivo rotondo DIY tratto dal kit Arduino, che ha lo scopo di mascherare un foro nel telaio e, nel contempo, di migliorare l’estetica. Potrete anche montare degli spoiler (autocostruiti), ma per il momento occorre semplicemente montare i componenti e scaldare i motori. Il passo finale prima del test su strada è l’assemblaggio. La breadboard dovrebbe avere un fondo adesivo. Togliete la pellicola protettiva e fissatela centrata sul telaio. Poi montate la scheda Arduino sopra le ruote (Figura 14.15). Potete utilizzare nastro adesivo o anche a un paio di gocce di colla a caldo.

Figura 14.14 Assemblaggio del telaio.

Figura 14.15 Connessione della logica di controllo e dell’alimentazione.

Ora fate correre i cavi di controllo dei servomotori nella parte posteriore del veicolo. Potete incrociarli per evitare che finiscano sotto le ruote. Montate il pacco batterie davanti al veicolo fissandolo con un po’ di Velcro adesivo (o anche un po’ di nastro adesivo “americano” per un approccio veramente grezzo). Congratulazioni, il vostro bolide è ora pronto per un test su strada. Mi piace particolarmente il suo design semplice, che si può ammirare nella Figura 14.16. Solo quanto serve e nessun fronzolo. Ma potete modificare il telaio come volete, sempre che non diventi troppo pesante o sbilanciato.


Figura 14.16 Pronti per il test su strada.

Ora indossate i guanti di pelle e gli occhiali. Impugnate il telecomando e connettete il pacco batterie alla scheda Arduino, facendo sempre attenzione alla polaritĂ . Poggiate lâ&#x20AC;&#x2122;automobilina su una superficie liscia e pigiate sul pedale. Provate anche il tasto Turbo, per prestazioni da Formula 1.


Capitolo 15

Un cubo a LED In questo capitolo Realizzazione di un cubo a LED 3 × 3 × 3 Invio di animazioni luminose Programmazione dei comandi per il cubo a LED Realizzazione della base

S

e non ne avete ancora visto uno, vi capiterà presto! I cubi a LED sono sempre più popolari e sono facili da realizzare utilizzando una scheda Arduino UNO. Questo progetto prevede la creazione di un cubo a LED 3 × 3 × 3 impiegando solo pochi componenti molto economici. Un cubo facile e divertente da costruire, con cui sbizzarrirsi con nuove animazioni. Nel frattempo farete parecchia pratica con le tecniche di saldatura. Dopo averne compreso il funzionamento, potrete espanderlo per creare un cubo 4 × 4 × 4 o uno più complesso, utilizzando una scheda Arduino MEGA. La realizzazione del cubo è solo il principio: vi divertirete molto a escogitare nuove animazioni per il cubo. Il sito web del libro, www.hoeplieditore.it/6323-9, offre un generatore di animazioni per il cubo a LED che aiuta a provare le varie animazioni e genera automaticamente il codice necessario. La realizzazione dell’intero progetto può richiedere all’incirca cinque ore. Ma acquisire la tecnica di saldatura è abbastanza facile, dopo aver iniziato. Dopo averlo costruito e collaudato, potrete cominciare a programmare le animazioni, un’attività molto divertente, che potrebbe diventare perfino compulsiva. Il cubo a LED è costituito da tre livelli di nove LED ciascuno. Ma, come l’insegna a scorrimento del Capitolo 6, un solo LED sarà acceso in un determinato momento. Semplicemente accenderete e spegnerete i LED così rapidamente che l’effetto di persistenza della visione farà sembrare che più LED siano contemporaneamente accesi. Potete scaricare lo schema elettrico e il diagramma a colori di collocazione dei componenti dal sito web del libro (www.hoeplieditore.it/6323-9).

I componenti Per realizzare il cubo, basta mettere insieme solo pochi componenti, rappresentati nella Figura 15.1. Una scheda Arduino. Ventisette LED da 5 mm dello stesso colore e caratteristiche. Tre resistenze (non rappresentate) fra 220 e 270 ohm. Una batteria da 9 V CC e relativo connettore. Un interruttore SPST (single-pole, single-throw) come Jameco #316451 o Maplin # N19CL. Un piccolo pezzo di basetta millefori stripboard o perfboard. Tredici ponticelli. Un piccolo pezzo di polistirolo espanso o di cartoncino spesso. Un contenitore da circa 80 × 12 × 40 mm, come Jameco #675489 o Maplin# LH14. Questo progetto può essere realizzato con facilità con qualsiasi scheda Arduino, ma per l’esempio abbiamo utilizzato un’Arduino UNO. Se volete espandere il progetto per creare un cubo di maggiori dimensioni o se volete accendere e spegnere gradualmente i LED utilizzando la modulazione PWM (pulse-width modulation), dovrete usare una scheda Arduino in grado di ospitare più uscite per


PWM, come un’Arduino MEGA. I LED dovrebbero avere le stesse dimensioni, colore e caratteristiche. Per un effetto creativo, potete utilizzare colori differenti. Naturalmente potete utilizzare i LED che volete, ma assicuratevi almeno che abbiano le stesse caratteristiche elettriche, in modo che il cubo possa funzionare correttamente e che i LED si accendano in modo uniforme. Se utilizzate LED con caratteristiche differenti, alcuni risalteranno rispetto a quelli vicini; questo può essere fonte di distrazione, specialmente durante le animazioni. Utilizzerete tre resistenze per controllare il flusso di corrente verso i LED, impiegando resistenze da 250-270 ohm. Utilizzando valori più elevati, i LED risulteranno più scuri.

Figura 15.1 I componenti necessari per realizzare il progetto.

Poiché il cubo deve poter funzionare anche senza essere connesso a un computer, avrete bisogno di una fonte di energia a batterie e di un interruttore. Poiché dovete alimentare sia la scheda Arduino sia i LED e tutto il circuito deve trovare posto in un piccolo contenitore, procuratevi una batteria standard da 9 V con relativo connettore. Alimenterete la scheda Arduino direttamente dal connettore della batteria e dunque procuratevi anche due piedini. In tal modo potrete collegare il connettore della batteria direttamente ai pin di alimentazione dell’Arduino. Per accendere e spegnere il cubo potete utilizzare un comodo interruttore rettangolare, che dà al progetto un tocco professionale ed è poco costoso. L’unico problema è che costringe a ricavare un foro squadrato nel contenitore. Potete anche utilizzare un interruttore più semplice, per il quale basta praticare un foro rotondo. Avrete anche bisogno di una piccola basetta millefori stripboard o perfboard, sulla quale monterete il cubo a LED per migliorarne la stabilità. Se utilizzate una stripboard, dovrete tagliare le tracce in modo che le colonne di LED non entrino in corto circuito. Le perfboard hanno invece solo una piazzola ramata attorno a ogni foro, il che elimina questo problema. Vanno bene entrambe, ma in genere ho sempre delle stripboard che mi avanzano e questo è il motivo per cui l’ho rappresentata in figura. A differenza della maggior parte dei progetti di questo libro, questo non utilizza una breadboard. Il progetto richiede tredici ponticelli, dodici dei quali andranno connessi ai pin di output della scheda Arduino. Un ponticello connette invece l’interruttore al pin Vin della scheda Arduino. Per disporre i LED a formare un cubo, avete bisogno di una “dima” in grado di trattenerli con sicurezza mentre li saldate. Potete ricavare dei fori nel legno, ma è altrettanto comodo utilizzare un pezzo di polistirolo espanso o un cartoncino spesso. Dovrebbero essere sufficienti, a meno che pensiate di realizzare una grande quantità di cubi, nel qual caso vale la pena di creare una dima meno provvisoria utilizzando un pezzo di legno. Se state utilizzando un contenitore in plastica ABS come quello rappresentato nell’elenco dei componenti, avrete bisogno di alcuni attrezzi per praticare i fori per il passaggio dei piedini dei LED e dell’interruttore. Dovrete impiegare un trapano a mano o elettrico e due punte: una da 1 mm per i piedini dei LED e una da circa 7 mm per l’interruttore. Se utilizzerete un interruttore di forma squadrata, dovrete sagomare il foro con una piccola lima.


Dopo aver raccolto i componenti, potrete realizzare il progetto e poi caricare il codice sulla scheda Arduino.

Realizzazione del cubo La realizzazione del cubo prevede tre passi. Innanzitutto dovrete preparare ciascun livello del cubo. Poi dovrete modificare il contenitore, in modo che ospiti la scheda Arduino e sostenga il cubo. Infine, dovrete aggiungere l’alimentazione al progetto, in modo che il cubo a LED possa operare anche senza essere connesso a un computer.

Assemblaggio della matrice di LED La matrice del cubo è costituita da tre livelli di nove LED ciascuno, per un totale di ventisette LED. I livelli sono identici, il che ne semplifica la realizzazione. Dovete saldare i livelli separatamente e poi assemblarli come una sorta di torta multistrato. Dopo aver assemblato il cubo, potrete saldarlo alla stripboard. Il piedino positivo “+” (anodo) di ciascun LED di un determinato livello è connesso a uno degli output digitali della scheda Arduino, che gli fornisce l’alimentazione. A ogni livello, tutti i piedini negativi “–” (catodi) sono connessi fra loro: per l’intero livello verrà impiegato un solo pin di terra dell’Arduino. Pertanto ai pin digitali della scheda Arduino andranno connessi in totale tre contatti di terra: uno per ciascun livello.

Si accende un solo LED per volta. Il ciclo di accensione è però talmente rapido che si ha l’impressione che più LED siano accesi contemporaneamente. Potete accendere un LED mandando corrente a uno dei nove pin di un livello, il livello “attivo”, e connettendo tale livello a terra. Nel frattempo, gli altri livelli, inattivi, non saranno connessi a terra e dunque i due LED nella stessa colonna su tali livelli rimarranno spenti.

Preparativi per la saldatura Per iniziare con il primo livello, dovete preparare una mini “dima” per i LED, costituita da un pannello di polistirolo espanso, di cartoncino spesso o di legno. Dovete ricavarvi una griglia di nove fori. Tracciate una griglia di 3 × 3 punti sul materiale con un righello e una penna. I punti dovranno trovarsi a una distanza di 25 mm. È importante misurare con cura queste distanze, per assicurarsi che il tutto sia molto preciso e uniformemente spaziato. Altrimenti i livelli non saranno ben allineati. Se utilizzate un pannello di polistirolo espanso, praticate delle × centrate sui punti. Poi, al centro dei tagli a × inserite con cura la capocchia di un LED per praticare i fori, come illustrato nella Figura 15.2. Se utilizzate un materiale più rigido, dovrete praticare i fori con un trapano. Il LED dovrebbe rimanere ben verticale, fissarsi nel foro e non cadere di lato. Se il LED “balla” nel foro, sarà difficile saldarlo e dovrete ricominciare da capo nel caso in cui i fori non facciano la presa dovuta. Dovrete collaudare ognuno dei livelli subito dopo averlo realizzato. Per questo potete utilizzare direttamente la scheda Arduino. Aprite l’ambiente di sviluppo e caricate sulla scheda lo sketch Blink. Il pin 13 dovrebbe lampeggiare a una frequenza di un secondo. Utilizzate dei ponticelli lunghi come contatti di test. Inseritene uno nel pin 13 e l’altro a terra, GND. Utilizzerete queste “sonde” per assicurarvi che i LED funzionino.


Figura 15.2 Creazione della “dima” per la saldatura.

Composizione e saldatura di un livello Il piedino del catodo, “–”, di ciascun LED deve essere connesso al suo vicino, in modo che i catodi del livello formino una sorta di “S”. Accendete il saldatore per saldare i catodi. Per realizzare i livelli, svolgete i seguenti passi, illustrati nelle Figure 15.3 e 15.4. 1. Piegate il piedino più corto, il catodo (–) di otto dei nove LED, in modo che ognuno di essi poggi contro il fondo della base del LED, e sia perpendicolare al piedino più lungo, l’anodo (+). Fate il segno della vittoria “V” con il dito indice e il dito medio; allineate il dito medio con il piedino più lungo, l’anodo (+), e il dito indice con il piedino più corto, il catodo (–); poi piegate il dito indice in avanti. Questo è il modo in cui dovete piegare i piedini dei LED (Figura 15.3). Non importa se utilizzerete la mano destra o quella sinistra; l’importante è che utilizziate sempre la stessa mano per l’intero progetto. 2. Collocate i LED nella dima a formare una “S” con i piedini piegati dei catodi, in modo che il piedino del catodo raggiunga il catodo del LED adiacente. 3. Utilizzate una piccola goccia di stagno per creare una solida connessione fra la punta di un catodo e la piega del catodo del LED successivo nella serie.

Figura 15.3 Disposizione dei LED e piegatura dei catodi.


Figura 15.4 Saldatura di un livello del cubo.

4. Procedete fino a realizzare la forma a “S”. Non piegate i due piedini dell’ultimo LED. Li utilizzerete per collegare i vari livelli. 5. Mentre il livello è ancora nella dima, connettete il ponticello di terra delle sonde a uno dei piedini piegati dei catodi. Utilizzate una pinzetta della “terza mano” per tenere il tutto in posizione. 6. Ora toccate con l’altra sonda (che è connessa al pin 13) il piedino dell’anodo di ciascun LED, come illustrato nella Figura 15.4. Dovrebbe lampeggiare a una frequenza di 1 secondo. Se ciò non accade, controllate che tutte le saldature offrano un buon contatto e riprovate. 7. Dopo aver eseguito il collaudo, mettete da parte il primo livello e realizzate il successivo, fino a preparare tutti e tre i livelli. Lasciate l’ultimo livello nella dima: da qui partirete per realizzare il cubo.

Assemblaggio del cubo Quando avrete completato i tre livelli, sarete pronti per assemblare il cubo. Portate uno dei livelli completati vicino a quello che ora è nella dima, facendo coincidere gli spigoli. Ma non allineate le forme a “S” che avete creato. Al contrario, ruotate il livello che avete in mano di 90°, in modo che le “S” dei due livelli non si sovrappongano. Questo darà maggiore stabilità strutturale al cubo quando i livelli verranno saldati insieme. Inoltre, dovete assicurarvi che i due LED che hanno l’anodo e il catodo rivolti verso l’alto non siano allineati. Fate riferimento agli schemi di connessione rappresentati nella Figura 15.5 e svolgete le seguenti operazioni. 1. Allineate il LED di angolo dei due livelli. 2. Utilizzando una pinzetta a becchi sottili, fate una piccola piega all’estremità del piedino dell’anodo (+) del LED nell’angolo della dima, in modo che tocchi il piedino dell’anodo del LED d’angolo del livello che tenete in mano.

Figura 15.5 Diagramma di connessione dei LED (visto di lato).

3. Ora saldate attentamente insieme i due anodi. Questo è il momento in cui sarebbe bello avere almeno cinque mani! Utilizzate la “terza mano” con un coccodrillo per tenere insieme il tutto mentre eseguite le saldature, come illustrato nella Figura 15.6. Cercate di lavorare con rapidità, in modo da non surriscaldare i LED. 4. Ora passate al LED successivo della serie e ripetete l’operazione. 5. Continuate finché non avrete saldato insieme tutti gli anodi dei LED nei due livelli.


Figura 15.6 Saldatura delle colonne di anodi.

Assicuratevi di non saldare il piedino del catodo dell’ultimo LED a un anodo del livello adiacente! Quando avrete connesso i due livelli, ogni LED del livello superiore dovrebbe avere il proprio anodo saldato all’anodo del LED corrispondente nel livello sottostante. L’ultimo LED della serie di ciascun livello dovrà avere entrambi i piedini rivolti verso il basso e nulla connesso al piedino del catodo (si trovano in angoli differenti). Ora ripetete l’operazione precedente per aggiungere il terzo livello. Ricordatevi di ruotare ancora il livello di 90°, in modo che le forme a “S” dei due livelli non siano allineate e i LED finali con entrambi i piedini rivolti verso l’alto non si trovino uno sopra l’altro. Pertanto le forme a “S” del primo e del terzo livello avranno lo stesso orientamento (Figura 15.5). Dopo aver saldato tutti i tre livelli del cubo, avrete nove colonne verticali di tre anodi connessi insieme. Avrete anche un unico LED nell’angolo di ciascun livello con il catodo non connesso. Salderete un ponticello a questo catodo, in modo da poter connettere ognuno dei tre livelli ad altrettanti pin analogici della scheda Arduino. Li connetterete a terra nel codice. Ora collaudate il cubo a LED per assicurarvi che tutto funzioni. Ripetete la procedura di test che avete svolto per i singoli livelli. Questa volta dovreste poter accendere un LED connettendo il suo livello a terra e toccando con la sonda positiva un qualsiasi anodo della sua colonna. Per esempio, nella Figura 15.7, la terra è connessa al livello superiore. Potete accendere ognuno dei LED di quel piano toccando l’anodo di una qualsiasi colonna di LED. Poiché solo il piano superiore è connesso a terra, si accenderà un unico LED.


Figura 15.7 Collaudo dei LED che formano il cubo.

Potete utilizzare lo stesso principio per creare le animazioni del cubo di LED, ma invece di connettere manualmente l’alimentazione, sarà la scheda Arduino a eseguire l’animazione dal programma e il tutto molto velocemente! Dopo aver collaudato il cubo ed esservi assicurati che ogni LED funzioni, dedicate qualche istante ad allineare con delicatezza tutti i LED e a raddrizzare per bene il cubo.

Realizzazione della base Ora che avete completato il cubo, potete fabbricare la base, che garantirà la necessaria stabilità dei LED e celerà i circuiti interni. Dovete praticare dei fori nelle posizioni corrette per i catodi e gli anodi, più un foro distinto per l’interruttore. Connetterete i LED alla basetta millefori (stripdoard o perfboard) all’interno del contenitore, che garantirà stabilità e semplificherà molto la saldatura dei ponticelli. Procedete nel seguente modo, facendo riferimento alle Figure da 15.8 a 15.13.

1. Collocate il cubo a LED sulla stripboard e contrassegnatela in modo che vi sia un po’ di spazio intorno alla griglia di LED, ma non troppo, così che possa entrare nel contenitore. 2. Ritagliate la stripboard alle dimensioni corrette. Per farlo potete utilizzare una taglierina da hobbistica. Passatela più volte sopra i fori della basetta, finché non sarete in grado di dividerla con facilità in due parti. 3. Fate scorrere con cura i piedini dei LED attraverso il lato ramato della basetta, in modo da poter contrassegnare i fori di passaggio sul lato superiore della stripboard. In tre degli angoli della stripboard, dovrete contrassegnare due fori adiacenti, come illustrato nella Figura 15.8. Un foro ospiterà l’anodo e l’altro la connessione con il catodo di ciascun livello. 4. Ora usate la stripboard come una dima per praticare i fori nel contenitore. Fissatela


con nastro adesivo all’esterno del contenitore e utilizzate un coltellino a punta sottile per tracciare dei segni sulla superficie del contenitore di plastica, uno per ogni anodo e tre per i catodi.

Figura 15.8 Le posizioni da forare, tracciate sulla stripboard.

5. Dovreste aver praticato dodici segni: nove per gli anodi e tre per i catodi. 6. Valutate e contrassegnate la posizione dell’interruttore. È meglio collocarlo in quello che normalmente viene considerato il pannello superiore del contenitore, poiché è più facile farlo, e fissare il cubo al coperchio inferiore. Il montaggio del cubo sul “fondo” della scatola è un po’ più facile, ma potreste non gradire la presenza delle viti. Dipende da voi. 7. Ora usate un piccolo trapano per praticare i fori precedentemente segnati. Potete farlo anche sulla scrivania, ma dovrete utilizzare un vecchio catalogo per proteggerne il piano, come illustrato nella Figura 15.9.

Figura 15.9 Uso della stripboard come dima.

8. Utilizzate il trapano e la punta grande per praticare il foro per l’interruttore, come illustrato nella Figura 15.10. Può essere più comodo praticare due fori adiacenti e poi eliminare la plastica che li separa. Utilizzate una piccola lima per sagomare un foro rettangolare adatto. Quando avrete terminato, l’interruttore avrà un aspetto eccellente. Provate il foro, come illustrato nella Figura 15.11.


Figura 15.10 Pratichiamo il foro per l’interruttore.

Figura 15.11 Proviamo a collocare l’interruttore.

9. Ora alimentate con attenzione gli anodi e i catodi dei LED attraverso la superficie del contenitore e la stripboard. Questa parte è un po’ macchinosa e può essere più facile iniziare da un angolo del cubo, alimentando un’unica fila e poi procedendo con le altre. Abbiate pazienza! Potete farcela! 10. Infine girate il tutto e fissate con nastro adesivo la stripboard in posizione. Tirate delicatamente il cubo, in modo che i piedini dei LED siano perfettamente ad angolo retto con la superficie del contenitore. 11. Utilizzate il saldatore per saldare i dodici piedini alla stripboard. 12. Tagliate le piste di rame che connettono le righe di LED. Potete utilizzare una taglierina da hobbistica o una piccola punta da trapano che sia appena più grande rispetto alle piste di rame. Praticate sei piccoli fori per interrompere le tracce di rame, facendo attenzione a non perforare la basetta. Il tutto dovrebbe avere l’aspetto rappresentato nella Figura 15.12.

Figura 15.12 Saldatura dei piedini e dei ponticelli alla stripboard.

Esecuzione delle connessioni finali Ognuno dei livelli di LED è connesso tramite una resistenza a un pin analogico. Invece di essere utilizzati per l’input, come avviene normalmente, i tre pin analogici forniscono la connessione di terra. Ognuno dei tre livelli di LED è connesso a un pin analogico. Ma i catodi di ciascun livello sono


connessi all’ultimo LED di tale livello. Per eseguire la connessione, stendete un ponticello volante attraverso il foro del catodo che avete praticato nel contenitore e saldatelo al catodo del LED in ognuno dei tre angoli del cubo (Figura 15.5). 1. Create un ponticello volante per ogni livello di LED. Fate passare un piccolo tratto di filo attraverso ognuno dei fori dei catodi e saldate le estremità al catodo libero di ogni livello di LED. È meglio usare un ponticello con isolante nero, meno visibile. Potreste dover allargare questo foro, in modo che sia leggermente più largo e lasci passare l’isolante. 2. Saldate l’altra estremità di ogni ponticello volante alla basetta millefori in una pista che non sia connessa a nessuno degli anodi. 3. Per ogni ponticello volante, saldate un piedino di una resistenza da 220 ohm al foro che si trova a lato del ponticello volante, sulla stessa pista di rame. 4. Saldate l’altro piedino della resistenza in una riga adiacente, inutilizzata. Utilizzate un ponticello per connettere il secondo piedino della resistenza ai pin analogici della scheda Arduino, per garantire la connessione a terra. 5. Per creare le tre connessioni ai pin analogici, saldate un ponticello alla basetta millefori in un foro adiacente a ciascuna resistenza. Questo è un modo un po’ insolito di saldare i fili elettrici alla stripboard. Normalmente si fanno passare i fili attraverso i fori della stripboard sul lato opposto. La saldatura delle connessioni in questo modo fa però sì che la stripboard rimanga piatta contro il contenitore. La Figura 15.12 descrive le operazioni svolte nei Passi 5 e 6. 6. Ora prendete nove dei ponticelli e saldateli alle sezioni della stripboard connesse a ciascuno degli anodi. 7. L’ultimo passo consiste nell’accendere la pistola della colla a caldo e porre un paio di gocce sui lati della scheda, in modo che aderisca bene al contenitore. Mettetela poi da parte a raffreddare mentre preparate l’interruttore.

Collaudo delle connessioni Dopo aver saldato tutti i ponticelli, occorre collaudare il cubo per verificare che non vi siano cattive connessioni. Connettete la sonda di terra dalla scheda Arduino a uno dei tre piedini dei catodi. La Figura 15.13 mostra il ponticello di terra connesso al livello intermedio e il ponticello positivo connesso a uno dei ponticelli di un anodo. Ora, passate da un anodo all’altro per assicurarvi che tutti i LED funzionino e prendete nota dei vari ponticelli che vanno a ciascuna delle nove colonne.

Figura 15.13 Collaudo dell’intera struttura.

Se un LED non dovesse accendersi, avrete una connessione interrotta sul suo anodo o catodo. Se


anche gli altri LED della stessa colonna non si accendono, il problema è probabilmente legato all’anodo di tale colonna. Se gli altri LED dello stesso livello non si accendono, il problema è legato alla connessione del catodo. La Figura 15.14 mostra lo schema elettrico del cubo. Se due o più LED si accendono quando eseguite una connessione, avete un “ponticello” di stagno fra di essi. Controllate tutte le saldature di tale colonna e livello, per assicurarvi che non vi siano gocce di stagno che provocano contatti indesiderati. Dopo aver collaudato il tutto, passate a occuparvi dell’alimentazione e dell’interruttore.

Figura 15.14 Schema elettrico del cubo a LED.

Aggiunta dell’alimentazione La fonte di alimentazione è rappresentata semplicemente da una batteria da 9 V connessa all’interruttore. Il polo positivo andrà connesso a un piedino dell’interruttore. L’altro piedino andrà connesso al pin Vin della scheda Arduino. Il polo negativo andrà direttamente al pin GND dell’Arduino. Svolgete le seguenti operazioni, rappresentate nella Figura 15.15. 1. Saldate il filo rosso, positivo, del connettore della batteria a 9 V a un piedino dell’interruttore. Non importa a quale piedino lo saldate. 2. Saldate un ponticello all’altro piedino dell’interruttore. Meglio se il ponticello è rosso. 3. Prendete due piedini di un connettore a pettine e saldate a uno di essi (o a entrambi) il filo nero negativo. È meglio utilizzare dei piedini, poiché vi sono due connessioni GND adiacenti sulla scheda Arduino e il fatto di impiegare due piedini offre più stabilità. Lasciate da parte la batteria fino a quando, successivamente, non programmerete l’animazione. La Figura 15.16 mostra l’aspetto del progetto dopo aver installato il tutto nel contenitore.

Figura 15.15 Saldatura delle connessioni all’interruttore.


Figura 15.16 Inserimento dell’elettronica nel contenitore.

Connessione alla scheda Arduino Ora potete connettere il cubo alla scheda Arduino. Collegate i nove ponticelli degli anodi ai pin digitali, come illustrato nella Figura 15.5. Connettete i tre catodi ai pin analogici 0, 1 e 2. Nel programma, utilizzerete i pin di input analogici come connessioni a terra e non come input analogici. Ora connettete la scheda Arduino alla porta USB. È il momento di occuparsi del codice.

Programmazione del cubo Il codice di questo progetto si trova sul sito web del libro, www.hoeplieditore.it/6323-9. Scaricatelo e poi caricatelo sulla scheda Arduino dopo averne compreso il funzionamento. Questo programma è molto lungo, in quanto contiene varie animazioni d’esempio.

È facile commettere errori digitando manualmente i codici delle animazioni e pertanto il sito web offre anche uno strumento per generarle, descritto nel prossimo paragrafo. Come nei cartoni animati, gli schemi danzanti del cubo di LED vengono creati come sequenze di frame visualizzati in rapida successione per dare l’illusione del movimento. Ciò significa che dovrete indicare se un LED deve essere acceso o spento per ogni frame dell’animazione, rappresentandolo con un 1 o uno 0. Il codice leggerà queste sequenze di bit e le applicherà al cubo. Ma, a differenza delle animazioni cinematografiche, potete impostare la durata di visualizzazione di ciascun frame in modo indipendente, con incrementi di 100 ms. In realtà le cose sono un po’ più complicate, poiché per ogni frame verrà acceso un solo LED per volta. Immaginate di dover accendere i nove LED superiori per un frame dell’animazione. Il codice determina che i nove LED superiori dovrebbero essere accesi per tale frame e quindi li accende in


rapida successione uno dopo l’altro. Poiché il tutto si svolge in un tempo misurabile in microsecondi, si ha l’illusione che rimanga acceso l’intero livello.

Vi sono solo 2048 byte di memoria operativa (l’area SRAM - Static Random Access Memory) utilizzabili per la memorizzazione e la manipolazione delle variabili durante l’esecuzione del programma. Per risparmiare spazio di memoria, l’animazione è definita da una tabella dei singoli bit (“on” o “off”), memorizzata in un unico grosso array collocato in un altro spazio della scheda Arduino, che viene normalmente utilizzato per memorizzare il programma stesso: la memoria flash. Questo array viene letto dalla memoria flash durante l’esecuzione del programma, invece di essere letto dalla SRAM. Dedicate qualche istante a comprendere il funzionamento del codice prima di caricarlo sulla scheda Arduino.

Le dichiarazioni di variabili Questa è la prima parte del codice che verrà eseguita e contiene le dichiarazioni delle variabili del programma; qui vengono definite anche le sequenze di animazione. Il listato è troncato, perché sarebbe troppo lungo, ma potete comunque consultarlo nell’ambiente di sviluppo.

La struttura delle animazioni #include <avr/pgmspace.h> prog_uchar PROGMEM patternData[] = { // Blink all LEDs on and off B111, B111, B111, B111, B111, B111, B111, B111, B111, 10, B000, B000, B000, B000, B000, B000, B000, B000, B000, 10, . . . };

La prima parte del codice include la libreria avr/pgmspace.h, che consente di estrarre le animazioni dallo spazio di memoria del programma. Si tratta di una libreria fornita con la distribuzione di software standard di Arduino. Il successivo grosso frammento di codice è l’array patternData[] (nel listato precedente ne viene mostrata solo una parte) che definisce ciascun frame della sequenza di animazione. Si tratta di un array di valori unsigned char (unsigned significa che sono senza segno e dunque non possono essere negativi) conservati nella memoria del programma, come indicato dal prefisso PROGMEM. Ogni gruppo di byte contiene i valori dei LED. I primi nove byte sono gli stati on o off dei ventisette LED di un frame. Le righe di dati sono disposte in frame, costituiti da dieci valori. Così è più facile leggerli, ma noterete che vi è una virgola alla fine di ogni riga, poiché in realtà questa tabella di dati non è altro che un lungo elenco di numeri. Il decimo byte memorizza il tempo di visualizzazione di questo frame, in incrementi di 100 ms. Pertanto, il valore 10 visualizza il frame per un secondo. La prima sequenza di frame accende tutti i LED per un secondo: B111, B111, B111, B111, B111, B111, B111, B111, B111, 10,

Ecco il modo in cui la sequenza di bit fa riferimento ai LED del cubo, la “mappa” dei LED. I valori binari sono preceduti dalla lettera B. Date un’occhiata alla seguente riga ipotetica: Livello superiore, | Livello medio, | Livello inferiore, ms Ant, Cen, Post, | Ant, Cen, Post, | Ant, Cen, Post, B111, B000, B000, | B010, B010, B010, | B111, B111, B111, 10,

Il primo valore, B111, accende i tre LED superiori della fila frontale del cubo. I tre LED superiori della seconda e della terza riga sono spenti, come indicato dai tre “0”, uno per ogni LED della riga.


Da questo schema potete vedere che i valori del livello medio accendono una fila di tre LED in mezzo a ciascuna riga, dalla parte frontale del cubo alla parte posteriore. Il piano inferiore è interamente acceso (tutti i LED sono on). L’ultimo valore è la durata: 10 volte 100 ms equivalgono a 1 secondo.

Definizione delle variabili Ecco le altre variabili: const int cubeSize=3; // the dimensions of the cube, in LEDs const int planeSize=9; // the number of LEDs on each plane of the cube const int planeDisplayTime=1000; // time each plane is displayed in microseconds const int updateSpeed=100; // multiplies displayTime to get milliseconds byte patternBuffer[planeSize]; // Stores the current pattern from patternData int patternIndex; // Keeps track of the data value containing the duration int patternBufferIndex; // Counts where we are while painting the display byte displayTime; // Multiplied by 100ms to set the frame duration unsigned long endTime; // Tracks when we are finished with the frame int plane; // Loop counter for painting the cube int ledrow; // Counts LED rows in the refresh loop int ledcol; // Counts LEDs columns in the refresh loop int ledpin; // Counts LEDs in the refresh loop int LEDPin[] = {2,3,4,5,6,7,8,9,10}; int PlanePin[] = {14,15,16};

Le prime quattro variabili const int definiscono le dimensioni del cubo (3 × 3, ovvero 33, 27) e le dimensioni di ciascun piano. Potete aumentare questo valore a 4 o più se intendete realizzare un cubo di maggiori dimensioni, ma avrete bisogno di impiegare una scheda Arduino più avanzata. La variabile planeDisplayTime controlla la frequenza di aggiornamento di ciascun frame, in milionesimi di secondo. La variabile updateSpeed controlla per quanto tempo viene visualizzato ciascun frame. La si deve moltiplicare per l’ultimo valore di ogni riga della tabella di dati, in modo da determinare per quanto tempo verrà visualizzato ciascun frame. Se cambiate questo valore, aggiornerete la velocità di tutti i frame dell’intera animazione. La variabile byte patternBuffer[] è un array temporaneo che contiene i dati dei frame letti dalla memoria del programma durante il funzionamento dello sketch. L’intero patternIndex viene utilizzato per registrare gli elementi dell’array quando si carica dalla memoria del programma, in modo da sapere quale elemento contiene la durata in millisecondi. patternBuffer Index è semplicemente un contatore utilizzato quando si scrive sul display. Il byte displayTime è una variabile temporanea che memorizza il tempo in cui ciascun frame viene visualizzato quando lo si legge dalla memoria del programma. Il valore endTime è un contatore utilizzato per determinare se si è finito di realizzare il frame. I quattro interi successivi vengono utilizzati come contatori di servizio mentre viene visualizzato il frame. Gli ultimi due array memorizzano i pin utilizzati per il cubo. L’array LEDPin[] conserva le connessioni degli anodi e l’array PlanePin[] conserva le connessioni dei catodi. Potete attivare o disattivare questi pin per aggiornare il display. I pin 14, 15 e 16 sono semplicemente i pin di input analogico di Arduino, il cui nome è A0, A1 e A2.

La sezione Setup La sezione di configurazione è molto semplice: è costituita da due cicli for che inizializzano i pin utilizzando il comando pinMode. I pin vengono tutti impostati come OUTPUT. Poiché i numeri di pin sono memorizzati in due array, occorrono due cicli for per eseguire le operazioni, in modo da impostare, a turno, la modalità on/off di ciascun pin.

Il ciclo principale Questo è il luogo in cui si svolge tutta l’azione. Si prelevano solo i dati necessari per lavorare con ciascun frame, un frame per volta. Ma lo spazio di memoria del programma contiene tutti i frame. La variabile patternIndex indica la posizione corrente e, per iniziare, impostate patternIndex a 0. Quindi caricate nel buffer temporaneo i dati di un unico frame dalla memoria del programma (nove valori, più la durata). Quindi eseguite un ciclo do…while per applicare al cubo questo frame per l’intero ciclo principale del programma. Continuate in questo ciclo fintantoché vi sono dati in


displayTime, che è l’ultimo valore di ciascun frame. Quando raggiungete la fine dello schema, non vi saranno più altri frame e dunque displayTime sarà nullo. A questo punto il ciclo termina e si ripete,

continuativamente. Ecco il listato: patternIndex = 0; do { memcpy_P( patternBuffer, patternData+patternIndex, planeSize ); patternIndex += planeSize; displayTime = pgm_read_byte_near( patternData + patternIndex++ ); endTime = millis() + displayTime * updateSpeed; while ( millis() < endTime ) { patternBufferIndex = 0; // Loop over the planes of the cube for (int plane=0; plane<cubeSize; plane++) { // Turn the previous plane off if (plane==0) { digitalWrite(PlanePin[cubeSize-1], HIGH); } else { digitalWrite(PlanePin[plane-1], HIGH); } // Prepare the digital pins to light up LEDs ledpin = 0; for (ledrow=0; ledrow<cubeSize; ledrow++) { for (ledcol=0; ledcol<cubeSize; ledcol++) { digitalWrite( LEDPin[ledpin++], patternBuffer[patternBufferIndex] & (1 << ledcol) ); } patternBufferIndex++; } // Turn on the current plane digitalWrite(PlanePin[plane], LOW); // delay planeDisplayTime us delayMicroseconds(planeDisplayTime); } } // End of the while loop } while (displayTime > 0 }

Caricamento del frame Innanzitutto partite con patternIndex a 0 e caricate i primi nove valori dello schema dallo spazio di memoria del programma nel buffer temporaneo, in modo da poterli utilizzare. Prendete i primi nove valori poiché planeSize è uguale a 9. Questi sono i dati per il primo frame dell’animazione.

L’indicizzazione degli array parte da 0, pertanto gli elementi dell’array saranno numerati da 0 a 8. Potete utilizzare una speciale istruzione del linguaggio di programmazione C, memcp_P, per copiare i dati dalla memoria del programma alla variabile patternBuffer[]. I dati provengono da patternData, che avete appena copiato dalla memoria del programma e da lì traete nove valori, poiché planeSize è uguale a 9. Poi incrementate patternIndex di una quantità pari a planeSize (ovvero 9), in modo da poter essere in grado di caricare il frame successivo di dati dopo aver applicato questo frame. Utilizzate un altro comando C, pgm_read_byte_near(), per leggere il valore che si trova dopo i valori relativi ai LED, il quale contiene la durata di visualizzazione del frame. L’ultimo passo prima della visualizzazione consiste nell’impostare endTime per questo frame. Questo è il numero corrente di millisecondi del timer interno di Arduino (che ottenete con la funzione millis()), più displayTime in millisecondi, moltiplicato per la velocità di aggiornamento.

Visualizzazione del frame Ora utilizzate patternBuffer per aggiornare i LED. Sempre che l’orologio non abbia raggiunto endTime,


si deve visualizzare il frame. Utilizzate due cicli for nidificati per eseguire delle iterazioni sui tre piani del cubo, impostando tutti i pin al livello HIGH, per impedire all’elettricità di passare fra i piani; ciò spegne tutti i LED dell’intero cubo. Poi eseguite un’iterazione sui LED con i dati caricati nel buffer. Utilizzate ledpin come indice dell’array per ottenere i valori dagli array, i quali contengono la posizione delle connessioni verso i pin digitali. In tal modo potete specificare se accendere o meno un LED. Due cicli for nidificati pongono LEDPin on o off. Il primo ciclo controlla la riga in cui siete posizionati e quello interno controlla la colonna all’interno di tale riga. Pertanto, potete accendere o spegnere i LED in modo semplice: digitalWrite(LEDPin[ledpin++], patternBuffer[patternBufferIndex] & (1<<ledcol));

Ricordate che la funzione digitalWrite(pin, value) accetta due parametri: il pin e il livello, HIGH (1) o LOW (0). Il pin da accendere è quello dell’array LEDPin su cui state attualmente lavorando. LEDPin specifica quale dei tre LED state impiegando. La sequenza “++” incrementa questa variabile indice, in modo che possiate prelevare il successivo elemento dell’array LEDPin nella successiva iterazione del ciclo for, per poter considerare il prossimo LED. Il valore da scrivere viene tratto dall’array patternBuffer, utilizzando uno scorrimento di bit. I valori binari della variabile ledcol vengono fatti scorrere a sinistra per il valore di ledcol, come indicato da 1 << ledcol. Questo ha l’effetto di saltare le colonne per trovare il valore della prossima colonna di LED. Il simbolo “&” è l’operatore di AND bit-a-bit. Se sia patternBuffer, sia il nuovo valore in arrivo da ledcol sono uguali a 1, l’output risultante è HIGH e il LED viene acceso; altrimenti l’output è LOW.

Anche se potete aver inviato il valore HIGH sul pin di un LED, questo non si accenderà ancora. Non esiste ancora un percorso che conduca a terra, in quanto i pin analogici sono ancora entrambi HIGH. La prossima volta che genererete un frame, dovete saltare avanti per ottenere i successivi ventisette valori binari dei LED da patternBuffer. Per farlo, incrementate patternBufferIndex. Ora, finalmente, attivate il passaggio di corrente sul piano, impostando il pin del catodo a LOW, per consentire il passaggio dell’elettricità dall’anodo attivo attraverso il catodo, fino a terra. Il LED si accenderà e potrete passare al successivo. La funzione delay Microseconds() introduce un leggerissimo ritardo. Se non ci fosse questa istruzione, il codice verrebbe eseguito così rapidamente che i LED sembrerebbero essere sempre accesi e l’effetto di animazione verrebbe vanificato. L’ultimissima riga di codice fa procedere questa operazione finché non terminano i patternData. Dopo di ciò, il ciclo do…while termina e il loop() principale non fa altro che riavviare l’intera sequenza dell’animazione. La Figura 15.17 mostra l’aspetto del cubo a LED una volta che avrete terminato di realizzarlo e che avrete caricato il codice per animare i LED.

Modifica degli schemi di animazione Potete modificare una qualsiasi delle sequenze di animazione cambiando i valori di patternData[]. Vi sono varie animazioni d’esempio da usare. Dovete cambiare gli schemi di bit e poi caricare il codice sulla scheda Arduino per vederne l’effetto. Naturalmente, la scheda Arduino dovrà essere connessa alla porta USB per poter applicare le modifiche e dunque dovrete collaudare tutte le idee prima di distaccare questo “cordone ombelicale” per procedere a batterie.


Figura 15.17 L’aspetto finale del cubo a LED.

Il software di progettazione di animazioni per il cubo a LED Naturalmente, intervenire sui singoli bit di dati è molto noioso, specialmente quando occorre collaudare le idee in modo dinamico. È molto difficile immaginarsi l’aspetto di un’animazione, tranne per chi ha “preso la pillola rossa”, l’eletto che è in grado di leggere il codice grezzo di Matrix! Un’interfaccia visuale semplifica moltissimo le cose. Il sito web del libro offre un software di progettazione delle animazioni per evitare di esplorare nuove possibilità alla cieca. Nel sito www.hoeplieditore.it/6323-9 ricercate il Pattern designer per il Capitolo 15, rappresentato nella Figura 15.18. Potete utilizzare il sito web per creare sequenze di frame e riprodurle. Basta fare clic sulle caselle grigie e trasformarle in arancione: il LED corrispondente si accenderà in tale frame. Potete osservare in anteprima i risultati in un apposito riquadro isometrico, a destra. Quando sarete soddisfatti del frame, impostatene la durata e fate clic sul pulsante Apply. Poi fate clic sul pulsante Insert in basso a destra, per creare un nuovo frame, e determinate quali dei suoi LED saranno accesi. Procedete fino a creare l’intera sequenza animata. Quando sarete pronti per osservare in anteprima l’animazione, fate clic sul pulsante Play. L’animazione verrà riprodotta approssimativamente alla stessa velocità che può essere ottenuta con il cubo. Quando sarete soddisfatti dell’animazione, fate clic sul pulsante Get Code. Potete tagliare e incollare i risultati dalla casella di testo direttamente allo sketch di Arduino. Niente di più facile! A questo punto, caricate il nuovo codice sulla scheda Arduino e godetevi l’effetto tridimensionale.


Figura 15.18 Lâ&#x20AC;&#x2122;applicazione per la progettazione di schemi per il cubo a LED.


Capitolo 16

Dieci soluzioni per dieci problemi In questo capitolo Che cosa fare in caso di problemi Problemi hardware Problemi software

A

volte le cose non vanno secondo i piani. Capita! E anche se avete seguito tutte le istruzioni con una certa cura, il progetto potrebbe non funzionare perfettamente.

Scoprire i problemi in un progetto Arduino è un’attività un po’ particolare. Nel caso di progetti puramente elettronici, basta concentrarsi sull’hardware. Con i problemi software, occorre tuffarsi nel codice. Ma con i progetti Arduino, potreste aver problemi con l’hardware oppure con il software. Pertanto potreste anche doverli controllare entrambi per vedere che cosa è andato storto. Fortunatamente ci sono alcuni “classici” da provare quando un progetto non funziona, oppure funziona, ma non secondo le aspettative. Quasi sempre io parto dall’hardware e, se non ne vengo a capo, do’ un’occhiata al codice, per vedere se vi è qualche di problema. Talvolta è anche possibile capire se rivolgersi subito all’hardware o al software in base al tipo di comportamento manifestato (o non manifestato) dal progetto. Ecco che cosa fare in caso di problemi.

Soluzioni per problemi hardware Vi sono almeno cinque elementi (ma probabilmente anche di più) da controllare per assicurarsi che l’hardware funzioni correttamente. Li ho elencati in ordine di importanza (e anche secondo l’ordine che seguo normalmente). La prima cosa da fare, in assoluto, è disconnettere l’alimentazione, nel caso in cui il circuito stia ancora funzionando. È meglio che i circuiti non siano sotto tensione mentre controllate le connessioni. Ogni ricerca di problemi hardware deve essere svolta mentre i circuiti NON sono alimentati. A questo punto controllate i cinque elementi seguenti.

Controllo delle connessioni Sono stato amministratore di reti per molto tempo, il che significa che ho connesso una grande quantità di computer a una grande quantità di altri computer. La causa più frequente di problemi, nel mio lavoro, era, semplicemente, un problema di connessione. Dunque, per prima cosa, tendo a controllare le connessioni. La stessa cosa vale per i progetti Arduino. Andate alla ricerca di fili elettrici “lenti”, piedini piegati e non ben inseriti e altre cose che possono essersi distaccate dalla loro normale posizione. Se le cose sembrano tutte a posto, verificate che anche i contatti siano corretti. Più di una volta ho inserito un componente nel foro errato della breadboard e questo causa un problema. Se avete eseguito saldature, verificatele. In particolare, si hanno saldature “fredde” quando il contatto è precario e poco conduttivo. Provate a muovere delicatamente le saldature per assicurarvi che siano fisse. Andate alla ricerca di saldature “grumose” o “sporche”, “unte”. Potreste dover risaldare qualcosa. Infine, impiegate un tester per verificare la continuità nei punti sospetti. Può capitare che una saldatura che sembra buona, in realtà non sia per niente conduttiva. Dopo aver controllato la presenza di fili disconnessi (o circuiti “aperti”), cercate i cortocircuiti. Si tratta di fili che si toccano oppure connessi quando non dovrebbero. Sono chiamati cortocircuiti perché il contatto imprevisto offre all’elettricità un percorso preferenziale che porta là dove non dovrebbe, normalmente a terra. L’elettricità, come l’acqua, segue il percorso di minor resistenza e un cortocircuito offre proprio quello. Ricercate fili senza isolamento e che possono toccarsi tra loro. Verificate attentamente la breadboard, per controllare che i fili non siano stati inseriti nella riga o


nella colonna sbagliata, con un cortocircuito. Inoltre, assicuratevi che i piedini dei componenti non si tocchino fra loro.

Se alimentate la scheda Arduino (con la porta USB o la batteria) e il LED ON non si accende, disconnettetela immediatamente. Dovete andare assolutamente alla ricerca di cortocircuiti: in qualche modo la linea di alimentazione è connessa direttamente a terra. La scheda Arduino è dotata di un fusibile protettivo, un fusibile a stato solido che previene i danni da cortocircuito che potrebbero bruciare il microcontroller, ma che non può proteggere contro tutti i problemi di messa a terra. Se avete eseguito saldature, assicuratevi che non vi siano gocce di stagno e che connessioni adiacenti non siano, in realtà, saldate insieme da un ponticello di stagno. In questo caso, utilizzate una treccia di dissaldatura o una pompetta succhia-stagno per rimuovere lo stagno in eccesso. Quindi riprovate a eseguire la saldatura. L’operazione è particolarmente difficile se avete un problema con un circuito integrato, poiché è importante non surriscaldarlo. Nel dissaldare circuiti integrati, transistor e altri componenti sensibili, fate attenzione a non applicare calore troppo a lungo o potreste bruciare il componente. La maggior parte dei componenti è in grado di sopportare un paio di centinaia di gradi per tre o cinque secondi, ma non molto di più. Una regola empirica dice che se un componente scotta, vuol dire che è troppo caldo!

Verifica dell’alimentazione Innanzitutto, assicuratevi di avere sufficiente alimentazione e che tale alimentazione arrivi nei punti corretti. Verificate bene i valori delle resistenze e assicuratevi di non aver sostituito le resistenze con valori notevolmente differenti da quelli specificati. Per esempio, se utilizzate una resistenza da 100 Kohm per ridurre il flusso di corrente verso un LED invece di una resistenza da 1 Kohm, probabilmente il LED non si accenderà affatto. Analogamente, se vi aspettate che un componente funzioni e non lo fa, può darsi che gli forniate troppa o troppo poca corrente. Se state alimentando dei componenti esterni tramite la scheda Arduino, ma questi non sembrano funzionare, provate ad alimentarli direttamente, utilizzando una batteria o una fonte di alimentazione esterna. Se il componente non funziona ancora, forse è guasto. Inoltre, se state fornendo alimentazione dal pin 5 V nella file inferiore dei contatti della scheda Arduino, verificate di non aver inavvertitamente inserito il piedino nel contatto adiacente, 3.3 V (Figura 16.1). In questo caso, il dispositivo non riceverà tensione sufficiente per funzionare. Al contrario, se avete alimentato un dispositivo da 3,3 Volt utilizzando 5 V, potreste aver esagerato e potrebbe anche essere troppo tardi per salvare il componente. I dispositivi da 3,3 V tendono a essere molto sensibili alle sovratensioni. Un altro problema che rientra in questo stesso campo potrebbe essere il fatto che avete connesso uno dei fili di terra al pin Vin. Questo pin è connesso al polo centrale del connettore di alimentazione, che si trova in basso a sinistra nella scheda Arduino. Il caso opposto è che abbiate connesso un filo che doveva fornire alimentazione al pin Vin a uno dei due pin GND. Il fusibile dovrebbe proteggere contro questi problemi, ma è sempre meglio evitarli.


Figura 16.1 Evitate di eseguire connessioni errate con i pin di alimentazione.

Fate attenzione a utilizzare una terra comune. Specialmente quando controllate i dispositivi commutando l’alimentazione con un transistor, spesso la terra del transistor deve essere connessa con la terra del dispositivo che state controllando. Verificate attentamente lo schema elettrico, per determinare se le cose stanno così e verificate di aver realizzato il circuito correttamente. Tutti commettiamo errori, anche nei nostri giorni migliori. Anch’io ho bruciato la mia bella quota di componenti. Ho iniziato a sentirmi in colpa quando ho bruciato una manciata di LED a infrarossi per un progetto e così ho iniziato a creare un piccolo cimitero di LED (Figura 16.2). Lo tengo sempre sul mio tavolo da lavoro per ricordarmi di controllare sempre le connessioni prima di dare alimentazione.

Figura 16.2 Il mio piccolo cimitero dei LED.

Alla ricerca di odori molesti e di componenti bollenti Può strappare un sorrisetto ironico, ma se avete dei problemi con i componenti, potreste averli inavvertitamente sottoposti a sovratensioni. Dovete sospettarlo in particolare se i componenti scottano tanto da non poterli toccare e se iniziate a percepire odori insoliti. Se qualcosa scotta, avete un problema. Disconnettete l’alimentazione e iniziate da capo per cercare di diagnosticare i contatti. Annusate attentamente i circuiti alla ricerca di odore di plastica bruciata. Normalmente è un cattivo segno e il componente, probabilmente, è già bruciato. Sfortunatamente, se siete arrivati a questo punto, probabilmente è troppo tardi e il danno è già fatto: “Non c’è fumo senza arrosto”, dice


il proverbio e non è bellissimo che l’arrosto sia di componenti. Controllate i contatti e, per sicurezza, sostituite tale componente. Potreste aver già bruciato il componente in questione o anche la scheda Arduino, ma potete provare almeno a sostituire il componente e riprovare. Anche il microcontroller ATmega328 può essere tolto e sostituito. Cercate solo di capire perché qualcosa s’è bruciato prima di sostituirlo e di dare nuovamente alimentazione.

Controllare le uscite per i dispositivi esterni Ottenete quello che vi aspettate? In caso contrario, dovreste controllare le uscite digitali, sia sulla scheda Arduino sia sui dispositivi esterni. Se vi aspettate che un dispositivo esterno invii 5 V, come nel caso di un sensore che utilizzate per un input digitale, utilizzate il tester per controllare di ricevere da tale sensore questa tensione. In caso contrario, la scheda Arduino potrebbe non essere in grado di leggere l’output di questo sensore come un livello HIGH. Se vi aspettate di leggere un valore analogico come input e non vi è alcuna tensione in arrivo dal dispositivo, la scheda Arduino non riceverà le letture previste per gli imput analogici. Anche in questo caso, utilizzate un tester per vedere esattamente quali valori vengono prodotti dal dispositivo di input. Inoltre, assicuratevi che se utilizzate un dispositivo che fornisce un output digitale, questo vada a un pin digitale. Se il sensore sta fornendo un output analogico, verificate che vada a un pin di input analogico.

Verifica dei pin digitali Controllate anche i pin della scheda Arduino. Se inviate loro troppa corrente, potreste averne bruciato uno, che magari ha smesso di operare. La massima corrente è di 40 mA. Può sopportare qualcosa di più per un po’ di tempo, ma superare i livelli massimi non è mai una buona idea. Se sospettate che un pin non funzioni più, controllatelo per sicurezza. Connettete una resistenza da 220 ohm a un LED. Connettete il piedino corto del LED a terra e quello lungo al pin digitale sospetto. Lanciate lo sketch Blink sulla scheda Arduino, sostituendo al pin 13 il pin in questione. Per esempio, se sospettate che il pin 7 sia “morto”, modificate il codice in modo che indichi ledPin = 7 e inviatelo alla scheda Arduino. Se il LED non lampeggia, significa che il pin ha ormai raggiunto il “Paradiso dei contatti”.

Soluzione dei problemi software Dopo esservi assicurati che l’origine del problema non sia nell’hardware, è tempo di concentrarsi sul software. Talvolta può capitare che un problema apparentemente hardware derivi in realtà dal codice. Di seguito ho elencato alcuni elementi da controllare, partendo da quelli più importanti.

Controllare la sintassi Più o meno nell’era dei dinosauri, stavo imparando a programmare e il messaggio che vedevo più spesso sul mio monitor a fosfori verdi era ?_ SYNTAX ERROR. Un messaggio laconico e criptico: normalmente significava che c’era un carattere fuori posto nel codice, che mancava uno spazio o che vi era un errore tipografico. L’ambiente di sviluppo di Arduino offre qualcosa di equivalente nella console che compare nella parte inferiore della finestra. Quando vi è un problema, il bordo della finestra diviene arancione e viene visualizzato un messaggio d’errore. Talvolta il messaggio di errore può essere difficile da interpretare. Ma dedicate del tempo a leggerlo e a cercare di capire che cosa vi sta comunicando. Il compilatore sta cercando di puntarvi nella direzione corretta. Se vi è un errore nel codice, normalmente evidenzierà la riga in cui si trova. Il problema più comune è la mancanza di un punto e virgola alla fine di una riga. Probabilmente la seconda più comune causa di errori è la mancanza di una parentesi graffa chiusa, che produce il messaggio “expected declaration before ‘}’ token” o qualcosa del genere. Non preoccupatevi troppo del significato della parola “token”, e andate semplicemente alla ricerca della parentesi mancante. Il piccolo numero che compare all’angolo inferiore sinistro della finestra dell’ambiente di sviluppo vi dirà la riga sulla quale si trova il problema. Il compilatore non è perfetto e pertanto può indicare che il problema si trova in un’area, quando invece la causa è un errore di sostanza o tipografico che si trova in un altro punto. Raggiungete il


punto in cui è stato identificato il problema e procedete a ritroso nelle parti del programma che possono aver condotto a questo punto. Probabilmente vi troverete il problema da sistemare.

Uso del Monitor seriale Poiché la scheda Arduino non ha un proprio monitor, non è possibile controllare ciò che sta accadendo nell’hardware. Pertanto dovrete utilizzare il computer come monitor di Arduino e inviare tutto ciò che intendete ispezionare al Monitor seriale. Ponete delle istruzioni serial.println() nei punti chiave del codice, per inviare il contenuto delle variabili sul Monitor seriale. Potreste anche dover aggiungere delle istruzioni delay() per introdurre un leggero ritardo, in modo da consentirvi di leggere i valori. In caso contrario, i numeri potrebbero scorrere subito via dal Monitor seriale. La porta seriale è l’unico canale di comunicazione fra il computer e la scheda Arduino. Tale porta usa il cavo USB, ma è accessibile anche attraverso i pin digitali 0 e 1. Per questo motivo, non potete utilizzare il Monitor seriale per inviare e ricevere dati dal computer quando state utilizzando quegli stessi pin digitali per uno shield o un altro dispositivo. Un solo progetto di questo libro, il lettore di schede RFID, usa il pin di input seriale di Arduino (pin 0, RX ) per prelevare dati dal lettore di schede RFID. Pertanto dovrete disconnetterlo dalla porta seriale quando caricate software sulla scheda Arduino.

Controllate gli input e gli output Verificate che nel codice abbiate specificato la modalità di input dei pin digitali nella sezione setup(). Devono essere pinMode(pin, INPUT) o pinMode(pin, OUTPUT). I pin analogici non devono essere dichiarati se li utilizzate come tali. Inoltre, se leggete dati da un sensore esterno, verificate che questo fornisca il genere di segnali che vi aspettate. Per esempio, alcuni sensori a effetto Hall forniscono un output digitale a 5 o 0 V. Se li leggete attraverso pin analogici, le cose non funzioneranno come previsto. Analogamente, se state cercando di leggere con un pin digitale un dispositivo che produce un’uscita a tensione variabile, potreste ottenere comportamenti imprevisti. Connettetelo invece a un pin di input analogico.

Uso di un simulatore o di un emulatore Se utilizzate Windows o Linux, potete anche utilizzare un “simulatore” per operare da computer su un Arduino virtuale. Purtroppo, al momento attuale, non esistono emulatori Arduino per Mac. I simulatori sono applicazioni che fingono di essere una scheda Arduino, comportandosi esattamente come l’hardware del chip ATmega328, ma operando esclusivamente tramite software. Basta eseguire l’emulatore e programmarlo con il codice che inviereste all’Arduino. La cosa interessante è che potete vedere tutti gli input e gli output e potete controllare i segnali che vanno ai pin analogici e digitali impiegando cursori e interruttori virtuali. L’Arduino virtuale mostra esattamente come si comporterebbe un Arduino reale, cambiando gli input e gli output. Potrete ispezionare anche il contenuto della memoria e verificare il valore delle variabili in un determinato momento. La diagnosi dei problemi può essere particolarmente difficile sui microcontroller, a meno che possiate ispezionarli in tempo reale con un emulatore. Il chip è una sorta di “scatola nera” e gli emulatori sono un ottimo modo per “aprirla” e rilevarne il contenuto. Vi sono sia simulatori Arduino che ne replicano il comportamento, sia emulatori per la famiglia di chip AVR, che sono strumenti tecnici rivolti soprattutto agli ingegneri. Ecco dove potete procurarveli.

Simulatori Arduino Provate i seguenti simulatori. Simulator per Arduino free e versione Pro (virtronics.com.au o www.arduino.com.au/) Arduino Simulator iPhone App Emulino (free) (https://github.com/ghewgill/emulino) Simuino (free) (http://code.google.com/p/simuino/)

Emulatori AVR


Ecco alcuni emulatori che potete utilizzare. AVR Studio 4, 5, or 6 (www.atmel.com/microsite/atmel_studio6/) Virtual Breadboard ($29.00) (www.virtualbreadboard.com/) Emulare (http://emulare.sourceforge.net/) SimAVR (http://gitorious.org/simavr)

Se, nonostante tutto, non funziona... Leggete il manuale! In realtà non potete farlo, poiché non esiste un manuale di Arduino. La cosa che gli si avvicina di più è il sito web di Arduino (http://arduino.cc). Il sito è ricco di forum che possono essere consultati utilizzando la casella di ricerca che si trova nell’angolo superiore destro. Se avete un problema, molto probabilmente è già stato riscontrato da altri! Scegliete i termini di ricerca con cura e, indubbiamente, scoprirete che il vostro problema, o un problema analogo, ha già una soluzione. Anche su Adafruit, Sparkfun e element14 trovate dei forum su Arduino, nei quali chiunque può aprire nuove discussioni. Queste comunità sono piene di appassionati come voi e me, che vogliono solo usare Arduino per fare cose interessanti. Quasi sempre gli altri utenti sono una risorsa preziosa. Non temete di presentarvi come principianti. Al contrario, potreste ricevere una risposta molto più rapidamente. Usate il vostro motore di ricerca preferito per cercare altre persone che possono aver avuto lo stesso problema e, soprattutto, siate perseveranti. Proprio quando pensereste che è veramente difficile venire a capo di un problema, potreste avere la risposta che aspettate.


Indice analitico A alarmArmed alarmFrequency alarmHrs alarmMins algoritmo alimentatore, scelta e uso alimentazione a batterie Ampere anodo comune API (Application Programming Interface) Arduino a cosa serve alimentazione comunitĂ di hobbisti configurazione sul computer connessione contribuire al progetto cosâ&#x20AC;&#x2122;è la scheda lavorare con mondo open-source studiare con Arduino DUE Arduino LEONARDO Arduino MEGA Arduino MICRO Arduino UNO array elemento indice array di byte di char attuatori automobilina telecomandata assemblaggio del telaio codifica dei motori collaudo dei motori collaudo del sistema collocazione dei componenti sulla breadboard componenti decodifica degli infrarossi fissaggio dei servomotori al telaio lettura dei codici del telecomando montaggio delle ruote realizzazione del circuito su breadboard realizzazione del telaio saldatura dei piedini di alimentazione schema elettrico

B basette millefori


basi dell’elettronica bitmap Blink breadboard

C cacciavite camel case catodi catodo catodo comune cavo multicore chip select ciclo ciclo for circuito, realizzazione circuito con input analogico codice configurazione definizione di nuove funzioni funzionamento del invio del sequenza delle operazioni codice di Arduino coltellino commenti commutatori componenti discreti componenti elettronici Comunicare con Arduinoc concetti chiave condizione di test configurazione confronto bit-a-bit connessione a terra connettori a pettine const, parola riservata continuità controllo degli input e degli output controllo dei processi controllo delle connessioni corrente costanti costanti intere cubo a LED aggiunta dell’alimentazione assemblaggio del cubo assemblaggio della matrice di LED caricamento del frame ciclo principale collaudo dei LED collaudo dell’intera struttura componenti composizione e saldatura di un livello connessione alla scheda Arduino dichiarazioni di variabili esecuzione delle connessioni finali modifica degli schemi di animazione preparativi per la saldatura programmazione realizzazione del cubo realizzazione della base saldatura dei piedini e dei ponticelli alla stripboard


saldatura delle colonne di anod schema elettrico sezione Setup software di progettazione di animazioni visualizzazione del frame currentLED

D datasheet data stream DateTime debugging decrementare delayTime DHCP (Dynamic Host Configuration Prototcol) diagrammi di flusso dichiarazioni di variabili dieci soluzioni per dieci problemi DIL (Dual In-Line) diodo dir disuguaglianza logica DNS (Domain Name Service) driver, installazione duty-cycle

E elemento dell’array elettricità elettrodomestici emulatori AVR evento principale

F flowchart fonte di alimentazione for funzioni definite dall’utente

G giardino automatizzato aggiunta di ulteriori valvole applicazione del nastro adesivo allo stampo avvolgimento del filo attorno ai chiodi calibrazione del sensore e del livello di flusso collocazione dei componenti sulla breadboard componenti componenti per realizzare il progetto configurazione in setup() creazione di un sistema di annaffiatura esecuzione del ciclo principale finitura della sonda con la colla a caldo fissaggio della riserva sulla base foro sul tappo della bottiglia inserimento del tubo per l’irrigazione portare l’acqua al vaso programmazione, calibrazione e collaudo realizzazione del circuito sulla breadboard realizzazione della riserva d’acqua realizzazione del sensore di umidità realizzazione del sistema


riempimento dello stampo con il gesso rimozione della sonda dallo stampo saldatura dei fili alla sonda schema elettrico del sistema di irrigazione taglio dello stampo in tubo vinilico valvola a solenoide e i relativi adattatori giocattoli e passatempi

H hardware, funzionamento Hertz (Hz)

I IC (Integrated Circuit) IDE installazione programmazione if incremento della variabile indice dell’array indirizzo IP statico inizializzazione della variabile input insegna scorrevole animazione degli sprite caricamento e visualizzazione delle lettere componenti creazione delle variabili funzionamento del codice funzionamento dell’hardware matrice di LED problemi e soluzioni realizzazione del circuito schema e aspetto della matrice di LED variabili globali per il testo a scorrimento visualizzazione del testo a scorrimento int interfaccia SPI involucro epossidico istruzione if

K kit Arduino know-how

L LED, come è fatto ledPin lega di stagno Legge di Ohm lettore RFID ID-Innovations adattare il lettore alla breadboard assemblaggio del lettore ciclo principale collaudo e configurazione del lettore componenti dichiarazioni di variabili funzioni definite dall’utente lettura con successo di un tag valido programmazione del lettore


realizzazione realizzazione del circuito rilevamento del valore di un nuovo tag nel Monitor seriale saldatura dei piedini sulla scheda breakout scheda SparkFun schema di montaggio dei componenti schema elettrico setup libreria RTClib librerie installazione LilyPad Arduino LiquidCrystal livello di luminosità su un pin digitale loadSprite, funzione loop Lux (pupazzetto luminoso) cambiare umore caricamento del codice codice pezzo per pezzo collaudo del codice componenti costruzione del circuito funzionamento dell’hardware interventi sul codice miscelare la luce posizionamento dei componenti sulla breadboard schema elettrico sequenza di passi eseguiti da

M MAC (Media Access Control) matita e pennarello indelebile meccanismo a relé memoria flash microcontroller microprocessori mixer audio modulazione PWM

N norme di sicurezza numeri esadecimali

O OAuth (Open Standard for Authentication) offset operatore di deindirizzamento operatori di confronto orologio sveglia aggiunta dei pulsanti e del commutatore di input aggiunta del display a cristalli liquidi aggiunta dell’altoparlante piezoelettrico aggiunta della sveglia assemblaggio del modulo RTC collocazione dei pulsanti di input e del commutatore a cursore collocazione del pulsante di avanzamento dei valori componenti componenti del kit RTC DS1307 controllo, impostazione e visualizzazione della sveglia


display a cristalli liquidi piedini di controllo schema elettrico visualizzazione dellâ&#x20AC;&#x2122;ora ottimizzazione della zona Arduino output

P parola riservata partitore di tensione pasta di pulizia PCB (Printed Cuircuit Board) perfboard piano di taglio piedinatura piedinatura della matrice di LED piedinature pin digitali pinza a becchi conici porta per animali domestici aggiunta della logica di programmazione aggiunta delle librerie Ethernet e Twitter collaudo dei sensori collaudo del circuito componenti connessione dei sensori e dei cavi alla scheda creazione di unâ&#x20AC;&#x2122;applicazione sul sito Developers creazione di un token di accesso e relativa chiave fissaggio con nastro dei sensori in posizione per stimare la lunghezza del cavo invio di un tweet modifiche allo sportello del gatto montaggio del sensore e del magnete preparazione dellâ&#x20AC;&#x2122;account Twitter realizzazione del codice schema di collocazione dei componenti specificare i tweet potenziometro predisposizione dello spazio di lavoro produzione automatizzata progetti messa in funzione scatole e contenitori progetto automobilina telecomandata casa e giardino interattivi collocazione dei componenti. cubo a LED giardino automatizzato insegna scorrevole lettore di RFID Lux (pupazzetto luminoso) occhio a scanner orologio sveglia porta per animali domestici predisposizione dei componenti registratore di percorsi GPS sistema di controllo degli accessi stazione di rilevamento domestica protocolli pulse width puntatore punte di ricambio


pupazzetto luminoso PWM (Pulse-Width Modulation)

R RAM (Random-Access Memory) registratore di percorsi GPS assemblaggio e collaudo dello shield GPS collaudo del registratore di dati collocazione dello shield in posizione pronto per la saldatura componenti connessione dell’adattatore per l’antenna esterna creazione del contenitore fissaggio della scheda Arduino fori per l’interruttore e l’antenna installazione della scheda Mini SD e della batteria montaggio dell’interruttore e dell’adattatore per l’antenna esterna programmazione del registratore di dati saldatura dello shield sui piedini separazione del pettine nel punto corretto tracciamento dei dati e del percorso resistenza resistenze RFID (radio frequency ID) attivi cosa sono i codici esempi frequenza e protocolli passivo RTC (Real Time Clock)

S saldatore scelta del saldatura, basi della scheda, scelta della schede RFID schemi collocazione dei componenti scorrimento di bit semiconduttore sensori gusto olfatto udito vibrazione/tatto vista serrature elettriche shield sigillare le estremità dei sensori di temperatura e di luminosità simulatori Arduino sistema di controllo degli accessi aggiunta e collaudo del relé assemblaggio e installazione del sistema codifica e collaudo del tastierino componenti componenti interni di una serratura elettrica connessione del circuito integrato Max xx connessione dell’alimentatore connessione del transistor e del relé connessioni nel transistor N2222 contatti dei piedini di un tastierino a matrice


dichiarazione delle variabili esecuzione del ciclo principale fissaggio dei cavi con una fascetta identificare i piedini del tastierino installazione degli elementi nel contenitore installazione della chiusura sulla porta nuove funzioni percorso dei cavi di alimentazione per la scatola di controllo e la serratura piedinatura e connessioni del tastierino all’Arduino realizzazione del prototipo con tasterino e display saldatura dei piedini del tastierino saldatura del circuito integrato su stripboard scelta di una serratura schema elettrico sezione setup uso di un cavo a nastro e di un connettore a pettine sistema GPS sistemi embedded sketch Blink slave select (SS) soluzione dei problemi software soluzioni per problemi hardware SparkFun spelafili SPI (Serial Peripheral Interface) sprite spugna e spugna metallica SRAM (Static Random Access Memory) stagnatura stazione di rilevamento domestica aggiunta della resistenza allo shield dei sensori calibrazione dei livelli di luminosità collaudo dello scorrimento dei sensori componenti configurazione del device su Xively conversione della temperatura conversione del livello di luminosità costruzione dei sensori costruzione e collaudo del circuito creazione di un account Xively disposizione dei componenti sulla breadboard funzionamento del ciclo principale funzionamento del codice inserimento dello shield dei sensori installazione della stazione di rilevamento output prodotto dal test dei sensori posizionamento dei piedini programmazione della stazione di rilevamento realizzazione delle sonde per i sensori realizzazione dello shield per i sensori saldatura dei pin in posizione saldatura del sensore di luminosità saldatura del sensore di temperatura schema elettrico senso delle letture dei sensori stripboard strumenti di dissaldatura strumenti per i progetti supporto supporto “terza mano”

T


taglierina tensione tester, scelta e uso tester (multimetro) timeChanged timestamp transistor tronchesino tweet Twitter

U uso del Monitor seriale uso di un simulatore o di emulatore

V valvola a solenoide variabile inizializzata variabile locale variabili variabili di servizio verifica dei pin digitali verifica dellâ&#x20AC;&#x2122;alimentazione Vibrazione/tatto void, parola riservata Volt (V)

X Xively, creazione di un account


Informazioni sul Libro Programmazione Arduino Realizzazione di una sveglia Arduino Automazione di un sistema di irrigazione domestico Suggerimenti per la realizzazione di un sistema di accesso a tastierino numerico Istruzioni per la realizzazione di un lettore RFID Realizzazione di unâ&#x20AC;&#x2122;automobilina robotizzata partendo da oggetti di uso quotidiano Progetti a controllo remoto

Creare progetti con arduino for dummies con 12 progetti facili da realizzare! (hoepli for dummies) (  
Creare progetti con arduino for dummies con 12 progetti facili da realizzare! (hoepli for dummies) (  
Advertisement