Arduino come Crepuscolare

Tempo di Arduino… La saga continua 😀
Questa volta vediamo come utilizzare Arduino come crepuscolare.
In mezzo al disordine e agli scarti di vecchi (parliamo di quando ancora andavo a scuola) esperimenti mi sono trovato una fotoresistenza. Vediamo come utilizzarla con Arduino.
Dal nome capiamo subito che stiamo parlando di qualcosa che ha a che fare con le resistenze, ma questa è una fotoresistenza, quindi diciamo che è una resistenza che cambia il suo valore al variare dell’intensità di luce che la colpisce.
Come gli ultimi articoli anche questo è orientato ad un approccio molto pratico della cosa, quindi non mi dilungo con spiegazioni tecniche e teoriche (anche perchè mi secco e non sarei di certo bravissimo).
Ti mostro un accenno prelevato da internet, e se ti interessa la lettura puoi continuarla su Wikipedia

La fotoresistenza è un componente elettronico la cui resistenza è inversamente proporzionale alla quantità di luce che lo colpisce. Si comporta come un tradizionale resistore, ma il suo valore in ohm diminuisce mano a mano che aumenta l’intensità della luce che la colpisce. Ciò comporta che la corrente elettrica che transita attraverso tale componente è proporzionale all’intensità di una sorgente luminosa. In tale maniera si realizza una sorta di potenziometro attuabile tramite la luce anziché tramite forze meccaniche o segnali elettrici.

Continua su Wikipedia

Torniamo a noi. Il titolo dell’articolo parla di Arduino Crepuscolare. Cos’è il crepuscolare?
Anche qui, brevemente, diciamo che un crepuscolare è un interruttore automatico in grado di attivare impianti di illuminazione al calare della sera. Tra i molteplici utilizzi, il più comune è quello di permettere l’illuminazione automatica di strade, scale, giardini, cortili e chi più ne ha più ne metta.
Quindi! Oltre alla fotoresistenza ci servirà un potenziometro (il mio è da 5.3 Khom circa) un led e naturalmente una scheda Arduino. A dimenticavo il led va in serie ad una resistenza, 100 Hom dovrebbero andar bene.

Schema dei collegamenti

Come mostrato nello schema, quello che si è creato tra fotoresistenza e potenziometro è un partitore di tensione. Questo ci permetterà di modificare il livello di sensibilità del nostro crepuscolare e decidere qual’è il livello di buio che decreterà l’accensione del led.

Il codice

Come sempre il codice è abbastanza commentato e si spiega da solo, se trovi difficoltà utilizza l’area commenti per fare domande.

/*
 * Arduino Crepuscolare
 * Semplice programmino per mostrare come creare un sistema crepuscolare utilizzando Arduino
 *
 * Autore  : Andrea Lombardo
 * Web     : http://www.lombardoandrea.com
 * Post    : http://bit.ly/arduino-crepuscolare
 * Git     : https://github.com/AndreaLombardo/Arduino-Crepuscolare
 */ 

static int sensore_luce = A0; //pin analogico che riceve l'indice di luminosità
static int comando_luce = 13; //pin che comanderà la luce (o sistema di pilotaggio grosso carico)
static int minuti_attesa = 2; //specifica il numero di minuti dopo i quali rieseguire il controllo una volta accesa la luce

static int soglia = 15; //modificare questo valore per definire la soglia dopo la quale verr accesa la luce

unsigned long attesa; //conterra' i minuti di attesa trasformati in millisecondi
int luminosita; // conterra' l'indice di luminosità percepito
boolean luceOn; // conterra' lo stato della luce, true = 1 = accesa, false = 0 = spenta

void setup() {

  //inizializzo comunicazione seriale per mostrare a video quello che stà accadendo
  Serial.begin(9600);

  //definisco la modalità dei pin
  pinMode(comando_luce, OUTPUT);
  pinMode(sensore_luce, INPUT);

  //trasformo i minuti d'attesa in millisecondi da dare in pasto alla funzione delay
  attesa = ((minuti_attesa * 60UL ) * 1000UL);

  //imposto indice di luminosità a 0
  luminosita = 0;

  //di default imposto lo stato della luce = a spento
  luceOn = false;

  //spengo la luce
  digitalWrite(comando_luce, LOW);
}

void loop() {

  //leggo l'indice di luminosità dal pin A0 (sensore_luce)
  luminosita = analogRead(sensore_luce);

  //comunico le info via monitor seriale
  Serial.print("Luminosita' percepita : ");
  Serial.print(luminosita);

  //se l'indice di luminosità è inferiore alla soglia
  if (luminosita < soglia) {
    //accendo la luce
    digitalWrite(comando_luce, HIGH);
    //informo il programma che la luce è accesa
    luceOn = true;
    //informo tramite monitor seriale
    Serial.print(" - Accendo luce e aspetto ");
    Serial.print(minuti_attesa);
    Serial.print(" minuti (");
    Serial.print(attesa);
    Serial.print(" millisecondi) prima di rieseguire il controllo");
    //mi metto in pausa e aspetto che finiscano i minuti_attesa
    delay(attesa);
  } else {
    //se l'indice di luminosità non è inferiore alla soglia, mantengo la luce spenta
    digitalWrite(comando_luce, LOW);
    //informo il programma che la luce è spenta
    luceOn = false;
  }

  //invio le info al monitor seriale
  Serial.print(" - Stato luce : ");
  Serial.println(luceOn);

}

In questo programmino ho utilizzato un sistema di attesa per fare in modo che una volta acceso il led, trascorrano tot minuti prima che Arduino ricontrolli lo stato di luminosità. Questo serve ad evitare che ad un indice di luminosità prossimo alla soglia stabilita, la luce cominci a lampeggiare in stile strobo da discoteca. Altra soluzione sarebbe stata questa:

if (luminosita < (soglia - 5)) && (luminosita > (soglia + 5)) {
  //accendo la luce
  ...
  ...
  resto del codice
}

In questo modo si sarebbe creato un range cuscinetto entro il quale far accendere il led.
Regolando il potenziometro invece è possibile variare la sensibilità del sensore e quindi la soglia d’intervento.
IMPORTANTE dire che in questo esempio è stata sfruttata la funzione delay() per mettere Arduino in pausa prima di rieseguire il controllo della luminosità. Questo va bene se stiamo utilizzando Arduino solo come crepuscolare. Non va invece bene se Arduino deve eseguire altre operazioni. Il metodo delay() infatti, è una cosiddetta blocking function, il che significa che fino a quando non saranno trascorsi il numero di millisecondi impostati come parametro, Arduino rimarrà fermo e non andrà avanti con le istruzioni.
In questo esempio abbiamo acceso un semplice led, ma sostituendo il led con un comando di potenza (magari a transistor) sarà possibile pilotare una lampadina o direttamente un intero impianto di illuminazione.
Detto questo, buon montaggio e buon esperimento!

Come sempre
• Assicurati che tutti i collegamenti siano corretti;
• Ricordati di impostare la porta COM del tuo Arduino;
• Ricordati di impostare lo stesso baud rate del monitor seriale con quello specificato in Serial.begin()
• E ricorda che io non mi assumo nessuna responsabilità per eventuali danni o disastri che causi 😀

A fine articolo trovi il codice da scaricare e un video del montaggio.

Prodotti Amazon

Il mio video

Puoi clonare il progetto direttamente da GitHub!

Approfondimenti

• Serial.begin()
• pinMode()
• digitalWrite()
• delay()
• analogRead()
• Serial.print()
• Serial.println()

• crepuscolare arduino (17)
• crepuscolare con arduino (13)
• arduino crepuscolare (11)
• https://www lombardoandrea com/arduino-crepuscolare/ (1)
• progetti crepuscolare arduino (1)