im Text zur FSM Library (Arduino Playground - FiniteStateMachine Library) steht, dass zu jedem einzelnen Zustand eine enter-, update- und eine exit-Funktion gehört (zu finden unter „State Creation“):
Da der Funktionsumfang der FSM Bibliothek gelinde gesagt nicht sofort ersichtlich ist ( ), habe ich mir mal die Mühe gemacht, sämtliche relevanten Informationen so gut es ging zu übersetzen und um sinnvolle Kommentare zu ergänzen.
Alles natürlich wie beim Lotto ohne Gewähr:
/******************************************************************************************************************/
/***************************************** Beschreibung FSM *****************************************************/
/******************************************************************************************************************/
/* Endlicher Zustandsautomat
Mit einem endlichen Zustandsautomaten lassen sich Zustände verwalten.
Er verwaltet sowohl die Übergänge zwischen den einzelnen Zuständen, als auch die Zustände an sich.
Die Übergänge lassen sich sowohl durch äußere Eingaben, als auch durch interne Logiken auslösen.
Übergänge können entweder sofort erfolgen oder bis zur nächsten Zustands-Aktualisierung zurückgestellt werden.
Letzteres wird häufiger verwendet, da dadurch sichergestellt wird, dass alle Codebestandteile,
die sich auf den aktuellen Zustand beziehen, gleichzeitig ausgeführt werden.
Das weiter unten aufgeführte Beispiel benötigt lediglich der Einfachheit
halber sowohl die Button_Library als auch die LED_Library.
*/
/******************************************************************************************************************/
/***************************************** Aufbau ***************************************************************/
/******************************************************************************************************************/
// Diese Bibliothek geht davon aus, dass sämtliche Funktionalitäten im Sketch hinterlegt sind,
// damit die einzelnen Zustände über eine einfache Abfrage die entsprechende Funktion auslösen können.
// Zustände erwarten entweder nur eine update_Funktion,
// oder eine enter_, update_ und exit_Funktion.
// Diese Funktionen werden anhand folgendes Schemas aufgerufen:
current.exit(); // Momentanen Zustand verlassen
next.enter(); // Zum nächsten Zustand wechseln
current = next; // Den eben noch nächsten Zustand zum momentanen Zustand machen
current.update(); // Wenn momentan kein Übergang stattfindet
/******************************************************************************************************************/
/***************************************** Initialisierung eines Zustandsautomatens *****************************/
/******************************************************************************************************************/
FSM(State)
// Beispiel:
FSM ethernetStateMachine = FSM(ethernetDebugState);
// Initialisiert einen Zustandsautomaten namens "ethernetStateMachine" mit dem Zustand "ethernetDebugState"
/******************************************************************************************************************/
/***************************************** Initialisierung von Zuständen ****************************************/
/******************************************************************************************************************/
State(updateFunction)
// Beispiel:
State On = State(ledOn); // Initialisierung lediglich mit der update_Funktion
State(enterFunction, updateFunction, exitFunction)
// Beispiel:
State ethernetDebugState = State(connectToHost, debug, closeConnectionToHost);
/******************************************************************************************************************/
/***************************************** Functions State Functions ********************************************/
/******************************************************************************************************************/
void enter() // Diese Funktion wird immer dann ausgelöst, wenn in den entsprechenden Zustand gewechselt wird.
void update() // Diese Funktion wird immer dann ausgelöst, wenn der Zustandsautomat aktualisiert wird,
// während der entsprechende Zustand momentan aktiv ist.
void exit() // Diese Funktion wird immer dann aufgerufen, wenn der entsprechende Zustand verlassen wird.
/******************************************************************************************************************/
/***************************************** Finite State Machine Functions ***************************************/
/******************************************************************************************************************/
void update() // Diese Funktion aktualisiert den momentanen Zustand
// des entsprechenden Zustandsautomatens
// Beispiel:
ledStateMachine.update();
void transitionTo(State) // Mit dieser Funktion kann eine Zustandsänderung herbeigeführt werden,
// deren Änderungszeitpunkt zu Beginn der nächsten Aktualisierung stattfinden wird
// Beispiel:
ledStateMachine.transitionTo(FadeIn);
void immediateTransitionTo(State) // Diese Funktion wechselt sofort vom aktuellen zum nächsten Zustand
// des des entsprechenden Zustandsautomatens
// Beispiel:
ledStateMachine.immediateTransitionTo(FadeIn);
State& getCurrentState() // Gibt den momentanen Status des entsprechenden Zustandsautomatens zurück
// Beispiel:
ledStateMachine.getCurrentState();
boolean isInState(State) // Prüft, ob der angefragte Zustand dem momentanen Zustand entspricht
// Beispiel:
ledStateMachine.isInState(On)
/******************************************************************************************************************/
/***************************************** Beispielcode *********************************************************/
/******************************************************************************************************************/
#include <FiniteStateMachine.h> // FSM-Library (http://arduino-info.wikispaces.com/HAL-LibrariesUpdates)
#include <Button.h> // Button-Library (http://arduino-info.wikispaces.com/HAL-LibrariesUpdates)
#include <LED.h> // LED-Library (http://arduino-info.wikispaces.com/HAL-LibrariesUpdates)
State On = State(ledOn); // Initialisierung der einzelnen Zustände (mit Verweisen auf einzelne Funktionen)
State Off = State(ledOff);
State FadeIn = State(ledFadeIn);
State FadeOut = State(ledFadeOut);
FSM ledStateMachine = FSM(On); // Initialisierung eines Zustandsautomatens namens "ledStateMachine"
// mit dem Zustand "On"
const byte NUMBER_OF_STATES = 4; // Gesamtanzahl der möglichen Zustände
Button button = Button(12,PULLUP); // Initialisierung eines Knopfes
byte buttonPresses = 0; // Zählervariable die festhält, wie oft der Knopf bereits gedrückt wurde
LED led = LED(13); // Initialisierung einer LED
void setup()
{
}
void loop()
{
if (button.uniquePress()) // Sobald der Knopf gedrückt wird,
{
buttonPresses = ++buttonPresses % NUMBER_OF_STATES; // wird die Zählervariable erhöht,
// diese im Anschluss auf 0 bis 3 beschränkt
switch(buttonPresses) // und der passende Zustandswechsel eingeleitet.
{
case 0:
ledStateMachine.transitionTo(On); // Bei "0" wird z.B. in den Zustand "On" gewechselt,
break; // welcher im Anschluss die Funktion ledOn aktiviert.
case 1:
ledStateMachine.transitionTo(Off);
break;
case 2:
ledStateMachine.transitionTo(FadeIn);
break;
case 3:
ledStateMachine.transitionTo(FadeOut);
break;
}
}
ledStateMachine.update(); // Permanent den Zustand aktualisieren
}
/***************************************** Ausgelagerte Funktionen **********************************************/
void ledOn() // LED an
{
led.on();
}
void ledOff() // LED aus
{
led.off();
}
void ledFadeIn() // LED fadet ein
{
led.fadeIn(500);
}
void ledFadeOut() // LED fadet aus
{
led.fadeOut(500);
}
Am besten ist bei sowas in den Header schauen. Da sieht man welche Methoden es gibt. Wenn man Glück hat sind sie auch dokumentiert. Manchmal stehen die Kommentare auch in der .cpp Datei. Aber der Header ist erst mal übersichtlicher, da er nur die Deklarationen der Methoden enthält und nicht deren Definition.
Auch gut ist eine IDE mit Autovervollständigung, so dass man schon beim Eintippen sieht was es an Optionen gibt. Obwohl die wenigsten Libs so geschrieben sind, dass da bei eine komplette Beschreibung der Methode anzeigen. Aber man sieht immerhin was an Methoden gibt.
jetzt hab ich doch noch einmal eine Frage bzgl. der FSM Library.
Im Playground steht..
State& getCurrentState()
"Returns the current state"
Ich gehe nun davon aus, dass ich mir mit dieser Funktion den momentanen Zustand eines bestimmten Zustandsautomatens anzeigen lassen kann.
Wenn jetzt mein Zustandsautomat z.B. fsm_01 heisst, wie müsste ich das ganze denn schreiben, wenn ich mir den Zustand über die serielle Schnittstelle anzeigen lassen wollen würde?
