AVR libc 328p, (Verständnis)Probleme mit Timern

[Alexander G. (jasmir)]

Hallo zusammen,

ich habe zwei Probleme mit Timern und komme nicht weiter:

1) Es funktioneren nicht zwei Timer gleichzeitig. Wenn ich im u.a. 
Programm den Timer2 wieder einkommentiere, tut die ISR für den Timer0 
genau garnichts mehr. Hat hier jemand nen Tipp für mich?

2) Der Timer (in diesem Fall Timer2) gibt eine ganz andere Frequenz 
zurück als erwartet. Der 328p sitzt auf nem Arduino-Nano Board, das mit 
16MHz Taktfrequenz angegeben ist. Die Kommentare im Code spiegeln meine 
Erwartung  & die Realität wieder. Vertue ich mich da irgendwie mit den 
Prescalern & dem Zähler, oder ist es normal das die Arduino-Boards 
derartig ungenau sind?


Hier das Programm:

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

// ********** Config **********

volatile uint32_t seconds = 68400;  // Startzeit bei PowerUp (19:00 Uhr)
uint8_t daemmerungSeconds = 10;    // Dauer der Daemmerung pro PWM-Stufe
uint8_t pwmTicksMax = 50;     // Anzahl der moeglichen PWM-Werte


uint32_t lichtAn_Kanal_1[2] = {25200,57600};  // Licht-An Zeiten (7 & 16 Uhr)
uint32_t lichtAusKanal_1[2] = {46800,79200};  // Licht-Aus Zeiten (13 & 22 Uhr)
volatile int8_t pwmDirKanal_1 = 1;      // PWM Vector bei Startzeit (1 -> wird heller, -1 -> wird dunkler, 0 bleibt so. Andere Werte sind properitär)


// ********** Config Ende **********

// http://www.avrfreaks.net/forum/tut-c-newbies-guide-avr-timers?name=PNphpBB2&file=viewtopic&t=50106
// https://sites.google.com/site/qeewiki/books/avr-guide/timers-on-the-atmega328

volatile uint16_t octalMilliseconds = 0;
uint8_t pwmTicks = 0;

volatile uint8_t pwmCurrentKanal_1 = 1;
volatile uint8_t pwmChangeTickKanal_1 = 0;


int main(void)
{
    TCCR0A |= (1 << WGM01);  // Uhr-Timer auf CTC setzen
    OCR0A = 0x02;    // Zaehlgrenze setzen (2)
    TIMSK0 |= (1 << OCIE0A);  // Set the ISR COMPA vect
    TCCR0B |= (1 << CS02);  // Prescaler auf 256 setzen

/** 
    TCCR2A |= (1 << WGM21);  // PWM-Timer auf CTC setzen
    OCR2A = 0x02;    // Zaehlgrenze setzen (2)
    TIMSK2 |= (1 << OCIE2A);  // Set the ISR COMPA vect
    TCCR2B |= (1 << CS21) | (1 << CS21);  // Prescaler auf 256 setzen
**/

    sei();      // Interrupts an

    DDRD = 0b11111100;    // Port D auf Output setzen, Pin 0 & 1 bleiben Input (Serial RX und TX)...
    PORTD = 0b00000000;    // und erstmal alle Ausgaenge auf 0.

    while(1) {
//        if(octalMilliseconds >= 31250) { // Sollten mit dem Prescaler 256 und der Zaehlgrenze von 2 genau eine Sekunde sein...
        if(octalMilliseconds >= 20838) { // Das ist wirklich eine Sekunde (ungefaehr...)
      seconds++;
      octalMilliseconds = 0;
            if(seconds >= 86400) {  //Reset der Sekunden am Tagesende
                seconds = 0;
            }
            // PWM-Setzen Kanal 1
            if((seconds == lichtAn_Kanal_1[0]) || (seconds == lichtAn_Kanal_1[1])) {
                pwmDirKanal_1 = 1;
            }
            if((seconds == lichtAusKanal_1[0]) || (seconds == lichtAusKanal_1[1])) {
                pwmDirKanal_1 = -1;
            }
      if(seconds == 75600) {  // Extra: Kanal um 21:00 Uhr runterdimmen
          pwmDirKanal_1 = -2;
      }
            if(pwmDirKanal_1 != 0) {
                if (pwmChangeTickKanal_1 == daemmerungSeconds) {
                    pwmChangeTickKanal_1 = 0;
                    pwmCurrentKanal_1 = pwmCurrentKanal_1 + pwmDirKanal_1;
        if ((pwmDirKanal_1 == -2) && (pwmCurrentKanal_1 <= 9)) {  // Extra: Kanal um 21:00 Uhr runterdimmen
            pwmDirKanal_1 = 0;
        }
                    if ((pwmCurrentKanal_1 == pwmTicksMax) || (pwmCurrentKanal_1 == 0)) { // wenn PWM-Max oder 0 erreicht sind, PWM-Dir wieder auf 0 setzen
                  pwmDirKanal_1 = 0;
              }
          }
          pwmChangeTickKanal_1++;
            }
            // ###################
        }
    }
}

/**
ISR (TIMER0_COMPA_vect)  // timer0 Uhr, alle 8 msec
{
    octalMilliseconds++;
}
**/

//ISR (TIMER2_COMPA_vect) {  // timer2 PWM, alle 32µsec
ISR (TIMER0_COMPA_vect) {  // Da keine zwei Timer funktionieren, Umbau auf nur einen Timer fuer alles
    // PWM-Teil
    if(pwmTicks <= pwmCurrentKanal_1) {
        PORTD |= (1 << PD7);  // Pin 7 auf 1
    }
    else {
        PORTD &= ~(1 << PD7);  // Pin 7 wieder auf 0
    }
    // ##############

    if(pwmTicks >=pwmTicksMax) {  // PWM-Zyklus resetten
      pwmTicks=0;
    }
    pwmTicks++;
    octalMilliseconds++;
}

PS: Das sind zwei Premieren für mich: Erstes Programm in C und erstes 
mal nen µC Programmieren. Sonstige Kritik ist erwünscht!