Atmega 16 Timer1 in Simulation ok aber in in Real

[Frank (Gast)]

Guten Morgen zusammen,

Ich habe ein Problem mit meinem Timer1 auf meinem Atmega 16

Und zwar nutze ich den Output Compare Interrupt vom Timer 1

Diesen stelle ich mit OCR inhalt(0x0753) auf ca 10ms.

In der ISR toggle ich nun einen Pin an Port B.
In dieser Simulation toggelt er auch mit ca 10ms.

Aber in der realität variert das toggel mal von 10 auf 30 oder 20 ms.

woran könnte soetwas liegen?
Das sieht so aus als wenn irgendetwas verhindert das die ISR aufgerufen 
wird.

Könnte mal jemand schauen ob er etwas findet was falsch sein könnte ?

Hier der Code

//////////////////////////////////////////////////
// Interupt Service Routinen          //  
//////////////////////////////////////////////////

//Alle 10ms tritt ein Timer1 Output Compare Interrupt auf.  
ISR (TIMER1_COMPA_vect)
{    
  TCNT1L    =  0x00;  //Timer1-Compare-Wert wieder 
  TCNT1H    =  0x00;  //auf 0 setzen
  PORTB ^= (1<<PB0);
}


// Interrupt speichert den Taster-Status in Variablen ab.
SIGNAL (SIG_OVERFLOW0)      // every 10ms
{
  //static unsigned char ct0, ct1, rpt;
   //unsigned char i;

  TCNT0 = (unsigned char)(signed short)-(XTAL / 1024 * 10e-3 + 0.5);  // preload for 10ms
  PORTB ^= (1<<PB1);
}


//////////////////////////////////////////////////
// Main-Schleife                //  
//////////////////////////////////////////////////  
int main (void)
{
  //Initialisierung
  TCCR1A    =  0x00;          // Timer 1 Initialisieren
  TCCR1B    |=  ((1<<CS11) | (1<<CS10));// Prescaler auf "64"
  TIMSK    |=  (1<<OCIE1A);      // Output Compare A Interrupt  
  OCR1AH    =  0x07;          // einschalten. Interrupt bei:
  OCR1AL    =  0x53;          // OCR1 Inhalt = 12Mhz / 64 * 0,0005s (500us)
                      // =005E(500us)
                      // =00BC(1ms)
                      // =0753(10ms)

  // Im SIMULATOR etwas realistischer bei F_CPU = 1MHz
  //OCR1AH    =  0x01;
  //OCR1AL    =  0x08;

//  TCCR0     = 1<<CS02^1<<CS00;      // divide by 1024
//  TIMSK     |= 1<<TOIE0;          // Time 0 Initialisieren

  //PORT-Initialisierung
  LCD_DDR    =    0xFF;    // PORT A Ausgang Text LCD
  DDRB = 0xFF;
  DDRC = 0xFF;

  while (1)
  {
    PORTB ^= (1<<PB2);
    
  }
  
}

[Oliver J. (skriptkiddy)]

Für deinen Fall hat Atmel den CTC-Modus in die AVR-Timer integriert.
Versuchs mal damit.

[spess53 (Gast)]

HI

>Aber in der realität variert das toggel mal von 10 auf 30 oder 20 ms.

Woran siehst du das?

>ISR (TIMER1_COMPA_vect)
>{
>  TCNT1L    =  0x00;  //Timer1-Compare-Wert wieder
>  TCNT1H    =  0x00;  //auf 0 setzen
>  PORTB ^= (1<<PB0);
>}

>SIGNAL (SIG_OVERFLOW0)
>  TCNT0 = (unsigned char)(signed short)-(XTAL / 1024 * 10e-3 + 0.5);  // >preload 
for 10ms
>  PORTB ^= (1<<PB1);

Schon mal etwas von CTC gehört?

MfG Spess

[Karl H. (kbuchegg)]

>

> ISR (TIMER1_COMPA_vect)
> {    
>   TCNT1L    =  0x00;  //Timer1-Compare-Wert wieder 
>   TCNT1H    =  0x00;  //auf 0 setzen
>   PORTB ^= (1<<PB0);
> }
>

Bei allen 16 Bit Registern. Beim Schreiben: erst High, dann Low

Durch das Beschreiben des Highbytes wird das Register gesperrt, diese 
Sperre wird durch das Beschreiben des Lowbytes wieder aufgelöst.

Aber dein Compiler weiß das alles und bietet dir Pseudo-16 Bit Register 
an, die das alles berücksichtigen

   TCNT1 = 0;

und fertig. (Besser wäre der CTC Modus, der macht das nämlich alles von 
alleine)

Auch hier
>

> OCR1AH    =  0x07;          // einschalten. Interrupt bei:
> OCR1AL    =  0x53;          // OCR1 Inhalt = 12Mhz / 64 * 0,0005s (500us)
>                       // =005E(500us)
>                       // =00BC(1ms)
>                       // =0753(10ms)
>

warum so kompliziert? Kein Mensch zwingt dich High und Low Register 
getrennt zu beschreiben bzw. da Hex-Zahlen anzugeben.

  OCR1A = 1875;

oder so

  OCR1A = 12000000 / 64 / 100;

oder so

  OCR1A = F_CPU / 64 / 100;

[Frank (Gast)]

mhm Daran hats nicht gelegen.

Habe nun den Timer1 soweit nach euren Vorschlägen verbessert.

Ich habe mit einem Scope mal an dem PIN den ich Toggle gemessen und da 
Messe ich immer eine Folge von ca8 bis 10 Flankenwechsel und dann liegt 
das signal 30 ms auf Low bzw auf High.

Wa ich kannst mir irgendwie nicht erklären

[Karl H. (kbuchegg)]

UNbeabsichtigter Hardware-Reset aus irgendeinem Grund?

einfach mal am Anfang in der main eine LED einschalten, 1/2 Sekunde 
brennen lassen und wieder aussschalten. Die LED darf nur das erste mal 
brennen, wann immer sie danach noch einmal kommt, ist ein Reset 
dazwischen passiert.

[Frank (Gast)]

Ich habe den Fehler gefunden, aber ich Verstehe ihn nicht :(.
Und zwar hatte ich unten in der While schleife das stehen

PORTB ^= (1<<PB4);

Wenn ich das reinsetze dann spinnt das toggeln in der Timer 1 Interrupt 
Routine

Ist das ^ eventuell kein bitweises XOR?



Hier nochmal der Code

//Alle 10ms tritt ein Timer1 Output Compare Interrupt auf.  
ISR (TIMER1_COMPA_vect)
{    
//  TCNT1L    =  0x00;  //Timer1-Compare-Wert wieder 
//  TCNT1H    =  0x00;  //auf 0 setzen
  PORTB ^= (1<<PB0);

//  PORTB++;
}


// Interrupt speichert den Taster-Status in Variablen ab.
SIGNAL (SIG_OVERFLOW0)      // every 10ms
{
  //static unsigned char ct0, ct1, rpt;
   //unsigned char i;

  TCNT0 = (unsigned char)(signed short)-(XTAL / 1024 * 10e-3 + 0.5);  // preload for 10ms
  PORTB ^= (1<<PB1);
}


//////////////////////////////////////////////////
// Main-Schleife                //  
//////////////////////////////////////////////////  
int main (void)
{
  //Initialisierung
  TCCR1A    |=  (1<<COM1A1);          // Timer 1 Initialisieren
  TCCR1B    |=  ((1<<CS11) | (1<<CS10) | (1<<WGM12));// Prescaler auf "64"
  TIMSK    |=  (1<<OCIE1A);      // Output Compare A Interrupt  
  
  OCR1A = XTAL / 64 / 100;
  /*OCR1AH    =  0x07;          // einschalten. Interrupt bei:
  OCR1AL    =  0x53;          // OCR1 Inhalt = 12Mhz / 64 * 0,0005s (500us)
                      // =005E(500us)
                      // =00BC(1ms)
                      // =0753(10ms)
*/
  // Im SIMULATOR etwas realistischer bei F_CPU = 1MHz
  //OCR1AH    =  0x01;
  //OCR1AL    =  0x08;

//  TCCR0     = 1<<CS02^1<<CS00;      // divide by 1024
//  TIMSK     |= 1<<TOIE0;          // Time 0 Initialisieren

  //PORT-Initialisierung
  LCD_DDR    =    0xFF;    // PORT A Ausgang Text LCD
  DDRB = 0xFF;
  DDRC = 0xFF;
  
  
  cli();
 //   i2c_init();
    sei();                               // now enable interrupt
  
  while (1)
  {
    //PORTB ^= (1<<PB4);
    PORTC ^= (1<<PC0);
    
  }
  
}

[Karl H. (kbuchegg)]

Frank schrieb:
> Ich habe den Fehler gefunden, aber ich Verstehe ihn nicht :(.
> Und zwar hatte ich unten in der While schleife das stehen
>
> PORTB ^= (1<<PB4);
>
> Wenn ich das reinsetze dann spinnt das toggeln in der Timer 1 Interrupt
> Routine
> Ist das ^ eventuell kein bitweises XOR?

Doch, doch.

Aber da passiert ganz was anderes:

Das Hauptprogramm läuft und läuft und läuft.

   PORTB ^= (1^<<PB4);

wie implementiert der Compiler das?

Da es keine Assembler Instruktion für Pin Toggeln gibt (das können erst 
neuerere Prozessoren), muss der Compiler das so implementieren.

   Register = Inhalte vom PORTB
   Bit mit einem XOR toggeln
   Register zurück schreiben auf PORTB


ab und an passiert es dann mal, dass der Interrupt genau dann kommt, 
wenn gerade die Instruktion

   Register = Inhalt vom PORTB

durch ist.
Der Interrupt macht was? Der toggelt das Bit 0 am PORTB.
Danach ist er fertig und es geht zurück ins Hauptprogramm. Was macht das 
Hauptprogramm?
Es toggelt seinerseits PB4 im Register und schreibt alles zurück an 
PORTB.
Aber! Dadurch ist auch PB0 wieder in seinem Ursprungszustand. Das 
Toggeln von PB0 würde rückgängig gemacht!

So etwas nennt man eine "Race Condition", wenn abhängig von den genauen 
Details und je nachdem wer schneller ist andere Ergebnisse entstehen.

Das Problem war also, dass die Operation
    PORTB ^= (1^<<PB4);
durch einen Interrupt unterbrochen wird.
Das Problem kannst du nur so lösen, dass du diese Unterbrechung nicht 
zulässt.

  ...

  while( 1 ) {
    cli();
    PORTB ^= (1^<<PB4);
    sei();
  }

[Frank (Gast)]

Wow - Vielen Vielen Dank für diese Ausführlich Erklärung ich habe das 
gerade mal ausprobiert und zu 100% nachvollziehen können. Genial.


Ich Danke dir.

Einen wunderschönen Freitag noch.

Nun bin ich Happy :-)