Bras robotique contrôlé par geste de la main utilisant Arduino Nano

Connexion de circuit entre MPU6050 et Arduino Nano:

Connexion de circuit entre les servomoteurs et Arduino Nano:

Un capteur flexible contient deux broches. Il ne contient pas de bornes polarisées. Ainsi, la broche un P1 est connectée à la broche analogique A0 de l'Arduino Nano avec une résistance de rappel de 10k et la broche deux P2 est mise à la terre sur Arduino.

Montage du MPU6050 et du capteur Flex sur des gants

Nous avons monté le MPU6050 et le capteur Flex sur un gant. Ici, une connexion filaire est utilisée pour connecter le gant et le bras robotique, mais elle peut être rendue sans fil en utilisant une connexion RF ou une connexion Bluetooth.

Après chaque connexion, la configuration finale du bras robotisé à commande gestuelle ressemble à l'image ci-dessous:

Programmation Arduino Nano pour bras robotique

Comme d'habitude, un code complet avec une vidéo de travail est fourni à la fin de ce tutoriel. Ici, quelques lignes de code importantes sont expliquées.

1. Commencez par inclure les fichiers de bibliothèque nécessaires. La bibliothèque Wire.h est utilisée pour la communication I2C entre Arduino Nano & MPU6050 et servo.h pour contrôler le servomoteur.

#comprendre #comprendre

2. Ensuite, les objets du servo de classe sont déclarés. Comme nous utilisons quatre servomoteurs, quatre objets tels que servo_1, servo_2, servo_3, servo_4 sont créés.

Servo servo_1; Servo servo_2; Servo servo_3; Servo servo_4;

3. Ensuite, l'adresse I2C du MPU6050 et les variables à utiliser sont déclarées.

const int MPU_addr = 0x68; // Adresse MPU6050 I2C int16_t axis_X, axis_Y, axis_Z; int minVal = 265; int maxVal = 402; double X; double y; double - z;

4. Ensuite, dans la configuration vide , une vitesse de transmission de 9600 est définie pour la communication série.

Serial.begin (9600);

Et la communication I2C entre l'Arduino Nano et le MPU6050 est établie:

Wire.begin (); // Lancement de la communication I2C Wire.beginTransmission (MPU_addr); // Démarrer la communication avec MPU6050 Wire.write (0x6B); // Écrit dans le registre 6B Wire.write (0); // Écrit 0 dans le registre 6B pour réinitialiser Wire.endTransmission (true); // Termine la transmission I2C

En outre, quatre broches PWM sont définies pour les connexions du servomoteur.

servo_1.attach (2); // Avant / Arrière_Motor servo_2.attach (3); // Up / Down_Motor servo_3.attach (4); // Gripper_Motor servo_4.attach (5); // Moteur_Gauche / Droite

5. Ensuite, dans la fonction de boucle vide , établissez à nouveau la connexion I2C entre le MPU6050 et l'Arduino Nano, puis commencez à lire les données des axes X, Y, Z du registre du MPU6050 et stockez-les dans les variables correspondantes.

Wire.beginTransmission (MPU_addr); Wire.write (0x3B); // Commencez avec regsiter 0x3B Wire.endTransmission (false); Wire.requestFrom (MPU_addr, 14, vrai); // Lecture de 14 registres axis_X = Wire.read () << 8-Wire.read (); axis_Y = Wire.read () << 8-Wire.read (); axis_Z = Wire.read () << 8-Wire.read ();

Ensuite, mappez la valeur minimale et maximale des données d'axe du capteur MPU6050 dans la plage de -90 à 90.

int xAng = carte (axis_X, minVal, maxVal, -90,90); int yAng = carte (axis_Y, minVal, maxVal, -90,90); int zAng = carte (axis_Z, minVal, maxVal, -90,90);

Utilisez ensuite la formule suivante pour calculer les valeurs x, y, z en termes de 0 à 360.

x = RAD_TO_DEG * (atan2 (-yAng, -zAng) + PI); y = RAD_TO_DEG * (atan2 (-xAng, -zAng) + PI); z = RAD_TO_DEG * (atan2 (-yAng, -xAng) + PI);

Ensuite, lisez les données de sortie analogique du capteur flex sur la broche A0 de l'Arduino Nano et, en fonction de la valeur numérique du capteur flex, réglez l'angle d'asservissement de la pince. Ainsi, si les données du capteur flexible sont supérieures à 750, l'angle du servomoteur de la pince est de 0 degré et s'il est inférieur à 750, il est de 180 degrés.

int gripper; int flex_sensorip = analogRead (A0); if (flex_sensorip> 750) { préhenseur = 0; } else { pince = 180; } servo_3.write (pince);

Ensuite, le mouvement du MPU6050 sur l'axe X de 0 à 60 est mappé en termes de 0 à 90 degrés pour le mouvement avant / arrière du servomoteur du bras robotique.

si (x> = 0 && x <= 60) { int mov1 = map (x, 0,60,0,90); Serial.print ("Mouvement en F / R ="); Serial.print (mov1); Serial.println ((char) 176); servo_1.write (mov1); }

Et le mouvement du MPU6050 sur l'axe X de 250 à 360 est mappé en termes de 0 à 90 degrés pour le bras robotique de mouvement UP / DOWN du servomoteur.

sinon si (x> = 300 && x <= 360) { int mov2 = map (x, 360, 250, 0,90); Serial.print ("Mouvement en haut / bas ="); Serial.print (mov2); Serial.println ((char) 176); servo_2.write (mov2); }

Le mouvement du MPU6050 sur l'axe Y de 0 à 60 est mappé en termes de 90 à 180 degrés pour le mouvement gauche du servomoteur du bras robotique.

if (y> = 0 && y <= 60) { int mov3 = map (y, 0,60,90,180); Serial.print ("Mouvement à gauche ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }

Le mouvement du MPU6050 dans l'axe Y de 300 à 360 est mappé en termes de 0 à 90 degrés pour le mouvement droit du servomoteur du bras robotique.

sinon si (y> = 300 && y <= 360) { int mov3 = map (y, 360,300,90,0); Serial.print ("Mouvement à droite ="); Serial.print (mov3); Serial.println ((char) 176); servo_4.write (mov3); }

Fonctionnement du bras robotique contrôlé par gestes à l'aide d'Arduino

Enfin, téléchargez le code sur Arduino Nano et portez le gant monté avec le capteur MPU6050 et Flex.

1. Déplacez maintenant la main vers le bas pour déplacer le bras robotique vers l'avant et déplacez-vous vers le haut pour déplacer le bras robotique vers le haut.

2. Inclinez ensuite la main vers la gauche ou vers la droite pour tourner le bras robotique vers la gauche ou vers la droite.

3. Pliez le câble flexible attaché avec le doigt du gant pour ouvrir la pince, puis relâchez-le pour le fermer.

Le fonctionnement complet est démontré dans la vidéo ci-dessous.