C’est un petit robot pédagogique, créé par un Maker français en 2022. Il permet d’initier les enfants à la programmation. Bien sûr, il est possible de faire la même chose sur écran avec un logiciel qui simule le déplacement d’un robot à l’écran.
Mais ça n’a rien à voir, la programmation d’un vrai robot est beaucoup plus passionnante. Non seulement il faut débugger le programme, mais il faut aussi analyser les petits soucis matériels :
- Pourquoi le robot n’avance pas ?
- Pourquoi robot dévie (sur la droite ou la gauche), au lien d’avancer en ligne droite ?
- Pourquoi le robot tourne sur lui même au lieu d’avancer ?
- Pourquoi le robot recule au lieu d’avancer ?
- Etc…
Tous ces problèmes, il faudra les résoudre mais lorsque ça fonctionne enfin, quelle satisfaction (et en plus, vous aurez acquis de nouvelles compétences).
J’aime bien jouer avec ce type de robot, alors quand Romain Boutrois m’a contacté pour me proposer de tester le robot Eliobot, j’ai accepté avec plaisir.
L’article est sponsorisé puisque j’ai reçu ce robot gratuitement, mais je conserve une entière liberté pour vous parler aussi bien des points positifs que des points négatifs.
Pour la petite histoire…
Romain est ingénieur de formation, il a passé beaucoup de temps dans les fablabs et les associations à partager et construire des projet avec d’autres makers et geeks. C’était la grande période des imprimantes RepRap où tout le monde faisait des variantes ou carrément de nouveaux modèles, ainsi que les drones qui commençaient a arriver pour le grand public. Il en a construit beaucoup et c’est ce qui lui a permis de trouver ses premiers jobs dans des startup de drone. Ensuite, il s’est mis à son compte pour accompagner les entreprises dans la conception et l’industrialisation de leurs produits. C’est ce qui lui a donné le temps et l’envie de concrétiser le projet qu’il avait depuis un moment : Un robot pour faire découvrir la robotique aux enfants.
« Eliobot c’est le premier robot officiel de la société, mais c’est peut être mon 20eme (voir beaucoup plus en comptant les projets abandonnés) et celui qui est commercialisé est la 5eme itération après un peu plus de 1 an de tests auprès des enfants notamment. »
« L’avenir pour Eliobot dans un futur proche va être de développer l’écosystème hardware avec des nouveaux capteurs comme le suiveur de ligne et actionneurs et on prépare aussi une plateforme de e-learning avec toutes les ressources, tutos, activités et défis pour progresser en robotique. Il y aura peut être un robot V2, peut être un ou des nouveaux produits … On verra en fonction de la demande. »
Montage du kit
Le robot est en pièces détachées dans une jolie boite en carton.
Le montage est un jeu d’enfant, il suffit d’un simple tournevis cruciforme, vous trouverez les instructions nécessaires à cette adresse.
Et il y a même une petite surprise pour réconforter les Makers après le montage. Miam-Miam !
Présentation du robot
Comme beaucoup de robots de ce type, Eliobot possède 2 roues motrices (à l’avant) et une roue libre (à l’arrière). Sa batterie de 3,7 V (14500) est amovible et se recharge lorsque que le robot est relié une source de courant sur la prise USB-C (qui sert aussi à la programmation). Il y a aussi un bouton poussoir (programmable), une LED adressable (Neopixel), un buzzer, 4 détecteurs d’obstacles à infrarouge (3 à l’avant et 1 à l’arrière) et un emplacement pour ajouter d’autres capteurs (par exemple un suivi de ligne).
Le Microcontrôleur utilisé est un ESP32-S2FN4R2, c’est une excellente nouvelle puisque le robot devrait être capable de communiquer en WiFi.
Il y a aussi 2 petits boutons poussoirs (un peu cachés à l’arrière) :
- Le bouton Reset (noté « EN » sous la carte) qui évite d’éteindre et de rallumer le robot lorsqu’on veut simplement le redémarrer.
- Le bouton « IO0 » qui permet de flasher le firmware de l’ESP32
Personnalisation du robot
Une partie des pièces est imprimée en 3D, les fichiers sont disponibles sur Cults. C’est une très bonne chose puisque vous pourrez les réimprimer en cas de problème.
Mais curieusement, si les bumpers avant et arrière sont imprimés d’une autre couleur que noir, la détection d’obstacles ne fonctionnent plus. Ou plutôt, les capteurs détectent en permanence des obstacles (même quand il n’y en a pas), les LED jaunes sont toujours allumées.
Les détecteurs d’obstacles sont toujours composés d’un émetteur et d’un récepteur. L’émetteur envoie un signal (sonore ou lumineux) et si un objet se trouve suffisamment proche, le signal ricoche dessus est peut être capté par le récepteur.
Eliobot émet en continu des signaux lumineux avec de minuscules LED infrarouges. Normalement les récepteurs sont isolés des lumières parasites par les bumpers.
Je pense que les cloisons sont un tout petit peu trop fines. Cela fonctionne parfaitement avec le noir, parce qu’il absorbe très bien la lumière. Malheureusement, avec des couleurs plus claires, une faible quantité de lumière arrive quand même à passer.
J’ai essayé de modifier les bumpers (en augmentant légèrement l’épaisseur des cloisons) mais le résultat est plutôt mitigé. Cela fonctionne avec le filament gris, mais toujours pas avec le rouge (même augmentant le remplissage à 100%).
Alors j’ai un peu triché, j’ai passé un petit coup de peinture noire à l’emplacement des capteurs (si vous ne dépassez pas, ça ne se verra pas).
En fait, il n’est pas utile de peindre tout (comme sur la photo), il suffit simplement de peindre la cloison.
Mais maintenant, le problème est enfin résolu : PIN-PON !!! PIN-PON !!!
Comme vous l’avez remarqué, j’en ai profité pour faire aussi une coque LEGO. Vous trouverez les fichiers sur Printables, alors je compte sur vous pour personnaliser votre robot.
Programmation avec ElioBlock
ElioBlock, le langage de blocs officiel est disponible à l’adresse suivante : https://app.eliobot.com
Le programme est très intuitif mais en cas de doute, n’hésitez pas à consulter la documentation.
L’interface graphique d’ElioBlock génère le code en CircuitPython (un langage dérivé du MicroPython, créé par Adafruit).
Il faut ensuite téléchargez le fichier main.py (en cliquant sur Programmer) et le copiez dans le robot (comme s’il s’agissait d’une clé USB).
Vous pouvez même modifier par la suite votre programme avec un éditeur de texte.
Voilà un exemple (rudimentaire) de code de détection d’obstacles.
Cela fonctionne, mais puisque le robot dispose de 3 capteurs à l’avant (et d’un à l’arrière), il est possible d’améliorer le programme.
Vous pouvez aussi tester la nouvelle interface de programmation (actuellement encore en Beta). Elle reprend le style visuel de Scratch et devrait simplifier la programmation du robot car elle intègre les tutos. Si cela vous intéresse, les infos sont disponibles ici : https://app.eliobot.com/beta/
CircuitPython avec Thonny
C’est le véritable langage de programmation d’Eliobot. Le CircuitPython est un dérivé open source du langage de programmation MicroPython. Il y a quelques différences entre les 2 langages mais surtout énormément de points communs, ce qui fait qu’il est très facile de passer de l’un à l’autre.
Comme je l’ai dit tout à l’heure, il suffit d’un éditeur de texte pour écrire ou modifier le programme, mais l’utilisation d’un IDE (environnement de développement intégré) comme Thonny simplifie beaucoup les choses (vous pouvez le télécharger ici).
Après avoir installé Thonny, allez dans Exécuter – Configurer l’interprétateur…, sélectionnez CircuitPython (générique) et le port correspondant à la carte (ou laissez « Essayer de détecter le port automatiquement » ).
Vous pouvez taper directement des instructions dans la console, mais pour conserver le code il faut l’enregistrer dans le fichier main.py
Cliquez sur la 2ème icone (une disquette avec une flèche vers le haut), puis sur appareil CircuitPython.
Sélectionnez le fichier main.py et cliquez sur OK.
Vous pouvez lancez le programme avec le triangle sur fond vert ou l’arrêter en cliquant sur le carré sur fond rouge.
Thonny est très pratique pour debugger le programme ou tester rapidement une modification (au niveau des capteurs, buzzer, LED Neopixel). Mais pour tester les déplacements du robot, il faudra quand même brancher et débrancher le câble à chaque fois.
L’IDE Arduino
Il est également possible d’utiliser le langage Arduino pour programmer le microcontrôleur (ESP32) d’Eliobot.
Attention, cela effacera le firmware CircuitPython d’Eliobot, mais ne vous inquiétez pas, j‘expliquerai ensuite comment réinstaller le firmware d’origine.
Tout d’abord, il faut rajouter les paramètres du microcontrôleur (ESP32-S2FN4R2) dans l’IDE Arduino. Pour cela, allez dans Fichier – Préférences et copiez la ligne suivante dans le champ URL de gestionnaire de cartes supplémentaires :
https://raw.githubusercontent.com/espressif/arduino-esp32/gh-pages/package_esp32_dev_index.jsonS’il y a déjà d’autres URL, vous pouvez ajouter celle là, à la suite (en la séparant d’une virgule).
Allez ensuite dans Outils – Type de carte – Gestionnaire de carte, tapez « esp32 » dans le champ de recherche et cliquez sur le bouton Installer.
Vous pouvez maintenant aller dans Outils – Type de Carte – ESP32 Arduino et sélectionner la carte UM TinyS2 (qui utilise le même microcontrôleur).
Appuyez sur le bouton IO0 et connectez Eliobot à l’ordinateur (en laissant encore le doigt appuyé pendant quelques secondes). Si le robot était déjà branchée, vous pouvez aussi appuyer sur le bouton IO0 et ensuite sur le bouton reset (EN) en laissant bien sûr le doigt appuyé sur IO0.
Ensuite, sélectionnez le bon port COM.
Je vous propose de tester le code suivant, il fait clignoter alternativement la LED Neopixel en bleu, en blanc et en rouge (ainsi, vous verrez tout de suite si le téléversement a fonctionné) :
// Eliobot_LED_NeoPixel
// Appel de la bibliothèque NeoPixel
#include <Adafruit_NeoPixel.h>
// Constantes
const int PIN_NEOPIXEL = 1;
const int NB_LED = 1;
// Création de l'objet "neoPixel"
Adafruit_NeoPixel neoPixel = Adafruit_NeoPixel(NB_LED, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
void setup() {
// initialisation du module de LED
neoPixel.begin();
// Intensité lumineuse (de 0 à 100)
neoPixel.setBrightness(10);
}
void loop() {
// LED en bleu
neoPixel.setPixelColor(0,0,0,255);
neoPixel.show();
delay(500);
// LED en blanc
neoPixel.setPixelColor(0,255,255,255);
neoPixel.show();
delay(500);
// LED en rouge
neoPixel.setPixelColor(0,255,0,0);
neoPixel.show();
delay(500);
// Extinction de la LED
neoPixel.clear();
neoPixel.show();
delay(500);
}Le téléversement s’effectue normalement (le pourcentage progresse bien jusqu’à la fin), ne vous inquiétez pas du message d’erreur qui apparait à la fin.
Redémarrez le robot en appuyant sur la touche reset (EN) et vous constaterez que le nouveau programme s’exécute parfaitement (la LED clignote bien en bleu, blanc et rouge).
Il n’est plus nécessaire d’utiliser le bouton IO0 pour reprogrammer le robot, il se comporte maintenant comme un Arduino (vous branchez le robot et vous pouvez lancer directement le téléversement).
Mais comme le port COM a changé, n’oubliez pas de sélectionner le nouveau.
Voilà un exemple de programme de détection d’obstacles (n’hésitez pas à vous en inspirer et éventuellement à l’améliorer, si cela vous amuse) :
// Eliobot_detection_obstacle
// Appel de la bibliothèque NeoPixel
#include <Adafruit_NeoPixel.h>
// Constantes
const int PIN_NEOPIXEL = 1;
const int NB_LED = 1;
const int OBSTACLE_G = 4;
const int OBSTACLE_AV = 5;
const int OBSTACLE_D = 6;
const int OBSTACLE_AR = 7;
const int motorAIN1 = 36;
const int motorAIN2 = 38;
const int motorBIN1 = 35;
const int motorBIN2 = 37;
// Création de l'objet "neoPixel"
Adafruit_NeoPixel neoPixel = Adafruit_NeoPixel(NB_LED, PIN_NEOPIXEL, NEO_GRB + NEO_KHZ800);
void setup() {
pinMode(OBSTACLE_G, INPUT);
pinMode(OBSTACLE_AV, INPUT);
pinMode(OBSTACLE_D, INPUT);
pinMode(OBSTACLE_AR, INPUT);
pinMode(motorAIN1, OUTPUT);
pinMode(motorAIN2, OUTPUT);
pinMode(motorBIN1, OUTPUT);
pinMode(motorBIN2, OUTPUT);
// initialisation du module de LED
neoPixel.begin();
// Intensité lumineuse (de 0 à 100)
neoPixel.setBrightness(20);
//randomSeed(1);
}
void loop() {
if (digitalRead(OBSTACLE_G) == 0){// Obstacle à gauche
tourneDroite(500); // A droite pendant 0.5 seconde
}
else if (digitalRead(OBSTACLE_D) == 0){//Obstacle à droite
tourneGauche(500); // A gauche pendant 0.5 seconde
}
else if(digitalRead(OBSTACLE_AV) == 0) { // Obstacle devant
if(random(2) == 0){
tourneDroite(500); // A droite pendant 0.5 seconde
}
else {
tourneGauche(500); // A gauche pendant 0.5 seconde
}
}
else if (digitalRead(OBSTACLE_AR) == 0){//Obstacle derriere
arret(500); // Arret pendant 0.5 seconde
}
else {// Pas d'obstacle
avant(20);
}
}
// Déplacements du robot
void arret(int duree){
// LED en rouge
neoPixel.setPixelColor(0,255,0,0);
neoPixel.show();
// Arret des moteurs
digitalWrite(motorAIN1, HIGH);
digitalWrite(motorAIN2, HIGH);
digitalWrite(motorBIN1, HIGH);
digitalWrite(motorBIN2, HIGH);
delay(duree);
}
void avant(int duree) {
// LED en vert
neoPixel.setPixelColor(0,0,255,0);
neoPixel.show();
// Moteurs en avant
digitalWrite(motorAIN1, LOW);
digitalWrite(motorAIN2, HIGH);
digitalWrite(motorBIN1, LOW);
digitalWrite(motorBIN2, HIGH);
delay(duree);
}
void arriere(int duree) {
digitalWrite(motorAIN1, HIGH);
digitalWrite(motorAIN2, LOW);
digitalWrite(motorBIN1, HIGH);
digitalWrite(motorBIN2, LOW);
delay(duree);
}
void tourneDroite(int duree) {
arret(100);
arriere(200);
digitalWrite(motorAIN1, HIGH);
digitalWrite(motorAIN2, LOW);
digitalWrite(motorBIN1, LOW);
digitalWrite(motorBIN2, HIGH);
delay(duree);
}
void tourneGauche(int duree) {
arret(100);
arriere(200);
digitalWrite(motorAIN1, LOW);
digitalWrite(motorAIN2, HIGH);
digitalWrite(motorBIN1, HIGH);
digitalWrite(motorBIN2, LOW);
delay(duree);
}Réinstallation du firmware d’origine
Vous souhaitez revenir au firmware d’origine et retrouver un Elibot neuf, comme au premier jour ?
J’ai posé la question à Romain et il m’a indiqué sa procédure (mais bien sûr, je l’ai un peu modifiée à ma sauce). En l’absence de source officielle pour les télécharger, j’ai déposé tous les fichiers nécessaires sur le Github d’Arduiblog. Alors, rendez-vous à l’adresse suivante : https://github.com/arduiblog/eliobot pour récupérer les fichiers eliobot.bin, firmware.uf2 et Sauvegarde ELIOBOT.zip.
ESPtool est très utile pour copier, effacer ou sauvegarder le contenu de l’ESP32. Pour l’installer, Téléchargez et installez la dernière version de Python. Cochez la case Add Python.exe to PATH et cliquez sur Install Now.
Ensuite faites un clic droit sur l’icône Windows, sélectionnez Terminal (administrateur), répondez Oui à la question Voulez-vous autoriser… et tapez le texte suivant (et bien sûr, appuyez sur Entrée) :
pip install esptoolÀ la fin de l’installation vous pouvez vérifier que tout s’est bien passé en tapant :
esptool.py version
Appuyez sur le bouton IO0 et connectez Eliobot à l’ordinateur (en laissant le doigt appuyé encore quelques secondes). Si le robot était déjà branchée, vous pouvez aussi appuyer sur le bouton IO0 et ensuite sur le bouton reset (EN) mais en laissant encore pendant quelques secondes le doigt appuyé sur IO0.
Tapez l’instruction suivante pour avoir des infos sur la carte (notamment le numéro de port série) :
esptool.py flash_id
Pour commencer, nous allons effacer la mémoire de la carte (modifiez le numéro de port en fonction des infos obtenue en tapant la commande précédente)
esptool.py -p COM39 erase_flash
Ensuite, tapez la commande suivante pour flasher le bootloader (adaptez le numéro de port et le chemin du fichier eliobot.bin) :
esptool.py -p COM39 write_flash 0x0 C:\Eliobot\eliobot.bin
Appuyez sur le bouton reset (EN) pour redémarrer le robot. Un nouveau lecteur (nommé TINYS2BOOT) apparait. Copier-y le fichier firmware.uf2
Eliobot redémarre tout seul à la fin de la copie et le lecteur s’appelle maintenant CIRCUIPY. Vous pouvez le renommer (ELIOBOT) en faisant un clic droit dessus et en sélectionnant Propriétés.
Décompressez le fichier Sauvegarde ELIOBOT.zip et copiez tout son contenu dans le robot (directement à la racine du lecteur), n’hésitez pas à remplacer les fichiers du même nom.
Voilà, Eliobot a retrouvé sa configuration initiale. Allumez-le pour vérifier qu’il exécute le programme de démonstration (détection d’obstacles).
Mon avis sur le robot
En général, les moteurs des robots pédagogiques se mettent en marche dés qu’on branche le câble à l’ordinateur, c’est très pénible parce que le robot se sauve alors qu’on essaie de le reprogrammer. Mais là, pas du tout, le robot n’avance que si l’interrupteur est sur ON (mais ça n’empêche absolument pas de le reprogrammer). C’est vraiment génial, je me demande pourquoi les autres n’y ont pas pensé.
Eliobot est capable de rouler en ligne droite sans dévier de sa route (et encore une fois, ce n’est pas le cas de tous les robots pédagogiques), cela montre que les moteurs sont bien équilibrés mais c’est peut être aussi parce que la roue libre est située à l’arrière (au lieu d’être à l’avant).
Les capteurs infrarouges de détection d’obstacle sont bien plus compacts que les habituels capteurs à ultrason mais il sont parfaitement efficaces. J’apprécie aussi les petits plus : la batterie amovible et rechargeable, la LED Neopixel, le buzzer ou le bouton programmable.
Je n’aime pas trop la petite bille qui sert de roue libre (j’aurais préféré une vrai roulette), mais excepté ce petit détail je pense vraiment qu’Eliobot est un très bon robot.
Pour le moment, la documentation est encore insuffisante. Une partie du site est toujours en construction et de nombreuses fonctions (comme le WiFi ou le buzzer) ne sont pas encore expliquées. Il manque aussi un schéma pour indiquer à quels pins sont connectés les différents éléments.
Heureusement cela pourrait très vite changer. Actuellement, Romain se concentre sur la version Beta d’Elioblock et sur les prochaines évolutions (comme le capteur de suivi de ligne), mais il m’a promis qu’il allait aussi enrichir bientôt la documentation.
arduiblog 