Bras de robot Arduino DIY – Contrôlé par des gestes de la main

Outils et machines nécessaires

Imprimante 3D (générique)

À propos de ce projet

Présentation du bras robotique DIY contrôlé par des gestes humains.

Des films à succès comme Pacific Rim, Avatar et d'autres films de science-fiction ont fait allusion à la capacité d'interagir avec les robots, où vos mouvements peuvent être améliorés grâce à l'assistance robotique.

Et si nous pouvions construire le même robot industriel, mais à plus petite échelle ?

Ce projet est une tentative pour y parvenir.

Il s'agit d'un bras robotique Arduino qui peut être programmé ou même contrôlé par des gestes de la main.

En restant fidèle à la convention du costume d'Iron Man, chaque itération serait connue sous le nom de Mark. Ce prototype serait connu sous le nom de MARK 1. Nous pouvons nous attendre à ce que d'autres itérations améliorent le bras robotique d'origine.

Voir le didacticiel complet du bras robotique DIY (contrôlé par les gestes de la main) ici

Présentation

Dans ce didacticiel, nous allons construire un robot à six axes contrôlé par des gestes de la main à l'aide d'un gant robotique. Et en imitant des gestes humains naturels tels qu'un pincement ou une rotation du poignet vers la gauche, vous pourrez ouvrir/fermer ou faire pivoter le bras robotique respectivement vers la gauche et la droite. En effet, contrôler manuellement un bras robotique.

Trouvez plus de détails sur l'article d'origine

Caractéristiques de MARK 1 :

• Rotation sur 6 axes
• Portable
• Contrôler le robot avec des gestes humains
• Peut être préprogrammé pour exécuter des fonctions de base
• Peut être contrôlé sans fil à partir d'une plage
• Peut supporter une charge de 600 g (charge maximale 1 kg)

Liste des pièces

Le bras robotique est entièrement personnalisable. Vous pouvez soit acheter le vôtre, soit imprimer le vôtre en 3D. Si vous choisissez d'imprimer en 3D, pas de soucis. Il existe une liste de différents robots qui utilisent des servomoteurs, donc la théorie de ce que nous construisons s'applique toujours.

Pour ce projet, ce prototype (Mark 1) serait imprimé en 3D car il me donne plus d'espace pour créer des pièces personnalisées.

Bras Robotique : Bras robotique imprimé en 3D Thingiverse (crédits :Wonder Tiger) :

• Partie 1 : Pièces de la pince
• Partie 2 :Base et plateau tournant
• Partie 3 : bras de base robotique

Vous pouvez trouver plus d'informations sur cette construction, ainsi que les types de vis des pièces ci-dessus. Le temps d'impression peut aller jusqu'à 40 heures. Cependant, cela réduit le coût d'achat d'un bras robotique.

Gant Robotique  : Les fichiers Robotic Glove.STL (crédits :Roman 13)

Le gant robotique était un ajout esthétique au projet, mais vous pouvez tout aussi bien utiliser un gant de constructeur pour mettre en œuvre le bras robotique.

Remarque : pour les grandes mains, imprimez à une échelle de 105 %

Comment ça marche

Dans l'ensemble, nous envoyons un signal (via Bluetooth) du gant robotique au servomoteur. Lorsqu'une valeur a été reçue, le servomoteur enverra un signal à un servomoteur spécifique déplaçant le bras robotique.

Maintenant, si nous ajoutons plusieurs servos et plus de capteurs, nous pouvons contrôler chaque moteur. `

Si nous considérons un bras robotique comme une série de servomoteurs se coordonnant les uns avec les autres pour exécuter une fonction, nous pouvons créer un bras robotique contrôlé par un gant robotique.

L'Arduino du gant robotique utilise des capteurs pour communiquer avec l'Arduino du bras robotique et envoie des données pour déplacer un servo à l'angle souhaité.

Vous vous demandez peut-être quels capteurs utilise le gant robotique ?

Pour MARK 1, nous utiliserions des capteurs Flex et un accéléromètre (MPU6050)

• Capteurs Flex – En fonction du degré de courbure de cette pièce en plastique, la résistance change, affectant le courant. Cette mesure est ensuite utilisée pour détecter les changements de mouvement de la main.
• Accéléromètres – Pour des gestes plus naturels, un accéléromètre peut détecter un changement dans la rotation des bras et du poignet.

Nous utilisons ces capteurs pour détecter un changement dans un geste. Nous pouvons ensuite envoyer une valeur spécifique mappée d'un geste au bras robotique pour contrôler un servomoteur via Bluetooth. Et avec suffisamment de gestes, le bras robotique prend vie !

Cartographie du bras robotique

Ce qui suit représente un tableau de mappage des valeurs envoyées au bras robotique par le gant. Cela peut être trouvé sur l'article original. Chacun ayant une clé pour caractériser sa fonction. (P - Pinkie, L - Droit, etc.)

Remarque : "F" majuscule (doigt) représente le sens opposé de la rotation du servomoteur

Assemblage de pièces

Bras robotique – Assemblage

L'achat d'un bras robotique peut être assez coûteux. Pour maintenir ce bras robotisé dans les limites du budget, l'impression 3D d'un bras robotique était la meilleure option.

Cela aide à long terme, car il existe de nombreux exemples de bras robotique imprimé en 3D qui peuvent être personnalisés, par exemple, l'ajout d'une LED, la création d'un support de caméra.

Comme mentionné précédemment, le bras robotique a été modélisé autour du bras robotique sur Thingyverse. J'ai choisi cet exemple car il s'agissait d'une excellente conception fournissant six axes, bien documentée et ayant une résistance / robustesse. Vous pouvez accéder au bras robotique de Wonder Tiger à partir de la liste des pièces.

Vous pouvez également trouver mes remixes pour un support de caméra Robotic Arm. Nous couvrirons cela plus en détail dans une prochaine version. Cependant, les pièces peuvent prendre au moins 40 heures pour imprimer toutes les pièces.

Vous pouvez également trouver de nombreuses autres alternatives au bras robotique imprimé en 3D.

Présentation du servomoteur et du pilote

Étant donné que le bras robotique est idéalement une série de moteurs en coordination, nous pouvons théoriquement attacher plusieurs moteurs qui peuvent tous être alimentés par l'Arduino. Dans ce projet, nous utiliserons le servomoteur PCA9685 pour alimenter le servomoteur MG966R.

Remarque : Utilisez une alimentation externe pour alimenter chaque moteur. L'Arduino ne peut pas fournir suffisamment de puissance pour contrôler tous les moteurs. Dans ce projet, une batterie RC 5V, 2200 mAh a été utilisée.

Le câblage du schéma Arduino doit ressembler à ci-dessous :

NEMA-17 pour la rotation de base

Étant donné que le robot commençait à prendre un peu de poids et que le servomoteur MG966R n'était pas assez puissant pour faire tourner le bras robotique à la base. Pour faire tourner le bras robotique, un moteur plus robuste qu'un servomoteur devrait être utilisé

Un moteur pas à pas (NEMA-17) peut être utilisé en raison de sa précision et de son couple élevé, aidant le bras robotique à pivoter de manière transparente pour les commandes gestuelles.

Le NEMA-17 et le pilote A4988 sont utilisés pour contrôler la direction du moteur, vous pouvez le voir sur le schéma ci-dessous :

Et enfin, le schéma suivant montre l'assemblage final du schéma de câblage du bras robotique complet.

Assemblage de circuits

Le schéma de câblage ci-dessous montre l'assemblage final de toutes les pièces électroniques pour créer un bras robotique, y compris le module Bluetooth. Nous couvrirons le processus d'appariement ci-dessous.

Capteur Flex humain

En restant fidèle à l'esthétique du bras robotique, vous pouvez imprimer un gantelet d'exosquelette imprimé en 3D à utiliser comme gant robotique.

Cependant, vous pouvez utiliser un gant de constructeur standard pour le prototypage du gant robotique. Cette conception « Robot Glove Exosquelette » s'harmonise parfaitement avec la conception du bras robotique.

Le gant robotique se compose des éléments suivants :

• Capteur Flex –  Sur la base du pli du doigt, le courant change que nous pourrions utiliser pour envoyer un signal au moteur
• Accéléromètre (MPU6050 ) - Nous pouvons contrôler le moteur en cartographiant les gestes humains du plan X, Y, Z
• LED - La LED s'allume lorsqu'un contrôle gestuel humain a été envoyé à l'Arduino
• Module Bluetooth (HC-05) – Envoi de données au récepteur du bras robotique HC-05
• Arduino Nano – Le microcontrôleur fonctionnerait comme le cerveau du gant robotique

Le schéma suivant est idéal pour tester le capteur de flexion et l'accéléromètre.

Important : Le bras robotique ne sera aussi précis que le contrôle du gant robotique. Cela vaut donc la peine de bien faire les choses.

Configuration du Bluetooth (maître et récepteur)

Le bras robotique Arduino communique via Bluetooth à l'aide des modules HC-05. Ci-dessous, mettez en évidence les informations critiques.

Module

Configuration

Gant Robotique HC-05   Maître Bras Robotique HC-05  Esclave

Remarque :

Le débit en bauds est fixé à 4800

Programmation Arduino

Vous pouvez télécharger le code suivant ci-dessous :

Remarque : Tous les autres codes de test et la dernière version peuvent être trouvés sur le dépôt Arduino Robotic Arm Git

Programmation du bras robotique

Le code du bras robotique utilise la bibliothèque HCPCA9685 (pour le servomoteur). De cette façon, nous pouvons alimenter plusieurs servomoteurs, tous contrôlés par un Arduino. Dans le code, nous pouvons commencer par ajouter cette bibliothèque et déclarer les variables d'asservissement.

Les variables suivantes sont utilisées pour trouver le précédent/incrément et obtenir la position actuelle du servo.

* Inclut la bibliothèque HCPCA9685 */
#include "HCPCA9685.h"
/* Adresse esclave I2C pour le périphérique/module. Pour le HCMODU0097, l'adresse I2C par défaut
est 0x40 */
#define I2CAd 0x40
/* Créez une instance de la bibliothèque */
HCPCA9685 HCPCA9685(I2CAd);
//position initiale de stationnement du moteur
const int servo_joint_L_parking_pos =60 ;
//Degré de sensibilité du servo du robot - Intervalles
int servo_joint_L_pos_increment =20 ;
//Gardez une trace de la valeur actuelle des positions du moteur
int servo_joint_L_parking_pos_i =servo_joint_L_parking_pos;
//Angle minimum et maximum du servomoteur
int servo_joint_L_min_pos =10;
int servo_joint_L_max_pos =180; 

Initialisez le port série au débit en bauds 4800 pour démarrer la communication Bluetooth

Serial.begin (4800); // Initialisation du débit de communication par défaut du module Bluetooth 

Dans la section loop(), nous vérifions constamment si des données proviennent du gant robotique. Si vrai, nous stockerons les données entrantes dans la variable « état ». Et selon le caractère donné, nous l'utiliserons pour déplacer le(s) moteur(s).

La section suivante décrit le code :

Le code du bras robotique peut être vu comme une série de servomoteurs travaillant ensemble pour simuler les mouvements humains. Le code est le même, les servos étant pilotés par un servomoteur basé sur les valeurs de Bluetooth.

//Définition du servodriver. L'adresse 0x40 est l'adresse I2C par défaut.
#define I2CAd 0x40
int response_time =5 ; //Réception des valeurs de l'intervalle Robotic Glove
// Vérifie si les données proviennent du port série

if (Serial.available()> 0) {
state =Serial .lire(); // Lit les données du port série
Serial.print(state); // Imprime la valeur envoyée
//Bloc de code fonctionnalité moteur
} 

Sur la base de la "valeur de l'état" actuelle, le servomoteur enverrait un signal au moteur respectif.

Par exemple, si nous plions les doigts. La valeur « f » serait envoyée par le gant robotique (via Bluetooth) grâce auquel le bras robotique lirait ces données et déclencherait une fonction pour faire tourner le servomoteur respectif. Ce processus est répété dans une boucle infinie.

if (Serial.available()> 0) { // Vérifie si les données proviennent du port série
state =Serial.read(); // Lit les données du port série
Serial.print(state); // Imprime la valeur envoyée
//Pour le nommage des moteurs, se référer à l'article/tutoriel
//Move (Base Rotation) Stepper Motor Left
if (state ==' S') {
baseRotateLeft();
delay(response_time);
}
} 

Remarque : Le code implémente un arrêt brutal, pour empêcher le moteur de dépasser son angle maximum, ce qui peut endommager les engrenages du moteur.

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Conduire le servomoteur au canal 0 à l'angle souhaité.
//Déplacer le moteur à griffes vers le bas
if (état =='f') {
if (servo_joint_3_parking_pos_i HCPCA9685.Servo(4, servo_joint_3_parking_pos_i);
delay(response_time);
Serial.println(servo_joint_3_parking_pos_i);
servo_joint_3_parking_pos_i;3_=servo_joint_3_pos_inc}>}
void baseRotateLeft() {
digitalWrite(stepPin, LOW); //Spin dans une direction basée sur HIGH, LOW
delayMicroseconds(stepDelay); //Modifier la vitesse du moteur pas à pas
} 

Si la valeur du servomoteur est inférieure à la rotation maximale, continuez à tourner. S'il a atteint la rotation maximale de 180 degrés, arrêtez.

servo_joint_3_parking_pos_i  

Où servo_joint_3_max_pos est la position maximale du moteur.

Remarque : Le code implémente un arrêt dur pour empêcher le moteur de dépasser son angle maximum, ce qui peut dépouiller les engrenages du moteur.

Programmation du capteur Flex

Le code du bras robotique se trouve sur GitHub. Si vous travaillez sur le projet, contribuez votre propre version à Git Repo. Cela aiderait à créer un index des différentes versions et fonctionnalités du bras robotique.

Le code a déjà été documenté (également disponible sur Git). Cependant, nous couvrirons les points clés :

Nous allons définir les cinq capteurs :

//LED ON PIN 3
int pinkie_Data =A1;
int finger_Data =A2;
int thumb_Data =A3;
//const int MPU_addr =0x68;
const int MPU2 =0x69, MPU1 =0x68 ; 

Remarque : 0x68 et 0x69 représentent l'adresse I2C des 2 accéléromètres MPU6050

//À quelle fréquence envoyer des valeurs au bras robotique
int response_time =1000 ; 

Le code suivant décrit l'Arduino lisant les valeurs des capteurs :

// lire les valeurs des capteurs Flex vers Arduino
pinkie =analogRead(pinkie_Data);
finger =analogRead(finger_Data);
thumb =analogRead(thumb_Data); 

Lire la position actuelle de l'accéléromètre :

GetMpuValue1(MPU1) ;
GetMpuValue2(MPU2) ; 

Calibrage des valeurs :

Le code suivant se calibre pour trouver la limite supérieure et inférieure du capteur Flex. Pour recalibrer le gant flexible, appuyez sur le bouton de réinitialisation de l'Arduino.

if (bool_caliberate ==false ) {
delay(1000);
thumb_high =(thumb * 1.15) ;
thumb_low =(thumb * 0.9);
finger_high =(finger * 1.03) ;
finger_low =(finger * 0.8);
pinkie_high =(pinkie * 1.06) ;
pinkie_low =(pinkie * 0.8);
bool_caliberate =vrai ;
} 

Nous vérifierons constamment si la valeur actuelle a dépassé la limite supérieure ou inférieure du flex défini en fonction de l'étalonnage. Si le capteur de flexion va au-dessus ou en dessous de cette valeur, les données sont envoyées au bras robotique pour déplacer un servomoteur spécifique dans une direction spécifique.

// doigt 1 - Claw Bend/Open
if (doigt>=finger_high) {
Serial.print("F");
delay(response_time);
}
if (doigt <=finger_low) {
Serial.print("f");
delay(response_time);
} 

Programmation du bras robotique

Résultats – Pay-off

Le bras robotique est suffisamment précis pour déplacer des objets. Cependant, il faudra un certain travail pour déplacer des objets complexes, ou même rivaliser avec la dextérité des êtres humains de plus d'un million d'années… bien qu'il passe plus de temps à travailler sur le code, la précision du robot peut fonctionner comme prévu pour MARK 1i . Bien que le bras puisse être amélioré, il peut être amélioré de manière significative.

Si vous souhaitez améliorer le code, contribuez au Arduino Robot Arm Git Repo et construisez votre bras. Ouvrons cela pour que d'autres puissent s'en inspirer !

Enfin, nous pouvons également contrôler le Robot par des gestes de la main et programmer le Robot pour automatiser les tâches de base.

Prochaines étapes

Et c'est tout pour les gens de MARK 1 ! Si vous souhaitez ce projet, pensez à soutenir ma page Patreon.