Boliboop

Arduino Duemilanove: espandere Hello, Blink!

27 gennaio 2009 , di Boliboop

Nel precedente tutorial abbiamo analizzato riga per riga il primo esempio di programmazione per Arduino, ovvero Hello, Blink!. Oggi presenterò qualche semplice e piccola modifica ed espansione, sia software che hardware allo scopo di prendere dimestichezza con il linguaggio utilizzato, ma anche con il dispositivo stesso.

Il codice di partenza è il seguente:

1
2
3
4
5
6
7
8
9
10
11
12
13
14

int ledPin = 13;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(1000);
  digitalWrite(ledPin, LOW);
  delay(1000);
}

Ricordando che al funzione delay() non è altro che una pausa, espressa in millisecondi imposta ad Arduino prima di eseguire l’istruzione successiva, possiamo ovviamente giocare a modificarne il valore tra parentesi (ovvero l’argomento della funzione), aumentandolo o diminuendolo a piacere.

Provate ad esempio a scrivere nelle corrispondenti righe:

11

  delay(2000);

e

13

  delay(500);

Effettuando queste modifiche e inviando il programma ad Arduino, tramite il comando Command+U, avremo, dopo il solito scintillio di led L, TX e RX, un lampeggiare del led L che rimarrà acceso per 2 secondi e resterà spento per mezzo secondo.

Ecco la prima piccola modifica hardware. Nel KIT WorkShop che abbiamo acquistato e di cui abbiamo parlato nel primo articolo introduttivo, sono presenti 5 led rossi, 1 verde e 1 giallo. Prendiamo, ad esempio il led rosso e proviamo a collegarlo ad Arduino. Prima di tutto però osserviamolo, perché noterete che possiede una zampa più lunga dell’altra.

Senza nemmeno dover piegare le zampe, inseriamo quella più corta nel pin contrassegnato con l’etichetta GND e quella più lunga nel famoso pin 13. Se non avete scollegato Arduino dall’alimentazione (o dalla porta USB), vedrete immediatamente il led illuminarsi secondo il ritmo stabilito dal programma.

Cosa abbiamo fatto? Semplicemente, siccome tutte le zampe corte dei led vanno messe a terra (da cui GND, ground in inglese vuol dire appunto terra) e siccome il pin 13 è, come abbiamo visto nel precedente tutorial, regolato sui 5 volt a intervalli regolari, il led rosso che abbiamo aggiunto viene alimentato esattamente come il piccolo e verde led L, e i due dovrebbero quindi lampeggiare all’unisono.

Ora qualcosa di divertente. Come prima cosa modifichiamo il programma in modo da creare una nuova variabile che chiameremo interval e assegniamole il valore di 1000. Dopo di che inseriamo tale variabile come argomento delle due funzioni delay(). Il nuovo listato del programma sarà quindi:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

int ledPin = 13;
int interval = 1000;
 
void setup()
{
  pinMode(ledPin, OUTPUT);
}
 
void loop()
{
  digitalWrite(ledPin, HIGH);
  delay(interval);
  digitalWrite(ledPin, LOW);
  delay(interval);
}

A questo punto possiamo modificare solo il valore assegnato alla variabile interval in riga 2 per modificare automaticamente gli argomenti delle due funzioni delay(). La cosa divertente accade quando proviamo ad assegnare ad interval valori sempre più piccoli. Proviamo ad esempio a scrivere interval = 100. Cosa accade? Ovviamente il nostro led rosso comincia a lampeggiare come una luce natalizia.

Ma se impostiamo interval = 10 cosa accade? Il led sembra aver messo di lampeggiare rimanendo sempre accesso. Perché?

Una breve digressione sul funzionamento del sistema visivo occhio-cervello ci fa capire la ragione di questo strano comportamento (non nascondo che appena provato ho istintivamente pensato ad un malfunzionamento o una limitazione di Arduino…). La persistenza della visione è un fenomeno che ci permette di credere che la sequenza di fotogrammi di un cartone animato sia una azione continua e non una serie di disegni statici (idem per i fotogrammi di un film). Alla stessa maniera anche la luce delle lampadine collegate ad una rete domestica a corrente alternata ci appare come stabile ma in realtà è un alternanza, appunto, di luce e buio, così rapida da non essere percettibile. Un tempo si pensava che questo fenomeno coinvolgesse la retina, ma ora è chiaro che è tutto un processo a livello della corteccia cerebrale, ovvero in poche parole, mentre la guardiamo, una immagine ci mette alcuni centesimi di secondi prima di perdere la sua luminosità originale e, se nel frattempo, è già pronta un’altra immagine, noi non siamo in grado di percepire il momento del cambiamento di immagine.

Nel caso del nostro led, se impostiamo un valore di interval di 20 ms vediamo chiaramente un lampeggiare (seppur frenetico) della luce, ma se interval è 18 ( o 16, 14, fino 11 ms) riusciamo a percepire solo un sempre più lieve tremolio. Quando interval = 10 il nostro cervello non ha fatto in tempo a cancellare, e neppure ad attenuare, l’immagine del led acceso che, dopo la pausa in cui il led rimane spento, è già ora di riaccenderlo.

In termini matematici, siccome la sequenza si compone di due delay() ognuno da 10 ms, questo significa che l’intera sequenza dura 20 ms, e quindi l’alternanza di accensioni e spegnimenti avviene 50 volte al secondo (50 x 20 ms = 1000 ms = 1 secondo), ovvero 50 Hz. Tenendo conto, però, che un lieve sfarfallio seppur invisibile può comunque essere fastidioso per l’occhio, la corrente alternata della rete domestica, cioè quella che fa funzionare le nostre lampadine, è sì fissata ad una frequenza di 50 Hz ma (dal momento che la corrente è alternata secondo un onda sinusoidale e rimane accesa sia a 220 V che a -220 V) la frequenza dell’intensità luminosa è doppia, ovvero di 100 Hz.

Ok, ma io non ci credo. Se siete arrivati a questo punto, con interval impostato a 10 ms, Arduino e il suo led apparentemente immobili, e la spiegazione che avete letto vi sembra plausibile ma non una dimostrazione che vi convinca in modo incontrovertibile… beh allora sappiate che avete una mentalità scientifica e tutta la mia stima.

Ad ogni modo, la dimostrazione la potete realizzare semplicemente agitando su e già il vostro Arduino con led rosso collegato. Ebbene sì, provateci. In questo modo, anziché una scia continua rossa, vedrete una scia interrotta da punti di buio, a riprova della rapida alternanza decisa nel programma che avete caricato sul dispositivo. In pratica, ciò che prima veniva percepito dal nostro cervello come immagine statica del led acceso, ora è un immagine spalmata su un certo spazio visivo dal vostro movimento e, in momenti diversi, il led si trova in punti diversi, permettendo al cervello di registrare le immagini della luce in punti diversi della cortecce cerebrale, con buona pace della persistenza della visione.

Ispirandomi ad un mio vecchio articolo, pomposamente intitolato Come trasformare la propria fotocamera digitale in un oscilloscopio, ho fotografato Arduino mentre girava il software Hello, Blink! con interval = 10 ms spostandomi velocemente con la fotocamera, durante lo scatto di un 1/10 di secondo. Nell’immagine in basso potete notare come il led rosso si spenga e si riaccenda varie volte (in sincrono col led verde L) mentre il led PWR mostra una scia continua proprio perché sempre acceso:

A conti fatti, ci sono 4 immagini di led interi più 2 mezzi led alle due estremità della scia intermittente. Infatti, con interval = 10, se in un secondo ci sono 50 lampeggiamenti, in un decimo di secondo (la durata dello scatto) ce ne saranno 5.

Nel prossimo articolo realizzeremo un’altra espansione hardware. Nel frattempo, se avete domande, critiche o richieste, scrivete pure nei commenti.

Condividi

Articoli correlati:

1. Arduino Duemilanove: espandere Hello, Blink! con una breadboard
2. Arduino Duemilanove: Hello, Blink!
3. Arduino Duemilanove: inizia l’avventura