Wegoptimiert?

[Christian Q. (osx)]

Hi! Ich muss in meiner TimerISR ein komisches Verhalten feststellen. 
Vorab der Code:

volatile int Timer1;
int i = 0;

ISR(TIMER1_COMPA_vect){  
  
  Timer1++;
  if(Timer1 == 20) {
    Timer1 = 0;
    for (i = 0; i < 20; i++) {
      printf("%d\n", i);
    } 
  }   
}

Es wird überhaupt nichts getan. Im Simulator kann ich sehen wie die 
Variablen Timer1 und i 'not in scope' sind, dann auf 0, später auf 1 und 
dann weder auf 'not in scope' wechseln.
Lasse ich eine LED beim ISR-Aufruf toggeln, dann ändert sich auch der 
Zustand. Versuche ich dies im if-Block tut sie es jedoch nicht.
Breakpoints lassen sich erst gar nicht setzen.

Das Problem ist bei jedem optimierungslevel in den Projekteinstellngen.
Hat jemand Ideen wie ich vorgehen kann um das Problem zu lokalisieren?

[(prx) A. K. (prx)]

"i" global ist ungut. Gehört in die ISR.

Debuggen mit eingeschalteter Optimierung sieht nicht immer befriedigend 
aus.

[Εrnst B. (ernst)]

Christian Q. schrieb:
> Variablen Timer1 und i 'not in scope' sind, dann auf 0, später auf 1 und
> dann weder auf 'not in scope' wechseln.

Soweit doch richtig. du musst warten bis Timer1 auf 20 steht, erst dann 
läuft er in dein if...


Abgesehen davon: printf in der ISR ist 'bäh'. Zum Debuggen aber 
verzeihbar...

[Christian Q. (osx)]

A. K. schrieb:
> "i" global ist ungut. Gehört in die ISR.
eher so?:

ISR(TIMER1_COMPA_vect){  
  int i;
  Timer1++;
  if(Timer1 == 20) {
  PORTD ^= (1 << PD6);
    Timer1 = 0;
    for (i = 0; i < 20; i++) {
      printf("%d\n", i);
    } 
  }   
}

Das Problem ist dann aber doch, dass i immer wieder neu initialisiert 
wird, oder nicht?


Er erreicht aber den if-Block nie. mysteriös.. aber  Computer haben 
immer Recht.

[Peter II (Gast)]

Christian Q. schrieb:
> eher so?:

noch besser so:

 for ( uint_8 i = 0; i < 20; i++) {

[Hans (Gast)]

Zeig doch einmal das komplette Programm!

[Εrnst B. (ernst)]

ISR(TIMER1_COMPA_vect){  
  static uint8_t timer1; // braucht kein "volatile"
  timer1++;
  if(timer1 == 20) {
    PIND = (1 << PD6);
    timer1 = 0;
    for (int8_t i = 0; i < 20; i++) {
       printf("%d\n", i);
    } 
   }   
}

:)

[(prx) A. K. (prx)]

Christian Q. schrieb:

> Das Problem ist dann aber doch, dass i immer wieder neu initialisiert
> wird, oder nicht?

Wird es doch von dir sowieso.

[Ralf (Gast)]

Wird 'Timer1' nur in der ISR verwendet? (Dann besser 'static') Oder wird 
die vielleicht in der 'main()' heimlich zurückgesetzt?

[Ralf (Gast)]

Ralf schrieb:
> (Dann besser 'static')
zu langsam ...

[Christian Q. (osx)]

//#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#include "UART.h"
#include "ADC.h"

int Timer1 = 0;

//Array für 20 Messungen
int iMessungen[20];

int main() {
  DDRD = 255;
  PORTD = 0;
  
  // 16-Bit Timer
  TCCR1B |= (1 << WGM12); //CTC Modus
  OCR1A  = 5000;                 
  TIMSK = (1<<OCIE1A);  
  TCCR1B |= (0 << CS12) | (0 << CS11) | (1 << CS10);  // Prescaler 1

  //External Interrupt
  //MCUCR |= (1<<ISC01) | (0<<ISC00);
  //GICR |= (1<< INT0);   
  
  uart_init();
  ADC_Init();
  
  //Ausgabumleiten
  stdout = &mystdout;

  sei();
  while( 1 ) {}
}    

ISR(TIMER1_COMPA_vect){  

  Timer1++;
  if(Timer1 == 20) {
  PORTD ^= (1 << PD6);
    Timer1 = 0;
    for (uint8_t i = 0; i < 20; i++) {
      printf("%d\n", i);
      PORTD = i;
    } 
  }   
}

ISR(INT0_vect) {
  PORTD ^= (1 << PD6);
}

[Jörg W. (dl8dtl) (Moderator)]

Εrnst B✶ schrieb:
> Abgesehen davon: printf in der ISR ist 'bäh'. Zum Debuggen aber
> verzeihbar...

Aber nicht in einer Timer-ISR: es könnte gut sein, dass der
nächste Interrupt schon da ist, während die ISR noch dabei ist,
die vorherigen 20 printfs abzuarbeiten (UART bei 9600 Bd: 1 ms
pro Zeichen).

[Ralf (Gast)]

Kann das sein, das die 'while()'-Schleife wegoptimiert wird? Das könnte 
erklären, dass der Interrupt vorher mal angesprungen wird (während der 
ganzen Initialisierungen). Und dann ist 'main()' zu Ende...

[Christian Q. (osx)]

Jörg Wunsch schrieb:
> es könnte gut sein, dass der
> nächste Interrupt schon da ist, während die ISR noch dabei ist,
> die vorherigen 20 printfs abzuarbeiten (UART bei 9600 Bd: 1 ms
> pro Zeichen).

Dann würde aber bestimmt mindestens 1 Zeichen ausgegeben oder PD6 
toggled.

Achso: Frequenz ist 1 Mhz.

[(prx) A. K. (prx)]

Ralf schrieb:

> Kann das sein, das die 'while()'-Schleife wegoptimiert wird?

Nein.

[Ralf (Gast)]

Christian Q. schrieb:
> Jörg Wunsch schrieb:
>> es könnte gut sein, dass der
>> nächste Interrupt schon da ist, während die ISR noch dabei ist,
>> die vorherigen 20 printfs abzuarbeiten (UART bei 9600 Bd: 1 ms
>> pro Zeichen).
>
> Dann würde aber bestimmt mindestens 1 Zeichen ausgegeben oder PD6
> toggled.
Fängt man aber gar nicht erst an, Das ist dann nämlich die nächste 
Baustelle!

[Peter II (Gast)]

schau doch einfach mal in den ASM code, diese stelle sollte ja recht 
einfach sein.

[Christian Q. (osx)]

Puh, im ASM finde ich mich noch weniger zurecht.
Ich hab mal die Dateien gepackt und angehangen.

[Jörg W. (dl8dtl) (Moderator)]

Schmeiß doch das printf() aus der ISR raus.  Wenn du dort einen
Pin wackeln lässt, dann denk dran, dass der ziemlich schnell wackelt.
Falls du da nur eine LED an PORTD0 dran hast, wirst du das Wackeln
nicht sehen ;-), sondern du brauchst ein Oszilloskop dafür.

[Christian Q. (osx)]

#include <stdio.h>
#include <avr/interrupt.h>
#include <util/delay.h>

#include "UART.h"
#include "ADC.h"

//int Timer1 = 0;

//Array für 20 Messungen
int iMessungen[20];

int main() {
  DDRD = 255;
  PORTD = 0;
  
  // 16-Bit Timer
  TCCR1B |= (1 << WGM12); //CTC Modus
  OCR1A  = 50000;                 
  TIMSK = (1<<OCIE1A);  
  TCCR1B |= (0 << CS12) | (0 << CS11) | (1 << CS10);  // Prescaler 1

  //External Interrupt
  //MCUCR |= (1<<ISC01) | (0<<ISC00);
  //GICR |= (1<< INT0);   
  
  uart_init();
  //ADC_Init();
  
  //Ausgabe umleiten
  //stdout = &mystdout;

  sei();
  while( 1 ) {}
}    

ISR(TIMER1_COMPA_vect){  
  static uint8_t Timer1;
  Timer1++;
  if(Timer1 == 20) {
    Timer1 = 0;
    for (uint8_t i = 0; i < 2; i++) {
      PORTD ^= (1<<PD6);
    } 
  }   
}

ISR(INT0_vect) {
  PORTD ^= (1 << PD6);
}

Mit ADC_init ausgeklammert und OCR1A auf 50000 erhöht blinkt die LED 
ganz kurz.

ADC.h

#ifndef _ADC_H_
#define _ADC_H_

#include "ADC.h"

/* ADC initialisieren */
void ADC_Init(void);

/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel );

/* ADC Mehrfachmessung mit Mittelwertbbildung */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average );

#endif

ADC.c

#include <avr/io.h>
#include <stdio.h>
#include <avr/interrupt.h>
#include <inttypes.h>
#include "ADC.h"

/* ADC initialisieren */
void ADC_Init(void) {

  uint16_t result;

    ADMUX = (1<<REFS1) | (1<<REFS0);      // interne Referenz: 2.56 Volt 
  ADCSRA = ((1<<ADPS2) | 0<<ADPS1) | (0<<ADPS0);     // Frequenzvorteiler
  ADCSRA |= (1<<ADIE);    // Interrupt
  ADCSRA |= (1<<ADEN);                  // ADC aktivieren

  /* nach Aktivieren des ADC wird ein "Dummy-Readout" empfohlen, man liest
  also einen Wert und verwirft diesen, um den ADC "warmlaufen zu lassen" */

  ADCSRA |= (1<<ADSC);                  // eine ADC-Wandlung 
  while (ADCSRA & (1<<ADSC) ) {}        // auf Abschluss der Konvertierung warten
  /* ADCW muss einmal gelesen werden, sonst wird Ergebnis der nächsten
  Wandlung nicht übernommen. */
  result = ADCW;
}

/* ADC Einzelmessung */
uint16_t ADC_Read( uint8_t channel ) {
  // Kanal waehlen, ohne andere Bits zu beeinflußen
  ADMUX = (ADMUX & ~(0x1F)) | (channel & 0x1F);
  ADCSRA |= (1<<ADSC);            // eine Wandlung "single conversion"
  while (ADCSRA & (1<<ADSC) ) {}  // auf Abschluss der Konvertierung warten
  return ADCW;                    // ADC auslesen und zurückgeben
}

/* ADC Mehrfachmessung mit Mittelwertbbildung */
uint16_t ADC_Read_Avg( uint8_t channel, uint8_t average ) {
  uint32_t result = 0;

  for (uint8_t i = 0; i < average; ++i )
  result += ADC_Read( channel );

  return (uint16_t)( result / average );
}

Komischer Weise geht nach dem Build and Run auch gleich das 
Disassembler-Fenster auf.

[Karl H. (kbuchegg)]

>  ADCSRA |= (1<<ADIE);    // Interrupt

Man gibt keinen Interrupt frei, für den man keine ISR hat.
Niemals!

[Christian Q. (osx)]

Oh ja. Danke für den Hinweis, das hab ich übersehen.
Leider ändert es überhaupt nichts am Verhalten.

[Karl H. (kbuchegg)]

Mach mal diese Variante der ISR

ISR(TIMER1_COMPA_vect){  
  static uint8_t Timer1;
  Timer1++;
  if(Timer1 == 20) {
    Timer1 = 0;
//    for (uint8_t i = 0; i < 2; i++)
    {
      PORTD ^= (1<<PD6);
    } 
  }   
}

Du musst schon sehr gut sein, wenn du das aufglimmen einer LEd in der 
Dauer von ca 1µs sehen willst. Auf meinem 4Mhz Mega16 kann ich das 
gerade noch erahnen. Aber auch nur weil ich weiß, an welcher LED sich 
was tun müsste. OHne dieses wissen, würde ich das niemals sehen.

Bei
    for (uint8_t i = 0; i < 20; i++)

hingegen, ist das regelmässige Aufblitzen schon deutlich zu sehen.

[Christian Q. (osx)]

Es muss ein Fehler beim ADC sein. Wenn ich das init auskommentiere 
funktioniert alles wie gewohnt. Naja okay in AVR Studio lassen sich 
immernoch keine Breakpoints setzen und es springt in den Disassembler 
aber auf der Hardware funktioniert alles wie erwartet.
Hab ich den ADC falsch eingebunden?

[Εrnst B. (ernst)]

Christian Q. schrieb:
> Hab ich den ADC falsch eingebunden?

Hast du:

Karl Heinz Buchegger schrieb:
> Man gibt keinen Interrupt frei, für den man keine ISR hat.
> Niemals!

wirklich beachtet, oder ohne Test einfach:

Christian Q. schrieb:
> Leider ändert es überhaupt nichts am Verhalten.

behauptet?

Schaltest du sonst noch andere Interrupts ein, für die du keine ISR 
hast?
ggfs einen bad_isr handler installieren, der dir das debuggt.

ISR(BADISR_vect) 
 { 
   while (1) {
     PORTA ^= 0x42; // Hier: irgendwelche Debug-LEDs blinken lassen 
   }
 }

[Christian Q. (osx)]

Ich hatte es getestet. Auf deinen Hinweis jetzt sogar erneut. Und siehe 
da jetzt geht es. Entweder ich habe bei meinem Test den Interrupt aus 
Versehen angelassen oder ein anderes Ergebnis erwartet. Vielen Dank für 
deinen unermüdlich durchgesetzten Lösungsvorschlag :D

Warum sich AVR-Studio trotzdem so komisch verhält verstehe ich nicht.