
Realizzare un impianto crepuscolare è molto semplice con Arduino. Un sensore di luminosità, dei led ed il software, rigorosamente Open source, per Arduino.
Come tutti ormai ben sapete, e come molti di noi condividono, la filosofia dell'open source è alla base di ogni mia considerazione e siccome sono affascinato dalla potenza e dalla bellezza del concetto stesso di condivisione mi sono affacciato, con grande entusiasmo, al mondo di Arduino.
Un esame all'università ha rappresentato lo stimolo decisivo a fare l'acquisto che, finora, si sta rivelando la spesa più riuscita e stimolante che io abbia fatto.
Per il momento, però, voglio descrivere ciò che s è proposto come semplice obiettivo hobbistico, ovvero creare un sensore di luminosità che pilotasse, almeno in miniatura, un impianto crepuscolare da semplice neofita.
Vi racconterò, quindi, la genesi del progetto.
L'idea, quando ho deciso di fare l'acquisto, era quella di procurarmi l'occorrente per completare il dispositivo.
Lo Store di Arduino è molto molto ben fornito e tra le mille possibilità offerte, c'è lo Starter Kit, un piccolo set di strumenti e dispositivi molto semplice in cui ci sono resistenze, condensatori, pulsanti vari e poi semplici fili, reostati... Insomma, un po' di tutto.
Una volta ricevuto il pacco, arrivato in tempi molto celeri, ho iniziato a provare e sperimentare.
Avevo già letto che i codici di Arduino si chiamano sketch, che il linguaggio di programmazione era da imparare ex novo, che c'era una grande community molto attiva, che c'era tanto da poter imparare, che c'erano tanti progetti già svolti, spiegati e commentati, che su you-tube si trovano dimostrazioni di progetti funzionanti... insomma, mi ero documentato su quanto successo e quali risultati arduino avesse ottenuto.
Le informazioni raccolte avevano portato a farmi un'idea, poi confermata, che il modo giusto per spiegare i che si tratta è “Arduino is not for quitters”. Grandi potenzialità, dunque, ma, come ogni progetto Open Source, alta richiesta di impegno da parte di chi lo usa... Come è giusto che sia!

Appena collegato Arduino al pc, ho avuto il mio primo problema: Arduino e il pc non comunicano! Ho iniziato compilando e facendo l'upload di uno sketch predefinito, uno degli esempi preconfezionati ma... Arduino si bloccava, il programma andava in crash e non ne venivo a capo. Mi sono collegato sul sito ed ho capito immediatamente che il problema era relativo all'uso delle porte COM, alla politica di assegnazione degli slot e che Arduino andava in conflitto con il Bluetooth del mio pc, il cui modulo di comunicazione è esterno e USB.
Così, una scheda di prototipazione esterna mi ha insegnato che la gestione degli indirizzi di comunicazione e dei protocolli non deve in alcun modo essere lasciata nella manie del sistema operativo e che certe cose devo tenerle sotto occhio io in prima persona. 🙂
Appresa questa importante lezione, sono andato avanti ed ho iniziato ad occuparmi di capire come funzionassero gli ingressi, le uscite, l'alimentazione e dopo una ventina di minuti di studio sulla scheda, ho iniziato a fare i collegamenti per creare un semplice sensore di luce con l'LDR incluso nella scatola ed un LED.
Dopo aver creato il primo sketch e la prima configurazione funzionante, ho deciso di migliorare questo prototipo ed ho immaginato un sensore di luminosità con 3 gradi di “sensibilità” che accendesse altrettanti LED a seconda della luce presente.
Ed è proprio questo progetto che ora descriverò.
Sulla board Arduino, ci sono due file di pin ai lati. Guardando Arduino dal lato della porta USB, ci sono sulla sinistra 13 ingressi digitali (che generalmente vengono usati come uscite) e sulla destra quelli analogiche (che di solito fungono da ingressi).
Accanto ai pin analogici, poi, ce ne sono alcuni contrassegnati come "power", tra i quali c'è il punto a 5V e GND.
Per realizzare il crepuscolare si proceda come segue:
- prendendo due fili e portando i 5V e GND su un pad della breadboard compresa nello starter kit. (Il consiglio che do, quando si lavora su breadboard, è di usare sempre le "colonne" + e - per questo passaggio. Si arriva fin troppo presto a scoprire che l'ordine è fondamentale!!!)
- attaccando l'LDR ai 5V e connettendo l'altro pin ad un'altra fila, che va all'ingresso A0.
- la resistenza va connessa tra il secondo pin dell'LDR e GND (per questa esperienza io ho usato una resistenza da 22kOhm.)
- ora vanno collegati i LED. Vengono usati i connettori delle linee digitali numeri 13, 12 e 11. Ciascuno dei led va connesso tra linea di riferimento e GND.
Ora veniamo al codice, vero cuore del crepuscolare. Lo sketch è il seguente:
// Sensore di luminosità versione con 3 LED
int ledPin1 = 13; // Dichiaro il LED sull'uscita digitale 13
int ledPin2 = 12; // Dichiaro un secondo LED sull'uscita digitale 12
int ledPin3 = 11; // Dichiaro un terzo LED sull'uscita digitale 11
int sensore = 0; // Dichiaro l'LRD su ingresso analogico 0
int val; // dichiaro una variabile di appoggio
void setup()
{
Serial.begin(9600); //apro la porta seriale per mettere in comunicazione il circuito col pc Il baudrate è fisso a 9600 bits per secondo
pinMode(ledPin1, OUTPUT); // imposto il LED1 come uscita
pinMode(ledPin2, OUTPUT); // imposto il LED2 come uscita
pinMode(ledPin3, OUTPUT); // imposto il LED3 come uscita
}
void loop()
{
val = analogRead(sensore); // leggo i valori associati al sensore
Serial.println(val); // scrivo i valori letti del sensore nella variabile val
int range=val/4; // ricavo il valore di val modulo 4
delay(10); // effettuo la lettura ogni centesimo di secondo
switch (range) {
case 0: // tutti i LED sono accesi => luminosità nulla
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, HIGH);
break;
case 1: //due LED su 3 sono accesi => luce scarsa
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, HIGH);
digitalWrite(ledPin3, LOW);
break;
case 2: //2 LED su 3 sono spenti => luce moderata
digitalWrite(ledPin1, HIGH);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
break;
case 3: //tutti i LED sono spenti => luce naturale
digitalWrite(ledPin1, LOW);
digitalWrite(ledPin2, LOW);
digitalWrite(ledPin3, LOW);
break;
}
}

Visto che il codice è commentato, non ho molto altro da dire 🙂
Solo un piccolo appunto: il controllo sull'intensità luminosa scandito ogni centesimo di secondo non è affatto necessario! Lo si può comunque fare ogni decimo di secondo. Questo diminuisce la frequenza delle interrogazioni e libera il bus di comunicazione. Ovvio è che, in questa applicazione specifica questo non ha granché importanza ma se si utilizza la scheda per progetti più “corposi” anche questo aspetto va tenuto in conto.
Progetto crepuscolare, in conclusione:
Arduino è una scheda semplice, efficiente, funzionale e divertente. Rende l'elettronica e la programmazione appetibili e fruibili anche a chi non ha competenze specifiche e la sua versatilità è garanzia di efficienza.
Il costo contenuto, la facilità di interfacciamento e la varietà delle applicazioni a cui può esser riferita, fanno di questa scheda un utilissimo supporto.

Serial.println(val); // scrivo i valori letti del sensore nella variabile val
println() è una funzione che scrive SULLA seriale in testo ASCII (con il ritorno a capo, ovvero carriage return). essendo la seriale collegata al computer (tramite usb), dall’ide di arduino è possibile leggere, tramite il “serial monitor”, il valore della variabile val.
in realtà penso che Piero l’abbia implementato per scopi di debug/didattici, perchè ovviamente non è utile al programma in versione finale.
int range=val/4; // ricavo il valore di val modulo 4
questa non l’ho capita bene neanche io… soprattutto dov’è il modulo?
Avete ragione, scusate.
Ho commesso un errore nella correzione del codice…
Il modulo qui non c’entra nulla…!
La riga corretta è
int rage=val;
Una versione precedente del codice prevedeva l’uso del modulo ma l’avevo commentato e lasciato nel testo. Ho solo cancellato la riga di testo sbagliata 🙂
Per quanto riguarda, invece, il comando Serial.println(val), ciò che dice gabri è giusto.
Il comando è virtualmente inutile.
Mi è servito solo per far pratica, fare debug e imparare ad usare le funzioni, le chiamate…insomma, prendere dimestichezza. 🙂
Uffaaaaaaaaaaaa….
Mannaggia alla fretta mannaggia…
Scusate ancora…
Ovviamente la riga è:
int range=val;
rage non c’entra nulla.. 🙂
Per mera ragione di cronaca, per completezza e correttezza, siccome anche quella riga è sbagliata in ogni caso, parliamo della funzione modulo 🙂
La funzione modulo, come tutti sappiamo, calcola il resto della divisione quando un numero intero viene diviso per un altro numero intero. Quando questi due non sono multipli l’uno dell’altro, la divisone da resto.
La sintassi corretta in arduino è:
risultato = dividendo % divisore
Così, risultato sarà proprio il resto. 🙂
Dici che ho sparato ad una mosca col fucile? 🙂
Tieni presente che si trattava di una prima prova appena aperta la confezione…
Presto, anche se non so dire quanto, pubblicherò altri progetti decisamente più “nobili” 🙂
Alla fine ha avuto ragione Piero ad “abbondare”, infatti ecco le prime richieste di modifiche che senza un microcontrollore non sarebbe cosi semplice attuare…..
1) per attivare una luce da giardino, presuppongo a 230Vac, devi gestire un relè a 230Vac sui contatti. Quindi l’uscita digitale deve pilotare un transistor che a sua volta comanda la bobina del relè che accenderà le luci.
2) potresti usare un sensore infrarosso che tramite il suo relè di uscita potresti collegare direttamente ad un ingresso digitale di Arduino. Monitorando questo pin o gestendolo in OR con il crepuscolare potresti attivare l’uscita rele di potenza di cui sopra.
vorrei realizzare un sistema simile per il mio pannello FV, ma si tratta di una cosa molto più complicata.
sto cercando inline un tutorial per realizzare un efficente sistema per l’inseguimento solare, tipo girasoli voi sapete dove trovo del materiale???
cordiali saluti
manuel
Salve a tutti! Se invece volessi aumentare o diminuire l’intensità luminosa dei led all’aumentare o al diminuire della luce esterna in maniera graduale??