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.
Ormai da tempo che svolgo i mie corsi su Arduino e gli allievi stanno diventando sempre pi esigenti. Mi accorgo che andando avanti con le lezioni, gli allievi hanno l’esigenza, legittime, di realizzare esperienze di laboratorio sempre pi attinenti al mondo reale che loro conoscono. Qualche anno fa era sufficiente mostrare come era semplice variare il colore di un diodo led RGB per avere interesse ed attenzione duratura, ci mi permetteva di conseguenza di dettagliare alcuni aspetti di programmazione che se non spiegati con Arduino sarebbero risultati pi difficili da comprendere, ma ora per mantenere lo stesso livello di attenzione necessario aggiungere altri elementi di sensibilizzazione.
Maggiori pretese e quindi fin dalle prime lezioni si vuole “la sorpresa tecnologica”…
mamma mia quanto faticoso fare l’insegnante!
Sono in quel periodo del corso in cui si accendono il led con Arduino in tutte le maniere possibili, dal blink al fade, in sequenza e in molti altri modi, ma alla lunga, mi rendo conto, la cosa pu diventare un po’ “noiosetta”, vorrei evitare il pi possibile l’effetto “sbadiglio” 🙂 e quindi ho pensato di modificare le prime esperienze con qualcosa di pi coreografico.
Tutto nasce da alcune idee che ho sulla realizzazione di una struttura semplificata (ad incastro) per la realizzazione di un kit robotico basato su Arduino da usare a scuola e da realizzare con materiali di basso costo di facile reperibilit, sto costruendo alcuni prototipi usando il plexiglass.
E proprio mentre manipolavo il plexiglass ho avuto l’idea di utilizzare questo materiale per nuove esperienze che fanno uso di led.
Ho voluto condividere questa bozza di lezione con voi in modo che se vorrete potrete darmi suggerimenti o alternative che potranno essere in futuro sfruttate a scuola.
Tutti sapete che quando la luce passa attraverso due materiali diversi, come tra l’aria e l’acqua oppure tra l’aria e la plastica, subisce rifrazione, effetto tipico che potete notare quando ad esempio mettete una cannuccia in un bicchiere d’acqua, si nota che la cannuccia nell’acqua sembra piegata.
Sfruttiamo questo fenomeno per far cambiare direzione alla luce che attraversa uno strato di plexiglass e la variazione di percorso della luce viene realizzata incidendo (graffiando) la superficie di plastica, cos facendo i raggi luminosi prodotti da diodi led che colpiscono la zona incisa si rifletteranno (cambiano direzione) provocando un effetto visivo molto bello.
Poich siamo in periodo natalizio l’idea potrebbe essere quella di realizzare una piccola insegna su cui scrivere “Buone Feste” facendo variare il suo colore in maniera ciclica.
Scopo dell’esperienza:
reciclando materiali di uso comune reperibili a scuola, realizzare un’insegna luminosa che auguri “Buone Feste” ai visitatori della scuola.
Tempo di realizzazione 3 ore (max).
Materiali:
plexiglass (misure a piacere nel mio caso inferiori alla lunghezza massima di una breadboard)
piccolo trapano con punta per incisione
breadboard
Arduino UNO
2 diodi RGB (nel mio caso ad anodo comune)
4 resistenze da 82 ohm
2 resistenze da 150 ohm
porta diodi (per evitare la saldatura diretta su millefori dei LED)
millefori
mammut (usati come supporto a scorrimento – vedi foto)
pezzi metallici per blocco insegna (ho usato delle punte da saldatore)
Vi state chiedendo perch ho usato i mammut e le punte da saldatore?
Perch nel magazzino della scuola ho trovato una scorta infinita e quindi mi sembrava uno spreco non usarli 🙂
Nella precedente lezione abbiamo visto come progettare un controllo presenza in due stanze adiacenti in cui abbiamo utilizzato due pulsanti per simulare due sensori PIR (uno per ogni stanza) e due led per simulare l’accensione delle lampade nelle due stanze.
L’ultimo sketch consentiva di silmulare la seguente situazione per entrambe le stanze:
entro nella stanza
PIR avverte la mia presenza
si accende la luce
ritardo lo spegnimento della luce per darmi il tempo di uscire dalla stanza
In questa e nella successiva lezione vorrei giungere alla realizzazione di un comportamento più vicino alla realtà:
entro nella stanza
PIR avverte la mia presenza
si accende in fade la luce
esco dalla stanza
il PIR non rileva più la mia presenza
si spegne in fade la luce
Suddivido la soluzione del problema in due sottoproblemi che risolverò in questa e nella successiva lezione:
funzione fade
funzione controllo presenza
Realizziamo la funzione fade
Se ricordate nella lezione 2 abbiamo realizzato il famoso “blink” lo sketch che accendeva e spegneva in modo continuativo un LED.
Realizziamo nuovamente il circuito ed eseguite lo sketch allegato:
// Esempio 01: fare lampeggiare un LED
#define LED 13 // LED collegato al pin digitale 13
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
digitalWrite(LED, HIGH); // accende il LED
delay(1000); // aspetta 1 secondo
digitalWrite(LED, LOW); // spegne il LED
delay(1000); // aspetta 1 secondo
}
Provate a ridurre drasticamente il ritardo di accensione e spegnimento, arrivate a 10 millisecondi, quasi non dovreste più pecepire lampeggiare il LED e inoltre dovreste aver notato che la luminosità del LED è diminuita.
// Esempio 02: modulazione di larghezza di impulso (PWM)
#define LED 13 // LED collegato al pin digitale 13
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
digitalWrite(LED, HIGH); // accende il LED
delay(10); // aspetta 10 millisecondi
digitalWrite(LED, LOW); // spegne il LED
delay(10); // aspetta 10 millisecondi
}
Il motivo per cui si vede illuminare di meno il diodo LED è dovuta alla modulazione di larghezza di impulso in inglese Pulse Width Modulation – PWM, che detta in modo meno tecnico vuol dire che se facciamo lampeggiare un diodo LED ad una frequenza sufficientemente elevata e se cambiamo il rapporto tra il tempo in cui sta acceso ed il tempo in cui sta spento, il nostro occhio non percepirà il lampeggiare del LED ed inoltre a secondo del rapporto del tempo di accensione e spegnimento potremo regolare la luminosità del LED.
Possiamo dire che il PWM è una tecnica per ottenere risultati analogici con mezzi digitali.
Un po’ di teoria: il Duty cycle
Il duty cycle di un onda quadra/rettangolare e il rapporto tra la durata (in secondi) del segnale quando è “alto” ed il periodo totale del segnale. In altre parole è un numero che esprime quant’è la parte di periodo in cui il segnale è alto.
Facendo riferimento al disegno la formula che esprime il duty cycle è:
τ/T
dove T è il periodo e τ la parte di periodo in cui il segnale è alto.
Dalla formula potete subito notare che τ può variare da un valore minimo di 0 a un valore massimo pari a T, ciò implica che il valore del duty cycle varia da 0 a 1:
in entrambi i casi siamo in presenza di segnali continui.
Dalla formula possiamo comprendere quindi che il duty cycle è sempre un valore che varia tra 0 e 1.
Il duty cycle è spesso rappresentato in percentuale, D% e per ottenere la percentuale è sufficiente moltiplicare per 100 il rapporto τ/T, dire quindi che il D%=30% vuol dire che per il 30% del periodo totale il segnale si trova a livello alto, come conseguenza possiamo subito dire che il segnale sarà a livello basso per il restante 70% del periodo.
Dire quindi che il duty cycle è del 50% vuol dire che nel periodo T il segnale si mantiene alto per T/2 e per il restante T/2 a livello basso in questo caso siamo quindi in presenza di un’onda quadra.
Passiamo ora alla pratica
Poniamoci nelle seguenti 3 condizioni:
50% LED acceso e 50% LED spento
luminosità al 50%
25% LED acceso e 75% LED spento
luminosità al 25%
75% LED acceso e 25% LED spento
luminosità al 75%
Per realizzare le tre condizioni impostate scegliamo un periodo sufficientemente breve tale da non percepire il lampeggiare del LED:
Poniamo un periodo T = 20ms
10ms acceso e 10ms spento
5 ms acceso e 15ms spento
75 ms acceso e 5ms spento
// Esempio 03: modulazione di larghezza di impulso (PWM) - on: 10ms - off: 10ms
#define LED 13 // LED collegato al pin digitale 13
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
digitalWrite(LED, HIGH); // accende il LED
delay(10); // aspetta 10 millisecondi
digitalWrite(LED, LOW); // spegne il LED
delay(10); // aspetta 10 millisecondi
}
// Esempio 04: modulazione di larghezza di impulso (PWM) - on: 5ms - off: 15ms
#define LED 13 // LED collegato al pin digitale 13
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
digitalWrite(LED, HIGH); // accende il LED
delay(5); // aspetta 5 millisecondi
digitalWrite(LED, LOW); // spegne il LED
delay(15); // aspetta 15 millisecondi
}
// Esempio 05: modulazione di larghezza di impulso (PWM) - on: 15ms - off: 5ms
#define LED 13 // LED collegato al pin digitale 13
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
digitalWrite(LED, HIGH); // accende il LED
delay(15); // aspetta 15 millisecondi
digitalWrite(LED, LOW); // spegne il LED
delay(5); // aspetta 5 millisecondi
}
Dal filmato potete notare la variazione di luminosità nelle tre condizioni:
Con un po’ di esperimenti noterete che la tecnica di variazione della luminosità, utilizzando il ritardo “delay()”, non è il metodo migliore in quanto, non appena inseite altri sensori ad Arduino, oppure inviate dei dati alla seriale, il LED tremolerà nell’attesa che termini la lettura del sensore o la scrittura sulla seriale.
Come evitare questo problema?
Arduino UNO offre la possibilità di usare i pin 3, 5, 6, 9, 10, 11 l’istruzione: analogWrite(), istruzione che consente appunto di far lampeggiare il LED o governare un motore elettrico mentre lo sketch esegue altre istruzioni.
Sintassi:
analogWrite(pin, valore)
dove:
pin: è il piedino su cui inviamo il segnale, per Arduino UNO i pin 3, 5, 6, 9, 10, 11
valore: è il duty cycle compreso tra 0 (sempre off) a 255 (sempre on)
La funzione non restituisce nessun valore.
Quindi se utilizziamo la funzione analogWrite() per il controllo della luminosità del LED e scriviamo:
analogWrite(11, 0)
il LED collegato al pin 11 avrà una luminosità dello 0% (duty cycle 0%)
// Esempio 06: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 0%)
#define LED 11 // LED collegato al pin digitale 11
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
analogWrite(LED, 0); // accende il LED
}
analogWrite(11, 64)
il LED collegato al pin 11 avrà una luminosità del 25% (duty cycle 25%)
// Esempio 07: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 25%)
#define LED 11 // LED collegato al pin digitale 11
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
analogWrite(LED, 64); // accende il LED
}
analogWrite(11, 128)
il LED collegato al pin 11 avrà una luminosità del 50% (duty cycle 50%)
// Esempio 08: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 50%)
#define LED 11 // LED collegato al pin digitale 11
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
analogWrite(LED, 128); // accende il LED
}
analogWrite(11, 191)
il LED collegato al pin 11 avrà una luminosità del 75% (duty cycle 75%)
// Esempio 09: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 75%)
#define LED 11 // LED collegato al pin digitale 11
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
analogWrite(LED, 191); // accende il LED
}
analogWrite(11, 255)
il LED collegato al pin 11 avrà una luminosità del 100% (duty cycle 100%)
// Esempio 10: utilizzo della funzione analgoWrite() - LED spento - (duty cycle 100%)
#define LED 11 // LED collegato al pin digitale 11
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
analogWrite(LED, 255); // accende il LED
}
Nel filmato allegato potete notare la differenza di luminosità nelle 5 condizioni sopra illustrate.
Imparato come variare la luminosità del LED usando la funzione analogWrite(), vediamo come realizzare il fade del LED ovvero l’accensione e lo spegnimento graduale, attenzione che questo modo di procedere sarà utile anche quando dovremo imparare a variare la velocità di un motorino elettrico.
Lo schetch che vi allego è già presente negli esempi disponibili dal menù: File -> Examples -> 3.Analog -> Fading ne ho variato alcune parti:
// Esempio 11: Fading
#define LED 11 // LED collegato al pin digitale 11
int valoreFade = 0; // variabile usata per contare in avanti e indietro
void setup() {
pinMode(LED, OUTPUT); // imposta il pin digitale come output
}
void loop() {
// procede ciclicamente da 0 a 254 (fade in -> aumento luminosità)
for (valoreFade = 0 ; valoreFade < 255; valoreFade++) { analogWrite(LED, valoreFade); //impostiamo la luminosità del LED delay(10); // aspettiamo 10ms per percepire la viariazione di luminosità, //perché analogWrite è istantaneo } // procede ciclicamente da 255 a 1 (fade out -> diminuzione della luminosità)
for(valoreFade = 255 ; valoreFade > 0; valoreFade--) {
analogWrite(LED, valoreFade); //impostiamo la luminosità del LED
delay(10);
// aspettiamo 10ms per percepire la viariazione di luminosità,
//perché analogWrite è istantaneo
}
}
Analizzaimo il codice.
Prendiamo in analisi la prima parte del loop(). All’interno troviamo un primo ciclo for:
...
// procede ciclicamente da 0 a 254 (fade in -> aumento luminosità)
for (valoreFade = 0 ; valoreFade < 255; valoreFade++) {
analogWrite(LED, valoreFade); //impostiamo la luminosità del LED
delay(10);
// aspettiamo 10ms per percepire la viariazione di luminosità,
//perché analogWrite è istantaneo
}
...
Ad ogni ciclo incrementiamo la variabile valoreFade di 1 (valoreFade++) partendo da 0 fino a 254. valoreFade viene utilizzata in analogWrite(LED, valoreFade) per variare il valore del duty cycle ed incrementare la luminosità del LED. Poichè l’azione di analogWrite(LED, valoreFade) è immediata per percepire visivamente la variazione di luminosità introduciamo un piccolo ritardo di 10ms con delay(10). Il ciclo terminerà non appena la condizione valoreFade < 255 non è più vera, cioè valoreFade non più minore di 255.
Il secondo ciclo for consente di diminuire la luminosità:
...
// procede ciclicamente da 255 a 1 (fade out -> diminuzione della luminosità)
for(valoreFade = 255 ; valoreFade > 0; valoreFade--) {
analogWrite(LED, valoreFade); //impostiamo la luminosità del LED
delay(10);
// aspettiamo 10ms per percepire la viariazione di luminosità,
//perché analogWrite è istantaneo
}
...
Ad ogni ciclo la variabie valoreFade viene decrementata di 1 (valoreFade–) facendo decrescere valoreFade da 255 a 1 e di conseguenza la luminosità del LED. Il ciclo terminerà quando la condizione valoreFade > 0 non è più vera.
Usciti da questo secondo ciclo si ripartirà con il primo ciclo for che permetterà nuovamente l’aumento della luminosità del LED.
Nella prossima lezione vedreme come interagire mediante pulsanti sull’intensità luminosità del LED.
In questa lezione vi mostrerò come utilizzare il sensore luminoso: LilyPad Light Sensor acquistato presso SparkFun.
Passo 1
Come per le lezioni precedenti utilizziamo un cartocino di forma circolare per proteggere il circuito e per aumentare la presa dei morsetti a coccodrillo.
Passo 2
Collegate come rappresentato nell’immagine il + del sensore luminoso a al + di LilyPad, il – del sensore luminoso al – di LilyPad e il piedino S del sensore al piedino A0 di LilyPad:
Passo 3
Avviate l’IDE Arduino
Passo 4
Copiate il codice allegato all’interno di una nuova finestra dell’IDE.
/* Arduino LilyPad: lezione 05: sensore di luce
* Uso del modulo LilyPad Light Sensor
* Michele Maffucci
* https://www.maffucci.it/
* Progetto originale:
* http://web.media.mit.edu/~leah/LilyPad/08_sensors.html
*/
int ledPin = 13; // il LED e' collegato al pin digitale 13
int sensorPin = 0; // il sensore di luce e connesso al piedino analogico 0
int sensorValue; // variabile per memorizzare il valore rilevato dal sensore
void setup()
{
pinMode(ledPin, OUTPUT); // imposta ledPin come pin di output
Serial.begin(9600); //inizializza la porta seriale
digitalWrite(ledPin, HIGH); // accende il LED
}
void loop()
{
sensorValue = analogRead(sensorPin); // legge il valore dal sensore
Serial.println(sensorValue); // invia il valore al computer
delay(100); // ritardo di 1/10 di secondo
}
Passo 5
Chiarimenti sul codice.
Vi ricordo che con l’istruzione:
Serial.begin(9600);
apriamo la porta seriale USB e la inizializziamo a 9600 bps.
delay() è un’istruzione molto semplice che non fa altro che interrompere per un determinato tempo l’esecuzione del programma.
L’istruzione ha un solo argomento numerico che indica il numero di millisecondi di attesa.
Quindi “delay(100)” vuol dire 100 millisecondi,
cioè 100/1000 secondi
ovvero 1/10 di secondo.
Passo 6
Compilate il codice ed effettuate l’upload su LilyPad, aprite la console di uscita:
Non appena il LED si accende su LilyPad, si vedranno i valori del sensore comparire nella console di uscita e l’intervallo di valori oscillerà tra 0 (buio assoluto) a 1024 (luce piena):
