Bouw een lijndoolhofoplosser-robot met LSRB-routegeheugen

Een lijnvolger volgt. Een lijndoolhofoplosser beslist. Dat is de hele sprong die dit project maakt, en hij is groter dan hij lijkt: de robot stopt niet langer een regellus met wielen te zijn en wordt iets dat een omgeving verkent die het nog nooit heeft gezien, onthoudt wat het heeft gevonden en op basis daarvan handelt.

De truc is dat niets ervan de lijnvolger vervangt — het zit er bovenop. Onderaan houden dezelfde reflectiearray en dezelfde PID-lus de robot gecentreerd op de tape en weten ze niets van doolhoven. Daarboven kijkt een dunne beslissingslaag naar de momenten waarop de lijn vertakt, classificeert welk kruispunt hij tegenkomt, kiest een richting en schrijft één teken op. Die scheiding maakt het project overzichtelijk en is dezelfde tweelaagse splitsing die echte roboten overal gebruiken.

De bouwvolgorde is dus belangrijker dan anders. Je maakt eerst gewone lijnvolging echt stabiel — afgesteld in de simulator en daarna op een grote ovaal van echte tape — en voeg pas dan kruispunten toe. Sla die discipline over en elk mechanisch probleem, elke kalibratiedrift en elk wiel dat 2 mm uit de lijn staat, doet zich voor als een doolhofbug.

Volg de techniekstructuur hieronder van boven naar beneden. Elk knooppunt wordt beschikbaar zodra de vereisten zijn afgerond, en je voortgang wordt op dit apparaat opgeslagen, zodat je de robot in een weekend kunt bouwen zonder je voortgang kwijt te raken.

Stuklijst

Totaal: ongeveer $35–45. De array met acht kanalen is het onderdeel waarop je niet moet bezuinigen, en de reden is specifiek: een robot detecteert een linkertak door te zien dat de buitenste linker sensoren donker worden terwijl het midden nog op de lijn ligt. Een array die maar iets breder is dan de tape kan dat fysiek niet zien, waardoor kruispuntdetectie gokwerk wordt, hoe goed de code ook is.

Waarom de array breder moet zijn dan de lijn

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

Vuistregel: de array moet minstens drie keer zo breed als de tape zijn. Voor 19 mm tape is dat ongeveer 60 mm, en dat krijg je precies met een array van acht kanalen op 8 mm afstand. Met een smallere array kan de robot niet onderscheiden of “de lijn maakte een scherpe bocht” of “de lijn vertakte”, en dat is precies de beslissing waarop het hele project rust.

Bouw de robot in mijlpalen

De bouwvolgorde is hier belangrijker dan in enig ander project op deze site. Een doolhofoplosser is een lijnvolger met een beslissingslaag, en elke mechanische of kalibratiefout in de lijnvolger komt verkleed als een doolhofbug terug.

Mijlpaal 1 is niet onderhandelbaar. “Volgt de lijn meestal” wordt “verzint af en toe een kruispunt”, en je besteedt een avond aan het foutzoeken in padvereenvoudiging voor een fout die in werkelijkheid een wiel 2 mm uit de lijn staat.

Mijlpaal 2 is de stap die mensen overslaan. Een doolhofoplosser voert honderden bochten per rit uit, en een bocht die steeds 5° te kort uitvalt, telt op tot de robot de lijn volledig verlaat. Dit is precies waar tandwielspeling zichtbaar wordt — een fout die van teken verandert naargelang de richting is mechanisch, geen afstemfout.

De tweelaagse splitsing, in code

Het is de moeite waard om de scheiding die dit project overzichtelijk maakt expliciet te zien:

             ┌─────────────────────────────────────┐
   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
             └─────────────────────────────────────┘

De onderste laag leert nooit wat een doolhof is. De bovenste laag raakt nooit een motor aan. Als er iets misgaat, vertelt die grens je welke helft je moet bekijken — en als je niet kunt zeggen in welke helft een bug zit, zijn de lagen niet goed gescheiden.

Hoe een goed resultaat eruitziet

De nauwkeurigheid van kruispunten is echt alles-of-niets, en dat verrast mensen. Eén verkeerd gelezen kruispunt verpest de opgenomen tekenreeks; de vereenvoudiger maakt daarna een ogend geldige maar verkeerde route en de terugrit rijdt zelfverzekerd tegen een muur. Er is geen gedeeltelijke score — daarom verloopt de verkenningsrit langzaam en win je de tijd terug op de terugrit.

Problemen oplossen

Waar je daarna kunt gaan

Voeg encoders toe en draai op basis van de afgelegde afstand in plaats van op basis van tijd. Tijdgestuurde bochten zijn de grootste bron van onbetrouwbaarheid in een eerste doolhofoplosser, omdat de benodigde tijd verandert met de accuspanning en de ondergrond. Bochten op basis van de afgelegde afstand en de encoders hebben dat probleem niet.

Ga naar een doolhof met muren — de micromouse — waarin tape wordt vervangen door muren en de LSRB-regel door flood fill. Dat is de werkelijk grotere stap: LSRB is een heuristiek voor muurvolgen die een pad vindt, terwijl flood fill het kortste pad berekent en opnieuw een route bepaalt zodra nieuwe muren worden ontdekt.

Optimaliseer de terugrit. Zodra het pad bekend is, hoef je niets meer te beslissen en kan de robot op rechte stukken versnellen en alleen voor bochten vertragen. Een bewegingsprofiel over de bekende route levert de grote tijdwinst op — vaak halveert het de terugrit.