Timer CTC Mode Atmega328P Verständnisproblem

[Milli (millsen)]

Hallo, ich habe vor mit dem Timer1 alle 10 ms eine Variable per 
Interrupt hochzuzählen. In der Schleife soll dann alle 500 ms eine LED 
umgeschaltet werden. Das funktioniert aber nicht. Es funktioniert nur, 
wenn mehr Code abgearbeitet wird, hier die auskommentierte For-Schleife, 
welche mindestens 17 Iterationen durchlaufen muss. Meine Vermutung ist, 
dass die Variable zu schnell ausgelesen wird. Aber das macht ja keinen 
Sinn, da die ISR ja abläuft, ohne dass die Variable ausgelesen wird. Wo 
liegt hier mein Denkfehler?

Hier noch das Programm:

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

#define F_CPU 16000000UL

// Ein- und Ausgänge definieren
#define LED     PB0

// Globale Variablen
uint8_t gIR_sysTick_counter = 0;

// ISR
ISR(TIMER1_COMPA_vect)
{
  gIR_sysTick_counter++;
}


int main()
{
  // Setup ================================
  cli();

  // Ausgänge Setup
  DDRB |= (1 << LED);


  // Timer1 Mode CTC (Geht auf 0 wenn OCR1A erreicht) & Prescaler auf 256 (Bei 16 MHz wird alle 16 us hochgezählt)
  TCCR1B |= (1 << WGM12) | (1 << CS12);

  // Output Compare
  OCR1A = 625;  // 16 us * 625 = 10 ms

  // Timer1 Interrupt einstellen (Compare mit OCR1A)
  TIMSK1 |= (1 << OCIE1A);

  sei();
  // Ende Setup ===========================

  // Programm Loop
  while(1)
  {
      if(gIR_sysTick_counter >= 50)
      {
        PORTB ^= (1 << LED);
        gIR_sysTick_counter = 0;
      }
      
      /*
      for(int i = 0; i < 17; i++)
      {}
      */
  }
}

[Stefan F. (Gast)]

Schreibe mal "volatile" for

> uint8_t gIR_sysTick_counter = 0;

Hintergrund: Die CPU kann auf Register schneller zugreifen, als auf RAM. 
Deswegen wird der Wert innerhalb der while Schleife in ein Register 
kopiert und dann nur noch das Register verwendet. Der Compiler ist nicht 
so schlau zu berücksichtigen, dass die ISR dazwischen kommen kann und 
den Wert ändern kann.

Mit dem Wort volatile zwingst du den Compiler dazu, bei jedem Zugriff 
wirklich auf das RAM zuzugreifen, ohne Abkürzungen zu verwenden.

Normalerweise setzt man den systick aber nicht auch 0 zurück, sondern 
lässt ihn durch laufen (samt Überlauf). In einem komplexeren Programm 
stößt du bei deiner Methode ganz schnell auf zahlreiche Probleme.

Benutze stattdessen die Subtraktion, um festzustellen, ob 50 Ticks 
stattgefunden haben:

vorher=gIR_sysTick_counter;
if (gIR_sysTick_counter - vorher > 50) {...}

Das funktioniert auch nach einem Überlauf korrekt.

In dem Zusammenhang könnte dieser Aufsatz für dich hilfreich sein: 
http://stefanfrings.de/multithreading_arduino/index.html

[Milli (millsen)]

Vielen Dank, jetzt geht es! Werde mir das noch mal genauer anschauen.

[Stefan F. (Gast)]

Falls du deine Variable auf mehr als 8 Bit vergrößerst, schreibe dir 
eine Hilfsfunktion die beim Lese-Zugriff Interrupts blockiert:

uint16_t get_systick()
{
    uint16_t value;
    cli();
    value=gIR_sysTick_counter;
    sei();
    return value;
}

Das sieht aufwändig aus, aber der Maschinencode der daraus generiert 
wird, ist ziemlich kompakt.

So verhinderst du, dass ein Lesezugriff durch die ISR gestört wird, was 
dazu führen würde, dass die oberen 8 Bit und die unteren nicht zusammen 
passen. Frage nach, wenn du das weiter ausdiskutieren willst.

[Milli (millsen)]

Hier tritt bei meinem Ansatz auch ein Problem auf, welches ich mir nicht 
erklären kann.

  uint8_t past = 0;
  (...)
  // Programm Loop
  while(1)
  {
      
      if(gIR_sysTick_counter - past >= 50)
      {
        PORTB ^= (1 << LED);
        past = gIR_sysTick_counter;
      }
  }

Die LED blinkt dann drei mal und leuchtet dann permanent. In past müsste 
nach dem dritten Mal leuchten ja 250 stehen. Nach meiner Berechnung 
sollte die nächste if(..) ausgeführt werden, wenn gIR_sysTick_counter 
bei 44 ist. Funktioniert aber nicht. In past müsste doch dann eine 50 
stehen, da ja beide unsigned sind.

[Stefan F. (Gast)]

Da bin ich jetzt überfragt. Das müsste eigentlich funktionieren.

Schaffe dir mal eine Möglichkeit zum Debuggen, oder zumindest 
Log-Meldungen ausgeben zu können. Dann kannst du die Werte der Variablen 
und auch das Ergebnis der Subtraktion kontrollieren.

Das "volatile" hast du aber noch drin, oder?

[Milli (millsen)]

Korrektur: "in past müsste doch dann eine 50 stehen" ist falsch, ich 
meinte natürlich das Ergebnis der Subtraktion.

Zu deiner Frage, ja, habe volatile stehen.

Hier nochmal der ganze Code:

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

#define F_CPU 16000000UL

// Ein- und Ausgänge definieren
#define LED     PB0

// Globale Variablen
volatile uint8_t gIR_sysTick_counter = 0;

// ISR
ISR(TIMER1_COMPA_vect)
{
  gIR_sysTick_counter++;
}


int main()
{
  uint8_t past = 0;

  // Setup ================================
  cli();

  // Ausgänge Setup
  DDRB |= (1 << LED);


  // Timer1 Mode CTC (Geht auf 0 wenn OCR1A erreicht) & Prescaler auf 256 (Bei 16 MHz wird alle 16 us hochgezählt)
  TCCR1B |= (1 << WGM12) | (1 << CS12);

  // Output Compare
  OCR1A = 625;  // 16 us * 625 = 10 ms

  // Timer1 Interrupt einstellen (Compare mit OCR1A)
  TIMSK1 |= (1 << OCIE1A);

  sei();
  // Ende Setup ===========================

  // Programm Loop
  while(1)
  {
      
      if(gIR_sysTick_counter - past >= 50)
      {
        PORTB ^= (1 << LED);
        past = gIR_sysTick_counter;
      }
  }
}

[S. Landolt (Gast)]

Was ist das Resultat der if-Abfrage, wenn past>(256-50), z.B. past=250?

[Stefan F. (Gast)]

Ich habe den Fehler mit dem Debugger und diesem Code nachvollziehen 
können:

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

#define LED     PB0

volatile uint8_t gIR_sysTick_counter = 250; // damit es schneller geht

int main() 
{
    uint8_t past=0;
    while(1)
    {      
        if(gIR_sysTick_counter - past >= 50)
        {
            PORTB ^= (1 << LED);
            past = gIR_sysTick_counter;
        }

        // simuliere Interrupts
        gIR_sysTick_counter += 10;
    }
}

Offenbar ist das Ergebnis des Ausdruckes "gIR_sysTick_counter - past" 
ein 16 Bit Integer. Erzwinge 8 Bit so, dann geht es:

        uint8_t diff=gIR_sysTick_counter - past;
        if(diff >= 50)

Da ich solche Warteschleifen bisher immer nur mit 16 Bit oder größeren 
Variablen programmiert habe, hatte ich das nicht auf dem Schirm.

Milli schrieb:
> Korrektur: "in past müsste doch dann eine 50 stehen" ist falsch, ich
> meinte natürlich das Ergebnis der Subtraktion.

Ist auch falsch, da müsste 250 drin stehen, vom vorherigen Moment wo die 
LED zuletzt getoggelt wurde.

[Milli (millsen)]

Danke, es funktioniert jetzt. Habe es auch mal mit 16-Bit Variablen und 
der empfohlenen Funktion getestet. Da läuft es ohne Probleme, auch nach 
Überlauf.

Ich würde mir das auch gerne noch mal mit dem Debugger ansehen, welche 
IDE nutzt du dafür? Ich programmiere in VS Code mit Platformio, da geht 
das Debuggen nicht so gut beim Atmega328P (oder?).

Stefan F. schrieb:
> Ist auch falsch, da müsste 250 drin stehen, vom vorherigen Moment wo die
> LED zuletzt getoggelt wurde.

Ja, in past müsste 250 stehen. Ich meinte im Ergebnis von 
gIR_sysTick_counter - past = 44 - 250 = 50.

[Stefan F. (Gast)]

Milli schrieb:
> Ich würde mir das auch gerne noch mal mit dem Debugger ansehen, welche
> IDE nutzt du dafür?

Für solche kleinen Tests bevorzuge ich das alte AVR Studio in einer 
virtuellen Maschine mit Windows XP.

Ernsthafte Programme compiliere ich unter Linux im Terminalfenster mit 
einem Makefile. Als Editor nutze ich Qt Creator. Visual Studio Code tut 
es auch gut.

Debuggen kannst du AVR nach meinem Kenntnisstand nur mit den IDEs von 
Atmel/Microchip. Es gab mal Frickeleien mit Open-Source Tools (sorry, 
falls sich da jemand betroffen fühlt), die habe ich aber nicht ans 
Laufen gebracht.

Siehe http://stefanfrings.de/avr_tools/index.html