frage zur ISR für Soft pwm

[ma W. (d3xt3r)]

Hallo, also mein Problem besteht darin eine gegeben ISR für eine Soft 
pwm zu verstehen. der Sachverhalt sieht so aus:
Benutzt wird ein Atmega8 für eine 4 Kanal Lüftersteuerung.

am Anfang wird für die Soft pwm eine Variable pwm1 mit dem Maximalwert 
255 initialisiert(ob sie jetzt mit 255 oder 0 initialisiert wird macht 
denke ich kein großen Unterschied).

int pwm1 = 255 //Anfangs Lüfter 1 auf 100%, wird im Hauptprogramm über 
Software-PWM geregelt

die temperatur am ntc wird eingelesen und in einem array gespeichert.

und dann wird dem pwm1 Signal mit dem folgenden code in Abhängigkeit von 
der eingelesenen Temperatur ein Wert zugewiesen.

if(i==0){
          set_cursor(3,1)
          if(t[i]<25) pwm1 = 77;  //Lüfter1 30%
       
          else{
    if(t[i]<=50) pwm1 = (5*t[i]-44); //Lüfter1 31%-81%

         else pwm1 = 255; //Lüfter1 100%
      }

und jetzt ist es ja so, dass währendessen der timer0 hochzählt und bei 
einem overflow in die folgende Routine springt und sie ausführt:
(kleine anmerkung: an ist eine variable die am anfang des programms mit 
1 initialisiert wurde und angibt ob der pin pb0 auf 1 oder 0 ist)

ISR(TIMER0_OVF_vect){
  if(an){
    PORTB &= ~(1<<PB0);  //PB0 0
    TCNT0 = pwm1;
    an = 0;
  }
  else{
    PORTB |= (1<<PB0);   //PB0 1
    TCNT0 = (255 - pwm1);
    an = 1;
  }
}

so wie ich es verstanden habe ist pwm1 der Vergleichswert der benutzt 
wird um das pwm Signal zu erzeugen.
das Prinzip hab ich verstanden denke ich.Bei jedem timer overflow prüft 
er ob  die Variable "an" auf 1 oder 0 ist und erzeugt durch die ISR ein 
periodisches Signal.

was ich nicht verstehe ist die Aufgabe der beiden Zuweisungen "TCNT0 = 
pwm1;" und "TCNT0 = (255 - pwm1);". ich vermute damit wird die Dauer 
einer Periode irgendwie bestimmt aber ich verstehe nicht wie.


hoffe ihr könnt mir helfen

[Karl H. (kbuchegg)]

Dex Mor schrieb:

> das Prinzip hab ich verstanden denke ich.Bei jedem timer overflow prüft
> er ob  die Variable "an" auf 1 oder 0 ist und erzeugt durch die ISR ein
> periodisches Signal.
>
> was ich nicht verstehe ist die Aufgabe der beiden Zuweisungen "TCNT0 =
> pwm1;" und "TCNT0 = (255 - pwm1);". ich vermute damit wird die Dauer
> einer Periode irgendwie bestimmt aber ich verstehe nicht wie.

er regelt damit, wie lange es dauert, bis die Overflow ISR das nächste 
mal aufgerufen wird.

Stell dir vor du hättest den Auftrag immer bis 100 zu zählen und dann in 
die Hände zu klatschen.

Wenn ich dir sage, du sollst bei 10 anfangen zu zählen, dann dauert es 
bis zum nächsten Klatscher schon eine Weile. Wenn ich dich aber 
beauftrage bei 95 anzufangen, dann bist du in 3 Sekunden am Klatschen.

[ma W. (d3xt3r)]

ok das habe ich mir schon gedacht, aber wieso macht man es im If-teil 
mit einer direkten zuweisung des wertes und im else-teil weist man dem 
counter die Differenz von 255 und pwm1 zu?

ich verstehe den Algorithmus der dahinter steckt noch nicht so richtig.



mfg

[Karl H. (kbuchegg)]

Dex Mor schrieb:
> ok das habe ich mir schon gedacht, aber wieso macht man es im If-teil
> mit einer direkten zuweisung des wertes und im else-teil weist man dem
> counter die Differenz von 255 und pwm1 zu?

Weil ich haben will, dass du für 2 Klatscher hintereinander immer die 
gleiche Zeit brauchst. Ok, Klatschen ist jetzt kein so gutes Beispiel. 
Nehmen wir betätigen des Lichtschalters. Wenn du bei 100 bist schaltest 
du den Lichtschalter in die andere Stellung.

Deine Vorgabe ist: fang bei 90 an
Du zählst von 90 bis 100 und betätigst den Lichtschalter. Danach zählst 
du weiter und zwar von 100 - 90. Du beginst also bei 10 und zählst bis 
100.
Beim ersten mal hast du also 10 Zählungen gebraucht. Beim 2-ten mal 90

  +-----------+-------------------------------------+----------+---..
       10                       90                        10

  ^           ^                                     ^
 schalten   schalten                            schalten

  |           |                                     |          |
  +- Licht ---+----------------- Licht -------------+-- Licht -+--- ...
      ein                         aus                     ein

Das Verhältnis der Zeiten von Licht ein zu Licht aus ist also 1:9. Von 
einem Ereignis Licht ein zum nächsten Ereignis Licht ein, hast du 100 
Zähltakte gebraucht.

Jetzt geb ich dir abwechselnd die Vorgabe: schalten bei 40, bzw. 
schalten bei 100 - 40, also 60.

Wie sieht es jetzt aus

  +--------------------+----------------------------+----------------+--..
         40                       60                      40

  ^                    ^                            ^                ^
 schalten             schalten                    schalten

  |                    |                            |                |
  +----- Licht --------+---------- Licht -----------+----- Licht ----+--..
          ein                        aus                    ein

Diesmal ist das Verhältnis von Licht ein zu Licht aus 4:6. Aber: Die 
Zeitpunkt, an denen das LIcht eingeschaltet wird, sind genau gleich wie 
vorher. In beiden Fällen vergehen von einem "Licht ein" zum nächsten 
"Licht ein" immer 100 Zähltakte.

Mathematisch ist das auch klar. Wie lange dauert denn ein Zyklus? Das 
ist die SUmme der beiden Zeitdauern. Licht ein dauerte x Einheiten. 
Licht aus dauerte 100 - x Einheiten. Also

    Zyklus = x + ( 100 - x )
    Zyklus = x + 100 - x
    Zyklus = x - x + 100
    Zyklus = 100

Die Zykluszeit ist also immer konstant 100. Durch das x teile ich sie 
einfach nur in 2 Teile auf, so dass der eine Teil x Einheiten dauert und 
der andere Teil gerade solange, dass sich alles in Summe wieder zu 100 
ausgeht.

Man kanns auch so sagen: der if Teil legt fest wie lange die LED brennt, 
der else Teil legt fest wie lange sie nicht brennt. Und beide Zeiten 
zusammen legen fest wie oft in der Sekunde die LED ein/aus geschaltet 
wird.
Die letzte Zahl ist konstant, aber mit der ersten steuere ich das 
Verhältniss von ein zu aus.

[ma W. (d3xt3r)]

Ah natürlich, so macht das alles natürlich sinn. Jetzt hab ich es 
verstanden, perfekt erklärt.


vielen Dank