Bras robotique simple et intelligent utilisant Arduino !!! : 5 étapes (avec photos)

2024 Auteur: John Day | [email protected]. Dernière modifié: 2024-01-30 09:08

Dans ce instructable je vais faire un simple bras robotique. Cela sera contrôlé à l'aide d'un bras maître. Le bras se souviendra des mouvements et jouera en séquence. Le concept n'est pas nouveau. J'ai eu l'idée de "mini bras robotique -par Stoerpeak" Je voulais faire ça depuis longtemps, mais à l'époque j'étais totalement noob et n'avais aucune connaissance en programmation. Maintenant, enfin, j'en construis un, en le gardant simple, pas cher et en le partageant avec vous tous.

Alors, commençons….

Étape 1: Choses dont vous aurez besoin:-

Voici une liste de choses dont vous aurez besoin:-

1. Servomoteurs x 5 Lien pour les États-Unis:- https://amzn.to/2OxbSH7Link pour l'Europe:-

2. Potentiomètres x 5 (j'ai utilisé 100k.) Lien pour les États-Unis:- https://amzn.to/2ROjhDMLink pour l'Europe:-

3. Arduino UNO. (Vous pouvez également utiliser Arduino Nano) Lien pour les États-Unis:- https://amzn.to/2DBbENWLink pour l'Europe:-

4. Planche à pain. (Je suggère ce kit) Lien pour les États-Unis:- https://amzn.to/2Dy86w4Lien pour l'Europe:-

5. Batterie. (facultatif, j'utilise un adaptateur 5v)

6. Carton/Bois/Sun-board/acrylique tout ce qui est disponible ou facile à trouver.

Et vous aurez également besoin d'Arduino IDE installé.

Étape 2: Faire le bras:-

Ici, j'ai utilisé des bâtons de Popsicle pour faire le bras. Vous pouvez utiliser n'importe quel matériel à votre disposition. Et vous pouvez essayer différentes conceptions mécaniques pour fabriquer un bras encore meilleur. ma conception n'est pas très stable.

J'ai juste utilisé du ruban adhésif double face pour coller les servos au bâton de Popsicle et les fixer à l'aide de vis.

Pour le bras Master, j'ai collé des potentiomètres sur des bâtons de popsicle et j'ai fabriqué le bras.

Se référer aux images vous donnera une meilleure idée.

J'ai tout monté sur un carton entoilé de format A4 utilisé comme base.

Étape 3: Établir des connexions:-

Dans cette étape, nous effectuerons toutes les connexions nécessaires. Reportez-vous aux images ci-dessus.

• Connectez d'abord tous les servos en parallèle à l'alimentation (le fil rouge à +ve et le fil noir ou marron à Gnd)
• Ensuite, connectez les fils de signal, c'est-à-dire le fil jaune ou orange à la broche PWM de l'arduino.
• Connectez maintenant les potentiomètres à +5v et Gnd de l'arduino en parallèle.
• Connectez la borne du milieu à la broche analogique d'ardunio.

Ici, les broches numériques 3, 5, 6, 9 et 10 sont utilisées pour contrôler les servos

Les broches analogiques A0 à A4 sont utilisées pour l'entrée des potentiomètres.

Le servo connecté à la broche 3 sera contrôlé par le potentiomètre connecté à A0

Le servo connecté à la broche 5 sera contrôlé par le pot sur A1, et ainsi de suite….

Remarque: - Même si les servos ne sont pas alimentés par arduino, assurez-vous de connecter la masse des servos à arduino, sinon le bras ne fonctionnera pas.

Étape 4: Codage:-

La logique de ce code est assez simple, les valeurs des potentiomètres sont stockées dans un tableau, les enregistrements sont ensuite parcourus à l'aide d'une boucle for et les servos effectuent les étapes selon les valeurs. Vous pouvez consulter ce tutoriel que j'ai utilisé pour référence "Arduino Potentiometer Servo Control & Memory"

Code:- (Fichier téléchargeable ci-joint.)

Tout d'abord, nous allons déclarer toutes les variables nécessaires globalement afin de pouvoir les utiliser tout au long du programme. Aucune explication particulière n'est nécessaire pour cela

#comprendre

//Objets Servo Servo Servo_0; Servo Servo_1; Servo Servo_2; Servo Servo_3; Servo Servo_4; //Objets potentiomètre int Pot_0; int Pot_1; int Pot_2; int Pot_3; int Pot_4; //Variable pour stocker Servo Position int Servo_0_Pos; int Servo_1_Pos; int Servo_2_Pos; int Servo_3_Pos; int Servo_4_Pos; //Variable pour stocker les valeurs de la position précédente int Prev_0_Pos; int Prev_1_Pos; int Prev_2_Pos; int Prev_3_Pos; int Prev_4_Pos; //Variable pour stocker les valeurs de la position actuelle int Current_0_Pos; int Current_1_Pos; int Current_2_Pos; int Current_3_Pos; int Current_4_Pos; int Servo_Position; //Stocke l'angle int Servo_Number; //Stocke le nombre de servos int Storage[600]; // Tableau pour stocker les données (L'augmentation de la taille du tableau consommera plus de mémoire) int Index = 0; // L'index du tableau commence à partir de la position 0 char data = 0; //variable pour stocker les données de l'entrée série.

Nous allons maintenant écrire une fonction de configuration, où nous définissons les broches et leurs fonctions. C'est la fonction principale qui s'exécute en premier

void setup()

{ Serial.begin(9600); //Pour la communication série entre arduino et IDE. //Les objets servo sont attachés aux broches PWM. Servo_0.attach(3); Servo_1.attach(5); Servo_2.attache(6); Servo_3.attach(9); Servo_4.attach(10); //Les servos sont réglés sur la position 100 à l'initialisation. Servo_0.write(100); Servo_1.write(100); Servo_2.write(100); Servo_3.write(100); Servo_4.write(100); Serial.println("Appuyez sur 'R' pour enregistrer et 'P' pour jouer"); }

Maintenant, nous devons lire les valeurs des potentiomètres à l'aide des broches d'entrée analogique et les mapper pour contrôler les servos. Pour cela, nous allons définir une fonction et la nommer Map_Pot();, vous pouvez lui donner le nom que vous voulez, c'est une fonction définie par l'utilisateur

void Map_Pot()

{ /* Les servos tournent à 180 degrés mais l'utiliser jusqu'aux limites n'est pas une bonne idée car cela fait bourdonner les servos en permanence, ce qui est ennuyeux, nous limitons donc le déplacement du servo entre: 1-179 */ Pot_0 = analogRead(A0); // Lire l'entrée du pot et la stocker dans la variable Pot_0. Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179); //Mappez les servos selon la valeur comprise entre 0 et 1023 Servo_0.write(Servo_0_Pos); // Déplacez le servo vers cette position. Pot_1 = lecture analogique(A1); Servo_1_Pos = map(Pot_1, 0, 1023, 1, 179); Servo_1.write(Servo_1_Pos); Pot_2 = lecture analogique(A2); Servo_2_Pos = map(Pot_2, 0, 1023, 1, 179); Servo_2.write(Servo_2_Pos); Pot_3 = lecture analogique(A3); Servo_3_Pos = map(Pot_3, 0, 1023, 1, 179); Servo_3.write(Servo_3_Pos); Pot_4 = lecture analogique (A4); Servo_4_Pos = map(Pot_4, 0, 1023, 1, 179); Servo_4.write(Servo_4_Pos); }

Maintenant, nous allons écrire la fonction de boucle:

boucle vide()

{ Map_Pot(); //Appel de fonction pour lire les valeurs du pot while (Serial.available() > 0) { data = Serial.read(); if (data == 'R') Serial.println("Enregistrement des mouvements…"); if (data == 'P') Serial.println("Lecture de coups enregistrés…"); } if (data == 'R') //Si 'R' est entré, démarre l'enregistrement. { //Stocker les valeurs dans une variable Prev_0_Pos = Servo_0_Pos; Prev_1_Pos = Servo_1_Pos; Prev_2_Pos = Servo_2_Pos; Prev_3_Pos = Servo_3_Pos; Prev_4_Pos = Servo_4_Pos; Carte_Pot(); // Fonction Map rappelée pour comparaison if (abs(Prev_0_Pos == Servo_0_Pos)) // la valeur absolue est obtenue en comparant { Servo_0.write(Servo_0_Pos); // Si les valeurs correspondent, le servo est repositionné if (Current_0_Pos != Servo_0_Pos) // Si les valeurs ne correspondent pas { Storage[Index] = Servo_0_Pos + 0; // La valeur est ajoutée au tableau Index++; // Valeur d'index incrémentée de 1 } Current_0_Pos = Servo_0_Pos; } /* De même, la comparaison des valeurs est effectuée pour tous les servos, +100 est ajouté à chaque entrée en tant que valeur différentielle. */ if (abs(Prev_1_Pos == Servo_1_Pos)) { Servo_1.write(Servo_1_Pos); if (Current_1_Pos != Servo_1_Pos) { Stockage[Index] = Servo_1_Pos + 100; Indice++; } Current_1_Pos = Servo_1_Pos; } if (abs(Prev_2_Pos == Servo_2_Pos)) { Servo_2.write(Servo_2_Pos); if (Current_2_Pos != Servo_2_Pos) { Stockage[Index] = Servo_2_Pos + 200; Indice++; } Current_2_Pos = Servo_2_Pos; } if (abs(Prev_3_Pos == Servo_3_Pos)) { Servo_3.write(Servo_3_Pos); if (Current_3_Pos != Servo_3_Pos) { Stockage[Index] = Servo_3_Pos + 300; Indice++; } Current_3_Pos = Servo_3_Pos; } if (abs(Prev_4_Pos == Servo_4_Pos)) { Servo_4.write(Servo_4_Pos); if (Current_4_Pos != Servo_4_Pos) { Stockage[Index] = Servo_4_Pos + 400; Indice++; } Current_4_Pos = Servo_4_Pos; } /* Les valeurs sont imprimées sur le moniteur série, '\t' est pour afficher les valeurs au format tabulaire */ Serial.print(Servo_0_Pos); Serial.print(" \t "); Serial.print(Servo_1_Pos); Serial.print(" \t "); Serial.print(Servo_2_Pos); Serial.print(" \t "); Serial.print(Servo_3_Pos); Serial.print(" \t "); Serial.println(Servo_4_Pos); Serial.print ("Index = "); Serial.println(Index); retard (50); } if (data == 'P') //SI 'P' est entré, Commence à jouer les coups enregistrés. { for (int i = 0; i < Index; i++) //Parcourir le tableau en utilisant la boucle for { Servo_Number = Storage / 100; // Trouve le nombre de servo Servo_Position = Storage % 100; // Trouve la position du servo-commutateur (Servo_Number) { case 0: Servo_0.write(Servo_Position); Pause; cas 1: Servo_1.write(Servo_Position); Pause; cas 2: Servo_2.write(Servo_Position); Pause; cas 3: Servo_3.write(Servo_Position); Pause; cas 4: Servo_4.write(Servo_Position); Pause; } retard (50); } } }

Une fois le code prêt, téléchargez-le maintenant sur la carte arduino

Le bras Smart est prêt à fonctionner. La fonction n'est pas encore aussi fluide que celle de Stoerpeak.

Si vous pouvez améliorer le code ou si vous avez des suggestions à me faire, faites-le moi savoir dans la section des commentaires.

Cela étant dit, passons aux tests….

Étape 5: Test:-

Après avoir téléchargé le code sur le tableau avec succès, ouvrez 'Serial Monitor', vous pouvez le trouver dans l'option Outils. Lorsque Serial Monitor démarre, l'arduino se réinitialise. Vous pouvez maintenant contrôler le bras robotique à l'aide du bras maître. Mais rien n'est enregistré.

Pour commencer l'enregistrement, entrez « R » dans le moniteur, vous pouvez maintenant effectuer les mouvements que vous souhaitez enregistrer.

Une fois les mouvements terminés, vous devez entrer 'P' afin de jouer les mouvements enregistrés. Les servos continueront à effectuer les mouvements tant que la carte n'est pas réinitialisée.