Atmega8 Timer2 CTC Zeitabweichung

[Thomas W. (ram99)]

Hi
Ich bin ein wenig verwirrt. Ich benutze den Atmega8 mit einem 12 Mhz 
Quarz und dem Timer2 in CTC Mode.
Das unten aufgeführte Programm ruft den CTC Interrupt alle 1.002ms auf. 
In diesem zähle ich einen Zähler bis auf 998 um auf exakt 1s zu kommen. 
Über das Display gebe ich den Sekundenwert alle ~10Sek. aus.
Wenn ich jetzt warte bis die Puls Variable auf 600 springt (10 min.) 
steht meine Stopuhr (Iphone) welche parallel läuft auf 10 Minuten und 11 
Sekunden. Habe ich noch einen Fehler oder sind die Dinger so ungenau das 
11 Sekunden Abweichung möglich sind.

Gruß
Thomas


#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>
#include <stdint.h>
#include <stdio.h>
#include <avr/interrupt.h>
#define F_CPU 12000000UL

char Buffer[20];
uint16_t counter1 = 0, counter2 = 0, Puls = 0;

//------------------------------------------------------------------
int main(void)
{
//8 Bit Timer2 Einstellungen
TCCR2 |= (1<<WGM21) | (1<<CS21)| (1<<CS22);  //Teiler: 256, 12Mhz
OCR2 = 47;
TIMSK |= (1<<OCIE2);

sei();
lcd_init();
//------------------------------------------------------------------
//------------------------------------------------------------------
  while(1)
  {

  }
  return 0;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
ISR(TIMER2_COMP_vect) //Interrut Timer2 Vergleicher (Alle 1,002ms)
{
  counter1++;
  counter2++;

  if(counter1 >= 998) // Alle 1000ms Drehzahl berechnen (1,002ms X 998)
  {
    Puls++;
    counter1 = 0;
  }

  if(counter2 >= 9980) // Alle ~10s Wert ausgeben
  {
    counter2 = 0;

    lcd_setcursor( 0, 1 );
    itoa( Puls, Buffer, 10 );
    lcd_string(Buffer);
  }
}

[MWS (Gast)]

Laut Berechnung müsste das Ding 13 Sekunden in 10 Minuten falsch gehen, 
da ist eher's IPhone kaputt. Sieh Dir die Formel im Datenblatt zu CTC 
an, ist eigentlich für PWM zu finden, trifft hier aber genauso zu.

[PittyJ (Gast)]

Wie kommt man auf die 1002 bzw 998?
Sind da nicht noch irgendwelche Nachkomma-Reste zu beachten, die sich 
aufsummieren?

[Falk B. (falk)]

@Thomas Webster (ram99)

>Ich bin ein wenig verwirrt. Ich benutze den Atmega8 mit einem 12 Mhz
>Quarz und dem Timer2 in CTC Mode.
>Das unten aufgeführte Programm ruft den CTC Interrupt alle 1.002ms auf.
>In diesem zähle ich einen Zähler bis auf 998 um auf exakt 1s zu kommen.

Ob das so günstig ist?

>TCCR2 |= (1<<WGM21) | (1<<CS21)| (1<<CS22);  //Teiler: 256, 12Mhz

Stimmt. Aber 12 MHz / 256 = 46,875 kHz

>OCR2 = 47;

Das teilt durch 48! Denn der Zähler geht von 0-47!

Aber selbst wenn du durch 47 teilen würdest, kämen immer noch 997,34 Hz 
raus. Bei Teilung durch 998 bleibt eine Fehler von 660ppm, macht 40ms 
Fehler pro Minute und 57s Fehler pro Tag. Wie man es richtig macht, 
siehe

AVR - Die genaue Sekunde / RTC

Dein Methode mit 2 Zählern ist ungünstig. Es ist deutlich besser und 
einfacher, den 2. Zähler mit dem ersten zu verketten, anstatt parallel 
zu zählen. Damit vermeidet man ein Desynchronisieren durch 
Programmfehler.

>ISR(TIMER2_COMP_vect) //Interrut Timer2 Vergleicher (Alle 1,002ms)
>{
>  counter1++;
>  counter2++;

  if(counter1 >= 998) // Alle 1000ms Drehzahl berechnen (1,002ms X 998)
  {
    Puls++;
    counter1 = 0;
  }

>  if(counter2 >= 9980) // Alle ~10s Wert ausgeben
>  {
>    counter2 = 0;

>    lcd_setcursor( 0, 1 );
>    itoa( Puls, Buffer, 10 );
>    lcd_string(Buffer);
>  }
>}

Das ist ein No-GO! Solche Ausgaben haben in der ISR NICHTS zu suchen! 
Wenn nämlich deine LCD-Ausgabe länger als 2x1,002ms dauert, verschluckst 
du Interrupts. Siehe Interrupt. Besser so.

#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>
#include <stdint.h>
#include <stdio.h>
#include <avr/interrupt.h>
#define F_CPU 12000000UL

char Buffer[20];
volatile uint16_t Puls = 0;
volatile uint8_t flag_10s;

//------------------------------------------------------------------
int main(void)
{
//8 Bit Timer2 Einstellungen
TCCR2 |= (1<<WGM21) | (1<<CS21)| (1<<CS22);  //Teiler: 256, 12Mhz
OCR2 = 47;
TIMSK |= (1<<OCIE2);

sei();
lcd_init();
//------------------------------------------------------------------
//------------------------------------------------------------------
  while(1)
  {
     if (flag_10s) {
        flag_10s=0;
        lcd_setcursor( 0, 1 );
        itoa( Puls, Buffer, 10 );
        lcd_string(Buffer);
     }
  }
  return 0;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
ISR(TIMER2_COMP_vect) //Interrut Timer2 Vergleicher (Alle 1,002ms)
{
  static uint16_t counter1 = 0, counter2 = 0;

  counter1++;  

  if(counter1 >= 998) // Alle 1000ms Drehzahl berechnen (1,002ms X 998)
  {
    Puls++;
    counter1 = 0;
    counter2++;
    if(counter2 = 10) // Alle ~10s Wert ausgeben
    {
      counter2=0; 
      flag_10s=1;
    }
  }
}

[Falk B. (falk)]

12 MHz / 256 = 46,875 kHz

46,875 kHz = 5^6 * 3 (Primfaktorzerlegung)

Diese Zahl kann man nun ohne Rest aufteilen in 5^3=125 und 5^3*3=375. 
Den Teilerfaktor 125 packt man in den Hardwarezähler Timer 2 mit

OCR2 = 124; // Teiler durch 125!

Den Teilerfaktor 375 packt man in die ISR als Softwaretimer.

Damit bleibt nur noch die Toleranz vom Quarz als Fehler übrig.

Et voilà!

[Falk B. (falk)]

Mist, oben ist noch der falsche Teiler drin! Also gleich richtig machen.

#include <avr/io.h>
#include "lcd-routines.h"
#include <util/delay.h>
#include <stdint.h>
#include <stdio.h>
#include <avr/interrupt.h>
#define F_CPU 12000000UL

char Buffer[20];
volatile uint16_t Puls = 0;
volatile uint8_t flag_10s;

//------------------------------------------------------------------
int main(void)
{
//8 Bit Timer2 Einstellungen
TCCR2 |= (1<<WGM21) | (1<<CS21)| (1<<CS22);  //Teiler: 256, 12Mhz
OCR2 = 124;    // teilt durch 125 !!!
TIMSK |= (1<<OCIE2);

sei();
lcd_init();
//------------------------------------------------------------------
//------------------------------------------------------------------
  while(1)
  {
     if (flag_10s) {
        flag_10s=0;
        lcd_setcursor( 0, 1 );
        itoa( Puls, Buffer, 10 );
        lcd_string(Buffer);
     }
  }
  return 0;
}
//-------------------------------------------------------------------
//-------------------------------------------------------------------
ISR(TIMER2_COMP_vect) //Interrut Timer2 Vergleicher , 375 Hz
{
  static uint16_t counter1 = 0, counter2 = 0;

  counter1++;  

  if(counter1 >= 375) // Alle 1000ms Drehzahl berechnen (1,002ms X 998)
  {
    Puls++;
    counter1 = 0;
    counter2++;
    if(counter2 = 10) // Alle ~10s Wert ausgeben
    {
      counter2=0; 
      flag_10s=1;
    }
  }
}

[STK500-Besitzer (Gast)]

Falk Brunner schrieb:
> if(counter2 == 10) // Alle ~10s Wert ausgeben

Schönheitsfehler...

[Falk B. (falk)]

@  STK500-Besitzer (Gast)

>> if(counter2 == 10) // Alle ~10s Wert ausgeben

>Schönheitsfehler...

Aufmerksamkeitstest ;-)

(Scheiß C-Stolperfallen, ich vermisse TurboPascal 8-0)

[Thomas W. (ram99)]

Hi,
vielen Dank für die Hilfe. Ich habe jetzt erst nach über 5 Jahren wieder 
angefangen mit den Teilen zu arbeiten. Freu mich auch über den Hinweiß 
mit der Ausgabe des Werts in der ISR.
Die Idee mit der Primfaktorzerlegung finde ich auch cool

Danke

Thomas

[Praktiker (Gast)]

Thomas Webster schrieb:
> Wenn ich jetzt warte bis die Puls Variable auf 600 springt (10 min.)
> steht meine Stopuhr (Iphone) welche parallel läuft auf 10 Minuten und 11
> Sekunden.

Zum Überprüfen des Programms ist ein iPhone denkbar ungeeignet, weil es 
die Fehler nicht analysieren und nach Software- und Taktfehler trennen 
kann. Der Simulator in Atmel-Studio zeigt mit "Stop Watch" und "Cycle 
Counter" taktgenau die Zeiten und Prozessorzyklen an. Damit sieht man 
gleich, ob die Anzahl von Schleifendurchläufen oder die Zeit zwischen 
Timer-Interrupts richtig ist.