informatics4kids.de

Benutzer-Werkzeuge

Webseiten-Werkzeuge

Zuletzt angesehen:
mbot_streckenfahren

Unterschiede

Hier werden die Unterschiede zwischen zwei Versionen angezeigt.

Link zu dieser Vergleichsansicht

Beide Seiten der vorigen RevisionVorhergehende Überarbeitung
Nächste Überarbeitung		Vorhergehende Überarbeitung
mbot_streckenfahren [2025/03/02 07:05] – [Quellcode (engl. Sourcecode)] torsten.roehlmbot_streckenfahren [2025/03/02 14:38] (aktuell) – [Erklärungen zum Quellcode] torsten.roehl
Zeile 1: Zeile 1:
 ====== mBot Streckenfahren ====== ====== mBot Streckenfahren ======
- 
-FIXME  <color #ed1c24>ABSCHNITT ENTSTEHT GERADE! - CODE NICHT GETESTET! 
-</color> 
- 
 //Der mBot kann, gesteuert über die Infrarot-Fernbedienung, eine zuvor eingegebene Strecke vorwärts oder rückwärts fahren. //Der mBot kann, gesteuert über die Infrarot-Fernbedienung, eine zuvor eingegebene Strecke vorwärts oder rückwärts fahren.
  
Zeile 392: Zeile 388:
 <WRAP center round tip 95%>Falls der Roboter nicht sauber geradeaus fährt, lässt sich das Programm dank seiner modularen Struktur leicht erweitern. Es ist möglich, eine zusätzliche Kalibriermethode zu implementieren, die sicherstellt, dass der Roboter präzise geradeaus fährt.“ <WRAP center round tip 95%>Falls der Roboter nicht sauber geradeaus fährt, lässt sich das Programm dank seiner modularen Struktur leicht erweitern. Es ist möglich, eine zusätzliche Kalibriermethode zu implementieren, die sicherstellt, dass der Roboter präzise geradeaus fährt.“
 </WRAP> </WRAP>
 +
  
 ==== Quellcode (engl. Sourcecode) ==== ==== Quellcode (engl. Sourcecode) ====
Zeile 407: Zeile 404:
  
 // IR-Entprellen // IR-Entprellen
-static uint8_t lastCode = 0xFF;+static uint8_t lastCode       = 0xFF;
 static unsigned long lastTime = 0; static unsigned long lastTime = 0;
 const unsigned long COOL_DOWN = 1000; // in Millisekunden, also 1 Sekunde const unsigned long COOL_DOWN = 1000; // in Millisekunden, also 1 Sekunde
Zeile 416: Zeile 413:
  
 // ADJUST AREA START // ADJUST AREA START
-int calibrationDistance = 40; // cm +int calibrationDistance = 40;  // in cm 
-int speed = 180; // Motor speed+int speed               = 200; // Motor speed 
 +int dir                 = 1;   // change to -1 if forward drive backwards!
 // ADJUST AREA END // ADJUST AREA END
  
 // actionCalibration... // actionCalibration...
 unsigned long ac_movingStartTimeForward  = 0; unsigned long ac_movingStartTimeForward  = 0;
-unsigned long ac_movingTimeForward = 0;+unsigned long ac_movingTimeForward       = 0;
 unsigned long ac_movingStartTimeBackward = 0; unsigned long ac_movingStartTimeBackward = 0;
-unsigned long ac_movingTimeBackward = 0; +unsigned long ac_movingTimeBackward      = 0; 
-bool ac_isMoving = false; +bool ac_isMoving         = false; 
-bool ac_isForwardMoving = false;+bool ac_isForwardMoving  = false;
 bool ac_isBackwardMoving = false; bool ac_isBackwardMoving = false;
-bool ac_calibrationDone = false;+bool ac_calibrationDone  = false;
  
-// actionForward +// motor movement 
-bool af_firstRunMotor = true;     // erstes Starten? +bool mm_firstRunMotor = true; 
-bool af_motorActive   = false;    // Motorzustand? +bool mm_motorActive   = false; 
-unsigned long af_motorStartTime = 0; +unsigned long mm_motorStartTime = 0;
-// actionBackward +
-bool ab_firstRunMotor = true;     // erstes Starten? +
-bool ab_motorActive   = false;    // Motorzustand? +
-unsigned long ab_motorStartTime = 0;+
  
 //FSM //FSM
Zeile 456: Zeile 450:
 }; };
 ExState exState       = EX_IDLE; ExState exState       = EX_IDLE;
 +
 int     inputNumber   = 0;    // Anzahl der eingegebenen Stellen int     inputNumber   = 0;    // Anzahl der eingegebenen Stellen
 String  inputBuffer   = "";   // Sammeln der Ziffern als Text String  inputBuffer   = "";   // Sammeln der Ziffern als Text
Zeile 462: Zeile 457:
 void setup() { void setup() {
   led.setpin(13);   led.setpin(13);
-  Serial.begin(9600);+  //Serial.begin(9600);  // debugging
   ir.begin();   ir.begin();
 } }
Zeile 496: Zeile 491:
   ---------------------------   ---------------------------
 */ */
 +void setLED(int r, int g, int b) {
 +  led.setColorAt(0, r, g, b);
 +  led.setColorAt(1, r, g, b);
 +  led.show();
 +}
  
 int read() { int read() {
   if (ir.decode()) {   if (ir.decode()) {
     uint32_t code = getIRCode();     uint32_t code = getIRCode();
 +
     // Vermeidung wiederholter Eingaben     // Vermeidung wiederholter Eingaben
     unsigned long now = millis();     unsigned long now = millis();
Zeile 506: Zeile 507:
     lastCode = code;     lastCode = code;
     lastTime = now;     lastTime = now;
 +
     //     //
     switch (code) {     switch (code) {
Zeile 575: Zeile 577:
       return STATE_FORWARD;       return STATE_FORWARD;
   }   }
- 
   return lastState;   return lastState;
 } }
Zeile 589: Zeile 590:
   inputNumber = 0;   inputNumber = 0;
   inputBuffer = "";   inputBuffer = "";
 +  setLED(0, 0, 255); // LED BLUE
 } }
  
Zeile 613: Zeile 615:
     exState = EX_IDLE;     exState = EX_IDLE;
     buzzer.tone(1200, 200);     buzzer.tone(1200, 200);
 +    setLED(0, 0, 0); // LED OFF
   }   }
 } }
Zeile 621: Zeile 624:
   ---------------------------   ---------------------------
 */ */
- 
 void actionCalibration() { void actionCalibration() {
  
Zeile 627: Zeile 629:
     return;     return;
  
-  led.setColorAt(1, 255, 0, 0); +  setLED(255, 0, 0); // RED ON
-  led.setColorAt(0, 255, 0, 0); +
-  led.show();+
   int sensorState = lineFinder.readSensors();   int sensorState = lineFinder.readSensors();
  
Zeile 636: Zeile 636:
     motor1.stop();     motor1.stop();
     motor2.stop();     motor2.stop();
-    motor1.run(-speed); +    motor1.run(-dir * speed); 
-    motor2.run(speed);+    motor2.run( dir * speed); 
     ac_movingStartTimeForward = millis();     ac_movingStartTimeForward = millis();
     ac_isMoving = true;     ac_isMoving = true;
Zeile 651: Zeile 652:
     motor2.stop();     motor2.stop();
     ac_movingTimeForward = millis() - ac_movingStartTimeForward;     ac_movingTimeForward = millis() - ac_movingStartTimeForward;
- +    motor1.run( dir * speed); 
-    motor1.run(speed); +    motor2.run(-dir * speed);
-    motor2.run(-speed);+
     ac_movingStartTimeBackward = millis();     ac_movingStartTimeBackward = millis();
     do {     do {
Zeile 669: Zeile 669:
     calibrationTravelTime = (ac_movingTimeForward + ac_movingTimeBackward) / 2.0;     calibrationTravelTime = (ac_movingTimeForward + ac_movingTimeBackward) / 2.0;
     ac_calibrationDone = true;     ac_calibrationDone = true;
-    led.setColorAt(1, 0, 0, 0); 
-    led.setColorAt(0, 0, 0, 0); 
-    led.show(); 
     buzzer.tone(1200, 600);     buzzer.tone(1200, 600);
     lastState = STATE_OFF;     lastState = STATE_OFF;
- 
   }   }
 } }
  
-void actionForward() {+void motorMovement(int go_forward ) {
   unsigned long currentMillis = millis();   unsigned long currentMillis = millis();
  
   // Wenn der Motor aktuell läuft, prüfen wir, ob die Zeit abgelaufen ist   // Wenn der Motor aktuell läuft, prüfen wir, ob die Zeit abgelaufen ist
-  if (af_motorActive) { +  if (mm_motorActive) { 
-    if (currentMillis - af_motorStartTime >= currentTravelTime) { +    if (currentMillis - mm_motorStartTime >= currentTravelTime) {
-      // Zeit ist um → Motor stoppen+
       motor1.stop();       motor1.stop();
       motor2.stop();       motor2.stop();
-      af_motorActive = false; +      mm_motorActive = false; 
-      state = STATE_OFF; +      state          = STATE_OFF; 
-      lastState = STATE_OFF;+      lastState      = STATE_OFF;
     }     }
-    // Funktion verlassen 
     return;     return;
   }   }
  
-  if (!af_firstRunMotor)+  if (!mm_firstRunMotor)
     return;     return;
  
-  motor1.run(-speed); +  setLED(0, 255, 0); // LED GREEN 
-  motor2.run(speed); +  motor1.run(-go_forward * speed); 
-  af_motorStartTime = currentMillis; +  motor2.run( go_forward * speed); 
-  af_motorActive    = true; + 
-  af_firstRunMotor  = false;+  mm_motorStartTime = currentMillis; 
 +  mm_motorActive    = true; 
 +  mm_firstRunMotor  = false;
 } }
  
 +void actionForward() {
 +  motorMovement(dir);
 +}
 void actionBackward() { void actionBackward() {
-  unsigned long currentMillis = millis(); +  motorMovement(-dir);
- +
-  // Wenn der Motor aktuell läuft, prüfen wir, ob die Zeit abgelaufen ist +
-  if (ab_motorActive) { +
-    if (currentMillis - ab_motorStartTime >= currentTravelTime) { +
-      // Zeit ist um → Motor stoppen +
-      motor1.stop(); +
-      motor2.stop(); +
-      ab_motorActive = false; +
-      state = STATE_OFF; +
-      lastState = STATE_OFF; +
-    } +
-    // Funktion verlassen +
-    return; +
-  } +
- +
-  if (!ab_firstRunMotor) +
-    return; +
-     +
-  motor1.run(speed); +
-  motor2.run(-speed); +
-  ab_motorStartTime = currentMillis; +
-  ab_motorActive    = true; +
-  ab_firstRunMotor  = false; +
 } }
  
Zeile 736: Zeile 711:
   //Serial.println("...actionDistance");   //Serial.println("...actionDistance");
   // noch in der Eingabe?   // noch in der Eingabe?
-  if (exState == EX_WAIT_FOR_INPUT) {+  if (exState == EX_WAIT_FOR_INPUT)
     return;     return;
-  }+
   // step: ...calculate distance   // step: ...calculate distance
-  inputDistance = inputBuffer.toInt(); +  inputDistance = max(0, min(200, inputBuffer.toInt())); 
-  if (inputDistance > 200) { +
-    inputDistance = 200; +
-  }+
   // step: calculate the travel time (for non blocking-method)   // step: calculate the travel time (for non blocking-method)
   double v = (1.0 * calibrationDistance) / (1.0 * calibrationTravelTime);   double v = (1.0 * calibrationDistance) / (1.0 * calibrationTravelTime);
Zeile 752: Zeile 725:
  
 void actionOff() { void actionOff() {
-  led.setColorAt(1, 0, 0, 0); +  setLED(0, 0, 0); // LED OFF
-  led.setColorAt(0, 0, 0, 0); +
-  led.show();+
   // reset   // reset
   motor1.stop();   motor1.stop();
Zeile 765: Zeile 736:
   ac_calibrationDone  = false;   ac_calibrationDone  = false;
  
-  // reset state forward +  // reset movement 
-  af_firstRunMotor = true; +  mm_firstRunMotor    = true; 
-  af_motorActive   = false; +  mm_motorActive      = false; 
-  af_motorStartTime = 0; +  mm_motorStartTime   = 0; 
-  // reset state backward +
-  ab_firstRunMotor = true; +
-  ab_motorActive   = false; +
-  ab_motorStartTime = 0;+
   // reset state distance   // reset state distance
   exState       = EX_IDLE;   exState       = EX_IDLE;
 } }
 </Code> </Code>
-==== Quellcode (engl. Sourcecode) ====+==== Erklärungen zum Quellcode ==== 
 +=== ⚙️ Setup (setup()) === 
 +Initialisiert die IR-Fernbedienung und setzt den LED-Pin.   
 +  * ''ir.begin()'' → Startet die IR-Signalverarbeitung.   
 +  * ''led.setpin(13)'' → Setzt den LED-Steuerpin.  
  
-<Code c linenums:1 | Listing 1:MinimalesProgramm.ino> +=== 🔄 Loop (loop()) === 
-#include "MeMCore.h"+  - **Liest IR-Signale (''read()'')**   
 +  - **Bestimmt den aktuellen Zustand (''decode()'')**   
 +  - **Führt die passende Aktion aus (`actionXXX()`)**  
  
-// Hardware +=== 🚦 Zustandsbezogene Aktionen (actionXXX()) ==== 
-MeIR ir; +  * **''actionForward()'' / ''actionBackward()''** → startet Motoren für Vorwärts-/Rückwärtsfahrt.   
-MeBuzzer buzzer; +  * **''actionDistance()''** → Berechnet die Fahrtzeit basierend auf eingegebener Distanz.   
-MeLineFollower lineFinder(PORT_2); +  * **''actionCalibration()''** → Bestimmt die Fahrzeit für eine feste Strecke mit dem Linienfolger.   
-MeRGBLed led(0, 2);   // must be fixed! +  * **''actionOff()''** → Stoppt alle Motoren und setzt den Zustand zurück.  
-MeDCMotor motor1(M1); +
-MeDCMotor motor2(M2);+
  
-// IR-Entprellen +=== ⌨️ Eingabeverarbeitung (handleInput(), finalizeInput()) === 
-static uint8_t lastCode = 0xFF; +  - Ermöglicht die Eingabe einer numerischen Distanz per IR-Fernbedienung.   
-static unsigned long lastTime = 0; +  - ''handleInput(int number)'' → Fügt eine Zahl zur Eingabe hinzu.   
-const unsigned long COOL_DOWN = 1000; // in Millisekunden, also 1 Sekunde+  - ''finalizeInput()'' → Wandelt den Eingabewert in eine Strecke um.  
  
-// Allgemein +=== ⚙️ Die ADJUST AREA === 
-unsigned long calibrationTravelTime; +Hier können **drei zentrale Parameter** angepasst werden:   
-unsigned long currentTravelTime = 100; +  * **''calibrationDistance = 40''** → Standardstrecke für die Kalibrierung in cm.   
- +  * **''speed = 200''** → Geschwindigkeit der Motoren.   
-// ADJUST AREA START +  * **''dir = 1''** → Richtungskorrektur für Vorwärtsbewegung.  
-int calibrationDistance = 40; // cm +          * Falls das Fahrzeug rückwärts fährt, auf ''-1'' setzen.  
-int speed = 180; // Motor speed +
-// ADJUST AREA END +
- +
-// actionCalibration... +
-unsigned long ac_movingStartTimeForward  = 0; +
-unsigned long ac_movingTimeForward = 0; +
-unsigned long ac_movingStartTimeBackward = 0; +
-unsigned long ac_movingTimeBackward = 0; +
-bool ac_isMoving = false; +
-bool ac_isForwardMoving = false; +
-bool ac_isBackwardMoving = false; +
-bool ac_calibrationDone = false; +
- +
-// actionForward +
-bool af_firstRunMotor = true;     // erstes Starten? +
-bool af_motorActive   = false;    // Motorzustand? +
-unsigned long af_motorStartTime = 0; +
-// actionBackward +
-bool ab_firstRunMotor = true;     // erstes Starten? +
-bool ab_motorActive   = false;    // Motorzustand? +
-unsigned long ab_motorStartTime = 0; +
- +
-//FSM +
-enum State { +
-  STATE_OFF, +
-  STATE_BACKWARD, +
-  STATE_CALIBRATION, +
-  STATE_DISTANCE, +
-  STATE_FORWARD +
-}; +
- +
-State state     = STATE_OFF; +
-State lastState = STATE_OFF; +
- +
-enum ExState { +
-  EX_IDLE, +
-  EX_WAIT_FOR_INPUT +
-}; +
-ExState exState       = EX_IDLE; +
-int     inputNumber   = 0;    // Anzahl der eingegebenen Stellen +
-String  inputBuffer   = "";   // Sammeln der Ziffern als Text +
-int     inputDistance = 0;    // Konvertierte Eingabe +
- +
-void setup() { +
-  led.setpin(13); +
-  Serial.begin(9600); +
-  ir.begin(); +
-} +
- +
-void loop() { +
-  // step: command (IR-Taste einlesen) +
-  int cmd = read(); +
-  // step: state bestimmen +
-  state  = decode(cmd); +
-  // step: zustandsabhängige Aktion +
-  switch (state) { +
-    case STATE_CALIBRATION: +
-      actionCalibration(); +
-      break; +
-    case STATE_FORWARD: +
-      actionForward(); +
-      break; +
-    case STATE_BACKWARD: +
-      actionBackward(); +
-      break; +
-    case STATE_DISTANCE: +
-      actionDistance(); +
-      break; +
-    case STATE_OFF: +
-      actionOff(); +
-      break; +
-  } +
-} +
- +
-/* +
-  --------------------------- +
-  Funktionen +
-  --------------------------- +
-*/ +
- +
-int read() { +
-  if (ir.decode()) { +
-    uint32_t code = getIRCode(); +
-    // Vermeidung wiederholter Eingaben +
-    unsigned long now = millis(); +
-    if (code == lastCode && (now - lastTime < COOL_DOWN)) +
-      return -1; +
-    lastCode = code; +
-    lastTime = now; +
-    // +
-    switch (code) { +
-      case IR_BUTTON_E: +
-        buzzer.tone(1200, 200); +
-        return 0;  // STATE_OFF +
-        break; +
-      case IR_BUTTON_B: +
-        buzzer.tone(1200, 200); +
-        return 1;  // STATE_BACKWARD +
-        break; +
-      case IR_BUTTON_C: +
-        buzzer.tone(1200, 200); +
-        return 2;  // STATE_CALIBRATION +
-        break; +
-      case IR_BUTTON_D: +
-        initInput(); +
-        return 3;  // STATE_DISTANCE +
-        break; +
-      case IR_BUTTON_F: +
-        buzzer.tone(1200, 200); +
-        return 4;  // STATE_FORWARD +
-        break; +
- +
-      // Ziffern 0–9 +
-      case IR_BUTTON_0: handleInput(0); break; +
-      case IR_BUTTON_1: handleInput(1); break; +
-      case IR_BUTTON_2: handleInput(2); break; +
-      case IR_BUTTON_3: handleInput(3); break; +
-      case IR_BUTTON_4: handleInput(4); break; +
-      case IR_BUTTON_5: handleInput(5); break; +
-      case IR_BUTTON_6: handleInput(6); break; +
-      case IR_BUTTON_7: handleInput(7); break; +
-      case IR_BUTTON_8: handleInput(8); break; +
-      case IR_BUTTON_9: handleInput(9); break; +
- +
-      // Taste 'Setting' = Eingabe abschließen +
-      case IR_BUTTON_SETTING: +
-        finalizeInput(); +
-        return -1;  // Kein direkter Zustandswechsel +
-        break; +
-    } +
-  } +
-  return -1; // keine bekannte/verwertbare Taste +
-} +
- +
-uint32_t getIRCode() { +
-  uint32_t value = ir.value; +
-  value = (value >> 16) & 0xff; +
-  return value; +
-} +
- +
-State decode(int cmd) { +
-  switch (cmd) { +
-    case 0: +
-      lastState = STATE_OFF; +
-      return STATE_OFF; +
-    case 1: +
-      lastState = STATE_BACKWARD; +
-      return STATE_BACKWARD; +
-    case 2: +
-      lastState = STATE_CALIBRATION; +
-      return STATE_CALIBRATION; +
-    case 3: +
-      lastState = STATE_DISTANCE; +
-      return STATE_DISTANCE; +
-    case 4: +
-      lastState = STATE_FORWARD; +
-      return STATE_FORWARD; +
-  } +
- +
-  return lastState; +
-} +
- +
-/* +
-  --------------------------- +
-  Eingabemodus für EX-Befehle +
-  --------------------------- +
-*/ +
-void initInput() { +
-  buzzer.tone(1000, 200); +
-  exState     = EX_WAIT_FOR_INPUT; +
-  inputNumber = 0; +
-  inputBuffer = ""; +
-} +
- +
-void handleInput(int number) { +
- +
-  if (exState != EX_WAIT_FOR_INPUT) return; +
- +
-  // Maximal 3 Stellen erlauben +
-  if (inputNumber >= 3) { +
-    buzzer.tone(300, 300); +
-    delay(200); +
-    buzzer.tone(300, 300); +
-    return; +
-  } +
- +
-  // Zahl anhängen +
-  inputBuffer += String(number); +
-  inputNumber++; +
-  buzzer.tone(1200, 80); +
-} +
- +
-void finalizeInput() { +
-  if (exState == EX_WAIT_FOR_INPUT) { +
-    exState = EX_IDLE; +
-    buzzer.tone(1200, 200); +
-  } +
-} +
- +
-/* +
-  --------------------------- +
-  Funktionen ...actionXXX +
-  --------------------------- +
-*/ +
- +
-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 moving forward +
-  if (!ac_isMoving) { +
-    motor1.stop(); +
-    motor2.stop(); +
-    motor1.run(-speed); +
-    motor2.run(speed); +
-    ac_movingStartTimeForward = millis(); +
-    ac_isMoving = true; +
-    ac_isBackwardMoving = true; +
-    do { +
-      sensorState = lineFinder.readSensors(); +
-    } while ( sensorState != S1_OUT_S2_OUT); +
-  } +
- +
-  // step - end moving forward ... start moving backward +
-  if (ac_isBackwardMoving && sensorState == S1_IN_S2_IN) { +
-    motor1.stop(); +
-    motor2.stop(); +
-    ac_movingTimeForward = millis() - ac_movingStartTimeForward; +
- +
-    motor1.run(speed); +
-    motor2.run(-speed); +
-    ac_movingStartTimeBackward = millis(); +
-    do { +
-      sensorState = lineFinder.readSensors(); +
-    } while ( sensorState != S1_OUT_S2_OUT); +
-    ac_isBackwardMoving = false; +
-    ac_isForwardMoving  = true; +
-  } +
- +
-  // step - end turing right +
-  if (ac_isForwardMoving && sensorState == S1_IN_S2_IN) { +
-    motor1.stop(); +
-    motor2.stop(); +
-    ac_movingTimeBackward = millis() - ac_movingStartTimeBackward; +
-    calibrationTravelTime = (ac_movingTimeForward + ac_movingTimeBackward) / 2.0; +
-    ac_calibrationDone = true; +
-    led.setColorAt(1, 0, 0, 0); +
-    led.setColorAt(0, 0, 0, 0); +
-    led.show(); +
-    buzzer.tone(1200, 600); +
-    lastState = STATE_OFF; +
- +
-  } +
-} +
- +
-void actionForward() { +
-  unsigned long currentMillis = millis(); +
- +
-  // Wenn der Motor aktuell läuft, prüfen wir, ob die Zeit abgelaufen ist +
-  if (af_motorActive) { +
-    if (currentMillis - af_motorStartTime >= currentTravelTime) { +
-      // Zeit ist um → Motor stoppen +
-      motor1.stop(); +
-      motor2.stop(); +
-      af_motorActive = false; +
-      state = STATE_OFF; +
-      lastState = STATE_OFF; +
-    } +
-    // Funktion verlassen +
-    return; +
-  } +
- +
-  if (!af_firstRunMotor) +
-    return; +
- +
-  motor1.run(-speed); +
-  motor2.run(speed); +
-  af_motorStartTime = currentMillis; +
-  af_motorActive    = true; +
-  af_firstRunMotor  = false; +
-} +
- +
-void actionBackward() { +
-  unsigned long currentMillis = millis(); +
- +
-  // Wenn der Motor aktuell läuft, prüfen wir, ob die Zeit abgelaufen ist +
-  if (ab_motorActive) { +
-    if (currentMillis - ab_motorStartTime >= currentTravelTime) { +
-      // Zeit ist um → Motor stoppen +
-      motor1.stop(); +
-      motor2.stop(); +
-      ab_motorActive = false; +
-      state = STATE_OFF; +
-      lastState = STATE_OFF; +
-    } +
-    // Funktion verlassen +
-    return; +
-  } +
- +
-  if (!ab_firstRunMotor) +
-    return; +
-     +
-  motor1.run(speed); +
-  motor2.run(-speed); +
-  ab_motorStartTime = currentMillis; +
-  ab_motorActive    = true; +
-  ab_firstRunMotor  = false; +
- +
-} +
- +
-void actionDistance() { +
-  //Serial.println("...actionDistance"); +
-  // noch in der Eingabe? +
-  if (exState == EX_WAIT_FOR_INPUT) { +
-    return; +
-  } +
-  // step: ...calculate distance +
-  inputDistance = inputBuffer.toInt(); +
-  if (inputDistance > 200) { +
-    inputDistance = 200; +
-  } +
-  // step: calculate the travel time (for non blocking-method) +
-  double v = (1.0 * calibrationDistance) / (1.0 * calibrationTravelTime); +
-  currentTravelTime = inputDistance / v; +
-  // Serial.print("Eingegebene Distance: "); +
-  // Serial.println(inputDistance); +
-} +
- +
-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_isMoving         = false; +
-  ac_isForwardMoving  = false; +
-  ac_isBackwardMoving = false; +
-  ac_calibrationDone  = false; +
- +
-  // reset state forward +
-  af_firstRunMotor = true; +
-  af_motorActive   = false; +
-  af_motorStartTime = 0; +
-  // reset state backward +
-  ab_firstRunMotor = true; +
-  ab_motorActive   = false; +
-  ab_motorStartTime = 0; +
-  // reset state distance +
-  exState       = EX_IDLE; +
-} +
-</Code>+
  
 +Die Werte beeinflussen das Fahrverhalten direkt und sollten je nach Umgebung angepasst werden.  
  
  
mbot_streckenfahren.1740899159.txt.gz · Zuletzt geändert: 2025/03/02 07:05 von torsten.roehl