Dimmer per lampada con PIC

[ricello9]

Riesci a regolare la lampada con fluidità, cambiando i ritardi?

Devo ancora creare la routine per variare la luminosità ma penso che non sia niente di complicato.

Se poi vuoi mi era venuta una ideuzza.

Spara...

[PietroBaima]

Devo ancora creare la routine per variare la luminosità ma penso che non sia niente di complicato.

ottimo.
Come prima cosa falla lineare, ma riservati la possibilità di interporre una tabella di valori tra ingresso e uscita.

Spara...

Finisco un altro post e arrivo...

[ricello9]

Finisco un altro post e arrivo...

Tranquillo, devo portare il bimbo a fare un giro in bici.
A dopo...

Grazie
Marcello

[PietroBaima]

L'altra sera mi chiedevo come variasse la luminosità di una lampada ad incandescenza in funzione del ritardo dato al TRIAC.
Chiaramente non è lineare, ma questa non linearità non viene compensata da nessuno perché in genere la luminosità viene impostata "in anello chiuso".
In pratica giro la manopola del dimmer finché sono soddisfatto della luminosità.
In pratica mi è sufficiente che la funzione sia abbastanza monotona.

Volendo però fare le cose bene, magari anche per inserire il dimmer in qualche automatismo più raffinato, sarebbe opportuno linearizzare.

Come prima cosa bisogna trovare la tensione efficace che la lampada vede, in funzione del ritardo imposto al TRIAC.

Chiamiamo "a" questo ritardo, normalizziamolo rispetto al periodo T, in modo che vada tra 0 e 1.
Bisogna quindi risolvere:



che fa:



adesso, posso utilizzare la formula per la luminosità di una lampada ad incandescenza, da questa pagina:

Rerated luminous intensity = (Va/Vd)3.4 to 3.5 × Luminous intensity at design voltage [1][2]

dove:

Va = Applied voltage
Vd = Design voltage

Considero che Va sia la tensione efficace che mi sono calcolato integrando, mentre Vd è la classica tensione efficace della rete, cioè 230V o, usando la mia notazione, .

Mi interessa un valore che varia tra 0 (lampada spenta) e 1 (lampada completamente accesa, cioè con luminosità pari a quella di progetto).
Pertanto normalizzo la formula alla luminosità di progetto, inserisco la formula trovata integrando e divido per la tensione efficace di rete, ottenendo:



Nota: ho usato 3.4 come esponente.

Questo è il grafico che si ottiene:

triacLamps2.jpg (10.42 KiB) Osservato 8788 volte

La funzione che ho trovato è quindi la legge con la quale la lampada varia la sua luminosità in funzione del ritardo dato al TRIAC.

Per renderla lineare bisogna invertirla e usarla come legge da usare per comandare il ritardo, in modo che le due cose si compensino e il risultato sia lineare.
Per fortuna la legge è decrescente, anche se non strettamente, per sfortuna, invece, bisogna invertirla numericamente.

Il grafico della funzione inversa, ottenuta per inversione numerica è:

In blu è riportata la funzione diretta, mentre in rosso quella inversa.
La linea tratteggiata è la composizione delle due, per verificarne la linearità.

Ho quindi discretizzato la funzione in 256 campioni, ottenendo una look-up table, da riportare nel micro.

Ecco il grafico della funzione continua e discretizzata sovrapposti:

In pratica dovresti utilizzare questa tabella a 8 bit:

Codice: Seleziona tutto

   const unsigned char DelayCorrection[]={
   255, 225, 221, 217, 215, 213, 211, 209, 208, 206, 205, 204, 203,
        202, 200, 199, 199, 198, 197, 196, 195, 194, 193, 192, 192, 191, 190,
        189, 189, 188, 187, 187, 186, 185, 184, 184, 183, 182, 182, 181, 180,
        180, 179, 178, 178, 177, 176, 175, 175, 174, 173, 173, 172, 171, 170,
        170, 169, 168, 167, 167, 166, 165, 164, 163, 162, 161, 161, 160, 158,
        157, 156, 155, 154, 152, 151, 149, 147, 144, 140, 120, 113, 110, 108,
   106, 104, 102, 101, 100, 99, 98, 97, 96, 95, 94, 93, 92, 92, 91, 90,
         90, 89, 88, 88, 87, 86, 86, 85, 85, 84, 84, 83, 83, 82, 82, 81, 81,
    80, 80, 79, 79, 78, 78, 77, 77, 76, 76, 75, 75, 75, 74, 74, 73, 73,
         73, 72, 72, 71, 71, 71, 70, 70, 69, 69, 69, 68, 68, 68, 67, 67, 66,
         66, 66, 65, 65, 65, 64, 64, 63, 63, 63, 62, 62, 62, 61, 61, 61, 60,
         60, 60, 59, 59, 59, 58, 58, 57, 57, 57, 56, 56, 56, 55, 55, 55, 54,
         54, 54, 53, 53, 52, 52, 52, 51, 51, 51, 50, 50, 50, 49, 49, 48, 48,
         48, 47, 47, 47, 46, 46, 45, 45, 45, 44, 44, 43, 43, 43, 42, 42, 41,
         41, 40, 40, 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, 34, 33,
         32, 32, 31, 31, 30, 29, 29, 28, 27, 26, 26, 25, 24, 23, 22, 21, 19,
         18, 16, 14, 11, 0
   };



[ricello9]

Ogni volta che leggo spiegazioni così articolate capisco che sono indietro anni luce per raggiungere il vostro livello di preparazione.
Non so neache da dove iniziare per inserire una tebella nel routine del ritardo.
Se hai pazienza di spiegarmelo io sono disposto a imparare.

Grazie
Marcello

[PietroBaima]

facciamo un esempio pratico.

Supponiamo che tu implementi due tasti per variare la luminosità della lampada (ma potrebbe essere qualunque altra cosa).
I due tasti sono UP e DOWN.
Uno ovviamente serve per aumentare la luminosità della lampada, l'altro per diminuirla.
Tenendo premuto UP la luminosità della lampada sale con una certa velocità, permettendomi di fermarmi quando raggiungo la luminosità che desidero.

Per farlo incremento un contatore a 8 bit, per esempio ogni 50ms, in modo che l'intera rampa duri 256*50ms=12.8s finché il tasto è premuto.
Quando lascio il tasto leggo il valore del contatore. Supponiamo sia 93.

Adesso con quel 93 devo calcolare un ritardo, tra 0 e 10ms, da dare al TRIAC.
Supponiamo di suddividere questo ritardo in 256 livelli, in pratica utilizziamo un char.
0ms saranno fatti corrispondere a 0
10ms saranno fatti corrispondere a 255

Se do un valore pari a 0 avrò un ritardo di 0ms dallo zero crossing, se do un valore di 255 avrò un ritardo di 10ms.

Se il tasto UP vuole impostare una luminosità di 93 che ritardo devo dare?
Semplice: devo dare un ritardo pari a DelayCorrection[93], dove nel vettore DelayCorrection è memorizzata la mia tabella.

Fai attenzione che lo zero della tabella restituirà un ritardo di 10ms, mentre 255 restituirà un ritardo di 0ms.
poiché abbiamo degli offset, cioè non possiamo impostare un ritardo nullo o un ritardo di 10ms potremo utilizzare solo una parte della tabella, effettivamente.

O calcoli una restrizione oppure se vuoi posso farlo io per te, però mi dovresti riportare due schermate dell'oscilloscopio: una schermata ottenuta sulla lampada impostando un ritardo nullo e una schermata ottenuta sulla lampada impostando il massimo ritardo che riesci a impostare (7ms forse 7.5ms, vedi tu).
Vorrei vedere i pezzi di sinusoide.
Grazie.

Ciao,
Pietro.

[ricello9]

Semplice: devo dare un ritardo pari a DelayCorrection[93], dove nel vettore DelayCorrection è memorizzata la mia tabella

Concettualemte mi è tutto chiaro ma non ho mai utilizzato una tabella nella programmazzione in c.
Comunque penso che non sia niente di complicato.
Questi sono i due screenschot dell'oscilloscopio,
a lampada completamente spenta (delay0)

1.jpg (39.37 KiB) Osservato 8748 volte

e a lampada completamente accesa (delay 69).

2.jpg (34.38 KiB) Osservato 8748 volte

Grazie
Marcello

[PietroBaima]

Sembra che tu abbia un ritardo minimo di 1.6ms e uno massimo di 10ms.

Con il ritardo minimo di 1.6ms dovresti ottenere una luminosità della lampada pari al 96%.
In pratica le cose vanno meglio delle stime, cioè perdi solo il 4% circa.

Usi un contatore ad 8 bit?
Quale valore minimo e massimo di questo contatore imposti per ottenere quei ritardi?
Probabilmente il minimo è zero, ma il massimo?

grazie
Ciao,
Pietro

[ricello9]

Usi un contatore ad 8 bit?
Quale valore minimo e massimo di questo contatore imposti per ottenere quei ritardi?
Probabilmente il minimo è zero, ma il massimo?

Uso un contatore che va da 0 a 64, che corrispondono a 6,4 millisecondi di ritardo massimo.
E' un po' contorta come logica di programmazione ma è la prima che mi è venuta in mente, sono un autodidatta è quindi la mia conoscenza del linguaggio di porgrammazione è scarsa.

Codice: Seleziona tutto


if(!timer_delay)              //questa routine mi definisce il ritardo per l'accensione
{                                   //del gate, è collegata all'interrupt del timer2
   trigger=0;                  // che è ciclico ogni 100uS
   timer_delay=incremento;  //la variabile incremento va da 0 a 64
    GATE=1;
}

  if(!timer_delay_2)      //  quest'altra routine mi incremento o diminuisce                         
  {                             // la variabile  incremento che è legata al valore
      if(inversione==0)   // analogico letto sul potenziometro, 
         incremento=incremento--;  // anche questa funzione è ciclica
      if(inversione==1)                   //ed è gestita  dal timer2
         incremento=incremento++;
      timer_delay_2=valore_medio    ;     
     
  }


  if(!timer_delay_1)          //RITARDO SPEGNIMENTO TRIAC DOPO UN MILLISECONDO
  {
     GATE=0;
     timer_delay_1=10;
}

//********************************************************************************
//                               INTERRUPT  TIMER 2
//********************************************************************************
if(PIR1bits.TMR2IF==1) //ciclico ogni 100uS
{
   if(trigger==1)
   {
      if (timer_delay) timer_delay--;
   }

   if(GATE==1)
   {
      if (timer_delay_1) timer_delay_1--;
   }

      if (timer_delay_2) timer_delay_2--;

   PIR1bits.TMR2IF=0;  //reset flag interrupt timer2
}


Non so se ci capisci qualcosa; devo provare a seguire il tuo suggerimento nel post [66] e riscivere il software.
ma non ho molte speranze.

Grazie
Marcello

[PietroBaima]

Adesso hai l'impulso di eccitazione del gate del TRIAC che dura 1ms.
Prova a portarlo a 200s.
Se il TRIAC si eccita lo stesso dovresti guadagnare un po' di ritardo, e spingerti un po' più avanti dei 6.4ms che hai come massimo.
Questo perché l'impulso, quando è verso la fine della sinusoide, potrebbe scavalcare lo zero crossing e eccitare il TRIAC anche dopo, facendo si che la lampada sia sempre accesa.

Il massimo è 10ms-1.6ms (il minimo, dato che rileviamo lo zero crossing sul fronte in discesa), cioè 8.4ms.

Fammi sapere.