lehrkraefte:blc:informatik:glf20:robotik:linefollower [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.
====== 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.

<WRAP info>
Damit alle Roboter in die gleiche Richtung und den gleichen Parcours fahren, machen wir ab, dass
  * **Weiss ist links, Schwarz ist rechts**
</WRAP>

Die einfachste Umsetzung dieser Idee sieht (als noch ungetesteten Code) wie folgt aus:
<code python>
# 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
</code>

===== 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 [[lehrkraefte:blc:informatik:glf20:robotik:motorenkontrolle#intervall_umrechnen_ein_fuer_alle_mal|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.

<code python>
###########################################
## 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
</code>
===== 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 2 ''Motor''-Objekte. Siehe z.B. [[lehrkraefte:blc:informatik:glf20:robotik:motorenkontrolle#steuerung_der_motoren|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