Centralina alba tramonto arduino sketch – terza parte

Realizzare la centralina alba tramonto arduino sketch completa la prima parte della realizzazione di una centralina per presepe

questo progetto è composto da alcuni articoli che ti accompagneranno per tutto il periodo natalizio.

Ho deciso di dividere il progetto in fasi per due motivi:

1. renderlo più comprensibile dedicando un articolo a ciascuna fase della realizzazione partendo dai principi che mi hanno ispirato;
2. permetterti di realizzare anche solo una parte del progetto e non tutto il progetto.

Nel primo articolo hai letto come puoi ricavare i tempi delle fasi alba-giono-tramonto-notte e come tradurre in tempi per arduino tali fasi.

Nel secondo articolo hai realizzato i collegamenti dei led in cui ciascun led simula una delle fasi del giorno e della notte stellata.

In questo articolo leggerai come da quei tempi ne consegue un grafico dell’andamento delle uscite arduino e quindi lo sketch.

Il grafico della centralina alba tramonto arduino sketch

Inizia subito guardando il grafico:

in cui ciascuna delle 4 fasi si alterna lungo la linea del tempo ( in alto ) in pratica in un ipotetico giorno che inizia dalle 5:54 si susseguono la prima fase di in cui la luna cala ed il sole sorge fino al raggiungimento della sua massima luminosità come alba e da inizio alla seconda fase alle 7:35 per continuare con le fasi successive.

Sulla base di questi tempi, e della tabella che hai già visto nel primo articolo potrai ricavare i tempi in millisecondi di durata delle singole fasi:

Lo sketch della centralina alba tramonto arduno

nello sketch tutta la giornata è riprodotta in un minuto quindi con le fasi che durano rispettivamente:

• 4194 ms per l’alba
• 22958 ms per il giorno
• 4195 ms per il tramonto
• 28651 ms per la notte

Passa allo sketch:

/**********************************************************
 * Centralina Alba-Tramonto per presepe
 *
 * Created on 12 december 2014
 * Modified on 15 decebre 2014
 *
 * by Mauro Alfieri
 * web:    mauroalfieri.it
 * Twitter: @mauroalfieri
/**********************************************************/

#define pin_down   3
#define pin_sun    5
#define pin_sunset 6
#define pin_moon   9
#define pin_starsA 10
#define pin_starsB 11

int oneminrome[4] = { 4194,22958,4195,28651 };
int oneminbtlm[4] = { 3668,25189,3668,27474 };
int timeStepOld = 0;
int timeStep = 0;

long timeCurr = 0;

byte fade[]  = {255,250,245,240,235,230,225,220,215,210,205,200,195,190,185,180,175,170,165,160,155,150,145,140,135,130,125,120,115,110,105,100,95,90,85,80,75,70,65,60,55,50,45,40,35,30,25,20,15,10,5,0}; // 52 step
byte curr   = 0;

void setup() {
  Serial.begin( 9600 );
  
  pinMode( pin_down  ,OUTPUT );
  pinMode( pin_sun   ,OUTPUT );
  pinMode( pin_sunset,OUTPUT );
  pinMode( pin_moon  ,OUTPUT );
  pinMode( pin_starsA,OUTPUT );
  pinMode( pin_starsB,OUTPUT );

  analogWrite( pin_down  ,LOW );
  analogWrite( pin_sun   ,LOW );
  analogWrite( pin_sunset,LOW );
  analogWrite( pin_moon  ,LOW );
  analogWrite( pin_starsA,LOW );
  analogWrite( pin_starsB,LOW );
  
  Serial.println("-- START --");
}

void loop() {
  timeCurr = oneminrome[curr];
  timeStep = (timeCurr/52);

  Serial.print("Current: "); Serial.println(curr);
  Serial.print("Time current: "); Serial.println(timeCurr);
  Serial.print("Time single step: "); Serial.println(timeStep);

  // down 
  if ( curr == 0 ) { 
     Serial.print("Fase: "); Serial.println("DOWN");
     for ( int i=0; i<52; i++) {
       analogWrite(pin_down,   fade[(51-i)]);
       analogWrite(pin_sun,    0 );
       analogWrite(pin_sunset, 0 );
       analogWrite(pin_moon,   fade[i] );
       analogWrite(pin_starsA, fade[i] );
       analogWrite(pin_starsB, fade[i] );
       delay( timeStep );
     }
     timeStepOld = timeStep;
  }

  // sun
  if ( curr == 1 ) {
     Serial.print("Fase: "); Serial.println("SUN");
     for ( int i=0; i<52; i++) {
       analogWrite(pin_down,   fade[i]);
       if ( fade[i] < 125) analogWrite(pin_sun,    fade[(51-i)]*2 );
       analogWrite(pin_sunset, 0 );
       analogWrite(pin_moon,   0 );
       analogWrite(pin_starsA, 0 );
       analogWrite(pin_starsB, 0 );
       delay( timeStepOld );
     }
     timeStepOld = (timeStepOld*52); // elapsed time
     timeCurr = (timeCurr - timeStepOld);
     delay( timeCurr );
  }

  // sunset
  if ( curr == 2 ) {
     Serial.print("Fase: "); Serial.println("SUNSET");
     for ( int i=0; i<52; i++) {
       analogWrite(pin_down,   0);
       analogWrite(pin_sun,    fade[i] );
       analogWrite(pin_sunset, fade[(51-i)] );
       analogWrite(pin_moon,   0 );
       analogWrite(pin_starsA, 0 );
       analogWrite(pin_starsB, 0 );
       delay( timeStep );
     }
     timeStepOld = timeStep;
  }
  
  // moon 
  if ( curr == 3 ) {
     Serial.print("Fase: "); Serial.println("MOON");
     for ( int i=0; i<52; i++) {
       analogWrite(pin_down,   0);
       analogWrite(pin_sun,    0 );
       analogWrite(pin_sunset, fade[i] );
       if ( fade[i] < 125) analogWrite(pin_moon,   fade[(51-i)]*2 );
       if ( fade[i] < 125) analogWrite(pin_starsA, fade[(51-i)]*2 );
       if ( fade[i] < 125) analogWrite(pin_starsB, fade[(51-i)]*2 );
       delay( timeStepOld );      
   }      
   timeStepOld = (timeStepOld*52); // elapsed time      
   timeCurr = (timeCurr - timeStepOld);      
   delay( timeCurr );
  }   
  curr++;
  if ( curr >= 4 ) { curr = 0; }
}

salta le prime linee che sono i commenti di intestazione del progetto e continua con:

linee 012-017: definisci i pin a cui sono collegati i led come hai letto nell’articolo dedicato ai collegamenti;

linee 019-020: sono definiti i due array di valori, uno per Roma ed uno per Betlemme al 25 dicembre 2014. Nel corso dello sketch sceglierai quali tempi utilizzare per il tuo presepe;

linee 021-022: definisci due variabili che userai per scandire i tempi di intervallo di ciascuna fase per ottenere la dissolvenza della fase corrispondente;

linea 024: imposta una variabile con cui terrai in memoria il tempo della fase corrente;

linea 026: definisci un array di 52 valori da 255 a 0 con cui ottenere la dissolvenza di ciascuna fase;

linea 027: definisci una variabile i cui valori andranno da 0 a 3 per indicare in quale fase ti trovi;

linee 034-039: imposta tutti i 6 pin in OUTPUT;

linee 041-046: porta a LOW tutti i pin corrispondenti ai led;

linea 052: in questa linea decidi se utilizzare la durata sulla base del fuso orario di Roma o quelli sul fuso orario di Betlemme. Semplicemente sostituendo il valore di oneminrome con oneminbtlm potrai variare la sequenza di durata tra le singole fasi. Il valore assegnato alla variabile timeCurr è relatico alla fase corrente ( curr ) in questo primo passaggio curr vale 0 e quindi il valore di timeCurr sarà corrispondente al primo valore dell’array oneminrome.

linea 053: dividi il valore di timeCurr per il numero di step in cui l’alba deve sorgere, come puoi vedere nel grafico sopra. Nella fase alba la prima luce dovrà partire da intensità 0 e compiere i 52 passi fino alla luminosità 255;

linea 060: se la fse è la prima ed il valore di curr è 0 esegui le righe seguenti;

linee 062: crea un ciclo di 52 valori ( ciascuno corrispondente ad uno degli indici del fade[] ) in cui l’alba inizia da 0 ed arriva a 255;

linea 063: siccome il valore di fade va da 255 a 0 ed il led dell’alba deve iniziare da 0 ed incrementarsi fino a 255 invertia il contatore i passando alla fade il valore (51-i). Otterrai che quando i = 0 fade[ 51-0 ] = fade[ 51 ] = 0 siccome gli array partono da 0 per cui 52 valori sono 0-51 indici;

linee 064-065: i relativi pin sun e sunset ( giorno e tramonto ) saranno a 0;

linee 066-068: si muovono in parallelo all’alba per ottenere il termine della notte e la fase di alba;

linea 069: il valore di tempo calcolato alla linea 053 lo usi per attendere tra le intensità di illuminazione dei singoli canali in modo che l’effetto finale osservato è una lenta fine della notte che pian piano lascia il posto all’alba;

linea 071: assegna alla variabile timeStepOld il valore di timeStep che userai nelle prossime fasi della centralina alba tramonto arduino sketch per regolare il passaggio dall’alba al giorno ed il passaggio dal tramonto alla notte;

linee 075-089: sono fondamentalmente simili alle linee precedenti se non in alcuni passaggi come ad esempio la linea 079: controllando il valore di fade[i] fino a quando scende sotto il valore 125, ritardi la fase di inizio del giorno e per recuperare questo ritardo moltiplichi per due il valore del fade ottenuto come descritto alla linea 063;

Questa elaborazione della centralina alba tramonto arduino sketch è stato necessario per compensare l’assorbimento contemporaneo da parte dei led bianchi ad alta luminosità che necessitano di più corrente per essere stabili a bassa tensione.

Con una shield ad hoc potrebbe non essere necessario applicare questa modifica software, dipende dal tipo di shield che sceglierai.

linea 086: moltiplica il valore di timeStepOld per 52 ( gli step del fade ) per conosce il valore totale trascorso nel realizzare tutti gli step del fade, questo calcolo ti serve per la linea 087;

linea 087: sottrai dal valore di timeCurr il tempo  timeStepOld appena calcolato, in questo modo sai quanto tempo deve ancora durare la fase corrente;

linea 088: attendi il passaggio del tempo fino al terine della fase;

linee 092-121: sono identiche alle precedenti linee e si preoccupano di gestire la fase di tramonto, simile a quella di alba e la fase notturna;

linea 122: incrementa il valore di curr in modo da procedere con le fasi successive;

linea 123: controlla che il valore di curr non superi il 3 e nel caso arrivi a 4 lo riporta a 0 per far iniziare nuovemente il ciclo alba-giorno-tramonto-notte;

Il video della centralina alba tramonto arduino sketch

Puoi osservare il video della centralina in funzione in due cicli successivi dall’alba alla notte:

Buon Natale !!