Zusammenwirken von 2 StateMaschine

[unwissender_Neuling (Gast)]

Hi,

hab ein Verständnisproblem, bei einen Quellcode. Vielleicht kann mir 
jemand auf die Sprünge helfen.

Es gibt 2 StateMaschine....SM_1 und SM_2.

SM_1 hat Zustände A,B und C

SM_2 hat Zustände 1,2 und 3

Wobei Zustände A=2 und B=3 sind.

in dem Quellcode wird dann geschrieben:

SM_1 = SM_2;

Nach meiner Interpredation müsste ja SM_1 den selben Zustand annehmen 
wie SM_2, d.h. wenn in SM_2 gerade der Zustand 2 anliegt, müsste SM_1 
danach im Zustand A sein.

Was passiert aber wenn SM_2 im Zustand 1 ist? Welchen Zustand würde dann 
SM_1 einnehmen?

[Stefan B. (stefan)]

unwissender_Neuling wrote:

> Was passiert aber wenn SM_2 im Zustand 1 ist? Welchen Zustand würde dann
> SM_1 einnehmen?

Das ist mit der vorliegenden Information nicht zu beantworten. Man 
müsste das Codestück sehen, in dem die Zustände A,B und C definiert 
werden.

[Christoph db1uq K. (christoph_kessler)]

Die Zustände sind ja irgendwie mit binären Zahlenwerten nummeriert, für 
drei Zustände also mindestens 2 Bit pro Statemachine.
Aus mir unbekannten Gründen macht z.B. Altera Quartus lieber ein 
"one-hot-encoding" also nur Binärzahlen mit einem high, dem Rest low - 
man hat ja genug Platz.
Mit der Zuweisung SM_1 = SM_2 übernimmt also die Statemachine 1 die 
momentane Statenummer der zweiten Statemachine.
War da ein "Code Obfuscator" am Werk? Alles in einer einzigen 
Statemachine verpackt wäre sicher lesbarer. 
http://de.wikipedia.org/wiki/Obfuscator

[unwissender_Neuling (Gast)]

>Man müsste das Codestück sehen, in dem die Zustände A,B und C definiert
>werden.

naja im Prinzip sind es 2 normale Statemaschine

SM_1:

switch(SM_1)
{ case A: 
  case B:
  case C: }

switch(SM_2)
{ case 1: 
  case 2:
  case 3: }

>Mit der Zuweisung SM_1 = SM_2 übernimmt also die Statemachine 1 die
>momentane Statenummer der zweiten Statemachine.

Wenn ich das richtig verstehe hängt es nicht vom Statenamen sondern der 
Statenummer ab, in welchen Zustand SM_1 springt? Demzufolge ist es egal 
das Zustand A den gleichen Namen hat wie Zustand 2 ?

[Michael G. (linuxgeek)]

Endliche Automaten lassen sich miteinander verknuepfen. Dahinter steht 
eine ziemlich ausfuehrliche Theorie.

http://de.wikipedia.org/wiki/Deterministischer_endlicher_Automat

[unwissender_Neuling (Gast)]

>Endliche Automaten lassen sich miteinander verknuepfen. Dahinter steht
>eine ziemlich ausfuehrliche Theorie.

Wenn ich das richtig verstanden habe, müsste die SM_2 ein Eingabesymbol 
setzen, welches von SM_1 ausgewertet wird.

Dies ist aber bei den beiden SM nicht der Fall. Es gibt keine Verbindung 
zwischen den SM, außer das die Zustände A und 2 bzw. B und 3 den selben 
Namen haben und das SM_1 mit SM_2 gleich gesetzt wird.

[Stefan B. (stefan)]

unwissender_Neuling wrote:
>>Man müsste das Codestück sehen, in dem die Zustände A,B und C definiert
>>werden.
>
> naja im Prinzip sind es 2 normale Statemaschine
>
> SM_1:
>
> [c]switch(SM_1)
> { case A:
>   case B:
>   case C: }

Das ist die Anwendung und nicht die Definition.

Die Definition von A,B und C kann z.B. so gemacht sein:

#define A 2
#define B 3
#define C 1

dann wäre bei SM_2 = 1 und SM_1 = SM_2 SM_1 gleich C.

Eine andere Art um A,B und C festzulegen, wäre z.B. ein enum
http://www.hs-augsburg.de/~sandman/c_von_a_bis_z/c_017_009.htm

[??? (Gast)]

Die SM Zustände sind mit einen enum definiert (danke nun weiss ich wofür 
das ist^^)

enum Zustände { 1 , A , B, C }

Was mich dann allerdings etwas verwirrt, mit Hilfe dieses enum wird 
scheinbar der Anfangszustand von SM_2 definiert, allerdings gibt es 
diesen Zustand in der Anwendung für SM_2 nicht.

static Zustände SM_2 = C;

So richtig werde ich dadurch nicht schlauer, wie sich daraus die 
Zustände in den SMs ergeben.

[Stefan B. (stefan)]

Wenn du im Code für SM_1 nur so auswertest und in den case Anweisungen 
manipulierst

switch(SM_1)
{
  case A:
  case B:
  case C:
}

dann schaffst du mit SM_2 = 1 und SM_1 = SM_2 für SM_2 einen nicht 
ausgewerteten Zustand (SM_2 == 1).

Ich halte das für gefährlich, weil dann ja die Frage auftauchen muss, 
wie SM_2 jemals aus diesem "illegalen" Zustand rauskommen soll... 
vielleicht hilft es dir, wenn du die Maschinen in einem Zustandsdiagramm 
aufzeichnest

[??? (Gast)]

>Ich halte das für gefährlich, weil dann ja die Frage auftauchen muss, wie >SM_2 
jemals aus diesem "illegalen" Zustand rauskommen soll...

Das hatte ich vergessen zu erwähnen.

Der Zustand C wird mit "break" beendet. Allerdings stellst sich dann die 
Frage in welchen Zustand er anschliessend springt.

Ist es möglich das diese 2 SM eigentlich nur eine SM ist, welche in 2 
Teile aufteilt wurde? Das würde soweit einen Sinn ergeben, da in diesen 
Zustand C das gesamte System auf einen Ausgangszustand gesetzt wird und 
die SM_2 häufiger noch in diesen Zustand C springt (wenn Fehler 
anliegen).

[??? (Gast)]

Vereinfacht sehen die beiden SM so aus.

switch(SM_1)
{ case A:  //leer
  case B:  /* System starten*/ break; 
  case C:  /*System stoppen */  break;
}

switch(SM_2)
{ case 1: if (Timer > 0) {SM_2 = 2;}
          else {SM_2 = 3;}
  case 2: if (myTimer == Timer) {SM_2 = 3}
          else {SM_2 = C;}
  case 3: if (X == Y) {SM_2 = C;}
          else {SM_2 = 2;} 
}

Der Zustand C scheint ein IDLE Zustand zu sein, müsste die SM_2 nach den 
break in den Zustand 1 springen ?

[Stefan B. (stefan)]

Oben in der Antwort 19.09.2008 14:14  habe ich schon SM_1 und SM_2 
durcheinandergeworfen... ich würde an deiner Stelle mit Papier und 
Belistift ein Zustandsdiagramm anfertigen.

In welche Zustände definieren das System und welche Aktionen bewirken 
die Übergänge von einem Zustand in einen anderen Zustand. Wenn das 
Programm richtig ist, solltest du einen geschlossenen Kreis pro state 
machine zeichnen können.
http://www.mikrocontroller.net/articles/Pollin_Funk-AVR-Evaluationsboard#Suppentimer

In

switch(SM_2)
{ case 1: if (Timer > 0) {SM_2 = 2;}
          else {SM_2 = 3;}
  case 2: if (myTimer == Timer) {SM_2 = 3}
          else {SM_2 = C;}
  case 3: if (X == Y) {SM_2 = C;}
          else {SM_2 = 2;}
}

sehe ich Programmierfehler (fehlende breaks) und vermute welche: An den 
beiden Stellen SM_2 = C; ergibt für mich ein SM_1 = C; mehr Sinn. Mir 
fehlt allerdings der Punkt, wo SM_2 zurückfällt auf Zustand 1. Im 
gezeichneten Zustanddiagramm würde das ein offenes Diagramm bedeuten, 
d.h. ein untaugliches.

switch(SM_1)
{ case A:  //leer
  case B:  /* System starten*/ break;
  case C:  /*System stoppen */  break;
}

Ist ohne die Weiterschaltung, d.h. fehlende Übergänge etwas seltsam. 
Kann es sein, dass das nur eine Vereinfachung der state machine 2 ist, 
um alle Manipulationen des Systems zentral in einem switch zu handhaben?