SW-Lösungsansatz gesucht für "Tunable White Dimmer"

[Markus (Gast)]

Hallo Zusammen,

ich versuche, einen 2-kanaligen Dimmer zu programmieren, für eine 
"Tunable White"-Funktion. Also Kanal 1 Warmweisse Led, Kanal 2 
Kaltweisse Led.

Die Helligkeit und das Farbverhältniss soll über 2 Potentiometer 
eingestellt werden:
P1 stellt das Farbverhältnis ein: Rechtsanschlag (0V) nur Warmweiss, 
Linksanschlag (3,3V) nur Kaltweiss. Dazwischen soll linear zwischen den 
Farben hinundhergeblendet werden.
P2 stellt die Helligkeit des Farbgemisches ein: Rechtsanschlag (0V) 
dunkel, Linksanschlag (3,3V) volle Helligkeit.

Die Hardware ist soweit aufgebaut und funktionert (Attiny841). Die 
beiden 10-Bit-Pwm-Timer / Mostfet-Ausgänge funktionieren. Auch das 
Einlesen der Potentiometer / Adc's funktioniert bestens.
Die Helligkeit wird über eine PWM-Tabelle modifiziert, damits "linear" 
wird fürs Auge (10-Bit PWM, 128 Steps).

Mein grosses Problem ist nun, wie ich nun die Software aufbaue / 
schreibe, damit das Hinundherblenden zwischen den beiden Farben 
funktioniert.
Die Helligkeit alleine konnte ich schon so programmieren dass das 
Funktioniert hat, aber sobald ich versuche den Farbwert zu ändern gibts 
Chaos...
Bin da schon relativ lange am rumprobieren, komme aber auf keine Lösung, 
mir fehlt einfach der logische Ansatz wie das gelöst werden soll.
Deswegen sieht der Code momentan noch total Mager aus (macht m.M.n. 
keinen Sinn einen überhaupt nicht funktionierenden Ansatz zu posten).

Wie gehe ich die beiden Abschnitte nun am besten an? Habt ihr einen 
Denkanstoss für mich, wie ich das Lösen kann? (erwarte natürlich keinen 
fertigen Code, mehr ein kleines Beispiel / denkansatz damit ich selbst 
weiter dran arbeiten kann).
Wahrscheinlich ist es total simpel und ich denke viel zu kompliziert 
(wie immer).

Falls ihr weitere Infos möchtet oder mein planloses rumgecode in den 
Abschnitten "farbe berechnen" und "helligkeit berechnen" doch sehen 
wollt, bitte melden!

Ich danke euch schon für eure Hilfe!

Beste Grüsse,
Markus

int main(void)
{
  uint8_t helligkeit = 0;    // 0 dunkel, 127 = 100% 
  uint8_t farbe = 0;       // 0 = warmweiss, 127 = kaltweiss
  uint8_t dimmlevel_cw = 0;  // dimmwert kaltweiss
  uint8_t dimmlevel_ww = 0;  // dimmwert warmweiss
  
  
  init_io;
  init_timer;
  init_adc;
  
  sei();
    
  while(1)
  {
    // potis über 10bit adc einlesen und durch 8 teilen so dass max. wert = 127
    farbe = read_adc(p1)/8;  
    helligkeit = read_adc(p2)/8;
    
    
    // farbe berechnen
    
    
    // helligkeit berechnen

    
    
    // pwm-timer / ausgänge setzen m. gammakorrektur aus pwm-tabelle
    OCR2B = pgm_read_word(&dimm_step[dimmlevel_cw]);
    OCR1A = pgm_read_word(&dimm_step[dimmlevel_ww]);

  }
}

[Wolfgang (Gast)]

Markus schrieb:
> P2 stellt die Helligkeit des Farbgemisches ein: Rechtsanschlag (0V)
> dunkel, Linksanschlag (3,3V) volle Helligkeit.

Über die Zuordnung würde ich nochmal nachdenken. Potis werden gewöhnlich 
andersrum benutzt.

Rechne dir das Helligkeitsverhältnis anhand des Farbtemperaturpotis aus 
und multipliziere die sich daraus ergebende Grundhelligkeit mit der 
Helligkeit, die sich aus der Stellung des Helligkeitspotis ergibt.

[Markus (Gast)]

Hallo Wolfgang,

vielen Dank für deinen Hinweis, habe dadurch nun eine funktionierende 
Software schreiben können. Unten der ist komplette Code angehängt. 
Eigentlich ziemlich simpel wenn man mal auf der richtigen Fähre ist. 
Kommentare zum Code sind erwünscht, was man besser machen könnte etc 
(die Verrechnung habe ich absichtlich in mehrere Schritte aufgeteilt, 
zum einfacheren debuggen).

Auf die Gammakorrektur per PWM-Tabelle habe ich schlussendlich 
verzichtet, der Regelweg passt so fast besser.

bez. den potis, ich hab beim schreiben l/r vertauscht... ^^

Gruss und vielen Dank!
Markus

// MCU: ATTINY841

#ifndef F_CPU
#define F_CPU 8000000UL
#endif

#include <avr/io.h>

uint16_t read_adc(uint8_t channel);

int main(void)
{    
  uint16_t helligkeit = 0;    // 0 dunkel, 127 = 100%
  uint16_t farbe = 0;        // 0 = warmweiss, 127 = kaltweiss
  uint16_t dimmlevel_cw = 0;    // dimmwert kaltweiss
  uint16_t dimmlevel_ww = 0;    // dimmwert warmweiss
    float  ratio_cw = 0;      //
  float  ratio_ww = 0;      //

  // init i/o's
  DDRA = (1<<PORTA1) | (1<<PORTA2);  // set outputs
  PUEA = (1<<PORTA3);          // set inputs
  DDRB = 0x00;            // set outputs
  PUEB = (1<<PORTB0);          // set inputs
  
  // init timer prescaler
  CCP = 0xD8;      // enable configuration change to change clock prescaler.
  CLKPR = 0x00;    // set clock prescaler to 1 from 1
  
  // init timer 1 fast-pwm 10bit // PIN3 PA2 TOCC1
  TCCR1A = (1<<COM1A1) | (0<<COM1A0) | (1<<COM1B1) | (0<<COM1B0) | (1<<WGM11) | (1<<WGM10);
  TCCR1B = (0<<ICNC1)  | (0<<ICES1)  | (0<<WGM13)  | (1<<WGM12)  | (0<<CS12)  | (1<<CS11) | (0<<CS10);
  TCCR1C = (0<<FOC1A)  | (0<<FOC1B);
  TOCPMSA0 |= (0<<TOCC1S1) | (1<<TOCC1S0); // i/o pin assignment
  TOCPMSA1 |= 0x00;             // i/o pin assignment
  TOCPMCOE |= (1<<TOCC1OE);         // enable/disable output pin
  TIMSK1 = (0<<ICIE1) | (0<<OCIE1B) | (0<<OCIE1A) | (0<<TOIE1);
  TCCR1A |= (1<<COM1A1);
  
  // init timer 2 fast-pwm 10bit // PIN4 PA1 TOCC0
  TCCR2A = (1<<COM2A1) | (0<<COM2A0) | (1<<COM2B1) | (0<<COM2B0) | (1<<WGM21) | (1<<WGM20);
  TCCR2B = (0<<ICNC2)  | (0<<ICES2)  | (0<<WGM23)  | (1<<WGM22)  | (0<<CS22)  | (1<<CS21) | (0<<CS20);
  TCCR2C = (0<<FOC2A)  | (0<<FOC2B);
  TOCPMSA0 |= (1<<TOCC0S1) | (0<<TOCC0S0); // i/o pin assignment
  TOCPMSA1 |= 0x00;             // i/o pin assignment
  TOCPMCOE |= (1<<TOCC0OE);         // enable/disable output pin
  TIMSK2 = (0<<ICIE2) | (0<<OCIE2B) | (0<<OCIE2A) | (0<<TOIE2);
  TCCR2A |= (1<<COM2B1);  
  
  // init adc
  ADCSRA |= ((1<<ADEN) |(1<<ADPS2) | (1<<ADPS1));  // Enable ADC, set prescaler to 16
  ADCSRA |= (1<<ADSC);              // eine ADC-Wandlung
  while (ADCSRA & (1<<ADSC));
  (void) ADCW;
  
  while (1)
  {      
    // potis über 10bit adc einlesen
    farbe = read_adc(3);    // PA3 ADC3
    helligkeit = read_adc(11);  // PB0 ADC11
    
    // farbeverhältnis berechnen
    ratio_cw = (float)farbe/511.5;
    ratio_ww = 2-ratio_cw; 
    
    // helligkeit berechnen (für 50/50-verhältnis)
    dimmlevel_cw = helligkeit/2;
    dimmlevel_ww = helligkeit/2;
    
    // helligkeit anhand farbverhälgnis verrechnen
    dimmlevel_cw = dimmlevel_cw * ratio_cw;
    dimmlevel_ww = dimmlevel_ww * ratio_ww;
    
    // pwm-timer / ausgänge setzen
    OCR2B = dimmlevel_cw;
    OCR1A = dimmlevel_ww;
  }
}

uint16_t read_adc(uint8_t channel)
{
  #define    ADC_AVRG  2    // number of ad-conversions
  #define    ADC_OFFSET  0    // adc offset-value (empiric)
  
  uint32_t  ADValue  = 0;    // saves sum of ad-conversions

  ADMUXA = (ADMUXA & ~(0x1F)) | (channel & 0x1F);  // select adc channel
    
  for(uint8_t i = 0; i < ADC_AVRG; i++)      // read adc values
  {  ADCSRA |= (1<<ADSC);            // start the first conversion
    while(ADCSRA &(1<<ADSC));          // wait until conversion is finished
    ADValue += ADCW;              // write adc value in variable
  }
  
  return (uint16_t) ((ADValue / ADC_AVRG) + ADC_OFFSET);
}