Atmega32 Timer1 und Timer0 laufen nicht zusammen

[Jakob (Gast)]

Hallo, ich hab jetzt mich damit befasst 2 Timer zu benutzen, einen rein 
für die Zeit und einen für die Taster Abfrage, damit  sich die Zeit 
nicht überschreitet wenn ein Taster gedrückt wird.

Einzeln  laufen die Timer super, aber zusammen macht es nur der Timer0.
Habe ich irgendwo ein kleinen Fehler drinnen ? Ich bin aus anderen 
Einträgen nicht schlau geworden deswegen schicke ich mal mein Code mit.

 

void start_timer1(uint16_t prescale)
{  
  TCCR1B = 0;
  //16Bit Timer Initialisierung:
  if (prescale == 0)
  {
    TCCR1B = (1<<CS10) | (1<<WGM12);        //Prescaler = 1, CTC    //
  }
  if (prescale == 1)
  {
    TCCR1B = (1<<CS11) | (1<<WGM12);        //Prescaler = 8, CTC
  }
  if (prescale == 2)
  {
    TCCR1B = (1<<CS11) | (1<<CS10) | (1<<WGM12);  //Prescaler = 64, CTC
  }
  if (prescale == 3)
  {
    TCCR1B = (1<<CS12) | (1<<WGM12);        //Prescaler = 256, CTC
  }
  if (prescale == 4)
  {
    TCCR1B = (1<<CS12) | (1<<CS10) | (1<<WGM12);  //Prescaler = 1024, CTC
  }

  TIMSK = (1<<OCIE1A);        //Timerinterrupt für Vergleich aktivieren
  OCR1A = 16000 - 1;          //Vergleichswert bis wohin er durchzählt  zählt!(länge des Timers abhängig vom Prescaler)
  sei();                //Interrupts zulassen
}




/*Timer0 prescale------------------------------------------------------------*/



void start_timer0(uint8_t prescale0){
  
  TCCR0 = 0; //8bit Timer
  
  if (prescale0 == 0)
  {
    TCCR0 = (1<<CS00) | (1<<WGM01);
  }
  
  if (prescale0 == 1)
  {
    TCCR0 = (1<<CS01) | (1<<WGM01);
  }
  
  if (prescale0 == 2)
  {
    TCCR0 = (1<<CS01) |(1<<CS00) | (1<<WGM01);
  }
  
  if (prescale0 == 3)
  {
    TCCR0 = (1<<CS02) | (1<<WGM01);
  }
  
  if (prescale0 == 4)
  {
    TCCR0 = (1<<CS02) | (1<<CS00) | (1<<WGM01);
  }
  
  
  TIMSK = (1<<OCIE0);        //Timerinterrupt für Vergleich aktivieren
  OCR0 = 255 - 1;
  sei();
  
}
//__________________________________________________________________________

void start_clock(void)
{
  start_timer1(0); //Prescaler 0
  
}


void start_clock0(void)
{
  start_timer0(0);
}
//__________________________________________________________________________

ISR(TIMER0_COMP_vect){
  scan_key();
}    
  
ISR(TIMER1_COMPA_vect){
  
  
  
  MilSek++;
  if (MilSek==1000)
  {
    Sek++;
    MilSek=0;
    //PORTB = 0xFF;
  }
  
  if (Sek==59)
  {
    //PORTB = 0x00;
    Sek = 0;
  }

//__________________________________________________________________________

void scan_key() {
  
  
  unsigned  char key1,key2;
  key1 = PIND;
  key1 ^= 0x00;
  key1 &= 0xFF;
  if (key1 != 0){
    _delay_ms(4);
    key2 = PIND;
    key2 ^=0x00;
    key2 &=0xFF;
    if ((key1 == key2) & (key1 != lastkey)) {
      lastkey = key1;
      if (keybuf == 0){
        keybuf = key1;
      }
    }
  }
  else lastkey = 0;
}

[Wolfgang S. (wsm)]

Wenn ein TimerIRQ aktiv ist, wird der andere IRQ ausgeschaltet.

Dann muss man in der ISR die anderen IRQs wieder aktivieren.

W.

[Thomas E. (thomase)]

Jakob schrieb:
>   TIMSK = (1<<OCIE1A);        //Timerinterrupt für Vergleich aktivieren

>   TIMSK = (1<<OCIE0);        //Timerinterrupt für Vergleich aktivieren

Je nach Reihenfolge der Aufrufe wird damit der vorige Interrupt wieder 
abgeschaltet.
TIMSK |= .....!!!

mfg.

[Jakob (Gast)]

Ahhhh , vielen Dank jetzt ist es klar

[Karl H. (kbuchegg)]

Jakob schrieb:
> Hallo, ich hab jetzt mich damit befasst 2 Timer zu benutzen, einen rein
> für die Zeit und einen für die Taster Abfrage, damit  sich die Zeit
> nicht überschreitet wenn ein Taster gedrückt wird.

Nimm eine ordentliche Entprellung, dann hast du dieses Problem nicht.
Ein _delay_ms(4) in einer ISR ist nicht akzeptabel.
Wo auch immer du diese Entprellung her hast, sie ist nicht gut.

Entprellung
Die sog. PeDa Entprellung spielt alle Stücke, die du je brauchen wirst. 
Das Nachladen des Timers in der ISR kannst du dort rausnehmen, das ist 
alles nicht zeitkritisch. Wenn die ISR eine Aufrufhäufigkeit im kleinen 
Millisekundenbereich hat, dann reicht das. Das muss nicht allzu genau 
sein. Und genau den Fall hast du mit deiner Zeit-ISR. Die wird jede 
Millisekunde aufgerufen. Passt perfekt.

[Karl H. (kbuchegg)]

Tu dir weiterhin selbst einen Gefallen und sieh den sei() nicht als Teil 
der Timer Initialisierung an.


Das sei() kommt am besten hier hin ....

int main()
{

  alle Initialisierungen


  sei();              // <-----------------

  while( 1 )
  {

     Programmlogik

  }
}

... ist also die letzte Anweisung vor der Hauptschleife in main.

Dort ist er gut aufgehoben. Steckst du ihn aber in die diversen 
Initialisierungsfunktionen und hast du mehrere solche 
Initialisierungsfuntkionen, wirst du schnell den Überblick verlieren, 
welche Initialisierungen eigentlich noch mit abgeschalteten Interrupts 
laufen und bei welchen Initialisierungen die Interrupts schon global 
eingeschaltet sind. Je nachdem in welcher Reihenfolge du diese 
Initialisierfunktionen aus dem ersten Abschnitt in main() aufrufst ist 
das jedesmal anders.
Das sei() hat in diesen Funktionen nichts verloren. Er ist die globale 
Interruptfreigabe und die wird erst getätigt, nachdem das Setup ALLER 
Komponenten vollständig komplett ist.
'globale Freigabe', sozusagen der Hauptschalter -> daher in main().