Questa settima lezione nasce dalla richiesta di alcuni miei studenti che hanno chiesto chiarimenti in merito all’uso degli array, della chiamata di funzioni esterne al loop e del controllo di flusso.

Per la realizzazione della lezione verrà usato un semplice circuito costituito da pulsanti, resistenze e led.

Fate attenzione che sui pulsanti non utilizzano una resistenza esterna di pull-up, perché abiliteremo la resistenza di pull-up interna di Arduino.

Nel montaggio noterete che ho impiegato un supporto costituito da due breadboard che ho costruito per rendere più agevole la realizzazione di esperienze con Arduino. Ovviamente potrete realizzare il tutto con una singola breadboard.

Lista componenti

• Scheda Arduino (nel mio caso Arduino UNO Rev3);
• 4 LED;
• 4 resistenza da 220 Ohm;
• 4 pulsanti normalmente aperti.

Schema topografico

Risultato del montaggio

Per completezza ripeto quanto detto in “Appunti di programmazione su Arduino: tipi di dati” che trovate su questo sito, chiarendo con un disegno:

Un array è un insieme di valori a cui si accede con un indice.
Un valore nell’array può essere richiamato con il nome dell’array e l’indice numerico che corrisponde al numero d’ordine del valore nell’array.
Gli array vengono indicizzati partendo dal numero zero e quindi il primo valore dell’array avrà indice 0.
Un array deve essere dichiarato ed opzionalmente si possono assegnare i valori prima di utilizzarlo.

Quindi l’array è una collezione organizzata di oggetti dello stesso tipo (campo di esistenza).
Il numero degli elementi contenuti nell’array viene detto dimensione dell’array.

Dire che la collezione di oggetti è organizzata vuol dire che si potrà identificare in modo univoco gli elementi dell’array.

L’identificazione di un elemento dell’array viene fatta mediante un indice.
In un array di dimensione N il valore dell’indice andrà da 0 a N-1.

Citando ancora quanto già spiegato:

int myArray[] = { value0, value1, value2...}

Allo stesso modo è possibile dichiarare un array dichiarandone il tipo e la dimensione e poi assegnare i valori:

int myArray[5];
// dichiara un array di interi avente una dimensione di 5

myArray[3] = 10;
// assegna in quarta posizione il valore 10

Per recuperare un valore all’interno di un array, bisogna dichiarare una variabile a cui poi viene assegnato il valore assunto allo specifivo indice:

x = myArray[3]; // ora x ha il valore 10

Prendiamo ora in considerazione il seguente sketch:

Questo il risultato:

Analizziamo il codice facendo riferimento allo schema che trovate di seguito:

definisce un array di interi di dimensione 4 che contiene i valori: 2,3,4,5

I 4 elementi sono:

pinPulsanti[0] coincide con il valore intero 2
pinPulsanti[1] coincide con il valore intero 3
pinPulsanti[2] coincide con il valore intero 4
pinPulsanti[3] coincide con il valore intero 5

Analogamente possiamo dire che:

è un array di dimensione 4 è contiene i valori 10, 11, 12, 13

pinLed[0] coincide con il valore intero 10
pinLed[1] coincide con il valore intero 11
pinLed[2] coincide con il valore intero 12
pinLed[3] coincide con il valore intero 13

La parte di codice contenuta nel setup:

consente di inizializzare come OUTPUT i pin digitali: 10, 11, 12, 13 e come INPUT i pin digitali: 2, 3, 4, 5 inoltre sui pin: 2, 3, 4, 5 viene abilitata la resistenza di pull-up.

Il for ciclerà fino a quando “indice” è minore di 4, quindi per i valori di “indice” pari a: 0, 1, 2, 3 cioè:

indice = 0

pinMode(pinLed[0], OUTPUT);
pinMode(pinPulsanti[0], INPUT);
DigitalWrite(pinPulsanti[0],HIGH);

andando a sostituire i valori contenuti nell’array avremo:

pinMode(10, OUTPUT);
pinMode(2, INPUT);
digitalWrite(2,HIGH);

cioè:

pin digitale 10 dichiarato come OUTPUT
pin digitale 2 dichiarato come INPUT
abilitazione della resistenza di pull-up sul pin 2

indice = 1

pinMode(pinLed[1], OUTPUT);
pinMode(pinPulsanti[1], INPUT);
DigitalWrite(pinPulsanti[1],HIGH);

andando a sostituire i valori contenuti nell’array avremo:

pinMode(11, OUTPUT);
pinMode(3, INPUT);
digitalWrite(3,HIGH);

cioè:

pin digitale 11 dichiarato come OUTPUT
pin digitale 3 dichiarato come INPUT
abilitazione della resistenza di pull-up sul pin 3

indice = 2

pinMode(pinLed[2], OUTPUT);
pinMode(pinPulsanti[2], INPUT);
DigitalWrite(pinPulsanti[2],HIGH);

andando a sostituire i valori contenuti nell’array avremo:

pinMode(12, OUTPUT);
pinMode(4, INPUT);
digitalWrite(4,HIGH);

cioè:

pin digitale 12 dichiarato come OUTPUT
pin digitale 4 dichiarato come INPUT
abilitazione della resistenza di pull-up sul pin 4

indice = 3

pinMode(pinLed[3], OUTPUT);
pinMode(pinPulsanti[3], INPUT);
DigitalWrite(pinPulsanti[3],HIGH);

andando a sostituire i valori contenuti nell’array avremo:

pinMode(13, OUTPUT);
pinMode(5, INPUT);
digitalWrite(5,HIGH);

cioè:

pin digitale 13 dichiarato come OUTPUT
pin digitale 5 dichiarato come INPUT
abilitazione della resistenza di pull-up sul pin 5

Nella successiva parte di codice:

Anche in questo caso utilizziamo un ciclo for, però questa volta per verificare quale dei quattro pulsanti è premuto.

indice = 0

“stato” (dichiarata come variabile intera) assumerà il valore HIGH o LOW a seconda che il pulsante a cui si fa riferimento nell’array con indice = 0, è premuto oppure no.

int stato = digitalRead(pinPulsanti[0]);

detto in altro modo:

int stato = digitalRead(2);

con digitalRead(2) leggiamo lo stato sul pin 2

Se stato == LOW
vuol dire che il pin corrispondente si trova a a GND cioè il pulsante è stato premuto, ma se il pulsante viene premuto il LED corrispondente dovrà accendersi infatti il corpo dell’if è:

digitalWrite(pinLed[indice], HIGH);

supponendo che sia stato premuto il primo pulsante avremo:

digitalWrite(pinLed[0], HIGH);

detto in altro modo:

digitalWrite(10, HIGH);

e quindi si accenderà il led connesso al pin digitale 10

Nel caso in cui il pulsante connesso al pin 2 non sia premuto, vuol dire che stato == HIGH (ricordate che i pin digitali 2, 3, 4, 5 sono stati impostati ad HIGH) e quindi viene eseguito l’else:

digitalWrite(pinLed[indice], LOW);

poiché indice = 0 avremo:

digitalWrite(pinLed[0], LOW);

che detta in altro modo sarà:

digitalWrite(10, LOW);

ovvero spegniamo il LED connesso al pin digitale 0.

Si procede in modo analogo per i valori successivi di indice.

Eseguiamo alcuni miglioramenti allo sketch precedente introducendo il comando const:

Il comando const viene utilizzato per definire delle costanti, cioè dei nomi assegnati in modo fisso a dei valori.
Possono essere assimiliati a delle macro, con la differenza che non accettano funzioni come valore.

Un modo alternativo all’uso del const è l’uso della direttiva #define.

Nello sketch precedente la variabile indice assume valori che vanno da 0 a 3. Potrebbe accadere che per errore si tenti di accedere accidentalmente a valori che si trovano oltre la dimensione dell’array, in questo caso il copilatore non vi darà nessun errore, per evitare l’accesso a valori che vanno al di fuori dell’array si utilizza il comando const. Così facendo se per errore richiediamo la lettura di un elemento con indice maggiore alla dimensione massima dell’array, il compilatore restituirà errore.

Analizziamo il codice:

definisce una variabile intera di nome INDICE_PIN che assume il valore 4

definisce un array di interi di dimensione 4

definisce un array di interi di dimensione 4

Chiamata ad una funzione esterna

Aggiungiamo una piccola funzionalità allo sketch precedente, alla pressione del pulsante 1 si vuole far lampeggiare il led 1, alla pressione del pulsante 2 si vuole far lampeggiare il led 2 e allo stesso modo per gli altri, per far ciò utilizzeremo una funzione esterna di nome blink1 che si occuperà di far lampeggiare il LED.

Le funzioni vengono utilizzate per suddividere in blocchi le azioni che il nostro sketch deve eseguire. Le funzioni raccolgono le azioni di input e output.
L’uso delle funzioni favorisce la strutturazione del programma per meglio comprendere il codice e favorire modifiche future.

Questo lo sketch:

Come potete constatare alla pressione del pulsante, cioè quando “stato” assume il valore LOW, viene eseguito il blink del led corrispondente.

Utilizziamo ora una funzione esterna per poter eseguire l’effetto blink.

Come già sapete negli sketch Arduino le due funzioni principali che devono sempre essere presenti sono setup e loop.

Per dichiarare una nuova funzione e sufficiente dichiarare il tipo di valore che deve restituire, il suo nome e tutti i parametri (opzionali) che deve ricevere quando viene chiamata.

Come esempio utilizziamo lo sketch precedente per richiamare una funzione blink a cui viene passato come valore un intero che identifica il pin a cui è collegato il led da far lampeggiare.

la parte inclusa tra parentesi graffe non è altro che il corpo del blink, ma cosa vuol dire:

Stiamo dicendo che blink1 è una funzione che accetta come input una variabile intera a cui viene assegnato di nome pin, in questo modo, quando all’interno del loop viene invocata:

verrà passata a blink1 l’intero corrispondente al valore dell’array con indice “indice”.

Supponendo che “indice” corrisponda al valore 0, allora:

pinLed[0] che coincide con il valore intero 10

e quindi a blink1 viene passato il valore 10:

blink1(10);

cioè:

si accenderà e si spegnerà il led connesso al pin digitale 10.

Facciamo un ulteriore passo ed aggiungiamo più funzioni richiamate all’interno del loop.
Realizziamo uno sketch che:

• alla pressione del pulsante 1 il led 1 si accenda per 50 millisecondi e si spenga per 50 millisecondi;
• alla pressione del pulsante 2 il led 2 si accenda per 100 millisecondi e si spenga per 100 millisecondi;
• alla pressione del pulsante 3 il led 3 si accenda per 150 millisecondi e si spenga per 150 millisecondi;
• alla pressione del pulsante 4 il led 4 si accenda per 200 millisecondi e si spenga per 200 millisecondi.

Si utilizzeranno una serie di if per capire quale pulsante è stato premuto.

Questo il risultato:

La parte fondamentale dello sketch è:

come precedentemente descritto il for scansiona lo stato dei pulsanti, ad ogni ciclo del for viene memorizzato in val lo stato del pulsante: LOW oppure HIGH. Se lo stato è LOW vuol dire che uno dei pulsanti è stato premuto, a questo punto bisognerà controllare quale dei pulsanti è stato premuto e ciò verrà fatto con la serie dei quattro if che seguono.

Per evitare di utilizzare una serie di if, possiamo usare l’istruzione switch che in maniera più sintetica ed elegante svolge la stessa funzione della serie di if inseriti nel precedente sketch:

In tutti gli esempi sopra esposti abbiamo passato alle funzioni esterne solo un parametro, vediamo con questo ultimo sketch come passare due parametri, uno che indica quale LED far lampeggiare ed un secondo che passa un intero corrispondente al tempo iniziale di accensione e spegnimento del LED. Si vuole realizzare la funzionalità tale per cui se si mantiene premuto il pulsante la frequenza di accensione e spegnimento aumenta.

Questo il risultato:

All’interno del loop() viene chiamata la funzione:

Supponiamo che il pulsante premuto sia il primo, si avrà quindi:

indice = 0

stato = digitalRead(pinPulsanti[indice]);
stato = digitalRead(pinPulsanti[0]);
stato = digitalRead(5);
stato = LOW;

a questo punto

risulta vero e viene chiamata la funzione blink1:

andando a sostituire i valori:

blink1(pinLed[0], 100);
blink1(13, 100);

il ciclo for permetterà di aumentare la frequenza con cui lampeggia il LED:

dire:
contatore=tempo

vuol dire:
contatore=100

contatore>10 && contatore <= tempo si traduce in: contatore>10 && contatore <= 100 dove ‘&&’ è AND logico ovvero la funzione logica è vera se entrambe le condizioni: contatore>10
e
contatore <= 100

sono vere.

Con contatore=contatore-10 assegnamo ad ogni ciclo il valore che aveva al ciclo precedente decrementato di 10 unità.