Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- hello_mbot_programmorganisation [2025/02/15 18:44] – torsten.roehl
+++ hello_mbot_programmorganisation [2025/02/27 14:51] (aktuell) – torsten.roehl
@@ Zeile 5: / Zeile 5: @@
 Die Steuerung erfolgt hier mit Hilfe der Infrarot-Fernbedienung.
-Alternativ kann man natürlich auch Bluetooth verwenden. Dies würde auch komplexere Abläufe ermöglichen, da man beispielsweise einen Rechner mit einem Python-Programm als Steuerung verwenden könnte.//
+Alternativ kann man natürlich auch Bluetooth verwenden. Dies würde auch komplexere Abläufe ermöglichen, da man beispielsweise einen Rechner mit einem Python-Programm als Steuerung verwenden könnte.
+Zusätzlich (siehe Beispiel) kann der eingebaute Taster genutzt werden, um einfache Befehle direkt am mBot auszuführen.
+//
 Vorteile einer geordneten Programmstruktur:
@@ Zeile 13: / Zeile 17: @@
   * **Flexibilität:** Unterschiedliche Abläufe (wie Kalibrierung, Labyrinth oder Stopp) können unabhängig voneinander optimiert und getestet werden.
-FIXME  ABSCHNITT SCHREIBEN 8-)
+{{ :inf:msr:programmstruktur.png?450 |}}
+<WRAP center round tip 90%>
+**Finite State Machine (FSM)** ist ein Modell mit einer endlichen Anzahl von Zuständen, das durch Eingaben zwischen diesen wechselt. Sie besteht aus Zuständen, Übergängen und einem Startzustand. FSMs werden in der Informatik und Automatisierung zur Steuerung von Abläufen genutzt.
+</WRAP>
+|Ein endlicher Automat (**Finite State Machine**, <color #7092be>**FSM**</color>) ist ein Modell zur Darstellung von //<color #ff7f27>Zuständen</color>// und deren //<color #ff7f27>Übergängen</color>// basierend auf //<color #ff7f27>Eingaben</color>//. |
+|{{ :inf:msr:fsm.png?300 |}} |
+| Die Abbildung zeigt eine <color #7092be>**FSM**</color> mit drei Zuständen (**S1**, **S2**, **S3**) und Übergängen, die durch Eingaben (**0** oder **1**) gesteuert werden. Beispielsweise wechselt die <color #7092be>**FSM**</color> bei **0** von **S1** nach **S3**, während sie bei **1** von **S1** nach **S2** übergeht. |
+===== Grundstrukur =====
 <code>
 enum State {
-  STATE_IDLE,
+  STATE_A,
-  STATE_CALIBRATION,
+  STATE_B,
-  STATE_LABYRINTH,
+  STATE_C
-  STATE_STOP
 };
+State state = STATE_A;
-State currentState = STATE_IDLE;
 void setup() {
-  // Initialisierung z. B. von IR-Empfänger, Serial, etc.
+  // Initialisierung
 }
 void loop() {
-  byte cmd = readIR(); // Funktion, die IR-Befehle einliest
+  // step: command
+  byte cmd = read(); // Funktion, die Steuer-Befehle einliest
-  // Befehl verarbeiten und ggf. Zustand wechseln
+  // step: state - Befehlsverarbeitungund ggf. Zustand wechseln
-  if (cmd != NO_CMD) {
+  state  = decode(cmd);
-    processCommand(cmd);
+  // step: action
+  switch (state) {
+    case STATE_A:
+         actionA();
+         break;
+    case STATE_B:
+         actionB();
+         break;
+    case STATE_C:
+         actionC();
+         break;
   }
+}
+// ...Implementierung der einzelnen Routinen
-  // Je nach aktuellem Zustand die entsprechende Routine ausführen
+</code>
-  switch (currentState) {
-    case STATE_IDLE:
+Die FSM wird hier an mehreren Punkten deutlich:
-      idleRoutine();
+  * Feste Zustände
-      break;
+          * Die Enumeration definiert eine endliche Menge von Zuständen.
-    case STATE_CALIBRATION:
+  * Zustandsübergänge
-      calibrationRoutine();
+          * Die Funktion decode(cmd) verarbeitet die eingehenden Befehle und ändert den aktuellen Zustand.
+  * Zustandsbasierte Aktionen
+          * Der switch-Block im loop() entscheidet, welche Aktion ausgeführt wird, basierend auf dem aktuellen Zustand.
+Die Methoden (actions) sollten möglichst  **nicht blockierend** sein, da blockierende Aufrufe den Zustandswechsel verzögern und das System an der schnellen Reaktion auf externe Ereignisse hindern. Gerade in zeitkritischen Anwendungen sorgt ein blockierender Zustand dafür, dass Sensorwerte oder Eingaben zu spät verarbeitet werden, was die Zuverlässigkeit und Leistung der gesamten Anwendung beeinträchtigen kann.
+===== Beispiel =====
+<WRAP center round tip 90%>
+Der **mBot** soll in diesem Beispiel die Zustände der LEDs über einen Taster ändern. Bei jedem Tastendruck wechselt die LED zyklisch zwischen drei Zuständen: **aus**, <color #ed1c24>**rot**</color> und <color #22b14c>**grün**</color>. Die Steuerung erfolgt über eine einfache Zustandsmaschine (FSM), die den Tastereingang auswertet und entsprechend die LED-Farbe setzt.
+  * **STATE_OFF** → LED **aus**
+  * **STATE_RED** → <color #ed1c24>LED **rot**</color>
+  * **STATE_GREEN** → <color #22b14c>LED **grün**</color>
+</WRAP>
+==== Quellcode (engl. Sourcecode) ====
+<Code c linenums:1 | Listing 1:MinimalesProgramm.ino>
+#include <MeMCore.h>
+MeRGBLed led(0, 2);   // must be fixed!
+int PIN_BUTTON = 7;   // must be fixed!
+int threshold  = 500; // Analoger Schwellenwert!
+int buttonCount;
+enum State {
+  STATE_OFF,
+  STATE_RED,
+  STATE_GREEN
+};
+State state = STATE_OFF;
+void setup() {
+  led.setpin(13);
+  pinMode(PIN_BUTTON, INPUT);
+  buttonCount = 0;
+}
+void loop() {
+  // step: command
+  int cmd = read();
+  // step: state
+  state  = decode(cmd);
+  // step: action
+  switch (state) {
+    case STATE_RED:
+      actionRed();
       break;
-    case STATE_LABYRINTH:
+    case STATE_GREEN:
-      labyrinthRoutine();
+      actionGreen();
       break;
-    case STATE_STOP:
+    case STATE_OFF:
-      stopRoutine();
+      actionOff();
       break;
   }
 }
-void processCommand(byte cmd) {
-  // Beispiel: Wenn 'f' (als Byte) empfangen wird, dann Stop-Zustand setzen
+/*
-  if (cmd == CMD_STOP) {
+ *   Funktionen
-    currentState = STATE_STOP;
+ */
+bool isButtonPressed() {
+  static bool buttonPressed = false;
+  int value = analogRead(PIN_BUTTON);
+  if (value < threshold) {
+    if (!buttonPressed) {
+      buttonPressed = true;
+      return true;
+    }
+  } else {
+    buttonPressed = false; // Button wurde losgelassen
   }
-  // Hier können weitere Befehle verarbeitet werden,
+  return false;
-  // z. B. Übergang in den Kalibrierungs- oder Labyrinthmodus.
 }
-// Implementierung der einzelnen Routinen
+int read() {
-void idleRoutine() {
+  if ( isButtonPressed() )
-  // Standardverhalten im Leerlauf
+    buttonCount += 1;
+  if (buttonCount > 2)
+    buttonCount = 0;
+  return buttonCount;
 }
-void calibrationRoutine() {
-  // Abläufe für den Kalibrierungsmodus
+State decode(int cmd) {
+  switch (cmd) {
+    case 1: return STATE_RED;
+    case 2: return STATE_GREEN;
+  }
+  return STATE_OFF;
 }
-void labyrinthRoutine() {
+void actionRed() {
-  // Abläufe für den Labyrinthmodus
+  led.setColorAt(1, 255, 0, 0);
+  led.setColorAt(0, 255, 0, 0);
+  led.show();
 }
-void stopRoutine() {
+void actionGreen() {
-  // Not-Aus oder Stopp-Verhalten, ggf. Warteschleife
+  led.setColorAt(1, 0, 255, 0);
+  led.setColorAt(0, 0, 255, 0);
+  led.show();
 }
-</code>
+void actionOff() {
+  led.setColorAt(1, 0, 0, 0);
+  led.setColorAt(0, 0, 0, 0);
+  led.show();
+}
+</Code>
+=== Erklärungen zum Quellcode ===
+  - Der Taster wird über ''analogRead(PIN_BUTTON)'' ausgelesen.
+  - Die Funktion'' isButtonPressed()'' erkennt den Tastendruck und verhindert mehrfaches Zählen (Entprellung).
+  - Die Funktion ''read()'' zählt die Tasterbetätigungen und wechselt durch die Zustände:
+          -  **OFF → RED → GREEN → OFF**.
+  - Die Funktion ''decode(cmd)'' wandelt den Zählerwert in einen **State** um.
+  - Die entsprechenden **LED-Funktionen** setzen die LED-Farbe je nach Zustand.
+Das Programm ermöglicht eine einfache Steuerung einer LED über einen Taster mit einer **Zustandsmaschine**.