Aller au contenu
storagebits

Deux robots micro:bit jouent au chat et à la souris, montés en une soirée

Deux robots micro:bit achetés pendant le Covid, un Raspberry Pi, une caméra au plafond et des marqueurs ArUco imprimés sur papier : en une soirée, un POC de robotique pilotable depuis le web.

10 min de lecture#devlog#agents#robotique#microbit

J’ai acheté ces deux robots pendant le Covid, pour faire un peu d’électronique. Le principe du micro:bit me plaisait, surtout avec MakeCode et sa programmation visuelle, et je voulais y amener mes enfants. Sont venus ensuite les châssis :MOVE mini de Kitronik, pour que les cartes se déplacent. Nous avions déjà fait un petit projet pour les télécommander avec des manettes d’arcade. C’était bien, mais il m’avait demandé plusieurs mois de week-ends.

Samedi, je les ai ressortis. Avec l’IA, j’ai monté en une soirée un POC bien plus évolué : deux robots qui jouent au chat et à la souris sur une table, suivis par une caméra au plafond, pilotés depuis une page web par n’importe quel visiteur, ou par une IA quand personne ne se présente. Le brief part à 17 h 53, la démo est filmée à 23 h 30. Entre les deux, il y a eu le flash des robots, la détection spatiale, et une librairie que je ne connaissais absolument pas : ArUco, celle des marqueurs.

Le montage de la démo, 33 secondes sans le son : l'IA contre l'IA, vue de la piste, de la tribune et du ciel, avec le ralenti d'une touche.

# La scène

Au départ, il y a un Raspberry Pi 4 de 2 Go, une webcam USB fixée au bout d’une planche au-dessus d’une table blanche, et les deux robots. Mon brief tenait en un message dicté : une interface web avec de la télémétrie façon SpaceX, un premier jeu où un robot doit toucher l’autre, une file d’attente pour les visiteurs, le pilotage aux flèches ou en ZQSD, et de l’IA quelque part. Le code vivrait sur mon Mac et tournerait sur le Pi.

Un coin de bureau : une étagère avec un vieux PC Tandon et son moniteur, l'écran du Raspberry Pi en dessous, une planche qui dépasse de l'étagère avec une webcam au bout, au-dessus d'une table blanche où attendent les deux petits robots.
La scène au départ : la webcam USB au bout de sa planche, la table blanche qui sert d'arène, et l'écran du Pi en bas à gauche.

Vingt minutes plus tard, le premier commit contenait le système complet : firmware, serveur, vision, arbitre, IA adverse et interface. Rien n’avait encore roulé sur un vrai robot.

# L’architecture

Architecture de micro:brawlDeux robots micro:bit parlent en Bluetooth Low Energy au Raspberry Pi 4 : commandes des roues à 20 Hz dans un sens, télémétrie dans l'autre. Trois caméras envoient leur flux MJPEG au Pi : un téléphone au plafond pour le suivi, une webcam USB et un vieux portable au ras de la table pour le spectacle. Sur le Pi, un serveur FastAPI fait tourner le lien Bluetooth, la vision ArUco, l'arbitre et l'IA, et les ralentis. Le navigateur reçoit l'état dix fois par seconde par WebSocket, la vidéo en MJPEG, et renvoie les touches du pilote.Téléphone au plafondvue du ciel, 720psert au suiviWebcam USBvue pistespectacle et ralentisVieux portablevue tribune, au rasdiffuse à la demandeMJPEGRobot Amicro:bit V1.5 + :MOVE minifirmware MakeCoderoues coupées après 400 msRobot Bmicro:bit V1.5 + :MOVE minifirmware MakeCoderoues coupées après 400 msBluetooth LEroues 20 Hz →← accéléro, temp.Raspberry Pi 4 · 2 Goun serveur FastAPIrobots.pylien BLE, reconnexionvision.pyArUco → cmgame.pyarbitre et IA, 20 Hzreplay.pyralentis des touchesweb/la page de télémétrieNavigateurtélémétrie, vidéo,file d'attenteflèches, ZQSD ou WASDpour piloterétat, 10 Hzvidéo MJPEGtouchesWebSocket
Tout passe par le Pi : une seule connexion par caméra, quel que soit le nombre de spectateurs. Seule la vue du ciel sert au suivi ; les deux autres font le spectacle et les ralentis.

Le Pi fait tout. Il parle aux deux micro:bit en Bluetooth Low Energy, avec bleak : il envoie la vitesse des roues 20 fois par seconde et reçoit l’accélération, les chocs et la température. Il lit les caméras, arbitre la partie, fait jouer l’IA et sert l’interface, une application FastAPI. Le navigateur reçoit l’état du jeu dix fois par seconde par WebSocket, et la vidéo en MJPEG.

Le firmware ne sait rien de la gauche, de la droite ni de l’étalonnage : il applique des vitesses brutes aux deux servos. C’est le Pi qui traduit, ce qui permet de régler un robot sans le reflasher. Si plus aucune commande n’arrive pendant 400 ms, les roues s’arrêtent.

# Le flash : un visage triste et « 020 »

Le premier flash a échoué. Le micro:bit affichait un 0, un 2 et un visage triste : l’erreur 020, plus de mémoire. Mes cartes sont des V1.5, avec 16 Ko de RAM, et la pile Bluetooth de MakeCode n’y tient pas avec tous ses services. L’agent a coupé ceux qui ne servaient à rien ici : la mise à jour par radio, les événements, les informations de l’appareil et le flash partiel. Le programme a démarré.

Le flash lui-même ne demande rien. Un script attend que la carte apparaisse sur le Mac comme une clé USB, y copie le firmware compilé, attend qu’elle se remonte et vérifie qu’elle ne signale pas d’erreur. Dans la soirée, un des micro:bit s’est retrouvé avec un écran vide : le reflasher a pris vingt secondes.

Le reste du temps perdu a été physique. Les robots ne s’allumaient plus, et je suis allé acheter des piles.

# ArUco, la librairie que je ne connaissais pas

Pour savoir où sont les robots, l’agent m’a proposé ArUco, des marqueurs carrés en noir et blanc, dont la détection est intégrée à OpenCV. Je ne la connaissais pas du tout. Elle fait exactement ce dont j’avais besoin : identifier chaque robot, savoir dans quel sens il avance, et le repérer dans l’espace, très vite.

Un marqueur est une grille de 4 × 4 cases dans une bordure noire. Le motif donne un identifiant, 1 pour le robot A et 2 pour le B, et l’ordre des quatre coins donne l’orientation : le bord du haut du marqueur, c’est l’avant du robot. Reste à passer des pixels aux centimètres. Je clique une fois les quatre coins de la table dans l’interface, et une homographie projette chaque point de l’image sur un rectangle de 84 × 55 cm.

Du marqueur ArUco à la position en centimètresChaque image de la caméra du plafond, en 1280 par 720, est décodée directement à moitié de sa taille et en gris. OpenCV y cherche les marqueurs du dictionnaire 4x4_50 : l'identifiant 1 est le robot A, le 2 le robot B, et chaque marqueur trouvé donne ses quatre coins dans l'ordre. Une homographie, calculée à partir des quatre coins de la table cliqués une fois dans l'interface, transforme ces points de l'image en centimètres sur une table de 84 par 55 cm. Le centre du marqueur donne la position, le milieu de son bord du haut donne l'avant du robot, donc son cap.Image du plafond1280×720MJPEG du téléphoneDécodage à ½640×360en gris, depuis le JPEGdetectMarkers15 msid 1 = A, id 2 = B4 coins, dans l'ordreHomographie4 clicscoins de la tablepixels → cmPose du robotx, y, capet vitesse lisséeLe marqueur du robot A (id 1), vu du plafondcoins 0 et 1 : le bord du haut= l'avant du robotcentre = moyenne des 4 coinscap = du centre versle milieu du bord du hautLa table, avant et après l'homographiedans l'imageH84 × 55 cmen centimètres
Toute la vision tient dans ces cinq étapes. Les 15 ms sont mesurées sur le Pi, sur les images du tournage : en pleine taille, il en fallait 46, pour le même taux de détection.

Ma part du travail était là : imprimer la feuille de marqueurs à 100 %, découper les carrés de 4 cm, les coller sur du carton, puis les poser en toit sur chaque robot, à plat, appuyés devant sur la tranche du micro:bit. Avant, l’agent ne pouvait pas dire dans quel sens tournait chaque roue : vu du plafond, un robot sans marqueur fait quelques pixels de large. Une fois les marqueurs collés, il a fait faire quatre petits mouvements à chaque robot et en a déduit le câblage des moteurs, en regardant où ils allaient.

Les deux robots :MOVE mini de face sur la table blanche, le micro:bit debout à l'avant avec ses LEDs rouges allumées, et au-dessus de chacun un marqueur collé sur carton, posé à plat comme un toit.
Les deux robots, avec leur marqueur posé en toit au-dessus du micro:bit.

# Ce qui a cassé

Pendant un match contre l’IA, la partie s’est arrêtée sur « B is not seen », alors que le robot B était bien là, allumé. Mesuré à ce moment-là, son marqueur n’était détecté que sur 51 % des images. Il était un peu caché en partie, et c’est très sensible : un marqueur doit être vu en entier, nettement, pour être reconnu. Je l’ai repositionné, l’agent a élargi les fenêtres de seuillage du détecteur, et les deux robots sont passés à 100 %.

L’autre surprise est venue de la caméra. L’image de la webcam USB était moyenne, et je l’ai remplacée au plafond par un vieux téléphone Redmi avec l’application IP Webcam. L’image était meilleure, mais le décalage entre le moment où je bougeais le téléphone et l’écran m’a paru rédhibitoire pour piloter. La cause : le Pi analysait 17 images par seconde quand le téléphone en envoyait 30, et le retard s’accumulait dans le tampon réseau. L’agent a séparé la lecture du flux et le suivi : un fil vide la caméra en continu, l’autre ne traite que l’image la plus récente.

Puis le téléphone est repassé tout seul en 1080p après un redémarrage de l’application, et les cercles de suivi se sont affichés à côté des robots. Depuis, toute la géométrie est calculée en coordonnées relatives à la taille de l’image, et le serveur reforce le 720p à chaque connexion.

# La caméra qui ne sert pas au suivi

Le vieux portable posé au bord de la table, un eeePC sous Arch Linux, a aussi une webcam. Il était tentant de s’en servir pour la vision. L’agent l’a écarté : en vue rasante, les positions sont inexploitables, et le processeur Atom n’a pas la puissance pour ça. Cette caméra fait le spectacle : une vue tribune, et le ralenti de chaque touche, rejoué à partir des dernières secondes que le Pi garde en mémoire pour chaque caméra. Le portable ne diffuse que quand quelqu’un regarde.

# Le partage des rôles

Ce que j’ai aimé dans ce projet, c’est de voir l’agent et son code agir sur le monde réel. Je voyais très concrètement des robots se déplacer et se comporter. Et je faisais dans le réel ce que l’IA ne peut pas faire : imprimer, découper, coller, préparer.

# Où j’en suis

À 23 h 30, le mode démo faisait jouer l’IA contre l’IA, en matchs de 45 secondes qui s’enchaînent seuls, pendant que l’agent enregistrait les trois caméras et l’interface. Il en a tiré le montage plus haut, les images de ce billet et un fil que j’ai publié le lendemain sur X et Bluesky.

L'interface de micro:brawl en plein match : au centre, la vue du ciel avec les deux marqueurs entourés d'un cercle orange et d'un cercle bleu, la vue piste en incrustation ; à gauche et à droite, la télémétrie de chaque robot ; en bas, le tracé au sol, le journal et l'état du Pi.
L'interface en plein match, en anglais : la vue du ciel avec les marqueurs suivis, la télémétrie de chaque robot de part et d'autre, le tracé au sol, le journal des touches et l'état du Pi.
La même interface, filmée pendant le mode démo : la télémétrie de A, puis de B, le ralenti d'une touche, le tracé et le journal.

Le lendemain matin, l’agent a corrigé ce que le tournage avait montré. Contre l’IA, une touche tombe toutes les 10 secondes environ, et les spectateurs ne voyaient presque que des ralentis : ils sont raccourcis et rendent la main au direct dès la reprise. Une perte du Bluetooth met désormais le match en pause, au lieu de le laisser continuer avec un robot inerte. Le suivi décode l’image à la moitié de sa taille : 15 ms par image sur le Pi au lieu de 46, pour le même taux de détection, parce que le Pi montait à 82 °C et réduisait sa fréquence. Il lui faudra quand même un ventilateur. Ces corrections restent à vérifier sur un vrai match.

Le code est sur GitHub, à titre informatif : storagebits/microbrawl.

# La suite

Ce qui m’amuserait, c’est d’ouvrir le jeu : laisser des inconnus se connecter et piloter les robots, et les voir rouler en direct chez moi. J’ai aussi envie d’élargir à d’autres robots, un Thymio peut-être, ou un mini drone d’intérieur. Les portes sont ouvertes.

# Liens