Problem bei UART einlesen

[A. R. (and)]

Hallo,

ich empfange aktuell über die serielle Schnittstelle Werte.
Wenn ich das Programm so schreibe, das der Programmdurchlauf blockiert 
wird vom Lesebefehl, d.h. ich warte bis neue Daten empfangen wurde, dann 
funktioniert alles.

Verwende ich aber jetzt den Befehl das ich nur die Daten einlese wenn 
neue Daten vorhanden sind:

if ( (UCSR0A & (1<<RXC0)) ){
   ......

Empfange ich die Werte nicht mehr korrekt. Woran kann das liegen?

[Georg G. (df2au)]

Syntaxfehler in Zeile 42 von main()

[Cyblord -. (cyblord)]

A. R. schrieb:
> Hallo,
>
> ich empfange aktuell über die serielle Schnittstelle Werte.
> Wenn ich das Programm so schreibe, das der Programmdurchlauf blockiert
> wird vom Lesebefehl,
Zeig mal DEN Code. Inwiefern unterscheidet sich das blockieren vom 
aktuellen Ansatz? Die Abfrage sollte gleich bleiben. Lediglich eine 
while Schleife sollte hinzugekommen sein.

Und poste mal den ganzen Code.

[spess53 (Gast)]

Hi

>Verwende ich aber jetzt den Befehl das ich nur die Daten einlese wenn
>neue Daten vorhanden sind

Warum nicht einfach den RX Complete-Interrupt benutzen?

MfG Spess

[A. R. (and)]

Hier das Programm in kurzer zusammenfassung:

Das funktioniert:

int main(void){

  uart_init();

while(1){
....
  a = uart_empfange();  //Low-byte
  b = uart_empfange();  //High-byte
  c = a+ (b<<8);
  ... 
  itoa(c,buffer,10);
  lcd_string(buffer);
  ....
 }
}

Das funktioniert nicht:

int main(void){

  uart_init();

while(1){
....
if ( (UCSR0A & (1<<RXC0)) ){
  a = uart_empfange();  //Low-byte
  b = uart_empfange();  //High-byte
  c = a+ (b<<8);
   
  ... 
  itoa(c,buffer,10);
  lcd_string(buffer);
  ....
  }
 }
}

[A. R. (and)]

Habe mit Interrupt noch nie gearbeitet, da ich noch nicht so erfahren 
bin.
Hast du ein Beispiel, bzw. eine gute Anleitung dafür?

[spess53 (Gast)]

HI

>Hast du ein Beispiel, bzw. eine gute Anleitung dafür?

Ich benutze Assembler. Ein Beispiel in C gibt es hier:

https://www.mikrocontroller.net/articles/AVR-GCC-Tutorial/Der_UART#Empfangen_.28RX.29

MfG Spess

[A. R. (and)]

Ok danke schonmal für eure Hilfen.
Werde mich mit dem Interrupt mal beschäftigen.

Jetzt wäre aber zum Verständnis meine Frage:
Warum bekomm ich die Daten denn falsch rein wenn ich diese Abfrage mit 
drin habe? Ist das ein Timing Problem? Und warum sollte das beim 
Interrupt anders sein?

[Flip B. (frickelfreak)]

A. R. schrieb:
> a = uart_empfange();  //Low-byte
>   b = uart_empfange();

weil nur dann daten gelesen werden, wenn sie zufällig im richtigen 
moment eintreffen. ansonsten tut uart_empfange nichts. du musst also 
solange  uart_empfange anspringen, bis deine 2 bytes empfangen wurden. 
dann am ende die berechnung ausführen.

[Georg (Gast)]

Flip B. schrieb:
> uart_empfange anspringen, bis deine 2 bytes empfangen wurden.

Die können aber genausogut in falscher Reihenfolge gelesen werden, b vor 
a. Da fehlt jede Synchronisation. Beim blocckierenden Lesen auch, aber 
da fällt das weniger auf, wenn der Sender nach dem Empfänger startet.

Georg

[Georg G. (df2au)]

Wie sieht uart_empfange() aus?

[Georg (Gast)]

A. R. schrieb:
> if ( (UCSR0A & (1<<RXC0)) ){
>   a = uart_empfange();  //Low-byte
>   b = uart_empfange();  //High-byte

Die if-Bedingung heisst nur, dass 1 Byte empfangen wurde - nicht beide.

Georg

[A. R. (and)]

Wenn ich die IF bedinungen nutze,
dann springt er rein wartet aber auf neue Werte im Puffer, wenn ich 
erneut werte sende, also seriell an den µC, dann liest er den letzten 
Wert ein und der Rest ist irgenndetwas komisches. Und danach springt er 
immer in die IF rein weil immer irgendwas im Puffer steht.

uint8_t uart_empfange (void){
  while (!(UCSR0A & (1<<RXC0)));
  return UDR0;
}

[Eric B. (beric)]

so was?

state = EMPFANGE_A;
while(1)
{
  // check UART
  if (UCSR0A & (1<<RXC0))
  {
    if (state == EMPFANGE_A)
    {
      a = UDR0;
      state = EMPFANGE_B;
    } else if (state == EMPFANGE_B) {
      b = UDR0;

      // Tue was mit a und b

      state = EMPFANGE_A;
    }  else {
      error(WRONG_STATE);
      state = EMPFANGE_A;
    }
  }

  //
  // do other stuff here
  //
}

[Georg (Gast)]

Eric B. schrieb:
> a = UDR0;
>       state = EMPFANGE_B;

Da bist du auf der richtigen Spur, aber woher weisst du was a und was b 
ist?

Ich sehe da 2 Möglichkeiten:

1. Das MSB entscheidet, 0=a, 1=b. Aber dann bleiben bloss 14 Bit an 
Daten.

2. Nach a und b kommt eine deutlich längere Pause als dazwischen. Aber 
dann musst du diese Zeit messen und auswerten, du brauchst also 
mindestens ein Timeout, das zwischen a,b und a,b anspricht.

Georg

[A. R. (and)]

Also di funktion das ich zweimal den uart lese und anschließend 
High-Low-Byte zusammen setzte funktioniert ja an sich.

Was mich gerade etwas irretiert oder noch unklar ist, warum funktioniert 
das uart_empfange(); nicht mehr wenn ich es nur dann mache, wenn neue 
Daten im Eingangspuffer steht?

Georg schrieb ja, das die If-Anweisung ja nur aussgat, das 1-byte 
vorhanden ist. Und ich frage erst dann ab. D.h. ich lese ja wenn ich 
zweimal Byte ein, wenn aber jetzt nur noch ein Byte vorhanden ist wartet 
das Program ja. und beim nächsten senden von zwei Byte erhält läuft das 
Programm weiter und springt im nächsten durchlauf direkt wieder in die 
IF-Anweisung.

Bedeuted doch eigentlich, das durch die IF-Anweisung mir vermutlich das 
erste Byte verloren geht oder?

[Eric B. (beric)]

Georg schrieb:
> Da bist du auf der richtigen Spur, aber woher weisst du was a und was b
> ist?

Ist mir schon klar. Das Problem bin ich auch gar nicht angegangen.

A. R. schrieb:
> Was mich gerade etwas irretiert oder noch unklar ist, warum funktioniert
> das uart_empfange(); nicht mehr wenn ich es nur dann mache, wenn neue
> Daten im Eingangspuffer steht?

Das können wir nur beantworten wenn du den Code von /uart_empfange/() 
zeigst.

[A. R. (and)]

Hatte ich oben schon gepostet:

uint8_t uart_empfange (void){
  while (!(UCSR0A & (1<<RXC0)));
  return UDR0;
}