lehrkraefte:snr:informatik:glf22:robotik:einfache-bewegungen

Differences

This shows you the differences between two versions of the page.

Link to this comparison view

Both sides previous revision Previous revision
Next revision		 Previous revision
lehrkraefte:snr:informatik:glf22:robotik:einfache-bewegungen [2024/06/06 05:19] – [Aufgabe 3: Kreisbogen-Fahren] Olaf Schnürerlehrkraefte:snr:informatik:glf22:robotik:einfache-bewegungen [2024/06/07 20:05] (current) – [Was man noch machen könnte...] Olaf Schnürer
Line 1: Line 1:
 +~~NOTOC~~
 +
 +====== Basisbewegungen: Vorwärts, Drehen, Abbiegen ======
 +
 +Du kannst dem Roboter befehlen, dass er das linke bzw. rechte Rad um einen gewissen Winkel mit einer gewissen Geschwindigkeit drehen soll.
 +
 +Der Winkel wird dabei in Grad, die Drehgeschwindigkeit in $\frac{\text{Grad}}{\text{Sekunde}}= \frac{\phantom{x}^\circ}{\text{s}}$ angegeben.
 +
 +Beispielsweise bewirkt der Befehl
 +
 +<code python>
 +links.run_angle(120, 10)   
 +</code>
 +eine Drehung des linken Rades um $10^\circ$ mit einer Drehgeschwindigkeit von $\frac{120^\circ}{\text{s}}$
 +(falls die Variable ''links'' zuvor korrekt mit dem entsprechende Motor verknüpft wurde). 
 +
 +In den folgenden Aufgaben wirst du dies nutzen, um dem Roboter einfache Bewegungen beizubringen (so dass du ihn ähnlich wie die Turtle bei der Turtle-Grafik steuern kannst).
 +
 +<WRAP center round important>
 +In den folgenden "Lückenprogrammen" sind die Fragezeichen korrekt zu ersetzen. Meist ist nur ein Messwert als konkrete Zahl einzutragen, die anderen Fragezeichen sind dann **in Python** aus den vorherigen Variablen zu berechnen. 
 +
 +Dies hat den Vorteil, dass man eventuelle Messfehler oder unerwünschtes Verhalten des Roboters später durch Änderung eines einzigen Wertes korrigieren kann.
 +
 +**Nicht erwünscht ist es, die gesuchten Werte per Taschenrechner auszurechnen und dann als Zahlen einzutragen.**
 +</WRAP>
 +
 +===== Aufgabe 1: Vorwärts-Fahren =====
 +
 +Der Roboter soll eine gewisse Distanz (in Zentimeter) vorwärts fahren. Durch Abmessen des Raddurchmessers berechnest du, um welchen Winkel sich jedes der beiden Räder drehen muss. 
 +
 +Bevor du diese Programmier-Aufgabe löst, solltest du die Aufgaben A1 und A2 im {{:lehrkraefte:snr:informatik:glf23:robotik:robotik-sv.pdf|Robotik-Skript}} lösen.
 +
 +
 +<WRAP center round todo>
 +Kopiere den folgenden Code-Block ans Ende des durch "Create a new project" erstellten Programms.
 +
 +Lies das Programm Zeile für Zeile und versuche, es möglichst gut zu verstehen. Ersetze die fünf ''??'' sinnvoll. Nur für das erste ''??'' ist eine konkrete Zahl einzutragen, der Rest ergibt sich daraus.
 +
 +<code python>
 +# Bitte sicherstellen, dass dein Computer im tech-lab-Netz ist und nicht in Schule SG o.ä..
 +
 +###############
 +#  AUFGABE 1  #
 +###############
 +
 +ev3.speaker.say(text="Hello I am Robby the robot")
 +
 +links = Motor(Port.A)
 +rechts = Motor(Port.B)
 +
 +# Checke die Kabelverbinungen! 
 +# Wenn du die obigen Einstellungen nutzen willst:
 +# - Der linke Motor muss mit Port A (am EV3-Brick) verbunden sein.
 +# - Der rechte Motor muss mit Port B verbunden sein.
 +
 +from math import pi
 +# Damit ist pi = 3.14152... benutzbar.
 +
 +raddurchmesser = ??   # Bitte abmessen (per Lineal oder App)! Alle Längen in cm.
 +radumfang = ??        # Formel in Abhängigkeit vom Raddurchmesser. KEINE ZAHL EINTRAGEN!
 +  
 +# Rad: Drehwinkel und dabei zurückgelegte Strecke  
 +# 360 Grad        ≙ radumfang (in cm)
 +# ??              ≙ 1 cm
 +
 +rad_drehwinkel_pro_cm = ??  # KEINE ZAHL EINTRAGEN, sondern eine Formel in Abhängigkeit von den obigen Variablen.
 +
 +def vorwaerts(distanz):    
 +    # Der Roboter bewegt sich geradlinig vorwärts.
 +    # Die Variable "distanz" gibt an, 
 +    # um wie viele cm er sich bewegt.
 +
 +    alpha = ??   # Winkel, um den sich jedes der beiden Räder drehen muss.
 +    links.run_angle(120, alpha, wait=False)   
 +    # Bewegt den linken Motor, also das linke Rad, mit 
 +    # (1) 120 Grad/s Drehgeschwindigkeit
 +    # (2) alpha als Drehwinkel.
 +    # (3) Wartet nicht, bis die Drehung vollständig ausgeführt ist; 
 +    #     der Roboter kann sofort einen weiteren Befehl verarbeiten.
 +
 +    rechts.run_angle(120, alpha, wait=True)   
 +    # Dito mit dem rechten Motor, aber nun wird gewartet, 
 +    # bis die Raddrehung beendet ist.
 + 
 +    links.stop()
 +    rechts.stop()
 +
 +vorwaerts(100)
 +
 +# Ersetze diesen Befehl etwa durch 'vorwaerts(50)'. Fährt der Roboter nun ca. 50 cm?
 +
 +# Passe die Mess-Variable "raddurchmesser" so an, 
 +# dass der Roboter möglichst genau 100 cm bzw. die gewünschte Distanz fährt.
 +
 +# Wenn du zufrieden bist, kannst du den Aufruf der Funktion  "vorwaerts" 
 +# löschen und die nächste Aufgabe bearbeiten.
 +</code>
 +</WRAP>
 +
 +===== Challenge: Welcher Roboter fährt genau einen Meter? Nebeneinander starten lassen ... =====
 +
 +===== Alternative, experimentell(er)e Herangehensweise =====
 +
 +Statt den Roboter zu vermessen, könnte man beide Roboterräder um denselben Winkel drehen lassen (etwa $980^\circ$) und dann die Strecke vermessen, die der Roboter gefahren ist. 
 +Aus diesem Messwert kann man dann berechnen, welcher Drehwinkel einer Vorwärtsbewegung von einem Zentimeter entspricht. Vermutlich liefert dieser Ansatz sogar bessere Ergebnisse, denn die Messungenauigkeiten dürften weniger stark ins Gewicht fallen. (Ähnlich könnte man die folgenden Aufgaben angehen; das Kreisbogenfahren erscheint mir aber nicht so leicht experimentell lösbar.)
 +
 +
 +
 +===== Aufgabe 2: Auf-der-Stelle-Drehen =====
 +
 +Der Roboter soll sich auf der Stelle um einen gewissen Winkel drehen (in mathematisch positivem Drehsinn, also dem Gegenuhrzeigersinn).
 +
 +Genauer soll der Mittelpunkt der Roboterdrehung genau in der Mitte der Radachse liegen, so dass sich die beiden Räder in entgegengesetzten Richtungen drehen müssen. Der Drehwinkel der beiden Räder ist auszurechnen. Zusätzlich zum bereits gemessenen Raddurchmesser benötigst du den Radabstand (= Abstand der "Mittelpunkte der Reifen").
 +
 +**Achtung:** Es gibt zwei "Drehwinkel": 
 +  * den Drehwinkel des Roboters (um die vertikale Achse durch den Radachsenmittelpunkt)
 +  * den Drehwinkel der Räder.
 +
 +Bevor du diese Programmier-Aufgabe löst, solltest du die Aufgabe A3 im {{:lehrkraefte:snr:informatik:glf23:robotik:robotik-sv.pdf|Robotik-Skript}} lösen.
 +
 +<WRAP center round todo>
 +Kopiere den folgenden Code-Block ans Ende deines in Aufgabe 1 erstellten Programms (den dortigen Befehlsaufruf ''vorwaerts(100)'' kannst du nun auskommentieren).
 +
 +Lies das Programm Zeile für Zeile und ersetze die sechs ''??'' sinnvoll. Nur für das erste ''??'' ist eine konkrete Zahl einzutragen, der Rest ergibt sich daraus (etwa per Dreisatz).
 +
 +<code python>
 +#############################################################################
 +
 +###############
 +#  AUFGABE 2  #
 +###############
 +
 +radabstand = ??  # in cm; bitte abmessen; Abstand zwischen den Reifenmitten
 +
 +def drehe(drehwinkel_roboter):
 +    # Der Roboter dreht sich AUF DER STELLE um den Winkel "drehwinkel_roboter".
 +    # Drehzentrum ist die Mitte zwischen den Rädern.
 +
 +    # Strecke eines Rades bei Roboterdrehung um 360 Grad:  2 * pi * (radabstand / 2) 
 +    # Strecke eines Rades bei Roboterdrehung um 1 Grad:    
 +    strecke_bei_roboterdrehung_um_ein_grad = ??
 +
 +    # Die folgenden Variable soll die Strecke eines Rades
 +    # bei der gewünschten Roboterdrehung speichern:
 +    strecke = ??
 +
 +    # Dies muss nun umgerechnet werden in den Winkel,
 +    # um den sich jedes Rad drehen muss:
 +    # Hinweis: Verwende die weiter oben definierte Variable "rad_drehwinkel_pro_cm".
 +    drehwinkel_rad = ??
 +
 +    # Nun sind die Räder so zu drehen, dass der Roboter sich **auf der Stelle** dreht.
 +    rechts.run_angle(120, ??, wait=False)   
 +    links.run_angle(120, ??, wait=True)   
 +
 +    links.stop()
 +    rechts.stop()    
 +
 +vorwaerts(20)
 +drehe(360)
 +vorwaerts(20)
 +drehe(180)
 +vorwaerts(20)
 +
 +# Ändere die Variable "radabstand" so, 
 +# dass der Roboter sich möglichst genau
 +# um den gewünschten Winkel dreht.
 +
 +# Wenn du zufrieden bist, kannst du den obigen Befehlsblock "vorwaerts(20); drehe(360); ... " löschen und die nächste Aufgabe bearbeiten.
 +</code>
 +</WRAP>
 +
 +===== Aufgabe 3: Kreisbogen-Fahren =====
 +
 +Der Roboter soll nun einen durch Kreisradius und Winkel festgelegten Kreisbogen abfahren. Dabei müssen sich die beiden Räder unterschiedlich schnell drehen.
 +
 +Bevor du diese Programmier-Aufgabe löst, solltest du die Aufgabe A4 im {{:lehrkraefte:snr:informatik:glf23:robotik:robotik-sv.pdf|Robotik-Skript}} lösen.
 +
 +<WRAP center round todo>
 +Kopiere den folgenden Code-Block ans Ende deines in Aufgabe 2 erstellten Programms.
 +
 +Lies das Programm Zeile für Zeile und ersetze die elf ''??'' sinnvoll (etwa per Dreisatz).
 +
 +<code python>
 +#############################################################################
 +
 +###############()
 +#  AUFGABE 3  #
 +###############
 +
 +def biege_ab(kreisradius, winkel_kreiszentrum, drehsinn):
 +    # Der Roboter fährt einen durch Radius "kreisradius" und Innenwinkel "winkel_kreiszentrum" gegebenen Kreisbogen.
 +    # Der Drehsinn (Links- bzw. Rechtskurve) wird durch den String "drehsinn" angegeben, der entweder den Wert 
 +    # "links" oder den Wert "rechts" haben darf.
 +
 +    # Bewegung eines fiktiven Rades in Robotermitte 
 +    # (bzw. genauer in der Mitte der Radachse):
 +
 +    # Fülle die folgende Tabelle aus:
 +    # Zu dem jeweils angegebenen Winkel ist die zugehörige Länge des Kreisbogens 
 +    # einzutragen (es geht um den Kreis, auf dem der Roboter fährt).
 +    # Winkel im Kreiszentrum | Länge des Kreisbogens       
 +    # 360 Grad               ≙ ?? # verwende den Parameter "kreisradius" 
 +    # 1 Grad                 ≙ ??
 +
 +    # Welche Strecke legt das fiktive Rad also zurück?
 +    # Hinweis: Verwende die Variable "winkel_kreiszentrum".
 +    robotermitte_strecke = ??
 +
 +    # Um welchen Winkel dreht sich das fiktive Rad dabei?
 +    # Hinweis: Verwende die weiter oben definierte Variable "rad_drehwinkel_pro_cm".
 +    robotermitte_rad_drehwinkel = ??
 +
 +    # Das fiktive Rad in Robotermitte soll sich mit 120 Grad/s drehen.
 +    # 120 Grad ≙ 1 s  
 +    #   1 Grad ≙ ??
 +
 +    # Wie lange dreht sich das fiktive Rad?
 +    zeit =  ??
 +
 +    # Die beiden Räder sollen sich genauso lange bewegen wie das fiktive Rad,
 +    # aber mit unterschiedlichen (Winkel-)Geschwindigkeiten, damit der Roboter 
 +    # einen Kreisbogen fährt.
 +
 +    # Berechnung der Drehgeschwindigkeit des äusseren Rades.
 +    # Welchen Radius hat der Kreis, auf dem sich das äussere Rad bewegt? 
 +    # Verwende die Variable "radabstand"!
 +    aussen_strecke =            ?? # Ähnlich wie "robotermitte_strecke" oben
 +    aussenrad_drehwinkel =      ?? # Ähnlich wie "robotermitte_rad_drehwinkel" oben
 +    aussenrad_geschwindigkeit = ?? # bitte in Grad pro Sekunde angeben
 +
 +    # Berechnung der Drehgeschwindigkeit des inneren Rades.
 +    # Das geht nun fast genauso wie beim äusseren Rad.
 +    innen_strecke =            ??
 +    innenrad_drehwinkel =      ??
 +    innenrad_geschwindigkeit = ??
 +
 +    if drehsinn == "links":
 +        # Die folgende Zeile sagt dem LINKEN Motor, was er zu tun hat.
 +        links.run_angle(innenrad_geschwindigkeit, innenrad_drehwinkel, wait=False)   
 +        rechts.run_angle(aussenrad_geschwindigkeit, aussenrad_drehwinkel, wait=True)   
 +    else:
 +        # In den beiden folgenden Zeilen stimmt noch nicht alles...
 +        links.run_angle(innenrad_geschwindigkeit, innenrad_drehwinkel, wait=False)   
 +        rechts.run_angle(aussenrad_geschwindigkeit, aussenrad_drehwinkel, wait=True)   
 +    links.stop()
 +    rechts.stop()    
 +
 +vorwaerts(20)
 +biege_ab(50, 90, "links")
 +vorwaerts(20)
 +biege_ab(50, 90, "rechts")
 +
 +# Hoffentlich fährt dein Roboter (in etwa) wie gewünscht.
 +</code>
 +</WRAP>
 +
 +===== Aufgabe 4: Challenge =====
 +
 +<WRAP center round todo>
 +Markiere etwa mit Klebeband einen Route auf dem Boden, die aus geraden Linien, Ecken und Kreisbögen besteht.
 +
 +Programmiere dann deinen Roboter so, dass er möglichst genau der Klebeband-Route folgt.
 +Du darfst die Route mit deinem Lineal/Klappmeter vermessen.
 +<!--Lass den Roboter einen Meter entfernt von einem Drehstuhl starten. Der Roboter soll relativ nah an den Drehstuhl heranfahren, ihn einmal umrunden und dann wieder an den Ausgangspunkt zurückkehren. Am Ende soll der Roboter genauso ausgerichtet sein wie am Anfang.
 +-->
 +</WRAP>
 +
 +===== Was man noch machen könnte... =====
 +
 +  * Beschleunigungs- und Abbremsphase
 +  * evtl. Sachen von https://ev3lessons.com/en/index.html
 +===== Falls jemand aus Versehen das "main"-Programm gelöscht hat ... =====
 +
 +<hidden "main.py">
 +<code python main.py>
 +#!/usr/bin/env pybricks-micropython
 +from pybricks.hubs import EV3Brick
 +from pybricks.ev3devices import (Motor, TouchSensor, ColorSensor,
 +                                 InfraredSensor, UltrasonicSensor, GyroSensor)
 +from pybricks.parameters import Port, Stop, Direction, Button, Color
 +from pybricks.tools import wait, StopWatch, DataLog
 +from pybricks.robotics import DriveBase
 +from pybricks.media.ev3dev import SoundFile, ImageFile
 +
 +
 +# This program requires LEGO EV3 MicroPython v2.0 or higher.
 +# Click "Open user guide" on the EV3 extension tab for more information.
 +
 +
 +# Create your objects here.
 +ev3 = EV3Brick()
 +
 +
 +# Write your program here.
 +ev3.speaker.beep()
 +</code>
 +</hidden>
 +
 +==== Lösungshinweise ====
 +
 +Bzw. was für die Fragezeichen einzutragen ist.
 +
 +<hidden Vorwärts-Fahren>
 +<code python>
 +radumfang = pi * raddurchmesser            # Formel in Abhängigkeit vom Raddurchmesser. KEINE ZAHL EINTRAGEN!
 +
 +# Rad: Drehwinkel und dabei zurückgelegte Strecke  
 +# 360 Grad        ≙ radumfang (in cm)
 +# 360 / radumfang ≙ 1 cm
 +
 +rad_drehwinkel_pro_cm = 360 / radumfang      # KEINE ZAHL EINTRAGEN, sondern eine Formel in Abhängigkeit von den obigen Variablen.
 +                                             # auch korrekt: rad_drehwinkel_pro_cm = 360 / (pi * raddurchmesser)
 +
 +def vorwaerts(distanz):    
 +    alpha = distanz * rad_drehwinkel_pro_cm      # Winkel, um den sich jedes der beiden Räder drehen muss.
 +</code>
 +</hidden>
 +