Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- hello_mbot_kalibrierung [2025/02/18 15:11] – torsten.roehl
+++ hello_mbot_kalibrierung [2025/02/19 19:55] (aktuell) – [Bedienung] torsten.roehl
@@ Zeile 1: / Zeile 1: @@
 ====== Hello mBot Kalibrierung ======
-FIXME  Abschnitt entsteht gerade!
@@ Zeile 11: / Zeile 11: @@
 {{ :inf:msr:kalibrierung.png?450 |}}
-====== erste (einfache) Variante  ======
+====== 90°-Drehung: erste (einfache) Variante  ======
 <WRAP center round tip 90%>
 Dieses Programm ermöglicht eine **90-Grad-Drehung** des mBot.
@@ Zeile 26: / Zeile 26: @@
   * Falls sich der mBot zu weit dreht → ''turn_time'' verringern.
   * Falls sich der mBot zu wenig dreht → ''turn_time'' erhöhen.
-  * Der optimale Wert wird durch Tests ermittelt.
+  * <color #ff7f27>Der optimale Wert muss durch Tests experimentell ermittelt werden.</color>
 ==== Quellcode (engl. Sourcecode) ====
@@ Zeile 57: / Zeile 57: @@
 === Vorteile & Nachteile ===
-^  Vorteil ^  Nachteil ^
+^Vorteil ^Nachteil^
 | ✅ Einfach zu implementieren und gut für Programmieranfänger geeignet. | ❌ Manuelle Kalibrierung ist aufwendig. |
 |   | ❌ Bei schwächer werdender Batterie muss die Drehzeit erneut angepasst werden. |
@@ Zeile 63: / Zeile 63: @@
-====== zweite (komplexere) Variante ======
+====== 90°-Drehung: zweite (komplexere) Variante ======
 <WRAP center round tip 90%>
@@ Zeile 73: / Zeile 73: @@
 Nach der Kalibrierung kann der Roboter getestet werden.
+**
+Dieses Programm verwendet eine einfache Tastensteuerung – einmal zur Kalibrierung und danach zum Testen der Kalibrierung. Es dient lediglich als Beispiel, um das Prinzip zu veranschaulichen.**
 </WRAP>
+^Idee^
 |{{ :inf:msr:mbot.png?200 |}}|
-|Dargestellt ist der **mBot**, der auf einem schwarzen L (90 Grad) steht.Dies ist die Ausgangskonfiguration für die Kalibrierung. Der Roboter dreht sich so lange gegen den Uhrzeigersinn, bis er exakt auf der schwarzen Linie steht. Dabei wird die benötigte Zeit gestoppt. Beim Zurückdrehen passiert dasselbe. Anschließend wird der Mittelwert gebildet. Dadurch kann sich der **mBot** selbstständig auf 90-Grad-Kurven kalibrieren.Auf diese Weise kann sich der Roboter immer wieder selbst kalibrieren, falls sich z. B. der Akkuladestand ändert und dadurch die Motorleistung variiert.Falls der **mBot** mehrmals hintereinander kalibriert, könnte er einen noch genaueren Mittelwert berechnen.|
+|<WRAP>
+Der **mBot** befindet sich auf einem **schwarzen L** (90-Grad-Winkel) als Referenz.
+Der Roboter dreht sich gegen den Uhrzeigersinn, bis er exakt auf der schwarzen Linie steht, und misst die benötigte Zeit.
+Beim Zurückdrehen wird die Zeit erneut erfasst.
+Aus beiden Werten wird der Mittelwert gebildet, wodurch sich der **mBot** selbstständig auf 90-Grad-Kurven kalibriert.
+Auf diese Weise kann er sich immer wieder automatisch anpassen, falls sich z. B. der Akkuladestand ändert und die Motorleistung variiert.
+Durch mehrfaches Kalibrieren ließe sich ein noch präziserer Mittelwert berechnen.
+</WRAP>|
-=== Funktionsweise ===
-  * Die FSM steuert den Kalibrierungsprozess basierend auf Benutzereingaben.
-  * Der mBot führt eine Drehung aus und passt die Drehzeit automatisch an.
-  * Nach erfolgreicher Kalibrierung kann die Drehung getestet werden.
-Dieses Programm verwendet eine einfache Tastensteuerung – einmal zur Kalibrierung und danach zum Testen der Kalibrierung. Es dient lediglich als Beispiel, um das Prinzip zu veranschaulichen.
 ==== Quellcode (engl. Sourcecode) ====
 <Code c linenums:1 | Listing 1:MinimalesProgramm.ino>
+#include "MeMCore.h"
+// Hardware
+MeBuzzer buzzer;
+MeLineFollower lineFinder(PORT_2);
+MeRGBLed led(0, 2);   // must be fixed!
+MeDCMotor motor1(M1);
+MeDCMotor motor2(M2);
+int PIN_BUTTON = 7;   // must be fixed!
+int threshold  = 500; // Analoger Schwellenwert!
+int buttonCount;
+// Allgemein
+int speed = 100; // Motor speed
+unsigned long time90degree;
+// turn90Degree...
+bool t90d_isTurning = false;
+unsigned long t90d_turnStartTime = 0;
+// actionCalibration...
+unsigned long ac_turnStartTimeLeft  = 0;
+unsigned long ac_turnTimeLeft = 0;
+unsigned long ac_turnStartTimeRight = 0;
+unsigned long ac_turnTimeRight = 0;
+bool ac_isTurning = false;
+bool ac_isLeftTurning = false;
+bool ac_isRightTurning = false;
+bool ac_calibrationDone = false;
+//actionTest...
+bool at_doneLeft = false;
+bool at_doneRight = false;
+bool at_testComplete = false;
+enum State {
+  STATE_OFF,
+  STATE_CALIBRATION,
+  STATE_TEST
+};
+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_CALIBRATION:
+      actionCalibration();
+      break;
+    case STATE_TEST:
+      actionTest();
+      break;
+    case STATE_OFF:
+      actionOff();
+      break;
+  }
+}
+/*
+     Funktionen
+*/
+bool turn90Degree(bool left) {
+  // step: ...start turning
+  if (!t90d_isTurning) {
+    motor1.stop();
+    motor2.stop();
+    t90d_isTurning     = true;
+    int dir = left ? 1 : -1;
+    motor1.run(dir * speed);
+    motor2.run(dir * speed);
+    t90d_turnStartTime = millis();
+    return false;
+  }
+  // step: ...in progress
+  if (millis() - t90d_turnStartTime < time90degree)
+    return false;
+  // step: ... finished
+  motor1.stop();
+  motor2.stop();
+  t90d_isTurning = false;
+  return true;
+}
+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
+  }
+  return false;
+}
+int read() {
+  if ( isButtonPressed() )
+    buttonCount += 1;
+  if (buttonCount > 2)
+    buttonCount = 0;
+  return buttonCount;
+}
+State decode(int cmd) {
+  switch (cmd) {
+    case 1: return STATE_CALIBRATION;
+    case 2: return STATE_TEST;
+  }
+  return STATE_OFF;
+}
+void actionCalibration() {
+  if (ac_calibrationDone)
+    return;
+  led.setColorAt(1, 255, 0, 0);
+  led.setColorAt(0, 255, 0, 0);
+  led.show();
+  int sensorState = lineFinder.readSensors();
+  // step - start turning left
+  if (!ac_isTurning) {
+    motor1.stop();
+    motor2.stop();
+    motor1.run(speed);
+    motor2.run(speed);
+    ac_turnStartTimeLeft = millis();
+    ac_isTurning = true;
+    ac_isRightTurning = true;
+    do {
+      sensorState = lineFinder.readSensors();
+    } while ( sensorState != S1_OUT_S2_OUT);
+  }
+  // step - end turning left ... start turning right
+  if (ac_isRightTurning && sensorState == S1_IN_S2_IN) {
+    motor1.stop();
+    motor2.stop();
+    ac_turnTimeLeft = millis() - ac_turnStartTimeLeft;
+    motor1.run(-speed);
+    motor2.run(-speed);
+    ac_turnStartTimeRight = millis();
+    do {
+      sensorState = lineFinder.readSensors();
+    } while ( sensorState != S1_OUT_S2_OUT);
+    ac_isRightTurning = false;
+    ac_isLeftTurning = true;
+  }
+  // step - end turing right
+  if (ac_isLeftTurning && sensorState == S1_IN_S2_IN) {
+    motor1.stop();
+    motor2.stop();
+    ac_turnTimeRight = millis() - ac_turnStartTimeRight;
+    time90degree = (ac_turnTimeLeft + ac_turnTimeRight) / 2.0;
+    ac_calibrationDone = true;
+    led.setColorAt(1, 0, 0, 0);
+    led.setColorAt(0, 0, 0, 0);
+    led.show();
+    buzzer.tone(1200, 600);
+  }
+}
+void actionTest() {
+  if (!at_doneLeft) { // Links-Drehung
+    at_doneLeft = turn90Degree(true);
+    led.setColorAt(1, 0, 255, 0);
+    led.setColorAt(0, 0, 255, 0);
+    led.show();
+    return;
+  }
+  if (!at_doneRight) { // Rechts-Drehung
+    at_doneRight = turn90Degree(false);
+    return;
+  }
+  if (!at_testComplete) { // fertig
+    motor1.stop();
+    motor2.stop();
+    led.setColorAt(1, 0, 0, 0);
+    led.setColorAt(0, 0, 0, 0);
+    led.show();
+    buzzer.tone(1200, 600);
+    at_testComplete = true;
+    return;
+  }
+}
+void actionOff() {
+  led.setColorAt(1, 0, 0, 0);
+  led.setColorAt(0, 0, 0, 0);
+  led.show();
+  // reset
+  motor1.stop();
+  motor2.stop();
+  // reset state calibration
+  ac_isTurning = false;
+  ac_isLeftTurning = false;
+  ac_isRightTurning = false;
+  ac_calibrationDone = false;
+  // reset state test
+  at_doneLeft = false;
+  at_doneRight = false;
+  at_testComplete = false;
+}
 </Code>
 ==== Bedienung ====
@@ Zeile 97: / Zeile 335: @@
 ⚡ **Schritt 1:**
-▶ **Drücken des Tasters** → **Rote LEDs leuchten**
+▶ **Drücken des Tasters** → **LEDs werden <color #ed1c24>rot</color>**
    * Die **Kalibrierung** startet.
    * Nach Abschluss der Kalibrierung **erlöschen die LEDs**.
 ⚡ **Schritt 2:**
-▶ **Erneutes Drücken des Tasters** → **LEDs werden grün**
+▶ **Erneutes Drücken des Tasters** → **LEDs werden <color #22b14c>grün</color>**
    * Der **Testlauf** beginnt.
+   * Nach Abschluss des Testlaufs **erlöschen die LEDs**.
 ⚡ **Schritt 3:**
-▶ **Nach dem Testlauf** kehrt der mBot in den **Ruhezustand** zurück.
+▶ **Nach dem Testlauf** kehrt der mBot durch Drückens des Tasters in den **Ruhezustand** zurück.
    * Der Vorgang kann **von vorne** gestartet werden.