12 Stunden Verzögerung mit ATmega16A

Ich hatte das Bedürfnis, eine nicht blockierende Lösung für das Problem zu finden, insbesondere weil wir hier über zwölf Stunden Verzögerung sprechen.

Die Bibliothek util/delay.h und ihre Funktionen _delay_ms() und _delay_us() sind die Software-Verzögerungsfunktionen. Sie sind praktisch in kleinen Programmen und für schnelles Prototyping und Experimentieren. Sie sind einfach und die Genauigkeit könnte in vielen Fällen ausreichen, aber wir haben hier einen Nachteil. Da es sich um Softwareverzögerungen handelt, blockieren sie die CPU. Tatsächlich verwenden wir die CPU als Zähler/Timer, sodass wir in der Zwischenzeit nichts anderes tun können.

Mit Hardware-Timern ist es möglich, im Hintergrund zu zählen und Ereignisse mit Interrupts zu verarbeiten, sodass die CPU frei verwendet werden kann, während der Timer unabhängig läuft.

Der "Nachteil" ist, dass wir etwas mehr Dokumentation durchgehen und etwas mehr Code schreiben müssen, dafür aber eine höhere Genauigkeit und eine freie CPU bekommen .

Richten Sie einen Timer mit Interrupts ein

Ich werde den Timer1 von Atmega16A verwenden , der ein 16-Bit-Zähler ist. Die Taktfrequenz ist$f = \small 8\,MHz$und ich möchte, dass der Timer alle Sekunden einmal überläuft, und ich werde diese Sekunden zählen, bis 12 Stunden (43200 Sekunden) erreicht sind.

Schritte:

1. Bestimmen Sie die Taktrate und den maximalen Wert des Timers, um alle Sekunden einen Überlauf zu erhalten.
2. Stellen Sie die entsprechenden Register ein (Timer-Modus, Uhrenauswahl, Interrupt aktivieren, Wert vergleichen (Maximalwert))
3. Schreiben Sie unsere Interrupt Service Routine (ISR), um die Sekunden zu zählen und in diesem Fall die LED zu steuern.

Ausführung:

1. Wir beginnen mit:$f_{SystemClock} = \small 8\,MHz$, wenn wir diese Frequenz ohne Vorskalierung verwenden, hat der Timer in jedem ein Häkchen:
   
   $\large T_{timer} = \frac{1}{f_{SystemClock}} = \frac{1}{8\,MHz} = 0.125\,\mu s$

   Leider ist es zu schnell, also werden wir die Taktfrequenz um 256 vorskalieren.

   $\large f_{timer} = \frac{f_{SystemClock}}{256} = 31250\,Hz$

   $\large T_{timer} = \frac{1}{f_{timer}} = \frac{1}{31.250\,kHz} = 32\,\mu s$

   Für einen 1-Sekunden-Überlauf$\sum_{ticks} = \large \frac{1\,s}{32\,\mu s} = \small 31250$Ticks benötigt werden, (In diesem 1 s- Fall gibt die Frequenz diesen Wert eindeutig an.)
   Bei einem 16-Bit-Timer ist der maximal mögliche Wert:$2^{16} - 1 = 65535$, also passt unser Wert, nicht wie mit$8\,MHz$Wo$\small \sum_{ticks}$wäre zu hoch.

2. Nachdem wir die oben genannten Werte ermittelt haben, ist es an der Zeit, den Timer zu konfigurieren. Wir werden den CTC-Modus (Clear Timer on Compare match) des Timers verwenden, der es ermöglicht, einen benutzerdefinierten Maximalwert festzulegen.

   Im CTC-Modus wird der Zähler auf Null zurückgesetzt, wenn der Zählerwert (TCNT1) mit dem OCR1A (WGM13:0 = 4) übereinstimmt.

   • OCR1A =$\small \sum_{ticks} - 1$= 31250 - 1 = 31249, da der Zähler bei 0 beginnt.
   • WGM13:0 = 4,$\Rightarrow$daher muss nur das WGM12- Bit im TCCR1B- Steuerregister gesetzt werden

   Der nächste Schritt besteht darin, den Prescaler durch die Clock-Select-Bits im TCCR1B- Register auf 256 zu setzen. Hinweis: Die Zählung beginnt, sobald die Clock-Quelle ausgewählt ist.

   • CS12:0 = 4,$\Rightarrow$es muss also nur das CS12- Bit gesetzt werden.

   Nächste; Aktivieren Sie den entsprechenden Timer1-Interrupt im TIMSK- Register (Timer/Counter Interrupt Mask Register), der bei Erreichen des Maximalwerts ausgelöst wird.

   

   • Wir benötigen das Bit OCIE1A (Timer/Counter1, Output Compare A Match Interrupt Enable), das heißt, wenn es auf 1 geschrieben wird, wird der Timer/Counter1 Output Compare A Match Interrupt aktiviert. ( Im normalen Modus sollte das TOIE1-Bit (Timer/Counter1, Overflow Interrupt Enable) verwendet werden. )
3. Der letzte Schritt besteht darin, den Code der ISR und die Timer-Initialisierung zu schreiben.

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

#define LED     PC0

// global variable to count the seconds
volatile uint16_t sec_cnt = 0; 

// Timer1 initializtion
void init_timer1() 
{
    // Timer Mode 4: Clear Timer on Compare match (CTC)
    TCCR1B |= (1<<WGM12); 
    // Initialize Timer staring value
    TCNT1 = 0;
    // Set Compare value for 1s overflow
    OCR1A = 31249;
    // Enable Timer Compare A Match interrupt
    TIMSK |= (1<<OCIE1A);
    // Start Timer & Clock Select: Prescale I/O clock by 256
    TCCR1B |= (1<<CS12);
}

// Timer1 output compare match A interrupt rutine
ISR(TIMER1_COMPA_vect)
{   
    if(sec_cnt < 5)
    {
        PORTC |= (1<<LED);  // turn on LED in first 5 sec
    }
    else
    {
        PORTC &= ~(1<<LED);
    }

    sec_cnt++;

    if(sec_cnt == 43200)    // 12*60*60 = 43200
    {
        sec_cnt = 0;        // restart counting
    }
}

void main(void)
{
    // init Timer1
    init_timer1();
    // enable global interrupts
    sei();                  

    while(1)
    {
         // Let the ISR handle the LED ...
         // and do other stuff
    }
}

Dies ist nur eine Möglichkeit, die ISR zu schreiben, eine andere könnte ein Flag verwenden, das einen Zeitraum von 12 Stunden angibt, und dann die LED in der Hauptfunktion behandeln, wenn dieses Flag gesetzt ist. Für die 5-Sekunden-Verzögerung könnte entweder das _delay_ms(5000)(da es nicht so lang ist) oder ein separates Flag verwendet werden. Die Interrupt-Vektoren (zB: TIMER1_COMPA_vect) sind im Datenblatt aufgeführt.

Testen

Ich habe einen Pin innerhalb des ISR umgeschaltet, um das 1-Sekunden-Timing der Interrupts zu messen, und ich habe die LED alle 30 Sekunden für 5 Sekunden eingeschaltet. Das Ergebnis ist im Bild unten:

Beim 1-Sekunden-Wert konnte ein kleiner Fehler (~0,9 %) beobachtet werden, der durch die Ungenauigkeit des internen Oszillators verursacht wird. Laut Datenblatt ist es normal:

Bei 5 V, 25 °C und einer ausgewählten Oszillatorfrequenz von 1,0, 2,0, 4,0 oder 8,0 MHz ergibt diese Kalibrierung eine Frequenz innerhalb von ± 3 % der Nennfrequenz.

Zuerst müssen Sie die Taktgeschwindigkeitsmaskerade behandeln, die in den Kommentaren besprochen wird. Wenn Sie sicherstellen, dass Ihre Uhren richtig sind, würde ich den Code wahrscheinlich ein wenig umgestalten:

int32_t second;
for (second = 0; second < 60LL*60*12; ++second) {
    if (second < 5) {
        PORTC.0 = 1;
    } else {
        PORTC.0 = 0;
    }
    delay_ms(1000);
}

Beachten Sie jedoch, dass dieser Ansatz etwas ungenau ist, da Ihre Gesamtperiode länger als 1 Sekunde ist. Die Ausführung des Codes braucht Zeit, sei es sehr kurz im Vergleich zu den 1000 ms Wartezeit.

Ja, ich hasse auch diese 12-Stunden-Sperrschleife.

unsigned int seconds,mins,hours;

for(hours=0;hours<12;hours++)
{
    for(mins=0;mins<60;mins++)
    {
       for(seconds=0;seconds<60;seconds++)
       {
          delay_ms(1000);
       }
    }
}

led = 1;
delay_ms(5000);
led = 0;