Fahren und Drehen

Geradeaus Fahren

Um geradeaus zu Fahren, wird die Funktion gyro_drive() verwendet.

gsgr.movement.gyro_drive(target_angle, speed, ending_condition, pid=None, accelerate=0, decelerate=0, sigmoid_conf=(6, True), brake=True)

Fahre mithilfe des Gyrosensors in eine bestimmte Richtung

Parameter:

target_angle (int) – Zielgradzahl; die Richtung in die gefahren werden soll
speed (int | float) – Fahrgeschwindigkeit; bei negativen Werten fährt der Roboter rückwärts; zwischen -100 und 100
ending_conditon – Zielbedingung; Bis wann/für wie lange die Bewegung ausgeführt werden soll
pid (Optional[PID]) – Die PID-Werte für die Bewegung; siehe PID
accelerate (float) – Über welche Stecke der Roboter beschleunigen soll; in Prozent von der ending_condition
decelerate (float) – Über welche Stecke der Roboter entschleunigen soll; in Prozent von der ending_condition
brake (bool) – Ob der Roboter nach der Bewegung bremsen soll

Die einfachste Verwendung sieht so aus:

#          Zielgradzahl
#          .   Geschwindigkeit in %
#          .   .    Ziel (Endingcondition)
#          .   .    .
gyro_drive(0, 75, cm(5))

Hier fährt der Roboter also 5 cm geradeaus mit 75% Geschwindigkeit.

Geschwindigkeit

Um Ungleichheiten der Motoren und Probleme mit schwächerer Batterieladung zu umgehen, sollte die Geschwindigkeit nicht zu niedrich gewählt werden. Unter 20-25 zu gehen, sollte vermieden werden.

Wichtig ist auch, die Geschwindigkeit nicht zu hoch einzustellen: Wenn der Roboter z.B. mit 100%iger Geschwindigkeit fährt, können die Korrekturwerte nur noch auf einem Rad effektiv angewandt werden; die Korrektur wird praktisch halbiert. Siehe PID-Korrektur für weitere Details. Dieser Effekt tritt, wenn auch nicht so stark, bereits bei Geschwindigkeiten von 90+ auf. Generell kannd er Roboter bei Geschwindigkeiten über 80-85 nicht mehr so genau fahren (Motoren unterschiedlich, weitere Faktoren), allein deshalb sollten zu hohe Geschwindigkeiten gemieden werden.

Auf die sog. Endingcondition gehen wir weiter unten genauer ein. Wichtig sind hier erstmal die anderen Werte.

Be- und Entschleunigung

Die Be- und Entschleunigung kann über die Parameter accelerate und deccelerate eingestellt werden. Standartmäßig ist sie ausgeschaltet.

Wenn ein Wert angegeben wird, wird er als Prozentsatz der angegeben Endingcondition verstanden.

Im folgenden Codeblock wird also für 5 cm be- und für 10 cm entschleunigt:

gyro_drive(0, 75, cm(20), accelerate=25, deccelerate=50)

Es ist wichtig, die Be- und Entschleunigungsstrecken nicht zu hoch einzustellen, da der Roboter bei schwächerer Batterieladung sonst verzieht, oder sogar nur mit einem Rad losfährt.

Die Strecken sollten, auch aus diesem Grund, jeweils nicht mehr als 7-10 cm betragen, je nach Geschwindigkeit.

„Bremsen“

Mit brake=False hat man die Möglichkeit, zu deaktivieren, das der Roboter nach der Bewegung anhält. Das kann sinnvoll sein, wenn man mehere Bewegungen direkt hintereinander ausführen will, ohne dass der Roboter kurz stehenbleibt.

Beispiel:

gyro_drive(0, 75, cm(10), brake=False)

PID-Korrektur

Der Roboter korrieiert mithilfe eines PID-Controllers zu der angegebenen Gradzahl hin. Das funktioniert, indem er regelmäßig die aktuelle Drehung des Roboters ausließt und entsprechend die Geschwindigkeit der Räder anpasst, sodass er sich wieder „von selbst“ in die richtige Richtung dreht.

Der Roboter berechnet die Differenz zwischen der aktuellen und der gewünschten Gradzahl. Dieser Wert heißt Fehler.

\[\Delta Fehler = \alpha_{aktuell} - \alpha_{Ziel}\]

Dann kommen die PID-Werte ins Spiel. P steht für Proportional, I für Integral und D für Ableitung (engl. derivative).

Der proportionale Korrekturwert \(p\) gibt an, wie stark auf basis des aktuellen Fehlers korrigiert werden soll.

\[Korrektur_P = \Delta Fehler * p\]

Der integrale Korrekturwert \(i\) bezieht sich auf die Summe aller bisherigen Fehler. Er hilft, wenn

\[Korrektur_I = \int_{t_{start}}^{t_{jetzt}} Fehler(t) dx * i\]

(oder in einfach, hatte gerade Spaß)

\[Korrektur_I = Fehlersumme * i\]

Der letzte Korrekturwert \(p\) wird auf die Veränderung angewandt:

\[Korrektur_D = (Fehler_{jetzt} - Fehler_{gerade \space eben}) * d\]

Das soll einer zu starken Korrektur vorauswirken, daher wird hier auch ein negativer Korrekturwert \(d\) verwendet.

Daraus wird dann die Summe berechnet:

\[Korrektur = Korrektur_P + Korrektur_I + Korrektur_D\]

Dann wird diese auf beide Radgeschwindigkeiten angewandt:

\[v_{links}=v_{links} + \frac{Korrektur}{2}\]

\[v_{rechts}=v_{rechts} - \frac{Korrektur}{2}\]

Dadurch dreht das eine Rad dann langsamer und das andere schneller, wodurch sich der Roboter wieder zuer Wunschrichtung ausrichtet.

Für weitere Details zum wählen der richtigen Korrekturwerte, siehe auch Fahrprobleme

Endingconditions

Bemerkung

WIP