Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

--- hello_mbot_blockierung [2025/02/15 20:24] – torsten.roehl
+++ hello_mbot_blockierung [2025/02/19 19:47] (aktuell) – [Nicht-blockierende Umsetzung] torsten.roehl
@@ Zeile 4: / Zeile 4: @@
 Blockierende Methoden halten die Programmausführung an, bis sie vollständig abgeschlossen sind – während dieser Zeit werden keine anderen Aufgaben bearbeitet. Nicht blockierende Methoden hingegen ermöglichen es, mehrere Prozesse quasi gleichzeitig auszuführen, da sie den Ablauf nicht vollständig unterbrechen, sondern Aufgaben asynchron abarbeiten, beispielsweise durch zeitgesteuerte Überprüfungen.
 //
-===== Blockierende vs. Nicht-blockierende Methoden =====
-^ Methode                ^ Beschreibung                                          ^ Vorteile                              ^ Nachteile                                      ^
+{{ :inf:msr:blocking-nonblocking.png?350 |}}
-| **Blockierend**        | Unterbricht die Programmausführung, bis eine Aufgabe abgeschlossen ist. Beispiel: ''delay()''. |  - Einfach zu schreiben und zu verstehen  |  - Keine parallelen Abläufe möglich  \\ - Verzögerte Reaktion auf Eingaben  |
-| **Nicht-blockierend**  | Führt Aufgaben parallel aus, indem Zeitabläufe gesteuert werden, ohne den Code zu unterbrechen. Beispiel: ''millis()''. |  - Mehrere Prozesse gleichzeitig möglich  \\ - Schnelle Reaktionszeit  |  - Etwas komplexer in der Umsetzung  |
-<note>
-Blockierende Programmierung (mit **delay**) ist oft leichter verständlich und implementierbar, verhindert jedoch parallele Abläufe.
-Nichtblockierende Programmierung (mit **millis**) ermöglicht eine reaktionsfähigere Steuerung, da alle Prozesse nahezu gleichzeitig abgearbeitet werden – was gerade bei zeitkritischen Anwendungen wie dem mBot von Vorteil ist.</note>
+====== Beispiel ======
-===== Problemstellung: Blockierende vs. Nicht-blockierende Steuerung =====
+<WRAP center round tip 80%>
-Ein mBot soll vorwärts fahren und gleichzeitig eine LED blinken lassen. Zusätzlich soll er anhalten, wenn er ein Hindernis erkennt (unter 15 cm Abstand).
+Ein mBot soll sich vorwärts bewegen, während eine LED regelmäßig blinkt. Erkennt der Ultraschallsensor ein Hindernis in weniger als 15 cm Entfernung, soll der Roboter sofort anhalten.
+</WRAP>
-==== Blockierende Umsetzung ====
+===== Blockierende Umsetzung =====
-In einer blockierenden Umsetzung wird ''delay()'' zum Blinken verwendet. Während der Wartezeit kann der mBot keine neuen Sensordaten auslesen. Dadurch kann er erst nach Ablauf der Verzögerung auf ein Hindernis reagieren, was zu einem verspäteten Anhalten führt.
+In einer blockierenden Umsetzung wird ''delay()'' zum Blinken verwendet. Während der Wartezeit kann der mBot keine neuen Sensordaten auslesen. Dadurch kann er erst nach Ablauf der Verzögerung auf ein Hindernis reagieren, was in der Regel zu einem verspäteten Anhalten führt.
-==== Nicht-blockierende Umsetzung ====
+<Code c linenums:1 | Listing 1:MinimalesProgramm.ino>
+#include <MeMCore.h>
+MeDCMotor motor1(M1);
+MeDCMotor motor2(M2);
+MeUltrasonicSensor ultrasonic(PORT_3);
+MeRGBLed led(0, 2);
+double limit = 15; // Grenze 15 cm
+void setup() {
+  led.setpin(13);
+}
+void loop() {
+  double distance = ultrasonic.distanceCm(); // Abstand messen
+  if (distance > limit ) { // freie Fahrt?
+    motor1.run(-255);
+    motor2.run(255);
+    blinken(200);  // blocking method
+  }
+  if (distance <= limit) { // stoppen ?
+    motor1.run(0);
+    motor2.run(0);
+    // LEDs ausschalten
+    led.setColor(0, 0, 0, 0);
+    led.setColor(1, 0, 0, 0);
+    led.show();
+  }
+}
+/*
+ * Funktionen
+ */
+void blinken(int interval) {
+  led.setColor(0, 255, 0, 0); // RGB-LED auf Rot setzen (LED 1)
+  led.setColor(1, 255, 0, 0); // RGB-LED auf Rot setzen (LED 2)
+  led.show();
+  delay(interval);  // Blockiert den Code
+  led.setColor(0, 0, 0, 0);  // RGB-LED ausschalten (LED 1)
+  led.setColor(1, 0, 0, 0);  // RGB-LED ausschalten (LED 2)
+  led.show();
+  delay(interval);  // Blockiert den Code
+}
+</Code>
+<note>
+Nicht immer schafft es der Roboter rechtzeitig zum Stehen zu kommen. In den Tests fuhr er ein paar Mal gegen die Wand, bevor er stoppen konnte. Schuld daran ist die blockierende LED-Steuerung, die während des Blinkens keine neuen Abstandswerte erfasst.
+</note>
+===== Nicht-blockierende Umsetzung =====
 In einer nicht-blockierenden Umsetzung wird die LED mit ''millis()'' gesteuert. Dadurch kann der mBot kontinuierlich Sensordaten auslesen und sofort stoppen, wenn er ein Hindernis erkennt, während die LED unabhängig weiterblinkt.
-==== Vergleich und Vorteile der nicht-blockierenden Methode ====
+<note important>
-  * ✅ **Schnellere Reaktionszeit:** Der Sensor wird ohne Unterbrechung geprüft.
+Beachte, die **loop-Funktionen** sind im Grunde genommen identisch, der einzige Unterschied ist, dass einmal ''blinken'' blockierend und einmal nicht blockierend ist.
-  * ✅ **Parallele Abläufe:** Der mBot kann gleichzeitig fahren, blinken und auf Hindernisse reagieren.
+</note>
-  * ✅ **Effizienter Code:** Keine Verzögerung durch blockierende Wartezeiten.
+<Code c linenums:1 | Listing 1:MinimalesProgramm.ino>
+#include <MeMCore.h>
+MeDCMotor motor1(M1);
+MeDCMotor motor2(M2);
+MeUltrasonicSensor ultrasonic(PORT_3);
+MeRGBLed led(0, 2);
+double limit = 15; // Grenze 15 cm
+// ...drei Variablen für nicht-blockierende Methode!
+unsigned long previousMillis = 0;
+bool ledState = false;
+bool firstRun = true;
+void setup() {
+  led.setpin(13);
+}
+void loop() {
+  double distance = ultrasonic.distanceCm(); // Abstand messen
+  if (distance > limit ) { // freie Fahrt?
+    motor1.run(255);
+    motor2.run(-255);
+    blinken(200); // not-blocking method
+  }
+  if (distance <= limit) { // stoppen?
+    motor1.run(0);
+    motor2.run(0);
+    // LEDs ausschalten, wenn der mBot stoppt
+    led.setColor(0, 0, 0, 0);
+    led.setColor(1, 0, 0, 0);
+    led.show();
+  }
+}
+/*
+ * Funktionen
+ */
+void blinken(int interval) {
+  unsigned long currentMillis = millis();
+  // step: ..in progress
+  if (!firstRun && (currentMillis - previousMillis < interval))
+    return;
+  // step: .. toggle now!
+  firstRun = false;
+  previousMillis = currentMillis;
+  ledState = !ledState;
+  if (ledState) {
+    led.setColor(0, 255, 0, 0); // RGB-LED auf Rot
+    led.setColor(1, 255, 0, 0); // RGB-LED auf Rot
+  } else {
+    led.setColor(0, 0, 0, 0);   // RGB-LED aus
+    led.setColor(1, 0, 0, 0);   // RGB-LED aus
+  }
+  led.show();
+}
+</Code>
+== Erklärungen zum Quellcode ==
+Die Variable ''firstRun'' sorgt dafür, dass das Blinken beim ersten Aufruf sofort startet, statt erst nach dem ersten Intervall zu warten.
+<note>
+In dieser Version wird das Blinken der LEDs nicht blockierend mit ''millis()'' umgesetzt. Dadurch kann der Roboter während des Blinkens weiterhin den Abstandssensor abfragen und schneller auf Hindernisse reagieren. Im Test führte dies dazu, dass der Roboter zuverlässiger rechtzeitig stoppt und nicht mehr gegen die Wand fährt.</note>
+====== Zusammenfassung ======
+Nicht-blockierende Methoden ermöglichen eine effizientere Steuerung des mBots, da Abläufe parallel ausgeführt werden können. Gleichzeitig sind blockierende Methoden einfacher umzusetzen und sind häufig ausreichend.
+^ ''millis'' Vorteile der nicht-blockierenden Methode ^ ''delay'' Vorteile der blockierenden Methode ^
+|✅ **Schnellere Reaktionszeit:** Der Sensor wird kontinuierlich geprüft, sodass der mBot Hindernisse sofort erkennt und rechtzeitig anhalten kann, ohne durch Wartezeiten verzögert zu werden. | ✅ **Einfache Umsetzung:** Der Code ist leicht zu schreiben und zu verstehen, da Abläufe nacheinander ausgeführt werden, ohne komplexe Zeitsteuerung. |
+|✅ **Parallele Abläufe:** Der mBot kann gleichzeitig fahren, blinken und Hindernisse erkennen, da keine Aufgabe den Programmfluss blockiert. Dadurch reagiert das System dynamischer auf Veränderungen in der Umgebung. |✅ **In einfachen Anwendungen ausreichend:** Wenn keine parallelen Abläufe oder schnelle Reaktionen erforderlich sind, kann die blockierende Methode eine pragmatische Lösung sein.   |
+|✅ **Effizienter Code:** Anstatt auf eine feste Wartezeit zu warten, werden Aufgaben zeitgesteuert verarbeitet. So bleibt das System jederzeit aktiv und reaktionsfähig.  | |
+<WRAP center round info 95%>
+**Wann ist welche Methode sinnvoll?**
-➡ **Ziel:** Die nicht-blockierende Variante ermöglicht eine bessere Steuerung des mBots, da sie Sensorabfragen und Motorsteuerung kontinuierlich ausführt.
+Die **blockierende Methode** ist für einfache Abläufe gut geeignet, während die **nicht-blockierende Methode** notwendig wird, wenn mehrere Prozesse gleichzeitig laufen oder schnelle Reaktionen erforderlich sind.</WRAP>