Construire un solveur de labyrinthe de lignes à mémoire LSRB

Un suiveur de ligne suit. Un solveur de labyrinthe de lignes décide. C’est tout le saut de ce projet, et il est plus grand qu’il n’y paraît : le robot cesse d’être une boucle de commande à roues et devient quelque chose qui explore un environnement jamais vu, se souvient de ce qu’il a trouvé, et agit sur cette mémoire.

L’astuce est que rien ne remplace le suiveur de ligne — cela s’assoit au-dessus. En dessous, la même barrette de réflectance et la même boucle PID maintiennent le robot centré sur le ruban, sans rien savoir des labyrinthes. Au-dessus, une fine couche de décision surveille les moments où la ligne se ramifie, classe le type de jonction rencontrée, choisit une direction, et écrit un caractère. Cette séparation rend le projet traitable, et c’est la même division en deux couches qu’utilisent partout les vrais robots.

L’ordre de montage compte donc plus que d’habitude. Vous stabilisez d’abord vraiment le suivi simple — réglé en simulateur, puis sur un grand ovale de vrai ruban — et seulement ensuite vous ajoutez les jonctions. Sans cette discipline, chaque problème mécanique, chaque dérive de calibration, chaque roue désalignée de 2 mm apparaîtra déguisée en bug de résolution de labyrinthe.

Suivez l’arbre technologique ci-dessous de haut en bas. Chaque nœud s’ouvre une fois ses prérequis terminés, et votre progression est enregistrée sur cet appareil, pour construire le robot sur un week-end sans perdre votre place.

Nomenclature

Total : environ $35–45. La barrette 8 canaux est la pièce sur laquelle ne pas économiser, et la raison est précise : un robot détecte une branche gauche en remarquant que les capteurs extérieurs gauches sont devenus sombres alors que le centre est encore sur la ligne. Une barrette à peine plus large que le ruban ne peut physiquement pas le voir, donc la détection de jonctions devient du hasard quel que soit le code.

Pourquoi la barrette doit être plus large que la ligne

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

Règle empirique : la barrette devrait faire au moins trois fois la largeur du ruban. Pour du ruban 19 mm, c’est environ 60 mm, ce qu’une barrette 8 canaux au pas de 8 mm donne exactement. Plus étroit et le robot ne peut pas distinguer « la ligne a tourné brusquement » de « la ligne s’est ramifiée », ce qui est la décision centrale sur laquelle repose tout le projet.

Construisez par étapes

L’ordre de montage compte ici plus que dans tout autre projet de ce site. Un solveur de labyrinthe est un suiveur de ligne avec une couche de décision, et chaque défaut mécanique ou de calibration du suiveur réapparaît déguisé en bug de labyrinthe.

L’étape 1 n’est pas négociable. « Suit presque la ligne » devient « invente parfois une jonction », et vous passerez une soirée à déboguer la simplification pour une faute qui est vraiment une roue désalignée de 2 mm.

L’étape 2 est celle qu’on saute. Un solveur exécute des centaines de virages par parcours, et un virage systématiquement court de 5° s’accumule jusqu’à quitter entièrement la ligne. C’est exactement là que le jeu du réducteur apparaît — une erreur qui change de signe avec la direction est mécanique, pas un défaut de réglage.

La division en deux couches, en code

La séparation qui rend ce projet traitable mérite d’être vue explicitement :

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

La couche basse n’apprend jamais ce qu’est un labyrinthe. La couche haute ne touche jamais un moteur. Quand quelque chose tourne mal, cette frontière dit dans quelle moitié chercher — et si vous ne pouvez pas dire dans quelle moitié vit un bug, les couches ne sont pas correctement séparées.

À quoi ressemble un bon résultat

La précision des jonctions est vraiment du tout-ou-rien, et cela surprend. Une jonction mal lue corrompt la chaîne enregistrée, le simplificateur produit alors un parcours faux mais d’apparence valide, et la manche retour fonce avec assurance dans un mur. Il n’y a pas de crédit partiel — c’est pourquoi l’exploration roule lentement et que la manche retour est là où l’on regagne le temps.

Dépannage

Pour aller plus loin

Ajoutez des codeurs et tournez en distance plutôt qu’en temps. Les virages chronométrés sont la plus grande source de non-fiabilité d’un premier solveur, car le temps nécessaire change avec la tension batterie et la surface. Les virages aux codeurs non.

Passez à un labyrinthe à murs — le micromouse — qui remplace le ruban par des murs et la règle LSRB par le remplissage par diffusion. C’est l’étape vraiment plus grande : LSRB est une heuristique de suivi de mur qui trouve un chemin, tandis que le remplissage calcule le plus court et replanifie à mesure que de nouveaux murs sont découverts.

Optimisez la manche retour. Une fois le parcours connu, il ne reste aucune décision à prendre, donc le robot peut accélérer en droites et ne ralentir qu’aux virages. Un profil de mouvement sur l’itinéraire connu est là où viennent les gains de temps spectaculaires — souvent la moitié du temps retour.