Differences

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

--- lehrkraefte:blc:informatik:glf20:robotik:linefollower [2021/05/12 11:21]
Ivo Blöchliger created
+++ lehrkraefte:blc:informatik:glf20:robotik:linefollower [2021/05/21 11:37] (current)
Ivo Blöchliger
@@ Line 7: / Line 7: @@
 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.
-Die einfachste Umsetzung dieser Idee sieht (als Pseudocode) wie folgt aus:
+<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
-rediusRechts = 0.2  # 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.
@@ Line 18: / Line 25: @@
     if hell==0:  # Roboter wurde aufgehoben? Also Ende
         break
-    if hell>grau:     # Bedingung umkehren, wenn in die andere Richtung gefahren werden soll
+    if hell<grau:     # Bedingung umkehren, wenn in die andere Richtung gefahren werden soll
         gear.leftArc(radiusLinks)
     else:
@@ Line 26: / Line 33: @@
 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