Bras robotique simple et intelligent utilisant Arduino

À propos de ce projet

Dans ce tutoriel, je vais créer un bras robotique simple qui 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 -de 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 (Amazon Link)

2. Potentiomètres x 5 (Amazon Link)

3. Arduino UNO. (Lien Amazon)

4. Batterie. (J'utilise un adaptateur 5v)

5. Planche à pain. (Lien Amazon)

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 sur le 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 canevas 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)
• Connectez ensuite 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 d'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.)

• Nous allons d'abord 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.

#include 
//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 mémoriser 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 position précédentes
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. 

• Maintenant, nous allons é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.attach(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"); 
} 

Nous devons maintenant lire les valeurs des potentiomètres à l'aide des broches d'entrée analogique et les mapper sur les servos de contrôle. 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 aux limites n'est pas
 une bonne idée car cela rend le les servos bourdonnent continuellement
 ce qui est ennuyeux donc nous limitons 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 =analogRead(A1) ;
 Servo_1_Pos =map(Pot_1, 0, 1023, 1, 179) ;
 Servo_1.write (Servo_1_Pos); 
 
 Pot_2 =analogRead(A2) ; 
 Servo_2_Pos =map(Pot_2, 0, 1023, 1, 179) ;
 Servo_2.write(Servo_2_Pos);
 
 Pot_3 =analogRead(A3) ; 
 Servo_3_Pos =map(Pot_3, 0, 1023, 1, 179) ;
 Servo_3.write(Servo_3_Pos);
 
 Pot_4 =analogRead(A4) ;
 Servo_4_Pos =map(Pot_4, 0, 1023 , 1, 179) ;
 Servo_4.write(Servo_4_Pos);
} 

• Nous allons maintenant écrire la fonction de boucle :

void loop() 
{
 Map_Pot(); //Appel de fonction pour lire les valeurs du pot
 
 while (Serial.available()> 0) 
 {
 data =Serial.read();
 if (data =='R')
 Serial.println("Recording Moves...");
 if (data =='P')
 Serial.println("Playing Recorded Moves.. .");
 }
 if (data =='R') //Si 'R' est entré, démarre l'enregistrement.
 {
 //Stocke les valeurs dans un 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_/> Map (); // 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 faite pour tous les servos, +100 est ajouté à chaque entrée 
 comme 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 ; 
 Index++;
 }
 Current_1_Pos =Servo_1_Pos;
 }
 
 if (abs(Prev_2_Pos ==Servo_2_Pos))
 {
 Servo_2.write(Servo_2_Pos);
 si (Current_2_Pos !=Servo_2_Pos)
 {
 Stockage[Index] =Servo_2_Pos + 200 ; 
 Index++;
 }
 Current_2_Pos =Servo_2_Pos;
 }
 
 if (abs(Prev_3_Pos ==Servo_3_Pos))
 {
 Servo_3.write(Servo_3_Pos); 
 si (Current_3_Pos !=Servo_3_Pos)
 {
 Stockage[Index] =Servo_3_Pos + 300 ; 
 Index++ ;
 }
 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 ; 
 Index++;
 }
 Current_4_Pos =Servo_4_Pos;
 }
 /* Les valeurs sont imprimées sur un moniteur série, '\t' est pour afficher les valeurs sous forme de tableau */ 
 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); 
 délai (50); 
 }
 if (data =='P') //SI 'P' est entré , Commencer à jouer les coups enregistrés.
 {
 for (int i =0; i  {
 Servo_Number =Storage[i] / 100; // Trouve le nombre de servos
 Servo_Position =Storage[i] % 100; // Recherche la position du commutateur servo
(Servo_Number) 
 { 
 case 0 :
 Servo_0.write(Servo_Position);
 break ;
 case 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 ;
 }
 délai (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 :Tests

Après avoir téléchargé le code sur le tableau avec succès, ouvrez « Moniteur série », 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.

J'espère que le projet vous plaira.

Merci...

Code

• Record-Play.ino
• Extrait de code n° 1
• Extrait de code 2
• Extrait de code 3
• Extrait de code n° 4

Record-Play.inoArduino

Extrait de code n°1Texte brut

#include //Servo ObjectsServo Servo_0;Servo Servo_1;Servo Servo_2;Servo Servo_3;Servo Servo_4;//Potentiomètre Objectsint Pot_0;int Pot_1;int Pot_2; int Pot_3;int Pot_4;//Variable pour mémoriser Servo Positionint Servo_0_Pos;int Servo_1_Pos;int Servo_2_Pos;int Servo_3_Pos;int Servo_4_Pos;//Variable pour mémoriser Valeurs de position précédentesint 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 actuelleint 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 servoint 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 du 0e positionchar data =0; //variable pour stocker les données de l'entrée série.

Extrait de code #2Texte brut

configuration vide() { 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"); }

Extrait de code n°3Texte brut

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);}

Extrait de code n°4Texte brut

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 des mouvements 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 la même manière, 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  

Schémas