Dimmerare una lampadina ad incandescenza 220v usando Arduino

ATTENZIONE, 220 Vac, PERICOLO DI MORTE: in questo articolo si descrivono circuiti elettrici che vengono collegati alla corrente elettrica alternata a 220 volt, c'è rischio di MORTE se riprodotti ed usati da persone poco esperte o se operanti senza criteri di sicurezza. Si declina ogni responsabilità.
(vedi disclaimer di questo blog)

Purtroppo non è possibile creare un variatore di luce ad icandescenza 220v AC usando semplicemente l'uscita pwm di Arduino che piloti un triac con onde quadre variando la frequenza delle stesse.

Se si facesse questo tentativo si otterrebbe un continuo sfarfallio della luce della lampadina da un minimo ad un massimo di intensità luminosa, perché per avere una emissione costante di luce è necessario che l'impulso che pilota il triac sia sincronizzato con il momento in cui l'onda dell'alternata passa attraverso lo zero.

Se si vuole capire il funzionamento si devono fare alcune considerazioni di base base del sistema di dimming in alternata.

Nota bene 1: la corrente alternata (in Italia) ha una frequenza di 50 Hz, quindi passa attraverso lo zero 2 volte ogni 0,02" (1"/50Hz=0,020") e quindi 1 volta ogni 10 millisecondi (ms).

Nota bene 2: il triac quando viene eccitato rimane in conduzione, anche se si toglie l'eccitazione sul gate, fino al successivo passaggio della sinusoide attraverso lo zero.

Questo significa che se si vuole variare la luminosità della lampadina, si dovrà eccitare il triac ogni decimillesimo di secondo, ma soprattutto vuol dire che per ridurre la luminosità della lampadina si dovrà attendere un certo tempo (successivo al passaggio dell'onda attraverso lo zero) prima di eccitare il triac, che sarà inversamente proporzionale al tempo di accensione della lampadina... ad esempio, se si vuole che il diming sia minimo si dovranno attendere circa 9 ms prima di eccitare il gate del triac, dopodiché quest'ultimo condurrà per 1 ms (9+1=10 ms) fino al successivo passaggio dell'onda attraverso lo zero. E così ogni 10 ms. Se questo concetto non è ben chiaro ripartire dal punto "Nota bene 1" e procedere con calma guardando le figure...

Passiamo al progetto.

Passo 1
Per prima cosa è necessario costruire un sensore da collegare ad Arduino che intercetti l'onda sinusoidale della corrente alternata 220 nel momento in cui transita attraverso il punto zero.
Il seguente schema è funzionante:

L'alternata passa ora nel primo ora nel secondo fotoaccoppiatore attraverso i piedini 1 e 2, mandando in conduzione alternativamente i piedini 4 e 5. I piedini 3 e 6 non devono essere usati.
Il tutto può essere messo in una scatola con un po' di aerazione per raffreddare le resistenze da 2 Watt:

Passo 2
E' necessaria anche una interfaccia tra l'uscita di Arduino e la lampadina ad incandescenza.

Il seguente schema è funzionante:

Notare che il MOC3020 non é un optoisolato zero crossing ma random. E' importante controllare che l'optoisolato non sia zero crossing perché, se lo fosse, non farebbe funzionare il dimmeraggio sempre per le questioni riportate ai punti "Nota bene 1" e "2", perché è compito dell'Arduino rilevare il punto di passaggio dallo zero!
La resistenza da 820 è regolata per l'alimentazione a +5 volt, se dovesse essere alimentata con 3,3 volt ridurla a 39 Ohm

Passo 3
Lo sketch di Arduino:
l'ho testato su un Arduino Mega;
premendo una volta la luce si accende dimmerata
premendo un'altra volta la luce si spegne dimmerata
tenendo premuto la luce aumenta fino al massimo poi diminuisce fino al minimo, si ferma al rilascio del pulsante

int T0 = 0;
int T1 = 0;
int ST0 = 0;
int ST1 = 0;
int var = 8900; //valore in mcsec attesa accensione triac, più è basso più sta acceso
int inc = 50;
int Luce = 0;
int PrintSer = 0;
int accendi = 0;
int spegni = 0;
int my_time = 0;
int my_time2 = 0;
int my_main_time = millis();
int my_main_delay = 10;
int my_var_time = 0;
int my_var_delay = 1000;
int my_timer = 0;
int tmp = 0;

//###################################################################################################
void setup() {
  attachInterrupt(0, zero_cross_detect, CHANGE); // interrupt pin 0, controlla zero cross
  pinMode(10, OUTPUT);                           // output verso opto isolante
  pinMode(3, INPUT);                             // input verso il pulsante in pull up
  Serial.begin(9600);                            // Inizializzazione seriale per debug
}
//###################################################################################################
void loop() {
  my_time = millis();
  my_time2 = my_timer;
 if(my_time>my_main_time+my_main_delay){
   Fn_Pulsante();
 }
}
//###################################################################################################

//---------------------------------------------------------------------------------------------------
void zero_cross_detect() {
  if(var <= 8900 && var >= 1100){
  delayMicroseconds(var/2);                        // attende mcsec var (che può essere da 1000 a 9000)
      tone(10, 500, 1);
  }
    my_timer = my_timer + 1; // incremento questo timer perchè millis() non è regolare negli interrupts
    if(my_timer > 10000){
      my_timer = 0;
    }
}
//---------------------------------------------------------------------------------------------------
  void Fn_Accendi(){
  accendi = 1;
  var = var - inc;
  if(var < 1100){
    var = 1100;
    Luce = 1;
    accendi = 0;
    T1 = 0;
    T0 = 0;
  }
  }
//---------------------------------------------------------------------------------------------------
  void Fn_Spegni(){
    spegni = 1;
  var = var + inc;
  if(var > 8900){
    var = 8900;
    Luce = 0;
    spegni = 0;
    T1 = 0;
    T0 = 0;
  }
  }
  //---------------------------------------------------------------------------------------------------
  void Fn_Pulsante(){
  if(digitalRead(3) == LOW){                     // se viene premuto il pulsante...
    if(ST0==0){
      T0 = my_timer;
      ST0 = 1;
      ST1 = 0;
    }
      var = var - inc;                              // aumenta il valore var

    PrintSer = 1;
    }
  if(digitalRead(3) == HIGH){
    if(ST1==0){
    T1 = my_timer;
    ST1 = 1;
    ST0 = 0;
    }
    if(PrintSer==1){
    Serial.print("var = ");
    Serial.print(var);
    Serial.print("     T0 = ");
    Serial.print(T0);
    Serial.print("     T1 = ");
    Serial.print(T1);
    Serial.print("     T1 - T0 = ");
    Serial.println(T1 - T0);
    PrintSer = 0;
    }
    if((T1 - T0 > 5 && T1 - T0 < 200) || (10000 - (T0 + T1) > 5 && 10000 - (T0 + T1) < 200) || accendi == 1 || spegni == 1){
      if(Luce == 0){
        Fn_Accendi();
      }else if(Luce == 1){
        Fn_Spegni();
      }
    }
  }

    
    if(var > 8900){                             // se var = 9000 mcsec... (luminosità minima)
      var = 8900;                                // reimposta var a 1000 mcsec (luminosità massima)
      inc = -inc;
    }
    if(var < 1100){                             // se var = 9000 mcsec... (luminosità minima)
      var = 1100;                              // reimposta var a 1000 mcsec (luminosità massima)
      inc = -inc;
    }
    my_main_time = millis();
  }

Passo 4
Collegare Arduino:

• l'uscita del sensore del passo 1 passaggio attraverso lo zero va collegato al pin 2 di Arduino (interrupt 0)
• il pin 10 di Arduino va collegato all'optoisolante dell'interfaccia del passo 2
• al pin 3 si deve collegare il pulsante di pilotaggio con resistenza in configurazione "pull up"

Purtroppo non è possibile pilotare più di una lampada con un singolo arduino...


Ciao. Carlo. 

[keywords: dimmeraggio dimmare dimmerare diming variatore variare 220 arduino]

Per lasciare un commento