Introduzione ad Arduino

Innanzitutto che cos'è Arduino?"Arduino è una scheda elettronica di piccole dimensioni con un microcontrollore e circuiteria di contorno, utile per creare rapidamente prototipi e per scopi hobbistici e didattici." (Da Wikipedia, l'enciclopedia libera).Nel periodo in cui sono stati scritti questi appunti (inizio 2015) facendo una ricerca su internet con la parola 'arduino', ad esempio con Google, viene mostrato il seguente risultato:

Circa 38.200.000 risultati

Naturalmente non tutte le pagine trovate riguarderanno la scheda in questione, ma una buona parte avrà come argomento qualche dispositivo, più o meno complesso, basato su uno dei tanti modelli di scheda realizzati a partire dall'avvio del progetto Arduino.Tra le prime pagine (se non proprio la prima) compare il sito di riferimento:

www.arduino.cc

che assieme alla pagina del relativo forum è diventato fin da subito il punto di incontro di migliaia di appassionati che hanno contribuito a rendere grande questa piattaforma "made in Italy".Un altro sito molto interessante, utile dal punto di vista didattico, è quello del prof. Michele Maffucci, raggiungibile al seguente link: http://www.maffucci.it/area-studenti/arduino/.

La piattaforma hardware che ha preso il nome di Arduino è un progetto italiano. Precisamente è nata ad Ivrea nel 2005 (da un team composto da Massimo Banzi, David Cuartielles, Tom Igoe, Gianluca Martino e David Mellis) presso l'Interaction Design Institute (un istituto di formazione post-dottorale con sede a Ivrea, fondato da Olivetti e Telecom Italia operante dal 2001 al 2005 prima di essere incorporato all'interno della Domus Academy) e successivamente sviluppata all'università Los Andes in Colombia. Il nome della scheda deriva da quello di un bar di Ivrea (che richiama a sua volta il nome di Arduino d'Ivrea, Re d'Italia nel 1002) frequentato da alcuni dei fondatori del progetto.

Lo scopo di tale progetto era quello di rendere disponibile, a progetti di Interaction design (disciplina che appartiene all'ambito di ricerca dell'«interazione uomo-macchina») realizzati da studenti, un dispositivo per il controllo che fosse più economico rispetto ai sistemi di prototipazione allora disponibili. I progettisti riuscirono a creare una piattaforma di semplice utilizzo ma che, al tempo stesso, permettesse una significativa riduzione dei costi rispetto ad altri prodotti disponibili sul mercato. A ottobre 2008, in tutto il mondo erano già stati venduti più di 50.000 esemplari di Arduino.

La particolarità del progetto è che le informazioni sull'hardware, e soprattutto i progetti, sono disponibili per chiunque: si tratta quindi di un hardware open source, distribuito nei termini della licenza Creative Commons Attribution-ShareAlike 3.0. In questo modo, chi lo desidera può legalmente auto-costruirsi un clone di Arduino o derivarne una versione modificata, scaricando gratuitamente lo schema elettrico e l'elenco dei componenti elettronici necessari. Questa possibilità ha consentito lo sviluppo di prodotti Arduino compatibili da parte di piccole e medie aziende in tutto il mondo: è quindi divenuto possibile scegliere tra un'enorme quantità di schede Arduino-compatibili.L'hardware originale Arduino è interamente realizzato in Italia dalla Smart Projects, mentre i cloni della scheda possono essere realizzati da chiunque in qualsiasi parte del mondo.Una scheda Arduino tipica consiste in un microcontrollore a 8-bit AVR prodotto dalla Atmel, con l'aggiunta di componenti complementari per facilitarne l'incorporazione in altri circuiti. In queste schede sono usati chip della serie megaAVR - nello specifico i modelli ATmega8, ATmega168, ATmega328, ATmega1280 e ATmega2560.Molte schede includono un regolatore lineare di tensione a 5 volt e un oscillatore a cristallo a 16 MHz, sebbene alcune implementazioni, come ad esempio la piccola LilyPad, abbiano un clock di 8 MHz e facciano a meno dello stabilizzatore di tensione.

L'attuale versione di Arduino Uno presenta le seguenti caratteristiche:

Microcontrollore ATmega328Tensione di funzionamento 5V

Tensione di ingresso (raccomandata)

7-12V

Tensione di ingresso (limiti) 6-20V

Pin Digitali di I/O 14 (i 6 indicati con ~ forniscono un'uscita PWM)Pin Analogici di Input 6

Corrente max per I/O Pin 40 mACorrente max per 3.3V Pin 50 mA

Memoria Flash32 KB (ATmega328) dei quali 0.5 KB usati dal bootloader

SRAM 2 KB (ATmega328)

EEPROM 1 KB (ATmega328)Velocità di Clock 16 Mhz

Altre versioni di Arduino presentano caratteristiche diverse, per la cui trattazione si rimanda alla pagina di riferimento www.arduino.cc/en/Main/Boards. Tra le più note citiamo solamente Arduino Diecimila, Arduino 2009, Arduino Mega e Arduino Mega2560 (si veda il sito di riferimento).

Inoltre sono disponibili in commercio molte schede applicative plug-in note come "shields", ovvero schede di espansione che possono essere collocate al di sopra della Arduino base, inserendosi nei connettori di cui è normalmente fornita la scheda Arduino.La seguente immagine riporta la descrizione dei principali elementi della scheda Arduino UNO R3:

Naturalmente la sola scheda elettronica non servirebbe a niente se non fosse affiancata da un buon tool di programmazione. L'ambiente di sviluppo integrato (Integrated Development Environment o IDE) di Arduino è un'applicazione multipiattaforma (per Windows, Mac, Linux) scritta in Java, ed è derivata dall'IDE creato per il linguaggio di programmazione Processing (è un linguaggio di programmazione che consente di sviluppare diverse applicazioni come giochi, animazioni e contenuti interattivi; eredita completamente la sintassi, i comandi e il paradigma di programmazione orientata agli oggetti dal linguaggio Java ma in più mette a disposizione numerose funzioni ad alto livello per gestire facilmente gli aspetti grafici e multimediali) e adattato al progetto Wiring (è un ambiente di programmazione open source per impieghi su schede elettroniche). Tale applicazione è concepita per iniziare alla programmazione artisti e altri neofiti, che siano a digiuno di pratica nello sviluppo di software.Per permettere la stesura del codice sorgente, l'IDE include un editore di testo dotato inoltre di alcune particolarità, come il syntax highlighting (evidenziazione della sintassi), il controllo delle parentesi e l'indentazione automatica. L'editor è inoltre in grado di compilare e lanciare il programma eseguibile in una sola passata e con un solo click. In genere non vi è bisogno di creare dei Makefile o far girare programmi dalla riga di comando.Sul sito ufficiale di Arduino è disponibile la sezione Download, dalla quale è possibile scaricare l’IDE per il sistema operativo che si sta utilizzando (sono supportati Windows, Linux e Mac OS X). Oltre all'ultima versione "Arduino 1.0.6" (versione corrente al momento della stesura della guida), sono disponibili una versione Beta con il supporto per le board "Arduino Yun" e "Arduino Due", una versione dedicata per la board "Galileo" della Intel ed addirittura i sorgenti dell’ambiente, data la natura open source del progetto.Nel caso di Windows, utilizzato nel corso di questa guida, c'è la possibilità di scaricare un installer oppure un semplice file ZIP contenente tutto il necessario. Per evitare un inutile processo di installazione, la seconda soluzione è assolutamente la migliore; in questo modo basterà semplicemente cancellare la cartella nel caso in cui si dovesse aggiornare l’IDE oppure non volerlo più utilizzare.

Una volta scaricato ed estratto il contenuto del file ZIP, basta cliccare sul file eseguibile arduino.exe che si trova nella cartella principale e dopo pochi secondi ci si ritrova davanti l’unica finestra semplice ma essenziale dell’IDE completamente sviluppato in Java.

L'ambiente di sviluppo presenta, come la maggior parte dei programmi, un menù a tendina ed una barra degli strumenti (toolbar) contenente i seguenti pulsanti:

Verifica: compila e controlla il codice per individuare eventuali errori

Carica: compila e carica il codice nella scheda Arduino

Nuovo: crea un nuovo programma (sketch)

Apri: presenta un menu contenete tutti i programmi realizzati

Salva: salva il programma su disco

Inoltre nella parte più a destra della toolbar è presente il pulsante utilizzato per aprire il cosiddetto monitor seriale:

Monitor seriale: apre la seguente finestra

che permette di visualizzare i dati inviati dalla scheda Arduino tramite la porta seriale (via USB). Per inviare i dati alla scheda basta inserire il testo e fare click sul pulsante "Invia" o premere Invio.

L'ambiente di sviluppo integrato di Arduino è fornito di una libreria software C/C++ chiamata "Wiring" (dall'omonimo progetto Wiring) che rende molto più semplice implementare via software le comuni operazioni di input/output. I programmi di Arduino sono scritti in C/C++, ma all'utilizzatore, per poter creare un file eseguibile, non è richiesto di scrivere un programma in C, ma solo di definire due funzioni:

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

• loop(); è una funzione chiamata ripetutamente, la cui esecuzione si interrompe solo con lo spegnimento della scheda.

Lo schema minimo di un programma è contenuto nel file di esempio "BareMinimum.ino" e consiste appunto nelle sole due funzioni appena citate:

Naturalmente questo programma non fa niente dato che non ci sono istruzioni da eseguire.Per vedere Arduino all'opera si può aprire il file di esempio "Blink" che si trova in:

File > Esempi > 01.Basics > Blink

Prima di caricare lo sketch sulla board occorre selezionare la scheda in possesso dal menu:

Strumenti > Tipo di Arduino > Arduino Uno

e la porta seriale da utilizzare per la comunicazione, che compare nella lista delle porte selezionabili solo dopo aver collegato la board Arduino al PC tramite l'apposito cavo USB:

A questo punto è sufficiente fare click sul pulsante Carica per trasferire il programma sulla scheda Arduino: ci vorrà qualche secondo durante i quali si vedranno lampeggiare i led RX e TX (ricezione e trasmissione); se tutto andrà a buon fine verrà restituito il messaggio "Caricamento terminato" nella status bar:

Dopo che l'upload su Arduino è terminato il led L associato al pin 13 inizierà a lampeggiare.

All'interno della cartella examples accessibile da:

File > Esempi >

sono contenuti molti sketch di esempio utili per prendere confidenza con il linguaggio usato per programmare Arduino. Inoltre per capire come utilizzare le funzioni disponibili è possibile leggere la guida di riferimento di Arduino consultabile dal menu:

Aiuto > Guida di riferimento

che apre un file html contenente tutte le funzioni fornite dall'ambiente di programmazione, suddivise per tipologia. Le funzioni più usate e che impareremo ad utilizzare in questa guida sono:

pinMode()usata per configurare uno dei 14 pin digitali come input o output

digitalWrite()usata per impostare un pin digitale a HIGH o LOW

digitalRead()usata per leggere lo stato di un pin digitale

analogRead()usata per leggere un pin analogico

analogWrite()usata per scrivere un valore analogico sui pin indicati con ~

delay()usata per mettere in attesa il programma per un tempo determinato (di millisecondi)

millis()usata per leggere il tempo trascorso dall'accensione della scheda, espresso in millisecondi

Analizziamo ora, riga per riga, il listato del programma "Blink" precedentemente caricato sulla board Arduino in modo da prendere confidenza con le istruzioni basilari.I caratteri /* e */ vengono usati per racchiudere un commento espresso su più righe:

/* Blink Turns on an LED on for one second, then off for one second, repeatedly. This example code is in the public domain. */

mentre un commento su una sola riga è preceduto dalla doppia barra //:

// Pin 13 has an LED connected on most Arduino boards.

La seguente riga di codiceint led = 13;

definisce una variabile di nome led di tipo intero (int) cui viene assegnato il valore 13 (che corrisponde al pin digitale associato al LED L della board Arduino). Si noti che ogni istruzione deve terminare con un punto e virgola.La parola chiave void indica ad Arduino che stiamo dichiarando una funzione di nome setup(), cioè una porzione di codice che esegue un’operazione specifica; la parentesi graffa aperta { indica dove incomincia il codice:void setup() {

mentre la parentesi graffa chiusa } indica la fine della funzione setup(). Le parentesi graffe vengono usate in generale per racchiudere blocchi di istruzioni.

L'istruzionepinMode(led, OUTPUT);

dice ad Arduino come usare un determinato pin. Tra parentesi tonde vengono specificati gli argomenti che possono essere numeri e lettere. I pin digitali possono essere utilizzati sia come INPUT che come OUTPUT. Nel nostro caso poiché vogliamo far lampeggiare il diodo LED dobbiamo definire il pin di OUTPUT. Le parole INPUT e OUTPUT sono costanti definite, che non variano mai nel linguaggio di Arduino.Le parolevoid loop()

indicano la sezione di codice principale, cioè il nucleo del programma che verrà ripetuto all’infinito fino a quando non si spegne la scheda.Tra le due parentesi graffe si trovano le seguenti istruzionidigitalWrite(led, HIGH);delay(1000);digitalWrite(led, LOW);delay(1000);

L’istruzione digitalWrite() possiede due argomenti, il primo definisce il pin, il secondo indica lo stato. Questa istruzione è in grado di impostare un pin definito come OUTPUT ad un valore HIGH (corrispondente ad una tensione di 5 V) o ad un valore LOW (corrispondente ad una tensione di 0 V); in modo più semplice permette di accendere o spegnere un led connesso al pin specificato nel primo argomento, nel nostro caso LED.L’istruzione delay() è un’istruzione molto semplice che non fa altro che interrompere per un determinato tempo l’esecuzione del programma. L’istruzione ha un solo argomento numerico che indica il numero di millisecondi di attesa. Nel nostro caso con “delay(1000)” diciamo che il programma deve bloccarsi per 1000 millisecondi ovvero 1 secondo.Quindi, in sostanza, il programma "Blink" accende e spegne ripetutamente per un secondo il LED L associato al pin 13.Il diagramma di flusso relativo al programma appena analizzato è:

Andiamo ora a vedere alcuni programmi un po' più impegnativi, che comportano anche la realizzazione di semplici circuiti elettronici. Allo scopo viene utilizzata una basetta sperimentale o breadboard che non richiede saldature ed è completamente riusabile:

Esercitazione 1

Il seguente circuito è formato da 3 LED, 3 pulsanti e 3 resistenze da 330 ohm:

I LED vanno collegati con la giusta polarità, essendo i due terminali distinti:

Le resistenze sono collegate tra gli anodi dei LED ed i pin digitali 3, 5 e 6; i catodi dei LED sono posti a massa (Gnd sulla board Arduino); i pulsanti sono posti tra la massa e i pin digitali 10, 11 e 12. Si vuole realizzare un programma che associ ad ogni pulsante un singolo led in modo tale che se il pulsante viene premuto il rispettivo LED viene acceso.

Il diagramma di flusso del programma da realizzare è il seguente, dove per semplicità le azioni da

compiere sui singoli componenti sono state raggruppate in blocchi:

Sulla board Arduino bisogna caricare il seguente programma:

/* 3 pulsanti disponibili e singolo led associato ad ogni pulsante. Se il pulsante viene premuto il rispettivo led viene acceso */

int Stato1 = 0; //Stato del pulsante 1int Stato2 = 0; //Stato del pulsante 2int Stato3 = 0; //Stato del pulsante 3const int P1 = 10; //Pulsante 1 collegato al PIN 10const int P2 = 11; //Pulsante 2 collegato al PIN 11const int P3 = 12; //Pulsante 3 collegato al PIN 12const int LED1 = 3; //LED 1 collegato al PIN 3const int LED2 = 5; //LED 2 collegato al PIN 5const int LED3 = 6; //LED 3 collegato al PIN 6

void setup() { pinMode(LED1, OUTPUT); //Impostazione PIN come uscita pinMode(LED2, OUTPUT); //Impostazione PIN come uscita pinMode(LED3, OUTPUT); //Impostazione PIN come uscita pinMode(P1, INPUT); //Impostazione PIN come ingresso pinMode(P2, INPUT); //Impostazione PIN come ingresso pinMode(P3, INPUT); //Impostazione PIN come ingresso digitalWrite(P1, HIGH); //Abilitazione pull-up digitalWrite(P2, HIGH); //Abilitazione pull-up digitalWrite(P3, HIGH); //Abilitazione pull-up}

void loop() { //Lettura stato pulsanti Stato1 = digitalRead(P1); Stato2 = digitalRead(P2); Stato3 = digitalRead(P3);

//Accensione e/o spegnimento LED in base allo stato pulsanti if (Stato1 == LOW) { //Accensione LED digitalWrite(LED1, HIGH); } else { //Spegnimento LED digitalWrite(LED1, LOW); } if (Stato2 == LOW) { digitalWrite(LED2, HIGH); } else { digitalWrite(LED2, LOW); } if (Stato3 == LOW) { digitalWrite(LED3, HIGH); } else { digitalWrite(LED3, LOW); } delay(100); //Attesa 100ms}

Di seguito si riporta una breve spiegazione del codice sopra scritto.All'inizio del programma vengono definite tre variabili necessarie per leggere lo stato dei pulsanti e sei costanti usate per definire i pin a cui vengono collegati i tre LED ed i tre pulsanti: lo si capisce dalla parola chiave const in testa alle righe di codice che definiscono i pin.Nel corpo della funzione setup() vengono impostati come uscite i PIN associati ai tre LED e come ingressi i PIN associati ai tre pulsanti. Inoltre per evitare che lo stato del pulsante non premuto rimanga indefinito occorre abilitare la resistenza di pullup interna (una resistenza da 20 Kohm collegata all'alimentazione) mediante l'istruzione digitalWrite(P1, HIGH) ripetuta per i tre pulsanti. Un modo alternativo sarebbe quello di impostare lo stato del pulsante mediante un collegamento esterno alla tensione di alimentazione, ma questo implica la realizzazione di un circuito un po' più complesso.Nel corpo della funzione loop() viene inizialmente letto lo stato dei tre pulsanti mediante le tre istruzioni:

Stato1 = digitalRead(P1);Stato2 = digitalRead(P2);Stato3 = digitalRead(P3);

Successivamente si controlla il valore assunto dalle variabili Stato.Se il primo pulsante viene premuto, lo stato di tale pulsante sarà basso e di conseguenza l'istruzione digitalWrite(LED1, HIGH) accenderà il primo LED, altrimenti il LED verrà spento mediante l'istruzione digitalWrite(LED1, LOW). La stessa cosa succede per gli altri due pulsanti.È possibile accendere un LED alla volta o anche tutti e tre contemporaneamente: si noti che i LED rimangono accesi solamente quando i relativi pulsanti vengono mantenuti premuti.Per simulare un comportamento analogo a quello che si ha per un impianto di illuminazione, cioè accendere una luce quando si preme un pulsante e spegnere la luce quando si preme nuovamente il pulsante, bisogna utilizzare un'ulteriore variabile che tenga conto dello stato del LED. Questo lo si può vedere nel codice della successiva esercitazione.

Esercitazione 2

Consideriamo ora il seguente circuito formato da 1 LED, 2 pulsanti e 1 resistenza da 330 ohm; la resistenza è collegata tra l'anodo del LED e il pin digitale 3; il catodo del LED è collegato a massa; i pulsanti sono posti tra massa ed i pin digitali 10 e 11:

Si vuole realizzare un programma che permetta di accendere o spegnere il LED premendo il pulsante uno e di regolare la luminosità del LED con la pressione del pulsante due.Il diagramma di flusso del programma da realizzare è il seguente:

Sulla board Arduino bisogna caricare il seguente programma:

/* 2 pulsanti disponibili che permettono di agire su un led spegnendo e accendendo (P1) il led oppure regolando la luminosità del led (P2) */

int Stato = 0; //Stato Pulsanteint Val_PWM = 125; //Valore luminosità led per PWM (0-255)int Accendi = 0; //0: Accendi LED - 1: Spegni LEDint Inc_Dec = 1; //0: Decremento luminosità - 1: Incremento luminositàint TEMPO = 20; //Tempo ritardo cambiamento luminosità (max 255)const int P1 = 10; //Pulsante ON/OFFconst int P2 = 11; //Pulsante senso luminosità const int LED1 = 3; //LED

void setup() { pinMode(LED1, OUTPUT); //Impostazione PIN come uscita pinMode(P1, INPUT); //Impostazione PIN come ingresso pinMode(P2, INPUT); //Impostazione PIN come ingresso digitalWrite(P1, HIGH); //Abilitazione pull-up digitalWrite(P2, HIGH); //Abilitazione pull-up}

void loop() { //Lettura stato pulsante 1 (Accensione/Spegnimento) //Accensione/spegnimento LED in base allo stato pulsanti if (digitalRead(P1) == LOW) { if (Accendi == 0) //Se led spento lo accendo { Accendi=1; analogWrite(LED1, Val_PWM); //Imposto luminosità LED } else //Se led acceso lo spengo { Accendi=0; analogWrite(LED1, 0); } }

while (digitalRead(P1) == LOW) { delay(100); //Attesa 100ms } //Lettura stato pulsante 2 (Regolazione senso luminosità) while (digitalRead(P2) == LOW) { if (Val_PWM == 255) { //Cambio senso, da Incremento a Decremento luminosità Inc_Dec=0; } if (Val_PWM == 0) { //Cambio senso, da Decremento a Incremento luminosità Inc_Dec=1; }

if (Inc_Dec == 1) //Incremento luminosità { Val_PWM = Val_PWM + 1; } else //Decremento luminosità { Val_PWM = Val_PWM - 1; } analogWrite(LED1, Val_PWM); //Imposto luminosità LED delay(TEMPO); //Attesa }}

Dando ormai per scontato il significato delle istruzioni che compaiono all'inizio del programma e nel corpo della funzione setup(), analizziamo il codice della funzione loop().Il primo blocco if controlla se è stato premuto il pulsante 1 e a seconda dello stato del LED (acceso o spento) procede allo spegnimento od all'accensione dello stesso con l'opportuna intensità luminosa definita dalla variabile Val_PWM. Si noti che a tal fine non si usa l'istruzione digitalWrite() che gestisce solo gli stati ON/OFF ma l'istruzione analogWrite() che permette di generare un segnale PWM (Pulse Width Modulation – modulazione di larghezza di impulso) ossia un segnale digitale con una tensione media variabile dipendente dal rapporto tra la durata dell'impulso positivo e di quello negativo (duty-cycle):

Il duty-cycle è il rapporto tra la durata del segnale "alto" e il periodo totale del segnale (rappresentato dalle linee verdi in figura), e serve a esprimere per quanta porzione di periodo il segnale è a livello alto. Il risultato del rapporto è sempre un numero compreso tra 0 e 1.Detto in modo meno tecnico vuol dire che facendo lampeggiare un diodo LED ad una frequenza sufficientemente elevata e cambiando il rapporto tra il tempo in cui sta acceso ed il tempo in cui sta spento, il nostro occhio non percepirà il lampeggiare del LED ed inoltre, a seconda del rapporto del tempo di accensione e spegnimento, potremo regolare la luminosità del LED.La frequenza del segnale PWM generato dalla funzione analogWrite() è circa 490 Hz, mentre il valore del PWM varia da 0 a 255 con 8 bit di risoluzione.Procediamo con l'analisi del codice. Il primo ciclo while che si incontra while (digitalRead(P1) == LOW) { delay(100); //Attesa 100ms }

serve ad impedire di accendere o spegnere continuamente il LED quando si mantiene premuto il pulsante 1. Nel successivo ciclo while si gestisce il cambiamento di luminosità del LED quando si tiene premuto il pulsante 2. Poiché, come abbiamo visto, i valori permessi per il PWM vanno da 0 a 255, quando si raggiunge uno dei due valori limite si inverte il senso di variazione della luminosità mediante i primi due blocchi if, mentre il terzo blocco if incrementa o decrementa il valore della variabile Val_PWM che verrà usato dalla successiva istruzione analogWrite() per impostare effettivamente la luminosità del LED.

Esercitazione 3

Nella seguente esercitazione si introduce l'uso del monitor seriale allo scopo di mostrare la possibilità di inviare al PC valori numerici e/o messaggi di possibile debugging del codice.Carichiamo sulla board Arduino lo sketch "AnalogInOutSerial" che si trova in:

File > Esempi > 03.Analog > AnalogInOutSerial

Dal commento iniziale si deduce che questo sketch permette di regolare la luminosità di un LED attraverso un potenziometro:

Per il corretto funzionamento del programma bisogna collegare un potenziometro (un dispositivo elettrico equivalente ad un partitore di tensione resistivo variabile) nel modo descritto: il terminale centrale va collegato al pin 0 analogico, i due terminali laterali vanno a +5V e a massa. Bisogna poi collegare un LED tra il pin digitale 9 e la massa.

Il codice relativo è il seguente: