Bras robotique contrôlé par Nunchuk (avec Arduino)

Applications et services en ligne

Arduino IDE

À propos de ce projet

Les bras robotiques sont géniaux ! Les usines du monde entier en ont, où elles peignent, soudent et transportent des objets avec précision. On les trouve également dans l'exploration spatiale, les véhicules télécommandés sous-marins et même dans les applications médicales !

Et maintenant, vous pouvez en avoir une version moins chère chez vous, au bureau ou au laboratoire ! Fatigué de faire un travail répétitif? Programmez votre propre robot pour vous aider... ou pour tout gâcher ! :D

Dans ce tutoriel, je vous montre comment monter un bras robotique et comment le programmer à l'aide d'un Arduino Mega. Pour ce projet, je voulais aussi expérimenter une méthode différente pour contrôler un bras robotique :utiliser un Nintendo Nunchuk ! Ils sont bon marché, faciles à trouver et ont un tas de capteurs.

Vous pouvez utiliser ce didacticiel de plusieurs manières. Si vous n'avez pas de kit de bras robotique (et que vous ne voulez pas en acheter ou en construire un), vous pouvez toujours l'utiliser pour apprendre quelque chose sur la programmation Arduino et comment interfacer un Wii Nunchuk avec vos propres projets. Vous pouvez également l'utiliser pour mettre en pratique vos compétences en électronique et en mécanique.

Étape 1 : outils et matériaux

Les outils et matériaux suivants ont été utilisés dans ce projet :

Outils et matériaux :

• Fer à souder et fil. J'ai dû souder des bornes aux fils du Nunchuk afin de le connecter à l'Arduino;

• Tube rétractable. Des morceaux de tube rétractable ont été utilisés pour une meilleure isolation des conducteurs;

• Tournevis. La structure est montée à l'aide de boulons et d'écrous ;

• Bras robotique de bureau mécanique à 6 axes (lien). Ce kit génial est déjà livré avec plusieurs composants comme décrit ci-dessous. Il est fiable et facile à assembler ;

• Alimentation 12 V (2 A ou plus );

• Contrôleur Nunchuk (lien). Il s'interface avec la carte Arduino et sert à contrôler le bras robotique ;

• Câbles de raccordement mâles (4 fils) ;

• Arduino Mega (lien / lien / lien). Notez que le kit de bras robotique que j'ai utilisé contient également un ensemble de cartes et de contrôleurs déjà fournis avec cette carte Arduino. Si vous n'utilisez pas l'un de ces kits, vous pouvez également utiliser d'autres cartes Arduino ;

J'ai appris plus tard qu'il y avait un adaptateur Nunchuk qui facilite la connexion à une breadboad (lien / lien). C'est une bonne option si vous voulez passer du temps à souder et ne voulez pas détruire le connecteur d'origine comme décrit à l'étape 9.

Le bras de bureau mécanique à 6 axes Sain Smart est déjà livré avec les composants suivants :

• Arduino Mega 2560 R3 (lien)

• Bouclier de la carte de contrôle (lien)

• Module émetteur-récepteur sans fil NRF24L01+ (lien)

• Gyroscope 3 axes MPU6050 et accéléromètre 3 axes (lien)

• 71 vis M3X8

• 47 x écrou M3

• 2 supports en U

• 5 supports de servomoteurs

• Servo 4 x 9kg (lien)

• 2 servos 20kg (lien)

• 6 x plateau servo en métal

• 3 supports en U

• 21 x support à angle droit

• 3 x palier à bride

• 1 x pince

Vous pouvez trouver d'autres kits de bras robotiques en ligne, ou même concevoir le vôtre. Il existe des projets impressionnants que vous pouvez imprimer en 3D, par exemple.

Dans les 7 étapes suivantes, je vais vous montrer comment assembler le kit de bras avant de câbler les circuits. Si vous n'avez pas de kit similaire, n'hésitez pas à sauter quelques étapes. Vous pouvez utiliser un autre kit de bras robotique, l'assembler et passer directement aux étapes de l'électronique et de la programmation.

A chaque étape, il y a un gif animé, montrant comment mon bras robotique a été assemblé. Il ne fonctionne que sur la version de bureau du site Web.

Étape 2 :Assemblage du bras robotique Pt1 - Base

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 indiqué sur les images. C'est probablement la partie la plus facile à monter.

Étape 3 :Assemblage du bras robotique Pt2 - Servo #1

Le premier servomoteur est monté perpendiculairement à la base, à l'aide d'un support servo. Ce profilé est fixé à la base à l'aide de quatre boulons et écrous M3, comme le montrent les images. Le servo n°1 est placé sur le dessus et fixé à l'aide de quatre boulons et écrous M3.

Une corne métallique circulaire est attachée à l'axe d'asservissement. Le kit est livré avec plusieurs cornes en plastique. Ils ne seront pas utilisés pour assembler le robot.

Étape 4 :Assemblage du bras robotique Pt3 - Servo #2

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

Un support en U est ensuite fixé au klaxon à l'aide de quatre boulons. Notez qu'un boulon M3 est utilisé en face de l'axe du servo. Il donne de la stabilité à la structure. Un roulement s'adapte sur ce boulon et il est verrouillé en position à l'aide d'un autre écrou M3. De cette façon, le support en U est fermement attaché à l'axe central du servo n°2.

Étape 5 :Assemblage du bras robotique Pt4 - Servo #3

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

À l'autre extrémité, le servo n°3 est installé, à l'aide d'un klaxon métallique circulaire et de quatre boulons. Un support de servomoteur est connecté au servomoteur et un profil en forme de L est lié au support de servomoteur à l'aide de boulons et d'écrous.

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

Étape 6 :Assemblage du bras robotique Pt4 - Servo #4

Un autre support en U est connecté au profilé en L à l'aide d'un jeu de quatre boulons et écrous M3. Comme à l'étape précédente, le servo n°4 est monté sur le support en U à l'aide de quatre boulons. Un autre support de servo est connecté au servo.

Étape 7 :Assemblage du bras robotique Pt4 - Servo #5

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.

Étape 8 :Assemblage du bras robotique Pt4 - Servo #6

La pince est ensuite connectée à l'axe du servo n°5. Sur le dessus, le servo n°6 est connecté à l'aide de boulons, d'écrous et d'un klaxon en métal. La pince a des engrenages, qui transformeront la rotation du servo en un mouvement linéaire de la pince.

Étape 9 :Préparation du contrôleur Nunchuk

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

• Ils sont bon marché ! Les répliques peuvent avoir une qualité inférieure, mais je n'avais pas besoin d'un contrôleur robuste pour ce projet;

• Ils sont faciles à trouver ! Il existe plusieurs répliques originales et peu coûteuses en ligne.

• Il a beaucoup de capteurs ! Chaque contrôleur a deux boutons (boutons Z et C), un joystick à deux axes (X et Y) et un accéléromètre à trois axes;

• Il a une bibliothèque Arduino. Robert Eisele a conçu une bibliothèque étonnante et facile à utiliser pour lire le capteur Nunchuk. Vérifiez-le :https://www.xarg.org/2016/12/using-a-wii-nunchuk-with-arduino/

Malheureusement, les joysticks Nunchuk ont ​​un connecteur compliqué, difficile à interfacer avec d'autres appareils électroniques. Afin de le connecter à l'Arduino, j'ai dû couper son câble et exposer ses fils. De cette façon, cela ne fonctionnera plus avec une Nintendo Wii... :/

J'ai d'abord dû couper le connecteur du joystick et retirer l'isolant des fils. À l'aide d'un multimètre et en fonction de la couleur de chaque fil, j'ai déterminé la fonction de chaque fil (Vcc, GND, SCL et SDA) en fonction du schéma du connecteur montré sur l'image. La couleur des fils n'a pas de norme. J'ai déjà entendu parler des possibilités suivantes :

Original :

• SDA =vert

• SCL =jaune

• 3V3 =rouge

• GND =blanc

Réplique 1 :

• SDA =jaune

• SCL =blanc

• 3V3 =vert

• GND =rouge

Réplique 2 :

• SDA =bleu

• SCL =blanc

• 3V3 =rose

• GND =vert

J'ai soudé les fils à un cavalier mâle, pour une connexion plus facile à la carte Arduino. Pour cela, j'ai utilisé un fer à souder et un tube rétractable, comme indiqué sur les photos.

On m'a informé plus tard qu'il existe un adaptateur Nunchuk qui facilite la connexion à une maquette (lien / lien). C'est une bonne option si vous voulez passer du temps à souder et ne voulez pas détruire le connecteur d'origine.

Étape 10 :Câblage des circuits

Une fois la structure assemblée et les connecteurs Nunchuk terminés, vous serez prêt à câbler les circuits. J'ai utilisé le bouclier de la carte de contrôle fourni avec mon kit de bras robotique. Il facilite le raccordement des composants, puisqu'il est déjà livré avec des connecteurs spécifiques pour les servomoteurs, l'alimentation, etc.

Connectez les composants comme suit :

Nunchouk :

• Nunchuk pin 6 (SCL) => Arduino Mega Pin 21 (SCL) (sur le shield)

• Nunchuk pin 1 (SDA) => Arduino Mega Pin 20 (SDA) (sur le shield)

• Nunchuk pin 3 (Vcc) => Ardino Mega Pin 3V3 (sur le shield)

• Nunchuk pin 4 (Gnd) => Arduino Mega Pin Gnd (sur le shield)

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

• Nunchuk broche 6 (SCL) => Arduino Uno broche A5

• Nunchuk pin 1 (SDA) => Arduino Uno Pin A4

• Nunchuk broche 3 (Vcc) => Ardino Uno broche 3V3

• Nunchuk broche 4 (Gnd) => Arduino Uno Pin Gnd

Servos :

• Borne 11 du blindage de contrôle => Servo #1

• Borne 12 du blindage de contrôle => Servo #2

• Borne de contrôle du blindage 13 => Servo #3

• Borne de contrôle du blindage 8 => Servo #4

• Borne 9 du blindage de contrôle => Servo #5

• Borne 10 du blindage de contrôle => Servo #6

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

• Arduino Pin 11 => Servo #1 (Sgn)

• Arduino Pin 12 => Servo #2 (Sgn)

• Arduino Pin 13 => Servo #3 (Sgn)

• Arduino Pin 8 => Servo #4 (Sgn)

• Arduino Pin 9 => Servo #5 (Sgn)

• Arduino Pin 10 => Servo #6 (Sgn)

• Arduino Gnd => Servos Gnd

• Alimentation 6V => Servos Vcc

Vous aurez également besoin de connecter une alimentation externe 12V. Je suggère un avec plus de 2A de sortie. Les servos consomment beaucoup d'énergie, et si l'alimentation n'est pas assez puissante, les servos vibreront et deviendront très chauds. Ils perdront également de la force.

Ne connectez pas la source d'alimentation avant d'avoir téléchargé le code Arduino (indiqué dans les étapes ultérieures). Il y a un bouton d'alimentation sur le bouclier. Gardez-le sur la position d'arrêt.

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

Étape 11 :Configurer l'IDE Arduino

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 pouvez trouver la dernière version pour Windows, Linux ou MAC OSX 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'incroyable bibliothèque Nunchuk Arduino de Robert Eisele ! Vous pouvez en savoir plus 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

Accédez à Esquisse-> Inclure la bibliothèque -> Gérer les bibliothèques ... sur votre IDE Arduino pour ajouter la bibliothèque.

Comment fonctionne la bibliothèque ?

La bibliothèque Nunchuk est livrée avec un ensemble de fonctions pour lire les capteurs du contrôleur :

nunchuk_buttonZ() :renvoie 1 si le bouton Z est enfoncé, ou 0 si ce n'est pas le cas ; nunchuk_buttonC() :renvoie 1 si le bouton C est enfoncé, ou 0 si ce n'est pas le cas ; 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.

Étape 12 : Code Arduino

Téléchargez le fichier de croquis d'Arduino.

Branchez le câble USB sur le port USB de votre ordinateur et téléchargez le code. Le téléchargement du code prend un certain temps. Vous pouvez utiliser ce temps pour « aimer » et « partager » ce didacticiel pendant que vous attendez ! :D

Une fois le téléchargement terminé, débranchez le câble USB, connectez l'alimentation et allumez le bouton d'alimentation. Le code commencera à s'exécuter immédiatement.

Avertissement :lorsque le code commence à s'exécuter, le bras robotique se déplace très rapidement vers sa position initiale. Veillez à ne pas vous blesser ou endommager les équipements à proximité lors du démarrage !

Vous devrez éventuellement remplacer l'angle de démarrage de chaque servomoteur en fonction de la façon dont vos servos ont été montés.

Code expliqué :

Avant l'installation, le code importe les librairies utilisées sur le sketch (nunchuk.h, wire.h et servo.h ).

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

servo#_speed Les variables définissent la vitesse du mouvement de chaque servo. Si vous voulez qu'un servo spécifique se déplace plus rapidement, augmentez sa valeur. angle#min et angle#max Les variables sont utilisées pour limiter l'angle maximum et minimum pour chaque servo. Vous pouvez définir ces variables afin d'éviter les collisions entre les articulations consécutives du robot.

//Include library#include #include #include //define variables#define SERV1 8 //servo 1 sur le port numérique 8#define SERV2 9 //servo 2 sur port numérique 9#define SERV3 10 //servo 3 sur port numérique 10#define SERV4 11 //servo 4 sur port numérique 11#define SERV5 12 //servo 5 sur port numérique 12#define SERV6 13 / /servo 6 sur le port numérique 13Servo s1 ; //servo 1Servo s2; //servo 2Servo s3; //servo 3Servo s4; //servo 4Servo s5; //servo 5Servo s6; //servo 6//définir l'angle de départ pour chaque servo//choisir une position sûre à partir de laquelle commencer//il essaiera de se déplacer instantanément vers cette position lorsqu'il est mis sous tension!//ces angles dépendront de l'angle de chaque servo pendant le assemblent angle1 =90; //servo 1 actuel angleint angle2 =30; //servo 2 actuel angleint angle3 =0; //servo 3 actuel angleint angle4 =90; //servo 4 actuel angleint angle5 =90; //servo 5 actuel angleint angle6 =45; //servo 6 current angleint servo1_speed =3; //servo 1 speedint servo2_speed =3; //servo 2 speedint servo3_speed =3; //servo 3 speedint servo4_speed =1; //servo 4 speedint servo5_speed =1; //servo 5 speed//définir les restrictions pour chaque servo//ces angles dépendront de l'angle de chaque servo lors de l'assemblage angle1min =0; //servo 1 angle minimumint angle1max =180; //servo 1 angle maximum angleint2min =0; //servo 2 angle minimumint angle2max =180; //servo 2 angle maximum angleint3min =0; //servo 3 angle minimumint angle3max =180; //servo 3 angle maximum angleint4min =0; //servo 4 angle minimumint angle4max =180; //servo 4 angle maximum angleint5min =0; //servo 5 angle minimumint angle5max =180; //servo 5 angle maximum angleint6min =0; //servo 6 angle minimumint angle6max =180; //servo 6 angleboolean maximum display_angles =true; //booléen utilisé pour mettre à jour l'angle de chaque servo sur Serial Monitor 

Lors de la configuration, chaque servo est attaché à une broche spécifique et sa position est démarrée.

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

//SETUPvoid ​​setup() { //attache chaque servo à une broche et démarre sa position s1.attach(SERV1); s1.write(angle1) ; s2.attache(SERV2) ; s2.write(angle2); s3.attache(SERV3) ; s3.write(angle3) ; s4.attache(SERV4) ; s4.write(angle4) ; s5.attache(SERV5) ; s5.write(angle5); s6.attache(SERV6) ; s6.écrire(angle6) ; //démarrer la communication série Serial.begin(9600); //démarrer Nunchuk Wire.begin(); nunchuk_init();} 

La boucle principale est répétée encore et encore. L'état du Nunchuk est lu à chaque cycle. Selon les lectures, différentes commandes sont exécutées.

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

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

Le bloc de code suivant a été utilisé. Tout d'abord, il vérifie si la valeur du joystick est suffisamment grande. De cette façon, le bruit et les petites variations sont ignorés. Si la valeur répond aux exigences, l'angle du servo sera augmenté/diminué à une vitesse donnée.

//Tourner à gauche/droite (à vitesse fixe) //Tourner à gauche si (x> 90) { angle1 -=servo1_speed; display_angles =vrai; if (angle1  angle1max) { angle1 =angle1max; } } s1.write(angle1); //mettre à jour la position du servo 

Un bloc similaire est utilisé pour le joystick y. Il est utilisé pour changer l'angle du servo #3. Servo #2 est maintenu fixe dans ce code.

La rotation de la pince est donnée par les angles de roulis et de tangage du contrôleur, mesurés par son accéléromètre. Afin de faciliter le contrôle 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 code lit l'angle de roulis et l'utilise comme point de consigne. le servo #5 est tourné jusqu'à ce qu'il atteigne le point de consigne. Sa vitesse est proportionnelle à l'erreur entre la position réelle et souhaitée. Un code similaire est utilisé pour le servo 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 (uniquement le bouton Z enfoncé) if (c &&!z) { roll =roll * 57.0 + 90.0; //convertir les degrés servo5_speed =abs(angle5 - roll)/10 + 1; // vitesse proportionnelle fait l'erreur entre l'angle réel et l'angle souhaité if (roll> angle5) { angle5 +=servo5_speed; display_angles =vrai; } if (roll  

La pince est fermée chaque fois que les deux boutons C et Z sont enfoncés. Lorsque l'un de ces boutons est relâché, le robot ouvre sa pince.

//Ouvrir/fermer la pince (les deux boutons enfoncés) if(z &&c) { s6.write(90); //ferme la pince display_angles =true; } else { s6.write(45); //ouvrir la pince } 

Il y a un bloc de code à la fin du sketch. Il affichera sur le moniteur série l'angle réel de chaque servomoteur. Cela peut être utile pour choisir l'angle de démarrage de chaque moteur.

nunchuk.ino

Étape 13 :Utilisation

Maintenant que tout est prêt, allumez le robot et amusez-vous !

Le Nunchuk est utilisé pour contrôler les cinq mouvements montrés sur les images :rotation droite/gauche, mouvement haut/bas, rotation de la pince, mouvement haut/bas de la pince et mouvements d'ouverture/fermeture de la pince. Vous pouvez combiner ces mouvements pour effectuer différentes tâches.

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