Auf Befehl warten ohne Blockierung des AVR

[Andreas S. (Gast)]

Hallo !

In einem Programm für einen AVR möchte ich per UART Strings als Kommando 
empfangen die mit einem festen Zeichen (!) beginnen und mit einem festen 
Zeichen aufhören (\n). Währenddessen soll aber das Hauptprogramm nicht 
unterbrochen werden. Momentan sieht mein Hauptprogramm so aus, zum 
Empfangen des Kommandos nutze die Methode aus dem AVR-GCC-Tutorial.

void uart_gets( char* Buffer, uint8_t MaxLen )
{
  uint8_t NextChar;
  uint8_t StringLen = 0;
 
    do {
        NextChar = uart_getc();
    } while (received_char != '!');         // Warte auf und empfange das nächste Zeichen
 
                                  // Sammle solange Zeichen, bis:
                                  // * entweder das String Ende Zeichen kam
                                  // * oder das aufnehmende Array voll ist
  while( NextChar != '\n' && StringLen < MaxLen - 1 ) {
    *Buffer++ = NextChar;
    StringLen++;
    NextChar = uart_getc();
  }
 
                                  // Noch ein '\0' anhängen um einen Standard
                                  // C-String daraus zu machen
  *Buffer = '\0';
}


int main(){
   while(1){
      tuDies();
      tuDas();

      empfangeUart();
   }
}

Für den Empfang einzelner Zeichen nutze ich die UART-Lib von hier
http://homepage.hispeed.ch/peterfleury/avr-software.html

Nun ist es natürlich so, dass erst wieder tuDies() und tuDas() gemacht 
wird, wenn ein Kommando über den UART gekommen ist. Kommt keins, wird 
solange nichts getan, bis ein Kommando kam. Ich hätte es aber gerne so, 
dass alles andere ausgeführt wird und nur wenn ein Kommando angekommen 
ist, wird die entsprechende Aktion ausgeführt. Wie bewerkstellige ich 
dies ?

Viele Grüße,

A.S.

[Karl H. (kbuchegg)]

Andreas S. schrieb:

> Nun ist es natürlich so, dass erst wieder tuDies() und tuDas() gemacht
> wird, wenn ein Kommando über den UART gekommen ist. Kommt keins, wird
> solange nichts getan, bis ein Kommando kam. Ich hätte es aber gerne so,
> dass alles andere ausgeführt wird und nur wenn ein Kommando angekommen
> ist, wird die entsprechende Aktion ausgeführt. Wie bewerkstellige ich
> dies ?

Pseudocode

int main()
{
  ....

  while( 1 )
  {

    if( Es gibt ein Zeichen an der UART )
    {
      Zeichen holen

      if( Zeichen ist Kommando-Endekennung )
      {
        Führe Kommando aus
        Lösche Kommando-String
      }

      else if( Zeichen ist Kommando-Startkennung )
        Lösche Kommando-String

      else
        Hänge das Zeichen an den Kommando String an
    }

    Tu dies();
    Tu das();
  }
}

Also eigentlich so wie immer, wenn man ein Programm schreibt, welches 
mehrere Dinge 'quasi' gleichzeitig machen soll:
Man fasst alles als mögliches Ereignis auf, prüft in der Hauptschleife 
reihum alle möglichen Ereignisse darauf hin ab, ob sie vorliegen und 
wenn sie das tun, dann löst man die zugehörige Aktion aus.

In deinem Fall ist dann eben das 'mögliche Ereignis' nicht, dass ein 
Kommando fertig ist, sondern dass ein Zeichen an der UART eingetrudelt 
ist. Und dafür muss man sich dann eben überlegen, was man damit machen 
will.
In deinem Fall hat man mit einem einzelnen Zeichen noch nichts 
angefangen, also muss man viele derartige 'mögliche Ereignisse' sammeln 
(den Kommandostring aufbauen), bis dann eben irgendwann alles vorhanden 
ist, so dass man mit der Abarbeitung beginnen kann.

PS: ein bischen Aufwand wirst du noch in den Teil stecken müssen, der 
einfach das Zeichen anhängt. Denn das Zeichen sollte nur dann angehängt 
werden, wenn vorher eine Startkennung gesichtet wurde. Aber mit einem 
Flag ist das ja kein Problem.

[O. D. (odbs)]

Das wäre die Variante ohne Interrupt. Die ist übersichtlich und 
funktioniert auch gut.

Allerdings nur, wenn die Hauptschleife so schnell durchlaufen wird, dass 
zwischen den Durchläufen nicht mehr als ein Zeichen an der Schnittstelle 
ankommen kann. Sprich, die Baudrate und die Abarbeitungsgeschwindigkeit 
der Hauptschleife müssen zusammenpassen.

Wir wissen ja nicht, was in der Hauptschleife passiert. Vielleicht steht 
da irgendwo ein längeres _delay_ms(), weil eine LED blinken soll oder 
ähnliches. Jetzt mal unabhängig davon, ob das guter Stil ist, man sieht 
es oft bei Anfängern, die hier Fragen stellen.

In einem solchen Fall bietet sich an, den Receive-Interrupt des USART 
abzufangen und den Kommandostring dort zusammenzusetzen. Wenn ein 
vollständiges Zeichen empfangen ist, kopiert man den String um und setzt 
ein Flag für die Hauptschleife.

Wenn es nicht zu viele verschiedene Kommandos gibt und diese keine 
Parameter enthalten, kann man auch für jedes mögliche Kommando ein 
eigenes Flag vorsehen.

[Karl H. (kbuchegg)]

Oliver Döring schrieb:
> Das wäre die Variante ohne Interrupt. Die ist übersichtlich und
> funktioniert auch gut.
>
> Allerdings nur, wenn die Hauptschleife so schnell durchlaufen wird, dass
> zwischen den Durchläufen nicht mehr als ein Zeichen an der Schnittstelle
> ankommen kann. Sprich, die Baudrate und die Abarbeitungsgeschwindigkeit
> der Hauptschleife müssen zusammenpassen.


Er benutzt
http://homepage.hispeed.ch/peterfleury/avr-software.html

und von der weiß ich zufällig, dass sie Interruptgesteuert ist und über 
einen kleinen Ringbuffer verfügt, der sich genau um diese 
Problemstellung kümmert.

[Uwe (Gast)]

Man kann sich nen interupthandler basteln der ne Statemachine drinne hat 
und auf '!' als startbedingung wartet, dann ein Flag setzt den Zähler um 
1 erhöht und den Interuprt beendet bis das nächte Zeichen kommt.
Beim nächsten Zeichen wird geguckt ob das Flag für start schon gesetzt 
ist, wenn ja kann man auf '\n' und maximallänge prüfen, falls positiv 
Zähler um 1 erhöhen und '\0' anhängen, beeden und weiteres Flag für die 
main setzen 'da_ist_was_gueltiges_im_puffer=true".
Falls nicht Zeichen in den Buffer und Zähler eröhen.

[Falk B. (falk)]

Siehe Multitasking.

[Adib (Gast)]

die Idde mit der Statemachine im ISR ist sicher nicht schlecht.
Man muss aber beachten, dass das Hauptprogramm (die main-schleife) dann 
auch das Protokoll schnell genug abholt befor ein neues Protokoll 
beginnt.
Einfacher ist sicher Karl Heinz' System mit dem Decoder im 
Hauptprogramm.

WEnn die Verarbeitung eh im Hauptprogramm stattfindet, ist die 
Reaktionszeit gleich.
Beim AVR würde ich aufwendige Verarbeitungen nicht im ISR machen, da 
dann alle anderen ISR solange blockiert sind.

Adib.

[cppler (Gast)]

Also so wie ich das verstehe sendest Du "!startexyz" als Text und das 
soll interpretiert werden.
Wenn Du Probleme mit der Zeit bekommst weil halt 
"!startenichtmehrxyzsondernabc" länger ist dann kann man zu #defines 
greifen und im sendenden Programm aus "!startyxz" dann "!a" machen.
Statemachine ist schon genannt worden, das solltest Du Dir mal genauer 
ansehen.