Interaktiver SimulatorMittelstufe

Labyrinthlöser-Simulator für Flood-Fill-Planung

Fahre einen Labyrinthlöser im Browser: Sieh zu, wie er jeden Korridor erkundet, dann per Flood-Fill den einen kürzesten Pfad findet und Bestzeit fährt.

Kategorie
ESP32
Zeitaufwand
2–4 Stunden
Plattform
Browser · ESP32
Technisches Schema: Labyrinthlöser-Simulator für Flood-Fill-PlanungWALL SENSING → FLOOD FILL

01 / Hier starten

Einführung

Labyrinthroboter erkunden zuerst, dann optimieren sie. Dieses Labor zeigt beide Phasen: Der Roboter läuft das Labyrinth per Tiefensuche ab — jeden Korridor entlang, in Sackgassen hinein, zurück — bis alles kartiert ist, flutet dann vom Ziel aus zum einzigen kürzesten Pfad und fährt ihn. Wie ein echter ESP32-Micromouse.

Live lab / Maze exploration & flood-fill shortest path

Maze solver simulator

Watch a robot explore a real maze — down every corridor, into dead ends, backtracking out — then flood-fill the map and speed-run the one shortest path to the centre.

Browser native
A twelve-by-twelve maze solver lab. A robot starts in the bottom-left corner, explores the maze depth-first — backtracking out of dead ends — then flood-fills to find and run the shortest path to the centre. Use the controls below to run it one move at a time.

Bold lines are maze walls. The shaded corridors are everywhere the robot explored (including dead ends it backtracked out of); the bold line is the shortest path found by flood fill; the triangle is the robot and its heading.

  • Wall
  • Explored (wrong paths)
  • Shortest path
  • Goal
Simulation

Ready. Press Start to explore the maze, or Step one move at a time.

Phase
Ready
Explored
1 / 144
Exploration
— moves
Shortest path
— moves
Saved
—
Maze
—

Keyboard: focus the maze, then use Space to run/pause, N to step, R to reset, M for a new maze, and F for full screen.

Steuerung

Wähle einen Modus — Erkunden, dann Bestzeit oder Nur Bestzeit — und drücke Start oder gehe Zug um Zug mit Schritt vor. Neues Labyrinth baut ein frisches Zufallslabyrinth; Zurücksetzen wiederholt dasselbe. Drei Geschwindigkeiten, Tastaturkürzel und Vollbild halten den Lauf kontrollierbar. Fette Linien sind Labyrinthwände, schattierte Korridore alles Erkundete (Sackgassen inklusive), die fette Linie der kürzeste Flood-Fill-Pfad.

Theorie

Ein Gitterlabyrinth sind Zellen, verbunden über offene Kanten, mit Wänden zwischen dem Rest. Für die kürzeste Route muss ein Roboter das Labyrinth erst kennen — dieses Labor fährt daher zwei Phasen.

Erkunden. Der Roboter läuft per Tiefensuche mit Linke-Hand-Regel: An jeder Kreuzung links, wenn möglich, sonst geradeaus, dann rechts. In einer Sackgasse kehrt er zur letzten Kreuzung um und nimmt den nächsten Abzweig. Wiederholt, bis jede Zelle besucht ist, kartiert das das ganze Labyrinth — inklusive aller falschen Wege, die es auszuschließen galt.

Optimieren. Auf fertiger Karte weist Flood-Fill dem Ziel Distanz null zu und propagiert steigende Werte über jede offene Kante nach außen. Jede Zelle hält nun ihre Zieldistanz — der kürzeste Pfad heißt schlicht: Vom Start immer auf einen Nachbarn mit um eins niedrigerer Zahl treten. Diesen Pfad fährt der Roboter als Bestzeit — weit kürzer als das wandernde Erkunden.

Acht-mal-acht-Gitter, eingefärbt nach Flood-Fill-Distanz zum Zentrum. Die vier Zielzellen in der Mitte sind umrandet und mit null beschriftet, jede umgebende Zelle zeigt eine steigende Zahl gleich ihrer Schrittdistanz zum Ziel, mit glattem Gradienten nach außen bis sechs an den Ecken.
Flood-Fill beschriftet jede Zelle mit ihrer Zieldistanz. Der Roboter tritt immer auf einen Nachbarn mit um eins niedrigerer Zahl — das Feld selbst kodiert die Route. SVG herunterladen

Algorithmus

  1. Erkunde das Labyrinth per Tiefensuche mit Linke-Hand-Regel und kehre aus jeder Sackgasse um, bis alle Zellen besucht sind.
  2. Trage jede offene Kante auf beiden Seiten ein, sodass die fertige Karte jede Wand kennt.
  3. Flute vom Ziel: Beschrifte es mit 0 und propagiere steigende Distanzen über jede offene Kante nach außen.
  4. Lies den kürzesten Pfad aus dem Feld: Vom Start wiederholt auf einen Nachbarn mit um eins niedrigerer Distanz treten.
  5. Fahre diesen Pfad als Bestzeit zum Ziel.
  6. Vergleiche Erkundungslänge mit Kürzesten-Länge, um zu sehen, wie viel Herumirren die Karte sparte.

Quellcode

Halte Erkundung, Kartierung, Planung und Bewegung als getrennte Funktionen:

// Phase 1 — map the whole maze, backtracking out of dead ends
exploreDepthFirst(map, robot);        // left-hand rule until every cell is visited

// Phase 2 — flood-fill the finished map and run the shortest path
map.floodFill(goal);                  // goal = 0, distances ripple outward
for (Cell c = start; c != goal; c = map.lowerNeighbor(c))
  robot.driveTo(c);                   // always step one distance lower

Diese Grenze macht denselben Planer testbar in diesem Browser-Labor, auf einem Desktop und auf dem finalen ESP32-Controller.

Annahmen und Unterschiede zur Hardware

Das Labor macht Kartieren sauber, indem es den schweren Teil einer echten Micromouse entfernt: Odometrie. Der simulierte Roboter fährt exakt eine Zelle pro Schritt ohne Schlupf, ohne Gyro-Bias und ohne 90°-Drehfehler, und seine drei Abstandssensoren melden Wände perfekt ohne Fehlalarme. Ein physischer ESP32-Aufbau sammelt jeden Zug Kurs- und Distanzfehler, muss sich an Wänden neu ausrichten und ToF-Messwerte gegen Sonnenlicht und Spannungseinbruch filtern — darum verbringen das Präzisionskurven-Tutorial und die Flood-Fill-Anleitung mehr Zeit mit Bewegung als mit Planung. Nutze diesen Simulator, um zu lernen, warum Flood-Fill neu plant — nicht, um deine Bewegungsschicht zu beweisen.

Schaltplan

Nutze einen externen Regler, bemessen für den Motor-Blockierstrom. ESP32 und Sensoren brauchen eine stabile Logikschiene, auch wenn Motoren umsteuern.

Blockdiagramm der Labyrinthroboter-Verdrahtung. Linker, vorderer und rechter Abstandssensor erreichen einen ESP32 über I²C oder GPIO, Rad-Encoder über interruptfähige GPIO, und der ESP32 treibt einen Motortreiber über PWM- und Richtungsleitungen, der die Motoren versorgt.
Der ESP32 liest drei Abstandssensoren und die Encoder und kommandiert dann die Motoren über einen Treiber an einer Versorgung in Blockierstromgröße. SVG herunterladen

Hardware-Checkliste

Bauteile

  • ESP32-Entwicklungsboard
  • Drei Time-of-Flight- oder Infrarot-Distanzsensoren
  • Zwei Getriebemotoren mit Encoder
  • Dual-Motortreiber und geregelte Batterieversorgung
  • Kompaktes Differenzialantrieb-Chassis

Den Graphen erkunden

Wo dieser Simulator verwendet wird

Die Projekte, Lernpfade und Tutorials, die auf diesem Labor aufbauen.

Weiterbauen

Ressourcen herunterladen

Nutze diese Referenzen auf der Seite, während du das Projekt durcharbeitest. Herunterladbare Projektpakete kommen erst hinzu, wenn ihr Quellcode und ihre Version veröffentlicht sind.

Häufige Fragen

Häufig gestellte Fragen

Welcher Labyrinth-Algorithmus ist der beste für einen ersten Roboter?

Tiefensuche zum Kartieren, dann Flood-Fill für den kürzesten Pfad. Flood-Fill ist didaktisch stark, weil jede erreichbare Zelle einen Distanzwert erhält und jeder Zug prüfbar ist. Dieser Simulator erkundet zuerst und flutet dann die fertige Karte — Kartierung und Kürzeste-Wege-Planung bleiben beide klar.

Wie findet ein Labyrinthroboter den kürzesten Pfad?

Den kürzesten Pfad kann er erst kennen, wenn er das Labyrinth gesehen hat — er erkundet also zuerst. Dieser Simulator nutzt wie eine echte Micromouse zwei Phasen: einen Erkundungslauf, der jeden Korridor und jede Sackgasse abläuft, um alles zu kartieren, dann einen schnellen Lauf auf dem einzigen kürzesten Pfad, den Flood-Fill auf der fertigen Karte offenbart. Die erste Phase ist gründlich und langsam; die zweite kurz und optimal.

Was unterscheidet Flood-Fill von BFS oder A*?

BFS und A* planen über einen bereits bekannten Graphen. Flood-Fill ist für ein Labyrinth gemacht, das noch entdeckt wird: Es weist dem Ziel Distanz null zu und flutet steigende Werte über jede nicht als blockiert bekannte Kante nach außen; sobald eine neu erfasste Wand die Karte ändert, wird neu gerechnet. Das Distanzfeld selbst kodiert die Route — der Roboter tritt einfach auf einen Nachbarn mit um eins niedrigerem Wert.

Was unterscheidet Erkunden und Bestzeit-Lauf?

Erkunden kartiert das Labyrinth: Der Roboter läuft per Tiefensuche in jeden Korridor und jede Sackgasse und kehrt aus den falschen um, bis er jede Wand kennt — dort siehst du ihn alle falschen Wege probieren. Die Bestzeit nutzt diese fertige Karte: Flood-Fill macht daraus ein Distanzfeld, und der Roboter folgt dem einzigen kürzesten Pfad von Start zu Ziel. Erkunden ist langsam und gründlich; die Bestzeit kurz und optimal.

Welche Sensoren braucht eine Micromouse oder ein Labyrinthroboter?

Mindestens Distanzsensoren nach links, vorn und rechts, um die Wände der aktuellen Zelle zu klassifizieren, plus Rad-Encoder, um eine exakte Zellenzahl zu fahren und Kurven sauber zu nehmen. Time-of-Flight- oder Infrarot-Distanzsensoren sind üblich; Encoder zählen, weil Wandsensorik allein nicht sagt, wie weit du gefahren bist.

Warum Flood-Fill statt Wandfolgen?

Wandfolgen (immer eine Hand an der Wand) ist einfach, erreicht aber kein Ziel, das nicht an der Außenwand hängt — etwa die Mitte eines Micromouse-Labyrinths — und findet selten eine kurze Route. Flood-Fill baut eine Distanzkarte des ganzen bekannten Labyrinths, erreicht also ein Innenziel und verbessert sich mit dem Erkunden Richtung Kürzeste.

Weiterführende Literatur

Quellen

Maßgebliche Quellen, um tiefer einzusteigen als das begrenzte Lernmodell dieses Simulators.