AtMega1284P: 0x12 + 0x01 = 0x03 (WTF?)

[Tobias S. (Firma: none) (tobimc)]

Hi,

ich habe ein ziemlich komisches Problem....
Ich versuche gerade, eine ADC-ISR zu programmieren, die 2 ADC-Kanäle des 
AVRs im Wechsel ausliest.
Zunächst zu den Rahmenbedingungen:

Hardware: AtMega1284P @ 20MHz bei 3,3V (clean) auf eigener Platine
IDE/Toolchain: Atmel Studio 6 mit integrierter Toolchain
Gedebuggt habe ich mit meinem Dragon.

Hier mal mein Code:

#define F_CPU 20000000

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

#include <stdlib.h>



#define LED_SET         PORTB |= (1<<1);
#define LED_CLR         PORTB &= ~(1<<1);
#define LED_TOG         PORTB ^= (1<<1);


volatile uint32_t sumA = 0;
volatile uint32_t sumB = 0;
volatile uint16_t count = 0, maxcount = 0;
volatile uint32_t count2 = 0, countA = 0, countB = 0, countC = 0;

uint8_t uartstate = 0;


uint8_t init_uart(uint16_t ubrr){  //UART initialisieren

  UBRR0L = (uint8_t) (ubrr & 0xFF);   //Baudrate
  UBRR0H = (uint8_t) ((ubrr & 0xF00) >> 8); 
  UCSR0B |= ((1<<TXEN0) | (1<<RXEN0));   //Tx- und RxEnable
  UCSR0C |= ((1<<UPM00) | (3<<UCSZ00));   //Parity, STOP usw...

  uartstate = 1;     //Statusvariable: UART offen (!= 0).

  return 0; 
}

uint8_t uart_puts(const char *string){  //Sendet einen String
  uint8_t currentchar = 0;

  if(uartstate != 0){    //UART-Status.
    while((uint8_t)string[currentchar] != 0){  
      while(!(UCSR0A & (1<<UDRE0)));  //Überprüfen ob der UART was hat, gegebenenfalls warten
      UDR0 = (uint8_t) string[currentchar];  //Senden, zur sicherheit noch in BYTE umwandeln.

      currentchar++;
    } 
  }else{      //UART nicht initialisiert?
    return 1;  //ERROR!!
  } 

  return 0; 
}

uint8_t startAQ(uint8_t samplesCH){

    if(count != 0){
        sumA = 0;
        sumB = 0;
        count = 0;
        maxcount = samplesCH * 2;
    
  ADMUX = ((3<<REFS0) | 0); 
        ADCSRA = ((1<<ADIE) | (1<<ADSC) | (1<<ADEN) |  (7<<ADPS0));
    
        return 1;
    }else{
        return 0;
    }

    return 0;
}


int main(void){
    uint16_t foo = 0;
    char txt[20];

    init_uart(10);

    DDRB = (1<<1);

    ADCSRB = 0;
    ADMUX = ((3<<REFS0) | (0x1E<<0));
    ADCSRA = ((1<<ADEN) | (1<<ADSC) |  (7<<ADPS0));

    while(ADCSRA & (1<<ADSC));
    foo = ADC;
    foo++;

    count = 100;

    sei();

    while(1){


        //DEBUG-OUTPUT (prae-Dragon)
        uart_puts("count2 ");
        utoa(count2, txt, 10);
        uart_puts(txt);
        uart_puts("\t");

        uart_puts("countA ");
        utoa(countA, txt, 10);
        uart_puts(txt);
        uart_puts("\t");

        uart_puts("countB ");
        utoa(countB, txt, 10);
        uart_puts(txt);
        uart_puts("\t");

        uart_puts("countC ");
        utoa(countC, txt, 10);
        uart_puts(txt);
        uart_puts("\t");

        uart_puts("sumA ");
        utoa((uint32_t)sumA, txt, 10);
        uart_puts(txt);
        uart_puts("\t");

        uart_puts("sumB ");
        utoa((uint32_t)sumB, txt, 10);
        uart_puts(txt);
        uart_puts("\n");

        while(PIND & (1<<3)); //warten bis knopf gedrückt...
        while(!(PIND & (1<<3))); //...und wieder losgelassen

        count2 = 0; //reset
        countA = 0;
        countB = 0;
        countC = 0;
//Hier wirds interessant:
        startAQ(10);  //Start der Aquise, s.o.

        while(count < maxcount); //abwarten bis alle Messwerte gesammelt wurden.

    }

    while(1);

    return 0;
}

ISR(ADC_vect){
    char txt[20];

count2 = count2 + 1; //count2++; //auch ohne erfolg

  count = countA + countB;

    if(count < maxcount){

        if(ADMUX & 1){
            sumA += ADC;
            countA++;
            ADMUX = ((3<<REFS0) | 0);
        }else{
            sumB += ADC;
            countB++;
            ADMUX = ((3<<REFS0) | 1);
        }

        ADCSRA |= (1<<ADSC);

    }else{
        countC++;
        ADCSRA &= ~((1<<ADIE) | (1<<ADSC));
    }

}

Im Debugger läuft der Code ohne Weiteres, bis auf ein mal die Variable 
count2 (a.k.a. R24, s.u.) z.B. von 0x12 auf 0x03 springt. Der Fehler 
scheint irgendwie zur Laufzeit zu passierten, denn es scheint nicht vom 
Wert von count2 abhängig, auch wenn der Fehler nie bei Werten unterhalb 
0x10 passiert (vllt. wichtig?).

Das disassembly von count2 = count2 + 1; sieht folgendermaßen aus:

count2 = count2 + 1;
000001B7  LDS R24,0x013D    Load direct from data space 
000001B9  LDS R25,0x013E    Load direct from data space 
000001BB  LDS R26,0x013F    Load direct from data space 
000001BD  LDS R27,0x0140    Load direct from data space 

000001BF  ADIW R24,0x01    Add immediate to word 
000001C0  ADC R26,R1    Add with carry 
000001C1  ADC R27,R1    Add with carry 

000001C2  STS 0x013D,R24    Store direct to data space 
000001C4  STS 0x013E,R25    Store direct to data space 
000001C6  STS 0x013F,R26    Store direct to data space 
000001C8  STS 0x0140,R27    Store direct to data space

Der Fehler passiert bei ADIW R24,0x01. R24 wurde davor aus dem RAM mit 
(z.B.) 0x12 geladen, und wenn ADIW R24,0x01 ausgeführt wird steht da in 
R24 z.B. statt 0x13 0x03.
Es hat fast den Anschein, als wäre das obere Nibble auf dem Weg von der 
ALU zurück abanden gekommen...

Ich bin jetzt ehrlichgesagt ratlos.
Habt ihr ne Idee? (Auch wie man der ganzen Sache noch näher auf den Zahn 
fühlen könnte...? -> ich dachte zuerst an einen unerlaubten RAM-Zugriff, 
aber das konnte ich durch einen Data-Breakpoint ausschließen...)

Danke euch,
Tobi

[holger (Gast)]

>Es hat fast den Anschein, als wäre das obere Nibble auf dem Weg von der
>ALU zurück abanden gekommen...

Ja, so ist es. Auf Variablen die grösser 8Bit sind und die
in einem Interrupt verändert werden sollte man beim AVR
ausserhalb eines Interrupts nur mit Interruptsperre zugreifen.

Beispiel:

cli();
count2 = 0; //reset
sei();

[chris (Gast)]

Tobias Schlegel schrieb:
> AtMega1284P @ 20MHz bei 3,3V

damit bewegst du dich übrigens bereits außerhalb der Spezifikation des 
Prozessors.
Dein Problem muss zwar nicht unbedingt daran liegen, aber Fehlfunktionen 
durch die zu niedrige Versorgungsspannung sind trotzdem nicht 
auszuschließen.

 Speed Grades
– 0 - 4 MHz @ 1.8 - 5.5V
– 0 - 10 MHz @ 2.7 - 5.5V
– 0 - 20 MHz @ 4.5 - 5.5V


lg
Chris

[Tobias S. (Firma: none) (tobimc)]

Hi,

holger schrieb:
> Auf Variablen die grösser 8Bit sind und die
> in einem Interrupt verändert werden sollte man beim AVR
> ausserhalb eines Interrupts nur mit Interruptsperre zugreifen.
Zugegeben, ist nicht gerade guter Stil, generell eine ISR ohne 
Interruptsperre zu implementieren, allerdings ist es geplant die ADC-ISR 
als 'NOBLOCK' laufen zu lassen, da der AVR in dem eigentlichen Programm 
noch 2 Phasenanschnittstreiber mit 100Hz bedienen soll, also noch andere 
wichtige Dinge zu tun hat...
Der Debugger hat auch keinen Hinweis darauf geliefert, dass die ISR 
durch einen anderen Interrupt unterbrochen wurde. Ausserdem passiert das 
Malheur während 1 einzigen Instruktion.

chris schrieb:
> damit bewegst du dich übrigens bereits außerhalb der Spezifikation des
> Prozessors.
Whoops, da hast du recht!

chris schrieb:
> Dein Problem muss zwar nicht unbedingt daran liegen, aber Fehlfunktionen
> durch die zu niedrige Versorgungsspannung sind trotzdem nicht
> auszuschließen.
Yep, ich werde das trotzdem gleich morgen mal mit 5V Versorgungsspannung 
gegenchecken. Wäre ja schon doof wenns daran liegen würde...

Dann bräuchte ich zwar nen Pegelwandler fürs TFT ... naja.
Einen Tod muss man sterben...

Danke, ich werde das mal testen...
Tobi