Bras robotique Arduino contrôlé par gestes manuels – Construction DIY pas à pas

Composants et fournitures

Composant	Quantité
Arduino UNO	1
PCB personnalisé JLCPCB	1
Servomoteur MG996R	6
Pack batterie 5V	1
Contrôleur PCA9685 8 canaux I2C	1
Module Bluetooth HC-05	2
Carte pilote moteur pas à pas SparkFun A4988	1
Moteur pas à pas NEMA-17	1
Plaque d'essai (générique)	1
Unité de mesure inertielle (IMU) 6 degrés de liberté	1
Arduino Nano R3	1
Capteur de flexion	1

Outils et machines nécessaires

• Imprimante 3D (générique)

À propos du projet

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

Des films à succès comme Pacific Rim, Avatar et d'autres films de science-fiction ont suggéré la capacité de synergie avec les robots – où vos mouvements peuvent être amplifiés par une assistance robotique.

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

Ce projet est une tentative d'y parvenir.

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

Fidèle à la convention de la combinaison 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 à plus d'itérations pour améliorer le bras robotique original.

Voir le tutoriel complet du bras robotique DIY (contrôlé par gestes manuels) ici

Vue d'ensemble

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

Caractéristiques MARK 1 :

• Rotation 6 axes
• Portable
• Contrôle du robot par gestes humains
• Peut être pré-programmé pour effectuer des fonctions de base
• Peut être contrôlé sans fil à distance
• Peut supporter une charge de 600g (Charge max 1kg)

Liste des pièces

Le bras robotique est entièrement personnalisable. Vous pouvez soit acheter le vôtre, soit l'imprimer en 3D. Si vous choisissez l'impression 3D, pas de souci. Il y a 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 cela me donne plus d'espace pour créer des pièces personnalisées.

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

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

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 : Fichiers STL du gant robotique (crédits : Roman 13)

Le gant robotique était un ajout esthétique au projet, mais vous pouvez tout aussi bien utiliser un gant de chantier pour implémenter le bras robotique.

Note : pour les grandes mains, imprimez à 105% d'échelle

Comment ça marche

Globalement, nous envoyons un signal (via Bluetooth) du gant robotique au servomoteur. Lorsqu'une valeur a été reçue, le pilote de servo enverra un signal à un servomoteur spécifique pour déplacer 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 coordonnés entre eux pour effectuer 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 désiré.

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

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

• Capteurs de flexion – Basés sur le degré de flexion 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 du bras et du poignet.

Nous utilisons ces capteurs pour détecter un changement de 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 assez de gestes, le bras robotique prend vie !

Cartographie du bras robotique

Ce qui suit représente un tableau de correspondance des valeurs envoyées au bras robotique par le gant. Cela peut être trouvé dans l'article original. Chacun ayant une clé pour caractériser sa fonction. (P – Auriculaire, D – Droite, etc.)

Note : La majuscule "F" (doigt) représente la direction opposée de la rotation du servomoteur

Assemblage des pièces

Bras robotique – Assemblage

L'achat d'un bras robotique peut être assez cher. Pour garder ce bras robotique dans le budget, l'impression 3D d'un bras robotique était la meilleure option.

Cela aide à long terme, car il y a de nombreux exemples de bras robotiques imprimés en 3D qui peuvent être personnalisés, par exemple, ajouter une LED, créer un support de caméra avec pince :

Comme mentionné précédemment, le bras robotique a été modélisé sur le bras robotique de Thingiverse. J'ai choisi cet exemple car c'était un excellent design fournissant six axes, bien documenté, et avait de la force/robustesse. Vous pouvez accéder au bras robotique de Wonder Tiger depuis la liste des pièces.

Vous pouvez également trouver mes remixes pour un support de caméra de bras robotique. Nous en reparlerons dans une future version. Cependant, les pièces pourraient prendre au moins 40 heures pour imprimer toutes les pièces.

Vous pouvez trouver de nombreuses autres alternatives de bras robotiques imprimés en 3D.

Présentation du servomoteur et du pilote

Donné que le bras robotique est idéalement une série de moteurs coordonnés ensemble, nous pouvons théoriquement attacher plusieurs moteurs qui peuvent tous être alimentés par l'Arduino. Dans ce projet, nous utiliserons le pilote de servo PCA9685 pour alimenter le servo MG966R.

Note : Utilisez une alimentation externe lors de l'alimentation de chaque moteur. L'Arduino ne peut pas fournir assez d'énergie pour contrôler tous les moteurs. Dans ce projet, une batterie RC 5V, 2200 mAh a été utilisée.

Le schéma de câblage Arduino devrait ressembler à ceci :

NEMA-17 pour la rotation de base

Puisque le robot commençait à prendre du poids, et que le servomoteur MG966R n'était pas assez puissant pour faire pivoter le bras robotique à la base. Pour faire pivoter le bras robotique, un moteur plus robuste qu'un servomoteur serait nécessaire.

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 sans à-coups vers les commandes de geste.

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

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

Assemblage du circuit

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'appairage ci-dessous.

Capteur de flexion humain

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

Cependant, vous pouvez utiliser un gant de chantier standard pour prototyper le gant robotique. Ce design 'Exosquelette Robot Gant' se fondait bien avec le design du bras robotique.

Le gant robotique se compose des composants suivants :

• Capteur de flexion – Basé sur la flexion du doigt, le courant change ce que nous pourrions utiliser pour envoyer un signal au moteur
• Accéléromètre (MPU6050) – Nous pouvons contrôler le moteur en mappant les gestes humains depuis les plans X, Y, Z
• LED – La LED s'allumera lorsqu'un contrôle de geste humain a été envoyé à l'Arduino
• Module Bluetooth (HC-05) – Envoi de données au récepteur HC-05 du bras robotique
• Arduino Nano – Le microcontrôleur ferait office de cerveau du gant robotique

Le diagramme suivant est excellent pour tester le capteur de flexion et l'accéléromètre.

Important : Le bras robotique ne sera aussi précis que les contrôles du gant robotique, donc cela vaut la peine de bien faire cette partie.

Configuration du Bluetooth (Maître et Récepteur)

Le bras robotique Arduino communique via Bluetooth en utilisant les modules HC-05. Ci-dessous les informations critiques.

Module	Configuration
Gant robotique HC-05	Maître
Bras robotique HC-05	Esclave

Note : Le débit en bauds est réglé à 4800

Programmation Arduino

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

Note : Tous les autres codes de test et la dernière version peuvent être trouvés sur le Git Repo Arduino Robot Arm

Programmation du bras robotique

Le code du bras robotique utilise la bibliothèque HCPCA9685 (pour le pilote de servo). Ainsi, 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 de servo.

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

/* Inclure la bibliothèque HCPCA9685 */
#include "HCPCA9685.h"
/* Adresse esclave I2C pour le dispositif/module. Pour le HCMODU0097 l'adresse I2C par défaut est 0x40 */
#define I2CAdd 0x40
/* Créer une instance de la bibliothèque */
HCPCA9685 HCPCA9685(I2CAdd);
// position de stationnement initiale du moteur
const int servo_joint_L_parking_pos = 60;
// Degré de sensibilité du servo robot - Intervalles
int servo_joint_L_pos_increment = 20;
// Suivre 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 à 4800 bauds pour démarrer la communication Bluetooth

Serial.begin(4800); // Initialiser le taux de communication par défaut du module Bluetooth

Dans la section loop(), nous vérifions constamment si des données arrivent du gant robotique. Si vrai, nous stockons les données entrantes dans la variable 'state'. Et selon le caractère donné, nous l'utilisons 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, avec les servos pilotés par un pilote de servo basé sur les valeurs Bluetooth.

// Définir le pilote de servo. L'adresse 0x40 est l'adresse I2C par défaut.
#define I2CAdd 0x40
int response_time = 5; // Intervalle de réception des valeurs du gant robotique
// Vérifie si des données arrivent du port série
if (Serial.available() > 0) {
  state = Serial.read(); // Lit les données du port série
  Serial.print(state); // Affiche la valeur envoyée
  // Bloc de code fonctionnalité moteur
}

En fonction de la valeur actuelle de 'state', le pilote de servo enverrait un signal au moteur respectif.

Par exemple, si nous plions nos doigts. La valeur 'f' serait envoyée par le gant robotique (via Bluetooth) et le bras robotique lirait cette donnée et déclencherait une fonction pour faire pivoter le servomoteur respectif. Ce processus est répété dans une boucle infinie.

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

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

HCPCA9685.Servo(0, servo_joint_L_parking_pos_i); // Pilote le servomoteur au canal 0 à l'angle désiré.
// Mouvoir le moteur de pince vers le bas
if (state == 'f') {
  if (servo_joint_3_parking_pos_i < servo_joint_3_max_pos) {
    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 = servo_joint_3_parking_pos_i + servo_joint_3_pos_increment;
  }
}
void baseRotateLeft() {
  digitalWrite(stepPin, LOW); // Tourne dans une direction basée sur HIGH, LOW
  delayMicroseconds(stepDelay); // Change 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 < servo_joint_3_max_pos

Où servo_joint_3_max_pos est la position maximale du moteur.

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

Programmation du capteur de flexion

Le code du bras robotique peut être trouvé sur GitHub. Si vous travaillez sur le projet, contribuez votre propre version au Git Repo. Cela aiderait à construire un index de 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 définirons les cinq capteurs :

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

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

// Fréquence d'envoi 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 de flexion 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);

Calibration des valeurs :

Le code suivant calibre pour trouver la limite supérieure et inférieure du capteur de flexion. Pour recalibrer le gant flexible, appuyez sur le bouton de réinitialisation sur 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 = true;
}

Nous vérifierons constamment si la valeur actuelle a dépassé la limite supérieure ou inférieure définie du capteur de flexion basée sur la calibration. Si le capteur de flexion dépasse ou descend en dessous de cette valeur, des données sont envoyées au bras robotique pour déplacer un servomoteur spécifique dans une direction spécifique.

// doigt 1 - Pliage/Ouverture de la pince
if (finger >= finger_high) {
  Serial.print("F");
  delay(response_time);
}
if (finger <= finger_low) {
  Serial.print("f");
  delay(response_time);
}

Programmation du bras robotique

Résultats – Gain

Le bras robotique est assez précis pour déplacer des objets. Cependant, il nécessitera du travail pour déplacer des objets complexes, ou même rivaliser avec les « millions d'années » que les êtres humains ont sur la dextérité … bien qu'en passant plus de temps à travailler sur le code, la précision du robot peut être améliorée significativement.

Si vous souhaitez améliorer le code, contribuez au Arduino Robot Arm Git Repo et construisez votre bras. Rendons cela ouvert pour que d'autres puissent construire dessus !

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

Prochaines étapes

Et c'est tout pour MARK 1 les amis ! Si vous aimez ce projet, envisagez de soutenir ma page Patreon.

Code

Extraits de code disponibles dans le dépôt GitHub : GitHub et GitHub 2

Pièces personnalisées et boîtiers

• Thingiverse - Pièces pince
• Thingiverse - Base et plateau
• Thingiverse - Bras principal
• Thingiverse - Gant robotique

Schéma

Robot Arm Git Repo