RS232 Steuerungs-Ablauf

Aus Forum "Codesammlung" verschoben.

zuallererst trennst du mal grundsätzlich das empfangen der
Zeichen von der Auswertung. Beides hat nichts miteinander
zu tun.
In der Empfangs-ISR speicherst du die empfangenen Zeichen
einfach in einem Buffer. Wenn du ein vernünftiges Protokoll
definierst, dann mach das so, dass du den Anfang deines
kompletten Kommandos eindeutig erkenne kannst. Stell dir
einfach vor, jemand liest aus einem Buch vor. Er tut dies
indem er die Wörter buchstabiert und auch Satzzeichen ausspricht.
Deine Aufgabe ist es jetzt aus dem was er vorliest ganze Sätze
zu bilden. Dein Problem: Wenn du in den Raum kommst, liest der
schon eine Weile. Du brauchst alse eine Methode um mit absoluter
Sicherheit den nächsten Satzanfang zu erkennen. Denk dir dazu was
aus! Nimm mein (blödes) Beispiel und überleg mal, wie du da das
machst. Das ist überhaupt eine gute Strategie! Wenn du vor einem
Problem stehst transformiere es in deine Welt und überlege
und beobachte dich selbst wie du dieses Problem löst. Wir Menschen
machen viele Dinge und sind uns gar nicht bewusst wie wir sie
machen. Programmieren heist auch seine Umwelt, einschliesslich
sich selbst, zu beobachten und lernen wie dort Probleme
gelöst werden.

Soweit, so gut: Wenn die ISR also signalisiert, zb über eine
globale Variable, liegt in einem Character Buffer ein komplett
übertragener Befehl  vor. Na ja, und den wertest du aus.
zb. in main()

volatile unsigned char CommandReveived;
char Command[30];  // oder wieviele du halt brauchst

ISR( ... )
{
  // empfängt ein Kommando Zeichen für Zeichen
  // und stellt das Kommando in 'Command' zur Verfügung
  // Ist ein Kommando vollständig wird 'CommandReceived'
  // auf TRUE gestellt
}

int main()
{

  ...
  while( 1 ) {
    if( CommandReceived ) {
      ...
      switch(Command[0]) {    // 1. Zeichen ist der Befehl

        case 'M':     // Kommando 'MoveTo'
                      // die restlichen empfangenen Zeichen
                      // geben die Position an
          HandleMove();
          break;

        case 'U':     // Kommando 'Up'
                      // Keine weitere Info notwendig
                      // Stift, Fräser abheben
          HandleUp();
          break;

        case 'D':     // Kommando 'Down'
                      // Stift, Fräser absenken
          HandleDown();
          break;

        case 'W':     // Kommando Kühlwasser
                      // das nachste Byte imm Buffer sagt aus
                      // ob 'Wasser ein' oder'Wasser aus'
          HandleWater();
          break;

        ...

                      // die UART wieder scharf stellen
        CommandReceiver = FALSE;
    }
  }
}

So ungefähr. Obiges ist nicht optimal, aber es ist mal ein
Anfang. Das Problem liegt darin, dass während die Verarbeitung
eines Kommandos läuft kein weiteres empfangen werden kann.
Ist lösbar. Aber eines nach dem anderen.

> jedoch sehe ich auch daraus das es keine alternative zu einer case
> oder if auswertung gibt. ?

Oh. Da gibt es noch jede Menge anderer Möglichkeiten.
Die von dir angesprochene Lookup-Tabelle ist zb eine.
Ich gehe allerdings davon aus, dass du nur wenige Kommandos
auf der Schnittstelle hast. Da ist eine switch-case Leiste
mehr als ausreichend und erfüllt seinen Job hervorragend.

Eine Lookup Tabelle könnte zb so aussehen:
Gesucht ist duch die Umsetzung eines Kommandos (in Form eines
Characters) in einen Funktionsaufruf.
Da gibt es jetzt mehrere Möglichkeiten, je nachdem über wieviele
zu erkennenden Kommandos wir reden. Sind es relativ viele, so dass
das Alphabet für das Kommandobyte gut ausgenutzt wird, so macht
man sich ganz einfach ein Array, wobei dann das Kommandobyte als
Index in dieses Array benutzt wird (Handlexxx sind jeweils Funktionen
die dafür zuständig sind ein Kommando abzuarbeiten).

    typedef void (*Fnct)(void);

    Fnct Functions[] =
      { HandleA,
        HandleB,
        HandleC,
        HandleD,
        NULL,
        HandleE,
        ... etc
        HandleZ
      };

     void HandleA()
     {
        // Bearbeite das Kommando 'A'
     }

     void HandleB()
     {
       // Bearbeite das Kommando 'B'
     }

     ...

Damit ist die Bühne aufgesetzt, jetzt muss nur noch in main(),
abhängig vom Kommandobyte die richtige Funktion aufrufen:

     ...
     if( Functions[ Command[0] - 'A' ] )
       Functions[ Command[0] - 'A' ]();

(Command[0], also das erste Byte, wird als index in die Tabelle
von oben mit den Funktionspointern genommen und die Funktion ueber
den Funktionspointer aufgerufen.

Möglichkeit 2:
Wenn es nur wenige Kommandos sind, dann ist obiges Array etwas
überkandidelt. Die meisten Einträgre sind NULL. Dann ist es ev.
besser sich eine Struktur zu basteln

  struct Entry {
    char Command;
    Fnct Function;
  }

Damit kann ich dann gezielt ein Array bauen:

  struct Entry Functions[] = {
     { 'M', HandleMove },
     { 'U', HandleUp },
     { 'D', HandleDown },
     { 'W', HandleWater }
  }

Nette kleine Tabelle :-)
Jetzt geht man mit dem ersten Zeichen des Kommandos wieder her
und durchsucht die Tabelle nach dem entsprechenden Eintrag. Hat
man ihn gefunden, hat man dann auch den Funktionspointer und kann
ueber diesen die Funktion aufrufen. Bei derartig wenig Kommandos
kann man ganz einfach linear suchen:

    for( i = 0; i < sizeof(Functions)/sizeof(*Functions); ++i )
      if( Command[0] == Functions[i].Command )
        Functions[i].Function();

Wenn es mehr Kommandos sind, könnte man auch eine binäre suchen
machen, oder das Ganze über eine Hashtable realisiern

Eine komplett andere Möglichkeit wäre es einen schönen Parser
aufzusetzen. Nimmt man dann wenn man nicht nur Kommandos mit
einem Buchstaben hat, sondern Schlüsselwörter.

Oder ...

Es gibt noch viele Möglichkeiten.
Aber für wenige Kommandos dürfte eine switch-case Leiste
das Einfachste aber nicht notwendigerweise das Schlechteste sein.

Für den Basteltisch würde ich sogar ganz darauf verzichten
und einfach auf der UART-Ebene die Parity einschalten.