02 - INTERFACCIA PER ASTRONAVE

ARDUINO STA PER DIVENTARE IL PROTAGONISTA DI UN FILM DI FANTASCIENZA

Scopri: input e output digitali, il tuo primo programma, le variabili

Tempo: 45 MINUTI Livello: ■ □ □ □ □ Basato sul progetto: 1

Ora che hai acquisito le basi dell’elettronica, è tempo di passare a controllare cose e oggetti con Arduino. In questo progetto, costruirai qualcosa che potrebbe essere un’interfaccia di una astronave di un film di fantascienza degli anni Settanta. Realizzerai un pannello di controllo con un pulsante e delle luci che si accenderanno quando schiaccerai il pulsante. Puoi decidere se le luci significano «Inserire l’hyperdrive» o «Spara il laser!». Un LED verde sarà acceso finché non premerai un pulsante. Quando Arduino riceverà un segnale da un pulsante, la luce verde si spegnerà e le altre due luci inizieranno a lampeggiare.

INGREDIENTI

• Pulsante

• LED

• Resistenza da 220 Ohm

• Resistenza da 10 kilo Ohm

I piedini digitali di Arduino possono leggere solo due stati: quando c’è o non c’è la tensione su un piedino di ingresso. Questo tipo di ingresso è chiamato digitale (o qualche volta binario, per via dei due stati). Questi stati vengono definiti come ALTO (HIGH) e BASSO (LOW). HIGH è come dire «c’è tensione qui!» e LOW significa «non c’è tensione su questo piedino!». Quando metti un piedino di OUTPUT a HIGH, usando un comando chiamato digitalWrite(), lo stai accendendo. Se misuri la tensione tra il piedino e la massa, ottieni 5 volt. Quando metti un piedino di OUTPUT a LOW, lo stai spegnendo. Il piedino digitale di Arduino funziona sia come ingresso sia come uscita. Nel tuo codice, dovrai configurarli a seconda della funzione che vorrai dare loro. Quando i piedini sono output (uscita), puoi accendere componenti come i LED. Se configuri i piedini come input (ingresso), puoi verificare se è stato premuto o no un pulsante. Dato che i piedini 0 e 1 sono usati per comunicare con il computer, è meglio iniziare con il piedino 2.

COSTRUISCI IL CIRCUITO

1. Collega la breadboard alle connessioni 5V e GND (massa) di Arduino, come nel progetto precedente. Posiziona due LED rossi e uno verde sulla breadboard. Connetti il catodo (piedino corto) di ciascun LED a massa attraverso una resistenza da 220 ohm. Connetti l’anodo (piedino lungo) del LED verde al piedino 3. Connetti gli anodi dei LED rossi rispettivamente ai piedini 4 e 5.

2. Posiziona l’interruttore sulla breadboard come nel progetto precedente. Connetti un lato all’alimentazione e l’altro lato al piedino digitale 2 di Arduino. Hai anche bisogno di aggiungere una resistenza da 10 kilo ohm da massa al piedino dell’interruttore che è collegato ad Arduino. Questa resistenza di “pull-down” connette il piedino a massa quando il pulsante è aperto, così si legge LOW quando nessuna tensione proviene dal pulsante.

Puoi coprire la breadboard con il cartoncino del kit. O puoi decorarlo per realizzare il tuo personale sistema di lancio. Se le luci si accendono e si spengono non significa nulla di per sé, ma, quando le metti in un pannello di controllo e dai loro un senso, acquistano un significato maggiore. Cosa vuoi che significhi il LED verde? E il lampeggio del LED rosso? Sei libero di deciderlo!
Trovi il modello da ritagliare nel capitolo PAPERCRAFT, in fondo al testo.

1. Piega il cartoncino pre-tagliato come mostrato qui.
2. Metti il cartoncino piegato sulla breadboard. I tre LED e il pulsante aiutano a trovare la posizione.

IL CODICE

Alcune note prima di iniziare

Ogni programma Arduino ha due funzioni principali. Le funzioni sono parti di un programma del computer che eseguono comandi specifici. Le funzioni hanno nomi univoci e sono “chiamate” quando servono. Le funzioni necessarie in un programma Arduino sono chiamate setup() e loop(). Queste funzioni devono essere dichiarate: significa che si deve dire ad Arduino cosa faranno. setup() e loop() sono indicate come vedi sulla destra. In questo programma, stai per creare una variabile prima di entrare nella parte principale del programma. Le variabili sono nomi che dai a delle aree di memoria di Arduino così puoi tenere traccia di ciò che sta accadendo. Questi valori possono cambiare a seconda delle istruzioni del tuo programma. I nomi delle variabili dovrebbero essere descrittivi dei valori che stanno immagazzinando. Per esempio, una variabile chiamata switchState spiega cosa sta immagazzinando: lo stato di un pulsante. Invece, una variabile chiamata x non spiega nulla su ciò che contiene.

void setup() {
}

void loop() {
}

Parentesi graffe { } Il codice scritto all’interno di parentesi graffe è eseguito quando viene chiamata la funzione.

Iniziamo a programmare

Per creare una variabile, hai bisogno di dichiararne il tipo. Il tipo di dato int contiene un numero intero (chiamato anche un intero); che è un numero qualsiasi senza punti decimali. Quando dichiari una variabile, normalmente gli dai anche un valore iniziale. La dichiarazione della variabile deve finire con un punto e virgola (;).

int switchState = 0;

Configura la funzionalità dei piedini

Il setup() viene eseguito una volta soltanto all’accensione dell’Arduino. Qui è dove configuri i piedini digitali per renderli ingressi o uscite usando la funzione pinMode(). I piedini connessi ai LED sono uscite (OUTPUT) e il pulsante un ingresso (INPUT).

void setup() {
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);
  pinMode(2, INPUT);
}

Maiuscole, minuscole Nel codice stai attento a distinguere le maiuscole e le minuscole. Per esempio, pinMode è il nome di un comando, ma pinmode produce un errore.

Crea la funzione loop

Il loop() viene eseguito continuamente dopo che è stato completato il setup(). Il loop() è il posto dove verifichi la tensione sugli ingressi e controlli le uscite. Per controllare la tensione su un input digitale, usa la funzione digitalRead() che rileva se c’è tensione sul piedino scelto. Per sapere quale piedino leggere, digitalRead() si aspetta un parametro. I parametri sono informazioni che dai alle funzioni dicendo loro come dovrebbero svolgere il loro lavoro. Per esempio, digitalRead() ha bisogno di un parametro: quale piedino leggere. Nel tuo programma, digitalRead() sta verificando lo stato del piedino 2 e immagazzinando il valore nella variabile switchState. Se c’è tensione sul piedino quando viene chiamata digitalRead(), la variabile switchState ha il valore HIGH (o 1). Se non c’è tensione, switchState prende il valore LOW (o 0).

void loop() {
  switchState = digitalRead(2);
  // questo è un commento

Commenti I commenti sono note che scrivi per te stesso, che il computer ignora. Per scrivere un commento, aggiungi due barre //. Il computer ignora tutto il contenuto presente dopo le due barre.

L’istruzione if

Un comando if() nella programmazione confronta due cose e determina se il confronto è vero o falso ed esegue le azioni che gli indichi. Quando confronti due cose nella programmazione, devi usare due simboli dell’uguale ==. Se usi un segno solo, imposti il valore della variabile invece di confrontarlo.

  if (switchState == LOW) {
  // il pulsante non è premuto

Costruisci la tua astronave

digitalWrite() è il comando che ti permette di impostare un’uscita a 5V o 0V. digitalWrite() richiede due parametri: quale piedino controllare e a quale valore impostare il piedino, HIGH o LOW. Se vuoi accendere i LED rossi e spegnere il LED verde nella tua istruzione if(), il tuo codice sarà così.

    digitalWrite(3, HIGH); // LED verde
    digitalWrite(4, LOW);  // LED rosso
    digitalWrite(5, LOW);  // LED rosso
  }

Può essere utile trascrivere il flusso del programma in pseudocodice: un modo per descrivere cosa vuoi che il programma faccia in un linguaggio semplice, ma strutturato in modo che renda facile scrivere un vero programma. In questo caso stai determinando se switchState è HIGH (significa che il pulsante è premuto) o no. Se il pulsante è premuto, spegnerai il LED verde e accenderai quello rosso. Nel pseudocodice, il comando potrebbe essere così:

se switchState è LOW:
____accendi il LED verde
____spegni il LED rosso
   se switchState è HIGH:
____spegni il LED verde
____accendi il LED rosso

Se ora esegui il tuo programma, le luci cambiano quando premi il pulsante. Questo è piuttosto chiaro, ma puoi aggiungere un tocco di complessità al programma per una reazione più interessante.

Hai detto ad Arduino cosa fare quando l’interruttore è aperto. Ora definisci cosa accade quando è chiuso. L’istruzione if() ha un componente opzionale else (in italiano oppure) che fa succedere qualcosa se la condizione originale non si è verificata. In questo caso, dato che hai verificato che il pulsante è LOW, scrivi il codice per la condizione HIGH dopo l’istruzione else.

Per far lampeggiare i LED rossi quando è premuto il pulsante, devi accendere e spegnere le luci nell’istruzione else che hai appena scritto.

  else { // il pulsante è premuto
    digitalWrite(3, LOW);
    digitalWrite(4, LOW);
    digitalWrite(5, HIGH);

Ora il tuo programma fa lampeggiare il LED rosso quando il pulsante è premuto.

Dopo aver impostato i LED in un determinato stato, devi mettere in pausa l’Arduino prima di riportarli allo stato precedente. Se non aspetti, le luci vanno avanti e indietro così velocemente che appaiono leggermente meno luminose ma non accese o spente. Questo perché l’Arduino esegue il suo loop() migliaia di volte ogni secondo e il LED si accende e spegne più velocemente di quanto riusciamo a percepirlo. La funzione delay() impedisce ad Arduino di eseguire istruzioni per un certo periodo di tempo. delay() richiede un parametro che determina il numero di millisecondi prima di eseguire le istruzioni successive. Ci sono 1000 millisecondi in un secondo. delay(250) fa pausa per un quarto di secondo.

    delay(250); // aspetta un quarto di secondo
    // cambia gli stati dei LED
    digitalWrite(4, HIGH);
    digitalWrite(5, LOW);
    delay(250); // aspetta un quarto di secondo
  }
} // torna indietro all'inizio del loop

USALA

Una volta che la tua Arduino è programmata, dovresti vedere accendersi la luce verde. Quando premi il pulsante, le luci rosse iniziano a lampeggiare e la luce verde si spegne. Prova a cambiare il tempo delle due funzioni delay(): nota cosa accade alle luci e come la risposta del sistema cambia in base alla velocità del lampeggio. Quando esegui un delay() nel programma, questo ferma tutte le altre funzionalità. Non avviene nessuna lettura di sensori fino a che questo periodo non è passato. Sebbene i ritardi siano spesso utili, quando realizzi il tuo progetto assicurati che non interferiscano inutilmente con l’interfaccia.

Come potresti far lampeggiare i LED rossi quando si avvia il programma? Come potresti creare un’interfaccia più grande o più complessa con LED e pulsanti per le tue avventure interstellari?

Quando inizi a creare un’interfaccia per il tuo progetto, pensa alle aspettative delle persone che lo useranno. Quando premono un pulsante, vorranno un feedback immediato? Dovrebbe esserci un ritardo tra le loro azioni e ciò che fa Arduino? Prova a metterti nei panni di un altro quando stai progettando e verifica che le tue aspettative siano adeguate alla realtà del progetto.*

In questo progetto, hai creato il tuo primo programma con Arduino per controllare con un pulsante il comportamento di alcuni LED. Hai usato delle variabili, un’istruzione if()… e funzioni per leggere lo stato di un ingresso e controllare delle uscite.

COME LEGGERE IL CODICE COLORI DELLE RESISTENZE

I valori delle resistenze sono espressi da anelli colorati secondo una norma sviluppata negli anni Venti quando era troppo complesso scrivere numeri su oggetti tanto piccoli. Ogni colore corrisponde a un numero, come vedi nella tabella sotto. Ogni resistenza ha 4 o 5 anelli. Nel tipo con 4 anelli, i primi due anelli indicano le prime due cifre del valore mentre il terzo indica il numero degli zero seguenti (tecnicamente rappresenta la potenza di dieci). L’ultimo anello specifica la tolleranza: nell’esempio qui sotto, l’oro indica che il valore della resistenza può essere 10 kilo ohm più o meno 5%.

RESISTENZE CONTENUTE NELLO STARTER KIT (Troverai versioni con 4 e 5 fasce)

• 220 Ω (Rosso, Rosso, Marrone, Oro / Rosso, Rosso, Nero, Nero, Marrone)

• 560 Ω (Verde, Blu, Marrone, Oro / Verde, Blu, Nero, Nero, Marrone)

• 4.7 kΩ (Giallo, Viola, Rosso, Oro / Giallo, Viola, Nero, Marrone, Marrone)

• 1 kΩ (Marrone, Nero, Rosso, Oro / Marrone, Nero, Nero, Marrone, Marrone)

• 10 kΩ (Marrone, Nero, Arancione, Oro / Marrone, Nero, Nero, Rosso, Marrone)

• 1 MΩ (Marrone, Nero, Verde, Oro / Marrone, Nero, Nero, Giallo, Marrone)

• 10 MΩ (Marrone, Nero, Blu, Oro / Marrone, Nero, Nero, Verde, Marrone)

CODICE COMPLETO

/*
  Arduino Starter Kit example
  Project 2 - Spaceship Interface

  This sketch is written to accompany Project 2 in the Arduino Starter Kit

  Parts required:
  - one green LED
  - two red LEDs
  - pushbutton
  - 10 kilohm resistor
  - three 220 ohm resistors

  created 13 Sep 2012
  by Scott Fitzgerald

  https://store.arduino.cc/genuino-starter-kit

  This example code is part of the public domain.
*/

// Create a global variable to hold the state of the switch. This variable is
// persistent throughout the program. Whenever you refer to switchState, you’re
// talking about the number it holds
int switchstate = 0;

void setup() {
  // declare the LED pins as outputs
  pinMode(3, OUTPUT);
  pinMode(4, OUTPUT);
  pinMode(5, OUTPUT);

  // declare the switch pin as an input
  pinMode(2, INPUT);
}

void loop() {

  // read the value of the switch
  // digitalRead() checks to see if there is voltage on the pin or not
  switchstate = digitalRead(2);

  // if the button is not pressed turn on the green LED and off the red LEDs
  if (switchstate == LOW) {
    digitalWrite(3, HIGH);  // turn the green LED on pin 3 on
    digitalWrite(4, LOW);   // turn the red LED on pin 4 off
    digitalWrite(5, LOW);   // turn the red LED on pin 5 off
  }
  // this else is part of the above if() statement.
  // if the switch is not LOW (the button is pressed) turn off the green LED and
  // blink alternatively the red LEDs
  else {
    digitalWrite(3, LOW);   // turn the green LED on pin 3 off
    digitalWrite(4, LOW);   // turn the red LED on pin 4 off
    digitalWrite(5, HIGH);  // turn the red LED on pin 5 on
    // wait for a quarter second before changing the light
    delay(250);
    digitalWrite(4, HIGH);  // turn the red LED on pin 4 on
    digitalWrite(5, LOW);   // turn the red LED on pin 5 off
    // wait for a quarter second before changing the light
    delay(250);
  }
}