ATxmega128: Unbeschreiblicher Fehler

[Joe (Gast)]

Hallo zusammen,

habe hier einen ATxmega128 der mir Rätsel aufgibt.
Hab hier eine Baugruppe die zunächst einwandfrei funktioniert.
Irgendwann nicht mehr. - Hier kann ich nicht ausschließen, dass aufgrund 
das Quick&Dirty-Versuchsaufbaus irgend eine blanke Leitung kurzfristig 
wo hinkommen ist, wo sie nicht sollte.
Beim Debuggen mit AVR viel mir auf, dass ich irgendwie immer an ein 
Stelle des Codes springe. Aber mitten drin in der Init. Zunächst dachte 
ich an einen Reset. Aber ein Breakpoint ein paar Zeilen drüber wird 
nicht angesprungen. Auch so springt beim "Schrittweise" debuggen der 
Code Plötzlich wohin, wo er nicht hin sollte.

Was ist da kaputt gegangen?

Gruß
Joe

[Peter II (Gast)]

Joe schrieb:
> Was ist da kaputt gegangen?

sicher das es kein Software fehler ist, auch ein Stacküberschreiber kann 
sich so auswirken. Gehen doch mal im ASM code schritt für schritt durch, 
dan sieht man doch was genau passiert.

[Joe (Gast)]

Da steht ein relativer Jump, wo er z.B. in eine falsche Codestelle 
springt:

00000928  RJMP PC+0x02AC    Relative jump

So sieht der ganze ASM-Code aus:

PK0_LED_GREEN_ON();
00000927  BRNE PC+0x02    Branch if not equal 
00000928  RJMP PC+0x02AC    Relative jump 
00000929  LDS R24,0x2008    Load direct from data space 
0000092B  TST R24    Test for Zero or Minus 
0000092C  BRLT PC+0x02    Branch if less than, signed 
0000092D  RJMP PC+0x004D    Relative jump 
0000092E  LDI R24,0x00    Load immediate 
0000092F  LDI R25,0x02    Load immediate 
00000930  LDI R18,0x00    Load immediate 
00000931  LDI R19,0x02    Load immediate

Und so das Makro in der Codestelle:

#define PK0_LED_GREEN_ON() \
  do { \
    PORTK_OUTSET = 0x02; \
    PORTK_OUTCLR = 0x01; \
    } while(0)

Habe ich irgendwelche falschen Einstellungen im Atmel Studio v6?
Dieses  habe ich gestern erst installiert, weil derjenige der die SW 
geschrieben hat im Urlaub ist...

[Peter II (Gast)]

und an welche Adresse spring er?

[Joe (Gast)]

Gibt es irgendwo in den Debug-Einstellungen ein "Program & Verify" Flag?

[Joe (Gast)]

Peter II schrieb:
> und an welche Adresse spring er?

0x0bd7

[Peter II (Gast)]

Joe schrieb:
> Peter II schrieb:
>> und an welche Adresse spring er?
> 0x0bd7

dann macht er ja erstmal das was er soll. Hast du den richtigen Prozesor 
ausgwählt?

[Joe (Gast)]

Peter II schrieb:
> dann macht er ja erstmal das was er soll. H

Vielleicht das was im ASM steht, abe rnicht, dass was im C-Code steht!

Peter II schrieb:
> Hast du den richtigen Prozesor ausgwählt?

Ja. - ATxmega128A1
Mit dem "Device Programming Tool" sogar extra verifiziert und die Device 
Signature ausgelesen: 0x1E974C
Bei einem anderen eingestellten MCU jammert das Tool.

[Peter II (Gast)]

zeige mal etwas mehr code, irgendwie passt der ASM code nicht zu dem 
Makro. Es sind dort viel zu viele sprünge enthalten.

[Joe (Gast)]

Joe schrieb:
> Gibt es irgendwo in den Debug-Einstellungen ein "Program & Verify" Flag?

Mit dem "Device Programming Tool" des AtmelStudio's habe ich die 
Verifizierung durchgeführt.
Der Flashinhalt stimmt überein.

[Joe (Gast)]

  ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();

  // Signal, that the Board is up and running
  PK0_LED_GREEN_ON();
  
  while(TRUE) {
  
    // read ADC continuously into a ring-buffer (16 bytes)
    if(ReadADCContinuously){
...

Das Makro für ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT sieht so aus:

#define ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT() TCE0.INTCTRLB = 0x03

"TRUE" ist per #define auf 1 gesetzt.

[Joe (Gast)]

Peter II schrieb:
> zeige mal etwas mehr code, irgendwie passt der ASM code nicht zu dem
> Makro. Es sind dort viel zu viele sprünge enthalten.

Der Meinung bin ich auch...

[Peter II (Gast)]

sorry aber mit diesen codefetzen kann man kaum weiter helfen. Bitte mal 
einen größere auschnitt aus dem C code und dann auch den passende ASM 
code.

[Joe (Gast)]

C-Code:

  // Initialize send/reveive buffers
  initializeBuffer(&Rx_Buffer);
  initializeBuffer(&Tx_Buffer);

  status = readPortConfiguration();

  while(status == FALSE) { // toggle LED D301, if the channel configuration is not correct
    PORTK.OUTTGL = 1 << PIN0;
    _delay_ms(1000);
  }
  
  // ********************************************************************
  // Application code starts here, after the board has been initialized.
  // ********************************************************************
  
  ENABLE_GLOBAL_INT();
  ENABLE_USARTF0_RX_INT();
  ENABLE_USARTF0();
  ENABLE_GLOBAL_HIGH_LEVEL_INT();
  ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();

  // Signal, that the Board is up and running
  PK0_LED_GREEN_ON();
  
  while(TRUE) {
  
    // read ADC continuously into a ring-buffer (16 bytes)
    if(ReadADCContinuously){
      //P1ChA
      if ((Analog_In_Configuration_Mask & 0x80) == 0x80)
      {
        ADCA_CH0_SET_INPUT_PINA0();
        START_ADCA_CH0_SINGLE_MEASUREMENT();
        while(!(ADCA.CH0.INTFLAGS & 0x01));
        CLEAR_ADCA_CH0_INTFLAG();
        ADC_PINA0_RingBuffer.pBuffer[ADC_PINA0_RingBuffer.inPos] = ADCA.CH0.RESL;
        ADC_PINA0_RingBuffer.inPos++;
        ADC_PINA0_RingBuffer.inPos = ADC_PINA0_RingBuffer.inPos & 0x0F;
      }
      //P1ChB
      if ((Analog_In_Configuration_Mask & 0x40) == 0x40)
      {
        ADCA_CH0_SET_INPUT_PINA1();
        START_ADCA_CH0_SINGLE_MEASUREMENT();
        while(!(ADCA.CH0.INTFLAGS & 0x01));
        CLEAR_ADCA_CH0_INTFLAG();
        ADC_PINA1_RingBuffer.pBuffer[ADC_PINA1_RingBuffer.inPos] = ADCA.CH0.RESL;
        ADC_PINA1_RingBuffer.inPos++;
        ADC_PINA1_RingBuffer.inPos = ADC_PINA1_RingBuffer.inPos & 0x0F;
      }
      //P2ChA
      if ((Analog_In_Configuration_Mask & 0x20) == 0x20)
      {
        ADCA_CH0_SET_INPUT_PINA2();
        START_ADCA_CH0_SINGLE_MEASUREMENT();
        while(!(ADCA.CH0.INTFLAGS & 0x01));
        CLEAR_ADCA_CH0_INTFLAG();
        ADC_PINA2_RingBuffer.pBuffer[ADC_PINA2_RingBuffer.inPos] = ADCA.CH0.RESL;
        ADC_PINA2_RingBuffer.inPos++;
        ADC_PINA2_RingBuffer.inPos = ADC_PINA2_RingBuffer.inPos & 0x0F;
      }
      //P2ChB
      if ((Analog_In_Configuration_Mask & 0x10) == 0x10)
      {
        ADCA_CH0_SET_INPUT_PINA3();
        START_ADCA_CH0_SINGLE_MEASUREMENT();
        while(!(ADCA.CH0.INTFLAGS & 0x01));
        CLEAR_ADCA_CH0_INTFLAG();
        ADC_PINA3_RingBuffer.pBuffer[ADC_PINA3_RingBuffer.inPos] = ADCA.CH0.RESL;
        ADC_PINA3_RingBuffer.inPos++;
        ADC_PINA3_RingBuffer.inPos = ADC_PINA3_RingBuffer.inPos & 0x0F;
      }

Assembler:

  __asm__ volatile (
000008F9  LDI R25,0x0B    Load immediate 
000008FA  LDI R18,0xA0    Load immediate 
000008FB  LDI R19,0x0B    Load immediate 
000008FC  MOVW R30,R18    Copy register pair 
000008FD  LDD R18,Z+3    Load indirect with displacement 
000008FE  ORI R18,0x30    Logical OR with immediate 
000008FF  MOVW R30,R24    Copy register pair 
00000900  STD Z+3,R18    Store indirect with displacement 
00000901  LDI R24,0xA0    Load immediate 
--- X:\/src/main.c -------------------
  while(status == FALSE) { // toggle LED D301, if the channel configuration is not correct
00000902  LDI R25,0x0B    Load immediate 
00000903  LDI R18,0xA0    Load immediate 
00000904  LDI R19,0x0B    Load immediate 
00000905  MOVW R30,R18    Copy register pair 
  ENABLE_GLOBAL_INT();
00000906  LDD R18,Z+4    Load indirect with displacement 
  ENABLE_USARTF0_RX_INT();
00000907  ORI R18,0x18    Logical OR with immediate 
00000908  MOVW R30,R24    Copy register pair 
00000909  STD Z+4,R18    Store indirect with displacement 
0000090A  LDI R24,0xA0    Load immediate 
0000090B  LDI R25,0x00    Load immediate 
0000090C  LDI R18,0xA0    Load immediate 
0000090D  LDI R19,0x00    Load immediate 
0000090E  MOVW R30,R18    Copy register pair 
0000090F  LDD R18,Z+2    Load indirect with displacement 
  ENABLE_USARTF0();
00000910  ORI R18,0x04    Logical OR with immediate 
00000911  MOVW R30,R24    Copy register pair 
00000912  STD Z+2,R18    Store indirect with displacement 
00000913  LDI R24,0x00    Load immediate 
00000914  LDI R25,0x0A    Load immediate 
00000915  LDI R18,0x03    Load immediate 
00000916  MOVW R30,R24    Copy register pair 
00000917  STD Z+7,R18    Store indirect with displacement 
00000918  LDI R24,0x25    Load immediate 
  ENABLE_GLOBAL_HIGH_LEVEL_INT();
00000919  LDI R25,0x07    Load immediate 
0000091A  LDI R18,0x02    Load immediate 
0000091B  MOVW R30,R24    Copy register pair 
0000091C  STD Z+0,R18    Store indirect with displacement 
0000091D  LDI R24,0x26    Load immediate 
0000091E  LDI R25,0x07    Load immediate 
0000091F  LDI R18,0x01    Load immediate 
00000920  MOVW R30,R24    Copy register pair 
00000921  STD Z+0,R18    Store indirect with displacement 
  ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();
00000922  RJMP PC+0x0002    Relative jump 
00000923  NOP     No operation 
00000924  LDS R24,0x200C    Load direct from data space 
00000926  TST R24    Test for Zero or Minus 
  PK0_LED_GREEN_ON();
00000927  BRNE PC+0x02    Branch if not equal 
00000928  RJMP PC+0x02AC    Relative jump 
00000929  LDS R24,0x2008    Load direct from data space 
0000092B  TST R24    Test for Zero or Minus 
0000092C  BRLT PC+0x02    Branch if less than, signed 
0000092D  RJMP PC+0x004D    Relative jump 
0000092E  LDI R24,0x00    Load immediate 
0000092F  LDI R25,0x02    Load immediate 
00000930  LDI R18,0x00    Load immediate 
00000931  LDI R19,0x02    Load immediate 
  } // end while(TRUE)
00000932  MOVW R30,R18    Copy register pair 
    if(ReadADCContinuously){
00000933  LDD R18,Z+33    Load indirect with displacement 
00000934  ANDI R18,0x03    Logical AND with immediate 
00000935  MOVW R30,R24    Copy register pair 
00000936  STD Z+33,R18    Store indirect with displacement 
00000937  LDI R24,0x00    Load immediate 
      if ((Analog_In_Configuration_Mask & 0x80) == 0x80)
00000938  LDI R25,0x02    Load immediate 
00000939  LDI R18,0x00    Load immediate 
0000093A  LDI R19,0x02    Load immediate 
0000093B  MOVW R30,R18    Copy register pair 
0000093C  LDD R18,Z+32    Load indirect with displacement 
        ADCA_CH0_SET_INPUT_PINA0();
0000093D  ORI R18,0x80    Logical OR with immediate 
0000093E  MOVW R30,R24    Copy register pair 
0000093F  STD Z+32,R18    Store indirect with displacement 
00000940  NOP     No operation 
--- X:\/src/main.c -------------------
00000941  LDI R24,0x00    Load immediate 
00000942  LDI R25,0x02    Load immediate 
00000943  MOVW R30,R24    Copy register pair 
00000944  LDD R24,Z+35    Load indirect with displacement 
00000945  MOV R24,R24    Copy register 
        START_ADCA_CH0_SINGLE_MEASUREMENT();
00000946  LDI R25,0x00    Load immediate 
00000947  ANDI R24,0x01    Logical AND with immediate 
00000948  ANDI R25,0x00    Logical AND with immediate 
00000949  SBIW R24,0x00    Subtract immediate from word 
0000094A  BREQ PC-0x09    Branch if equal 
0000094B  LDI R24,0x00    Load immediate 
0000094C  LDI R25,0x02    Load immediate 
0000094D  LDI R18,0x01    Load immediate 
0000094E  MOVW R30,R24    Copy register pair 
        while(!(ADCA.CH0.INTFLAGS & 0x01));
0000094F  STD Z+35,R18    Store indirect with displacement 
--- No source file -------------------------------------------------------------
00000950  MOVW R24,R28    Copy register pair 
00000951  SUBI R24,0xC0    Subtract immediate 
00000952  SBCI R25,0xFF    Subtract immediate with carry 
00000953  MOVW R30,R24    Copy register pair 
00000954  LDD R24,Z+0    Load indirect with displacement 
00000955  MOV R24,R24    Copy register 
00000956  LDI R25,0x00    Load immediate 
00000957  LDI R18,0x00    Load immediate 
00000958  LDI R19,0x02    Load immediate 
00000959  MOVW R30,R18    Copy register pair 
0000095A  LDD R20,Z+36    Load indirect with displacement 
0000095B  MOVW R18,R28    Copy register pair 
0000095C  SUBI R18,0xD0    Subtract immediate 
0000095D  SBCI R19,0xFF    Subtract immediate with carry 
0000095E  ADD R24,R18    Add without carry 
--- X:\/src/main.c -------------------
        ADC_PINA0_RingBuffer.pBuffer[ADC_PINA0_RingBuffer.inPos] = ADCA.CH0.RESL;
0000095F  ADC R25,R19    Add with carry 
00000960  MOVW R30,R24    Copy register pair 
00000961  STD Z+0,R20    Store indirect with displacement 
00000962  MOVW R24,R28    Copy register pair 
00000963  SUBI R24,0xC0    Subtract immediate 
00000964  SBCI R25,0xFF    Subtract immediate with carry 
00000965  MOVW R30,R24    Copy register pair 
00000966  LDD R24,Z+0    Load indirect with displacement 
00000967  MOV R18,R24    Copy register 
00000968  SUBI R18,0xFF    Subtract immediate 
00000969  MOVW R24,R28    Copy register pair 
0000096A  SUBI R24,0xC0    Subtract immediate 
0000096B  SBCI R25,0xFF    Subtract immediate with carry 
0000096C  MOVW R30,R24    Copy register pair 
0000096D  STD Z+0,R18    Store indirect with displacement 
0000096E  MOVW R24,R28    Copy register pair 
0000096F  SUBI R24,0xC0    Subtract immediate 
00000970  SBCI R25,0xFF    Subtract immediate with carry 
        ADC_PINA0_RingBuffer.inPos++;
00000971  MOVW R30,R24    Copy register pair 
00000972  LDD R24,Z+0    Load indirect with displacement 
00000973  MOV R18,R24    Copy register 
00000974  ANDI R18,0x0F    Logical AND with immediate 
00000975  MOVW R24,R28    Copy register pair 
00000976  SUBI R24,0xC0    Subtract immediate 
00000977  SBCI R25,0xFF    Subtract immediate with carry 
00000978  MOVW R30,R24    Copy register pair 
00000979  STD Z+0,R18    Store indirect with displacement 
0000097A  LDS R24,0x2008    Load direct from data space 
0000097C  MOV R24,R24    Copy register 
        ADC_PINA0_RingBuffer.inPos = ADC_PINA0_RingBuffer.inPos & 0x0F;
0000097D  LDI R25,0x00    Load immediate 
--- X:\/src/main.c -------------------
0000097E  ANDI R24,0x40    Logical AND with immediate 
0000097F  ANDI R25,0x00    Logical AND with immediate 
00000980  SBIW R24,0x00    Subtract immediate from word 
00000981  BRNE PC+0x02    Branch if not equal 
00000982  RJMP PC+0x004E    Relative jump 
00000983  LDI R24,0x00    Load immediate 
00000984  LDI R25,0x02    Load immediate 
00000985  LDI R18,0x00    Load immediate 
00000986  LDI R19,0x02    Load immediate 
00000987  MOVW R30,R18    Copy register pair 
00000988  LDD R18,Z+33    Load indirect with displacement 
      if ((Analog_In_Configuration_Mask & 0x40) == 0x40)
00000989  ANDI R18,0x03    Logical AND with immediate 
0000098A  ORI R18,0x08    Logical OR with immediate 
0000098B  MOVW R30,R24    Copy register pair 
0000098C  STD Z+33,R18    Store indirect with displacement 
0000098D  LDI R24,0x00    Load immediate 
0000098E  LDI R25,0x02    Load immediate 
0000098F  LDI R18,0x00    Load immediate 
00000990  LDI R19,0x02    Load immediate 
00000991  MOVW R30,R18    Copy register pair 
        ADCA_CH0_SET_INPUT_PINA1();
00000992  LDD R18,Z+32    Load indirect with displacement 
00000993  ORI R18,0x80    Logical OR with immediate 
00000994  MOVW R30,R24    Copy register pair 
00000995  STD Z+32,R18    Store indirect with displacement 
00000996  NOP     No operation 
00000997  LDI R24,0x00    Load immediate 
00000998  LDI R25,0x02    Load immediate 
00000999  MOVW R30,R24    Copy register pair 
0000099A  LDD R24,Z+35    Load indirect with displacement 
0000099B  MOV R24,R24    Copy register 
        START_ADCA_CH0_SINGLE_MEASUREMENT();
0000099C  LDI R25,0x00    Load immediate 
0000099D  ANDI R24,0x01    Logical AND with immediate 
0000099E  ANDI R25,0x00    Logical AND with immediate 
0000099F  SBIW R24,0x00    Subtract immediate from word 
000009A0  BREQ PC-0x09    Branch if equal 
000009A1  LDI R24,0x00    Load immediate 
000009A2  LDI R25,0x02    Load immediate 
000009A3  LDI R18,0x01    Load immediate 
000009A4  MOVW R30,R24    Copy register pair 
        while(!(ADCA.CH0.INTFLAGS & 0x01));
000009A5  STD Z+35,R18    Store indirect with displacement 
--- No source file -------------------------------------------------------------
000009A6  MOVW R24,R28    Copy register pair 
000009A7  SUBI R24,0xAF    Subtract immediate 
000009A8  SBCI R25,0xFF    Subtract immediate with carry 
000009A9  MOVW R30,R24    Copy register pair 
000009AA  LDD R24,Z+0    Load indirect with displacement 
000009AB  MOV R24,R24    Copy register 
--- No source file -------------------------------------------------------------
000009AC  LDI R25,0x00    Load immediate 
000009AD  LDI R18,0x00    Load immediate 
000009AE  LDI R19,0x02    Load immediate 
000009AF  MOVW R30,R18    Copy register pair 
--- X:/src/main.c -------------------
        CLEAR_ADCA_CH0_INTFLAG();
000009B0  LDD R20,Z+36    Load indirect with displacement 
000009B1  MOVW R18,R28    Copy register pair 
000009B2  SUBI R18,0xBF    Subtract immediate 
000009B3  SBCI R19,0xFF    Subtract immediate with carry 
000009B4  ADD R24,R18    Add without carry 
        ADC_PINA1_RingBuffer.pBuffer[ADC_PINA1_RingBuffer.inPos] = ADCA.CH0.RESL;
000009B5  ADC R25,R19    Add with carry 
000009B6  MOVW R30,R24    Copy register pair 
000009B7  STD Z+0,R20    Store indirect with displacement 
000009B8  MOVW R24,R28    Copy register pair 
000009B9  SUBI R24,0xAF    Subtract immediate 
000009BA  SBCI R25,0xFF    Subtract immediate with carry 
000009BB  MOVW R30,R24    Copy register pair 
000009BC  LDD R24,Z+0    Load indirect with displacement 
000009BD  MOV R18,R24    Copy register 
000009BE  SUBI R18,0xFF    Subtract immediate 
000009BF  MOVW R24,R28    Copy register pair 
000009C0  SUBI R24,0xAF    Subtract immediate 
000009C1  SBCI R25,0xFF    Subtract immediate with carry 
000009C2  MOVW R30,R24    Copy register pair 
000009C3  STD Z+0,R18    Store indirect with displacement 
000009C4  MOVW R24,R28    Copy register pair 
000009C5  SUBI R24,0xAF    Subtract immediate 
000009C6  SBCI R25,0xFF    Subtract immediate with carry 
        ADC_PINA1_RingBuffer.inPos++;
000009C7  MOVW R30,R24    Copy register pair 
000009C8  LDD R24,Z+0    Load indirect with displacement 
000009C9  MOV R18,R24    Copy register 
000009CA  ANDI R18,0x0F    Logical AND with immediate 
000009CB  MOVW R24,R28    Copy register pair 
000009CC  SUBI R24,0xAF    Subtract immediate 
000009CD  SBCI R25,0xFF    Subtract immediate with carry 
000009CE  MOVW R30,R24    Copy register pair 
000009CF  STD Z+0,R18    Store indirect with displacement 
000009D0  LDS R24,0x2008    Load direct from data space 
000009D2  MOV R24,R24    Copy register 
        ADC_PINA1_RingBuffer.inPos = ADC_PINA1_RingBuffer.inPos & 0x0F;
000009D3  LDI R25,0x00    Load immediate 
000009D4  ANDI R24,0x20    Logical AND with immediate 
000009D5  ANDI R25,0x00    Logical AND with immediate 
000009D6  SBIW R24,0x00    Subtract immediate from word 
000009D7  BRNE PC+0x02    Branch if not equal 
000009D8  RJMP PC+0x004E    Relative jump 
000009D9  LDI R24,0x00    Load immediate 
000009DA  LDI R25,0x02    Load immediate 
--- X:\src/main.c -------------------
000009DB  LDI R18,0x00    Load immediate 
000009DC  LDI R19,0x02    Load immediate 
000009DD  MOVW R30,R18    Copy register pair 
000009DE  LDD R18,Z+33    Load indirect with displacement )

Lass mich aber teilhaben und erkläre mir mal, wie du bei der Fehlersuche 
vorgehst.
ich meine schon beim Makro entsteht ja Code, der nicht sein kann. Wofür 
dann mehr davon?

[Peter II (Gast)]

mit ATxMega hatte ich bis jetzt noch nicht zu tun, aber das kommt mir 
merkwürdige vor:

00000924  LDS R24,0x200C    Load direct from data space 
00000926  TST R24    Test for Zero or Minus 
  PK0_LED_GREEN_ON();
00000927  BRNE PC+0x02    Branch if not equal 
00000928  RJMP PC+0x02AC    Relative jump

hier wird scheinbar ein wert vom FLASH in das Register R24 geladen. 
Diese stelle konnte ich schon mal nicht im code finden, eventuell in 
einem Makro versteckt.

Wenn dieser Wert != 0 ist dann wird der "merkwürdige" spung nicht 
ausgeührt. Scheinbar steht hier aber ein Wert 0 drin, damit sprint er 
dann.

[Joe (Gast)]

Die Zeilen

00000916  LDS R24,0x200B    Load direct from data space 
00000918  TST R24    Test for Zero or Minus

stehen da immer, auch wenn ich die im C-Code vorangehenden Makros 
auskommentiere aus:

  ENABLE_GLOBAL_INT();
  ENABLE_USARTF0_RX_INT();
  ENABLE_USARTF0();
  ENABLE_GLOBAL_HIGH_LEVEL_INT();
  ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();

  // Signal, that the Board is up and running
  PK0_LED_GREEN_ON();

Wurde als

  ENABLE_GLOBAL_INT();
  ENABLE_USARTF0_RX_INT();
  ENABLE_USARTF0();
  //ENABLE_GLOBAL_HIGH_LEVEL_INT();
  //ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();

  // Signal, that the Board is up and running
  PK0_LED_GREEN_ON();

[Joe (Gast)]

So, jetzt habe ich aus dem Makro PK0_LED_GREEN_ON eine Funktion gemacht.
Die auskommentierten Zeilen habe ich wieder eingefügt und nun schaut 
euch mal den Assemblercode an:

  ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();
00000933  TST R24    Test for Zero or Minus 
00000934  BRLT PC+0x02    Branch if less than, signed 
00000935  RJMP PC+0x004D    Relative jump 
00000936  LDI R24,0x00    Load immediate 
00000937  LDI R25,0x02    Load immediate 
  PK0_LED_GREEN_ON();
00000938  LDI R18,0x00    Load immediate 
00000939  LDI R19,0x02    Load immediate 
0000093A  MOVW R30,R18    Copy register pair

Keine Sprünge mehr! - So sieht es besser aus!

Das Problem scheint also im Preprozessor versteckt zu sein...
Oder sehe ich das falsch?

[Anton (Gast)]

>00000924  LDS R24,0x200C    Load direct from data space
>00000926  TST R24    Test for Zero or Minus
>  PK0_LED_GREEN_ON();
>00000927  BRNE PC+0x02    Branch if not equal
>00000928  RJMP PC+0x02AC    Relative jump

Kenne die ATXMEGAS leider nicht, nur weiß ich daß
bei den ATMEGAS der LDS-Befehl die Zustandsflags
NICHT! beeinflußt, die stehen so wie sie vom letzten
z.B. "and" etc. Befehl, der die Flags beeinflußt,
zurückgelassen wurden.

LDS lädt aus dem Datenbereich. Was steht dort?

[Joe (Gast)]

Anton schrieb:
> LDS lädt aus dem Datenbereich. Was steht dort?

Was für ein "Datenbereich"!?

[Johann L. (gjlayde)]

Mit dem Code kann niemand was anfangen.

Das sind doch nur Makros die keiner kennt.  Das kann alles mögliche 
sein...

[Peter II (Gast)]

Joe schrieb:
> Was für ein "Datenbereich"!?

Flash - irgendetwas mit Progmem

[Joe (Gast)]

Johann L. schrieb:
> Das sind doch nur Makros die keiner kennt.

Wieso, zwei Makros bei denen es schief läuft sind angegeben:

#define ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT() TCE0.INTCTRLB = 0x03

#define PK0_LED_GREEN_ON() \
  do { \
    PORTK_OUTSET = 0x02; \
    PORTK_OUTCLR = 0x01; \
    } while(0)

[Joe (Gast)]

Peter II schrieb:
> Joe schrieb:
>> Was für ein "Datenbereich"!?
>
> Flash - irgendetwas mit Progmem

Achso, du willst wissen, was in Adresse 0x200C steht!?

[Anton (Gast)]

>00000924  LDS R24,0x200C    Load direct from data space

Der Befehl besagt, daß der Inhalt der Adresse 0x200C
in das Register geladen wird. Ob die Adresse auch wirklich
vorhanden ist, weiß ich nicht.

Bei den ATMEGAS wird als Datenbereich alles bezeichnet
was NICHT Programmspeicher oder EEPROM ist.

[Joe (Gast)]

00000931  LDS R24,0x2008    Load direct from data space 
  ENABLE_TIMER_TCE0_COMP_A_HIGH_LEVEL_INT();
00000933  TST R24    Test for Zero or Minus

data 0x002008  0c 03 f0 01 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 
00 00 00 00 00 00 00 00 00 00

[MWS (Gast)]

Peter II schrieb:
> Joe schrieb:
>> Was für ein "Datenbereich"!?
>
> Flash - irgendetwas mit Progmem

Unsinn, LDS kann kein Flash lesen. Um aus Progmem zu lesen, benötigt man 
LPM.

[Johann L. (gjlayde)]

Joe schrieb:
> Johann L. schrieb:
>> Das sind doch nur Makros die keiner kennt.
>
> Wieso, zwei Makros bei denen es schief läuft sind angegeben:

Was heisst schon "bei denen es schief geht"?

Versuch erst mal, die Stelle im Quellcode zu finden, der zu dem 
Disassenbly passt, annstatt dich von Kommentaren irritieren zu lassen, 
die irgendein Tool nach dem Gießkanneprinzip über das Disassembly 
verteilt hat.

- Das Disassembly enthält bedingte Sprünge, die Makros nicht

- Das Disassembly enthält kein 0x3, das Makro aber wohl

- etc.

[Joe (Gast)]

Sorry, meine begrenzten geistigen Fähigkeiten lassen es nicht zu, deine 
Antwort zu verstehen.
Ich erwarte, dass wenn ich den Dissambly-Code anschaue und der Code den 
Namen des Makros enthält, dass dann auch der Assemblercode zu diesem 
Makro gehört. Zumal der Breakpoint ebenfalls an dieser stelle sitzt...

[Peter II (Gast)]

Joe schrieb:
> Ich erwarte, dass wenn ich den Dissambly-Code anschaue und der Code den
> Namen des Makros enthält, dass dann auch der Assemblercode zu diesem
> Makro gehört.

das stimmt leider nicht immer. Der Optimierer kann die Reihenfolge von 
befehlen ändern damit ist eine zuordnung von C zu ASM nicht mehr 
möglich.

schmeiss doch mal alles raus bis auf einen leere Main funktion. Dann der 
reihe nach wieder rein nehmen und schauen ab wann dieser code auftauch.