Arduino: Problem mit Timer in loop

[Jonny H. (jonny123)]

Hallo,
ich möchte gerne LEDs mit Hilfe einer PWM ansteuern.
analogWrite liefert mir eine zu geringe Auflösung
Deswegen habe ich mich in das Thema Timer eingelesen und ein Testsketch 
erstellt. Dieses Sketch habe ich nun noch um das Thema LED-Fading 
(https://www.mikrocontroller.net/articles/LED-Fading)  erweitert.
Es läuft so weit auch ganz gut.

Aber in dem Testsketch wird die Helligkeit erstmal in einer For-Schleife 
erhöht.
Dann soll die LED für eine Sekunde ausgehen, damit mir signalisiert 
wird, dass die erste For-Schleife abgearbeitet ist. Die LED geht 
allerdings nur aus, wenn "Serial.println(ZeitHigh);" nicht 
auskommentiert ist. Danach wird die nächste For-Schleife ganz normal 
ausgeführt.

Kann mir vielleicht jemand sagen wieso die LED nur ausgeht, wenn 
"Serial.println(ZeitHigh);" aktiv ist? Ich habe auch schon ein delay 
direkt vor "ZeitHigh = 0;" dies hat aber auch nichts gebracht.

Der Code:

#define LampePin 9
int ZeitHigh = 0;
int PWMWert = 0;
int ZeitHighMax = 9950;       // eigentlich 10000 (bei 100 Hz), aber dies führt zu Unstabiität. Wahrscheinlich weil die ISR-Schleife ca 50µs zum Schalten der digitalen Pins benötigt
float HelligkeitMax = 5000;   // Warum muss dies ein Float sein? Wenn Int, dann werden von PWMWert nur die Extremwerte berechnet

int Basis = 200;              // Basis zur Anpassung an Menschliche Wahrnehmung -> je nach Empfinden einstellen


void setup()
{
  Serial.begin(9600);
  pinMode(LampePin, OUTPUT);
  digitalWrite(LampePin, LOW);

  cli(); // Interrupts deaktivieren

  // Reset
  TCCR1A = 0; // Setze TCCR1A Register auf 0
  TCCR1B = 0; // Setze TCCR1B Register auf 0
  TCNT1  = 0; // Zählerwert zurücksetzen

  OCR1A = 155.25; // Compare Match Register -> PWM Freqeunz: 100 Hz

  // Prescaler einstellen
  TCCR1B |= (1 << CS12) | (1 << CS10);

  TCCR1B |= (1 << WGM12); // Auf CTC-Mode setzen
  TIMSK1 |= (1 << OCIE1A); // Timer-Vergleichsinterrupt aktivieren

  sei(); // Interrupts zulassen
}

void loop()
{

  for (int i = 0; i < HelligkeitMax; i++)
  {
    PWMWert = ((pow(Basis, (i / HelligkeitMax)) - 1) / (Basis - 1)) * HelligkeitMax;    // Anpassung an Menschliche Wahrnehmung
    ZeitHigh = map(PWMWert, 0, HelligkeitMax, 0 , ZeitHighMax);                         // delayMicroseconds in ISR wird beschrieben
    //    Serial.print("PWMWert: ");
    //    Serial.print(PWMWert);
    //    Serial.print(" - Zähler: ");
    //    Serial.print(i);
    //    Serial.print(" - ZeitHigh: ");
    //    Serial.println(ZeitHigh);
    delay(1);
  }
  ZeitHigh = 0;                         // delayMicroseconds in ISR wird beschrieben
  Serial.println(ZeitHigh);
  delay(1000);
  for (int i = HelligkeitMax; i > 0; i--)
  {
    PWMWert = ((pow(Basis, (i / HelligkeitMax)) - 1) / (Basis - 1)) * HelligkeitMax;    // Anpassung an Menschliche Wahrnehmung
    ZeitHigh = map(PWMWert, 0, HelligkeitMax, 0 , ZeitHighMax);                         // delayMicroseconds in ISR wird beschrieben
    //        Serial.print("PWMWert: ");
    //        Serial.print(PWMWert);
    //        Serial.print(" - Zähler: ");
    //        Serial.print(i);
    //        Serial.print(" - ZeitHigh: ");
    //        Serial.println(ZeitHigh);
    delay(1);
  }
  delay(1000);
}

ISR(TIMER1_COMPA_vect)    // Diese Funktion wird beim Auftreten eines Interrupts von Timer 1 aufgerufen
{
  if (ZeitHigh == 0)digitalWrite(LampePin, LOW);
  else if (ZeitHigh == ZeitHighMax) digitalWrite(LampePin, HIGH);
  else
  {
    digitalWrite(LampePin, HIGH);
    delayMicroseconds(ZeitHigh);
    digitalWrite(LampePin, LOW);
  }
}

Vielen Dank.

MfG
Jonny

[Veit D. (devil-elec)]

Hallo,

nulle/resete alle Timer Register, die sind nämlich mit anderen 
Einstellungen vorbelegt bei Arduino. Desweiteren hat ein delay in einer 
ISR nichts zu suchen. Das Duty Cycle stellst du über den Wert von OCR1x 
ein. Timerregister können nur Ganzzahlen aufnehmen. Also die 155.25 
werden zu 155.

Du musst den Timer mit einer festen Frequenz konfigurieren. Das geht 
entweder mit dem IRC1 oder OCR1A Register. Das Dutycycle dann entweder 
mit OCR1A oder OCR1B.

Frequenz bestimmt mit IRC1  >  PWM mit OCR1A und/oder OCR1B möglich
Frequenz bestimmt mit OCR1A >  PWM nur mit OCR1B möglich

Aktuell taktet der Timer, wenn er es so macht, mit 100Hz. Und du 
schaltest irgendwann die LED ein oder aus. Bedeutet, die mögliche hohe 
Auflösung verpufft komplett. Weil du überlässt das ja nicht den Timer.

[Veit D. (devil-elec)]

Hallo,

weil ich das schon einmal zusammengetragen hatte, kann ich das hier mal 
zu Besten.

Hallo,

nun denn. Die Frequenz habe ich jetzt mal mit 100Hz festgelegt.

Die Einstellungen sehen dann wie unten aus.  Wie kommt man darauf?

Timer 1

Fast-Modi gibt es mehrere. Tabelle auf Seite 172. Modi 5, 6, und 7 sind auf feste TOP Werte festgelegt.
Das heißt die Timerfrequenz ist in diesen drei Modi nur noch mittels Prescaler einstellbar.

Tipp, älteres Manual sind verständlicher wie das aktuelle.

Der flexibelste Modi ist immer der, aus meiner Sicht, wenn man einen verwenden kann wo man den TOP Wert in einem OCR1A Regsiter einstellen kann. Das ist nämlich gepuffert, dass heißt man kann den Wert live in seinem Programm ändern ohne den Timer stoppen/nullen zu müssen, wenn alles korrekt laufen soll mit dem Compare Match.

Wenn die Frequenz konstant bleibt, kann man für die TOP Wert Einstellung auch einen Modi nehmen wo ein ICR1 Register für TOP zuständig ist. Man könnte auch hier die Frequenz später im Programm ändern, hat nur im Code mehr Aufwand, wenn alles korrekt laufen soll, dass am Rande.

Wir nehmen Modi 15. Damit sind schon 2 Dinge festgelegt laut Tabelle Seite 172.
Das Frequenz bestimmende Register ist OCR1A und das Duty Cycle Register ist OCR1B.
Der Timer 1 beim 328P hat nur zwei OCR1x Register. A und B.
Einen verwenden wir als TOP, nämlich OCR1A, damit bleibt nur OCR1B.

Die LED Frequenz ist auf 100Hz festgelegt.

Jetzt benötigen wir den TOP Wert zusammen mit dem Prescaler der die 100Hz Frequenz erzeugt.
Dazu suchen wir uns die passende Formel raus.
Abschnitt Fast-PWM, Seite 164.
Die Formel stellen wir nach TOP um.
TOP = (CPU Takt / Prescaler / Takt ) - 1

Mit Prescaler 64 erhalten wir:   2499 ... etwas wenig für einen 16 Bit Counter
Mit Prescaler  8 erhalten wir:  19999 ... schon besser
Mit Prescaler  1 erhalten wir: 159999 ... zu viel, 16 Bit geht nur bis 65535

Also nehmen wir den Prescaler 8 und TOP Wert 19999.
Damit taktet der Timer schon einmal mit 100Hz.

Jetzt wollen wir aber den Pin bei 25% der Periodendauer abschalten.
Das heißt, wir brauchen noch einen zweiten Vergleichswert für OCR1B.

25% von unseren TOP 19999 sind 5000. Das ist der Wert für unser OCR1B Register.

Damit der Timer zugehörige Pin auch schaltet, müssen wir das noch aktivieren.
Und zwar das COM1B1 Bit, Seite 171, restliche Tabelle oben.

In welchen Registern befinden sich nun die vielen Bits die wir setzen müssen?

Nun, dazu müssen wir uns im Datenblatt die Registerbelegungen mit ihren Bits anschauen.
Das beginnt ab Seite 170.

Für Fast Mode 15 müssen wir alle 4 WGM1x Bits einschalten.
Die verstreuen sich auf 2 Register. Seite 170 und 173.
TCCR1A und TCCR1B.

Prescaler soll 8 sein, wird ebenfalls im Register TCCR1B eingestellt, Seite 173.
Das sind die CS Bits. Wir benötigen hier Bit CS11.

Mehr benötigen wir nicht, alles in Code umgesetzt sieht es dann so aus. Wichtig wäre noch das man in der IDE alle Register vorher nullt, weil die intern vorgeladen werden für analogWrite usw. Sonst macht der Timer nicht das was man möchte.

In diesem Bsp. müßtest du nur den Wert für OCR1B ändern und damit die 
Pulsweite/Helligkeit. Kannst natürlich auch den CTC Modus nehmen.
Desweiteren immer darauf achten das der Wert für die Pulsweite nie 
größer wird wie der Werte für TOP. Sonst gibts Aussetzer.

/*
  IDE 1.8.5
  Arduino Mega2560
  
  LED mit 25% Duty Cycle bei 100Hz

  Pinouts  >>> http://www.pighixxx.com/test/pinoutspg/boards/
  Uno      >>> http://www.pighixxx.com/test/portfolio-items/uno/?portfolioID=314
  Mega2560 >>> http://www.pighixxx.com/test/portfolio-items/mega/?portfolioID=314
*/  

// Mega
// const byte Takt_Pin = 12;     // OC1B bzw. PB6, nicht invertiert

// Uno
const byte Takt_Pin = 10;  // OC1B bzw. PB2, nicht invertiert

void setup()  {
  
  pinMode(Takt_Pin, OUTPUT);
  set_Timer1();
}


void loop() {

    
}   // loop Ende


// ****** Funktionen ******* //
    
void set_Timer1()   //  Fast-PWM, Mode 15
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // Start 0
  OCR1A = 19999; // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = 5000;  // Pulsweite, OCR1B <= OCR1A
  TCCR1A = (1<<COM1B1) | (1<<WGM11) | (1<<WGM10);  // nicht invertiert
  TCCR1B = (1<<WGM13) | (1<<WGM12) | (1<<CS11);    // Prescaler 8
  sei();         // Interrupts einschalten
}  // end Funktion

[Jim M. (turboj)]

Jonny H. schrieb:
> Die LED geht
> allerdings nur aus, wenn "Serial.println(ZeitHigh);" nicht
> auskommentiert ist.

Da fehlt ein volatile:

volatile int ZeitHigh = 0;

Die Begründung liegt im C/C++ Optimizer, der ohne das Serial.println() 
den Wert gar nicht erst in die entsprechende Speicherstelle schreibt. 
Denn er kann nicht wissen das die ISR den lesen will.

Übrigens sollte man hier auch auf Probleme mit Atomizität achten, denn 
als int könnte die ISR schon mal einen Wert erwischen wo von den 2 Bytes 
erst eins geschrieben wurde.

[Jonny H. (jonny123)]

Vielen Dank für die schnellen Antworten.
Leider leuchtet die LED noch ganz leicht, wenn OCR1B 0 ist.Gibt es eine 
elegante Möglichkeit den Pin dann low zu setzen?

[Veit D. (devil-elec)]

Hallo,

zeig mal deinen neuen kompletten Code.

[Jonny H. (jonny123)]

Habe den Code von dir kopiert und testweise OCR1B in void set_Timer1() 
Null-gesetzt .
Mehr habe ich nicht gemacht. Ausser halt noch ein paar sachen probiert, 
die aber leider nichts gebracht haben.

[Veit D. (devil-elec)]

Hallo,

ja, das ist ein Problem im Fast PWM Mode, der erzeugt mit 0 immer kurze 
Peaks, wenn man sich das mit einem Oszi anschaut. Abhilfe schafft man 
entweder den Pin direkt auf 0 zu setzen oder einen anderen PWM Modus zu 
verwenden. Frequenz correct sollte das nicht mehr machen. Oder du 
invertierst das Signal im Fast pwm Modus. Dann hast du ein sauberes aus. 
Der umgekehrte Peak mit 100% Duty Cycle sollte nicht stören denke ich.

[Jonny H. (jonny123)]

Hallo,

Danke! Mit dem Invertieren läuft es. Ich habe vorher schon versucht den 
Pin LOW zu setzen, aber ich habe es nicht hinbekommen, danach wieder die 
PWM zu starten.

Zwei Fragen habe ich allerdings noch:
1.: Kann vielleicht jemand sagen, warum ich für "HelligkeitMax" den 
Datentyp float verwenden muss, damit es läuft?
int geht nicht. Eigentlich dürfte das doch nichts ausmachen, weil die 
Variable eh kein Komma hat und auch nicht verändert wird. Oder sehe ich 
das falsch?

2.: Gibt es eine Möglichkeit 3 Ausgänge mit dem Timer auf einem Arduino 
laufen zu lassen? Zwecks RGB-LEDs

Hier noch der aktuelle Code:

// Mega
#define Takt_Pin 12     // OC1B bzw. PB6

// Uno
//#define Takt_Pin 10  // OC1B bzw. PB2

int TimerTopWert = 19999;     // Topwert des Timers -> OCR1B auf Topwert -> 0V am Ausgang -> OCR1B auf 0 -> 5V am Ausgang (aufgrund Invertierung)
int PWMWert = 0;
float HelligkeitMax = 5000;   // Warum muss dies ein Float sein? Wenn Int, dann werden von PWMWert nur die Extremwerte berechnet

int Basis = 200;              // Basis zur Anpassung an Menschliche Wahrnehmung -> je nach Empfinden einstellen


void setup()
{
  pinMode(Takt_Pin, OUTPUT);
  set_Timer1();
}

void loop()
{
  for (int i = 0; i < HelligkeitMax; i++)
  {
    PWMWert = ((pow(Basis, (i / HelligkeitMax)) - 1) / (Basis - 1)) * HelligkeitMax;    // Anpassung an Menschliche Wahrnehmung
    OCR1B = map(PWMWert, HelligkeitMax, 0, 0, OCR1A);
    delay(1);
  }
  OCR1B = TimerTopWert;
  delay(2000);
  for (int i = HelligkeitMax; i > 0; i--)
  {
    PWMWert = ((pow(Basis, (i / HelligkeitMax)) - 1) / (Basis - 1)) * HelligkeitMax;    // Anpassung an Menschliche Wahrnehmung
    OCR1B = map(PWMWert, HelligkeitMax, 0, 0, OCR1A);
    delay(1);
  }
  delay(1000);
}


void set_Timer1()   //  Fast-PWM, Mode 15, 100 HZ
{
  cli();         // Interrupts ausschalten
  TCCR1A = 0;    // Reset TCCR1A Register
  TCCR1B = 0;    // Reset TCCR1B Register
  TIMSK1 = 0;    // Reset TIMSK1 Register (disable Timer Compare Interrupts)
  TCNT1  = 0;    // Start 0
  OCR1A = TimerTopWert; // TOP Wert bestimmt Auflösung und mit Prescaler den PWM Takt
  OCR1B = TimerTopWert;  // Pulsweite, OCR1B <= OCR1A -> auf Topwert gesetzt, damit Leuchte beim einschalten aufgrund der Invertierung nicht hell aufleuchtet
  //TCCR1A = (1 << COM1B1) | (1 << WGM11) | (1 << WGM10); // nicht invertiert
  TCCR1A = (1 << COM1B0) | (1 << COM1B1) | (1 << WGM11) | (1 << WGM10); // invertiert
  TCCR1B = (1 << WGM13) | (1 << WGM12) | (1 << CS11); // Prescaler 8
  sei();         // Interrupts einschalten
}

Gruß
Jonny

[ratazong (Gast)]

zu 1)
Wenn HelligkeitMax ein int ist kommt bei dem Ausdruck

 (i / HelligkeitMax)) (fast) immer 0 raus

(Zeile bei Dir)
PWMWert = ((pow(Basis, (i / HelligkeitMax)) - 1) / (Basis - 1)) * 
HelligkeitMax;

[Veit D. (devil-elec)]

Hallo,

vermutlich haste einen Wertebereichsüberlauf mit int.
Nimm mal "unsigned int".
int ist nur immer bequem zum tippen. Für 16Bit Timer ungeeignet.
Ich denke du solltest alle int zu unsigned int ändern.

https://www.arduino.cc/reference/en/language/variables/data-types/unsignedint/

[Veit D. (devil-elec)]

Hallo,

wegen der Ganzzahlrechnung, man kann mit Fließkomma rechnen, dann mit 
+0.5 runden und einen cast auf unsigned int machen.

Den ersten Wert in der Formel mit 1.0 multiplizieren, dann wird in float 
gerechnet.

ungetestet:

PWMWert = (unsigned int) ((((pow(Basis, (1.0*i / HelligkeitMax)) - 1) / (Basis - 1)) * HelligkeitMax) +0.5);

[Frank (Gast)]

Jim M. schrieb:
> Jonny H. schrieb:
>> Die LED geht
>> allerdings nur aus, wenn "Serial.println(ZeitHigh);" nicht
>> auskommentiert ist.
>
> Da fehlt ein volatile:
> volatile int ZeitHigh = 0;
>
> Die Begründung liegt im C/C++ Optimizer, der ohne das Serial.println()
> den Wert gar nicht erst in die entsprechende Speicherstelle schreibt.
> Denn er kann nicht wissen das die ISR den lesen will.

Danke! Danke! Danke!
Ich war schon am Verzweifeln, warum meine ISR nicht funktionierte und 
Google führte mich zu diesem Thread. Mit 'volatile' vor meinen globalen 
Variablen (später wird das eine Klasse) funktioniert die ISR wie 
erwartet.
Danke! Danke! Danke!

[Stefan F. (Gast)]

Mache einfache alle Variablen volatile, die sowohl außerhalb als auch 
innerhalb von ISR benutzt werden.

Es gibt zwar ein paar Spezialfälle, wo das nicht nötig ist, aber über 
die würde ich mir erst Gedanken machen, wenn eine Optimierung der 
Performance and dieser Stelle wirklich wirklich notwendig wird.

[Veit D. (devil-elec)]

Stefan ⛄ F. schrieb:
> Mache einfache alle Variablen volatile, die sowohl außerhalb als auch
> innerhalb von ISR benutzt werden.

"Bin dagegen." Dann könnte man auch sagen nimm immer den größten 
Datentyp oder gleich Fließkomma, da passt alles rein.
Bitte nicht machen.

Die Nutzung von volatile hängt meistens auch sehr stark mit atomic 
zusammen. Damit sollte man sich schon einmal tiefer beschäftigen.