Linien-Labyrinthlöser bauen: Mit LSRB-Routenspeicher

Ein Linienfolger folgt. Ein Linien-Labyrinthlöser entscheidet. Das ist der ganze Sprung, den dieses Projekt macht, und er ist größer, als es aussieht: Der Roboter hört auf, ein Regelkreis mit Rädern zu sein, und wird etwas, das eine nie gesehene Umgebung erkundet, sich merkt, was er fand, und nach diesem Gedächtnis handelt.

Der Trick ist, dass nichts davon den Linienfolger ersetzt – es sitzt darauf. Darunter halten dasselbe Reflexionsarray und derselbe PID-Regelkreis den Roboter mittig auf dem Band und wissen nichts von Labyrinthen. Darüber beobachtet eine dünne Entscheidungsschicht die Momente, in denen sich die Linie verzweigt, klassifiziert, auf welche Kreuzungsart sie traf, wählt eine Richtung und schreibt ein Zeichen auf. Diese Trennung macht das Projekt handhabbar, und es ist dieselbe Zwei-Schichten-Trennung, die echte Roboter überall nutzen.

Also zählt die Baureihenfolge mehr als sonst. Du bekommst reines Linienfolgen erst wirklich stabil – abgestimmt im Simulator, dann auf einem großen Oval aus echtem Band – und fügst erst dann Kreuzungen hinzu. Wer diese Disziplin überspringt, bei dem zeigt sich jedes mechanische Problem, jede Kalibrierungsdrift, jedes 2 mm schief stehende Rad getarnt als Labyrinthlöse-Bug.

Folge dem Technikbaum unten von oben nach unten. Jeder Knoten öffnet sich, sobald seine Voraussetzungen erfüllt sind, und dein Fortschritt wird auf diesem Gerät gespeichert, sodass du den Roboter über ein Wochenende bauen kannst, ohne den Faden zu verlieren.

Stückliste

Gesamt: ca. $35–45. Das 8-Kanal-Array ist das Bauteil, an dem nicht gespart wird, und der Grund ist spezifisch: Ein Roboter erkennt einen linken Zweig daran, dass die äußersten linken Sensoren dunkel werden, während die Mitte noch auf der Linie ist. Ein Array, das kaum breiter ist als das Band, kann das physisch nicht sehen – Kreuzungserkennung wird dann Raten, egal wie gut der Code ist.

Warum das Array breiter sein muss als die Linie

    left branch                    array (8 channels, ~60 mm wide)
    ────────────────┐          [ x x x . . . . . ]   outer left dark -> a branch
                    │
    ════════════════╪═══════   [ . . . x x . . . ]   centre still on the line
                    │

Faustregel: Das Array sollte mindestens dreimal so breit sein wie das Band. Für 19-mm-Band sind das rund 60 mm, was ein 8-Kanal-Array bei 8 mm Abstand genau liefert. Schmaler, und der Roboter kann „die Linie kurvt scharf“ nicht von „die Linie verzweigt sich“ unterscheiden – die zentrale Entscheidung, auf der das ganze Projekt ruht.

Baue ihn in Meilensteinen

Die Baureihenfolge zählt hier mehr als in jedem anderen Projekt dieser Seite. Ein Labyrinthlöser ist ein Linienfolger mit Entscheidungsschicht, und jeder mechanische oder Kalibrierungsfehler im Folger erscheint getarnt als Labyrinthlöse-Bug.

Meilenstein 1 ist nicht verhandelbar. „Folgt der Linie meistens“ wird zu „erfindet gelegentlich eine Kreuzung“, und du verbringst einen Abend mit Pfadvereinfachungs-Debugging für einen Fehler, der wirklich ein 2 mm schief stehendes Rad ist.

Meilenstein 2 wird gerne übersprungen. Ein Labyrinthlöser fährt Hunderte Drehungen pro Lauf, und eine konstant 5° zu kurze Drehung summiert sich, bis der Roboter die Linie ganz verlässt. Genau hier zeigt sich Getriebespiel – Fehler, der mit der Richtung das Vorzeichen wechselt, ist mechanisch, kein Abstimmungsfehler.

Die Zwei-Schichten-Trennung, im Code

Die Trennung, die dieses Projekt handhabbar macht, ist es wert, explizit zu sehen:

              ┌─────────────────────────────────────┐
    decision  │  classify junction -> choose turn   │   runs only at junctions
      layer   │  record a character -> simplify     │   knows nothing about PWM
              └──────────────────┬──────────────────┘
                                 │ "turn left" / "keep going"
              ┌──────────────────▼──────────────────┐
    following │  read array -> position -> PID      │   runs every loop, ~200 Hz
      layer   │  -> left and right wheel speeds     │   knows nothing about mazes
              └─────────────────────────────────────┘

Die untere Schicht lernt nie, was ein Labyrinth ist. Die obere fasst nie einen Motor an. Wenn etwas schiefgeht, sagt dir diese Grenze, in welcher Hälfte du suchst – und wenn du nicht sagen kannst, in welcher Hälfte ein Bug lebt, sind die Schichten nicht sauber getrennt.

Wie gut aussieht

Kreuzungsgenauigkeit ist wirklich alles oder nichts, und das überrascht. Eine falsch gelesene Kreuzung verdirbt den aufgezeichneten String, der Vereinfacher produziert dann einen gültig aussehenden, aber falschen Pfad, und der Rücklauf fährt selbstbewusst in eine Wand. Es gibt keine Teilpunkte – weshalb Erkundungsläufe langsam fahren und der Rücklauf die Zeit zurückgewinnt.

Fehlersuche

Wie es weitergeht

Encoder hinzufügen und per Distanz statt per Zeit drehen. Zeitgesteuerte Drehungen sind die größte Unzuverlässigkeitsquelle eines ersten Labyrinthlösers, weil die nötige Zeit mit Akkuspannung und Untergrund wechselt. Encoderbasierte Drehungen nicht.

Zum Wandlabyrinth wechseln – die Micromouse – die Band durch Wände und LSRB-Regel durch Flood-Fill ersetzt. Das ist der wirklich größere Schritt: LSRB ist eine Wandfolge-Heuristik, die einen Pfad findet, während Flood-Fill den kürzesten berechnet und bei neu entdeckten Wänden neu plant.

Den Rücklauf optimieren. Ist der Pfad bekannt, bleibt keine Entscheidung übrig – der Roboter kann auf Geraden beschleunigen und nur für Abbiegungen bremsen. Ein Bewegungsprofil über die bekannte Route bringt die dramatischen Zeitgewinne – oft halbiert es den Rücklauf.