mega8515 Timer-> Anfänger

//

// Demo Timer - JannikS

// uC     = Atmega8515

// F_CPU   = 8 MHz

// 

#include <avr/io.h>

#include <avr/interrupt.h>  // Hilfsdefintionen für Interrupts

int main(void)

{

  DDRB = 0xff; // Ausgang LED

  /**

  Datenblatt: http://www.atmel.com/dyn/resources/prod_documents/doc2512.pdf

  Ab Seite 80: Timer0

  Als am einfachsten verstehbarer Modus wird der Normal Mode (Seite 85) 

  von Timer0 gewählt:

  Ein 8-Bit Register zahlt von einem Anfangswert (Voreinstelltung 0) 

  bis 0xFF hoch. Wenn 0xFF erreicht ist, führt die nächste Erhöhung um 

  Eins zu einem Ergebnis von 0 (neuer Startwert zum Hochzählen) und zu 

  dem gewünschten Overflow-Interrupt

  Wie das Register TCCR0 (Timer/Counter Control Register) zu setzen ist, 

  um den Normal Mode einzustellen steht in Table 44 bei den Bits WGM01 

  und WGM02

  Eine weitere Einstellmöglichkeit ist, wie schnell hochgezählt werden

  soll. Das kann mit der vollen Taktrate F_CPU geschehen oder indem man

  die Taktrate durch einen Vorteiler (Prescaler) teilt. Die möglichen 

  Prescaler 1, 8, 64, 256, 1024 sind in Table 48 angegeben.

  Berechnung der Zeit bis zum Overflow bei verschiedenen Prescaler 

  Einstellungen

  Overflow = 1/F_CPU * 256

  Prescaler   Overflow

  1             32 us

  8            256 us

  64          2048 us

  256         8192 us

  1024       32768 us = 32,768 ms

  1s sind aber 1000 ms bzw. 1000000 us... 

  d.h. man braucht mehrere Overflow Interrupts in denen die nur Anzahl 

  der Interrupts gezählt wird und erst wenn die Anzahl mal die Dauer 

  die gewünschte Sekunde ergibt, wird die LED umgeschaltet.

  Wieviele Overflows braucht man für eine Sekunde bei verschiedenen 

  Prescaler Werten?

  Anzahl_Overflows = 1s / Zeit_für_einen_Overflow

  Prescaler   Overflow  Anzahl_Overflows    

  1             32 us    31250

  8            256 us    3906,25

  64          2048 us    488,28125

  256         8192 us    122,0703125

  1024       32768 us    30,517578125

  Bzw. die Gesamtrechnung ist:

  Anzahl_Overflows = 1 * F_CPU / 256

  Hier ist der Wert bei Prescaler 1 interessant: Die Anzahl der nötigen 

  ist Overflows ist nämlich eine ganze Zahl und das vereinfacht das 

  Programmieren!

  Dieser Wert wird im Timer0-Interrupt verwendet.

  */

  // 8-Bit TIMER0 Normal Mode, Prescaler 1

  TCCR0 = (0 << WGM01) | (0 << WGM00) 

          | (0 << CS02) | (0 << CS01) | (1 << CS00) ; 

  // Und den spezellen Timer0 Overflow Interrupt nicht nur konfigurieren, 

  // sondern auch zulassen (enablen) d.h. das Timer/Counter Interrupt Mask 

  // Register setzen (Seite 93)

  TIMSK = (1 << TOIE0);

  // Alle zugelassenen Interrupts einschalten

  sei();

  // Endlosschleife

  // 1. main() nie verlassen

  // 2. wird vom Timer0 Overflow Interrupt unterbrochen

  while(1)

  {

  }

}

/**

  Dies ist die Interruptroutine, die aufgerufen wird, 

  wenn der eingestellte Timer einen Überlauf hat.

  Der Name ist aus Datenblatt und aus avr/iom8515.h 

  ersichtlich. avr/iom8515.h ist die genaue Beschreibung

  deines µC und wird über avr/io.h eingebunden.

  Ein möglicher Interruptvektor steht dort im Abschnitt:

  // Timer/Counter0 Overflow

  #define TIMER0_OVF_vect      _VECTOR(7)

  Timer0 ist ein 8-Bit-Timer mit Overflow Modus 

*/

unsigned int Anzahl_Overflows;

ISR(TIMER0_OVF_vect)

{

  Anzahl_Overflows++;

  // Prüfen ob 1s voll

  if (Anzahl_Overflows == 1 * F_CPU / 256)

  {

    // LOW/HIGH mit Hilfe der XOR Bitmanipulation umschalten

    // das schaltet die LED(s) AN/AUS

    // In der Simulation auf die nächste Zeile einen Breakpoint setzen (F9)

    // und das Programm voll laufen lassen (F5). 

    // Dann mit Hilfe der Stop Watch im I/O View die Zeit bis zum 

    // nächsten Erreichen des Breakpoints messen.

    // (Nicht ungeduldig werden. Das dauert auf meinem Rechner ca. 65 s)

    PORTB ^= 0xFF; 

    // Zurücksetzen für nächste 1s Wartezeit

    Anzahl_Overflows = 0;

  }

}