AVR - Die genaue Sekunde / RTC

Inhaltsverzeichnis

1 Einleitung
2 Lösung
3 Beispiel
4 Berechnung
5 Das Programm
6 Echtzeituhr mit Uhrenquarz
7 Links

[Bearbeiten] Einleitung

Oftmals sieht man Projekte, bei denen ein externer RTC-Baustein (engl. Real Time Clock, Echtzeituhr; z. B. PCF8583 mit I2C-Anschluss Datenblatt (PDF)) angeschlossen ist, ohne dessen Vorteil wirklich zu nutzen.

Die wichtigsten Vorteile einer externen RTC sind

Die Zeitzählung läuft während eines Ausfalls der Hauptstromversorgung über eine kleine Stützbatterie bei geringem Strombedarf weiter.
Es gibt hochgenaue RTCs, die man im Gegensatz zu Selbstbaulösungen nicht abgleichen muss.
Der Strombedarf eines externen RTC ist in der Regel etwas niedriger als die RTC Funktion eines Prozessors. Als Vergleich diene ein DS1302(300nA@2V) zu einem Mega32(5uA@2.7V) als nicht ganz neuer Vertreter, bzw. ein Mega324P(500nA@1.8V) als moderner Vertreter. Dieser Vorteil kommt bei Datenschreibern (engl. data logger) zum Tragen, welche die meiste Zeit inaktiv im Sleep Mode sind.

In allen anderen Fällen ist die zusätzliche Hardware nicht unbedingt nötig und man kann eine präzise Zeitbasis bequem mit dem Hauptquarz des Mikrokontrollers programmieren. Daraus ergeben sich sogar noch zusätzliche Vorteile, wie eine geringere Temperaturabhängigkeit und höhere Güte, die Quarze im MHz-Bereich gegenüber Quarzen im kHz-Bereich besitzen. Ich möchte hiermit die Angst vor dem bisschen Mathematik nehmen, welche zur Berechnung der Teilerfaktoren benötigt wird.

[Bearbeiten] Lösung

Speziell für den AVR kommen Quarze im Bereich 1MHz bis 16MHz zum Einsatz, d.h. in einer Sekunde werden 1.000.000 bis 16.000.000 Zyklen durchlaufen (Zyklen pro Sekunde = Frequenz). Möchte man eine Sekunde messen, kann man somit die entsprechende Anzahl Zyklen von Null an hochzählen oder von dem entsprechenden Wert bis auf 0 runterzählen. Für das Zählen bietet sich im µC der Compare-Modus eines Timers an.

Die obigen Zahlen lassen sich jedoch nicht in einer 16 Bit Variablen ausdrücken da sie zu gross sind und somit ist ein direktes Setzen des Compare-Wertes des Timers T1 im AVR nicht möglich. Deshalb unterteilt man die Quarzfrequenz in zwei Faktoren; der erste (Softwareteiler) bestimmt die Periode des Timers T1 und der zweite den Reloadwert eines Registers, welches im Timerinterrupt runtergezählt wird.

[Bearbeiten] Beispiel

Im Beispiel AVR wird ein 11,0592-MHz-Quarz verwendet, was einem üblichen Baudratenquarz entspricht, d.h. damit können die UART-Standardbaudraten erzeugt werden.

Der Softwareteiler wird mit 256 gewählt, d.h. 256 Timerinterrupts pro Sekunde, und kann somit mit nur einem einzigen Byte realisiert werden. Für größere Werte muß der Softwareteiler als int (2 Byte) deklariert werden. Bei kleineren Werten als 256 muss man beachten, dass der zweite Faktor immer noch in 2 Byte passt, um als Comparewert für den 16-Bit-Timer 1 verwendet werden zu können.

Die Timerroutine wird in einer Sekunde Softwareteiler-Mal aufgerufen. Mit diesen 256 Hz ergibt sich eine Timerinterruptzeit von ca. 4ms, die auch sehr gut zum Entprellen von Tasten benutzt werden kann. Eine Entprellroutine kann also bequem in den Timerinterrupt mit eingefügt werden. Beachten muss man nur noch, dass das Nullsetzen des Timers erst einen Zyklus nach dem Comparematch erfolgt.

[Bearbeiten] Berechnung

Die Berechnung des Comparewertes ist sehr einfach:

Comparewert OCR1A = 11059200 / 256 - 1 = 43199, Rest 0.

Da haben wir ja noch mal Glück gehabt, es gibt keinen Rest bei der Division und die Sekunde ist exakt 256 * 43200 = 11059200 Zyklen lang.
Theoretisch.
Denn selbst wenn auf dem Quarz eine Frequenz von 11,0592 Mhz aufgedruckt ist, so schwingt er doch auf einer etwas anderen Frequenz. Der Grund dafür sind Fertigungstoleranzen und natürlich die Tatsache, dass die Frequenz eines Quarzes auch von der Temperatur abhängig ist. Es gilt also zunächst einmal herauszufinden, auf welcher Frequenz der Quarz wirklich schwingt.

Dazu wird eine Uhr programmiert und mit dem theoretischen Wert laufen gelassen. Nun habe ich die Uhr einen Tag laufen lassen und festgestellt, dass sie 1,5 s nach geht (Dazu kann man beispielsweise die Tagesschau nutzen, welche jeden Tag um 20:00 (+einer konstanten Zeitverschiebung durch das Übertragungsmedium SAT,DVB-T, ...) beginnt und sogar eine Uhr dabei einblendet). D.h. die Quarzfrequenz beträgt in Wirklichkeit:

11059200 * (1 - 1,5 / 24 / 60 / 60) = 11059008 Hz.

Ausführliche Rechnung:

(Zyklen in 24h - Zyklen Verspätung) / Sekunden pro 24h = korrekte Frequenz
((24 * 60 * 60 * 256 * 43200) - (1,5 * 256 * 43200)) / (24 * 60 * 60) = 11059008 Hz.

Also die ganze Rechnung nochmal:

OCR1A = 11059008 / 256 - 1 = 43198, Rest 64.

Nun haben wir einen Rest und es würden uns jede Sekunde 64 Zyklen fehlen. Das geht natürlich nicht.

Deshalb wird jedesmal, wenn der Softwareteiler Null ist und die Sekunde weitergezählt wird, ein anderer Comparewert geladen. Dieser ist dann um den Rest größer. Und beim nächsten Timerinterrupt wird dann wieder der Comparewert geladen, der das Ergebnis der Division war.

Es ergeben sich somit:

255 * (43198 + 1) + 1 * (43198 + 64  + 1) = 11059008 Zyklen

Exakt so, wie wir es wollten.

[Bearbeiten] Das Programm

Nachfolgend nun das C-Programm. Da wir ja alle nicht gerne rechnen, lassen wir das einfach den C-Compiler erledigen. D.h. wir brauchen nur noch per Definition für XTAL den entsprechenden Wert eintragen und der Compiler rechnet alle nötigen Konstanten ganz alleine aus.

So ein Compiler ist auch ziemlich faul, der merkt sofort, wenn die Operanden für eine Berechnung alles Konstanten sind. Und ehe er sich damit abquält, extra Code für diese Berechnungen zu erzeugen, rechnet er es lieber selber aus und fügt das Ergebnis direkt in den Code ein.

Der Assembler kann auch 32-Bit Konstanten-Berechnungen ausführen. Allerdings muß man dann die entsprechenden Präprozessoroperationen benutzen. Man könnte auch eine Divisionsroutine aufrufen, aber dann würde ja echter Code erzeugt.

[Bearbeiten] Beispiel in C

Wichtig: Ab Ver.1.4.0 haben sich Namen/Funktionen geändert:

"There are currently two different styles present for naming the vectors. One form uses names starting with SIG_, followed by a relatively verbose but arbitrarily chosen name describing the interrupt vector. This has been the only available style in avr-libc up to version 1.2.x.

Starting with avr-libc version 1.4.0, a second style of interrupt vector names has been added, where a short phrase for the vector description is followed by _vect. The short phrase matches the vector name as described in the datasheet of the respective device (and in Atmel's XML files), with spaces replaced by an underscore and other non-alphanumeric characters dropped. Using the suffix _vect is intented to improve portability to other C compilers available for the AVR that use a similar naming convention...."

Quelle: http://www.nongnu.org/avr-libc/user-manual/group__avr__interrupts.html

/************************************************************************/
/*                                                                      */
/*          Precise 1 Second Timebase           */
/*                                                                      */
/*              Author: Peter Dannegger                                 */
/*                      danni@specs.de                                  */
/*                                                                      */
/************************************************************************/
// Target: Mega8, 2313
 
#include <avr/io.h>
#include <avr/interrupt.h>
#include <avr/signal.h>
 
 
#ifndef OCR1A
#define OCR1A OCR1  // 2313 support
#endif
 
#ifndef WGM12
#define WGM12 CTC1  // 2313 support
#endif
 
#ifndef PINC
#define KEY_INPUT   PIND    // 2313
#else
#define KEY_INPUT   PINC    // Mega8
#endif
#define LED_DIR     DDRB
 
//#define XTAL      11059201L   // nominal value
#define XTAL        11059008L   // after measuring deviation: 1.5s/d
 
#define DEBOUNCE    256L        // debounce clock (256Hz = 4msec)
 
#define uchar unsigned char
#define uint unsigned int
 
uchar prescaler;
uchar volatile second;          // count seconds
 
 
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
  }
}
 
 
int main( void )
{
  LED_DIR = 0xFF;
  while( KEY_INPUT & 1 );               // start with key 0 pressed
 
  TCCR1B = (1<<WGM12) | (1<<CS10);      // divide by 1
                    // clear on compare
  OCR1A = XTAL / DEBOUNCE - 1;          // Output Compare Register
  TCNT1 = 0;                            // Timmer startet mit 0
  second = 0;
  prescaler = (uchar)DEBOUNCE;          //software teiler
 
  TIMSK = 1<<OCIE1A;                    // beim Vergleichswertes Compare Match                    
                                        // Interrupt (SIG_OUTPUT_COMPARE1A)
  sei();
 
  for(;;){
    if( second == 60 )
      second = 0;
    PORTB = second;         // display second (binary)
  }
}

[Bearbeiten] Beispiel in Assembler

;************************************************************************/
;*                                                                      */
;*          Precise 1 Second Timebase           */
;*                                                                      */
;*              Author: Peter Dannegger                                 */
;*                      danni@specs.de                                  */
;*                                                                      */
;************************************************************************/
.nolist
.include "m8def.inc"
 
.equ    xtal      = 11059008
.equ    debounce  = 256
.equ    remainder = xtal - xtal / debounce * debounce
 
.def    isreg     = r15
.def    wr0       = r16
.def    iwr0      = r17
.def    prescaler = r18
.def    second    = r19
 
.list
    rjmp    init
.org    OC1Aaddr
    rjmp    OC1Aint
;-------------------------------------------------------------------------
OC1Aint:
    in  isreg, sreg
;************************************************************************/
;*          Insert Key Debouncing Here          */
;************************************************************************/
 
    ldi iwr0, high( xtal / debounce - 1 )
    out ocr1ah, iwr0
    ldi iwr0, low( xtal / debounce - 1 )
    out ocr1al, iwr0
 
    dec prescaler
    brne    _oci1
 
    ldi prescaler, debounce
    inc second
 
    ldi iwr0, high( xtal / debounce + remainder - 1 )
    out ocr1ah, iwr0
    ldi iwr0, low( xtal / debounce + remainder - 1 )
    out ocr1al, iwr0
_oci1:
    out sreg, isreg
    reti
;-------------------------------------------------------------------------
init:
    ldi wr0, 0xFF
    out ddrb, wr0
    sbic    pinc, 0
    rjmp    init
 
    ldi wr0, high( ramend )
    out sph, wr0
    ldi wr0, low( ramend )
    out spl, wr0
 
    ldi wr0, 1<<WGM12^1<<CS10
    out TCCR1B, wr0
 
    ldi wr0, high( xtal / debounce - 1 )
    out ocr1ah, wr0
    ldi wr0, low( xtal / debounce - 1 )
    out ocr1al, wr0
    out tcnt1l, wr0
    ldi prescaler, debounce
 
    ldi wr0, 1<<OCIE1A
    out TIMSK, wr0
    sei
main:
    ldi second, 0
_mai1:
    cpi second, 60
    breq    main
    out ddrb, second
    rjmp    _mai1
;------------------------------------

[Bearbeiten] Verbesserte Version mit durchlaufendem Hardwarezähler

Hier sind trotzdem kleine Verbesserungsvorschläge.

Wird im Timer die Option "Clear On Compare Match" verwendet, so verliert man den Overflow Interrupt. Oder möchte man nebenher noch eine Zeit mit dem Capture Interrupt messen, so benötigt man einen durchlaufenden Timer. Um dies zu erreichen, wird OCR1A nicht fest eingestellt, sondern bei jedem Aufruf um den gleichen Wert erhöht.

In Peters Code wurde der Rest auf einmal abgearbeitet. Damit erspart man sich bei jedem Interrupt einen Vergleich und die Verarbeitungszeit verkürzt sich in seinem Code. Der Unterschied zwischen kurzem und langem Interrupt ist hier der Rest. Bei den geänderten Codeschnipseln wird der Rest gleichmäßiger abgearbeitet. Der Unterschied zwischen kurzem und langem Interrupt beträgt 1 Takt.

ungetesteter Code für den durchlaufenden Timer:

SIGNAL (SIG_OUTPUT_COMPARE1A) {
/************************************************************************/
/*      Insert Key Debouncing Here      */
/************************************************************************/
 
  if( --prescaler == 0 ){ 
    prescaler = (uchar) DEBOUNCE;
    second++;      // exact one second over  
  }  
#if XTAL % DEBOUNCE
  if (prescaler <= XTAL % DEBOUNCE)
    OCR1A += XTAL / DEBOUNCE +1;   /* um 1 Takt längere Periode um den Rest abzutragen */
  else
#endif
    OCR1A += XTAL / DEBOUNCE;   /* kurze Periode */
}

[Bearbeiten] Durchlaufender Hardwarezähler und fortlaufende Addition

Gänzlich ohne Hin- und Hertogglen eines Bits kommt man aus, wenn irgendein Timer mit einer Überlauf-Interruptfrequenz > 1Hz arbeitet. Dann kann die ISR eine 32-bit-Konstante auf einen 32-bit-Akkumulator addieren; bei Überlauf ist eine Sekunde vergangen. Zugegeben, es gibt "lange" und "kurze" Sekunden, aber der Fehler summiert sich nicht, und der Code ist sehr einfach.

Hier ein Beispiel:

Es gibt ein Programm gettick(), das einen Wert holt. Dieser Wert wird von Zeit zu Zeit von der Hardware (Beispiel AVR: der Timer) oder dem Betriebssystem (Beispiel Linux: gettick ruft getmsec, getmsec ruft gettimeofday)

Dieser aufgerufene Wert sollte pro Sekunde um TICKPERSEC erhöht werden, was aber mit einer gewissen Ungenauigkeit geschieht.

Die Laufzeitkorrektur wird dadurch ausgeführt, dass der von gettick() zurückgegebene Wert mit einem Faktor TFAK multipliziert wird. Der Faktor sollte so gewählt werden, dass:

Das Ergebnis actual_value immer in 32 Bit hineinpasst.
Die Multiplikation durch Schiebeopertionen ersetzt werden kann, weil der Faktor eine 2-er-Potenz ist. (Das erledigt avr-gcc)

Immer wenn tsdaytim_calibrated() erkennt, dass eine Sekunde vergangen, wird last_value um die Zahl onesecond erhöht.

Der Zahlenwert onsecond wird mit TICKPERSEC*TFAK initalisiert und kann angezeigt oder neu eingegeben werden (Die Bedienung der seriellen Schnittstelle hierfür ist in diesem Beispiel nicht enthalten).

Wenn festgestellt wird, dass die Uhr pro Zeit (P) um (E) zu schnell geht, dann kann der Wert onsecond korrigiert werden.

c = d * (P+E)/P Beispiel Pro 7 Tage 120 Sekunden zu viel:

7 Tage = 7*86400= 604800 sekunden c = 992000000 * (604800+120)/604800=991803175 Dann wird die Uhr genauer gehen.

/****************************************************************/
/* File home/cc/qq/danclock.cpp                                 */
/*          Precise 1 Second Timebase                           */
/*                                                              */
/*      Author: Peter Dannegger / Hjherbert                     */
/*          danni@specs.de                                      */
/*                                                              */
/****************************************************************/
// Target: atmega8, (2313?)
 
#include <avr/io.h>
#include <avr/interrupt.h>
// #include <avr/signal.h>
 
 
#ifndef OCR1A
#define OCR1A OCR1  // 2313 support
#endif
 
#ifndef WGM12
#define WGM12 CTC1  // 2313 support
#endif
 
#ifndef PINC
#define KEY_INPUT   PIND    // 2313
#else
#define KEY_INPUT   PINC    // Mega8
#endif
 
//#define F_CPU     11059201L   // nominal value
 
 
#define DIVISOR 256
 
#define TICKPERSEC  (F_CPU/DIVISOR)
 
uint8_t volatile second;            // count seconds
 
 
 
// TFAK ? TICKPERSEC must not exceed 2^32
#define TM (0x7FFFFFFFUL/2/TICKPERSEC)  // max of TFAK
 
 
#define TFAK ( (  (TM>>1) | (TM>>2) | (TM>>3)  | (TM>>4)  | (TM>>5)  | (TM>>6)  | (TM>>7) \
                | (TM>>8) | (TM>>9) | (TM>>10) | (TM>>11)  | (TM>>12)  | (TM>>13)  | (TM>>14)  | (TM>>15) \
                | (TM>>16) | (TM>>17) | (TM>>18) | (TM>>19)  | (TM>>20)  | (TM>>21)  | (TM>>22)  | (TM>>23) \
                | (TM>>24) | (TM>>25) | (TM>>26) | (TM>>27)  | (TM>>28)  | (TM>>29)  | (TM>>30)  | (TM>>31) \
               ) + 1 )
// TFAK is a power the biggest power of two which is less than TM
 
 
uint32_t onesecond = 1*TICKPERSEC*TFAK ;    // correct this value if see the clock is late / too fast
uint32_t last_value ;
uint32_t ticks ;
 
 
SIGNAL (SIG_OUTPUT_COMPARE1A)
{
    ++ticks ;
}
 
 
uint32_t gettick( void )
{
    uint32_t l ;
    cli();
    l = ticks ;
    sei();
    return l ;
}
 
 
void tsdaytim_calibrated(void)
// Keep the time-of-the-day actual
// Add a second, if a second if gone
{
    uint32_t actual_value ;         // gettick() multiplied by factor 2^n
 
 
    actual_value = gettick() * TFAK ;   // because TFAK is a power of two
                                        // The compiler will create some shift commands
 
    if ( actual_value - last_value > onesecond )
    {                           // once per second
        if ( ++second >= 60 )
        {
            second = 0 ;
        }
        last_value += onesecond ;   // One second more
    }
}
 
 
int main( void )
{
    DDRB = 0xFF;
    while( KEY_INPUT & 1 );         // start with key 0 pressed
 
    TCCR1B = 1<<WGM12^1<<CS10;      // divide by 1
                                    // clear on compare
    OCR1A = DIVISOR ;               // Output Compare Register
    TCNT1 = 0;                      // Timer start value
    second = 0;
 
    TIMSK = 1<<OCIE1A;              // beim Vergleichswertes Compare Match
                                    // Interrupt (SIG_OUTPUT_COMPARE1A)
    sei();
    last_value = gettick() * TFAK ;
    for(;;)
    {
        tsdaytim_calibrated();
        PORTB = second;             // display second (binary)
    }
}

[Bearbeiten] Echtzeituhr mit Uhrenquarz

[Bearbeiten] RTC mit wenig Stromverbrauch

Das vorgestellte Verfahren ist leider nicht direkt anwendbar, wenn man eine RTC mit einem 32,768 KHz Uhrenquarz realisieren möchte. Dieser Weg ist dann notwendig, wenn der Controller batteriebetrieben sehr lange laufen soll und durch Verwendung des Sleep Mode Strom gespart wird.

[Bearbeiten] Begrenzung der Auflösung

Wo liegt das Problem? Das obige Verfahren nutzt recht hochfrequente Quarze mit 1 MHz und mehr. Wenn man die Frequenz eines Quarzes von 1 MHz = 1.000.000 Hz mit einer Auflösung von 1 Hz angibt, entspricht das einem maximalen Fehler von 1/1.000.000 oder 1ppm (engl. parts per million, millionstel Teil). Das ist sehr wenig. Eine RTC mit einem Fehler von 1ppm hat eine Gangabweichung von 86,4ms pro Tag, oder 2,5s pro Monat. Das ist ein sehr guter Wert. Wenn ich nun aber die Frequenz 32768 Hz mit 1 Hz Auflösung angebe, ist das schlimmstenfalls ein Fehler von 1/32768 = 30,5ppm, was einer Abweichung von 2,5s pro Tag und 75s pro Monat entspricht!

[Bearbeiten] Uhrentakt genau messen und digital korrigieren

Wie kann man das Problem lösen? Die AVRs können im Sleep Mode den Uhrenquarz nur am Timer 2 betreiben, welcher ein 8 Bit Timer ist. D.H. ein Überlauf passiert alle 256 Takte, sprich 7,8125ms (=128 Hz). Man kann auch einen Prescaler verwenden, welcher das Problem aber nicht löst.

Wie bereits festgestellt, müssen wir die Frequenz des 32768Hz Uhrenquarzes genauer messen und darstellen. Wir wollen hier annehmen, dass wir die Frequenz auf 0,001Hz = 1mHz (Millihertz) auflösen, ein guter Frequenzzähler kann das problemlos und ist auch so genau. Wir können beispielsweise feststellen, dass ein Quarz mit 32768,423Hz schwingt, das entspricht einem Fehler von

$F_r=(\frac{f_{ist}}{f_{soll}} -1 )\cdot 10^6=(\frac{32768,423}{32768} -1 )\cdot 10^6=12,9ppm$

Dabei ist zu beachten, daß diese Messung nicht direkt am Quarz erfolgen darf, auch nicht mit kapazitätsarmen 10:1 Tastköpfen! Denn so ein Quarz wird von kleinsten Kapazitäten im Bereich von weniger als ein pF messbar verstimmt. Darum muss man in so einem Fall den Uhrentakt auf ein anderes IO-Pin ausgeben und dort messen. Beim MSP430 ist das einfach, man kann ACLK auf ein Pin direkt ausgeben. Der AVR kann das leider nicht. Hier muss man zu einem Trick greifen. Man benutzt die Output Compare Funktion, um mit Timer 2 einen 128 Hz Takt zu erzeugen. Dieser ist fest mit dem Uhrentakt verbunden und kann anstellte dessen gemessen werden, ohne den Quarz zu verstimmmen. Die Messung ergibt in diesem Fall eine Frequenz von 128,00165 Hz.

OK, jetzt haben wir den Takt gemessen, wir wissen, daß pro Sekunde 128 Timerüberläufe passieren (Prescaler =1). Wir wissen, dass unser Quarz pro Sekunde um 0,423 Takte zu schnell ist. Wir können aber keine halben Takte mehr oder weniger zählen? Doch! Mit Festkommaarithmetik! Denn nach 1000s ist unser Quarz um 423 Takte zu weit gelaufen und muss um diese Anzahl zurückgestellt werden. Also könnte man im ersten Ansatz nach 1000 Sekunden den Timer 2 um diesen Betrag korrigieren. Das Problem dabei ist nur, dass der Zähler nur 8 Bit breit ist. Ein Addieren oder Subtrahieren von 423 würde mehrfache Überläufe verursachen, welche programmtechnisch nur schwer zu handhaben wären. Also muss eine etwas bessere Methode her.

[Bearbeiten] Bresenham für RTCs

Wenn man sich die Idee der Festkommaarithmetik mal eine Weile durch den Kopf gehen lässt, kommt man vielleicht auf folgende Idee. Der Frequenzfehler beträgt in unserem Beispiel 0,423 Hz, also Takte pro Sekunde. Oder aber 423 Tausendstel Takte pro Sekunde. Nach drei Sekunden sind es schon 1,269 Takte oder 1269 Tausendstel Takte. Moment! Einen Takt können wir korrigieren, indem wir den Zähler um 1 Takt zurück setzen. Den Restfehler von 269 Tausendstel merken wir uns und akkumulieren weiter. Wenn dann wieder die 1000er Marke überschritten wird machen wir das Gleiche. Analog dazu natürlich auch bei negativem Vorzeichen, sprich wenn der Quarz zu langsam schwingt wird er um einen Takt vorgestellt. É Voilà! Dieses Verfahren ist sehr ähnlich zum Bresenham-Algorithmus zum Zeichnen von Linien auf Computermonitoren.

[Bearbeiten] Beispielprogramm

Das folgende Beispiel stellt eine RTC mit sehr niedrigem Stromverbrauch zur Verfügung. Laut Datenblatt beträgt die Stromaufnahme nur ca. 6µA bei 3V Versorgungsspannung, besser als einige kommerzielle RTCs! Möglich macht das die Nutzung des Power Save Sleep Modes. Die Frequenz kann auf $10 - 5$ Hz genau abgeglichen werden, was in diesem Fall bei einer Messfrequenz von 128Hz einer Auflösung von 0,078ppm entspricht. Das bedeutet eine Abweichung von 6,7ms pro Tag, 0,2s pro Monat oder 2,46s pro Jahr!

Die Abweichung des Quarzes wird in einer vorzeichenbehafteten 16 Bit Variable in der Einheit $10 - 3$ Hz gespeichert. D.h. es kann ein Frequenzfehler von +/- 32,768 Hz korrigiert werden, das sind 1000ppm! Normale Quarze haben Abweichungen von max. 100ppm, meist viel weniger. Jede Sekunde wird der Frequenzfehler neu berechnet und in den darauffolgenden 128 Interrupts ggf. mehrfach korrigiert. Wichtig ist dabei, dass die Korrektur wirklich ganz am Anfang der ISR steht, weil hier das Timing wirklich kritisch ist. Denn innerhalb eines Uhrenquarztaktes von ~30µs muss der Timer 2 neu beschrieben werden. Bei 1 MHz RC-Oszillatortakt sind das nur 30 Takte, wovon 6 zum Aufwachen und 4 zum Anspringen der ISR benötigt werden. Dazu kommen noch das Sichern einiger Register am Anfang der ISR, was man im C nicht direkt sieht. Sicherheitshalber sollte man auch einen höheren Takt einstellen, z. B. 2 MHz, dann ist das Timing wesentlich entspannter.

/*
************************************************************************
*
* Stromsparende Echtzeituhr mit 32768Hz Uhrenquarz
*
* ATmega88 mit internem 2 MHz Oszillator + 32,768 kHz Quarz
*
* Fuses bleiben auf Standardeistellungen
* LOW Fuse Byte = 0x62
* HIGH Fuse Byte = 0xDF
* EXT Fuse Byte = 0xF9
*
* LED mit 1K Vorwiderstand an PB5
* Kalibriertaktausgang an PB3
************************************************************************
*/
 
#define F_CPU 2000000L          // Systemtakt in Hz
#define F_CAL 12800000L         // gemessener Kalibriertakt in 10^-5 Hz
                                // Endung L ist wichtig!
 
#define LED_TOGGLE PORTB ^= (1<<PB5);
 
#include <avr/io.h>
#include <avr/sleep.h>
#include <avr/interrupt.h>
#include <avr/eeprom.h>
#include <util/delay.h>
 
// EEPROM Daten
 
int16_t ee_rtc_cal EEMEM = (F_CAL-12800000)*256/100;        // Kalibrierung für RTC, Frequenzfehler in 1/1000 Hz
 
// globale Variablen
 
// beidseitiger Zugriff durch ISR und Hauptprogramm
 
volatile uint32_t time;             // 24h Zeitstempel, 1s Auflösung
volatile int16_t rtc_cal;           // Kalibrierung des 32K Quarzes
volatile uint8_t flag_1s;           // Flag für 1s Intervall
 
void long_delay(uint16_t ms) {
    for (; ms>0; ms--) _delay_ms(1);
}
 
 
int main (void) {
 
// Clock divider auf /4
 
    CLKPR = 0x80;       // update  enable
    CLKPR = 2;          // Prescaler /4
 
// IO konfigurieren
 
    DDRB  = (1<<PB3) | (1<<PB5);
    PORTB = ~((1<<PB3) | (1<<PB5)); // Pull ups 
    PORTC = 0xFF;       
    PORTD = 0xFF;
 
// Analogcomparator ausschalten
 
    ACSR = 0x80;
 
// Timer2 konfigurieren
 
    ASSR   = (1<< AS2);             // Timer2 asynchron takten
    long_delay(1000);               // Einschwingzeit des 32kHz Quarzes
    TCCR2A = (1<<COM2A1) | (1<<WGM21) | (1<<WGM20); // Fast PWM, non inverted
    TCCR2B = 1;                     // Vorteiler 1 -> 7,8ms Überlaufperiode
    OCR2A  = 128;                   // PWM, Tastverhältnis 50%
    while((ASSR & (1<< TCR2BUB)));  // Warte auf das Ende des Zugriffs
    TIFR2  &= ~(1<<TOV2);           // Interrupts löschen
    TIMSK2 |= (1<<TOIE2);           // Timer overflow Interrupt freischalten
 
// EEPROM Werte auslesen
 
    rtc_cal= eeprom_read_word(&ee_rtc_cal);
 
// Interrupts freigeben
 
    sei();
 
// Endlose Hauptschleife
 
    while(1) {
 
        while((ASSR & (1<< OCR2AUB)));  // Warte auf das Ende des Zugriffs
        set_sleep_mode(SLEEP_MODE_PWR_SAVE);
        sleep_mode();                   // in den Schlafmodus wechseln
 
        // hier wachen wir wieder auf, nach Ausführung des 7,8ms Timerinterupt
 
        if (flag_1s) {  
            flag_1s =0;
            LED_TOGGLE                      // Test
        }
 
    }
}
 
// Timer2 overflow Interrupt
 
ISR(TIMER2_OVF_vect) {
    static uint8_t ticks;               // Hilfsvariable für Messintervall
    static int16_t time_error;          // RTC Fehlerkompensation
 
    // Zeitkritische Dinge, welche am Anfang der ISR stehen müssen!
 
    OCR2A=128;                          // Dummy-Write zur Sicherung des Timings
                                        // von Timer 2 im asynchronen Modus 
 
    // RTC Fehler korrigieren
 
    if (time_error>999) {               // RTC zu schnell
        TCNT2 = 2;                      // Zähler einen Schritt zurück setzen (2 Takte Verzögerung!)
        time_error -= 1000;
    } else if (time_error<-999) {       // RTC zu langsam
        TCNT2 = 4;                      // Zähler einen Schritt vor setzen (2 Takte Verzögerung!)
        time_error += 1000;     
    }
 
    // ab hier ist es nicht mehr zeitkritisch
 
    // Echtzeituhr
    ticks++;                            // 1/128tel Sekunde
    if (ticks==128) {                   // Sekundenintervall
        time_error += rtc_cal;          // RTC Fehler akkumulieren
 
        // 24h Timer
        time++;
        if (time==86400) time=0;        // 24h Überlauf
 
        ticks=0;
        flag_1s =1;                     // setzte Flag für 1s Verarbeitung in main Endlosschleife
    }
}

[Bearbeiten] Weitere Verbesserungen

Der Algorithmus ermöglicht eine sehr hochauflösende Kalibrierung der RTC. Allerdings heisst das leider noch lange nicht, daß die RTC dann auch wirklich so genau ist. Denn diese Kalibrierung gilt nur für eine exakte Temperatur! Auch ein Quarz hat eine Temperaturabhängigkeit der Schwingfrequenz. Wenn man nun eine sehr genaue RTC bauen möchte, welche über einen grossen Temperaturbereich genau läuft, muss man periodisch die Temperatur messen und in die Kalibrierung einbeziehen. Einen typischen Temperaturverlauf des Frequenzfehlers zeigt das folgende Bild.

Temperaturgang eines Uhrenquarzes

Weiterhin kann man natürlich die Kalibrierung ohne erneutes Kompilieren des Quelltextets vornehmen, indem man den Kalibrierwert per UART oder I2C an den AVR sendet und im EEPROM speichert.

Kernpunkt der Kalibrierung ist natürlich die Messung der realen Quarzfrequenz. Die oben beschriebene Methode per Tagesschau und 1 Tag warten ist sehr zeitaufwändig und hat eine begrenzte Genauigkeit von ca. 1/2 Sekunde, das entspricht 5,8ppm. Hier muss zwangsläufig ein guter Frequenzzähler her. Da dieser nicht jedem Hobbybastler zur Verfügung steht, muss man sich in Lehrwerkstätten, Universitäten oder Firmen im Elektronikbereich umsehen und nachfragen, ob man einen Frequenzzähler vor Ort kurze Zeit nutzen kann.

[Bearbeiten] Links

www.mikrocontroller.net

▶ Dieser Artikel

▶ Benutzer

▶ Suche

▶ Werkzeuge