Ansi C: state machine + at commandos

[*Ho* (Gast)]

Guten Tag, für eine spezielle Anwendung bräuchte ich Hilfe.
Ich bin gerade dabei ein kleines Tool zu schreiben mit dem ich AT 
Kommandos via UART absetzen möchte. Die Gegenstelle anwortet dann mit 
einem String.
Nun ist es so das ich mehrere AT Kommandos per Uart versenden möchte.
Dies soll in einer State Machine realisiert werden. In einem UART 
Callback wird dann der empfangene String von der Gegenstelle 
ausgewertet.
Ich weiß nicht wie ich dies richtig realisieren kann.

void Uart Callback(...)
{
  ==> check receive message, start other state
}

int main()
{

   while(1)
   {
     stateMachine();
   }
}

void stateMachine()
{
    switch (state)
    {
    case AT_COMMAND1:
        ==> send at command1 via uart

        break;

    case AT_COMMAND2:
        ==> send at command2 via uart
        
        break;

    }
}

[DerEgon (Gast)]

*Ho* schrieb:
> Nun ist es so das ich mehrere AT Kommandos per Uart versenden möchte.
> Dies soll in einer State Machine realisiert werden.

"Du möchtest" ... und "das soll".

Was jetzt? Und vor allem: Warum? Warum hast Du Dich für eine 
Statemachine entschieden?

[Stephan (Gast)]

>spezielle Anwendung
Eine Hausaufgabe?

[*Ho* (Gast)]

Warum eine Statemachine?
Das war sozusagen mein erster Gedanke soweis ordentlich sequenzell zu 
machen

[Niklas G. (erlkoenig)]

Muss es ANSI-C (C89) sein? Aktuelle C-Standards sind viel komfortabler 
und werden von fast allen Compilern unterstützt. ANSI-C ist 33 Jahre 
alt...

[*Ho* (Gast)]

Welche Standard ist mir jetzt echt egal.

Das mit der Uart Callback und der statemachine läuft bei mir nicht 
richtig.
Irgendwas habe ich übersehen.
Die Statemachine soll dann erst weiterlaufen sobald der string korrekt 
empfangen wurde.

[Wilhelm M. (wimalopaan)]

Das mit der SM ist schon genau richtig. Du wirst sogar zwei brauchen, 
denn in Deinem UartCallback wird auch eine laufen, die die empfangenen 
Zeichen parsed, und damit die Antwort auswertet.

Der Ablauf ist ja etwa

1) Senden Cmd1
2) Warten auf OK/NOK (ggf. mit Ergebnis)
3) Sendem Cmd2
4) Waretn auf OK/NOK (ggf. mit Ergebnis)
...

D.h. Du musst zusätzliche Wartezustände einbauen. Der Übergang von einem 
Wartezustand zu nä. Zustand wird dadurch ausgelöst, dass die andere SM 
im UartCallback eine Antwort erkannt hat und damit einen Event sendet.

[Georg (Gast)]

*Ho* schrieb:
> Warum eine Statemachine?
> Das war sozusagen mein erster Gedanke soweis ordentlich sequenzell zu
> machen

Eine state machine ist sinnvoll, wenn sie Ereignisse und states 
verknüpft:

Für jeden state gibt es eine Prozedur, die auf das Ereignis (z.B. 
Zeichen empfangen) reagiert und dann einen neuen state setzt. Das ist 
bei dir aber nicht der Fall, du reagierst NUR auf states. Das ist 
überhaupt keine state machine. Ausserdem sendet deine Prozedur immer 
wieder das AT Kommando.

Normal wäre es wenn die state machine nach dem Absenden des Kommandos 
selbst den state zurücksetzen würde auf "empfangsbereit". Und in diesem 
state wartet die Prozedur auf eingehende messages.

Das vorgestellte Programm hat nur eine sehr entfernte Ähnlichkeit mit 
einer state machine.

Georg

[Nanana (Gast)]

Niklas G. schrieb:
> Muss es ANSI-C (C89) sein? Aktuelle C-Standards sind viel
> komfortabler und werden von fast allen Compilern unterstützt. ANSI-C ist
> 33 Jahre alt...

Msvc... Hust hust

[db8fs (Gast)]

Mal doch erstmal ein Diagramm, einmal was der Sender in welchem Zustand 
senden soll und einmal eins, welche Nachrichten der Empfänger überhaupt 
empfangen darf.

Der Einfachheit halber nimmste für den Sender halt an, dass beim 
Betreten eines Zustands irgendwas gesendet wird. Beim Empfänger dann 
erfolgt die Transition unter der Bedingung, das eine bestimmte Sequenz 
empfangen wird.

https://de.wikipedia.org/wiki/Zustandsdiagramm_(UML)

Soll heißen: was soll der sender machen, was der empfänger.

[Rolf M. (rmagnus)]

Nanana schrieb:
> Msvc... Hust hust

Ist der nicht inzwischen auch "schon" bei C99 angekommen?

[Mox (Gast)]

Rolf M. schrieb:
> Nanana schrieb:
>> Msvc... Hust hust
>
> Ist der nicht inzwischen auch "schon" bei C99 angekommen?

Ja: 
https://devblogs.microsoft.com/cppblog/c11-and-c17-standard-support-arriving-in-msvc/

Und: 
https://github.com/MicrosoftDocs/cpp-docs/blob/main/docs/overview/visual-cpp-language-conformance.md#c-standard-library-features-1

[Alex (Gast)]

Moin,

Gibt hier doch einen super Artikel wie das geht:
https://www.mikrocontroller.net/articles/Statemachine

schönen Gruß,
Alex

[Wilhelm M. (wimalopaan)]

Alex schrieb:
> Moin,
>
> Gibt hier doch einen super Artikel wie das geht:
> https://www.mikrocontroller.net/articles/Statemachine

Naja, der Artikel ist ganz gut, aber bei der softwaretechnischen 
Umsetzung leider etwas schwach in einigen Dingen.

Wer wirklich effektive FSMs in C++ machen will, sollte

https://github.com/boost-ext/sml

benutzen.

[Niklas G. (erlkoenig)]

Wilhelm M. schrieb:
> Wer wirklich effektive FSMs in C++ machen will,

Ich bin großer Fan des State Pattern weil es einfach und Flexibel ist. 
Man braucht im Prinzip nichtmal eine Library dafür, man kann das mit 
einer Union oder std::variant umsetzen.

Ich habe mal eine Mini-Library geschrieben die ein bisschen die 
Schreibarbeit reduziert:

https://github.com/Erlkoenig90/OverlayFSM

Bin aber leider bisher nicht dazu gekommen sie zu dokumentieren...

[Rolf M. (rmagnus)]

Wilhelm M. schrieb:
> Wer wirklich effektive FSMs in C++ machen will, sollte
>
> https://github.com/boost-ext/sml
>
> benutzen.

Hat allerdings wieder das gleiche Problem, das man in boost sehr oft 
findet - die ausufernde Operator-Abuse:

  return make_transition_table(
      *"established"_s + event<release>          / send_fin  = "fin wait 1"_s,
       "fin wait 1"_s  + event<ack> [ is_valid ]             = "fin wait 2"_s,
       "fin wait 2"_s  + event<fin> [ is_valid ] / send_ack  = "timed wait"_s,
       "timed wait"_s  + event<timeout>                      = X
  );

[A. S. (Gast)]

*Ho* schrieb:
> Welche Standard ist mir jetzt echt egal.
> Das mit der Uart Callback und der statemachine läuft bei mir nicht
> richtig

Statemachine ist sehr allgemein.

Zum einen gibt es verschiedenste Ausführungen, zum anderen verschiedene 
Teilaspekte, für die Du welche verwenden kannst.

Man kann dann vollkommen aneinander vorbeireden.

Daher: nutzt Du sie blockierend (Anfänger, simpel, mit delays) oder wie 
SPS?

Welche SMs, wo?
 * Im Interrupt (Dekodierung der RX-Zeichen)?
 * In Loop
 * Beim kodieren des Telegramms?
 * Beim Senden (falls keine Tel-Puffer)

Wie koppelst Du Receive und statemachine? Über Flags? Über je einen 
state, in dem Du auf Antwort wartest?

Hast Du (brotlose) Timer für die Zeitüberwachung und Wiederholung?

Oftmals muss man die statemachine im Empfang "doppelt" nachbilden oder 
umgekehrt. Wwie man ein if verdoppeln muss, wenn man 2 unabhängige 
Bedingungen hat. Entweder reagiert man an 2 Stellen (States) auf 
"Telegramm 35" oder man wertet beim Empfang des Tel aus, ob der state 
gerade "hü" oder "hot" ist.

Jeder hat bei solchen Diskussionen "seinen" Favoriten um Kopf.

Daher bitte kurz Deine Struktur, Dein Timing, Deine Interaktion von SM 
und Receive, ob blockierend,