Les bras robotisés sont formidables ! On en trouve dans des usines du monde entier, où ils peignent, soudent et transportent des objets avec précision. Ils sont également utilisés dans l'exploration spatiale, les véhicules sous-marins télécommandés et même dans le domaine médical !

Et maintenant, vous pouvez en avoir une version moins chère chez vous, au bureau ou au labo ! Marre des tâches répétitives ? Programmez votre propre robot pour vous aider… ou pour semer la pagaille ! :D

Dans ce tutoriel, je vous montre comment monter un bras robotique et comment le programmer avec une carte Arduino Mega. Pour ce projet, j'ai également voulu expérimenter une autre méthode de contrôle : l'utilisation d'une manette Nintendo Nunchuk ! Elles sont peu coûteuses, faciles à trouver et possèdent de nombreux capteurs.

Ce tutoriel peut être utilisé de plusieurs façons. Même sans kit de bras robotique (et sans souhaiter en acheter ou en construire un), il vous permettra d'apprendre les bases de la programmation Arduino et d'intégrer une manette Wii Nunchuk à vos projets. Vous pourrez également l'utiliser pour perfectionner vos compétences en électronique et en mécanique.

La première pièce à assembler est la base du robot.

Il est composé de deux supports en forme de U, assemblés dos à dos à l'aide de quatre boulons et écrous M3, comme illustré sur les photos. C'est probablement la partie la plus facile à monter.

Un autre support de servo est monté perpendiculairement au précédent. Il est fixé au palonnier du servo n° 1 à l'aide de quatre vis M3. Le servo n° 2 est installé avec quatre vis et écrous M3 et utilise également un palonnier métallique circulaire.

Un support en U est ensuite fixé au palonnier à l'aide de quatre boulons. Notez qu'un boulon M3 est utilisé à l'opposé de l'axe du servo. Il assure la stabilité de la structure. Un roulement est monté sur ce boulon et bloqué en position par un autre écrou M3. De cette manière, le support en U est solidement fixé à l'axe central du servo n° 2.

Un autre support en U est monté à l'aide de quatre boulons et écrous M3.

À l'autre extrémité, le servomoteur n° 3 est installé à l'aide d'un bras métallique circulaire et de quatre boulons. Un support de servomoteur est fixé au servomoteur, et un profilé en L est relié à ce support par des boulons et des écrous.

Notez qu'un autre roulement est utilisé à l'opposé de l'axe du servomoteur, comme décrit précédemment.

Un autre support en U est fixé au profilé en L à l'aide de quatre boulons et écrous M3. De la même manière que précédemment, le servomoteur n° 4 est monté sur le support en U à l'aide de quatre boulons. Un autre support de servomoteur est ensuite fixé à ce dernier.

Le cinquième servo est connecté perpendiculairement au servo n°4 à l'aide d'un autre support de servo, installé à l'aide de quatre boulons et écrous M3.

La pince est ensuite reliée à l'axe du servomoteur n° 5. Sur sa partie supérieure, le servomoteur n° 6 est fixé à l'aide de boulons, d'écrous et d'un bras métallique. La pince est équipée d'engrenages qui transforment la rotation du servomoteur en un mouvement linéaire.

Pour ce projet, j'ai décidé d'utiliser une manette Nintendo Nunchuk pour plusieurs raisons :

1. Ils ne coûtent pas cher ! Les répliques sont peut-être de qualité inférieure, mais je n'avais pas besoin d'une manette robuste pour ce projet ;
2. Ils sont faciles à trouver ! On trouve en ligne plusieurs répliques originales et peu coûteuses.
3. Il possède de nombreux capteurs ! Chaque manette possède deux boutons (boutons Z et C), un joystick à deux axes (X et Y) et un accéléromètre à trois axes ;
4. Elle possède une bibliothèque Arduino. Robert Eisele a conçu une bibliothèque remarquable et facile à utiliser pour la lecture des données des capteurs Nunchuk. Découvrez-la ! https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Malheureusement, les manettes Nunchuk ont ​​un connecteur complexe, difficile à connecter à d'autres appareils électroniques. Pour la brancher à l'Arduino, j'ai dû couper son câble et dénuder ses fils. Du coup, elle ne fonctionne plus avec une Nintendo Wii… :/

J'ai d'abord dû couper le connecteur du joystick et dénuder les fils. À l'aide d'un multimètre, et en me basant sur la couleur de chaque fil, j'ai déterminé sa fonction (Vcc, GND, SCL et SDA) d'après le schéma du connecteur visible sur la photo. La couleur des fils n'est pas standardisée. J'ai déjà entendu parler des possibilités suivantes :

Original:

• SDA = vert
• SCL = jaune
• 3V3 = rouge
• GND = blanc

Réplique n° 1 :

• SDA = jaune
• SCL = blanc
• 3V3 = vert
• GND = rouge

Réplique n° 2 :

• SDA = bleu
• SCL = blanc
• 3V3 = rose
• GND = vert

J'ai soudé les fils à un connecteur mâle pour faciliter la connexion à la carte Arduino. Pour cela, j'ai utilisé un fer à souder et de la gaine thermorétractable, comme indiqué sur les photos.

J'ai appris par la suite qu'il existe un adaptateur Nunchuk qui facilite la connexion à une plaque d'essai. C'est une bonne solution si vous souhaitez gagner du temps sur la soudure et ne pas endommager le connecteur d'origine.

Une fois la structure assemblée et les connecteurs Nunchuk installés, vous pourrez câbler les circuits. J'ai utilisé la carte de contrôle fournie avec mon kit de bras robotique. Elle simplifie le branchement des composants grâce à ses connecteurs spécifiques pour les servomoteurs, l'alimentation, etc.

Connectez les composants comme suit :

Nunchuk :

• Broche 6 du Nunchuk (SCL) => Broche 21 (SCL) de l'Arduino Mega (sur le shield)
• Nunchuk pin 1 (SDA) => Arduino Mega Pin 20 (SDA) (sur le bouclier)
• Nunchuk pin 3 (Vcc) => Ardino Mega Pin 3V3 (sur le bouclier)
• Broche 4 du Nunchuk (Gnd) => Broche Gnd de l'Arduino Mega (sur le shield)

Si vous utilisez une carte Arduino Uno, les broches SCL et SDA de la carte Nunchuk doivent être connectées à différentes broches Arduino, comme suit :

• Nunchuk broche 6 (SCL) => Arduino Uno broche A5
• Nunchuk broche 1 (SDA) => Arduino Uno broche A4
• Nunchuk broche 3 (Vcc) => Ardino Uno broche 3V3
• Broche Nunchuk 4 (Gnd) => Arduino Uno Pin Gnd

Servos :

• Borne 11 du panneau de commande => Servo n° 1
• Borne 12 du panneau de commande => Servo n° 2
• Borne 13 du panneau de commande => Servo n° 3
• Borne 8 du panneau de commande => Servo n° 4
• Borne 9 du panneau de commande => Servo n° 5
• Borne 10 du panneau de commande => Servo n° 6

Si vous n'utilisez pas la carte de contrôle, vous devez utiliser la configuration de broches suivante :

• Broche 11 de l'Arduino => Servo n° 1 (Sgn)
• Broche 12 de l'Arduino => Servo n° 2 (Sgn)
• Broche 13 de l'Arduino => Servo n° 3 (Sgn)
• Broche 8 de l'Arduino => Servo n° 4 (Sgn)
• Broche 9 de l'Arduino => Servo n° 5 (Sgn)
• Broche 10 de l'Arduino => Servo n° 6 (Sgn)
• Arduino Gnd => Servos Gnd
• Alimentation 6 V => Servos Vcc

Il vous faudra également brancher une alimentation externe de 12 V. Je vous recommande un modèle avec un courant de sortie supérieur à 2 A. Les servos consomment beaucoup d'énergie ; si l'alimentation est insuffisante, ils vibreront et chaufferont fortement, perdant ainsi de leur force.

Ne branchez pas l'alimentation avant d'avoir téléversé le code Arduino (voir les étapes suivantes). Le module d'extension comporte un bouton marche/arrêt. Laissez-le sur la position « arrêt ».

Branchez un câble USB à l'Arduino et passez à l'étape suivante.

Maintenant que le matériel est prêt, il est temps de travailler sur le code Arduino.

1. Téléchargez et installez la dernière version de l'IDE Arduino
Vous trouverez la dernière version pour Windows, Linux ou macOS sur le site web d'Arduino : https://www.arduino.cc/en/main/software

Téléchargez-le gratuitement, installez-le sur votre ordinateur et lancez-le.

2. Ajout des bibliothèques

Pour ce projet, j'ai utilisé l'excellente bibliothèque Nunchuk pour Arduino de Robert Eisele ! Vous trouverez plus d'informations à ce sujet sur son site web :

https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Téléchargez la bibliothèque sur https://github.com/infusion/Fritzing/tree/master/Wii-Nunchuk

Naviguer vers Dans votre IDE Arduino , accédez à Croquis -> Inclure une bibliothèque -> Gérer les bibliothèques ... pour ajouter la bibliothèque.

Comment fonctionne la bibliothèque ?

La bibliothèque Nunchuk inclut un ensemble de fonctions permettant de lire les capteurs du contrôleur :

• nunchuk_buttonZ() : renvoie 1 si le bouton Z est enfoncé, ou 0 s'il ne l'est pas ;
• nunchuk_buttonC() : renvoie 1 si le bouton C est enfoncé, ou 0 s'il ne l'est pas ;
• nunchuk_joystickX() : renvoie la valeur x du joystick (entre -127 et 127) ;
• nunchuk_joystickY() : renvoie la valeur y du joystick (entre -127 et 127) ;
• nunchuk_pitch() : renvoie l'angle du contrôleur en radians (entre -180º et 180º) ;
• nunchuk_roll() : renvoie l'angle de roulis du contrôleur en radians (entre -180º et 180º).

Les angles sont renvoyés en radians. J'ai converti ces valeurs en degrés dans mon code Arduino.

Téléchargez le fichier de programme Arduino.

Branchez le câble USB au port USB de votre ordinateur et téléchargez le code. Le téléchargement peut prendre un certain temps. Profitez-en pour « aimer » et « partager » ce tutoriel ! :D

Une fois le téléchargement terminé, débranchez le câble USB, branchez l'alimentation et allumez l'appareil. Le code s'exécutera immédiatement.

Avertissement : au démarrage du programme, le bras robotisé se déplacera très rapidement vers sa position initiale. Veillez à ne pas vous blesser ni à endommager les équipements environnants !

Il vous faudra peut-être remplacer l'angle de départ de chaque servomoteur en fonction de la manière dont vos servos ont été montés.

Explication du code :

Avant la configuration, le code importe les bibliothèques utilisées dans le programme ( nunchuk.h, wire.h). et servo.h ).

Les broches à utiliser sont définies et les variables globales sont déclarées. angle# Les variables entières stockent la position initiale de chaque servomoteur. Si vous souhaitez que votre robot démarre à une autre position, modifiez les valeurs de ces variables.

servo#_vitesse Les variables définissent la vitesse de déplacement de chaque servomoteur. Pour qu'un servomoteur se déplace plus rapidement, augmentez sa valeur. angle#min et angle#max Des variables permettent de limiter l'angle maximal et minimal de chaque servomoteur. Vous pouvez paramétrer ces variables afin d'éviter les collisions entre les articulations consécutives du robot.

 // Inclure les bibliothèques
 #include <nunchuk.h>
 #include <wire.h>
 #include <servo.h>

 //définir les variables
 #define SERV1 8 //servo 1 sur port numérique 8
 #define SERV2 9 //servo 2 sur port numérique 9
 #define SERV3 10 //servo 3 sur le port numérique 10
 #define SERV4 11 //servo 4 sur le port numérique 11 
#define SERV5 12 //servo 5 sur port numérique 12
 #define SERV6 13 //servo 6 sur port numérique 13

 Servo s1 ; //servo 1
 Servo s2 ; //servo 2
 Servo s3 ; //servo 3
 Servo s4 ; //servo 4
 Servo s5 ; //servo 5
 Servo s6 ; //servo 6

 //Définir l'angle de départ pour chaque servo
 //choisissez une position sûre pour démarrer
 //Il tentera de se déplacer instantanément vers cette position une fois allumé !
 Ces angles dépendront de l'angle de chaque servomoteur lors de l'assemblage.
 int angle1 = 90; //angle actuel du servo 1
 int angle2 = 30; //angle actuel du servo 2
 int angle3 = 0; //angle actuel du servo 3
 int angle4 = 90; //angle actuel du servo 4
 int angle5 = 90; //angle actuel du servo 5
 int angle6 = 45; //angle actuel du servo 6
 int servo1_speed = 3; //vitesse du servo 1
 int servo2_speed = 3; //vitesse du servo 2
 int servo3_speed = 3; //vitesse du servo 3
 int servo4_speed = 1; //vitesse du servo 4
 int servo5_speed = 1; //vitesse du servo 5

 //Définir les restrictions pour chaque servo
 Ces angles dépendront de l'angle de chaque servomoteur lors de l'assemblage.
 int angle1min = 0; //angle minimum du servo 1 
int angle1max = 180; // angle maximum du servo 1
 int angle2min = 0; //angle minimum du servo 2
 int angle2max = 180; // angle maximal du servo 2
 int angle3min = 0; //angle minimum du servo 3
 int angle3max = 180; // angle maximal du servo 3
 int angle4min = 0; //angle minimum du servo 4
 int angle4max = 180; // angle maximal du servo 4
 int angle5min = 0; //angle minimum du servo 5
 int angle5max = 180; // angle maximal du servo 5
 int angle6min = 0; //angle minimum du servo 6
 int angle6max = 180; // angle maximum du servo 6

 boolean display_angles = true; // Booléen utilisé pour mettre à jour l'angle de chaque servo sur le moniteur série

Lors de la configuration, chaque servomoteur est fixé à une broche spécifique, et sa position est initialisée.

La communication série (vers le moniteur série) et la communication I2C avec le Nunchuk sont également lancées ici.

 //INSTALLATION

 void setup() {
 //Fixez chaque servo à une broche et démarrez sa position
 s1.attacher(SERV1);
 s1.écrire(angle1);
 s2.attach(SERV2);
 s2.écrire(angle2);
 s3.attach(SERV3);
 s3.écrire(angle3);
 s4.attach(SERV4);
 s4.écrire(angle4); 
s5.attach(SERV5);
 s5.écrire(angle5);
 s6.attach(SERV6);
 s6.écrire(angle6);

 //démarrage de la communication série
 Série.début(9600);

 //démarrer Nunchuk
 Fil.début();
 nunchuk_initialisation();
 }

La boucle principale se répète indéfiniment. L'état du Nunchuk est lu à chaque cycle. Selon les résultats, différentes commandes sont exécutées.

 boucle void() {

 //lire les capteurs Nunchuk
 si (nunchuk_read()) {
 int x = nunchuk_joystickX(); // Position X du joystick
 int y = nunchuk_joystickY(); // Position Y du joystick
 booléen z = nunchuk_buttonZ(); //état du bouton z
 booléen c = nunchuk_buttonC(); //état du bouton c
 float pitch = nunchuk_pitch(); //angle de tangage
 float roll = nunchuk_roll(); //angle de roulis

Le joystick X sera utilisé pour déplacer le servo n° 1.

Le bloc de code suivant a été utilisé. Il vérifie d'abord si la valeur du joystick est suffisamment élevée. Ainsi, le bruit et les petites variations sont ignorés. Si la valeur est conforme, l'angle du servo sera augmenté ou diminué à une vitesse donnée.

 //Tourner à gauche/à droite (à vitesse fixe)
 //Tourner à gauche
 si (x > 90) {
 angle1 -= vitesse_servo1;
 afficher_angles = vrai;
 si (angle1 < angle1min) {
 angle1 = angle1min;
 }
 }
 //Tournez à droite
 si (x < -90) {
 angle1 += vitesse_servo1;
 afficher_angles = vrai ;
 si (angle1 > angle1max) {
 angle1 = angle1max;
 }
 }
 s1.write(angle1); //mise à jour de la position du servo

Un bloc similaire est utilisé pour l'axe Y du joystick. Il sert à modifier l'angle du servomoteur n° 3. Le servomoteur n° 2 reste fixe dans ce code.

La rotation de la pince est déterminée par les angles de roulis et de tangage du contrôleur, mesurés par son accéléromètre. Afin de faciliter la manipulation du bras, l'angle de la pince n'est mis à jour que lorsque les boutons C ou Z sont enfoncés.

Lorsque seul le bouton C est enfoncé, le programme lit l'angle de roulis et l'utilise comme consigne. Le servomoteur n° 5 est mis en rotation jusqu'à atteindre cette consigne. Sa vitesse est proportionnelle à l'écart entre la position actuelle et la position souhaitée. Un programme similaire est utilisé pour le servomoteur n° 4, qui suit l'angle de tangage du Nunchuk.

 // Activer l'accéléromètre uniquement lorsque les boutons sont enfoncés
 // Faire pivoter la pince (seul le bouton Z est enfoncé)
 si (c && !z) {
 roulement = roulement * 57,0 + 90,0 ; //conversion en degrés
 servo5_speed = abs(angle5 - roulis)/10 + 1; //vitesse proportionnelle à l'erreur entre l'angle réel et l'angle souhaité
 si (roulis > angle5) {
 angle5 += servo5_vitesse;
 afficher_angles = vrai ;
 }
 si (roulis < angle5) {
 angle5 -=servo5_vitesse; 
afficher_angles = vrai;
 }
 s5.write(angle5); //mise à jour de la position du servo
 }

La pince se ferme lorsque les boutons C et Z sont enfoncés simultanément. Dès que l'un de ces boutons est relâché, le robot ouvre sa pince.

 //Ouvrir/fermer la pince (appuyer sur les deux boutons)
 si(z && c) {
 s6.write(90); //fermer la pince
 afficher_angles = vrai ;
 }
 autre {
 s6.write(45); //ouvrir la pince
 }

Un bloc de code se trouve à la fin du programme. Il affichera sur le moniteur série l'angle réel de chaque servomoteur. Cela peut s'avérer utile pour choisir l'angle de démarrage de chaque moteur.

Pièce jointe : nunchuk.ino

Maintenant que tout est prêt, mettez le robot sous tension et amusez-vous !

Le Nunchuk permet de contrôler les cinq mouvements illustrés : rotation droite/gauche, mouvement haut/bas, rotation de la pince, mouvement haut/bas de la pince et ouverture/fermeture de la pince. Vous pouvez combiner ces mouvements pour réaliser différentes tâches.

Vous pouvez modifier le code pour obtenir différents mouvements en fonction d'une combinaison des boutons et des angles du joystick.

Si cet article vous a plu, veuillez consulter la publication originale sur Instructables ou Hackster.io .