UART RXC Bit wird nach empfangenem Zeichen nicht gelöscht

[Philipp (Gast)]

Hallo zusammen,

zur Zeit versuche ich erfolglos, ein kleines C-Programm auf dem ATMEGA 
328P zum laufen zu bringen. Dieses soll in einer Schleife nacheinander 
die Werte von 5 Variablen über den UART ausgeben. Anschließend soll es 
in den "Empfangsmodus" gehen.
Hier soll zuerst der Name der Variable und anschließend deren Wert 
empfangen werden. Danach ist diese Funktion beendet, und es soll wieder 
von vorne begonnen werden (mit der Ausgabe der 5 Variablen).

Am Serial Monitor empfange ich plausible Zeichenfolgen. Wenn ich nun 
aber einen Variablenname sende (z.B. a), wartet das Programm nicht, bis 
ich nachfolgend den Variablenwert sende, sondern springt gleich wieder 
aus der Funktion heraus in die Sendeschleife.

Um ein Zeichen zu empfangen, warte ich in einer While-Schleife auf das 
Setzen RXC0 Bits. Scheinbar wird dieses jedoch nicht mehr gelöscht, 
nachdem ich das UDR0 Register das erste Mal auslese (dies muss ja 
gelesen werden, um in den richtigen "Switch-Case" Zweig zu springen). 
Dadurch entsteht wohl das unerwartete Verhalten, im Case Zweig wartet er 
dann nicht mehr auf das RXC0 bit, da dieses ja scheinbar bereits gesetzt 
ist.

Hier ist mein Code:

#define BAUD 4800UL      // Baudrate
#define F_CPU  16000000L

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <util/setbaud.h>

// Variablendefinition 
uint8_t a = '1';//
uint8_t b = '2';
uint8_t c = '3';
uint8_t d = '4';
uint8_t e = '5';


void SendeByte(uint8_t Byte){
  while (!(UCSR0A & (1<<UDRE0)))  // warten bis Senden moeglich                
  {
  }
  UDR0 = Byte;                    // schreibt das Zeichen x auf die Schnittstelle
}

void EmpfangeVariable(void){
    while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
    }
    switch(UDR0){          // Variablenname zuordnen
        case 'a':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }  
              a=UDR0;
              SendeByte('a');  
              SendeByte(a);  
              break;
        case 'b':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              b=UDR0;
              SendeByte('b');  
              SendeByte(b);  
              break;
        case 'c':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              c=UDR0;
              SendeByte('c');
              SendeByte(c);  
              break;
        case 'd':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              d=UDR0;
              SendeByte('d');
              SendeByte(d);  
              break;
        case 'e':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              e=UDR0;
              SendeByte('e');
              SendeByte(e);  
              break;
          }
                                  
  }

// Hauptschleife
int main(void)
{
  // UART Initialisieren  
  UBRR0H = UBRRH_VALUE;
  UBRR0L = UBRRL_VALUE;
  UCSR0C = (1 << UCSZ01)|(1 << UCSZ00); // Asynchron Modus 8N1
  
  while(1)
    {
    // Variablen der Reihe nach ausgeben
    UCSR0B &= ~(1<<RXEN0);    // Receiver Deaktivieren
    UCSR0B |= (1<<TXEN0);    // Transmitter Aktivieren
    SendeByte('*');        // Startzeichen
    SendeByte(a);
    SendeByte(b);
    SendeByte(c);
    SendeByte(d);
    SendeByte(e);
    SendeByte('#');      // Endzeichen
    
    // Variable empfangen
    UCSR0B &= ~(1<<TXEN0);    // Transmitter Deaktivieren
    UCSR0B |= (1<<RXEN0);    // Receiver Aktiviern
    EmpfangeVariable();      
  } 
    
}

Wäre super nett, wenn einer von euch eine Idee dazu hätte.

Danke schonmal für die Mühe,

Philipp

[STK500-Besitzer (Gast)]

Das UDR enthält nach dem ersten Lesen schon das zweite Zeichen. Du muust 
es also in einer Variablen zwischenspeichern.

[STK500-Besitzer (Gast)]

Vergiss, was ich geschrieben habe.
So, wie du es machst, ist es sehr ungewöhnlich.

[Karl H. (kbuchegg)]

Philipp schrieb:

>     switch(UDR0){          // Variablenname zuordnen

der switch hier aus dem Register heraus ist keine gute Idee.
Du weisst nicht, was der COmpiler aus dem switch macht. Wir wissen aber 
aus dem Datenblatt, dass du auf UDR0 nur ein einziges mal zugreifen 
darfst.

Daher: mach dir eine Zwischenvariable, in der du dir erst mal das Byte 
aus der UART holst und erst damit arbeitest du dann weiter.

Noch besser:
Schreib dir eine Funktion, die auf 1 Byte wartet und es zurückliefert. 
Denn deine ständige Codewiederholung dieser simplen Funktionalität geht 
sowieso auf keine Kuhhaut.

uint8_t LeseByte()
{
  while (!(UCSR0A & (1<<RXC0))) {   // warten bis Zeichen verfuegbar
  }

  return UDR0;
}

und diese Funktion rufst du auf, wenn du in weiterer Folge auf 1 Zeichen 
warten willst.

void EmpfangeVariable(void){

    uint8_t c = LeseByte();


    switch( c ) {          // Variablenname zuordnen
        case 'a':
              a = LeseByte();
              SendeByte('a');  
              SendeByte(a);  
              break;

...

Hast du das Zeichen, dann ist es zb auch eine gute Möglichkeit sich zu 
Debug-Zwecken dieses empfangene Byte über die UART wieder zurückschicken 
zu lassen, um zu kontrollieren, ob der µC auch richtig verstanden hat.


>     // Variable empfangen
>     UCSR0B &= ~(1<<TXEN0);    // Transmitter Deaktivieren
>     UCSR0B |= (1<<RXEN0);    // Receiver Aktiviern

Eher unüblich.
Wenn der Transmitter eingeschaltet ist, dann bleibt der das auch. Wozu 
soll das gut sein, wenn du dauernd umschaltest.
Solange du nichts sendest, geht auch nichts aus dem AVR raus. und 
umgekehrt.

Ständiges Umkonfigurieren ist meistens (nicht immer) eher ein Zeichen 
für schlechtes Programmdesign.

[Philipp (Gast)]

Kann dir nicht ganz folgen. Ich sende doch von der Seriellen Konsole am 
PC nur ein Zeichen, wie kann das UDR da schon ein zweites Zeichen 
enthalten?

[Philipp (Gast)]

Alles klar, werde es mal mit dem Zwischenspeichern und extra Funktion 
probieren.

[Karl H. (kbuchegg)]

Ausserdem ist es in so einem Fall eine extrem gute Idee, wenn du dem 
switch einen default Zweig verpasst, in dem du zb mit einer weiteren 
Ausgabe zum PC signalisiern kannst, dass da was schief gelaufen ist.

void EmpfangeVariable(void){

    uint8_t c = LeseByte();


    switch( c ) {          // Variablenname zuordnen
        case 'a':
              a = LeseByte();
              SendeByte('a');  
              SendeByte(a);  
              break;

....
      default:
              SendeByte( '!' );
              SendeByte( c );
              SendeByte( '!' );
    }
}

Du brauchst zb nur irrtümlich auf deiner Tastatur den Shift-Lock 
eingeschaltet haben und schon überträgst du kein 'a' sondern ein 'A'. 
Was natürlich nicht dasselbe ist.
Wenn du einen menschlichen Benutzer am Terminal sitzen hast, musst du 
IMMER damit rechnen, dass sich der vertippt oder einen sonstigen Fehler 
macht und enstrpechend reagieren bzw. eine entsprechende Rückmeldung 
liefern.

[Karl H. (kbuchegg)]

Karl H. schrieb:

>>     // Variable empfangen
>>     UCSR0B &= ~(1<<TXEN0);    // Transmitter Deaktivieren
>>     UCSR0B |= (1<<RXEN0);    // Receiver Aktiviern
>
> Eher unüblich.
> Wenn der Transmitter eingeschaltet ist, dann bleibt der das auch. Wozu
> soll das gut sein, wenn du dauernd umschaltest.
> Solange du nichts sendest, geht auch nichts aus dem AVR raus. und
> umgekehrt.

Ganz abgesehen davon musst du mir jetzt mal erklären, wie eigentlich die 
Funktion EmpfangeVariable() etwas ausgeben soll, wenn der Transmitter 
abgeschaltet ist.

    // Variable empfangen
    UCSR0B &= ~(1<<TXEN0);    // Transmitter Deaktivieren
    UCSR0B |= (1<<RXEN0);    // Receiver Aktiviern
    EmpfangeVariable();

die wird sich da eher schwer tun.

-> Transmitter einschalten, Receiver einschalten gehören an den 
Programmanfng zu den Initialisierungen und danach lässt du die UART 
diesbezüglich in Ruhe.
Anstatt da zu künsteln schreibst du dir lieber eine Funktion, mit der du 
Strings ausgeben kannst. Von der hast du mehr, denn die brauchst du alle 
Nase lang.

[Philipp (Gast)]

So, habe mal nachgebessert, sieht nun so aus:

#define USERINTERFACE DEBUG
#define BAUD 4800UL      // Baudrate
#define F_CPU  16000000L

#include <avr/io.h>
#include <avr/interrupt.h>
#include <stdlib.h>
#include <util/setbaud.h>



// Variablendefinition 

uint8_t a = '1';//
uint8_t b = '2';
uint8_t c = '3';
uint8_t d = '4';
uint8_t e = '5';
uint8_t UartBuffer;


void SendeByte(uint8_t Byte){
  while (!(UCSR0A & (1<<UDRE0)))  // warten bis Senden moeglich                
  {
  }
  UDR0 = Byte;                    // schreibt das Zeichen x auf die Schnittstelle
}

uint8_t LeseByte()
{
  while (!(UCSR0A & (1<<RXC0))) {   // warten bis Zeichen verfuegbar
  }

  return UDR0;
}

void EmpfangeVariable(void){
    UartBuffer=LeseByte();
    switch(UartBuffer){          // Variablenname zuordnen
        case 'a':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }  
              a=UDR0;
              SendeByte('a');  
              SendeByte(a);  
              break;
        case 'b':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              b=UDR0;
              SendeByte('b');  
              SendeByte(b);  
              break;
        case 'c':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              c=UDR0;
              SendeByte('c');
              SendeByte(c);  
              break;
        case 'd':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              d=UDR0;
              SendeByte('d');
              SendeByte(d);  
              break;
        case 'e':  while (!(UCSR0A & (1<<RXC0))){   // warten bis Zeichen verfuegbar
              }
              e=UDR0;
              SendeByte('e');
              SendeByte(e);  
              break;
        default:  SendeByte('!');
              SendeByte(UartBuffer);
              SendeByte('!');
        }
                                  
  }

// Hauptschleife
int main(void)
{
  // UART Initialisieren  
  UBRR0H = UBRRH_VALUE;
  UBRR0L = UBRRL_VALUE;
  UCSR0C = (1 << UCSZ01)|(1 << UCSZ00); // Asynchron Modus 8N1
  UCSR0B |= (1<<TXEN0)|(1<<RXEN0);    // Transmitter + Receiver  Aktivieren
  
  while(1)
    {
    // Variablen der Reihe nach ausgeben
    SendeByte('*');        // Startzeichen
    SendeByte(a);
    SendeByte(b);
    SendeByte(c);
    SendeByte(d);
    SendeByte(e);
    SendeByte('#');      // Endzeichen
    
    // Variable empfangen
    EmpfangeVariable();      
  } 
}

Funktioniert leider immer noch nicht. Das Programm wartet nachdem ich 
vom PC ein Zeichen gesendet habe einfach nicht, sondern gibt direkt 
irgendwas aus.
Habe mal ein W gesendet, dann sollte ja in den Default Zweig gesprungen 
werden. Darauf erhalte ich folgende Rückmeldung:
!w!*12345#!(Hier ist wohl ein Zeichen für Zeilenumbruch??)
!*12345#

Verstehe nicht, warum er das ganze zweimal Ausführt. Sieht echt so aus 
als ob das TXC Bit für zwei Durchläufte aktiv bleibt, warum auch 
immer???

[Karl H. (kbuchegg)]

Philipp schrieb:

> Habe mal ein W gesendet,


wie hast du das gemacht?

Auf die Taste 'w' gedrückt und danach auf die Taste 'Return'?

Auch 'Return' ist ein Zeichen, dass übertragen wird.

[Karl H. (kbuchegg)]

Philipp schrieb:
> So, habe mal nachgebessert,

aber leider hast du nur die Hälfte gemacht.

Wenn du eine Funktion LeseByte hast, dann wird die natürlich an ALLEN 
Stellen benutzt, an der du auf 1 Byte von der UART wartest.
Auch zb hier

         case 'a':  while (!(UCSR0A & (1<<RXC0))){   // warten bis  Zeichen verfuegbar
               }
               a=UDR0;
...

auch hier

         case 'b':  while (!(UCSR0A & (1<<RXC0))){   // warten bis  Zeichen verfuegbar
               }
               b=UDR0;
....

und all den anderen Stellen!
Die Funktion wurde ja nicht zur Volksbelustigung geschrieben sondern 
dazu, ein für alle mal den Themenkreis "warte auf 1 Zeichen von der 
UART" an einer einzigen Stelle abzuhandeln.

[Philipp (Gast)]

Habe schon beides getestet, sowohl mit der Return Taste als auch mit 
Mausklick auf Senden. Beides Mal das gleiche Ergebnis.
Verwende übrigens die serielle Konsole von der Arduino IDE, falle die 
Info hilft.

[Karl H. (kbuchegg)]

Philipp schrieb:
> Habe schon beides getestet, sowohl mit der Return Taste als auch mit
> Mausklick auf Senden. Beides Mal das gleiche Ergebnis.

Ja.
Das Ergebnis ist, dass dein Terminalprogramm 2 Zeichen wegschickt, von 
denen eines ein '\n' (also ein Zeilenumbruch oder auch "Return" genannt) 
ist. Die Rückmeldung vom AVR beweist das eindeutig.

Entweder machst du deinem Terminalprogramm klar, dass es das zu 
unterlassen hat
oder du benutzt ein anderes Terminalprogramm welches das nicht macht
oder du kümmerst dich im AVR Programm darum, dass derartige \n 
ausgefiltert werden und dir nicht die Programmlogik durcheinander 
bringen.

[Philipp (Gast)]

Sorry, das ging wohl etwas schnell, natürlich gehört es auch an den 
anderen Stellen geändert.
Mit den Änderungen und anderem Terminal Programm nochmal versucht,jetzt 
funktioniert es tatsächlich.

Vielen Vielen Dank für die schnelle Hilfe!

[Karl H. (kbuchegg)]

Philipp schrieb:
> Sorry, das ging wohl etwas schnell, natürlich gehört es auch an den
> anderen Stellen geändert.
> Mit den Änderungen und anderem Terminal Programm nochmal versucht,jetzt
> funktioniert es tatsächlich.

Da kannst du mal sehen, wie hilfreich es sein kann, wenn einem sein 
Programm bei der Fehlerdiagnose mittels Ausgaben weiterhilft :-)
Vorher tappte man im Dunkeln, ein paar Ausgaben später ist alles klar.

Unterschätze das daher nicht! Ein paar Ausgaben zwischendurch können ein 
mächtiges Werkzeug sein.
Wenn alles fertig ist, kann man sie immer noch wieder entfernen.