WinAvr - Variable wird nicht von einer *.c in die andere übernommen

[Markus W. (kornbanane)]

Hallo,

ich programmiere meinen Atmega16 in C mit WinAvr und stehe gerade voll 
auf dem Schlauch.

Also nur kurz zum Programm

Es geht einfach nur darum ein Telegramm über die UART0 Schnittstelle was 
vom PC an den µC empfangen wird solange in einen Empfangsbuffer zu 
schreiben, bis das Telegrammendezeichen (CR) empfangen wird.
Wenn das Telegramm fertig empfangen ist wird die Variable 
uart0_rxd_complete auf 1 gesetzt und das nachfolgende Programm kann 
irgendwas machen.

Ich habe 4 Dateien: main.c main.h uart.c uart.h

Hier jetzt nur mal die für mein Problem relevanten Codeausschnitte

uart.c:

//---------------------------------------------------------------------------
// ISR(USART_TXC_vect)
//
// functiondescription:  Interrupt für USART0 recieve. Schreibt die empfangenen Zeichen in einen Empfangsbuffer bis das Endezeichen (CR=0x0D) erkannt wurde
//
// hand over:
//  - input parameters: nothing
// returns:
//  - return parameter: nothing
//---------------------------------------------------------------------------
ISR(USART_RXC_vect)
{
  if(UDR!=0x0D)     // Kein Endezeichen empfangen ?
  {
    uart0_rx_buffer[uart0_rx_buffer_pointer]=UDR;
    uart0_rx_buffer_pointer++;
    if(uart0_rx_buffer_pointer>255) uart0_rx_buffer_pointer=0;    // Zur Sicherheit, kann hier aber nicht passieren, da unsigned char sowieso überläuft 
  }
  else        // Wenn ein Endezeichen empfangen wurde
  {
    uart0_rx_buffer[uart0_rx_buffer_pointer]=UDR;          // Das Endezeichen (CR=0xOD) wird als letztes in den Empfangsbuffer geschrieben
    uart0_rx_buffer_pointer=0;
    uart0_rxd_complete=1;
    PORTC=0x0A;
  }
}

main.h

//-------------------
// begin extern vars 
//-------------------

extern unsigned char uart0_rxd_complete;

//-----------------
// end extern vars 
//-----------------

main.c

while (1)
  {
  
      if(uart0_rxd_complete==1)
    {
    
      PORTC=0xFF;
      uart0_rxd_complete=0;
      putstring("\nFolgende Daten wurden empfangen: \n",0);
      
      while(uart0_rx_buffer[i]!=0x0D)
      {
        putch(uart0_rx_buffer[i],0);
      }
      
      putch('\n',0);
    }
    
  }

So also nun zum Problem. In der uart.c steckt der empfangsinterrupt. Das 
ganze funktioniert auch, das sehe ich an meinen LED's die ich am PortC 
angeschlossen habe. Wenn das Telegrammendezeichen empfangen wurde wird 
Portc auf 0x0A gesetzt. Gleichzeitig setze ich uart0_rxd_complete=1;.

Jetzt müsste in der main.c die Abfrage if(uart0_rxd_complete==1) true 
ergeben, aber nix da. Für die main.c ist uart0_rxd_complete immer 0 !
Es liegt auch nicht an der Abfrage die Variable ist dort wirklich immer 
0 aber wieso ? Ich habe sie doch in main.h "eingebungen" und main.c ruft 
main.h auf.

Ich dachte das aus irgendeinen Grund generell keine Variable von der 
uart.c in die main.c übertragen werden kann. Hab ich überprüft und es 
geht. Aber wieso dort nicht ? Das Programm ist sehr klein. Die Variable 
wird 100%ig nirgendswo auf 0 gesetzt.

Jetzt hab ich echt kein Plan mehr :(

[Achim K. (aks)]

Versuchs mal mit

extern volatile unsigned char uart0_rxd_complete;

[Markus W. (kornbanane)]

Danke, man wie blöd ....

Sag mal versteh ich das richtig, dass das jetzt nur eine 
Optimierungssache war die halt in meinem Fall daneben ging. Mit anderen 
Worten bei einem anderem Compiler oder auch bei WinAvr mit anderen 
Einstellungen hätte es auch ohne volatile funktioniert ?

[Thomas M. (langhaarrocker)]

Naja, ob die Optimierung nun 'daneben' ging, ist Ansichtssache. Es ist 
ja durchaus gut und richtig, wenn ein Compiler nicht unnötig Variablen 
mit vergleichsweise teuren Ram Zugriffen nochmal holt, wenn sie ohnehin 
schon gerade in einem flotten Register gepuffert sind. Nur wenn dann 
durch einen Interrupt diese Pufferung unterwandert wird, gibt's 
Probleme. Genau das zu vermeiden, dafür ist so ein volatile halt gut. 
Die Alternative wäre ja auf Optimierungen zu verzichten.

Man könnte auch auf die Idee kommen dem Compiler die Pufferung zu 
verbieten indem man ihn anweist ein Register für solch eine Variable zu 
reservieren:
register unsigned char uart0_rxd_complete asm("r2");
Aber das ist nicht zu empfehlen, da der Compiler sich durchaus auch 
erlaubt trotzdem das Register für andere Zwecke zu verwenden, wenn ihm 
freie Register ausgehen. Wenn dann ein Interrupt stattfindet und völlig 
andere Werte überschreibt ... viel Spaß bei der Fehlersuche. :)