Probleme beim Empfang über UART: Abhilfe FIFO?

Die while - schleifen sind wie mein Vorgänger erwähnt hat, tödlich.

Du solltest in der Hauptschleife einen Zustandsautomaten einbauen, der 
anstatt auf While -(TUE GARNICHTS BIS DIE SCHNITTSTELLE FERTIG IST) eine 
If-Abfrage einbauen, die nur bei fertiger Schnittstelle ein Datenbyte 
nachlegt.

Wäre das Senden oder Empfangen noch nicht fertig, ist der Prozessor in 
der Lage an anderer Stelle im Programm weiter zu machen. Phasenprobleme 
werden so vermieden.




ANregung OHNE ANSPRUCH AUF COMPILIERFÄHIGKEIT !!!

define MAX_STING 70

uint8_t *SpeicherString[] = "IRGEND_ETWAS_VON_IRGENDWOHER\0"

uint8_t  SpeicherStringZaehler=0

mode = 0;

// Hier noch die Initialisierungen

Main
{
 while(1)
 {



  switch(mode)
  {
     case 0:
        if(SpeicherStringZaehler++ < MAX_STRING)
        {
          /* IF erspart das Sinnlos Warten ...*/
          if ((UCSR0A & (1 << UDRE0))
      UDR0 = *SpeicherStringe++;
        }
        mode ++;
        break;
     case 1:

        Empfangen irgendwie analog wie oben.

        mode ++;
        break;
     default:
        mode = 0;
         // tue noch irgendetwas anderres sinnvolles und warte nicht.

  }
 }
}
Ich habe mir von je her angewöhnt, so ein kooperatives Scheduling zu 
integrieren. Die Statemachines machen zwar die Funktion des Codes 
unübersichtlich. Aber es lohnt sich. CAN - Grafik-Display und Modem 
betreiben etc. , lassen sich so quasi parallel betreiben.

Und man kann so dem AVRs mit nur 16MHz richtig etwas abverlangen.

Viel erfolg.

Hallo zusammen,
vielen Dank für die schnellen Antworten. Ich habe es nun mal mit einer 
ISR probiert und es klappt. Zunächst einmal passen die so, oder 
muss/sollte ich da etwas anders machen? Ich möchte das Programm so 
aufbauen, dass beim Auftreten eines bestimmten 
Zustandes/Zeichenkombination ein Befehl verendet wird.

Zudem hätte ich noch folgende Frage:

Ich habe zwei UARTS mit UART0 will ich die Daten kontrollieren. Mit dem 
Zweiten will ich beim Auftreten einer bestimmten Situation, eine SMS 
versenden.

Die GSM-Initialisierung habe ich ebenfalls mittels Polling realisiert. 
Diese kann ich ja nun einfach durch ISR´s ersetzen. Muss ich dabei auf 
etwas spezielles achten? Ich weiß nicht inwieweit die dann zueinander im 
Konflikt stehen.

Bin für jeden Hinweis und Tipp dankbar...
VG

Hallo, ich bins nochmal.

Das Empfangen und Versenden der Daten klappt auf jeden Fall besser, wie 
mit der while-Schleife. Ich empfange und versende meine 70 Zeichen lange 
Strings nun nacheinander. Allerdings wird der letzte String der nur 14 
Zeichen lang ist nicht versendet. Am obigen Programm hab ich nichts 
verändert. VG

Hallo KH, vielen dank für die Antwort!
Wenn ich Funktion get_log_data um

void get_log_data(void)
{
  if( log_daten == 1 && uart_tx_flag == 1)
  {
    send_string(stringbuffer);
    log_daten = 0;
  }
}

uart_tx-flag == 1 erweitere, erhalte ich das gesamte Protokoll. Ich muss 
also noch festlegen: Wenn letzte Übertragung beendet, dann können neue 
Daten gesendet werden?!

Muss ich also immer, wenn ich ein Befehl senden will, mit uart_tx_flag 
== 1 die Sendebereitschaft prüfen? Beim Polling habe ich meine 
Sendefunktion,


void send_string(char *string)
{
  while(*string)
  {
    send_char(*string);
    string++;
  }
  send_char('\r');
}


mit der ich einfach die Befehle innerhalb eines Programms versenden 
kann.

if(log_data == 1)
send_string("Log Daten vorhanden");

Bspw. wenn ich nach dem Erreichen eines Counters == 12 einen Befehl 
versenden will, oder wenn ich auf die Antwort des GSM Moduls reagieren 
will. Muss ich das dann immer mittels Flags realisieren? Sprich Flag 
setzen und schauen ob uart_tx_flag auch gesetzt, wenn ja, Senden?

if(counter == 12)
counter_flag = 1;
.
.
.

if(strcmp(stringbuffer, "OK") == 0)
gsm_answer_flag = 1;
.
.
.

if(counter_flag == 1 && uart_tx_flag == 1)
{
    send_string("Counter = 12");
    counter flag = 0;
}

if(gsm_answer_flag == 1 && uart_tx_flag == 1)
{
    send_string("12345");
    gsm_answer_flag = 0;
}


Ich kapiere das immer noch nicht so richtig.
VG

Hallo,
zunächst einmal vielen Dank für eure Antworten.
Ich habe mich mal anhand den Anmerkungen von Lothar an die Arbeit 
gemacht und versucht die Pufferverwaltung zu realisieren.

Für mich als Anfänger auf jeden Fall etwas schwieriger als wie beim 
Einsatz von Polling. Es klappt nicht wirklich. Mit Hilfe meines C-Buches 
und über das Internet hab ich versucht die Fehler ausfindig zu machen, 
ohne Erfolg.

Es wäre nett, wenn der ein oder andere erfahrenen Programmierer einen 
Tipp oder Hinweis hätte...Es wäre schon mal gut zu wissen, ob das, was 
ich gemacht hab in die Richtung geht, die mit Lothar geraten hat.

Meine Strings, die ich empfange Enden immer mit '\r', also würde ich 
dieses Zeichen als Terminator verwenden. In meinem Programm möchte ich 
die bereits oben erwähnte Flag-Problematik vermeiden um im Haupt- oder 
Nebenprogramm Befehle zu versenden.

Viele Grüße,
Urban

Hallo Karl-Heinz,
danke für deine Antwort.
Ufff,das war wohl ein Griff ins Klo. Ich habe mir die Lib mal angeschaut 
und bin nicht so richtig durchgestiegen. Dann werde ich mir sie nochmals 
zu Gemüte führen und hoffen das ich es kapier. Nochmals Danke!
VG,
Urban

Hallo,

ich habe nun versucht mit der von KH vorgeschlagenen UART Lib von Peter 
Fleury einen FIFO zu realisieren.

Ich verwende eine Arduino Board Mega mit einer 16MHz Taktfequenz. Die 
Daten die ich empfange werden mit 9600bps 8Bit, keine Parität und einem 
Stoppbit versendet. Bisher konnte ich mit Polling meine kleine Anlage 
ansteuern.

Zwar seh ich jetzt den versendeten String am Hyperterminal, meine Anlage 
reagiert allerdings nicht mehr wenn ich die Befehle über den UART 
versende.
Das lies mich vermuten, dass etwas nicht mit der Einstellung des 
Datenformates(Parität, bps, etc.) stimmt. Allerdings ist soweit alles in 
Ordnung.

Des weiteren wollte ich die empfangenen Zeichen, sofort wieder über die 
UART versenden (siehe Programm). Allerdings wird nur 0x00 versendet. Ich 
weiß nicht mehr weiter.

Hallo Karl-Heinz,ich wollte das nicht einfach so übernehmen, sondern 
versuchen das zu verstehen und selbst zu probieren...Klappt allerdings 
noch nicht ganz. ich bleib hartnäckig