Construisez un Bras Robotique Intelligent Contrôlé par Arduino : Tutoriel DIY Facile

Composants et Fournitures

Composant	Description	Quantité
Arduino UNO	Carte microcontrôleur	1
Micro Servomoteurs	Servos standards	5
Potentiomètres	Pour le bras maître (contrôle manuel)	5
Plaque d'essai (Breadboard)	Genérique	1

À Propos de ce Projet

Dans ce tutoriel, je vais réaliser un bras robotique simple contrôlé par un bras maître. Le bras mémorisera les mouvements et les rejouera en séquence. Le concept n'est pas nouveau – je m'en suis inspiré du "mini robotic arm" de Stoerpeak. Je voulais le faire depuis longtemps, mais j'étais alors débutant sans connaissances en programmation. Maintenant, je le construis enfin, en le gardant simple, peu coûteux, et en le partageant avec vous tous.

Alors, commençons…

Étape 1 : Matériel Nécessaire

• 5 Servomoteurs (lien Amazon)
• 5 Potentiomètres (lien Amazon)
• 1 Arduino UNO (lien Amazon)
• 1 Alimentation (j'utilise un adaptateur 5V)
• 1 Plaque d'essai (lien Amazon)
• Carton / Bois / Panneau solaire / Acrylique – ce qui est disponible ou facile à trouver
• Arduino IDE installé

Étape 2 : Fabriquer le Bras

J'ai utilisé des bâtonnets de glace (popsicle sticks) pour construire le bras. Vous pouvez utiliser n'importe quel matériau disponible. Essayez différents designs mécaniques pour un bras encore meilleur – le mien n'est pas très stable.

J'ai simplement utilisé du ruban adhésif double face pour coller les servos aux bâtonnets et les ai fixés avec des vis.

Pour le bras maître, j'ai collé les potentiomètres sur des bâtonnets et fabriqué le bras.

Regardez les photos pour mieux comprendre. J'ai tout monté sur une toile A4 utilisée comme base.

Étape 3 : Réaliser les Connexions

Dans cette étape, nous faisons toutes les connexions nécessaires. Référez-vous aux photos ci-dessus.

• Connectez tous les servos en parallèle à l'alimentation (fil rouge → +, fil noir/brun → GND)
• Connectez les fils de commande (jaune/orange) aux broches PWM de l'Arduino
• Connectez les potentiomètres au +5V et GND de l'Arduino en parallèle
• Connectez le curseur (borne centrale) de chaque potentiomètre à une broche analogique de l'Arduino

Broches utilisées :

• Broches numériques PWM 3, 5, 6, 9 et 10 pour commander les servos
• Broches analogiques A0 à A4 pour les entrées des potentiomètres
• Le servo sur la broche 3 est contrôlé par le potentiomètre sur A0
• Le servo sur la broche 5 par le potentiomètre sur A1, et ainsi de suite…

Note importante : Même si les servos ne sont pas alimentés par l'Arduino, assurez-vous de connecter la masse (GND) des servos à l'Arduino, sinon le bras ne fonctionnera pas.

Étape 4 : Programmation

La logique du code est assez simple : les valeurs des potentiomètres sont stockées dans un tableau, puis parcourues avec une boucle for pour que les servos reproduisent les positions mémorisées. Vous pouvez consulter ce tutoriel de référence : "Arduino Potentiometer Servo Control & Memory".

Variables Globales

#include <Servo.h>
// 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;

// Variables pour stocker positions servos
int Servo_0_Pos;
int Servo_1_Pos;
int Servo_2_Pos;
int Servo_3_Pos;
int Servo_4_Pos;

// Variables pour stocker positions précédentes
int Prev_0_Pos; 
int Prev_1_Pos; 
int Prev_2_Pos;
int Prev_3_Pos; 
int Prev_4_Pos;

// Variables pour stocker positions actuelles
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 numéro du servo
int Storage[600]; // Tableau pour stocker les données (augmenter la taille consomme plus de mémoire)
int Index = 0; // Index du tableau commence à 0
char data = 0; // Variable pour stocker données depuis entrée série

Fonction setup()

void setup() {
  Serial.begin(9600); // Communication série entre Arduino et IDE
  // Attacher les objets Servo aux broches PWM
  Servo_0.attach(3);
  Servo_1.attach(5);
  Servo_2.attach(6);
  Servo_3.attach(9);
  Servo_4.attach(10);
  // Servos initialisés à la position 100
  Servo_0.write(100);
  Servo_1.write(100);
  Servo_2.write(100);
  Servo_3.write(100);
  Servo_4.write(100);
  Serial.println("Press 'R' to Record and 'P' to play");
}

Fonction Map_Pot() – Lecture et Mapping des Potentiomètres

void Map_Pot()
{
  /* Les servos tournent sur 180 degrés
     mais les utiliser aux limites n'est pas
     une bonne idée car cela fait bourdonner les servos en continu
     ce qui est agaçant. On limite le mouvement entre 1 et 179 */
  Pot_0 = analogRead(A0); // Lecture entrée pot, stockage dans Pot_0
  Servo_0_Pos = map(Pot_0, 0, 1023, 1, 179); // Mapping 0-1023 → 1-179
  Servo_0.write(Servo_0_Pos); // Déplace servo à 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);
}

Fonction loop()

void loop() 
{
  Map_Pot(); // Appel fonction lecture pots
  
  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' saisi, commencer enregistrement
  {
    // Stocker les valeurs dans variables
    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;
    
    Map_Pot(); // Rappel fonction Map pour comparaison
    
    if (abs(Prev_0_Pos == Servo_0_Pos)) // Valeur absolue par comparaison
    {
      Servo_0.write(Servo_0_Pos); // Si valeurs identiques, servo repositionné
      if (Current_0_Pos != Servo_0_Pos) // Si valeurs différentes
      {
        Storage[Index] = Servo_0_Pos + 0; // Valeur ajoutée au tableau
        Index++; // Index incrémenté
      }
      Current_0_Pos = Servo_0_Pos; 
    }
    /* De même pour tous les servos, +100 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)
      {
        Storage[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);
      if (Current_2_Pos != Servo_2_Pos)
      {
        Storage[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); 
      if (Current_3_Pos != Servo_3_Pos)
      {
        Storage[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)
      {
        Storage[Index] = Servo_4_Pos + 400; 
        Index++;
      }
      Current_4_Pos = Servo_4_Pos;
    }
    /* Affichage valeurs sur moniteur série, '\t' pour 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); 
    delay(50); 
  }
  
  if (data == 'P') // SI 'P' saisi, lecture mouvements enregistrés
  {
    for (int i = 0; i < Index; i++) // Parcours tableau avec boucle for
    {
      Servo_Number = Storage[i] / 100; // Trouve numéro servo
      Servo_Position = Storage[i] % 100; // Trouve position servo
      switch(Servo_Number) 
      { 
        case 0:
          Servo_0.write(Servo_Position);
          break;
        case 1:
          Servo_1.write(Servo_Position);
          break;
        case 2:
          Servo_2.write(Servo_Position);
          break; 
        case 3:
          Servo_3.write(Servo_Position);
          break;
        case 4:
          Servo_4.write(Servo_Position);
          break;
      }
      delay(50);
    }
  }
}

Une fois le code prêt, téléversez-le sur la carte Arduino.

Le bras intelligent est prêt à fonctionner. Le mouvement n'est pas encore aussi fluide que celui de Stoerpeak.

Si vous pouvez améliorer le code ou avez des suggestions, faites-le moi savoir dans les commentaires.

Étape 5 : Test

Après avoir téléversé le code avec succès, ouvrez le 'Moniteur Série' (dans Outils). Au démarrage du moniteur, l'Arduino redémarre. Vous pouvez maintenant contrôler le bras robotique avec le bras maître, mais rien n'est enregistré.

Pour commencer l'enregistrement, tapez 'R' dans le moniteur, puis effectuez les mouvements souhaités.

Une fois les mouvements terminés, tapez 'P' pour lire les mouvements enregistrés. Les servos continueront à exécuter la séquence tant que la carte n'est pas réinitialisée.

J'espère que le projet vous plaira. Merci !

Code (Fichiers Séparés)

Le code est également fourni en plusieurs extraits pour une meilleure lisibilité :

• Record-Play.ino (fichier principal – erreur d'ouverture dans l'original)
• Extrait #1 : Déclarations globales et includes
• Extrait #2 : Fonction setup()
• Extrait #3 : Fonction Map_Pot()
• Extrait #4 : Fonction loop() complète

Schémas