Controllo Luci del Plastico di Carnate con Arduino & Processing

Edgardo Rosatti   marzo 23, 2016   Commenti disabilitati su Controllo Luci del Plastico di Carnate con Arduino & Processing
Print Friendly, PDF & Email
2012929202853_Carnate

Fotografia di Stefano Cremonesi

Il plastico di Carnate Usmate sul sito del GAS TT

In questo articolo verrà spiegato come realizzare un sistema completamente automatico di illuminazione a led per plastici ferroviari utilizzando la piattaforma Arduino UNO e l’ambiente di sviluppo Processing. L’idea è nata quando il Gruppo Appassionati Scala TT ha deciso di realizzare un plastico sociale da esporre in occasione di fiere e manifestazioni del settore.

L’illuminazione è parte fondamentale della scenografia!

Il plastico in oggetto ha le dimensioni di 150 x 100 centimetri circa ed il suo esercizio ferroviario è quasi completamente automatico. Inoltre riproduce fedelmente il fabbricato viaggiatori della stazione ferroviaria di Carnate Usmate. L’impianto di illuminazione è dotato di circa 340 diodi led gestiti in modo completamente automatico da una scheda Arduino UNO in grado di generare l’effetto di alba e tramonto e di illuminare in sequenza fabbricati e strade, il tutto sincronizzato in una linea temporale simulata di 24 ore.

La parte elettrica del sistema è composta da tre schede (shield) descritte di seguito:

  • Arduino UNO
  • RGB
  • Luci Carnate
Carnat1

Arduino UNO, RGB e Luci Carnate

Partendo da sinistra possiamo vedere lo shield Arduino UNO, lo shield RGB e lo shield Luci Carnate. Arduino UNO è il “cervello” che si occupa della gestione automatica per l’accensione e lo spegnimento delle luci tramite un programma che vedremo in seguito. Arduino può essere anche programmato tramite Processing per consentire all’utente un controllo diretto in tempo reale con interfaccia grafica tramite un comune personal computer.

RGB è una scheda di potenza che consente di pilotare una striscia led RGB tramite Arduino ed è in grado di regolare la luminosità dei tre canali colore; rosso, verde e blu. Per questa applicazione, la scheda gestirà una striscia di 300 led di colore bianco e verrà utilizzato solo uno de tre canali disponibili per illuminare lo sfondo del plastico.

Carnat2

Gli shield assemblati tramite strip

Lo shield Luci Carnate:

Luci Carnate è la terza ed ultima scheda usata in questo progetto e deve essere auto costruita. La scheda consente di gestire 11 canali per illuminare i caseggiati e strade del plastico.

Layout:

Layout

Layout

PCB:

Carnat4

Circuito stampato

Questa scheda consente di gestire una serie di led per un carico massimo di 100 milliAmpere sulle porte di Arduino numero 2, 3, 4, 5, 7, 8, 9, 10, 11, 12 e 13.

La porta numero 6 è dedicata allo shield RGB che controlla in PWM l’illuminazione del fondale tramite lo shield RGB per un carico massimo di 5 Ampere in grado di pilotare una striscia da 300 led di colore bianco.

IMG_20150912_215940

Shield Luci Carnate assemblato visto da sopra

IMG_20150912_215959

Shield Luci Carnate visto da sotto

Schema elettrico dello shield Luci Carnate:

La scheda Luci Carnate è formata da 11 circuiti che si ripetono e che sono collegati alle 11 uscite di Arduino citate sopra.

Schema elettrico di un canale

Nello schema, uno degli 11 canali dello shield.

Ogni uscita di Arduino è collegata alla base del transistor NPN BC547, il quale una volta polarizzato accende il led di monitor collegato tra la resistenza da 1000 OHM ed il suo collettore. I led del plastico andranno collegati all’uscita OUT del circuito. Con questo tipo di transistor possiamo collegare un carico massimo di circa 100 milliAmpere, quindi non più di 2 o 3 led contemporaneamente. Il transistor BC547 è quindi indicato per l’illuminazione di un edificio o di un paio di lampioni al massimo.

E’ possibile aumentare l’erogazione di corrente del canale sostituendo il transistor BC547 con uno di tipo darlington come il BC517 che è in grado di sopportare correnti di circa 1 Ampere. In questo modo si potrà collegare all’uscita un numero maggiore di led per illuminare ad esempio una serie di lampioni di una strada.

Gli shield RGB e Luci Carnate devono essere alimentati separatamente a 12 Volt in CC tramite un alimentatore di potenza che fornisca almeno 3-5 Ampere di corrente. Arduino verrà alimentato con un alimentatore dedicato da 7-8 Volt in CC oppure tramite porta USB collegata al PC a 5 Volt.

Schema a blocchi

Carnat6

Schema a blocchi

In questa immagine è raffigurato lo schema a blocchi di tutto il sistema. Nella parte alta, la morsettiera consente di collegare tutti i fili per alimentare le luci del plastico relative ai fabbricati ed ai lampioni delle strade. In verde le uscite da Arduino tramite gli shield RGB e Luci Carnate, in rosso l’alimentazione di potenza a 12 Volt CC. L’alimentatore di potenza in rosa fornisce corrente agli shield e 7/8 Volt in CC ad Arduino in azzurro e 12 Volt in CC per i led in rosso. USB è il network col PC per la sua programmazione o gestione tramite Processing.

Software:

I programmi scritti per questa applicazione sono tre, uno è scritto con l’IDE di Arduino e serve per la gestione automatica di tutto l’impianto. Gli altri due sono scritti usando Processing, usare i link a fine pagina per provare i demo funzionanti.

Carnate_serial è un programma scritto con l’IDE di Arduino e consente di comandare in automatico tutte le luci del plastico tramite gli shield descritti sopra.

/* ILLUMINAZIONE DEL PLASTICO DI CARNATE GAS-TT 2012 - EDGARDO ROSATTI */
 
/* definizione delle variabili globali */
int digital2=2;       // pin 2 digitale
int analog3=3;        // pin 3 analogico
int digital4=4;       // pin4 digitale
int analog5=5;        // pin 5 analogico
int analog6=6;        // pin 6 analogico
int digital7=7;       // pin 7 digitale
int digital8=8;       // pin 8 digitale
int analog9=9;        // pin 9 analogico
int analog10=10;      // pin 10 analogico
int analog11=11;      // pin 11 analogico
int digital12=12;     // pin 12 digitale
int digital13=13;     // pin 13 digitale
int vel=500;          // la velocità di transizione dei cicli, questa variabile determina il tempo virtuale
int passo=1;          // passo di incremento del ciclo
 
/* Procedura di setup, tutti i pin dal 13 al 2 vengono settati in OUT*/
void setup() {
  pinMode(digital2,OUTPUT);   // luce al neon
  pinMode(analog3,OUTPUT);    // stazione 1
  pinMode(digital4,OUTPUT);   // stazione 2
  pinMode(analog5,OUTPUT);    // stazione 3
  pinMode(analog6,OUTPUT);    // Luce del fondale analogica (il sole)
  pinMode(digital7,OUTPUT);   // Villette 2
  pinMode(digital8,OUTPUT);   // Villette 1
  pinMode(analog9,OUTPUT);    // stazione 4
  pinMode(analog10,OUTPUT);   // Parcheggio
  pinMode(analog11,OUTPUT);   // Viale stazione
  pinMode(digital12,OUTPUT);  // Lampioni salita
  pinMode(digital13,OUTPUT);  // Luce lampione tangenziale
  Serial.begin(9600);         // configuro la porta seriale a 9600 baud
}
 
/* Procedura di loop */
void loop() {            // inizio del ciclo a mezzogiorno
Serial.println();
Serial.println("Sono le ore 12:00");
  for(float L=0;L<128;L+=passo)  {  // verso il tramonto
    float N=128+127*cos(L/128*PI);   // funzione trigonometrica di un andamento cosinuoidale del ciclo
    int X=L;
    Serial.print("Livello di X:");Serial.print(X);Serial.println(" ciclo");
    Serial.print("Tramonto:");Serial.print(N);Serial.println(" dimmeraggio della striscia led");
    analogWrite(analog6,N);      // tramonta il sole; attivazione del led blu porta 6 analogica
    if (X==113)  {
    analogWrite (analog9,255);
    Serial.println("Accende la luce 9");
    }
    if (X==115)  {               // iniziano ad accendersi le luci notturne
    digitalWrite (digital13,HIGH);
    Serial.println("Accende la luce 13");
    }
    if (X==116)  {
    analogWrite (analog5,255);
    Serial.println("Accende la luce 5");
    }
    if (X==118)  {
    analogWrite (analog10,255);
    Serial.println("Accende la luce 10");
    }
    if (X==119)  {
    analogWrite (analog3,255);
    Serial.println("Accende la luce 3");
    }
    if (X==120)  {
    digitalWrite (digital12,HIGH);
    Serial.println("Accende la luce 12");
    }
    if (X==122)  {
    digitalWrite (digital4,HIGH);
    Serial.println("Accende la luce 4");
    }
    if (X==123)  {
    analogWrite (analog11,255);
    Serial.println("Accende la luce 11");
    }
    if (X==124)  {                // questa è una luce al neon
    digitalWrite (digital2,HIGH);
    delay(120);
    digitalWrite (digital2,LOW);
    delay(40);
    digitalWrite (digital2,HIGH);
    delay(80);
    digitalWrite (digital2,LOW);
    delay(70);
    digitalWrite (digital2,HIGH);
    delay(100);
    digitalWrite (digital2,LOW);
    delay(390);
    digitalWrite (digital2,HIGH);
    Serial.println("Accende digital 2, al neon");
    }
    if (X==126)  {
    digitalWrite (digital7,HIGH);
    Serial.println("Accende la luce 7");
    }
    if (X==127)  {
    digitalWrite (digital8,HIGH);
    Serial.println("Accende la luce 8");
    }
    delay (vel);
  }                                // ora è notte e le luci notturne sono accese
  analogWrite(analog6,0);
  Serial.println("Attende 24 secondi");
  Serial.println("Sono le ore 00:00");
  delay(24000);                    // attende 24 secondi
  for(float L=128;L<256;L+=passo)  {  // verso l'alba
   float N=128+127*cos(L/128*PI);   // funzione trigonometrica di un andamento coseno del ciclo
   int X=L;
   Serial.print("Livello di X:");Serial.print(X);;Serial.println(" ciclo");
   Serial.print("Alba:");Serial.print(N);Serial.println(" dimmeraggio della striscia led");
   analogWrite(analog6,N);      // alba del sole; attivazione del led blu, porta 6 analogica
   if (X==135)  {               // iniziano a spegnersi le luci notturne
   digitalWrite (digital13,LOW);
   Serial.println("Spegne la luce 13");
   }
   if (X==138)  {
   analogWrite (analog10,0);
   Serial.println("Spegne la luce 10");
   }
   if (X==140)  {
   digitalWrite (digital12,LOW);
   Serial.println("Spegne la luce 12");
   }
   if (X==141)  {
   analogWrite (analog5,0);
   Serial.println("Spegne la luce 5");
   }
   if (X==143)  {
   analogWrite (analog11,0);
   Serial.println("Spegne la luce 11");
   }
   if (X==144)  {                // questa è una luce al neon che si spegne
   digitalWrite (digital2,LOW);
   Serial.println("Spegne digital2, al neon");
   }
   if (X==145)  {
   digitalWrite (digital4,LOW);
   Serial.println("Spegne la luce 4");
   }
   if (X==146)  {
   digitalWrite (digital7,LOW);
   Serial.println("Spegne la luce 7");
   }
   if (X==147)  {
   analogWrite (analog3,0);
   Serial.println("Spegne la luce 3");
   }
   if (X==148)  {
   digitalWrite (digital8,LOW);
   Serial.println("Spegne la luce 8");
   }
   if (X==150)  {
   analogWrite (analog9,0);
   Serial.println("Spegne la luce 9");
   }
   delay (vel);
 }                                // ora è giorno e le luci notturne sono di nuovo spente
  Serial.println("Attende 24 secondi");
  Serial.println("Sono le ore 12:00");
  delay(24000);                    // attende 24 secondi
}

Questo programma simula un ciclo di 24 ore dove si alternano alba e tramonto sul fondale e accende e spegne in sequenza tutte le luci degli edifici e delle strade.

Il software usa la porta seriale di Arduino per monitorare gli eventi mentre esegue la sequenza di attivazione e disattivazione delle luci.

Il fondale illuminato dalla striscia led tramite lo shield RGB (porta OUT 6), segue un andamento non lineare per simulare nel limite del possibile l’alba e il tramonto del sole nel suo moto apparente, cioè come viene visto in realtà da un osservatore sulla terra.

Grafico_eventi

Grafico non lineare di alba e tramonto

e la parte del software preposta a tale operazione è presente alle linee del codice comprese tra la 108 e la 110;

for(float L=128;L<256;L+=passo)  {  // verso l'alba
float N=128+127*cos(L/128*PI);   // funzione trigonometrica di un andamento coseno del ciclo.

Link correlati all’articolo: