ATmega8 untere Dimmstufen zu groß

[Stas S. (stas0)]

Guten Tag.
Ich hab mir mal ein 0-10v in PWM Dimmer gebaut für meine LED Leisten.
Das PWM kommt aus einem ATmega8 das Programm hab ich aus diesem Forum.

Ich bin mit den unteren Dimmstufen nicht zufrieden, die Sprünge sind zu 
groß.
Das liegt definitiv am ATmega und nicht an meinen 0-10v.

So jetzt hab ich hier im Forum ein Thread gefunden, wo genau das Problem 
besprochen wurde und da ist sogar ein Lösungsvorschlag.
Leider kenn ich mich selber nur sehr schlecht mit dem ATmega aus und 
deswegen bitte ich euch, mir zu helfen.
Könnte jemand mir helfen diesen Lösungsvorschlag in meinen Code 
einzufügen.

Hier der Lösungsvorschlag von AndiH 
(Beitrag "Re: AVR LED Dimmen mit Logarithmus")

Die Beste Lösung, die ich bisher hinbekommen habe, ist folgende:

* 8-Bit-Timer mit Compare-Match-IRQ
* zunächst sehr kleinen Compare-Match Wert, der aber bei jedem IRQ
Aufruf verlängert wird.
* Ein Regsiter als "PWM-Zähler"
* Bei jedem Aufruf des Timers LED-Helligkeits-Wert mit "PWM-Zähler"
vegleichen und entsprechend die LED ein oder ausschalten

Der Trick dabei ist nämlich der, daß bei sehr kleinen Helligkeitswerten
die Zeitdauer des IRQ-Aufrufes (und damit das ausschalten der LEDs) sehr
kurz ist, mit jedem erneuten Aufruf (=Helligkeits-schritt) aber
verlängert wird. Sozusagen eine pwm, bei dem die Zeitspanne der
einelnen Schritte unterschiedlich lang ist.

Ich hoffe, man versteht, was ich meine? Ich kanns schlecht erklären...

Hier mal ein kleiner Auszug der Assembler-IRQ-Routine:

-----CUT ---------
  ;****** IRQ TIMER 1 Compare Match ****
timer1irqA:

        ; *** Register-Werte sichern ***
    in itemp, SREG    ; Status-Register...
    push itemp      ; ...auf dem Stack sichern

              ;** Dauer bis nächsten aufruf verlängern
    ldi itemp2, mpwm      ; letzter durchlauf? (mpwm = maxpwm, s.o.: 
equ)
    cp pwm, itemp2      ; vergleichen
    brne t1alonger      ; ...wenn nicht - sprung. Sonst:
    clr pwm          ; ...pwm wieder auf 0 setzen, und
    ldi ZL, $10        ; ...Z-Register...
    clr ZH          ; ... auf Anfangswert setzen
    rjmp t1aset

t1alonger:            ; noch nicht letzter durchlauf, dann:
    adiw ZH:ZL, $10      ; wert hinzuaddieren

t1aset:

    out OCR1AH, ZH      ; Timer 1A Compare HighByte
    out OCR1AL, ZL      ; Timer 1A Compare LoByte

led1:
    cp pwm, led1      ; wenn led1...
    brlo led1an        ; ...größer als pwm, dann led einschalten
    brsh led1aus      ; ...gleich oder größer pwm, dann ausschalten
    rjmp led2        ; ...sonst weiter mit led2
led1an:
    cbi portd,0        ; LED0 einschalten (lo-aktiv, clear bit)
    rjmp led2        ; ...sonst weiter mit led2
led1aus:
    sbi portd,0        ; LED0 ausschalten (hi-inaktiv, set bit)

led2:
(......)
-----CUT ---------
Bei diesem Codebeispiel wird bei jedem Aufruf der Timer-Compare-Wert um
$10 verlängert, insgesamt 16mal (mpwm-Wert wird per equ. im Programmkopf
festgelegt), dann wieder zurückgesetzt auf den Anfangswert (=kleineste
Helligkeitsstufe).

So hab ich es geschafft, mit 16 (oder auch mehr, = mpwm-Wert)
Helligkeitsstufen halbwegs gleichmäßig zu dimmen, besonders der
Einschaltmoment ist schön "weich", Stufe 1 glimmt nur.

Zeitdiagramm:

|--1--|-----2----|-------3-------|----------4--------|---....

Hier mein jetziger Code:

#define    PC1          1
#define    PC0          0
#include <avr/io.h>
#include <stdio.h>

unsigned char adc_read8(char channel);

int main(void)
{

  //PC4,5 output
  DDRB = (1<<DDB1) | (1<<DDB2);


  //TIMER 1
  ICR1 = 255;
  TCCR1A = (1<<COM1A1) | (1<<COM1B1) | (1<<COM1A0) | (1<<COM1B1) | (1<< WGM11);   //Fast PWM, TOP = ICR1, Clear on Compare Match
  TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11) | (1<<CS10);  //Prescaler 64  //Fast PWM, Prescaler 256
  

  //ADC
  ADMUX = (1<<REFS0) | (1<<ADLAR);                    //VRef = AVCC
  ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN);       // 125 kHz @ 8 Mhz, ADC enabled
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));

  unsigned int i = 0;
  while(1)
  {
    if (~i)
    {
      OCR1A = 255-adc_read8(PC0);
      OCR1B = 255-adc_read8(PC1);;

    }
    i++;
  }
}

unsigned char adc_read8(char channel)
{
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));
  return ADCH;
}

Danke im voraus

[Karl H. (kbuchegg)]

das Beispiel in Assembler bringt dich nicht wirklich weiter.

Was dich ev. weiter bringen würde, wäre die Tabelle weiter vorne im 
verlinkten Thread

0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16, 18, 20, 22, 25,
28, 30, 33, 36, 39, 42, 46, 49, 53, 56, 60, 64, 68, 72, 77, 81, 86, 90,
95, 100, 105, 110, 116, 121, 127, 132, 138, 144, 150, 156, 163, 169,
176, 182, 189, 196, 203, 210, 218, 225, 233, 240, 248, 255

die 64 Dimmstrufen auf einer 8 Bit PWM abbildet.

Willst du aber 255 Dimmstufen haben, dann geh einfach mit der PWM höher. 
Auf 10 Bit, oder 12. Deine PWM ist sowieso auf den Top Wert in ICR1 
eingestellt. D.h. du schreibst da 1023 rein (für 10 Bit) oder 4095 (für 
12 Bit) und gehst ev. mit dem Vorteiler für den Timer etwas runter, 
wenns dann flackert.

Und dann rechnest du dir eben im Excel eine neue Tabelle aus, die dir 
265 Dimmstufen in den Werten von 0 bis 1023 realisiert.

Der Rest bleibt im Grunde wie er ist. Mit dem ADC Wert gehst du in diese 
Tabelle und kriegst daraus den Wert raus, der ins OCR1A Register zu 
schreiben ist.

Den erstrebten, fürs Auge gleichmässigen Helligkeitsverlauf, kriegst du 
dann durch die Werte in der Tabelle, die die Korrektur für die 
logarithmische Kennlinie des Auges machen.

[Karl H. (kbuchegg)]

Du kannst dich hier orientieren

http://www.mikrocontroller.net/articles/LED-Fading

[Oldie (Gast)]

Da ist nicht der ATmega dran Schuld, sondern die PWM-
Auflösung mit nur 8 Bit. Da es nun mal RELATIV größere Sprünge
bei den kleinen Pulsweiten gibt, fällt es beim Dimmen auf.

Von 255/256 zu 254/256 hast du eine Änderung um 0,04.
Von 2/256 zu 1/256 hast du eine Änderung um 0,5.

Ob man kleinere Helligkeitsunterschiede damit erzeugt, dass
man nicht von 2/256 auf 1/256 schaltet, sondern als
Zwischenstufe noch abwechelnd 2/256 und 1/256 o.ä. ausgibt,
ist Geschmackssache - ich würde eine 16-Bit PWM bevorzugen.

Bei den 8-Bit Zwischenstufen könnte dich auch bald ein Flackern
stören, da die PWM damit effektiv langsamer wird.

Nimm eine 16-Bit-PWM und alles ist gut.

[Stas S. (stas0)]

Mein Problem ist, dass ich mich gar nicht auskenne damit.
Hab eben http://www.mikrocontroller.net/articles/LED-Fading mir 
angeschaut. Scheint genau das Richtige zu sein weis aber gar nicht wo 
ich das einfügen soll und was noch geändert werden muss.
Könnte nicht jemand bitte mein Code so bearbeiten, damit es geht.

Vielen dank für eure Hilfe

[Michael_ (Gast)]

Oldie schrieb:
> Ob man kleinere Helligkeitsunterschiede damit erzeugt, dass
> man nicht von 2/256 auf 1/256 schaltet, sondern als
> Zwischenstufe noch abwechelnd 2/256 und 1/256 o.ä. ausgibt,
> ist Geschmackssache - ich würde eine 16-Bit PWM bevorzugen.

Den Unterschied braucht und sieht kein Mensch!
64 Stufen reichen dicke aus.

[Blinder (Gast)]

Wenn man blind ist natürlich nicht..

Oo

[Michael_ (Gast)]

Oh entschuldige! Das man hier auf Blinde (Im Gehirn) Rücksicht nehmen 
muß, wußte ich nicht.

Karl Heinz schrieb:
> Was dich ev. weiter bringen würde, wäre die Tabelle weiter vorne im
> verlinkten Thread0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 16,
> 18, 20, 22, 25,
> 28, 30, 33, 36, 39, 42, 46, 49, 53, 56, 60, 64, 68, 72, 77, 81, 86, 90,
> 95, 100, 105, 110, 116, 121, 127, 132, 138, 144, 150, 156, 163, 169,
> 176, 182, 189, 196, 203, 210, 218, 225, 233, 240, 248, 255
> die 64 Dimmstrufen auf einer 8 Bit PWM abbildet.

Wie kommt man nur auf so eine dämliche Tabelle?
Eine sinnvolle Helligkeit erhält man erst ab etwa 30% der Tabelle.
Und wenn man schon mit einer Tabelle arbeitet, dann sollte die 
logarithmisch sein. Das Auge will es so.

[Michael K. (Gast)]

Michael_ schrieb:
> Den Unterschied braucht und sieht kein Mensch!
> 64 Stufen reichen dicke aus.

Aha ?
Alles unter 10bit hauen meine Kunden mir um die Ohren und das zu Recht.
Es sieht einfach billig aus wenn sich Helligkeit & Farbort in Sprüngen 
ändern.

Michael_ schrieb:
> Und wenn man schon mit einer Tabelle arbeitet, dann sollte die
> logarithmisch sein. Das Auge will es so.

Man kann mit einem 8bit Sollwert auf eine 10bit Tabelle refenzieren.
Das ändert aber wenig daran das 8bit PWM sichtbare Sprünge mit sich 
bringt.

Stas S. schrieb:
> Könnte nicht jemand bitte mein Code so bearbeiten, damit es geht.

Das wäre aber schade wenn das jemand tut, denn dann würdest Du nie diese 
tiefe Befredigung erfahren nach langer nervenaufreibender Arbeit ein 
gutes Ergebniss zu erhalten.
Ich denke das Du hier schon ganz wertvolle Tips erhalten hast wo das 
Problem liegt und wie Du weitermachen solltest.
Wenn Du mehr möchtest fällt das in den Bereich 'Auftragsentwicklung' und 
damit verdiene nicht nur ich mein Geld.

[Stas S. (stas0)]

Also ich hab mal versucht die Tabelle mit 16bit von 
http://www.mikrocontroller.net/articles/LED-Fading
in mein Code einzufügen.
Leider funktioniert das noch nicht wo sind meine Fehler?

Mein jetziger Code:

/*
 * GccApplication6.c
 *
 * Created: 23.07.2014 12:37:51
 *  Author: PC
 */ 

#include <avr/io.h>
#include <avr/pgmspace.h>

#define F_CPU 8000000L
#include <util/delay.h>

#define INVERT_PWM (1 << COM1A0)
// non-inverted PWM on OC1A

#define    PC1          1
#define    PC0          0
#include <stdio.h>

unsigned char adc_read8(char channel);

const uint16_t pwmtable_16[256] PROGMEM =
{
  0, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3,
  3, 3, 3, 3, 3, 3, 4, 4, 4, 4, 4, 4, 5, 5, 5, 5, 5, 6, 6, 6, 6, 7,
  7, 7, 8, 8, 8, 9, 9, 10, 10, 10, 11, 11, 12, 12, 13, 13, 14, 15,
  15, 16, 17, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29,
  31, 32, 33, 35, 36, 38, 40, 41, 43, 45, 47, 49, 52, 54, 56, 59,
  61, 64, 67, 70, 73, 76, 79, 83, 87, 91, 95, 99, 103, 108, 112,
  117, 123, 128, 134, 140, 146, 152, 159, 166, 173, 181, 189, 197,
  206, 215, 225, 235, 245, 256, 267, 279, 292, 304, 318, 332, 347,
  362, 378, 395, 412, 431, 450, 470, 490, 512, 535, 558, 583, 609,
  636, 664, 693, 724, 756, 790, 825, 861, 899, 939, 981, 1024, 1069,
  1117, 1166, 1218, 1272, 1328, 1387, 1448, 1512, 1579, 1649, 1722,
  1798, 1878, 1961, 2048, 2139, 2233, 2332, 2435, 2543, 2656, 2773,
  2896, 3025, 3158, 3298, 3444, 3597, 3756, 3922, 4096, 4277, 4467,
  4664, 4871, 5087, 5312, 5547, 5793, 6049, 6317, 6596, 6889, 7194,
  7512, 7845, 8192, 8555, 8933, 9329, 9742, 10173, 10624, 11094,
  11585, 12098, 12634, 13193, 13777, 14387, 15024, 15689, 16384,
  17109, 17867, 18658, 19484, 20346, 21247, 22188, 23170, 24196,
  25267, 26386, 27554, 28774, 30048, 31378, 32768, 34218, 35733,
  37315, 38967, 40693, 42494, 44376, 46340, 48392, 50534, 52772,
  55108, 57548, 60096, 62757, 65535
};
void my_delay (uint16_t milliseconds)
{
  for (; milliseconds > 0; milliseconds--)
  _delay_ms (1);
}
void pwm_up_down (const uint16_t pwm_table[], int16_t size, uint16_t delay)
{
  int16_t tmp;
  
  for (tmp = 0; tmp < size; tmp++)
  {
    OCR1A = pgm_read_word (& pwm_table[tmp]);
    my_delay (delay);
  }
  
  for (tmp = size-1; tmp >= 0; tmp--)
  {
    OCR1A = pgm_read_word (& pwm_table[tmp]);
    my_delay (delay);
  }
}
void pwm_16_256 (uint16_t delay)
{
  // 16 Bit Fast PWM
  TCCR1A = 0x82 | INVERT_PWM;
  // stop timer
  TCCR1B = 0;
  // TOP for PWM, full 16 Bit
  ICR1 = 0xFFFF;
  // prescaler 1 -> ~122 Hz PWM frequency
  TCCR1B = (1 << WGM12) | (1 << WGM13) | 1;
  
  pwm_up_down (pwmtable_16, 256, delay);
}

int main (void)
{
  //PC4,5 output
  DDRB = (1<<DDB1) | (1<<DDB2);

  int8_t i;
  // delay in milliseconds for one fading step
  int16_t step_time = 400;
  
   
    //ADC
    ADMUX = (1<<REFS0) | (1<<ADLAR);                    //VRef = AVCC
    ADCSRA = (1<<ADPS2) | (1<<ADPS1) | (1<<ADEN);       // 125 kHz @ 8 Mhz, ADC enabled
    ADCSRA |= (1<<ADSC);
    while (ADCSRA & (1<<ADSC));
     
    while (1)
    {
      if (~i)
      {
        OCR1A = 255-adc_read8(PC0);
        OCR1B = 255-adc_read8(PC1);;

      }
      i++;
    }
  {
    for (i=0; i<3; i++) pwm_16_256 (step_time/16);
    my_delay (1000);
  }
  
  return 0;
}

unsigned char adc_read8(char channel)
{
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);
  while (ADCSRA & (1<<ADSC));
  return ADCH;
  }

[Michael K. (Gast)]

Stas S. schrieb:
> Leider funktioniert das noch nicht

Was funktioniert nicht ?

> OCR1A = pgm_read_word (& pwm_table[tmp]);
Deine Zuweisung aus der PWM Tabelle.
Wo wird die aufgerufen ?

Stas S. schrieb:
> OCR1A = 255-adc_read8(PC0);
Die wird in der main ständig durchlaufen.

[Stas S. (stas0)]

Danke euch für euere Hilfe

Also wie gesagt ich kenn mich fast gar nicht aus damit hatte mir die 
Tutorials mal durchgelesen hat mich aber bei meinem Projekt nicht weiter 
gebracht.
Ist einfach zu kompliziert für mich, wenn man sich damit noch nie 
beschäftigt hatte und auf einmal so was programmieren möchte.
Also ich bin auch gern lernfähig müsst mir nur sagen, wo ich das finde, 
was ich brauch.

Den ersten Code hat mir hier einer aus dem Forum erstellt.
Hab gehofft das dieses Mal auch jemand mein Code editiert.


> Was funktioniert nicht ?
Also bei meinem letzten geposteten Code passiert einfach gar nix.

> Deine Zuweisung aus der PWM Tabelle.
Wo wird die aufgerufen?
Nirgendwo? Wo muss ich die den einfügen.

> Die wird in der main ständig durchlaufen.
Ist das so falsch? Ist doch mein ADC eingang mit meinen 0-5v.Oder nicht?

[Karl H. (kbuchegg)]

Stas S. schrieb:
> Danke euch für euere Hilfe
>
> Also wie gesagt ich kenn mich fast gar nicht aus damit hatte mir die
> Tutorials mal durchgelesen hat mich aber bei meinem Projekt nicht weiter
> gebracht.
> Ist einfach zu kompliziert für mich, wenn man sich damit noch nie
> beschäftigt hatte und auf einmal so was programmieren möchte.
> Also ich bin auch gern lernfähig müsst mir nur sagen, wo ich das finde,
> was ich brauch.

Der springende Punkt ist, dass es in der Programmierung nicht diesen 
einen Punkt gibt, den du können musst und dann ist alles gut.

Das ist wie bei einem Chirurgen. Will man sich auf Herzoperationen 
spezialisieren bedeutet das nicht, das man alles andere nicht lernen 
braucht. Jeder Chirurg fängt erst mal damit an, Knoten binden zu lernen.

Und wie überall, gibt es eine untere kritische Masse an Können, die man 
erst mal überschreiten muss, ehe es Sinn macht, sich aus dem Übungsraum 
in die freie Wildbahn hinaus zu wagen.

> Den ersten Code hat mir hier einer aus dem Forum erstellt.
> Hab gehofft das dieses Mal auch jemand mein Code editiert.

So wie der aussieht hast du einfach alles irgendwie zusammenkopiert. 
Deine Beste Chance ist es, wenn dir wieder jemand das komplette Programm 
schreibt, auch wenn die Änderungen zu deinem Originalprogramm eigentlich 
recht trivial sind. Pikanterweise ist nämlich dein Originalprogramm weit 
näher an der Lösung drann, als dein letztes Konglomerat.
Allerdings: ich werds nicht sein. Aus dem Geschäft zieh ich mich mehr 
und mehr zurück. Du willst was bauen - dann lerne es. Und zwar von der 
Pieke auf, selbst wenn das ein paar Monate Lernen bedeutet. Musste ich 
ja schliesslich auch.

[Mat (Gast)]

Stas S. schrieb:
>> Die wird in der main ständig durchlaufen.
> Ist das so falsch? Ist doch mein ADC eingang mit meinen 0-5v.Oder nicht?

Genau und der ist linear und nicht logarithmisch. Also muss der lineare 
Werte in die Tabelle und die spuckt dann den logarthmischen Wert zurück. 
Sonst wird die Tabelle ja garnicht verwendet.

lg

[Michael K. (Gast)]

Stas S. schrieb:
> Den ersten Code hat mir hier einer aus dem Forum erstellt.
> Hab gehofft das dieses Mal auch jemand mein Code editiert.

Dein Code ?
Und genau deswegen sollte man sowas nicht tun.
Du lernst nichts und wir müssen immer weiter damit machen 'unseren' Code 
für Dich zu schreiben.

Stas S. schrieb:
> Also ich bin auch gern lernfähig müsst mir nur sagen, wo ich das finde,
> was ich brauch.

Du hast jetzt viele Schubser in die richtige Richtung bekommen.
Versuch doch wenigstens mal zu verstehen was da jede Zeile macht und 
warum manches geht und manches nicht.
Mehr Engagement !

MCU Datenblatt lesen, C Syntax lernen.

Stas S. schrieb:
> Ist einfach zu kompliziert für mich

Dann mußt Du das sein lassen