Corso base su arduino – Prima parte

Che cos’è arduino ?

Si tratta di una piccola scheda con un microcontrollore, ideata ad Ivrea per consentire a designer e
creativi di realizzare prototipi di progetti in breve tempo (prototipazione veloce).

Quali sono i vantaggi nell’uso in ambito didattico ?

Principalmente :

- Economicità
A differenza di altri sistemi di sviluppo, l’ambiente di programmazione è gratuito.
Il costo di una scheda arduino Uno originale è di circa 20 euro, ma esistono cloni che si possono
acquistare per una decina di euro (Amazon) o anche meno (ebay, Ali express, ecc…).
Sempre su Amazon, si possono acquistare 5 schede arduino Nano per 15 euro.

- Multi piattaforma
L’ambiente di sviluppo (IDE=Integrated Development Environment) può essere installato su PC
dotati di sistemi operativi Windows, Mac OS, Linux, senza grandi differenze prestazionali.

- Sistema aperto
Oltre a tutti i sorgenti della IDE e delle librerie, sono liberamente disponibili gli schemi elettrici e il
disegno dei circuiti stampati di tutte le schede arduino.

- Enorme quantità di software e documentazione disponibili

In rete si trovano librerie che consentono di interfacciare dispositivi di tutti i tipi, dai sensori ai
display, agli attuatori, ecc…, esempi, tutorial ed un ottimo forum dove persone tecnicamente
preparate sono disponibili a fornire aiuto in caso di difficoltà.

- Semplicità d’uso e rapidità di apprendimento

Per programmarla è sufficiente collegarla tramite un cavo USB al PC e trasferire il codice oggetto
tramite l’IDE. Le istruzioni sono semplici, si basano sul linguaggio C/C++ ampliato con funzioni
che ne semplificano la programmazione (non è necessario conoscere la struttura interna del
microcontrollore e il nome dei singoli registri interni).

E gli svantaggi ?

- Mancanza di un sistema di debugging “maturo” e completo

Non è possibile l’esecuzione in single step del programma. Non si può esaminare il contenuto delle
variabili. L’unico strumento disponibile è la stampa dei valori su un terminale di testo inserito nella
IDE.

- Difficoltà di comprendere l’interazione fra le diverse librerie

Ciò può portare a risultati inattesi e difficilmente comprensibili dall’utente normale. Esempio:
voglio usare una libreria che riceve i codici di un telecomando ad infrarossi per comandare dei
piccoli motori in continua. Le due funzionalità (infrarossi e motori) utilizzano i timer interni del
microcontrollore e possono generare conflitti, ma non ce ne accorgiamo a meno che non andiamo
ad analizzare il codice stesso delle librerie (di difficile comprensione).

1 Antonio Visentini 2017

- Difficoltà nella transizione dalla programmazione con la IDE alla programmazione “vera”, che
utilizza i registri interni e le caratteristiche hardware del microcontrollore.
L’ambiente di arduino è ottimo per introdurre la programmazione dei microcontrollori agli studenti,
ma il passo successivo dovrebbe riguardare lo studio dettagliato dello hardware dei microc. della
famiglia AVR e la loro programmazione con la IDE ufficiale AVR Studio.
Le difficoltà aumentano notevolmente perché si passa ad un tipo di programmazione che coinvolge
i registri delle periferiche interne del microcontrollore (porte, ADC, Timer, seriale, i2c, SPI,
interrupt, risparmio energetico, ecc...), un po’ come si fa con i micro della famiglia PIC e gli
studenti, abituati alla programmazione semplice di arduino, sono MOLTO restii a compiere questo
salto. Del resto, ammettiamolo, è difficile anche per i docenti imparare a gestire una nuova famiglia
di microcontrollori, andarsi a studiare un datasheet di 660 pagine e sperimentare. Senza contare il
fatto che viene meno la possibilità di usare le comode librerie che ci permettevano di interfacciare
miriadi di dispositivi.

Cito la mia personale esperienza didattica.

Classe terza di informatica e telecomunicazioni, articolazione telecomunicazioni, materia Tecnologie e
progettazione di sistemi informatici e di telecomunicazioni, 28 alunni, 3 ore settimanali di insegnamento di
cui una di laboratorio. Dal secondo quadrimestre, dopo che gli studenti avevano imparato i rudimenti di
elettronica e di programmazione in C nelle altre discipline, ho introdotto arduino e alla fine dell’anno quasi
tutti erano in grado di utilizzarlo per applicazioni semplici.
La stessa classe, l’anno successivo, 20 allievi (alcuni non erano stati ammessi, altri avevano cambiato
indirizzo). Affronto lo studio dettagliato dei micro AVR, introduco la programmazione vera in C, per gradi,
partendo dall’accensione di un LED. In tutto l’anno scolastico sono riuscito ad affrontare pochi argomenti,
rispiegati più volte, e solo 5 studenti sono riusciti a raggiungere un livello di competenze più che sufficienti.
Gli altri hanno imparato a memoria, solo per poter superare le verifiche. Più e più volte gli studenti mi
chiedevano: “Quando torniamo a programmare con arduino ?”

Le schede arduino

Ci sono molti tipi di schede arduino in commercio, alcune originali prodotte in Italia, altre
legalmente prodotte altrove (Cina, USA).
Riporto solo quelle più diffuse.

La più utilizzata e copiata è senza dubbio arduino Uno, dotata di microcontrollore ATMega 328 con
32KB di memoria flash (per contenere i programmi), 2KB di RAM (per le variabili), 1KB di
EEPROM (per i dati che devono essere mantenuti anche in assenza di alimentazione), frequenza di
clock 16 Mhz (1 istruzione in linguaggio macchina ogni 62,5 ns), ADC a 10 bit con 6 canali,
contenitore 28 piedini dual in line e svariate periferiche.
La scheda dispone di 14 piedini di ingresso – uscita digitali, 6 ingressi analogici che all’occorrenza
possono essere utilizzati come ingressi – uscite digitali, interfaccia USB per l’alimentazione ed il
trasferimento dei programmi, connettore per alimentazione esterna da 7 a circa 12 V.
Inoltre sono presenti un pulsante di reset, 4 LED che segnalano: presenza di alimentazione (ON),
traffico dati sulla porta seriale (TX e RX) ed un LED (L) collegato al piedino 13. I piedini 0 e 1
sono anche ingresso e uscita della porta seriale e non sono utilizzabili durante il trasferimento dei
programmi. I piedini contrassegnati con ~ sono utilizzabili come uscite in PWM, come descritto più
avanti. Sui piedini POWER sono disponibili le tensioni di 5V (max 200 mA) e 3,3V (max 50 mA),
che si possono usare per alimentare dispositivi esterni. Il “Francobollo” nero vicino alla porta USB
è un altro microcontrollore (ATMega 16U2) che si incarica della conversione da USB a seriale e
viene utilizzato per il trasferimento dei programmi. Tutti i piedini digitali lavorano a livelli logici
TTL (0 e 5V), mentre gli ingressi analogici accettano tensioni da 0 a 5V che convertono in un

2 Antonio Visentini 2017

valore da 0 a 1023 (10 bit). Mai alimentare la scheda contemporaneamente da USB e dal connettore
esterno, pena la distruzione della stessa.

Qui di seguito viene riportato uno schema che evidenzia le funzioni assegnate ai vari piedini.

In giallo sono evidenziati i bit delle porte del microcontrollore.

3 Antonio Visentini 2017

La corrente massima erogabile, sia a livello alto che a livello basso, da ciascun piedino digitale è di
40 mA (è consigliabile non superare 20 mA), ma in totale non si devono superare i 200 mA.

Talvolta il numero di piedini risulta insufficiente per le applicazioni più complesse; in tal caso è
disponibile la scheda arduino Mega 2560. L’inconveniente è che il microcontrollore ha un
contenitore SMD, se si brucia non conviene sostituirlo ma buttare la scheda. I cloni cinesi sono
venduti a 13 – 15 euro (Amazon).

Vi sono ben 54 ingressi – uscite digitali, 16 ingressi analogici e 4 porte seriali. La memoria flash è
di 256KB e aumenta anche la RAM (8KB) e la EEPROM (4KB).

Per applicazioni che richiedono spazi ridotti, una valida alternativa è costituita dalla scheda arduino
Nano. Il processore è sempre un ATMega 328, ma in versione SMD ed i segnali disponibili sono
praticamente gli stessi di arduino Uno. Fanno eccezione gli ingressi analogici che salgono a 8.
Il connettore USB è dipo MINI-USB, meno diffuso rispetto al MICRO-USB. I cloni di arduino
Nano si possono reperire su Amazon (5 schede a 15 euro), ebay, Ali express, ecc...

Sul lato inferiore della scheda si trova l’integrato preposto alla comunicazione con il PC. Nelle
schede originali è un FT232, in quelle cinesi è un CH340 o CH341 e richiede, sui sistemi operativi
Windows, un driver particolare reperibile in rete. Il sistema operativo linux riconosce la scheda
senza la necessità di scaricare alcunchè.

4 Antonio Visentini 2017

Sempre per esigenze progettuali con spazi ridotti, una valida alternativa è costituita dalla scheda
arduino Micro Pro, dotata di processore ATMega 32U4. La particolarità di questa scheda è che il
processore è già dotato di interfaccia USB nativa ed il connettore , questa volta, è MICRO-USB.

Da notare che gli ingressi – uscite digitali sono numerati in modo diverso, la porta seriale non viene
più utilizzata per comunicare con il PC e dispone di soli 4 ingressi analogici (ma altri sono
disponibili in condivisione con i piedini digitali).

Il successore di arduino Uno è arduino Leonardo, riportato nella figura seguente:

5 Antonio Visentini 2017

Anche in questo caso il microcontrollore è un ATMega 32U4, ma il formato della scheda è uguale a
quello di arduino Uno. Non è comunque riuscita a scalzare il successo di arduino Uno.

In commercio esistono molte altre schede arduino, alcune dotate di connessione WiFi, con
processori ARM a 32 bit, inseribili nei capi di vestiario, ecc…, ma quelle elencate sono, a mio
avviso, le più interessanti per applicazioni didattiche.

L’ambiente di sviluppo (IDE)

L’ambiente di sviluppo (d’ora in poi denominato IDE) è scritto in Java e pertanto, multi piattaforma.
La programmazione avviene tramite linguaggio C/C++ ampliato con funzioni specificatamente
scritte per le schede arduino. Non sono utilizzabili le comuni istruzioni di input – output su
terminale (printf, scanf, cin, cout), com’è ovvio quando si lavora con i microcontrollori.
Vediamo ora quali sono i comandi principali della IDE, riferendoci alla figura che segue.

Icone in alto a sinistra (sotto i menù):

la prima effettua la verifica della sintassi del programma, in pratica, la compilazione. Eventuali
errori vengono riportati nell’area nera presente sul lato inferiore della finestra (area di stato).
La seconda icona (con la freccia verso destra) serve per trasferire il codice compilato alla scheda
arduino. Nel caso in cui il programma fosse stato modificato, prima di trasferire il codice oggetto
effettua la compilazione. Prima di premere questo pulsante è importante effettuare alcune
operazioni: controllare di avere collegato una scheda arduino tramite cavo USB al PC, andare sul

6 Antonio Visentini 2017

menù Strumenti → Scheda e verificare di avere selezionato la scheda arduino corretta, sempre dal
menù Strumenti → Porta, verificare di avere scelto la porta corretta (in Windows è una porta COMx
con x diverso da 1). Il tipo di scheda e la porta sono riportate anche nell’angolo inferiore destro
della finestra.
La terza icona serve per creare un nuovo file sorgente in C/C++. I programmi vengono denominati
sketch (schizzo) e l’estensione dei file sorgenti è .ino.
La quarta icona (freccia rivolta verso l’alto) serve per aprire un file sorgente già presente nel PC.
La quinta icona(freccia rivolta verso il basso) serve per salvare il file sorgente.
L’icona con la lente sul lato superiore destro apre la finestra del terminale, denominato “serial
monitor”, che comunica con la porta seriale del microcontrollore (vedremo in seguito la sua utilità).
Effettuato il trasferimento del programma compilato alla scheda arduino, in caso di successo,
sull’area di stato vengono riportate informazioni relative alla quantità di memoria occupata e
disponibile nel microcontrollore.

La IDE comprende una serie di programmi esemplificativi e di librerie di base, accessibili dal menù
File→Esempi; ulteriori librerie possono essere scaricate dal menù Sketch→#include libreria →
Gestione librerie (è necessario essere connessi a internet).
Ogni libreria, a sua volta, contiene una serie di esempi di utilizzo che possono essere modificati e
inclusi nei nostri programmi.
Qualora si volesse utilizzare una libreria scaricata da internet e che non viene elencata tramite
Gestione librerie, è possibile utilizzare la voce del menù Sketch→#include libreria → aggiungi
libreria da file zip (ovviamente dovrà essere un file compresso .zip).

La IDE comprende molte altre funzionalità, come la numerazione delle righe, ecc… ma per iniziare
possono bastare le precedenti informazioni.
I microcontrollori delle schede arduino contengono un piccolo programma, il “Bootloader”, situato in
un’area protetta della memoria flash. Tale segmento di codice si occupa della comunicazione tra scheda e PC
e, nell’arduino Uno occupa 512 Byte.

Struttura di un programma per arduino

Ogni programma per arduino deve contenere obbligatoriamente almeno due funzioni: setup() e
loop().
La funzione setup() non ritorna alcun valore (void) e viene eseguita una sola volta, in genere
all’inizio del programma. In questa funzione si inseriscono le istruzioni di inizializzazione, ad
esempio se un dato piedino deve essere d’ingresso o d’uscita.
Anche la funzione loop() non ritorna alcun valore (void) ma le istruzioni al suo interno vengono
eseguite ciclicamente come se fossero all’interno di un ciclo infinito for(; ;) o while (1).
Ciò rispecchia il modo tipico di programmare i microcontrollori: dopo una fase di inizializzazione si
passa ad un ciclo infinito che viene interrotto solo dall’assenza di alimentazione.
Nota per i più smaliziati: sì, arduino gestisce anche gli interrupt (attenti alle variabili dichiarate volatile).
Riassumendo, la tipica struttura di un programma per arduino può essere la seguente:

- commento che spiega cosa fa il programma, quando è stato scritto, come lo fa, chi ne è l’autore
- eventuale inclusione di librerie esterne
- dichiarazione / inizializzazione delle costanti
- prototipi delle eventuali proprie funzioni
- dichiarazione / inizializzazione delle variabili globali
- void setup() {
- istruzioni di inizializzazione (porte di ingresso / uscita, ecc…)
-}

7 Antonio Visentini 2017

- void loop() {
- istruzioni da eseguire ciclicamente
-}
- definizione delle eventuali proprie funzioni

Tipi di dati

Arduino riconosce quasi tutti i tipi di dati del linguaggio C, ma ne aggiunge alcuni e altri li tratta in
maniera particolare. Teniamo presente che stiamo lavorando con un microcontrollore a 8 bit che ha
una quantità di memoria (in particolare, RAM) esigua se paragonata ad un PC.
E’ opportuno fare allora una raccomandazione: usiamo le grandezze in virgola mobile (float) solo se
indispensabili; infatti, la gestione dei float richiede una libreria, caricata automaticamente, che
occupa qualche kilobyte di memoria flash e rallenta notevolmente l’esecuzione del programma
(millisecondi, invece di microsecondi).
E’ chiaro tuttavia, che se ho bisogno di visualizzare la temperatura rilevata da un sensore con una
risoluzione di un decimo di grado centigrado, non posso esimermi dall’utilizzare i float, a meno di
contorsioni logiche che riducono la leggibilità del mio programma.
Arduino riconosce, tra gli altri, i seguenti tipi di dati:

boolean 1 byte true / false es: boolean sceriffo = false;

char 1 byte (da -128 a + 127) es: char c1=’A’; char c2= 65; // A
byte 1 byte (da 0 a 255) equivale a unsigned char
int 2 byte (da -32768 a 32767)
unsigned int 2 byte (da 0 a 65535)
long 4 byte (da -2,1 miliardi a +2,1 miliardi, circa)
unsigned long 4 byte (da 0 a circa 4,2 miliardi)
float 4 byte (da ±3,4x10-38 a ±3,4x1038)
double esattamente come float, occupa 4 byte ed ha lo stesso campo di valori, in pratica non
viene riconosciuto come double

i vettori usano la stessa sintassi del C.

Oltre alle normali stringhe del C (vettori di caratteri terminanti con \0), arduino ha un proprio tipo
denominato String con tutta una serie di funzioni che ne facilitano il trattamento (concatenazione,
lunghezza, ricerca di una sotto stringa, ecc…) ma ritengo sia un argomento avanzato che non
tratterò in questa sede.
Per gli esperti: String è una classe C++ contenente diversi metodi, oltre al costruttore.

Una nota particolare riguarda i sistemi di numerazione riconosciuti da arduino. Oltre al sistema
decimale, viene accettato quello esadecimale del C (esempio: 0x12f4) ed anche quello binario.
Una costante binaria deve essere preceduta dalla lettera B (es: int binario_triste = B0111001;).

Il primo programma per arduino

Normalmente, il primo programma che si scrive in un nuovo linguaggio di programmazione è il

classico “hello world!”, che visualizza tale stringa su un terminale.
Invece, chi usa i micro, sa che il primo programma fa lampeggiare un LED, non disponendo spesso
di un terminale e delle funzioni per gestirlo.
Tra l’altro, viene anche usato per vedere se una scheda è bruciata o ancora integra (almeno in parte).

8 Antonio Visentini 2017

Ecco allora il primo programma che si propone di far lampeggiare il LED L (che ha già in serie la
resistenza di limitazione) presente sulla scheda arduino Uno con un periodo di 2 secondi (1 secondo
acceso e 1 secondo spento):

/* Fa lampeggiare il LED L con periodo di 2 secondi.

Il LED è collegato al piedino 13 di arduino Uno.
*/

#define LED 13 // definizione della costante LED

void setup() { //viene eseguita una sola volta all’inizio

pinMode(LED, OUTPUT); // definisco il piedino 13 come uscita
// digitale
}

void loop(){ //Per sempre finché non stacchi la corrente

digitalWrite(LED, HIGH); // Manda un livello alto (5V) al LED
delay(1000); // attendi 1000 millisecondi
digitalWrite(LED, LOW); // Manda un livello basso (0V) al LED
delay(1000); // attendi 1000 millisecondi
}

Si noti la presenza di 3 funzioni particolari predefinite: pinMode, digitalWrite, delay.

La funzione pinMode necessita di due parametri: il primo identifica il numero del piedino della
scheda a cui si riferisce (può essere una costante o una variabile) , il secondo è una costante
predefinita che può essere solo INPUT o OUTPUT e stabilisce se quel piedino deve essere
d’ingresso o d’uscita. Bisogna sempre definire se i piedini che si vogliono usare devono essere
ingressi o uscite.
Nota: in realtà, all’accensione tutti i piedini digitali sono predefiniti come ingressi.
La funzione digitalWrite manda una tensione a livello alto (5V) o basso (0V) al piedino specificato
come uscita. Anch’essa prevede due parametri: il primo identifica il numero del piedino della
scheda a cui si riferisce (può essere una costante o una variabile) , il secondo è una costante
predefinita che può essere solo HIGH (alto) o LOW (basso).
La funzione delay genera un ritardo specificato in millisecondi (costante o variabile). Il micro
rimane in attesa per il numero di millisecondi indicato.

Inserito il programma, bisogna verificarne la sintassi (icona col segno di spunta) e trasferirlo (icona
con freccia verso destra) alla scheda precedentemente collegata al PC mediante cavo USB.
Godersi lo spettacolo e manifestare ampia soddisfazione.

Nel secondo esempio, buono per le prossime feste natalizie, vengono collegati 9 LED con le
relative resistenze in serie (330 o 390 o 470 ohm) ai piedini indicati nel programma seguente (dal 5
al 13). I catodi dei LED vanno collegati alla massa (terminale GND) di arduino, gli anodi, ciascuno
in serie con la propria resistenza, ai piedini di arduino.

9 Antonio Visentini 2017

int led[9]={5,6,7,8,9,10,11,12,13};

void setup() {
for (int i = 0; i < 9; i++)
pinMode(led[i], OUTPUT);
}

void loop() {
for (int i = 0; i < 9; i++) {
digitalWrite(led[i], HIGH);
delay(100);
digitalWrite(led[i], LOW);
delay(100);
}
for (int i = 0; i < 7; i++) {
digitalWrite(led[7-i], HIGH);
delay(100);
digitalWrite(led[7-i], LOW);
delay(100);
}
for (int i = 0; i < 9; i++) {
digitalWrite(led[i], HIGH);

10 Antonio Visentini 2017

 delay(100);
}
for (int i = 0; i < 9; i++) {
digitalWrite(led[i], LOW);
delay(100);
}
for (int i = 0; i < 9; i++) {
digitalWrite(led[8-i], HIGH);
delay(100);
}
for (int i = 0; i < 9; i++) {
digitalWrite(led[8-i], LOW);
delay(100);
}
for (int i = 0; i < 5; i++) {
digitalWrite(led[i], HIGH);
digitalWrite(led[8-i], HIGH);
delay(100);
digitalWrite(led[i], LOW);
digitalWrite(led[8-i], LOW);
delay(100);
}
for (int i = 0; i < 5; i++) {
digitalWrite(led[i+4], HIGH);
digitalWrite(led[4-i], HIGH);
delay(100);
digitalWrite(led[i+4], LOW);
digitalWrite(led[4-i], LOW);
delay(100);
}
}

Sempre per i più esigenti: come faccio a comandare più uscite con una sola istruzione ?
Usando le vere istruzioni del micro in C, che si possono inserire anche nella IDE di arduino.
Lo ATMega328 dispone di 3 porte: la porta B (6 bit), la porta C (7 bit, ma il 7° è il reset, lasciatelo stare per carità) e la
porta D (8 bit, i bit 0 e 1 sono associati alla seriale). Ciascuna porta ha due registri: un registro di direzione DDRx
(x=B,C,D) e un registro dati PORTx (x=B,C,D).
Per porre un bit di una porta in ingresso bisogna settare a 0 il bit corrispondente nel registro DDR. Per porre un bit di
una porta in uscita bisogna settare a 1 il bit corrispondente nel registro DDR.Esempio: con l’istruzione
DDRB = B111111; imposto i 6 bit come uscite; poi con l’istruzione PORTB = B010101; mando in uscita sui 6 bit la
configurazione 010101. Posso usare gli operatori sui bit (&, |, ^, ~, >>, <<) per manipolare uno o più bit alla volta (ad
esempio, per mascherarne alcuni).
Perchè non c’è la porta A ? Per compatibilità con il resto della famiglia dei microcontrollori AVR ATMega.

Gli esempi svolti in classe e le esperienze di laboratorio proposte agli studenti

Dopo aver illustrato hardware e software di arduino Uno e dopo aver visto come inserire, compilare
e provare il programma che fa lampeggiare un LED, solitamente propongo agli studenti di
realizzare in laboratorio un gioco di luci, come quello trattato in precedenza. Questo serve per
familiarizzarsi con le uscite digitali e ripassare un po’ di linguaggio C (cicli, vettori e funzioni).
Poi, in classe, spiego come funzionano i display a 7 segmenti (anodo e catodo comune) e propongo
di realizzare un programma che visualizza il conteggio da 0 a 9, ciclicamente. Le soluzioni degli
studenti prevedono un numero enorme di digitalWrite per accendere e spegnere i segmenti del

11 Antonio Visentini 2017

display allo scopo di visualizzare le diverse cifre. Allora mostro una possibile soluzione più
elegante e la spiego nei dettagli.

/* Contatore ciclico da 0 a 9 su display a 7 segmenti a catodo comune. I

segmenti sono collegati come segue: a al pin 2 di arduino, b al pin 3, c
al pin 4, d al pin 5, e al pin 6, f al pin 7, g al pin 8, catodo a gnd.
Inserire in serie a ciascun segmento un resistore da 330 o 470 ohm.
*/

void disp_7seg(byte valore); //prototipo della funzione che visualizza

//una cifra (valore) sul display
byte segmento[]={2,3,4,5,6,7,8}; //a=pin2, b=pin3, c=pin4, . . .
byte numero[]={B0111111,B0000110,B1011011,B1001111,B1100110,B1101101,
B1111101,B0000111,B1111111,B1101111}; //vettore contenente le
//cifre da 0 a 9.Per ciascuna cifra: 1 = segmento acceso,
//0=segmento spento. Bit meno significativo=segmento a.
//Esempio: B0111111 rappresenta la cifra 0
void setup(){
for (int i=0;i<7;i++)
pinMode(segmento[i], OUTPUT); //pin dal 2 all’8 come uscite
}
void loop(){
for (int i=0;i<10;i++){ //per tutte le cifre da 0 a 9
disp_7seg(i); //visualizza la cifra sul display
delay(1000); //attendi un secondo
}
}

void disp_7seg(int valore) {

byte temp; //variabile temporanea locale
temp=numero[valore]; // in temp la sequenza binaria della cifra
for (int j=0;j<7;j++) { //per tutti i segmenti della sequenza bin
if ((temp & 1) == 1) //se il bit meno significativo è 1
digitalWrite(segmento[j],HIGH); //accendi segmento
else
digitalWrite(segmento[j],LOW); //spegni segmento
temp = temp >> 1; //shift a destra di una posizione
}
}

La funzione disp_7seg risulta di difficile comprensione ma permette di ridurre di molto il numero di

istruzioni.

In laboratorio, chiedo ai ragazzi di modificare il programma in modo da visualizzare il conteggio

all’indietro e poi, di realizzare un programma che simuli il funzionamento di un singolo semaforo
dotato di contatore dei secondi rimanenti. Il semaforo dovrà partire, ad esempio, dalla luce rossa e
sul display dovrà iniziare il conteggio da 9 a 0 (10 secondi in totale); poi dovrà accendersi il verde e
conteggiare altri 10 secondi, quindi il giallo per 5 secondi, poi nuovamente il rosso per 10 secondi.
Il tutto dovrà ripetersi ciclicamente.

12 Antonio Visentini 2017

Materiale extra – Arduino su breadboard o standalone

Abbiamo visto come arduino rappresenti una valida piattaforma per la prototipazione veloce; ma
una volta testato il prototipo, come si fa a realizzare il circuito finale ?
In effetti, una volta programmato il microcontrollore, la porta USB non ci serve più e con essa
anche il micro che si occupa della conversione seriale TTL – USB.
In commercio esistono degli ATMega-328P-PU già programmati con il bootloader (costo: circa 5
euro); è sufficiente uno di questi, un quarzo da 16 Mhz, un paio di condensatori da 22 pF e una
resistenza da 10 K per realizzare un arduino su breadboard.
Basterà allora, programmare il microcontrollore inserendolo nello zoccolo di una scheda arduino
Uno, toglierlo e spostarlo nel progetto finale.
Con qualche complicazione in più si può anche evitare lo scambio di integrati e programmare
direttamente il microcontrollore target attraverso il bus SPI usando come programmatore una
scheda arduino Uno. In rete si trovano tutorial che spiegano come fare.

Ma dal punto di vista economico, ha senso una tale operazione quando si possono acquistare 5
arduino Nano per 15 euro, perciò con un costo unitario di 3 euro ?
Direi di no.

Volendo comunque intraprendere questa strada, occorre tenere presente la corrispondenza tra la
piedinatura delle schede arduino e quella del microcontrollore ATMega-328P-PU che riporto nella
figura seguente.

13 Antonio Visentini 2017

Il circuito per utilizzare il micro su breadboard o su circuito stampato è il seguente:

Il pulsante per il reset è facoltativo, così come il condensatore elettrolitico da 10 µF

sull’alimentazione, ma conviene metterlo per minimizzare i disturbi.

Sitografia

www.arduino.cc Il sito del progetto arduino, in inglese, contiene una moltitudine di tutorial,
progetti, il riferimento per il linguaggio di programmazione, esempi di interfacciamento con i più
disparati tipi di trasduttori, ecc…

forum.arduino.cc Il forum ufficiale di arduino; la parte più corposa è in lingua inglese, ma

esistono sezioni in molte altre lingue, compreso l’italiano.

www.arduino.cc/en/Main/Software sito dove si effettua il download della IDE per i diversi sistemi
operativi.

14 Antonio Visentini 2017

fritzing.org/home/ Permette di scaricare un utile ed intuitivo programma gratuito (Fritzing) con
cui disegnare gli schemi di cablaggio, come quello riportato a pag.10. Per i componenti mancanti,
cercare nel forum apposito di Fritzing http://forum.fritzing.org/c/parts-submit oppure con Google,
digitandone il nome in inglese.

http://www.maffucci.it/area-studenti/arduino/ In italiano, contiene una serie di articoli, un corso in

forma di slide su arduino indirizzato ai docenti (anche a digiuno di elettronica e di programmazione
in C) e molta bibliografia.

www.mauroalfieri.it In italiano, sito di un collega che contiene corsi online a diversi livelli di
difficoltà e moltissime informazioni e progetti utili.

http://www.atmel.com/products/microcontrollers/avr/megaAVR.aspx Il sito del produttore dei

microcontrollori utilizzati nelle schede arduino. Per chi vuole approfondire la programmazione con
l’ambiente di sviluppo ufficiale (Atmel Studio).

www.instructables.com/ Qui si trovano molti progetti realizzati dagli utenti della rete, spiegati in
modo semplice, passo dopo passo.

Poi, su YouTube, si trovano moltissimi video tutorial, anche in italiano, ma fate attenzione perché ci
sono anche esempi errati.

15 Antonio Visentini 2017