Arduino Alvik

Exaktes Fahren – Präzise Steuerung mit Radgeschwindigkeit

Der Arduino Alvik ist ein Schulungsroboter, der sehr präzise gesteuert werden kann. Während move() für einfache Fahraufgaben ausreicht, ermöglicht die direkte Steuerung der Radgeschwindigkeit eine feinere Kontrolle über Bewegungen und Zeitabläufe.

Direkte Radgeschwindigkeitssteuerung

Mit diesem Befehl steuerst du die Geschwindigkeit jedes Rades einzeln. Das ermöglicht:

• Präzise Zeitsteuerung (z.B. "fahre genau 10 Sekunden")
• Unterschiedliche Geschwindigkeiten für linkes und rechtes Rad
• Sanfte Kurvenfahrten
• Kontinuierliche Bewegung während andere Aufgaben ausgeführt werden

Wie weit fährt der Alvik pro Radumdrehung?

Um diese Frage zu beantworten, müssen wir zuerst den Radumfang berechnen.

Berechnung des Radumfangs

Gegebene Werte:

• Raddurchmesser: 34 mm
• Radius: 17 mm

Formel für den Umfang (U):

U = π × d

U = 3,14 × 34 mm

U = 106,8 mm

Wichtige Erkenntnis: Eine vollständige Radumdrehung (360°) bewegt den Roboter etwa 106,8 mm (≈ 10,7 cm) vorwärts.

Fahrtstrecke berechnen

Wenn die Räder mit 10 Umdrehungen pro Minute (RPM) drehen:

• Pro Umdrehung: 106,8 mm
• 10 Umdrehungen: 10 × 106,8 mm = 1.068 mm ≈ 1,07 Meter pro Minute
• Pro Sekunde: 1.068 mm ÷ 60 = 17,8 mm/s

Beispiel 1: Kontinuierliches Fahren

Der Alvik fährt mit konstanter Geschwindigkeit ohne Zeitbegrenzung:

from arduino_alvik import ArduinoAlvik
from time import sleep_ms

alvik = ArduinoAlvik()
alvik.begin()

# Beide Räder mit 10 Umdrehungen pro Minute
alvik.set_wheels_speed(10, 10)

# Der Alvik fährt jetzt dauerhaft mit dieser Geschwindigkeit
# Um zu stoppen, muss man explizit alvik.stop() aufrufen

Beispiel 2: Exaktes Fahren mit Zeitsteuerung

Der Alvik soll genau 60 Sekunden fahren und dann automatisch stoppen. Dafür verwenden wir ticks_ms() zur Zeitmessung.

from arduino_alvik import ArduinoAlvik
from time import sleep_ms, ticks_ms

alvik = ArduinoAlvik()
alvik.begin()

# Startzeit merken
startzeit = ticks_ms()

while True:
    # Räder mit 10 RPM drehen
    alvik.set_wheels_speed(10, 10)
    
    # Aktuelle Zeit prüfen
    aktuelle_zeit = ticks_ms()
    
    # Nach 60 Sekunden (60.000 Millisekunden) stoppen
    if aktuelle_zeit - startzeit >= 60000:
        alvik.stop()
        break

# Berechne die gefahrene Strecke:
# 10 RPM × 106,8 mm × 1 Minute = 1.068 mm ≈ 1,07 Meter

Analyse: Wie weit ist der Alvik gefahren?

Bei 10 Umdrehungen pro Minute für 60 Sekunden:

• 10 Umdrehungen × 106,8 mm = 1.068 mm
• Gefahrene Strecke: ≈ 1,07 Meter

Was ist ticks_ms() und warum brauchen wir es?

Stell dir vor, dein Roboter hat eine Stoppuhr, die automatisch startet, sobald du ihn einschaltest. ticks_ms() zeigt dir, wie viele Millisekunden (Tausendstel Sekunden) seit dem Einschalten vergangen sind.

Warum nicht einfach time.sleep() verwenden?

Der Unterschied ist entscheidend:

• Mit sleep(1): Der Roboter pausiert komplett für 1 Sekunde – er kann in dieser Zeit nichts anderes machen
• Mit ticks_ms(): Der Roboter kann die Zeit im Auge behalten UND gleichzeitig andere Dinge tun (Sensoren auslesen, weiterfahren, LEDs steuern)

Beispiel 3: Zeitmessung mit ticks_diff()

Eine elegantere Methode zur Zeitdifferenz-Berechnung:

from time import ticks_ms, ticks_diff
from arduino_alvik import ArduinoAlvik

alvik = ArduinoAlvik()
alvik.begin()

# Startzeit merken
start_zeit = ticks_ms()

while True:
    # Prüfe, ob 2 Sekunden vergangen sind
    if ticks_diff(ticks_ms(), start_zeit) > 2000:  # 2000 ms = 2 Sekunden
        print("2 Sekunden sind um!")
        start_zeit = ticks_ms()  # Zeitmessung neu starten
    
    # Hier kann der Roboter trotzdem andere Dinge machen:
    # - Sensoren auslesen
    # - LEDs blinken lassen
    # - Hindernissen ausweichen
    # - etc.
    
    alvik.set_wheels_speed(10, 10)

Vorteile von ticks_ms() und ticks_diff()

• Nicht-blockierend: Code läuft weiter, während Zeit gemessen wird
• Präzise: Millisekunden-Genauigkeit
• Flexibel: Mehrere Zeitintervalle parallel messbar
• Robust: ticks_diff() funktioniert auch bei Überlauf (nach ~49 Tagen)

Praktische Anwendungen

Beispiel: Exakte Fahrtstrecke

Du möchtest, dass der Alvik genau 2 Meter fährt:

• Ziel: 2.000 mm
• Pro Umdrehung: 106,8 mm
• Benötigte Umdrehungen: 2.000 ÷ 106,8 ≈ 18,7 Umdrehungen
• Bei 10 RPM: 18,7 ÷ 10 = 1,87 Minuten ≈ 112 Sekunden

from arduino_alvik import ArduinoAlvik
from time import ticks_ms, ticks_diff

alvik = ArduinoAlvik()
alvik.begin()

# Fahre 112 Sekunden mit 10 RPM für ca. 2 Meter
start = ticks_ms()

while ticks_diff(ticks_ms(), start) < 112000:  # 112 Sekunden
    alvik.set_wheels_speed(10, 10)

alvik.stop()
print("2 Meter gefahren!")

Vergleich: move() vs. set_wheels_speed()

Tipps für präzises Fahren

• Batteriespannung: Volle Batterien für konstante Geschwindigkeit
• Untergrund: Glatter, ebener Boden für beste Ergebnisse
• Kalibrierung: Messe die tatsächliche Strecke und passe RPM-Werte an
• Schlupf: Berücksichtige, dass Räder auf verschiedenen Oberflächen unterschiedlich viel Grip haben
• Reaktionszeit: Der Roboter braucht eine kurze Zeit, um auf Geschwindigkeitsänderungen zu reagieren

Zusammenfassung

Für exaktes Fahren kombinierst du:

1. Radumfang-Berechnung: Wissen, wie weit eine Radumdrehung fährt (106,8 mm)
2. Geschwindigkeitssteuerung: set_wheels_speed() für kontinuierliche Bewegung
3. Zeitmessung: ticks_ms() und ticks_diff() für präzise Zeitsteuerung
4. Mathematik: RPM × Radumfang × Zeit = Gefahrene Strecke

from arduino_alvik import ArduikoAlvik
from time import ticks_ms, ticks_diff

alvik = ArduinoAlvik()
alvik.begin()

# Berechnung:
# 1 Meter = 1000 mm
# Radumfang = 106,8 mm
# Benötigte Umdrehungen: 1000 / 106,8 ≈ 9,36 Umdrehungen
# In 10 Sekunden: 9,36 Umdrehungen / (10/60) min ≈ 56,2 RPM

print("Start!")
start_zeit = ticks_ms()

# Fahre mit berechneter Geschwindigkeit
alvik.set_wheels_speed(56, 56)

while True:
    # Prüfe, ob 10 Sekunden vergangen sind
    if ticks_diff(ticks_ms(), start_zeit) >= 10000:
        alvik.stop()
        print("Ziel erreicht!")
        break

# Gefahrene Strecke: ca. 1 Meter in 10 Sekunden