Molto spesso durante le prime fasi di realizzazione di uno sketch Arduino si tende a non strutturare il proprio programma in blocchi funzionali separati, tutto il codice viene inserito all’interno del loop(). Questo tipo di approccio, soprattutto se siamo in presenza di un codice molto lungo, rende difficoltosa la lettura del programma da parte di altre persone e non permette una facile comprensione del funzionamento o l’identificazione di possibili errori.
Ho parlato in passato come strutturare il codice in blocchi funzionali nel post:
Arduino – lezione 07: lavorare con gruppi di valori e funzioni esterne, ma in quella lezione utilizzavo istruzioni che in questa fase dell’anno scolastico non sono ancora conosciute da alcuni allievi soprattutto del 3′ anno, che iniziano ad utilizzare Arduino, pertanto la presente lezione dovrebbe chiarire in modo più semplice l’argomento.
Le funzioni vengono utilizzate per organizzare le azioni eseguite dal vostro programma. Ogni funzione può essere identificata da un’azione specifica richiamata dal programma principale loop(), oppure richiamate da altre funzioni sempre all’interno del nostro sketch.
Senza saperlo quando avete iniziato a programmare con Arduino avete utilizzato delle funzioni: loop() e setup() le due funzioni sempre presenti in ogni sketch.
Per creare una funzione bisogna:
- definire il tipo di valore restituito dalla funzione;
- assegnare un nome alla funzione;
- e opzionalmente impostare una serie di parametri che la funzione riceverà quando viene chiamata (si dice anche invocata).
Creiamo una semplice funzione che permette di fare lampeggiare un LED, non possiede parametri e non restituisce nessun valore.
Assegnare alla funzione il tipo void vuol dire che non restituisce nulla e non inserire nulla tra le parentesi tonde indica che la funzione non accetta nessun parametro.
Esempio 1
// Prof. Michele Maffucci
// Es.01 - Usare le funzioni
// Data: 15.11.2020
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
lampeggia();
}
// blink LED una volta
void lampeggia()
{
digitalWrite(LED_BUILTIN, HIGH); // accende il LED
delay(1000); // pausa di 1 secondo
digitalWrite(LED_BUILTIN, LOW); // spegne il LED
delay(1000); // pausa di 1 secondo
}
Ogni volta che il loop() chiama (invoca) la funzione esterna lampeggia() viene effettuato il blink del LED sulla scheda.
Esempio 2
Realizziamo ora un secondo esempio in cui la funzione “lampeggia” accetta come parametro un valore intero che definisce il delay da impostare all’interno del funzione.
// Prof. Michele Maffucci
// Es.02 - Usare le funzioni
// Data: 15.11.2020
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
// chiamiamo la funzione lampeggia passando il valore
// specificato all'interno delle parentesi tonde
lampeggia(250);
}
// blink LED una volta
// per far si che la funzione accetti un parametro in input
// bisogna dichiarare il tipo del parametro in ingresso
// nella funzione lampeggia: int pausa
void lampeggia(int pausa)
{
digitalWrite(LED_BUILTIN, HIGH); // accende il LED
delay(pausa); // pausa: valore inserito nella variabile "pausa"
digitalWrite(LED_BUILTIN, LOW); // spegne il LED
delay(pausa); // pausa: valore inserito nella variabile "pausa"
}
Esempio 3
Realizziamo ora un terzo sketch in cui i parametri di ingresso per la funzione lampeggia() sono due, uno che definisce il tempo di accensione del LED ed uno che definisce il tempo di spegnimento del LED:
// Prof. Michele Maffucci
// Es.03 - Usare le funzioni
// Data: 15.11.2020
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
// chiamiamo la funzione lampeggia passando il valore
// specificato all'interno delle parentesi tonde
lampeggia(250, 1000);
}
// blink LED una volta
// per far si che la funzione accetti duen parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn e int pausaOff
void lampeggia(int pausaOn, int pausaOff)
{
digitalWrite(LED_BUILTIN, HIGH); // accende il LED
delay(pausaOn); // delay LED ON
digitalWrite(LED_BUILTIN, LOW); // spegne il LED
delay(pausaOff); // delay LED OFF
}
Esempio 4
Definiamo ora una funzione che ha 3 parametri di ingresso: il tempo in cui il LED rimane acceso, il tempo in cui il LED rimane spento e il numero di volte (cicli) che deve ripetersi il lampeggio, al termine del numero di cicli il LED non lampeggerà più. Come specificato nei commenti la variabile chiave verrà utilizzata per eseguire una volta sola la chiamata della funzione lampeggio:
// Prof. Michele Maffucci
// Es.04 - Usare le funzioni
// Data: 15.11.2020
// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
// chiamiamo la funzione lampeggia passando il valore
// specificato all'interno delle parentesi tonde
if (chiave == 0) {
chiave = 1;
lampeggia(250, 1000, 5);
}
}
// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio
void lampeggia(int pausaOn, int pausaOff, int contatore)
{
for (int i = 0; i < contatore; i++) {
digitalWrite(LED_BUILTIN, HIGH); // accende il LED
delay(pausaOn); // delay LED ON
digitalWrite(LED_BUILTIN, LOW); // spegne il LED
delay(pausaOff); // delay LED OFF
}
}
All’interno dello sketch precedente la funzione lampeggio utilizza un ciclo for per ripetere, per il numero di volte specificato dalla variabile contatore, il codice di accensione e spegnimento (corpo del for).
Esempio 5
Per completezza e per richiamare il modo con cui utilizzare l’istruzione while, di seguito trovate lo sketch che realizza la medesima funzionalità dello sketch precedente in cui il ciclo for viene sostituito da un while:
// Prof. Michele Maffucci
// Es.05 - Usare le funzioni
// Data: 15.11.2020
// chiave e la variabile che consente l'esecuzione della
// chiamata della funzione lampegga una sola volta
int chiave = 0;
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
}
void loop() {
// chiamiamo la funzione lampeggia passando il valore
// specificato all'interno delle parentesi tonde
if (chiave == 0) {
chiave = 1;
lampeggia(250, 1000, 5);
}
}
// blink LED una volta
// per far si che la funzione accetti tre parametri in input
// bisogna dichiarare il tipo per ogni parametro in ingresso
// nella funzione lampeggia: int pausaOn, int pausaOff, int contatore
// la variabile contatore definisce il numero di cicli di lampeggio
void lampeggia(int pausaOn, int pausaOff, int contatore)
{
while (contatore > 0) {
digitalWrite(LED_BUILTIN, HIGH); // accende il LED
delay(pausaOn); // delay LED ON
digitalWrite(LED_BUILTIN, LOW); // spegne il LED
delay(pausaOff); // delay LED OFF
contatore = contatore - 1; // decremento del contatore
}
}
Esempio 6
Nello sketch che segue realizziamo una funzione che accetta un parametro e restituisce un valore. Il parametro che viene passato alla funzione definisce la durata dei tempi di accensione e spegnimento del LED (in millisecondi). La funzione continua a far lampeggiare un LED fino a quando non viene premuto un pulsante. Il valore restituito dalla funzione è il numero di lampeggi effettuati, questo valore verrà stampato sulla Serial Monitor:
// Prof. Michele Maffucci
// Es.06 - Usare le funzioni
// Data: 15.11.2020
const int pinPulsante = 8; // pin a cui colleghiamo il pulsante
void setup() {
pinMode(LED_BUILTIN, OUTPUT);
pinMode(pinPulsante, INPUT);
Serial.begin(9600);
}
void loop() {
Serial.println("Premere il pulsante per interrompere il lampeggio");
int contatore = lampeggia(500); // lampeggio del LED: 500 ms ON e 500 ms OFF
Serial.print("Il numero di volte in cui il LED ha lampeggiato è stato di: ");
Serial.println(contatore);
while (digitalRead(pinPulsante) == HIGH)
{
// non viene fatto nulla fino a quando non rilascio il pulsante
}
}
// la funzione fa lampeggiare il LED per un periodo specificato (int periodo)
// e restituisce il numero di volte in cui il LED ha lampeggiato
int lampeggia(int periodo)
{
int contatoreLampeggio = 0;
while (digitalRead(pinPulsante) == LOW)
// ripetere finché non viene premuto il pulsante
// cicla fino a quando il pulsante non viene premuto
{
digitalWrite(LED_BUILTIN, HIGH);
delay(periodo);
digitalWrite(LED_BUILTIN, LOW);
delay(periodo);
contatoreLampeggio = contatoreLampeggio + 1; // incrementa il contatore
}
// in questo punto vuol dire che pinPulsante è HIGH
// ciò vuol dire che il pulsante è premuto
// contatoreLampeggio è il valore che viene restituito alla funzione chiamante
return contatoreLampeggio;
}
Il tipo di dato che precede in nome della funzione:
int lampeggia()
indica il tipo di dato restituito dalla funzione. Ricordarsi che nella funzione chiamante, nel nostro caso il loop(), quando chiamiamo la funzione questa deve terminare con un punto e virgola:
int contatore = lampeggia(500);
Errori comuni che vengono commessi nella chiamata di funzioni
Rimando a queste due brevi note che mostrano alcuni errori tipici:
Buon Making a tutti 🙂
Esercizi per i miei studenti
Esercizio 1
Realizzare un circuito costituito da 4 pulsanti e 4 led, connessi ad Arduino.
- Alla pressione del pulsante P1 il LED1 effettua il blink con un tempo di 200 ms
- Alla pressione del pulsante P2 il LED2 effettua il blink con un tempo di 400 ms
- Alla pressione del pulsante P3 il LED3 effettua il blink con un tempo di 600 ms
- Alla pressione del pulsante P4 il LED4 effettua il blink con un tempo di 800 ms
Fare in modo tale che ci sia una funzione esterna, chiamata dal loop(), che effettui il blink dei led.
Esercizio 2
Aggiungere all’esercizio 1 un pulsante che se premuto accende in sequenza ripetuta i 4 led. L’accensione in sequenza deve avvenire chiamando una funzione esterna al loop().
