UART-Interrupt Problem

[Ralf (Gast)]

Hallo Leute!

Mit folgendem Code möchte ich alle LEDs meines STK500s einschalten, wenn 
irgendein Zeichen vom UART empfangen wird.
Wenn nichts empfangen wird, soll die Endlosschleife ein Lauflicht 
(später Schrittmotor) leuchten lassen.

Ich habe nun versucht, mit einem Terminal ein Zeichen zum Board zu 
schicken, leider reagiert es nicht (springt nicht in die 
Interrupt-Routine), sodass ständig nur das Lauflicht leuchtet.


Wisst ihr wo mein Fehler ist?

Hier ist mein Code:

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



#define DELAY 50

void initialisiere_UART(void)
{
  UCSRB |= (1<<RXEN);                         // Senden/empfangen aktivieren
  UCSRC |= (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1);  

  UBRRH = 00;                             // Baudrate einstellen 9600 bei 8 MHz
  UBRRL = 51;
}


ISR (USART_RXC_vect) 
{
  
  PORTA =~(0xFF);
  _delay_ms(500);
  PORTA =~(0x00);  
  _delay_ms(500);    
}




void main (void)
{
  DDRA = 0xFF;

  PORTA = ~0x01;

  initialisiere_UART();
   

  sei();                  // Interrupt scharf schalten


  while(1)
  {
    PORTA = ~(0b00000001);
    _delay_ms(DELAY);
    PORTA = ~(0b00000011);
    _delay_ms(DELAY);
    PORTA = ~(0b00000010);
    _delay_ms(DELAY);
    PORTA = ~(0b00000110);
    _delay_ms(DELAY);
    PORTA = ~(0b00000100);
    _delay_ms(DELAY);
    PORTA = ~(0b00001100);
    _delay_ms(DELAY);
    PORTA = ~(0b00001000);
    _delay_ms(DELAY);
    PORTA = ~(0b00001001);
    _delay_ms(DELAY);
  }

}

[Ralf (Gast)]

Ok, habe es herausgefunden, das Flag "RXCIE" im UCSRA-Register war nicht 
gesetzt, welches für Interrupts über UART zuständig ist.


Nun eine weitere Frage:

Mein Controller empfängt nun das Zeichen, springt auch in die 
Interrupt-Routine, leider kommt er aber aus der Interrupt-Routine nicht 
mehr raus.
(es blinken nun alle LEDs ( ~(0xFF) und ~(0x00)   ) )...

Wisst ihr woran das liegen könnte?

[Peter II (Gast)]

du musst auch das zeichen abrufen was du empfangen hast.

[Ralf (Gast)]

ah interessant! :)


Danke, hat geholfen.

Welch ein Mechanismus steckt denn da dahinter, dass man mitkriegt, ob 
ein Register ausgelesen wurde?


DAnke!

[Tom M. (tomm)]

Aus dem Datenblatt (hier zu atmegaXX8):

When the Receive Complete Interrupt Enable (RXCIEn) in UCSRnB is set, 
the USART Receive Complete interrupt will be executed as long as the 
RXCn Flag is set (provided that global inter- rupts are enabled). When 
interrupt-driven data reception is used, the receive complete routine 
must read the received data from UDRn in order to clear the RXCn Flag, 
otherwise a new interrupt will occur once the interrupt routine 
terminates.

Das RXC Flag wird gelöscht, indem die Daten abgeholt werden. Wie das in 
der Hardware verdrahtet ist - irgendwas mit FlipFlop.

[Ralf (Gast)]

So...das Programm läuft jetzt soweit, allerdings habe ich noch zwei 
Problemchen:


Wenn ich die Taste "1", "2" oder "3" im Terminal drücke, dann ändert der 
Controller die Delaytime leider nicht.

Außerdem ist mein Flash jetzt schon 25 % voll! Woran liegt das?

Hier der Code:

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



unsigned int DelayTime = 400;

void initialisiere_UART(void)
{
  UCSRB |= (1<<RXEN) | (1<<RXCIE);                         // Senden/empfangen aktivieren
  UCSRC |= (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1) ;  

  UBRRH = 00;                             // Baudrate einstellen 9600 bei 8 MHz
  UBRRL = 51;
}


ISR (USART_RXC_vect) 
{
  char empfangenesZeichen = UDR;

  switch(empfangenesZeichen)
  {
    case '1':  DelayTime = 50;
          break;

    case '2':  DelayTime = 100;
          break;

    case '3':  DelayTime = 200;
          break;
  }
}


  

void main (void)
{

    DDRA = 0xFF;

  initialisiere_UART();
   

  sei();                  // Interrupt scharf schalten


  while(1)
  {
    PORTA = ~(0b00000001);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000011);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000010);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000110);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000100);
    _delay_ms(DelayTime);
    PORTA = ~(0b00001100);
    _delay_ms(DelayTime);
    PORTA = ~(0b00001000);
    _delay_ms(DelayTime);
    PORTA = ~(0b00001001);
    _delay_ms(DelayTime);
  }

}

[Falk B. (falk)]

@  Ralf (Gast)

>Wenn ich die Taste "1", "2" oder "3" im Terminal drücke, dann ändert der
>Controller die Delaytime leider nicht.

Weil deine Baudrate nicht stimmt, wenn man den RC-Oszillator nutzt.

http://www.mikrocontroller.net/articles/AVR_Checkliste#UART.2FUSART

>Außerdem ist mein Flash jetzt schon 25 % voll! Woran liegt das?

Dein _delay_ms() hätte gern konstante Argumente.

http://www.mikrocontroller.net/articles/AVR-GCC-Tutorial#Warteschleifen_.28delay.h.29

MFG
Falk

[Arne (Gast)]

> dann ändert der Controller die Delaytime leider nicht.
volatile vergessen?

[Ralf (Gast)]

Jap, lag wohl an dem volatile.

Wie könnte man das mit der Delaytime machen, damit die Werte "konstant" 
werden bzw. der Flashspeicher eben nicht zu sehr belegt wird?!


Gruß

Ralf

[Falk B. (falk)]

@  Ralf (Gast)

>Wie könnte man das mit der Delaytime machen, damit die Werte "konstant"
>werden bzw. der Flashspeicher eben nicht zu sehr belegt wird?!

Glotzn ofmachn, geeene Fedbemm fressen und orweidn!

void long_delay(uint16_t ms)
{
    for(; ms>0; ms--) _delay_ms(1);
}

[Ralf (Gast)]

Supooo :)


Danke!

[Ralf (Gast)]

Soo...Heute wollte ich dann mal wieder eine kleine Änderung am Code 
vornehmen, leider ohne Erfolg.


Da ich gerne mittels Eingabe über das Terminal von "e" und "a" (ein, 
aus) den Motor einschalten und ausschalten möchte, habe ich folgendes 
gecodet.

Leider funktioniert es aber nicht.

Anfangs soll der Motor stillstehen. Sobald ein "e" gesendet wird, soll 
der Motor eingeschaltet werden. Sobald (währenddessen) ein "a" geschickt 
wird, soll der Motor ausgeschaltet werden.
Wenn man das Board einschaltet, soll der Motor stillstehen und der 
Controller auf einen Befehl warten
.
Wo liegt mein Problem?

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



volatile int DelayTime = 20;

void initialisiere_UART(void)
{
  UCSRB |= (1<<RXEN) | (1<<RXCIE);                         // Senden/empfangen aktivieren
  UCSRC |= (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1) ;  

  UBRRH = 00;                             // Baudrate einstellen 9600 bei 8 MHz
  UBRRL = 51;
}


ISR (USART_RXC_vect) 
{
  char empfangenesZeichen = UDR;

  switch(empfangenesZeichen)
  {
    case 'a':  motor_ausschalten();
          break;

    case 'e':  motor_einschalten();
          break;
    
    case '1':  DelayTime = 5;
          break;

    case '2':  DelayTime = 10;
          break;

    case '3':  DelayTime = 30;
          break;
  }
}



void motor_einschalten(void)
{
  sei();
  
  while(1)
  {
    PORTA = ~(0b00000001);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000011);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000010);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000110);
    _delay_ms(DelayTime);
    PORTA = ~(0b00000100);
    _delay_ms(DelayTime);
    PORTA = ~(0b00001100);
    _delay_ms(DelayTime);
    PORTA = ~(0b00001000);
    _delay_ms(DelayTime);
    PORTA = ~(0b00001001);
    _delay_ms(DelayTime);
  }
    
}
  

void motor_ausschalten(void)
{
  
  sei();
  PORTA = ~(0x00);

}




void main (void)
{
    DDRA = 0xFF;

  initialisiere_UART();
   
    sei();                  // Interrupt scharf schalten
  

}

[Stefan E. (sternst)]

Wozu sollen die sei() in motor_einschalten und motor_ausschalten gut 
sein?

_delay_ms mit einer Variable als Parameter ist ein no-go. Bitte 
Dokumentation zu der Funktion lesen.

Dein Hauptproblem hier ist aber die fehlende Endlosschleife in main.

[Ralf (Gast)]

das mit der delay_ms und den Variablen habe ich bereits gelesen und 
werde es auch ändern.

Aber was ist das Problem, dass in der main keine Endlosschleife ist?
Ich schalte doch den Interrupt scharf (sei()), sodass ein Interrupt 
kommen kann wann und wie er will, oder sehe ich das falsch?


Was stimmt in meinem Code denn (außer der delay_ms) nicht , dass es 
nicht so funktioniert wie ich es gerne hätte? ;)


Gruß
Ralf

[Stefan E. (sternst)]

Ralf schrieb:
> Aber was ist das Problem, dass in der main keine Endlosschleife ist?
> Ich schalte doch den Interrupt scharf (sei()), sodass ein Interrupt
> kommen kann wann und wie er will, oder sehe ich das falsch?

Aber ohne die Endlosschleife verlässt du main() (beendest also quasi das 
Programm), und der exit-Code der AVR-Libc beinhaltet ein cli(), schaltet 
also deine Interrupts gleich wieder ab.

[Ralf (Gast)]

Und wie ist nun die Lösung zu meinem Problem?

[Stefan E. (sternst)]

Ralf schrieb:
> Und wie ist nun die Lösung zu meinem Problem?

Ach komm, das kannst du auch alleine lösen.
Ich wiederhole das Problem nochmal:
"Du hast keine Endlosschleife in main()."

Zusätzlicher Hinweis: eine Schleife kann auch leer sein.

[Karl H. (kbuchegg)]

@Ralf

>> Und wie ist nun die Lösung zu meinem Problem?
>
> Ach komm, das kannst du auch alleine lösen.
> Ich wiederhole das Problem nochmal:
> "Du hast keine Endlosschleife in main()."
>
> Zusätzlicher Hinweis: eine Schleife kann auch leer sein.

Allerdings will man das eigentlich gar nicht.

> Ach komm, das kannst du auch alleine lösen.

Wenns nur das wäre. Der ganze Programmaufbau ist Mist.
Die Arbeit kommt in die Hauptschleife in main (oder später mal in eine 
Interrupt Funktion die von einem Timer angetrieben wird). Der UART 
Interrupt wertet meinetwegen das empfangene Zeichen aus und stellt ein 
paar globale Variablen (Flags) so, dass in der Hauptschleife das 
Richtige getan wird.

Delays in einer ISR sind ein absolutes NoNo. (ausser vielleicht ganz 
kurze delays im µs Bereich). Und eine Endlosschleife in einer ISR, die 
dann wieder durch einen anderen Interrupt unterbrochen wird ... dafür 
sollte man dir den µC gleich wieder wegnehmen :-)

[Ralf (Gast)]

Dass dieses Projekt wohl eines meiner Ersten mit Mikrocontrollern ist, 
solltet ihr vielleicht wissen.

Dass ihr den Controller in- und auswändig kennt, das glaube ich euch 
gerne und schätze es sehr.
Doch immer vom hohen Ross auf die "Kleinen" abfällig zu kommentieren 
finde ich nicht unbedingt angebracht a la:
> Wenns nur das wäre. Der ganze Programmaufbau ist Mist.

Traurig. Wirklich traurig.

[Karl H. (kbuchegg)]

Ralf schrieb:
> Dass dieses Projekt wohl eines meiner Ersten mit Mikrocontrollern ist,
> solltet ihr vielleicht wissen.

Ist ok. Jeder muss mal anfangen

> Dass ihr den Controller in- und auswändig kennt, das glaube ich euch
> gerne und schätze es sehr.

Das hat mit 'dem Controller' an sich nichts zu tun.

> Doch immer vom hohen Ross auf die "Kleinen" abfällig zu kommentieren
> finde ich nicht unbedingt angebracht a la:
>> Wenns nur das wäre. Der ganze Programmaufbau ist Mist.
>
> Traurig. Wirklich traurig.

Aber die Wahrheit :-)
Und ob es dir gefällt oder nicht, deinem µC ist es völlig wurscht ob es 
dein erster Kontakt mit ihm ist oder nicht. Der schlägt erbarmungslos 
zu. In deinem Fall wird nach dem (geschätzten) 300sten hintereinander 
empfangenen Zeichen 'e' Schluss mit lustig sein und dein µC wird 
erbarmungslos abstürzen oder eventuell noch schlimmere Sachen machen.

Also.
Der Grundaufbau 'jedes' µC-Programmes sieht so aus

int main()
{
   Hardware initialisieren und einstellen

   eventuell sei(), wenn mit Interrupts gearbeitet wird

   while( 1 ) {
 
      Hier drinn wird die eigentliche Arbeit gemacht

   }
}

Wenn es Interrupts gibt, dann machen deren Funktionen relativ wenig 
Arbeit selber. Wenn sie auf den Rest des Programmes einen Einfluss 
haben, dann maximal so, dass sie in globalen Variablen Kennwerte 
hinterlassen, die den Programmteil in main() der innerhalb der 
Hauptschleife steht, dazu veranlassen das Richtige zu tun.

volatile uint8_t Irgendwas;

ISR( ... )
{
  ...
  Irgendwas = ...
}

int main()
{
   Hardware initialisieren und einstellen

   sei();

   while( 1 ) {
 
      Hier drinn wird die eigentliche Arbeit gemacht

      if( Irgendwas == ... ) {
        mach die spezielle Arbeit, die von der ISR angefordert wurde
      }

   }
}

Das ist dein grundsätzlicher Programmaufbau. Es gibt auch Ausnahmen und 
es gibt auch Variationen dazu. Aber die nächsten 20 bis 30 Projekte 
wirst du praktisch immer gut fahren, wenn du dich an diesen 
Programmaufbau hältst.


AVR-GCC-Tutorial

[Karl H. (kbuchegg)]

uint8_t MotorStep[] = { 0b00000001, 0b00000011, 0b00000010, 0b00000110,
                        0b00000100, 0b00001100, 0b00001000, 0b00001001 };
uint8_t curStep;

volatile uint8_t DelayTime;
volatile uint8_t MotorRunning;

void delay( uint8_t ms )
{
  uint8_t i;
  for( i = 0; i < ms; ++i )
    _delay_ms( 1 );
}

void initialisiere_UART(void)
{
  UCSRB |= (1<<RXEN);                         // Senden/empfangen aktivieren
  UCSRC |= (1<<URSEL)|(1<<UCSZ0)|(1<<UCSZ1);  

  UBRRH = 00;                             // Baudrate einstellen 9600 bei 8 MHz
  UBRRL = 51;                             // diese Konstanten besser vom Compiler
                                          // berechnen lassen !
}

ISR (USART_RXC_vect) 
{
  char empfangenesZeichen = UDR;

  switch(empfangenesZeichen)
  {
    case 'a':  MotorRunning = 0;
          break;

    case 'e':  MotorRunning = 1;
          break;
    
    case '1':  DelayTime = 5;
          break;

    case '2':  DelayTime = 10;
          break;

    case '3':  DelayTime = 30;
          break;
  }
}

void main (void)
{
  DDRA = 0xFF;

  MotorRunning = 0;
  DelayTime = 30;
  curStep = 0;

  initialisiere_UART();
   
  sei();                  // Interrupt scharf schalten

  while( 1 ) {
    if( MotorRunning ) {
      PORTA = ~( MotorStep[curStep] );
      curStep++;
      if( curStep == 8 )
        curStep = 0;
      delay( DelayTime );
    }
  } 
}

[Steffen H. (avrsteffen)]

Hallo Karl Heinz

Das hast du super erklärt! Und sogar gleich eine Lösung angeboten.. Da 
hat es der Ralf aber einfach. Ob er damit jetzt noch einen Lerneffekt 
hat?

Hoffen wir es mal.

Steffen

[Steffen H. (avrsteffen)]

Ach ja, wie würde es denn aussehen wenn "MotorRunning" nicht gleich ein 
ganzes Byte einnehmen würde sondern wirklich nur ein Flag (Bit) in einem 
Byte? Mal angenommen das Byte sollte "Control" heißen und das Flag 
"MotorRunning" ?

Lerne nämlich auch gerade "C"

Gruß Steffen

[Karl H. (kbuchegg)]

Steffen H. schrieb:
> Ach ja, wie würde es denn aussehen wenn "MotorRunning" nicht gleich ein
> ganzes Byte einnehmen würde sondern wirklich nur ein Flag (Bit) in einem
> Byte?

Grundsätzlich ist die kleinste Einheit, die du in C ansprechen kannst 
immer ein komplettes Byte. Willst du auf einzelne Bits runter, dann 
musst du mittels | bzw & die entsprechende Bitposition ausmaskieren.

>  Mal angenommen das Byte sollte "Control" heißen und das Flag
> "MotorRunning" ?

OK. Für die Bitposition benutze ich ein #define, damit ich mir keine 
Zahlen merken muss :-) Bin ja auch schon älter und ausserdem wird so der 
Code schon mal einen ersten Schritt in Richtung selbstdokumentierend 
nehmen.

#define MOTOR_RUNNING 0   // Bit 0 in Control
volatile uint8_t  Control;

ISR( ... )
{

   ....

   switch 'a':
     Control &= ~( 1 << MOTOR_RUNNING );    // Bit löschen
     break;

   switch 'b'
     Control |= ( 1 << MOTOR_RUNNING );     // Bit setzen
     break;

   ....
}


....

int main()
{
  ....
  while( 1 ) {

    if( Control & ( 1 << MOTOR_RUNNING ) ) {
      ...
    }
  }
}

Ganz normale Bit-Setz, Bit-Lösch und Bit-Abfrage Operationen, wie sie in 
jedem Programm zu Hauf vorkommen. Nur war bei dir wahrscheinlich Bit 
setzen bzw. Bit löschen meistens auf einen Port bezogen um damit einen 
Portpin zu schalten. Aber die Syntax ist ja nicht auf Ports beschränkt. 
Die Operationen setzen bzw. löschen bzw. fragen ein Bit ab. Wo das 
zugehörige Byte herkommt interessiert ja die Operationen nicht.

[Steffen H. (avrsteffen)]

Danke Karl Heinz.
Mir ist nämlich aufgefallen das in C schnell mal ein ganzes Byte für nur 
ein Bit herhalten muss. Ich finde die Lösung über nur einem Bit besser, 
da man nicht so viel Resourcen verschwendet, natürlich nur wenn noch ein 
paar Flags mehr in das Byte "Control" kommen. Also geht es in C genauso 
einfach wie in asm.

Steffen

[Karl H. (kbuchegg)]

Das ist die Version, die du als C-Neuling machen wirst.

Wenn deine C-Kentnisse umfangreicher sind (werden) (Lehrbücher lesen und 
studieren!), dann wirst du das anders schreiben und dem Compiler mehr 
Arbeit aufhalsen :-)

struct control_ {
  uint8_t motorRunning : 1;
  uint8_t motorDirection : 1;
}

volatile struct control_ Control;

ISR( ... )
{

   ....

   switch 'a':
     Control.motorRunning = 1;
     break;

   switch 'e'_
     Control.motorRunning = 0;
     break;

   switch '+':
     Control.motorDirection = 0;
     break;

   switch '-':
     Control.motorDirection = 1;

   ....
}

....

// zur Vereinfachung der Schreibweise wieder ein paar Makros
#define MOTOR_RUNNING    Control.motorRunnnig
#define MOTOR_DIRECTION  Control.motorDirection

int main()
{
  ....
  while( 1 ) {

    if( MOTOR_RUNNING ) {
      if( MOTOR_DIRECTION ) {
        ...
      }
      else {
        ...
      }
    }
  }
}

[Karl H. (kbuchegg)]

Steffen H. schrieb:
> Danke Karl Heinz.
> Mir ist nämlich aufgefallen das in C schnell mal ein ganzes Byte für nur
> ein Bit herhalten muss. Ich finde die Lösung über nur einem Bit besser,
> da man nicht so viel Resourcen verschwendet, natürlich nur wenn noch ein
> paar Flags mehr in das Byte "Control" kommen. Also geht es in C genauso
> einfach wie in asm.

Kommt drauf an.
Wenn du die Bytes im SRAM hast, dann ist es kein Problem dafür jeweils 
ein komplettes Byte zu benutzen. Wenn du den Platz nicht hast, dann muss 
man wohl oder übel zusammenlegen.

die Überlegung
* du bekommst für nicht benutztes SRAM kein Geld zurück
* Bits auszumaskieren bringt zwar ein paar Bytes SRAM, kostet
  aber immer etwas Programmcode. Umsonst ist nun mal nur der Tod

[Steffen H. (avrsteffen)]

Karl Heinz Buchegger schrieb:
>* du bekommst für nicht benutztes SRAM kein Geld zurück
Da hast du Recht (-:

Aber diese Sache mit einem Struct anzugehen finde ich ja toll:

struct control_ {
  uint8_t motorRunning : 1;
  uint8_t motorDirection : 1;
}

Das sieht dann auch sehr übersichtlich aus.

   switch 'a':
     Control.motorRunning = 1;
     break;

   switch 'e'_
     Control.motorRunning = 0;
     break;

   switch '+':
     Control.motorDirection = 0;
     break;

   switch '-':
     Control.motorDirection = 1;

 -> Und wieder was dazu gelernt..

Dank an dieses tolle Forum! Hier lernt mann mehr als in manch einem 
Studium!

Weiter so..

[2ter Gast (Gast)]

switch 'a':
     Control.motorRunning = 1;
     break;

   switch 'e'_
     Control.motorRunning = 0;
     break;

   switch '+':
     Control.motorDirection = 0;
     break;

   switch '-':
     Control.motorDirection = 1;

wie hast Du das mit den switch anweisungen hinbekommen? :-)

[Ralf (Gast)]

Hallo Karl-Heinz!


Vielen Dank für deinen umfangreichen Lösungsansatz, finde ich wiederum 
super, dass du mir so geholfen hast.

Ich werde den Programmablauf mal so in etwas übernehmen und testen.

Ob es für mein Referat allerdings nicht etwas zu umfangreich ist (Leute, 
die noch NIE etwas von einem Mikrocontroller gehört haben), wage ich zu 
bezweifeln :-/
Denn der Code selbst würde wohl schon die Zeit des Referats (10-12 
Minuten) sprengen.



Gruß
Ralf