Actionneur linéaire (tige filetée) contrôlé par Arduino

Une tige filetée (longue vis) constitue un moyen efficace de transformer un mouvement de rotation en un mouvement de translation linéaire. Ce court projet consiste à bricoler un actionneur électrique linéaire (vérin électrique) au moyen d'un moteur électrique et d'une tige filetée. Le dispositif sera automatisé au moyen d'une carte Arduino Uno.

Voici d'abord une courte séquence vidéo qui montre le résultat:

Couplage de la tige filetée au moteur électrique

J'ai utilisé une tige filetée d'environ 30 cm de longueur et un moteur à courant continu.  Il est possible de se procurer un moteur déjà muni d'une tige fileté, mais je n'en avais pas, et j'ai préféré utiliser un des nombreux moteurs électriques que j'ai accumulés avec les années. C'est facile de trouver une tige filetée dans une quincaillerie.

Pour le couplage de la tige à l'arbre du moteur, j'ai utilisé des tubes thermorétractables (ceux qu'on utilise habituellement pour l'isolation des fils électriques). J'en ai d'abord superposé plusieurs couches sur l'arbre du moteur jusqu'à ce que son diamètre soit similaire à celui de la tige filetée, en prenant soin de chauffer le tube chaque fois pour qu'il soit bien serré sur la couche précédente.

J'ai ensuite couplé l'arbre du moteur et la tige filetée grâce à un tube thermorétractable, bien chauffé pour qu'il enserre bien les deux tiges. 

Partie mobile

L'écrou adapté à la tige fileté est encastrée dans la partie mobile. Il ne faut pas que la partie mobile puisse tourner, d'où sa forme rectangulaire.

Pont en H L9110S

Puisque le moteur devra nécessairement pouvoir tourner dans les deux sens, un pont en H est  nécessaire. J'ai utilisé un module L9110S mais vous avez bien sûr l'embarras du choix: L293D, L298, etc. 

Voici comment j'ai branché le module L9110 au moteur et à l'Arduino Uno:

• Broche GND du L9110: GND de l'Arduino et borne négative de l'alimentation du moteur
• Broche VCC du L9110: Alimentation du moteur (2,5 V à 12 V: utiliser ce qui convient à votre moteur)
• Broche A-IA du L9110: broche 10 de l'Arduino Uno *
• Broche A-IB du L9110: broche 11 de l'Arduino Uno *

*:Doivent être des sorties PWM.

Détecteurs de fin de course: paire LED infrarouge + phototransistor

Pour détecter la présence du mobile près des extrémités de la tige filetée, j'ai choisi d'utiliser, à chaque extrémité, une LED infrarouge et le phototransistor. Lorsque la partie mobile passe entre la LED et le phototransistor, la diminution de luminosité provoque une augmentation de la tension acheminée à une entrée analogique de l'Arduino.

La LED infrarouge était protégée par une résistance de 220 Ω et alimentée par une tension de 5 V. Le modèle que j'ai utilisé était TSAL7400.

Le phototransistor était également alimenté avec une tension de 5 V, et il était associé à une résistance de 10 kΩ. C'est la plus courte des broches du phototransistor qui est branchée à la masse (GND). J'ai utilisé le modèle TOPS-050.

Ici encore, bien d'autres solutions seraient possibles: interrupteur, aimant avec détecteur à effet hall, télémètre à ultrasons...

Sketch Arduino

Le principe est assez simple: on fait tourner le moteur dans un sens ou dans l'autre, selon la valeur de la variable booléenne "sens". Si la partie mobile est détectée par un des phototransistors, il faut changer le sens de rotation des moteurs (donc modifier la valeur de la variable "sens").

Vous devrez probablement modifier la valeur des constantes "seuil1" et "seuil2" qui dépendent de la distance entre la LED infrarouge et le phototransistor, leur alignement, etc.

-

-

À lire aussi:

• Assemblage d'un bras robotique MeArm v0.4
• Robot quadrupède à deux servomoteurs
• Robot suiveur de ligne
• Robot éviteur d'obstacles

Yves Pelletier (Facebook)

Robot quadrupède à base de Raspberry Pi Pico (MicroPython)

Au début du mois, je vous ai présenté un robot quadrupède très facile à fabriquer qui comportait deux servomoteurs branchés à un Arduino Uno. Je vous présente aujourd'hui le même robot, dans lequel j'ai remplacé l'Arduino par un Raspberry Pi Pico programmé en MicroPython.

Dans un premier temps, voici une courte vidéo qui montre le robot en mouvement.

Fabrication du robot

J'ai fabriqué le robot en utilisant du carton et quelques bâtonnets de bois, assemblés avec de la colle et du ruban gommé.

Pour que le robot puisse avancer, il est important que les deux servomoteurs soient inclinés par rapport à l'horizontale, d'où la forme triangulaire du châssis du robot.

Connexions des servomoteurs au Rasbperry Pi Pico

Chaque servomoteur est alimenté par une tension continue de 5 V (broche Vbus du Raspberry Pi Pico).

Servomoteur avant: 

• fil jaune: broche GP15 du Raspberry Pi Pico
• fil rouge: broche Vbus du Raspberry Pi Pico
• fil brun: broche GND du Raspberry Pi Pico

Servomoteur arrière: 

• fil jaune: broche GP13 du Raspberry Pi Pico
• fil rouge: broche Vbus du Raspberry Pi Pico
• fil brun: broche GND du Raspberry Pi Pico

Script en MicroPython

Ce script fait avancer le robot de quelques pas vers l'avant, puis de quelques pas vers l'arrière. Vous devrez probablement ajuster les variables "pwm_avant" et "pwm_arriere": il s'agit de la durée de l'impulsion pour laquelle chaque servomoteur se trouve à sa positon moyenne  (la patte droite n'est alors ni en avant, ni en arrière par rapport à la patte gauche).

Il sera peut-être pertinent de modifier également le contenu de la variable "pas": si vous l'augmentez, le robot fera de plus grandes enjambées (ainsi, il marchera peut-être un peu plus vite, à moins qu'il ne perde l'équilibre...). 

-

-

À lire également

• La version Arduino du même robot
• Les autres projets de robotique
• Programmer le Raspberry Pi Pico en MicroPython avec Thonny

Yves Pelletier (Facebook)

Robot quadrupède à 2 servomoteurs (Arduino)

Je vous présente aujourd'hui un robot quadrupède peu coûteux et très facile à fabriquer.  Il est constitué de deux servomoteurs: un premier servomoteur qui contrôle la paire de pattes avant, et un deuxième servomoteur qui contrôle la paire de pattes arrière. Pour que le robot puisse avancer, il est très important que les servomoteurs soient légèrement inclinés (les pattes ne sont donc pas parfaitement perpendiculaires au sol).

Avant d'aller plus loin, observons le robot en mouvement (il se déplace d'abord vers l'avant, puis ensuite vers l'arrière):

Fabrication du robot

J'ai fabriqué la structure mécanique de mon robot avec du carton, quelques baguettes de bois, un peu de colle et du ruban gommé.

Pour les pattes, j'ai utilisé quatre segments de crayons. Les crayons sont assemblées par paires, collés à chaque extrémité d'une tige de bois. 

Un palonnier de servomoteur est fixé sur la tige de bois, à mi-chemin entre les deux pattes (contrairement à ce que suggère la photo, c'est préférable de visser le palonnier au servomoteur avant de le fixer à la tige de bois).

Pour le châssis, j'ai découpé un rectangle dans du carton ondulé. ainsi que deux triangles pour les côtés. Deux petites ouvertures rectangulaires sont juste assez grandes pour qu'on puisse y insérer les servomoteurs.

On assemble le tout en ne lésinant pas sur le ruban gommé...

J'ai ajouté un peu de ruban gommé sur le bout des pattes pour les rendre plus adhérentes.

Circuit

J'ai fait mes tests avec une carte Arduino Uno mais, puisqu'il s'agit de contrôler deux servomoteurs, n'importe quel microcontrôleur pourvu de 2 sorties PWM fera l'affaire. Si votre robot est de petite taille, vous préférerez peut-être une carte de plus petite dimension comme l'Arduino Nano ou la STM32 Bluepill. Si vous optez pour l'ESP8266 ou l'ESP32, vous ajoutez la possibilité de contrôler votre robot via le réseau WiFi.

Sans surprise, chaque servomoteur est alimenté par une tension de 5 V, et contrôlé par une broche PWM (en l'occurrence les broches 9 et 10).

Installation de la bibliothèque Servo

Si ce n'est pas déjà fait, on installe la bibliothèque Servo au moyen du gestionnaire de bibliothèque.

Sketch

Voici le sketch utilisé: le robot marche un certain temps vers l'avant, puis ensuite vers l'arrière.

-

-

Les 4 phases du mouvement

La marche du robot s'effectue en 4 phases; à chaque phase, un seul des deux servomoteurs change de position:

Phase 1:  servo avant à 70°, servo arrière à 110°

Phase 2: servo avant à 110°, servo arrière à 110°

Phase 3: servo avant à 110°, servo arrière à 70°

Phase 4: servo avant à 70°, servo arrière à 70°

Sources

Ce robot est fortement inspiré de celui qui avait été présenté par Vinod sur son blog Electronics the King of Hobbies. J'ai été intrigué par la simplicité du robot, tout en regrettant que Vinod ait utilisé une carte MSP430 Launchpad programmée...en assembleur!

Le même principe a été utilisé par Edwindertien pour son robot SimpleWalker. Si vous disposez de la machinerie nécessaire, vous serez certainement intéressés par ses plans détaillés (il a fait un robot en contreplaqué et un autre en acrylique). Son sketch Arduino a servi de point de départ à mon propre sketch.

À lire également

• Avec du matériel similaire, vous pouvez fabriquer un robot qui dessine
• Mes autres projets de robotique

Yves Pelletier (Facebook)

Contrôle d'un moteur pas à pas avec un module A4988

Le A4988 est un circuit intégré spécialement conçu pour le contrôle d'un moteur à pas bipolaire. Deux broches suffisent pour contrôler le moteur: une entrée qui provoque la rotation d'un pas, et une autre qui détermine la direction de la rotation.

Le circuit intégré est étonnement petit pour un dispositif capable de tolérer une tension de 35 V et un courant de 2 A. Le module est accompagné d'un petit dissipateur thermique qu'il est conseillé de coller sur le circuit intégré.

Le module comporte 16 broches.

VDD et GND servent à l'alimentation du circuit intégré (3 V à 5,5 V)

Vmot et GND servent à l'alimentation du moteur (8 V à 35 V). Il faut placer un condensateur de 100 µF en parallèle avec l'alimentation pour atténuer les surtensions.

1A, 1B, 2A et 2B sont les sorties vers le bobinage 1 et le bobinage 2 du moteur pas à pas.

Chaque fois que l'entrée STEP passe du niveau logique bas au niveau logique haut, le moteur tourne d'un pas.

Le moteur tourne dans le sens horaire si l'entrée DIRECTION est au niveau logique haut, et dans l'autre sens si elle est au niveau logique bas.

On peut désactiver le module en plaçant l'entrée ENABLE au niveau logique bas. Si vous ne branchez rien à cette entrée, elle demeure par défaut au niveau logique haut.

On peut mettre le module en veille (pour qu'il consomme moins d'énergie) en plaçant son entrée SLEEP au niveau logique bas. Cette entrée est maintenue au niveau logique haut pendant l'utilisation du moteur.

La broche RESET peut être mise brièvement au niveau logique bas pour déclencher une réinitialisation du module (suite à un arrêt pour cause de surchauffe, par exemple). Cette entrée est maintenue au niveau logique haut pendant l'utilisation du moteur.

Les broches MS1, MS2 et MS3 permettent de sélectionner différents degrés de micropas (microstepping). Si vous ne les connectez pas, elles sont, par défaut, au niveau logique bas et le moteur fonctionnera en pas complets. Mais il est possible de régler ces broches de façon à obtenir des demi pas, des quarts de pas, des huitièmes de pas et des seizièmes de pas.

• Pas complet:   MS1 Bas  - MS2 Bas - MS3 Bas
• Demi pas: MS1 Haut - MS2 Bas - MS3 Bas
• Quart de pas: MS1 Bas  - MS2 Haut - MS3 Bas
• Huitième de pas:   MS1 Haut  - MS2 Haut - MS3 Bas
• Seizième de pas:   MS1 Haut  - MS2 Haut - MS3 Haut

Connexions du module A4988 à l'Arduino

Voici comment j'ai branché le module A4988 à une carte Arduino Uno pour effectuer quelques tests.

Réglage du courant maximal

Un petit potentiomètre sert à limiter le courant pour éviter qu'un courant trop intense n'endommage le moteur ou le circuit intégré. Vous pouvez mesurer le courant en plaçant le multimètre en série avec un des bobinages du moteur, ou encore mesurer la tension entre le potentiomètre et la masse. Le courant en ampères est approximativement égal à la tension mesurée (en volts) multipliée par 2,5. Cette mesure dépend de la tension à laquelle est soumise l'entrée Vmot, il faut donc refaire ce réglage si vous modifiez l'alimentation du moteur.

Un exemple de sketch

Voici un sketch qui fait tourner le moteur rapidement dans une direction, et lentement dans l'autre. Le programme est très simple: il n'a pas à alterner la direction du courant dans chaque bobinage comme il aurait à le faire pour un L293D, puisque c'est le A4988 qui fait tout le travail.

Le moteur tourne d'un pas chaque fois que le signal de son entrée STEP passe du niveau logique bas au niveau logique haut. Plus ces impulsions sont rapides, plus le moteur tourne rapidement (la vitesse de rotation est contrôlée par des delay() dans le sketch: un délai court correspond à une vitesse rapide).

Le sens de rotation du moteur dépend de l'état logique de la broche DIRECTION.

-

-

Source:

Page du produit chez Pololu.

À lire également:

Bien d'autres façons de faire tourner un moteur pas à pas avec Arduino: en utilisant le L293D,  l'ULN2003, le L9110S, le L298N ou le L6205.   Pilote de moteur pas à pas autonome .

Yves Pelletier (Twitter, Facebook)

Contrôler un servomoteur avec le Raspberry Pi Pico (MicroPython)

Il n'est pas très difficile de contrôler un servomoteur au moyen du Raspberry Pi Pico programmé en MicroPython.

Un petit servomoteur se contrôle au moyen d'un signal modulé en largeur d'impulsion (PWM) de 50 Hz de fréquence. La position du servomoteur dépend de la durée des impulsions, qu'on fait typiquement varier entre 1 ms et 2 ms.

Connexions du servomoteur au Rasperry Pi Pico

Ces servomoteurs sont conçus pour fonctionner à une tension de 5 V.  Pour faire mes tests, puisqu'il n'y avait qu'un seul petit servomoteur, j'ai utilisé la broche VBUS du Pico comme sortie 5 V. Il est toutefois préférable d'alimenter le servomoteur avec une alimentation distincte.

N'importe quelle broche GPIO du Pico peut générer un signal PWM. Le script ci-dessous suppose que le servomoteur est contrôlé par la broche GP 15.

• Fil brun du servomoteur: broche GND du Pico
• Fil rouge du servomoteur: broche VBUS du Pico (ou autre alimentation 5 V)
• Fil jaune du servomoteur: broche GP 15 du Pico

Exemple de script en MicroPython

Le script ci-dessous fait tourner le servomoteur dans un sens, puis dans l'autre. Par expérimentation, vous devriez pouvoir déterminer les valeur exactes à utiliser comme paramètre à duty_u16() pour que votre servomoteur atteigne les positions extrêmes de son mouvement.  En principe, ça devrait aller d'environ 3000 à 6500, mais ça peut varier un peu d'un servomoteur à l'autre.

Plutôt que duty_u16(), j'aurais pu utiliser la méthode duty_ns(). Mais puisque la durée d'une impulsion de 1,5 milliseconde correspond à 1500000 nanosecondes, les valeurs numériques à utiliser m'ont semblé peu pratiques.

-

-

À lire également

• Programmer le Raspberry Pi Pico en MicroPython
• Écran OLED SH1106 et Raspberry Pi Pico
• Écran couleur SPI ST7735 et Raspberry Pi Pico
• Afficheur TM1638 et Raspberry Pi Pico

Yves Pelletier (Twitter, Facebook)

Bricoler un robot dessinateur BrachioGraph

Le BrachioGraph est un robot dessinateur (plotter, table traçante) qui a été spécialement conçu pour être fabriqué à très faible coût, sans outils et avec très peu de matériel: un Raspberry Pi, trois servomoteurs, deux bâtonnets, une pince à linge et un peu de colle ou de ruban adhésif suffisent à sa réalisation.

Assemblage du robot

C'est la partie la plus simple: on fixe deux palonniers de servomoteur sur un bâtonnet de bois, à 8 cm l'un de l'autre. Sur un deuxième bâtonnet, on fixe un servomoteur et une pince à linge, qui servira à tenir le crayon (on mesure encore une fois 8 cm entre la position du crayon et le moyeu du servomoteur). Vous trouverez une marche à suivre très claire et beaucoup plus détaillée sur la page officielle BrachioGaph par Daniele Procida.

Il en résulte un bras robotisé constitué de deux segments, chacun d'entre pouvant tourner dans un plan horizontal. Le 3e servomoteur sert à soulever le crayon lorsqu'on doit le déplacer sans faire de marque sur la feuille de papier.

Branchements des servomoteurs au Raspberry Pi

Les trois servomoteurs sont alimentées par une des sorties 5 V du Raspberry Pi. 

• Le servomoteur "épaule" (celui qui demeure immobile) est branché à la broche GPIO 14.
• Le servomoteur "coude" (qui fait le lien entre les deux bâtonnets) est branché à la broche GPIO 15.
• Le servomoteur qui soulève le crayon est branché à la broche GPIO 18.

Installation des logiciels dans le Raspberry Pi

Il y a beaucoup de trucs à installer mais, encore une fois, tout est expliqué sur la page de BrachioGraph:

On colle tout ça dans le terminal:

sudo apt install -y python3-venv pigpiod libjbig0 libjpeg-dev liblcms2-2 libopenjp2-7 libtiff5 libwebp6 libwebpdemux2 libwebpmux3 libzstd1 libatlas3-base libgfortran5 git

Et ensuite:

python3 -m venv env
source env/bin/activate

On clone la bibliothèque BrachioGraph:

git clone https://github.com/evildmp/BrachioGraph.git

On entre dans le nouveau répertoire "BrachioGraph":

cd BrachioGraph
pip install -r requirements.txt

Mise à l'essai

Pour démarrer le brachiograph, il faut démarrer le démon pigpiod ainsi qu'un environnement python:

sudo pigpiod
source env/bin/activate
python

from brachiograph import BrachioGraph

bg = BrachioGraph()

À partir de là, on peut écrire des commandes en Python, ligne par ligne (mais à la longue, considérant toutes les commandes de calibrations nécessaires, c'est plus simple d'exécuter un script en python: le site brachio.me présente des exemples de scripts).

L'instruction "bg.box()" ordonne au BrachioGraph de tracer un rectangle. Voici le premier "rectangle" que j'ai obtenu...

Calibration

Il est assez normal d'obtenir ce genre de résultat très approximatif lors de vos premiers essais: le BrachioGraph a besoin d'être calibré pour fonctionner correctement.

Par exemple, le logiciel suppose que vos servomoteurs tournent de 1° chaque fois que la durée des impulsions pwm varie de 10 µs, mais en fait ça varie d'un servomoteur à l'autre.

En faisant quelques tests (qui pourraient être refaits avec une bien meilleure précision), j'ai constaté que:

• Mon premier servomoteur tournait de 1° pour une variation d'environ 8 µs
• Mon deuxième servomoteur tournait de 1° pour une variation d'environ 12 µs
• Mon troisième servomoteur (celui qui était responsable de soulever le crayon) avait rendu l'âme!

J'ai modifié ces paramètres de façon logicielle en écrivant:

bg.servo_1_degree_ms = -8
bg.servo_2_degree_ms = 12

Suite à ces modification, le rectangle tracé par le Brachiograph, sans être parfait, s'était un peu amélioré  (je n'avais pas encore remplacé le 3e servomoteur, d'où le gribouillis indésirable à droite du rectangle).

Il serait possible d'améliorer encore la calibration de mon traceur: 

• en mesurant avec une meilleure précision le nombre de microsecondes correspondant à une rotation de 1°
• en tenant compte de la non-linéarité de mes servomoteurs
• en compensant l'hystérésis
• en minimisant le mouvement du crayon lorsqu'il est soulevé. 

Évidemment, tout ça est expliqué en détails sur la page de BrachioGraph. Je n'ai rien fait de tout ça, parce que ma patience est somme toute assez limitée...

Reproduire l'illustration d'un fichier .jpeg

On peut s'amuser un certain temps à tracer des formes simples en utilisant des commandes comme "bg.drive_xy()", mais là où ça devient vraiment rigolo, c'est quand on utilise le BrachioGraph pour reproduire une image.

Pour ce faire, il faut d'abord convertir l'image en un fichier .json qui décrit toutes les lignes qui devront être tracées par le BrachioGraph.

(voici un extrait d'un fichier json:)

Le répertoire "BrachioGraph" créé sur votre Raspberry Pi contient les programmes nécessaires à cette conversion, mais j'ai préféré utiliser le site "brachio.me" de Rob Bricheno: vous y téléchargez votre fichier (jpeg, png ou autre), et il le transforme en un fichier json prêt à l'emploi.

Vous pouvez alors copier ce fichier json dans le répertoire BrachioGraph du Raspberry Pi, puis le faire tracer par la commande: 

bg.plot_file("nom_du_fichier.json")

Résultat: à la fois impressionnant...et un peu brouillon

Sur figure ci-dessous, de gauche à droite: le fichier original (format jpeg), la version vectorisée par le site brachio.me et, finalement, la copie réalisée, avec une certaine dose d'impressionnisme, par mon BraccioGraph. Il faudrait que j'améliore la calibration (surtout à gauche), mais c'est assez amusant, malgré tout.

Pour terminer, une vidéo montrant mon BrachioGraph au travail, pendant le début de l'illustration (environ 5 minutes sont nécessaires pour réaliser l'illustration complète).

Ressources:

• Page officielle BrachioGaph par Daniele Procida
• brachio.me de Rob Bricheno

À lire également

Avec du matériel similaire, vous pouvez fabriquer un robot quadrupède.

Yves Pelletier (Twitter, Facebook)

Assemblage d'un bras robotique miniature de type MeArm v0.4

MeArm est le nom d'un bras robotique miniature open source dont la première version à été mise au point en 2014. Je me suis procuré un kit similaire à la version 0.4 du MeArm. Si vous avez accès à l'équipement nécessaire, vous pouvez fabriquer les pièces vous-mêmes grâce aux fichiers fournis sur Thingiverse (mais alors vous préférerez peut-être réaliser une version plus récente: ils en sont à la version 3.0).

Je vous montre immédiatement une vidéo de mon bras robotique, une fois monté, en train d'effectuer ses exercices physiques quotidiens:

Le bras est actionné par 4 petits servomoteurs: un d'entre eux fait tourner la base rotative, un autre  sert à ouvrir et fermer la pince...

...un des deux servomoteurs latéraux ("l'épaule"), contrôle la partie antérieure du bras...

... alors que l'autre servomoteur latéral ("le coude"), contrôle l'inclinaison de la partie supérieur du bras.

Assemblage du bras

Au départ, les pièces en acrylique sont disposées sur 4 plaquettes de 14,5 cm X 9,5 cm. C'est le moment idéal d'énoncer notre traditionnelle remarque "Mais...ça semblait beaucoup plus grand sur les photos!". 

(Une fois terminé, le bras semble un peu plus petit que sur les photos, mais plus grand qu'on aurait pu le croire en regardant les pièces détachées)

On détache chacune des 37 pièces, et on prend soin de retirer le papier adhésif protecteur.

Il y a aussi des vis...

Aucune directive d'assemblage n'accompagnait mon kit, mais le vendeur avait proposé un lien vers les instructions officielles de la version 0.4 de MeArm sur le site Instructables. L'assemblage du bras robotique y est extrêmement bien documenté: les instructions sont claires et détaillées, les photographies sont nombreuses. Seul bémol: les pièces qui figurent sur ce guide d'assemblage sont très similaires aux miennes, mais pas rigoureusement identiques, ce qui m'a rendu un peu nerveux au début: je n'étais jamais certain à 100% de faire la bonne chose en utilisant le bon morceau...

Ainsi, j'avais remarqué avec inquiétude que le kit officiel comportait 4 collets servant à fixer un servomoteur, alors que le mien n'en comportait que 3. En cours de route, j'ai constaté qu'il s'agissait d'une pièce de rechange, car plusieurs personnes en cassent un en serrant un vis trop fortement. Pas besoin du 4e collet, alors...

J'avais aussi une petite pièce qui ne ressemblait à rien de ce que je pouvais voir dans les instructions, mais son emplacement est devenu évident vers la fin du montage.

Pas de panique, donc. Il s'agit de ne pas être trop pressé, et d'accepter d'avoir à démonter certaines parties lorsqu'on constate qu'on a placé quelque chose à l'envers (ça m'est arrivé quelques fois). Plusieurs pièces comportent des coches situées d'une façon qui vous oblige à les installer dans le bon sens (ou à constater qu'on a commis une erreur lors d'une étape précédente).

Assemblage de la base rotative (étapes 2, 3, 4 et 5 des instructions):

Le côté gauche (étapes 6, 7 8 et 9 des instructions):

Le côté droit (étapes 10 et 11 des instructions):

Jonction des deux côtés et ajout de la travée centrale (étapes 12, 13 et 14):

Installation sur la base et ajout des avant-bras (étapes 16 et 17):

Assemblage de la pince... (étapes 18 et 19) ... (dans l'excitation du moment, j'ai complètement oublié de prendre quelques photos!)

Et le bras est terminé!

En cours de route, j'ai cassé le coin d'une pièce supportant la pince (la vis devait s'insérer dans le sens contraire à ce qu'indiquaient les instructions...). J'ai pu réparer ma gaffe grâce à un peu de colle. J'ai aussi remplacé deux vis d'articulations qui n'étaient plus retenues par leur pièce de plastique (probablement parce qu'elles avaient été un peu trop souvent dévissées/revissées).

Contrôle des servomoteurs

Puisque mon kit ne comportait aucune carte de contrôle, j'avais l'entière liberté de choisir ce qui me convenait le mieux. J'ai opté pour un Arduino Uno associé à un module PCA9685. J'avais d'abord essayé de brancher les servomoteurs directement à l'Arduino, sans le module PCA9685, mais le comportement du bras devenait erratique lorsque les 4 servomoteurs étaient branchés en même temps.

Le projet MeArm met à notre disposition une bibliothèque de cinématique inverse: il s'agit d'indiquer les coordonnées de la position finale désirée, et la bibliothèque calcule la position angulaire que doit prendre chacun des 4 servomoteurs: cette bibliothèque est offerte en version Arduino, Arduino avec module PCA9685, Raspberry Pi, Beaglebone Black et Espruino.

Avant de passer à ces bibliothèques, je recommanderais de faire quelques tests pour vérifier le bon fonctionnement de chacun des 4 servomoteurs, en démarrant à leur position centrale et en les faisant tourner avec précaution de façon à connaître les limites de leur mouvement.

Les servomoteurs ne semblent pas très loin de leur moment de force maximal: j'ai obtenu des meilleurs résultats en les alimentant avec une tension de 6 V, et en ajoutant un peu de lubrifiant sur les articulations du bras.

À lire aussi:

• le bras robotique Tinkerkit Braccio (plus gros, plus fort, plus cher)
• utilisation du module PCA9685 pour contrôler plusieurs servomoteurs
• autres articles en lien avec la robotique

Yves Pelletier (Twitter, Facebook)