Line-Follower
Ein “Line-Follower” ist ein Roboter, der einer Linie entlang folgen kann. Dazu gibt es verschiedene Strategien, je nach Anzahl und Geschwindigkeit der Sensoren und Reaktionszeit der Motoren.
Bei den unseren Lego-Robotern mit TigerJython sind die Reaktionszeiten sehr langsam (Python auf Java). Entsprechend schwierig ist es, einen guten Line-Follower zu programmieren.
Grundidee: Grau muss es sein
Am einfachsten ist es, der Grenze zwischen Weiss und Schwarz zu folgen (so dass der Helligkeitssensor effektiv grau sieht). So weiss der Roboter sofort, auf welche Seite er korrigieren muss.
Damit alle Roboter in die gleiche Richtung und den gleichen Parcours fahren, machen wir ab, dass
- Weiss ist links, Schwarz ist rechts
Die einfachste Umsetzung dieser Idee sieht (als noch ungetesteten Code) wie folgt aus:
# Initialisierung fehlt hier! grau = 500 # Diesen Wert eventuell anpassen radiusLinks = 0.1 # Radius anpassen, so dass die engsten Kurven gefahren werden können radiusRechts = 0.2 # Radius anpassen, so dass die engsten Kurven gefahren werden können gear.setSpeed(20) # Langsam genug, damit der Roboter noch sinnvoll fahren kann. while True: hell = ls.getValue() if hell==0: # Roboter wurde aufgehoben? Also Ende break if hell<grau: # Bedingung umkehren, wenn in die andere Richtung gefahren werden soll gear.leftArc(radiusLinks) else: gear.rightArc(radiusRechts) gear.stop() # Motoren stopp robot.exit() # Programm korrekt beenden
Weniger wackeln
Anstatt immer Kurven zu fahren, soll der Kurvenradius davon abhängen, wie weit man vom «optimalen» grau-Wert entfernt ist. Die Idee ist, dass wenn man schön auf grau fährt, dass der Roboter dann gerade aus fährt.
Benutzen dazu z.B. die Funktion “linear”, die wir hier definiert haben.
Wenn die Geschwindigkeit klein genug ist (z.B. gear.setSpeed(10)
) erhält man so einen Linefollower, der schön ruhig und zuverlässig der Linie folgt.
########################################### ## B E G I N D E S P R O G R A M M S ## ########################################### grau = 500 # Diesen Wert eventuell anpassen radiusLinks = 0.1 # Radius anpassen, so dass die engsten Kurven gefahren werden können radiusRechts = 0.2 # Radius anpassen, so dass die engsten Kurven gefahren werden können # Das Interval [a,b] linear auf das Intervall [c,d] umrechnen, an der Stelle x def linear(a,b,c,d,x): return (x-a)/(b-a)*(d-c)+c def guterRadius(hell): if (hell>=grau-50 and hell<=grau+50): gear.forward() return if (hell<grau): r = linear(?, grau-50, ?, ?, hell); # TODO gear.leftArc(r) else: r = linear(grau+50, ?, ?, ? , hell); # TODO gear.rightArc(r) gear.setSpeed(20) # Langsam genug, damit der Roboter noch sinnvoll fahren kann. while True: hell = ls.getValue() if hell==0: # Roboter wurde aufgehoben? Also Ende break guterRadius(hell) gear.stop() # Motoren stopp robot.exit() # Programm korrekt beenden
Weitere mögliche Verbesserungen
- Auf geraden Stücken könnte die Geschwindigkeit erhöht werden und die Kurvenradien entsprechend reduziert werden. Sobald aber eine Kurve festgestellt wird, muss die Geschwindigkeit wieder reduziert werden.
- Man betrachtet nicht nur die aktuelle Helligkeit, sondern auch die Veränderung der Helligkeit. Wenn diese schnell heller wird, kann man so bereits Gegensteuer geben.
- Man summiert die “Fehler” auf, d.h. wie weit man von grau entfernt ist und passt damit den Kurvenradius an.
- Anstatt mit dem Kurvenradius könnten auch die Motoren individuell gesteuert werden. Anstatt eines
Gear
-Objekts benutzt man 2Motor
-Objekte. Siehe z.B. hier/ - Mathematisches Modell des Roboters und der Kurve (habe ich selbst noch nie programmiert).
- In jedem Schritt werden die Positionen der Räder ausgelesen, eine Schätzung des aktuellen Kurvenradius (der Kurve) und der Position und Rotation des Roboters erstellt. Mit dieser Schätzung werden die Motoren gesteuert und die Schätzung im nächsten Schritt überprüft