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.

code noch nicht getestet

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.

<code>
#include <MeMCore.h>

MeDCMotor motorLeft(M1);
MeDCMotor motorRight(M2);
MeUltrasonicSensor ultrasonic(PORT_3); // Ultraschallsensor an Port 3
MeRGBLed led(0, 2);   // RGB-LED am mBot (Port 0, 2 LEDs)
int PIN_LED = 13;     // Standard-LED-Pin

void setup() {
  led.setpin(PIN_LED); // Richtige Initialisierung der LED
}

void loop() {
  int distance = ultrasonic.distanceCm(); // Abstand messen

  if (distance > 15 || distance == 0) { // Falls kein Hindernis erkannt
    motorLeft.run(200);
    motorRight.run(200);
    
    // LEDs dauerhaft blinken, solange der mBot fährt
    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(200);  // Blockiert den Code für 200 ms

    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(200);  // Blockiert erneut für 200 ms
  } else {
    motorLeft.run(0);
    motorRight.run(0);
    
    // LEDs ausschalten
    led.setColor(0, 0, 0, 0);
    led.setColor(1, 0, 0, 0);
    led.show();
  }
}
</code>

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.

#include <MeMCore.h>

MeDCMotor motorLeft(M1);
MeDCMotor motorRight(M2);
MeUltrasonicSensor ultrasonic(PORT_3); // Ultraschallsensor an Port 3
MeRGBLed led(0, 2);   // RGB-LED am mBot (Port 0, 2 LEDs)
int PIN_LED = 13;     // Standard-LED-Pin

unsigned long previousMillis = 0;
const unsigned long blinkInterval = 200;  // Blinken alle 200 ms
bool ledState = false;

void setup() {
  led.setpin(PIN_LED); // Richtige Initialisierung der LED
}

void loop() {
  int distance = ultrasonic.distanceCm(); // Abstand messen

  if (distance > 15 || distance == 0) { // Falls kein Hindernis oder Sensorfehler
    motorLeft.run(200);
    motorRight.run(200);
    updateBlink(true);  // LEDs blinken nur während der Fahrt
  } else {
    motorLeft.run(0);
    motorRight.run(0);
    updateBlink(false); // LEDs ausschalten, wenn der mBot stoppt
  }
}

void updateBlink(bool shouldBlink) {
  unsigned long currentMillis = millis();

  if (shouldBlink) {
    if (currentMillis - previousMillis >= blinkInterval) {
      previousMillis = currentMillis;
      ledState = !ledState;

      if (ledState) {
        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)
      } else {
        led.setColor(0, 0, 0, 0);     // RGB-LED ausschalten (LED 1)
        led.setColor(1, 0, 0, 0);     // RGB-LED ausschalten (LED 2)
      }
      led.show();
    }
  } else {
    led.setColor(0, 0, 0, 0); // Beide LEDs ausschalten
    led.setColor(1, 0, 0, 0);
    led.show();
  }
}

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 ist häufig ausreichend.

✅ 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.

✅ 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.

✅ Effizienter Code: Anstatt auf eine feste Wartezeit zu warten, werden Aufgaben zeitgesteuert verarbeitet. So bleibt das System jederzeit aktiv und reaktionsfähig.

✅ Einfache Umsetzung: Der Code ist leicht zu schreiben und zu verstehen, da Abläufe nacheinander ausgeführt werden, ohne komplexe Zeitsteuerung.

✅ In einfachen Anwendungen ausreichend: Wenn keine parallelen Abläufe oder schnelle Reaktionen erforderlich sind, kann die blockierende Methode eine pragmatische Lösung sein.

⚠ Blockierend: Verzögerungen durch Wartezeiten, keine parallelen Abläufe möglich.

⚠ Nicht-blockierend: Erfordert eine etwas komplexere Programmstruktur mit Zeitsteuerung durch millis().