Problem mit ATmega1284, USART verursacht Resets

[Gerold (Gast)]

Mir ist beim Verwenden des USART des Controllers ein Problem 
aufgefallen. Es kommt häufig vor, dass der Controller resetet, wenn ein 
Signal an den USART gesendet wird.

Das Programm habe ich in C geschrieben. Es steuert 5 TLC5940 über den 
PortA an. Am Controller sind zwei 100nF Abblokkondensatoren für VCC und 
AVCC sowie ein 100nF an AREF. Es wird ein 20 MHz Quarz verwendet. Als 
RS232 Überträger verwende ich den im STK500 integrierten. Weiterhin ist 
die ISP an das STK500 angeschlossen.

Die TxD und RxD Leitungen des USART 0 habe ich direkt mit dem 
entsprechenden Header des STK500 verbunden. Wenn nun vom PC aus über 
HTerm Signale an den USART sende, treten häufig Resets des Controllers 
auf. Dies ist nicht davon abhängig, ob der USART0 im Programm 
tatsächlich aktiviert ist oder nicht! Wenn allerdings alle Interrupts 
global abgeschaltet sind, tritt der Reset nicht mehr auf. Es sind 
allerdings im Programm keine anderen Interrupts als Timer 1 und Timer 2 
(und der USART) aktiviert. Im Register MCUSR sind nach dem Reset alle 
bits 0.

Was ich schon getestet habe:

-Stromversorgung nicht über STK500 - keine Änderung

-USART deaktiviert - trotzdem Resets

-STK500 an USART1 angeschlossen (USART0 und 1 deaktiviert) - trotzdem 
Resets

-Interrupts deaktiviert - funktioniert

-ISP abgetrennt - keine Änderung

Also meine Frage: Muss man beim ATmega1284 noch irgendwas deaktivieren? 
Die USART Pins werden ja auch noch für Pin Change Interrupt verwendet. 
Dann sollte der Reset aber doch immer auftreten, oder?

Hier noch mein Code, leider noch nicht dokumentiert, aber die Init 
Routinen sollte erkennbar sein.

#define F_CPU 20000000
#define DEVICE_ADDRESS 0x01
#include <avr/io.h>
#include <stdint.h> 
#include <util/delay.h> 
#include <avr/interrupt.h> 
#define VPRG PORTA0
#define SIN PORTA1
#define SCLK PORTA2
#define XLAT PORTA3
#define BLANK PORTA4
#define DCPRG PORTA5
#define GSCLK PORTA6
#define XERR PORTA7

volatile uint8_t refresh;
volatile uint8_t trigger;
uint8_t DCvalues[80];
uint16_t PWMvalues[80];
uint8_t ValueMap[80][100];
uint8_t ControlMap[30][100];
uint8_t Patch[80];
uint16_t Curve[256];

void Scycle(void)
  {
    PORTA |= (1 << SCLK);
    PORTA &= ~(1 << SCLK);
  }
  
void Xcycle(void)
  {
    PORTA |= (1 << XLAT);
    PORTA &= ~(1 << XLAT);
}  




void SendPWM(uint16_t x)
{  
  if(x & 0b0000100000000000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000010000000000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000001000000000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000100000000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000010000000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000001000000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000000100000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000000010000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000000001000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000000000100){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000000000010){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b0000000000000001){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
}  

void ProgPWM(void)
{
  int i;
  for(i=0;i<80;i++){SendPWM(PWMvalues[i]);}
  Xcycle();
}


void SendDC(uint8_t x)
{
  if(x & 0b00100000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b00010000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b00001000){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b00000100){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b00000010){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
  if(x & 0b00000001){PORTA |= (1 << SIN);}
  else{PORTA &= ~(1 << SIN);}
  Scycle();
}  


  
void ProgDC(void)
{
  int i;
PORTA |= (1 << VPRG);for(i=0;i<80;i++){SendDC(DCvalues[i]);}
  Xcycle();
  PORTA &= ~(1 << VPRG);
}

uint8_t CalcOutput(uint8_t frameval,uint8_t preframeval,uint8_t fadeval)
{
  uint16_t v1 = (uint16_t)frameval*fadeval/255;
  uint16_t v2 = (uint16_t)preframeval*(255-fadeval)/255;
  uint16_t v5 = v1+v2;
  if(v5 > 255){return 255;}
  else{return v5;}
    //return frameval;
}
void OutputData(uint8_t frameA, uint8_t frameB,uint8_t frameC,uint8_t frameD,uint8_t preframeA, uint8_t preframeB,uint8_t preframeC,uint8_t preframeD,uint8_t fadecounterA, uint8_t fadecounterB,uint8_t fadecounterC,uint8_t fadecounterD)
{
  int i;
  for(i=0;i<32;i++){PWMvalues[Patch[i]] = Curve[CalcOutput(ValueMap[i][frameA],ValueMap[i][preframeA],fadecounterA)];}
  for(i=32;i<64;i++){PWMvalues[Patch[i]] = Curve[CalcOutput(ValueMap[i][frameB],ValueMap[i][preframeB],fadecounterB)];}  
  for(i=64;i<68;i++){PWMvalues[Patch[i]] = Curve[CalcOutput(ValueMap[i][frameC],ValueMap[i][preframeC],fadecounterC)];}  
  for(i=68;i<80;i++){PWMvalues[Patch[i]] = Curve[CalcOutput(ValueMap[i][frameD],ValueMap[i][preframeD],fadecounterD)];}  
  ProgPWM();
}      
int main(void)
{
  DDRA = 0xff;
  DDRB  =0xff;
  DDRC = 0xFF;
  PORTC = (1 << 4);
  DDRA &= ~(1 << XERR);
  PORTA = (0 << VPRG) | (0 << SIN)| (0 << SCLK)| (0 << XLAT)| (1 << BLANK)| (1 << DCPRG)| (0 << GSCLK);
  int i;
  for(i=0;i<256;i++){Curve[i] = i;}
  for(i=0;i<80;i++){Patch[i] = i;}
  for(i=0;i<80;i++){DCvalues[i] = 10;}
  int j;  
  for(i=0;i<80;i++){for(j=0;j<100;j++){ValueMap[i][j] = (j%2)*255;}}
  for(i=0;i<4;i++){for(j=0;j<100;j++){ControlMap[i][j] = 64;}}//TriggerTime
  for(i=4;i<8;i++){for(j=0;j<100;j++){ControlMap[i][j] = 1;}}  //FadeAmmount
  for(i=8;i<12;i++){for(j=0;j<100;j++){ControlMap[i][j] = 1;}}//TriggerControl
  for(i=12;i<16;i++){for(j=0;j<100;j++){ControlMap[i][j] = 0;}}//LoopControl
  for(i=16;i<20;i++){for(j=0;j<100;j++){ControlMap[i][j] = 0;}}//LoopDestination
  for(i=20;i<24;i++){for(j=0;j<100;j++){ControlMap[i][j] = 0;}}//LoopCounter
  for(i=24;i<28;i++){ControlMap[i][0] = 255;}      
  ProgDC();    
  
  TCCR0A = (1 << WGM01)|(1<<COM0A0);
  TCCR0B = (1 << CS00);
  OCR0A = 0x01;
  TCCR1B = (1 << CS02) | (1 << WGM12);
  TIMSK1 = (1 << OCIE1A);
  OCR1A = 0x02FF;
  TCCR2A = (1 << WGM21);
  TCCR2B = (1 << CS20)|(1 << CS21)|(1 << CS22);
  TIMSK2 = (1 << OCIE2A);
  OCR2A = 0x04;
  UBRR0L = 64;
  UCSR0C = (1 << UCSZ00)|(1 << UCSZ01);
  UCSR0B = (1 << RXCIE0)|(1 << RXEN0);
  PORTA &= ~(1 << BLANK);
  sei();
  PORTC &= ~(1 << 4);
  PORTC = MCUSR;
  MCUSR = 0;
    while(1)
    {  
    if(trigger != 0){refresh = 1;}
    if(trigger == 10){ProgDC();}
    if(refresh == 1){
//static int c;
      static int framediv;              
      static int fc1,fc2,fc3,fc4;
      static int ft1,ft2,ft3,ft4;
      static int pfc1,pfc2,pfc3,pfc4;
      static int fac1,fac2,fac3,fac4;
      framediv++;
      if(framediv == 16)
      {
        ft1++;
        if((ft1 == ControlMap[0][fc1] && ControlMap[8][fc1] == 1)||(ControlMap[8][fc1]==trigger))
        {
          pfc1=fc1;
          if(ControlMap[12][fc1]==0){fc1++;}
          else{
            if(ControlMap[20][fc1] < ControlMap[12][fc1]){
              fc1 = ControlMap[16][fc1];
              ControlMap[20][fc1]++;
            }
            else{
              ControlMap[20][fc1]=0;
              fc1++;
            }
          }
          if((fc1 == 100)|(fc1==ControlMap[24][0])){fc1 = 0;}
          ft1 = 0;
          fac1 = 0;
        }
        ft2++;
        if((ft2 == ControlMap[1][fc2] && ControlMap[9][fc2] == 1)||(ControlMap[9][fc2]==trigger))
        {
          pfc2=fc2;
          if(ControlMap[13][fc2]==0){fc2++;}
          else{
            if(ControlMap[21][fc2] < ControlMap[13][fc2]){
              fc2 = ControlMap[17][fc2];
              ControlMap[21][fc2]++;
            }
            else{
              ControlMap[21][fc2]=0;
              fc2++;
            }
          }
          if((fc2 == 100)|(fc2==ControlMap[25][0])){fc2 = 0;}
          ft2 = 0;
          fac2 = 0;
        }
        ft3++;
        if((ft3 == ControlMap[2][fc3] && ControlMap[10][fc3] == 1)||(ControlMap[10][fc3]==trigger))
        {
          pfc3=fc3;
          if(ControlMap[14][fc3]==0){fc3++;}
          else{
            if(ControlMap[22][fc3] < ControlMap[14][fc3]){
              fc3 = ControlMap[18][fc3];
              ControlMap[22][fc3]++;
            }
            else{
              ControlMap[22][fc3]=0;
              fc3++;
            }
          }
          if((fc3 == 100)|(fc3==ControlMap[26][0])){fc3 = 0;}
          ft3 = 0;
          fac3 = 0;
        }
        ft4++;
        if((ft4 == ControlMap[3][fc4] && ControlMap[11][fc4] == 1)||(ControlMap[11][fc4]==trigger))
        {
          pfc4=fc4;
          if(ControlMap[15][fc4]==0){fc4++;}
          else{
            if(ControlMap[23][fc4] < ControlMap[15][fc4]){
              fc4 = ControlMap[19][fc4];
              ControlMap[23][fc4]++;
            }
            else{
              ControlMap[23][fc4]=0;
              fc4++;
            }
          }
          if((fc4 == 100)|(fc4==ControlMap[27][0])){fc4 = 0;}
          ft4 = 0;
          fac4 = 0;
        }
        framediv = 0;
        //c++;
      }
      if(fac1 + ControlMap[4][fc1] < 255){fac1 += ControlMap[4][fc1];}
      else{fac1 = 255;}
      if(fac2 + ControlMap[5][fc2] < 255){fac2 += ControlMap[5][fc2];}
      else{fac2 = 255;}
      if(fac3 + ControlMap[6][fc3] < 255){fac3 += ControlMap[6][fc3];}
      else{fac3 = 255;}
      if(fac4 + ControlMap[7][fc4] < 255){fac4 += ControlMap[7][fc4];}
      else{fac4 = 255;}  
      OutputData(fc1,fc2,fc3,fc4,pfc1,pfc2,pfc3,pfc4,fac1,fac2,fac3,fac4);      
      refresh = 0;
      if(trigger != 0){trigger = 0;}      
    }
  }
}

ISR(TIMER2_COMPA_vect)
{
  PORTA |= (1 << BLANK);
  PORTA &= ~(1 << BLANK);
}

ISR(TIMER1_COMPA_vect)
{
  refresh = 1;
}

void SaveStore(uint8_t mw, uint8_t it, uint8_t t)
{
  if(mw == 200){if(it < 80){DCvalues[it]=t;}}
  else if(mw == 201){Curve[it]=t;}  
  else if(mw == 202){if(it < 80){Patch[it]=t;}}
  else if((mw >= 116) && (mw < 120)){if(it < 80){if(t < 100){Patch[it]=t;}}}  
  else if((mw >= 100) && (mw < 128)){if(it < 100){ControlMap[mw-100][it]=t;}}
  else{if(it < 100){ValueMap[mw][it]=t;}}
}

ISR(USART0__RX_vect)
{
  static uint8_t uart_status;
  uint8_t temp;
  static uint8_t mem_write_address;
  static uint8_t lenght;
  static uint8_t mem_iter;
  switch(uart_status){
  case 0:
    if(UCSR0A & (1 << FE0)){uart_status = 1;}
    temp = UDR0;
    break;
  case 1:
    temp = UDR0;
    if(temp == 0){uart_status = 2;}
    else{uart_status = 0;}
    break;  
  case 2:
    temp = UDR0;
    if(temp == 0){uart_status = 3;}
    else{trigger = temp;uart_status = 0;}
    break;
  case 3:
    temp = UDR0;
    if(temp == DEVICE_ADDRESS){uart_status = 4;}
    else{uart_status = 0;}
    break;
  case 4:
    temp = UDR0;
    mem_write_address = temp;
    uart_status = 5;
    break;
  case 5:
    temp = UDR0;
    lenght = temp;
    mem_iter=0;
    uart_status = 6;
    break;
  case 6:
    temp = UDR0;
    SaveStore(mem_write_address,mem_iter,temp);
    if(mem_iter == lenght){uart_status = 0;}  
    mem_iter++;
    break;
  }
//  PORTC = uart_status;
}

[Stefan E. (sternst)]

ISR(USART0__RX_vect)
          ^

[Nils S. (kruemeltee)]

Stefan Ernst schrieb:
> ISR(USART0__RX_vect)

Das müsste der gcc doch mit "misspelled isr?" oder ähnlich kommentieren, 
oder nicht?!

[Stefan E. (sternst)]

Nils S. schrieb:
> Stefan Ernst schrieb:
>> ISR(USART0__RX_vect)
>
> Das müsste der gcc doch mit "misspelled isr?" oder ähnlich kommentieren,
> oder nicht?!

Ja.
Wäre ja aber nicht das erste Mal, das jamand Warnungen einfach 
ignoriert.

[Gerold (Gast)]

Also eine Warnung kommt da nicht, außerdem markiert AVRStudio das lila, 
also gehe ich schon davon aus, dass es stimmt.

[Nils S. (kruemeltee)]

Selbst ohne -Wall meckert der gcc:

> test.c:9: warning: 'testisr' appears to be a misspelled signal handler

...
#include <avr/interrupt.h>
...
ISR(testisr) {
...

AVR-Studio weiss nicht, was dein Compiler macht oder wie die ISRs 
heissen.

[Thomas E. (thomase)]

Gerold schrieb:
> also gehe ich schon davon aus, dass es stimmt.
Das ist eindeutig ein Fehler: ISR(USART0__RX_vect)
Und nur das ist richtig: ISR(USART0_RX_vect)
Ob das nun lila wird oder nicht.

mfg.

[Stefan E. (sternst)]

Thomas Eckmann schrieb:
> Gerold schrieb:
>> also gehe ich schon davon aus, dass es stimmt.
> Das ist eindeutig ein Fehler: ISR(USART0__RX_vect)
> Und nur das ist richtig: ISR(USART0_RX_vect)
> Ob das nun lila wird oder nicht.

Es ist aber nicht zwangsläufig die Ursache des Problems. Denn obwohl 
"eigentlich falsch" könnte es dennoch richtig sein. Die Atmel-Leute 
haben bei ihrer eigenen Toolchain so manches verbockt. Dazu gehören auch 
diverse Vektoren mit doppelten Unterstrich. Siehe z.B. hier:
http://www.avrfreaks.net/index.php?name=PNphpBB2&file=viewtopic&t=117536

[Daniel F. (df311)]

Gerold schrieb:
> -Interrupts deaktiviert - funktioniert

dein code im ersten beitrag ist mir eindeutig zu lang um ihn 
durchzuschauen, aber die zitierte zeile gibt schon einen super hinweis 
auf die ursache: irgendein interrupt (adc, uart2, timer, brown-out, ...) 
wird ausgelöst, der keine isr hat...

[Gerold (Gast)]

Also bei USART0__RX_vect gibt es keine Warnung, bei USART0_RX_vect 
schon. Mit USART0_RX_vect stürzt auch der AVR bei jedem seriellem Input 
ab und startet nicht mehr richtig bis man manuell Reset drückt.

[... (Gast)]

während der Initialisierung der UARTs müssen die INTs gesperrt werden.

[Thomas E. (thomase)]

Gerold schrieb:
> Also bei USART0__RX_vect gibt es keine Warnung, bei USART0_RX_vect
> schon. Mit USART0_RX_vect
Was steht denn in der iom1284p.h als Definition drin?

Und schreib' dir mal ein kleines Testprogramm, mit nichts weiter als der 
USART-Isr, die einfach nur das empfangene Zeichen wieder zurück sendet.

mfg.

[Gerold (Gast)]

In der iom1284.h ist der Vektor mit 2 Unterstrichen definiert.

Ein kleines Beispielprogramm in dem nur der UART verwendet wird 
funktioniert auch.

[Krapao (Gast)]

Wenn die IRQs nicht aktiviert sind, wird refresh auch nicht durch die 
Timer-ISR oder über trigger 1, d. h. der riesige Anweisungsblock in 
main() wird nicht ausgeführt.

Eine Reset-Quelle in diesem Block könnte ein Stackoverflow sein. Du hast 
ca 11 kB globale Daten. Plus die statischen Daten im riesigen 
Anweisungsblock plus sonstige lokale Daten.

Weitere Fehlerquellen können Bufferoverflows bei den vielen Schleifen 
sein. Hier und bei den Dimensionierungen der Felder lohnt es sich statt 
mit absoluten Werten mit Makronamen als Grenzen zu arbeiten. Wenn man 
das macht, ist es auch einfacher die Grenzen zu verkleinern, um einen 
potentiellen Stackoverflow zu entlarven.

[Gerold (Gast)]

Stackoverflow wäre natürlich eine Möglichkeit, aber wie gesagt der 
Fehler tritt auch auf wenn der Uart gar nicht an ist, und einfach nur 
das Signal an die Pins angelegt wird.

Ich habe trotzdem mittels Auskommentierung getestet ob man den Fehler 
eingrenzen kann und es schaut so aus als ob der Fehler immer dann 
auftritt, wenn ein Signal an den Uart kommt und gleichzeitig der AVR 
Daten an die TLCs sendet. Kommentiert man das nämlich aus funktionierts.

[Gerold (Gast)]

Hab noch keine Lösung gefunden. Problem scheint schlimmer zu werden, 
jetzt funktioniert auch ein kleines Testprogramm wie dieses nicht mehr:

/*
 * AVRGCC1.c
 *
 * Created: 24.02.2012 23:00:34
 *  Author: Gerold von Lachemair
 */ 
#define F_CPU 20000000
#define DEVICE_ADDRESS 0x01
#include <avr/io.h>
#include <stdint.h> 
#include <util/delay.h> 
#include <avr/interrupt.h> 
#define VPRG PORTA0
#define SIN PORTA1
#define SCLK PORTA2
#define XLAT PORTA3
#define BLANK PORTA4
#define DCPRG PORTA5
#define GSCLK PORTA6
#define XERR PORTA7

      
int main(void)
{
  DDRC = 0xFF;
  PORTC = (1 << 4);
  sei();
  PORTC &= ~(1 << 4);
  PORTC = MCUSR;
  MCUSR = 0;
    while(1)
    {  

  }
}

Auch hier treten die Resets auf, wenn an den UART gesendet wird.

Hab an Hardware jetzt auch nichts mehr außer Spannungsversorgung (mit 
Kondensatoren), Quarz, ISP und UART dran.

[Krapao (Gast)]

Ich würde bei der

Hardware

1) einen anderes µC Exemplar testen, um auszuschießen, dass der jetzige 
µC einen Hau weg hat.

2) alle Spannungen an allen Pins des µC messen und im Schaltplan / 
Aufbaubild dokumentieren. Messbezugspunkt ist GND am µC.

3) mit einem DSO oder einem LA den Spannungsverlauf beim Anlegen von 
Signalen an UART-Pins aufzeichnen.

und bei der Software

4) die Fuses (Watchdog?, Brownout?) und den Flashinhalt auslesen 
und das HEX-File disassemblieren, um auszuschließen, dass die Toolchain 
ink. Flashen schief geht.

[Dietrich L. (dietrichl)]

Es könnte auch ein einfacher Kurzschluss zwischen RX und einem anderen 
Signal sein, das den RX-Ruhepegel hat. Beim Empfang zieht RX soviel 
Strom, dass Vcc einbricht und einen Reset auslöst.

Gruß Dietrich

[Gerold (Gast)]

Problem anscheinend gelöst!


Nachdem ich eure Vorschläge alle soweit möglich durchgearbeitet habe und 
den µc auch unter Assembler getestet habe, bin ich schließlich durch 
Probieren auf die Lösung gekommen: der Atmel mag unter der Einstellung 
EXTOSC nur Quarze bis 16 MHz, für 20 MHz muss man FSOSC verwenden, dann 
gehts!