informatics4kids.de

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
hello_mbot_blockierung

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
hello_mbot_blockierung [2025/02/16 08:36] – [Nicht-blockierende Umsetzung] torsten.roehlhello_mbot_blockierung [2025/02/19 19:47] (aktuell) – [Nicht-blockierende Umsetzung] torsten.roehl
Zeile 5: Zeile 5:
 // //
  
-FIXME code noch nicht getestet +{{ :inf:msr:blocking-nonblocking.png?350 |}}
  
 ====== Beispiel ====== ====== Beispiel ======
Zeile 21: Zeile 21:
 MeDCMotor motor1(M1); MeDCMotor motor1(M1);
 MeDCMotor motor2(M2); MeDCMotor motor2(M2);
-MeUltrasonicSensor ultrasonic(PORT_3);  +MeUltrasonicSensor ultrasonic(PORT_3); 
-MeRGBLed led(0, 2);   +MeRGBLed led(0, 2);
 double limit = 15; // Grenze 15 cm double limit = 15; // Grenze 15 cm
  
 void setup() { void setup() {
-  led.setpin(13); +  led.setpin(13);
 } }
  
Zeile 35: Zeile 35:
     motor1.run(-255);     motor1.run(-255);
     motor2.run(255);     motor2.run(255);
-     +    blinken(200);  // blocking method 
-    // LEDs dauerhaft blinken, solange der mBot fährt +  }   
-    led.setColor(0, 255, 0, 0);   // RGB-LED auf Rot setzen (LED 1) +  if (distance <= limit) { // stoppen ?
-    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 +
-  } +
-  if(distance <= limit) { // stoppen ?+
     motor1.run(0);     motor1.run(0);
     motor2.run(0);     motor2.run(0);
-     
     // LEDs ausschalten     // LEDs ausschalten
     led.setColor(0, 0, 0, 0);     led.setColor(0, 0, 0, 0);
Zeile 56: Zeile 45:
     led.show();     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> </Code>
Zeile 61: Zeile 65:
 <note> <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. 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.
-einfache zentrierte Box</note>+</note>
  
 ===== Nicht-blockierende Umsetzung ===== ===== 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. 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.
 +
 +<note important>
 +Beachte, die **loop-Funktionen** sind im Grunde genommen identisch, der einzige Unterschied ist, dass einmal ''blinken'' blockierend und einmal nicht blockierend ist.
 +</note>
 +
 +
 <Code c linenums:1 | Listing 1:MinimalesProgramm.ino> <Code c linenums:1 | Listing 1:MinimalesProgramm.ino>
 #include <MeMCore.h> #include <MeMCore.h>
Zeile 75: Zeile 85:
 double limit = 15; // Grenze 15 cm double limit = 15; // Grenze 15 cm
  
 +// ...drei Variablen für nicht-blockierende Methode! 
 unsigned long previousMillis = 0; unsigned long previousMillis = 0;
 bool ledState = false; bool ledState = false;
Zeile 89: Zeile 100:
     motor1.run(255);     motor1.run(255);
     motor2.run(-255);     motor2.run(-255);
-    blinken(200);+    blinken(200); // not-blocking method
   }   }
   if (distance <= limit) { // stoppen?   if (distance <= limit) { // stoppen?
Zeile 100: Zeile 111:
   }   }
 } }
 +/*
 + * Funktionen
 + */
 +void blinken(int interval) {
  
-void blinken(int interval) { 
   unsigned long currentMillis = millis();   unsigned long currentMillis = millis();
  
-  if (currentMillis - previousMillis >= interval || firstRun) { +  // step: ..in progress 
-    firstRun = false; +  if (!firstRun && (currentMillis - previousMillis < interval)) 
-    previousMillis = currentMillis; +    return;
-    ledState = !ledState;+
  
-    if (ledState) { +  // step: .. toggle now! 
-      led.setColor(0, 255, 0, 0); // RGB-LED auf Rot setzen (LED 1) +  firstRun = false; 
-      led.setColor(1, 255, 0, 0); // RGB-LED auf Rot setzen (LED 2) +  previousMillis = currentMillis; 
-    } else { +  ledState = !ledState;
-      led.setColor(0, 0, 0, 0);   // RGB-LED ausschalten (LED 1) +
-      led.setColor(1, 0, 0, 0);   // RGB-LED ausschalten (LED 2) +
-    } +
-    led.show(); +
-  }+
  
 +  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> </Code>
-<note> +== Erklärungen zum Quellcode ==
-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> +
-===== Vor- und Nachteile blockierender und nicht-blockierender Methoden =====+
  
-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. 
  
-=== Vorteile der nicht-blockierenden Methode === +Die Variable ''firstRun'' sorgt dafür, dass das Blinken beim ersten Aufruf sofort startet, statt erst nach dem ersten Intervall zu warten.
-✅ **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.  +<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 ======
  
-✅ **Effizienter Code:** Anstatt auf eine feste Wartezeit zu warten, werden Aufgaben zeitgesteuert verarbeitet. So bleibt das System jederzeit aktiv und reaktionsfähig.  +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.
  
-=== Vorteile der blockierenden Methode === 
-✅ **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.  +^ ''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.  | | 
  
  
hello_mbot_blockierung.1739695008.txt.gz · Zuletzt geändert: 2025/02/16 08:36 von torsten.roehl