Robot

Conception : 

Nous souhaitons réaliser un robot de compagnie muni de 4 pattes  (cuisse + mollet), chacune des pattes est équipée de 2 moteurs (bassin et genou). 

Le robot devrait coûter moins de 50€ et être relativement solide (il faut quand même éviter de marcher dessus :-)

Le robot est réalisé à partir d'un profilé aluminium (de fenêtre) de 78x38 coupé à une longueur de 210mm.

(Sur la photo, le profilé n'est pas encore découpé)

Ce profilé est muni de 4 moteurs (hauts) pas à pas avec réducteur fixé chacun par 2 vis M4 et écrou. Ce sont des petits moteurs pas à pas économiques (on peut en trouver 10 pour une vingtaine d'euros avec leurs cartes de commande ULN2003)

Aliexpress 

Ces moteurs sont très économiques et munis d'un réducteur mais le couple fourni en 5V est vraiment faible, insuffisant pour faire marcher le robot, même avec des cuisses et des mollets courts.

Heureusement, les cartes ULN2003 (livrées avec) sont munis d'un switch qui réunit le commun du moteur au +5V. Il faut ôter le switch et réunir tous les communs des moteurs à la sortie d'un convertisseur +5V->8V ou 9V réglable. Le convertisseur fourni 5A. A noter que l'informatique est conçu pour ne jamais alimenter plus de 2 moteurs en même temps. (Avec les réducteurs, ces moteurs pas à pas sont "irréversibles" et le robot ne va pas s'affaisser sur ses pattes si on coupe un moteur. cette "irréversibilité a de nombreux avantages :

En théorie, les moteurs fonctionnent en 12V mais les moteurs pas à pas, c'est à peu près increvable (ce n'est pas le cas du réducteur avec ses pignons en plastique). En théorie, si on alimente les moteurs en 12V, les bobines vont surchauffer. Mais nous avons vu que seuls 0, 1 ou 2 moteurs sont alimentés en même temps. Ce qui fait que la puissance moyenne d'un moteur (autour de 0.5W) et donc son échauffement est très peu élevé.

Chaque moteur est donc piloté par un ULN2003 (livré avec) et un PCF8574 (non livré avec) en I2C.

ATTENTION : à la mise sous tension, par défaut les PCF8574 sont en entrée à l'état haut avec un pull-up. Ils actionnent donc toutes les entrées de l'ULN2003 : tous les transistors sont saturés et toutes les bobines des 8 moteurs sont activées. Ce qui fait beaucoup de courant : environ 8A ! Conclusion : à la mise sous tension, pendant , mettons une seconde environ : le temps d'initialiser l'I2C et mettre les 4 PCF à 0, le courant est très important. Le convertisseur (qui alimente les ULN2003 mais pas l'Arduino, va probablement s'écrouler. Il faut s'assurer qu'une fois le courant revenu à la normale, il reparte seul. Sinon il faut ajouter une électronique de temporisation

Chaque moteur est muni d'une tôle aluminium 10x2 découpée et percée,(la cuisse) fixée sur un embout vissé sur l'axe du moteur. Avec un entraxe de 25. Au bout de la cuisse est fixé le même type de moteur (bas) tourné vers l'extérieur (le genou) sur l'axe duquel est fixé un embout avec une vis M4 pour bloquer l'axe, une tige filetée M4X20 muni de deux écrous. 

Les cuisses et les mollets ne doivent pas être trop longs pour ne pas exiger un couple trop important aux moteurs (petits mais démultipliés 64 fois).

Les fils du moteur du genou sont fixés à la cuisse et commandés de la même manière avec un ULN2003 et le même PCF8574 en I2C. Tous les PCF8574 sont reliés en bus I2C à un Arduino Nano 33BLE (un Arduino Nano muni d'un Bluetooth et d'accéléromètres 3 axes et d'un magnétomètre). Il est monté à l'avant du robot, prise USB à l'avant pour la programmation : le cerveau.

Tout ça est relié à un bloc batterie muni d'une entrée USBC pour la charge et d'un convertisseur 5V qui alimente l'électronique et les moteurs via embase USB standard.

Le robot est muni "d'yeux" :  un capteur à Ultrason Arduino qui indique la distance (jusqu'à environ 4m) à l'avant.

Un bouton poussoir, à l'arrière, sur le dos du robot permet de l'activer ou de l'arrêter. Un interrupteur classique permet d'éteindre complètement le robot.

Le robot est équipé d'un piezo pour que le robot puisse émettre du son et un microphone.

On pourra plus tard munir le robot d'une tête orientable avec le capteur ultrason, 1 ou 2 axes avec le même type de moteur. Voire une caméra ?

Comme d'habitude, dans ce genre de projet, il faut commencer par construire une mécanique fiable, simple, saine et facile à entretenir. Ensuite on peut attaquer l'électronique, les commandes de moteur, l'I2C, l'Arduino Nano et le bloc batterie. Enfin il faut s'attaquer au code Arduino.

Mécanique :

 

Sur cette vue, l’avant du robot est évidemment à gauche. le capteur à ultra-son, L'Arduino 33BLE et sa prise USB de programmation, le bouton poussoir de veille, l'interrupteur de marche sont visibles, les vis et les écrous. La queue est un cordon USB pour la recharge de la batterie. Les cuisses en tôle aluminium et les mollets des vis M4x30.

Electronique :

Informatique :

Il faut développer un code Arduino, en mesurant l’horizontalité gauche/droite (accéléromètres) 


Le code Arduino :

Il y a donc 8 moteurs : AVGH (Avant gauche haut), AVGB, ARGH, ARGB, ARVDH, AVDB, ARDH, ARDB. Chaque moteur est piloté par son angle en pas par exemple; AVGH=-160.

Il faut définir des routines qui consisterons à envoyer des angles au moteur, une seule fois ou périodiquement :

Ces routines déclencheront l'envoi des angles à chaque moteur en I2C, une fois ou de manière répétitive.

Sur l'Arduino, il nous faut donc des entrées sortie :

Dynamique et programmation :

Lors de la marche, les mouvements des membres sont identiques entre l'avant droit et l'arrière gauche et inversement. Les mouvements entre, par exemple, l'avant droit et l'arrière droit sont identiques mais déphasés. En principe, les cuisses et les mollets ne tournent pas en même temps.

Marche avant :

La séquence complète pour marcher :

Et ainsi de suite...

Autrement dit (vu du point de vue des moteurs, en pas, + = CW, - = CCW=trigo), sur ces moteurs, : 10°=14 pas, 20°=28 pas

Il convient de tester jusqu'où on peut aller en vitesse maxi (environ 2000us/pas), accélération, décélération

L'Arduino calcule les pas et envoie la séquence de pas avec une tempo qui déterminera la vitesse de marche. la séquence de pas se traduit par des suites de 0 et de 1 dans les bobines des moteurs concernés qui tournent en boucle jusqu'à atteindre l'angle requis.

Ex du code très simplifié en I2C :  A la mise sous tension on envoie le code 0000 (hors tension) aux 8 moteurs.

Pour la marche : soulève la cuisse : AVGH=0001, ARGD=0001, AVGH=0010, ARGD=0010, AVGH=0100, ARGD=0100, AVGH=1000, ARGD=1000, pause : par exemple 2 ms, et on recommence : AVGH=0001... La pause détermine la vitesse de rotation des moteurs et finalement la vitesse de marche du robot. (en augmentant ou diminuant la durée (entre, par exemple 2 ms et 20ms) pendant les décélérations et accélérations). Idem en décalé pour les moteurs AVGD et ARGH. Quand la séquence est finie : les 30° sont atteints, après la décélération, on fait une "grosse" pause : ex : 100ms, (on en profite pour vérifier tous les capteurs), puis on attaque les mouvements du mollet de la même manière. On peut provisoirement multiplier toutes les tempo par 10 ou par 100 pour les premiers tests et le debug (Marche avant au ralenti).

Pour limiter le code et éviter de saturer l'Arduino, on ne fait pas bouger les cuisses et les mollets et même temps, ça a un autre avantage : celui de moins solliciter les moteurs en étant sûr que la marche avant soit bien arrêtée avant de démarrer la marche arrière. En fait, les moteurs pas à pas, c'est increvable ! Par contre les pignons du réducteur ont une durée de vie finie...

Nous avons besoin des PCF8574 (8 Entrées/sorties I2C), en effet : les ULN2003 sont des darlingtons de puissance qui n'ont aucune mémoire. les PCF8574, outre le fait de beaucoup simplifier le câblage en I2C, mémorisent la sortie jusqu'à la prochaine. sinon, il faudrait 8x4 = 32 sorties sur l'Arduino + les capteurs (sans parler du câblage)

A noter que nous commandons les moteurs en 5 fils ce qui est moins efficaces qu'en 4 fils mais plus simple.

Lors de la pause entre les mouvements de cuisse et de mollet, on peut en profiter pour vérifier le capteur à ultrason, les accéléromètres, le magnétomètre et les autres consignes. En espérant que l'Arduino soit suffisamment rapide. A noter que l'Arduino 33BLE est nettement plus puissant que l'Arduino Nano standard.

En fait de puissance de calcul, si l'Arduino est trop lent, ça limitera simplement la vitesse maxi du robot :-) (Si la vitesse est limitée par l'informatique, c'est un peu dommage...)

Ce système à 8 moteurs et quatre pattes est très efficace : certains robots industriels quadrupèdes dépassent les 45 km/h) et parviennent à sauter et à même à faire des saltos. Bon évidemment, ici, nous n'en demandons pas tant :-)

Nous pensons que le point faible de ce robot devrait être le dernier pignon de sortie des moteurs et son axe (usure, passage trop rapide avant/arrière, casse si bug et que les jambes se rentrent dedans....). 

Ceci dit, changer un moteur est économique et pas très compliqué...

Si tout marche bien, on pourra protéger l'avant (avec 2 trous pour le capteur et un trou pour la micro USB de programmation), le dessous, l'arrière avec un trou pour la queue USB pour recharger la batterie. 2 trous à l'avant et 2 trous à l'arrière pour les câbles moteurs bas. Avec 1 plaque légère en aluminium cintrée au niveau des coins (arrondis) et fixée à l'avant et à l'arrière ?

Le robot complet devrait peser moins de 1 kg.

Masse estimée du robot (sans dessous) :

TOTAL : 782 g

Réalisation : 

Nous avons réunit une partie des composants du robot : Le profilé est coupé à la bonne longueur mais pas encore percé. L'Arduino et les vis M4, la queue du robot...

Le coffret assemblé, avec son dessous, vu de dessous assemblé par 10 vis :

Nous avons : 

Vue de dessus, on distingue la découpe pour la prise Micro USB de l'Arduino sur le côté du dessous.

Essai des PCF8574 en I2C :

Nous avons installé 2 cartes ULN2003 (livrées avec les moteurs) sur une plaquette à trous munie d'un PCF8574. L'ensemble devra être reproduit 4 fois. Il est relié à la masse (fil noir), au +5V (fil jaune), à l'I2C SDA (fil vert) relié à l'Arduino et l'I2C SCL (fil bleu) relié à l'I2C Arduino. Les cartes ULN2003 ont été légèrement recoupées pour que les 8 rentrent, à plat, dans le coffret.

Si le bloc batterie ne rentre pas dans le profilé, on pourra le fixer sur le dos...

Le code a bien avancé, il y a un peu plus de 700 lignes :

On pourra en rajouter...

L'Arduino élabore le code pour faire tourner les moteurs dans un sens ou dans l'autre avec accélération, vitesse max et décélération. Le PCF modifie ses 8 sorties et les transmet à l'ULN2003 qui allume les diodes Leds rouges et actionne les 2 moteurs en 5 fils. 


Sur la photo :

Nous avons reçu les moteurs et le capteur à ultrason. Nous avons installé le capteur qui fonctionne très bien. Jusqu'à plus de 4m ce qui amplement suffisant. Epatants ces petits capteurs : ça ne coûte presque rien ça fonctionne bien et c'est assez précis...

Nous avons installé un moteur et câblé un autre. Les moteurs fonctionnent bien, pour que le couple soit suffisant, il faut régler la tension de sortie du convertisseur des moteurs autour de 8V. A affiner lorsque les 8 moteurs avec leurs cuisses et mollets et cartes seront installés. Le convertisseur permet de régler facilement la puissance du bidule 

Sur la photo, de gauche à droite : 

On relie le Vcc des moteurs (accessibles sur les ULN2033) à petit convertisseur élévateur 5V->7.5V ou 8V réglable.  (environ 2€).

Etant donné que les moteurs sont "irréversibles" :  ils sont "bloqués" même déconnectés. Par logiciel, dès qu'un moteur a fini de tourner, il est déconnecté. A part pour la marche où 2 moteurs sont activés en même temps, le reste du temps un seul ou aucun moteur n'est activé. Ce qui fait une consommation de 4.5W en moyenne, mettons 5W avec l'Arduino. soit 1A sous 5V. Avec une powerbank de 5Ah, ça fait 5h d'autonomie.

On économise aussi la température des moteurs. (La puissance moyenne dans chaque moteur est d'environ 0.5W ce qui est très faible.

Un autre avantage de moins consommer, c'est de pouvoir prendre une powerbank de plus faible capacité, moins chère, et surtout, plus légère puisqu'elle est portée par le robot..

Les 4 moteurs de cuisse ont été montés. Les 4 cuisses avec les moteurs de mollets et les jambes : des vis M4x20 et les embouts caoutchouc noirs.

 Il manque encore 3  ensembles de 2 ULN2003+ 1 PCF8574...

Le robot est, pour la première fois sur ses pattes. Les moteurs déconnectés tiennent largement le poids du robot.  Il a ses chaussures (les embouts caoutchouc) au bout des mollets.

That's all folks !

Créé le 18/04/2024

A jour le 29/04/2024