Timer (Uhrzeit) ist ungenau

Hi,

also ich würde in der ISR nur ein Flag setzen, und die Auswertung nicht
in der ISR ausführen, sondern mittels einer Funktion die aus der
main-loop aufgerufen wird. Denn es werden vorm Reloaden der
Timerregister alle Befehle abgearbeitet, was Zeit kostet und die Uhr
ungenau macht.

Oder du zählst die verbrauchten Takte in der ISR für die Abfrage und
ziehst diese von den Reloadwerten ab.

Grüße,

Der2te_Michael

Jede Codezeile benötigt Zeit für die Ausführung !!!

Deshalb muß, einen Timer zu setzen nach einer rein willkürlichen
Ausführungszeit, zwangsläufig ungenau sein.

Hinzukommen noch bei größeren Programmen Verzögerungen durch andere
Interrupts.

Und genau deshalb haben die AVR-Entwickler die "Clear on Compare
Match" Funktion eingebaut. Nutze sie !


Außerdem sind MC-Quarze in der Regel etwas schneller als die
Nennfrequenz, d.h. entweder genau messen oder ne Weile laufen lassen,
ausstoppen und dann den Comparewert korrigieren.


Peter

Wie und wo muss ich in meiner oben aufgeführten Interrupt Routine was
verändern?

"bevor ihr mich nun schlagen tut =)"

Ja wollen wir.
Was sollen wir denn mit einem Hex-File anfangen ?


Peter

@Christoph:

TCNT1H=0xCF;
TCNT1L=0x2C;

Diese zwei Teile DIREKT als ERSTES in der Interrupt-Routine
aufrufen.

Dann wird der Timer IMMER mit einer definierten und gleichbleibenden
Verzögerung neu gesetzt.
Zum Abgleich dann TCNT1L tunen.

Gruss
Jadeclaw.

Etwas grundsätzliches zu der Interrupt-Routine:

da die Bedingungen, die abgearbeitet werden müssen, nicht konstant
sind, fütter den Timer am Anfang der Routine mit den Reload-Werten. Und
bei 10 Einsprüngen in der Sekunde soll die Abarbeitungsgeschwindigkeit
schon reichen.

Eleganzer ist aber auf alle Fälle Peters Vorschlag mit dem Clear on
Compare. Wenn die Hardware es anbietet, warum nicht nutzen?

Und im Assemblerlisting nachschauen, wieviel Pops und Pushes in der
Routine vom Compiler eingesetzt werden, genauso die 4 (?) Takte, die
der Controller braucht, um die Routine anzusprechen.

MW

Einfachste Variante für eine genaue Uhr: Timer-Prescaler so einstellen,
daß sich aus Quarzfrequenz dividiert durch Prescaler eine ganze Zahl
ohne Kommastellen ergibt. Dann das Timer-Compare Register mit einem
möglichst hohen Wert laden, durch den die zuvor erhaltene Zahl
dividiert, wieder zu eine ganze Zahl ergibt. Dann den Timer auf "Clear
on Compare match" (CTC-mode) einstellen und den Interrupt bei compare
match auslösen. In dem Interrupt dann einen Zähler incrementieren und
auf die Restzahl hin vergleichen und wenn sie erreicht ist, den Zähler
zurücksetzen und so weiter. So erhält man eine sehr genaue Sekunde, nur
abhängig von der Quarzgenauigkeit und völlig unbeeindruckt vom Code.

ich hab gedacht der timer läuft über -> interrupt -> timer läuft aber
gleich wieder weiter (verwende allerdings kein AVR)

ach jetzt da, hier wird keine autoreload genommen oder??

Hallo,

ich habe ein Beispiel gesehen von Peter Danneger:
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
/*********************************************************************** 
*/
/*      Insert Key Debouncing Here      */
/*********************************************************************** 
*/

#if XTAL % DEBOUNCE                     // bei rest
  OCR1A = XTAL / DEBOUNCE - 1;    // compare DEBOUNCE - 1 times
#endif
  if( --prescaler == 0 ){
    prescaler = (uchar)DEBOUNCE;
    second++;        // exact one second over
#if XTAL % DEBOUNCE      // handle remainder
    OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per
second
#endif
  }
}

Diesen Code habe ich an meine Applikation angepasst. Dabei habe ich die
If und Endif anweisungen entfernt. Stimmt dann dieser Code so:
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
/*********************************************************************** 
*/
/*      Insert Key Debouncing Here      */
/*********************************************************************** 
*/

#if XTAL % DEBOUNCE                     // bei rest
  OCR1A = XTAL / DEBOUNCE - 1;    // compare DEBOUNCE - 1 times
#endif
  if( --prescaler == 0 ){
    prescaler = (uchar)DEBOUNCE;
    second++;        // exact one second over
#if XTAL % DEBOUNCE      // handle remainder
    OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per
second
#endif
  }
}

Sorry mein Code sieht dann so aus:
interrupt [TIM1_COMPA] void timer1_compa_isr(void)
{
 if (XTAL % DEBOUNCE)                     // bei rest
  OCR1A = XTAL / DEBOUNCE - 1;    // compare DEBOUNCE - 1 times

  if( --prescaler == 0 )
   {
    prescaler = DEBOUNCE;
    sekunde++;
    Uhrzeit(sekunde);        // exact one second over
if(XTAL % DEBOUNCE)      // handle remainder
    OCR1A = XTAL / DEBOUNCE + XTAL % DEBOUNCE - 1; // compare once per
second
   }
}