On trouve dans le commerce de nombreux équipements « robotisés ». Sous ce terme, je vais volontairement regrouper tout un ensemble d’objets, allant de la voiture télécommandée avec votre smartphone, à la grue meccano ou aux légo technic qui vont pouvoir réaliser seuls ou en semi-autonomie différentes actions.
Pour apprendre la robotique, il existe de nombreux kits à monter, à tous les prix.
Mais n’avez-vous jamais eu envie de réaliser votre propre robot ?
Il ne vous faudra finalement pas grand chose :
– un peu de mécanique,
– un peu d’électronique,
– et un peu de programmation.
Le plus difficile est de trouver l’idée qui donnera à votre robot une touche personnelle.
Pour ce projet « découverte », je vous propose de réaliser des yeux animatroniques tels que ceux présentés ci-dessous.
Ce type de produit se trouve tout fait, mais vous pouvez aussi trouver des fichiers stl à imprimer, voire concevoir vous même.
Côté mécanique
Le principe de fonctionnement mécanique est généralement le même : les yeux peuvent se déplacer de gauche à droite et de haut en bas grâce à des servos-moteurs (2 par oeil). Les paupières peuvent s’ouvrir et se fermer (1 servo par paupière dans mon cas). Nous aurons donc 6 servos-moteurs à piloter.
Côté électronique
Piloter des servos-moteurs est une chose qu’une carte arduino (ou de la même famille) sait parfaitement faire à moindre coût. Pour simplifier au maximum la connectique, nous pouvons même utiliser une carte spécialisée pouvant piloter jusqu’à 16 servo moteurs. Nous verrons cela plus en détail par la suite.
Côté programmation
Nous pourrions programmer directement notre controleur Arduino. Mais j’ai découvert un outil dédié à ce type de tâche (et open-source) : Bottango. Il fonctionne exactement comme un logiciel de montage vidéo, avec une timeline, mais orienté servo-moteur. Ceci permet d’obtenir rapidement un résultat, avec en plus un mode simulation qui permet d’arriver rapidement au résultat souhaité.
Le décor étant maintenant fixé, êtes-vous prêt à vous lancer dans ce mini-projet ? C’est parti !
Chapitre 1 : L’expression du besoin
Pour ce premier projet, le besoin va être très simple :
« je souhaite animer les yeux de la manière suivante :
– ouvrir et fermer les paupières régulièrement (un clignement toutes les 10 secondes)
– regarder à gauche, puis à droite et revenir au centre régulièrement.
Le cycle se répète en permanence.
Chapitre 2 : La programmation de l’animation
Avant d’aborder la réalisation, il est utile d’avoir une idée de la façon dont on va réaliser la programmation de l’animation.
J’ai découvert un logiciel plutôt sympathique pour obtenir rapidement un résultat : « BOTTANGO ».
Cet outil est un logiciel open-source que vous pouver télécharger à cette adresse : https://www.bottango.com/
A noter que si le logiciel est gratuit, le site propose aussi d’acheter des kits tout fait.
Une fois le logiciel installé, il se présente de la façon suivante :
Trois grandes zones sur l’écran :
– à gauche, la gestion des projets (celle qui va nous interresser),
– au centre, de la pub pour les kits,
– à droite, des accès à la communauté.
La première chose à faire est de créer un nouveau projet.
Ce nouvel écran représente l’environnement « physique » de votre futur robot. Le principe de Bottango est assez simple :
– on positionne les éléments mécaniques (par exemple un oeil),
– on ajoute les actionneurs ( les 2 servos moteurs),
– on ajoute les liaisons ( 1 servo fait bouger l’oeil de gauche à droite),
– on définit la timeline de l’animation,
– on simule l’animation.
Si le résultat est correct, on peut transférer l’animation sur notre carte Arduino.
étape 1 : ajout de l’oeil
Bottango permet d’importer des modèles, issus par exemple de FreeCAD, ou toout simplement téléchargés. Il suffit d’aller dans l’onglet « Import » et d’importer le modèle.
Une fois tous les éléments mécaniques importés (pour l’exemple, je ne vais importer qu’un seul oeil), on retourne dans l’onglet « Build » et on clique sur « Create Part ». Ceci ouvre un bandeau qui sera utilisé pour ajouter tous les éléments de notre animation, en particulier les objets et les servos-moteurs.
Voici ce que cela doit donner :
La pièce oeil est liée à un élément Joint, lui même associé au servo moteur.
On peut ainsi voir une simulation des déplacements, à gauche, au centre et à droite.
Nous verrons plus loin que cette simulation peut-être reproduite en live si toute l’électronique est connectée.
étape 2 : l’animation
Une fois les composants positionnés associés aux différentes servos-moteurs, il reste à mettre en place l’animation.
On passe dans l’onglet « Animation » de Bottango.
Pour gérer l’animation, il suffit d’ajouter dans la time line les différents éléments qui l’on souhaite animer. Ici, pour l’exemple, je vais rajouter le « joint ».
Il suffit ensuite de rajouter des « points clés » – comme les images clés dans les logiciels de montage vidéo – et d’affecter une valeur entre 0 et 1 (0.5 étant la position médiane de l’objet).
On arrive assez facilement au résultat souhaité.
en conclusion
Il est très simple de « programmer » ainsi une animation complète. Voici le montage complet, avec les 2 yeux, les paupières et les 6 servos-moteurs de commande.
On ajoute de la même manière les différentes pistes et les points clés de l’animation.
Pour arriver à l’animation suivante finale.
Chapitre 3 : le matériel physique
Pour simplifier au maximum les cablages, et parce que Bottango est nativement capable de la prendre en charge, je vias utiliser une carte PCA9685. Cette carte est capable de prendre en charge jusqu’à 16 servos-moteurs, pour un prix très modique.
Dans le même esprit, plutôt que d’utiliser une carte arduino Uno, je vais utiliser une carte ESP32. Celle-ci est plus puissance et va permettre d’exploiter totalement les 16 sorties de la carte PCA9685 (ll y a une limitation pour le moment avec Bottango et Arduino en nombre de servos pilotables).
Le cablage devient donc très simple : la carte PCA9685 est simplement pilotée en I2C, les broches SCL et SDA simplement connectées aux broches SCL et SDA de l’ESP32.
Le schéma de cablâge se résume donc à celui-ci :
Les 6 servos-moteurs seront connectés sur les sorties de la carte PCA9685, par exemple 1 à 6.
Chapitre 4 : La connexion entre Bottango et le matériel
La connexion entre Bottango et le matériel permet principalement la mise au point des animations. Tout ce que vous effectuez comme action sur l’interface de Bottango se trouve reproduit sur le matériel. On peut ainsi vérifier les vitesses, les limites de position, etc.
Pour effectuer celà, Bottango va utiliser la carte micro-contrôleur (Arduino ou ESP) comme une passerelle. Il est nécessaire pour celà d’installer sur la carte un driver spécifique, fourni avec la distribution de Bottango.
Pour que ceci fonctionne, il faut donc, en préalable, s’assurer que la carte est bien reconnue sur le PC, et connaitre sont adresse. La solution la plus simple est d’utiliser, avant de lancer Bottango, le logiciel Arduino IDE.
On voit ici que la carte ESP32-xxx est bien identifiée, et quelle est connectée sur le port COM14.
C’est un pré-requis indispensable. Si la carte n’est pas identifée à ce stade, Bottango sera incapable de la piloter.
Autre point important à noter : Arduino IDE et Bottango ne peuvent être lancés en même temps. C’est une erreur classique de laisser Arduino IDE en tâche de fond, mais ceci va « bloquer » le port COM, car Arduino IDE n’est pas partageur …
Lorsque l’on exécute Bottango à partir de maintenant, et que l’on ouvre un projet (ou que l’on créé un nouveau projet), nous pouvons accéder à cette page.
Si tout est OK, nous devons retrouver le bon port, et un statut OK sur le driver.
Remarque : Si le statut du driver n’est pas correct, Bottango propose de recharger le driver dans la carte. Mais seuls les drivers pour les cartes Arduino sont actuellement proposés. Pour les cartes ESP, il faudra recharger le driver depuis Arduino IDE.
A partir de ce moment, toute action effectuée dans Bottango, sera répercutée sur le matériel physique. Ci-dessous un exemple avec la paupière droite.
Chapitre 5 : Exportation de l’animation
Maintenant que votre animation est prête et que vous l’avez testée en live, il va falloir l’exporter dans la carte contrôleur afin d’obtenir un système autonome.
Dans l’onglet « Animation », vous trouvez un bouton « Export animations ».
Il suffit de suivre ensuite les différentes étapes.
Etape 1
Dans Bottango, vous pouvez créer plusieurs animations différentes, qui pourront être exécutées séquentiellement ou conditionnellement (nous verrons celà plus loin). La première étape consiste donc à sélectionner les animations à exporter.
Etape 2
Bottango propose aussi de sélectionner les composants concernés par l’animation. On pourrait en effet imaginer créer une animation complexe, et déployer cette animation sur plusieurs controleurs synchronisés.
Etape 3
C’est une étape importante ! Elle conditionne en effet le mode d’exécution de l’animation :
- l’animation doit-elle démarrer à la mise sous tension de la carte ?
- l’animation s’exécute-t-elle en boucle ?
- par quelle animation commence-t-on (si plusieurs animations exportées) ?
- existe-t-il des conditions d’exécution ?
Bottango est correctement documenté, je ne rentrerais pas ici dans les détails des conditionnements.
Etape 4 (et dernière)
Il faut choisir dans cette étape le format d’exportation.
Comme expliqué, le choix va dépendre principalement du type de contrôleur utilisé et de la taille de l’export. Un autre critère de choix peut-être lié à la fréquence de changement de l’animation. Il sera en effet plus simple de remplacer une carte SD que de re-flasher le contrôleur.
En ce qui concerne la génération en fichier JSON, je ne connais pas l’usage.
Si l’on conserve le choix par défaut, à savoir la génération d’un script « Driver Code », Bottango va générer, dans le répertoire de votre choix, 3 fichiers :
- GeneratedCodeAnimations.cpp
- GeneratedCodeAnimations.h
- HowToUseThisCode.txt
Le mode opératoire est décrit dans le fichier .txt, avec de nombreuses autres informations.
En résumé, il suffit de copier/coller les 2 fichiers (.cpp et .h) dans le répertoire BottangoArduinoDriver (créé lors de l’installation de Bottango) , d’ouvrir avec Arduino IDE le fichier .ino contenu dans ce répertoire, et de le téléverser dans la carte. Les fichiers générés pour l’animation seront automatiquement pris en charge.
En conclusion
Avec ce premier article DIY, je voulais vous montrer la facilité (relative) à imaginer votre futur robot. La documentation de Bottango, très complète, pourra vous guider pour aller plus loin, en particulier en personnalisant le fichier du driver fourni, afin d’étendre les possiblités.
Dans le prochain article DIY, je vais vous proposer la réalisation d’une carte plus polyvalente, qui intégrera – en plus du pilotage des servo-moteurs – la prise en compte d’évênements extérieurs, la génération d’effets lumineux et sonores, ainsi que des sorties de puissance.
Bonne découverte de Bottango !
