lehrkraefte:blc:informatik:glf25:robotik:distanzfahren [https://fginfo.ksbg.ch Fachgruppe Informatik der KSBG]

This page is read only. You can view the source, but not change it. Ask your administrator if you think this is wrong.
{{backlinks>.}}
====== Geradeausfahren ======
<WRAP todo>
  * [[.:einrichten#neues_projekt_anlegen|Legen Sie in neues EV3-Projekt an]] (in VS-Code) z.B. mit dem Namen ''geradeausfahren''.
  * Am Ende des Programms (in der Datei ''main.py''), kommentieren Sie das Piepsen aus und fügen Sie folgende zwei Zeilen hinzu:
<code python>
links = Motor(Port.A)   # Kontrollieren Sie, ob die Motoren auch an den richtigen Ports angeschlossen sind.
rechts = Motor(Port.B)

links.run_angle(120, 360, wait=False)   # 120 Grad/s Drehgeschwindigkeit, eine volle Rad-Umdrehung, nicht warten, sondern gleich den nächsten Befehl ausführen.
rechts.run_angle(120, 360, wait=True)   # Dito, aber warten, bis fertig gedreht.
</code>
  * Stellen Sie den Roboter auf den Boden, bevor Sie den Code testen. Der Roboter sollte eine Radumdrehung nach vorne fahren.
  * Am Anfang Ihres Programms, nach den anderen ''import'' Statements, fügen Sie folgenden import hinzu (damit der Wert ''pi'' bekannt ist):
<code python>
from math import pi  # Wert pi importieren
</code>

</WRAP>


====== Einen Meter fahren ======
Ziel ist es, dass der Roboter möglichst genau einen Meter zurücklegt.

  * Dazu soll nicht einfach gut geraten werden, sondern durch Messung und geschickte Korrektur soll folgende Konstante für Ihren Roboter und den Teppich-Untergrund möglichst genau bestimmt werden:
    * ''radDurchmesser'' in cm. Daraus berechnen Sie (Konstante ''pi'' wurde durch den import definiert):
    * ''gradProCM'' gibt an, um wie viele Grad sich das Rad für einen cm Vorwärtsfahrt drehen muss.
  * Der gewünschte Drehwinkel für 1 m ist dann ''100*gradProCM''.

<WRAP todo>
  * Bestimmen Sie durch Messung die Konstante ''radDurchmesser'' und berechnen Sie daraus direkt im Code die Konstante ''gradProCM'' für Ihren Roboter.
  * Fahren Sie damit genau einen Meter und testen Sie.
  * Fahren Sie schneller. Welche Probleme tauchen auf?
</WRAP>

<hidden Lösungsvorschlag>
<code python>
radDurchmesser = 6                             # Raddurchmesser in cm
gradProCM = 360/(radDurchmesser*pi)            # Ergibt um die 20 Grad/cm (Feinjustierung mit 1m fahren).

distanz = 100     # 1m fahren

links.run_angle(120, distanz*gradProCM, wait=False)   # 120 Grad/s Drehgeschwindigkeit, eine volle Rad-Umdrehung, nicht warten, sondern gleich den nächsten Befehl ausführen.
rechts.run_angle(120, distanz*gradProCM, wait=True)   # Dito, aber warten, bis fertig gedreht.
</code>
</hidden>

====== Langsam anfahren und abbremsen ======
Ziel ist es, die Geschwindigkeit der Motoren in Abhängigkeit der zurückgelegten Strecke selbst hoch und runter zu regeln, damit langsam angefahren und abgebremst wird, dazwischen aber doch «Vollgas» gefahren werden kann.

{{.:pasted:20251121-075525.png}}

Dazu soll folgende Funktion ergänzt werden (nach der Definition von ''links'', ''rechts'' und ''gradProCM'' zu platzieren):
<code python>
def smoothRide(distanz, vmax):  # Fährt gegebene distanz in cm mit maximaler Geschwindigkeit vmax in cm/s
   # Winkel zurücksetzen:
   links.reset_angle(0)
   rechts.reset_angle(0)
   s = 0  # Bereits zurückgelegte Distanz
   while s<distanz:                   # Fahren, so lange die gewünschte Strecke nicht zurückgelegt ist
      s = links.angle()/gradProCM     # Bereits zurückgelegte Strecke
      
      v = 120                 # Hier aus der bereits zurückgelegten Distanz die Geschwindigkeit berechnen.
      
      links.run(v*gradProCM)
      recht.run(v*gradProCM)
   rechts.stop()
   links.stop()
   
   
# Funktion aufrufen
smoothRide(100, 20)   # 1 m fahren, mit max 2 Umdrehungen pro Sekunde.
</code>


Tipp: Die Geschwindigkeit kann als das Minimum von drei Geschwindigkeiten geschrieben werden:
<code python>
vstart = ...   # Formel aus s (Anstieg am Anfang)
vend = ...     # Formel aus s (Abfall am Ende)
v = min([vstart, vmax, vend])    # Kleinste der 3 Geschwindigkeiten
</code>

<hidden Lösungsvorschlag>
Anfahren auf gegebener Strecke, Geschwindigkeit proportional zur Strecke (führt zu einem exponentiellen Geschwindigkeitszuwachs und Beschleunigung).
<code python>
vmin = 1        # Mindestgeschwindigkeit, dass man überhaupt einmal losfährt 
anfahren = 10   # 10cm Strecke zum Anfahren/Bremsen.


vstart = vmin+(vmax-vmin)*s/anfahren
vend = vmin+(vmax-vmin)*(distanz-s)/anfahren
</code>
Setzt man eine konstante Beschleunigung $a$ voraus, erhält man aus den Bewegungsgleichungen $v(s) = s\cdot\sqrt{2as}$.
<code python>
a = 2   # Beschleunigung in cm/s/s


vstart = vmin + s*(2*a*s)**0.5
vend = vmin + (distanz-s)*(2*a*(distanz-s))
</code>

</hidden>
===== Online-Dokumentation =====
Dokumentation der Motor-Klasse: https://pybricks.com/ev3-micropython/ev3devices.html#motors