Impariamo in questa lezione ad usare un sensore per controllare l’accensione di un diodo led. Useremo il più semplice dei sensori: il pulsante.
Scopo della lezione:
realizzare un programma che permette di accendere una luce quando premiamo un pulsante e quando viene nuovamente premuto il pulsante spegne la luce, comportamento analogo a quello che si ha per un impianto di illuminazione.
Per controllare lo stato di un pulsante utilizzeremo l’istruzione digitalRead(), questa istruzione legge il valore su uno specifico pin digitale che può assumere due valori, HIGH o LOW, detto in modo meno informatico e più elettronico, verifica se su un determinato pin è applicata una tensione di +5V (definito HIGH) o 0V (definito LOW).
Nella lezione 2 abbiamo realizzato un programma che permetteva di far lampeggiare un led, con la nuova istruzione digitalRead() siamo in grado di eseguire qualcosa di più evoluto, l’accensione di un led solamente se cambia una situazione esterna, in questo esercizio, lo stato di un pulsante.
Quindi con digitalRead() possiamo leggere uno stato di un sensore e memorizzare questo stato nella memoria di Arduino per fare qualcosa.
Per procedere con questa lezione abbiamo necessità di un po’ di hardware elettronico:
- 1 breadboard
- 1 pulsante
- 1 diodo led
- 1 resistenza da 10 K Ohm
- filo elettrico per breadboard
- ed ovviamente Arduino duemilanove 🙂
Il circuito che deve essere realizzato è il seguente.
l’immagine è stata realizzata utilizzando Fritzing
Dettagli sui collegamenti:
Questo l’immagine del circuito reale:
Ricordate di collegare il catodo del diodo LED su GND e l’anodo all’uscita digitale 13.
Questo il codice usato per controllare il LED:
// Esempio 01: accendi il led appena è premuto il pulsante
#define LED 13 // LED collegato al pin digitale 13
#define BUTTON 7 // pin di input dove è collegato il pulsante
int val = 0; // si userà val per conservare lo stato del pin di input
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
pinMode(BUTTON, INPUT); // imposta il pin digitale come input
}
void loop() {
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// controlla che l'input sia HIGH (pulsante premuto)
if (val == HIGH) {
digitalWrite(LED, HIGH); //accende il led
}
else {
digitalWrite(LED, LOW); //spegne il led
}
}
Come potete constatare oltre all’istruzione digitalRead() in grado di leggere lo stato di un sensore esterno abbiamo anche l’istruzione if e if…else
L’istruzione if…else consente di prendere delle decisioni in funzione del fatto che una determinata condizione logica sia VERA o FALSA.
Nel caso in cui la condizione sia VERA viene eseguito il primo blocco di istruzioni, nel caso in cui la condizione sia FALSA, viene eseguito il secondo blocco di memoria.
La condizione logica espressa tra parentesi tonde, segue la parola if
Esempio:
if (x < 100)
{
// blocco A
}
else
{
// blocco B
}
Se la condizione X<100 è vera viene eseguito il blocco di istruzioni del “blocco A”, se la condizione X<100 è falsa viene eseguito il blocco di istruzioni del “blocco B”.
Nota:
Dire che una condizione è VERA vuol dire che assume un valore binario pari a 1, ma in senso booleano, è VERA qualsiasi condizione diversa da zero, per cui -50, -7, -1, 3, 9 sono tutti considerati VERO in senso booleano.
Per maggiori dettagli si consulti il reference su Arduino.cc
Tornando al codice del programma “Esempio 1” notate che ho usato “==” invece che “=” per confrontare due elementi.
Nel linguaggio di programmazione di Arduino il simbolo “==” (vai al manuale) viene utilizzato per confrontare due entità (confronto logico) e restituisce TRUE o FALSE, mentre il simbolo “=” (vai al manuale) viene utilizzato per assegnare un valore ad una variabile.
Analizziamo il programma
Poiché vogliamo ottenere una funzionalità simile a quello di un interruttore per attivare l’illuminazione in una casa, bisogna in qualche modo ricordare lo stato del pulsante, per far ciò definiamo una variabile intera di nome val a cui assegnamo inizialmente il valore 0.
Come potete vedere nel programma useremo val per conservare il valore di digitalRead()
I valori di qualsiasi variabile usata con Arduino vengono inseriti nella memoria RAM, valori che vengono persi una volta che si toglie l’alimentazione alla scheda Arduino.
All’interno della codice di loop() viene assegnata alla variabile val lo stato del valore di input mediante l’istruzione digitalRead(BUTTON), ovvero l’istruzione legge il valore dell’input (pulsante) e restituisce un valore 0 oppure 1:
// legge il valore dell'input e lo conserva val = digitalRead(BUTTON);
successivamente viene controllato mediante l’istruzione if…else se il pulsante è premuto:
// controlla che l'input sia HIGH (pulsante premuto)
if (val == HIGH) {
digitalWrite(LED, HIGH); //accende il led
}
else {
digitalWrite(LED, LOW); //spegne il led
}
}
Se il valore di val è HIGH (valore logico 1) vuol dire che il pulsante è premuto e allora, tramite l’istruzione “digitalWrite(LED, HIGH);” viene acceso il LED, se il primo confronto risulta falso, ciò vuol dire che il pulsante non è premuto come conseguenza viene eseguita la parte di codice else che spegne il LED, ciò viene eseguito con l’istruzione: “digitalWrite(LED, LOW);”
Però lo scopo di questa terza lezione è quello di realizzare un circuito simile a quello di un impianto di illuminazione: “premo il pulsante accendo la luce, premo una seconda volta e spengo la luce”, l’esempio 1, ci costringe a mantenere il dito sul pulsante per mantenere acceso il led.
Questa la prima versione del programma che risolve il problema:
// Esempio 02: accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia
// premendo una seconda volta il pulsante spegne il led
#define LED 13 // LED collegato al pin digitale 13
#define BUTTON 7 // pin di input dove è collegato il pulsante
int val = 0; // si userà val per conservare lo stato del pin di input
int stato = 0; // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
pinMode(BUTTON, INPUT); // imposta il pin digitale come input
}
void loop() {
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// controlla che l'input sia HIGH (pulsante premuto)
// e cambia lo stato del led
if (val == HIGH) {
stato = 1 - stato;
}
if (stato == 1) {
digitalWrite(LED, HIGH); // accende il led
}
else {
digitalWrite(LED, LOW); //spegne il led
}
}
Prima di provare il risultato su Arduino vediamo come funziona il programma.
Passo 1: pulsante non premuto – diodo spento
Il valore assunto da val è 0 in quanto il pulsante non è premuto (l’istruzione “digitalRead(BUTTON);” restituisce 0), la condizione logica val == HIGH del prim if restituisce falso e la variabie stato resta al valore iniziale 0.
Poiché il confronto stato == 1 del secondo if restituisce falso, viene eseguito l’else in cui è presente l’istruzione “digitalWrite(LED, LOW);” che spegne il diodo led.
Passo 2: pulsante premuto – diodo acceso
Il valore assunto da val è 1 in quanto il pulsante è premuto (l’istruzione “digitalRead(BUTTON);” restituisce 1), la condizione logica val == HIGH del primo if restituisce vero e la variabie stato viene impostata a stato = 1 – 0, cioè a 1.
Poiché il confronto stato == 1 del secondo if restituisce vero, viene eseguita l’istruzione che segue, cioè: “digitalWrite(LED, HIGH);” che accende il diodo led.
Passo 3: pulsante premuto – diodo spento
Il valore assunto da val è 1 in quanto il pulsante è premuto (l’istruzione “digitalRead(BUTTON);” restituisce 1), la condizione logica val == HIGH del primo if restituisce vero e la variabie stato viene impostata a stato = 1 – 1 (stato è stato impostato ad 1 nel passo precedente), cioè a 0.
Poiché il confronto stato == 1 del secondo if restituisce falso, viene eseguito l’else in cui è presente l’istruzione “digitalWrite(LED, LOW);” che spegne il diodo led.
Se provate il programma noterete un funzionamento molto strano, potrebbe capitare che premendo e rilasciando il pulsante il led non si accende e si spegne correttamente, ad esempio premo e non si accende oppure se acceso premendo il pulsante non si spegne il led. Ciò è dovuto al fatto che Arduino legge le istruzioni del vostro programma ad una velocità di milioni di istruzioni al secondo ciò vuol dire che la lettura dello stato del pulsante viene letta moltissime volte al secondo e l’accensione e lo spegnimento del diodo led potrebbe essere imprevedibile.
Per comprendere questa situazione immaginate che al Passo 3 precedente si continui a mantenere premuto il pulsante, noterete che la variabile stato ad ogni ciclo, assume valori diversi che possono portare ad una situazione di accensione o spegnimento del diodo.
Per ovviare a questo problema bisogna riuscire a identificare il momento esatto in cui il pulsante viene premuto è questo può essere fatto conservando in una variabile lo stato del pulsante al passo precedente:
// Esempio 03: antirimbalzo
// accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia
// premendo una seconda volta il pulsante spegne il led
#define LED 13 // LED collegato al pin digitale 13
#define BUTTON 7 // pin di input dove è collegato il pulsante
int val = 0; // si userà val per conservare lo stato del pin di input
int vecchio_val = 0; // si userà vecchio_val per conservare lo stato del pin di input al passo precedente
int stato = 0; // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
pinMode(BUTTON, INPUT); // imposta il pin digitale come input
}
void loop() {
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// controlla se è accaduto qualcosa
if ((val == HIGH) && (vecchio_val == LOW)){
stato = 1 - stato;
}
vecchio_val = val; // ricordiamo il valore precedente di val
if (stato == 1) {
digitalWrite(LED, HIGH); // accende il led
}
else {
digitalWrite(LED, LOW); //spegne il led
}
}
In questo caso usiamo la variabile vecchio_val per conservare lo stato al ciclo precedente, in questo modo verifichiamo lo stato effettivo del pulsante verificando se lo stato attuale è “pulsante premuto” E “pulsante non premuto al passo precedente“, se la condizione è vera viene modificato lo stato.
L’operatore boleano utilizzato è AND che nel linguaggio di programmazione si indica con &&.
La cosa più bella nell’applicare l’informatica al mondo reale e che è indispensabile far i conti con le caratteristiche fisiche dei dispositivi su cui operiamo.
Come potete vedere dal filmato, non appena aumentiamo la frequenza con cui premete il pulsante, si ricade in una situazione di incongruenza per cui il led non risponde più ai comandi. Questo problema avviene perché il pulsante è un apparato meccanico costituito da contatti elettrici ed una molla, quando premiamo e rilasciamo, si manifestano situazioni di rimbalzo del contatto che creano dei segnali non corretti, detti spuri, che modificano lo stato del diodo led.
Per risolvere il problema è sufficiente attendere che questi rimbalzi spuri si concludano e quindi bisogna attendere una certa quantità di tempo dopo che è stato rilevato un cambiamento di stato, provate con valori non superiori a 50 millisecondi, nell’esempio ho introdotto un valore di 15 millisecondi di ritardo.
// Esempio 04: antirimbalzo2 - accendi il led appena è premuto il pulsante mantenendolo acceso quando si rilascia
// premendo una seconda volta il pulsante spegne il led
#define LED 13 // LED collegato al pin digitale 13
#define BUTTON 7 // pin di input dove è collegato il pulsante
int val = 0; // si userà val per conservare lo stato del pin di input
int vecchio_val = 0; // si userà vecchio_val per conservare lo stato del pin di input al passo precedente
int stato = 0; // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
pinMode(BUTTON, INPUT); // imposta il pin digitale come input
}
void loop() {
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// controlla se è accaduto qualcosa
if ((val == HIGH) && (vecchio_val == LOW)){
stato = 1 - stato;
delay(15); // attesa di 15 millisecondi
}
vecchio_val = val; // ricordiamo il valore precedente di val
if (stato == 1) {
digitalWrite(LED, HIGH); // accende il led
}
else {
digitalWrite(LED, LOW); //spegne il led
}
}
Ora come esercizio uniamo ciò che abbiamo imparato nella lezione n. 2 e ciò che abbiamo imparato in questa lezione.
Esercizio:
realizzare un programma che esegue questa funzione: quando si preme un pulsante il diodo led lampeggia, quando premo una seconda volta il pulsante il led termina di lampeggiare:
// Esempio 05: led lampeggia se premo il pulsante
// premendo una seconda volta il pulsante si spegne il led
#define LED 13 // LED collegato al pin digitale 13
#define BUTTON 7 // pin di input dove è collegato il pulsante
int val = 0; // si userà val per conservare lo stato del pin di input
int vecchio_val = 0; // si userà vecchio_val per conservare lo stato del pin di input al passo precedente
int stato = 0; // ricorda lo stato in cui si trova il led, stato = 0 led spento, stato = 1 led acceso
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
pinMode(BUTTON, INPUT); // imposta il pin digitale come input
}
void loop() {
val = digitalRead(BUTTON); // legge il valore dell'input e lo conserva
// controlla se è accaduto qualcosa
if ((val == HIGH) && (vecchio_val == LOW)){
stato = 1 - stato;
delay(15); // attesa di 15 millisecondi
}
vecchio_val = val; // ricordiamo il valore precedente di val
if (stato == 1) {
digitalWrite(LED, HIGH); // accende il LED
delay(1000); // aspetta un secondo
digitalWrite(LED, LOW); // spegne il LED
delay(1000); // aspetta un secondo
}
else {
digitalWrite(LED, LOW); //spegne il led
}
}
Un piccolo esercizio.
Se provate ad aumentare la frequenza con cui premete il pulsante noterete che non riuscite a spegnere il diodo led, siete in grado di risolvere questo problema?
Buon Lavoro 🙂
Vai alle altre lezioni:
