Construire un Bras Robot Arduino Sans Fil, Contrôlé depuis Votre Smartphone

Introduction

Dans ce tutoriel, nous allons apprendre à fabriquer un bras robot Arduino contrôlable et programmable sans fil via une application Android personnalisée. Je vous montrerai tout le processus : conception et impression 3D des pièces, connexion des composants électroniques, programmation Arduino, jusqu'au développement de notre propre application Android pour contrôler le bras robot.

Vous pouvez regarder la vidéo ou lire le tutoriel écrit ci-dessous.

Vue d'Ensemble

Avec les curseurs de l'application, on contrôle manuellement chaque servo/axe du bras robot. Avec le bouton "Save" (Sauvegarder), on enregistre chaque position/étape, puis le bras rejoue automatiquement ces étapes. Le même bouton permet de mettre en pause l'exécution automatique, ainsi que de réinitialiser/supprimer toutes les étapes pour en enregistrer de nouvelles.

Modèle 3D du Bras Robot Arduino

Pour commencer, j'ai conçu le bras robot avec SolidWorks. Il a 5 degrés de liberté.

Construire un Bras Robot Arduino Sans Fil, Contrôlé depuis Votre Smartphone

Pour les 3 premiers axes (base, épaule, coude), j'ai utilisé des servos MG996R. Pour les 2 derniers axes (poignet roulis, poignet tangage) et la pince, des servos SG90 micro.

Vous pouvez trouver et télécharger ce modèle 3D, ainsi que l'explorer dans votre navigateur sur Thangs :

Télécharger l'assemblage 3D depuis Thangs.

Merci à Thangs pour le soutien de ce tutoriel.

Fichiers STL pour impression 3D :

Fichiers STL Bras Robot Arduino

1 fichier(s) 0,00 KB Télécharger

Impression 3D du Bras Robot

Avec mon imprimante 3D Creality CR-10, j'ai imprimé toutes les pièces du bras robot Arduino.

Un grand merci à Banggood.com pour m'avoir fourni cette superbe imprimante. La qualité d'impression du Creality CR-10 est incroyable pour son prix, et il arrive pré-assemblé à 90%.

Pour finir l'assemblage, il suffit de connecter les parties supérieures et inférieures du châssis avec boulons et équerres, puis de connecter les composants électroniques au boîtier de contrôle avec les câbles fournis.

Avant de tester, vérifiez que les roulettes sont bien serrées ; sinon, utilisez les écrous excentriques pour les serrer. Après nivellement du plateau, vous êtes prêt à transformer vos créations 3D en réalité.

Toutes les pièces du bras robot étaient prêtes en quelques heures.

Lire aussi : Top 15 Accessoires et Outils Indispensables pour Imprimante 3D

Assemblage du Bras Robot

Passons à l'assemblage. J'ai commencé par la base sur laquelle j'ai fixé le premier servo avec les vis fournies. Sur l'arbre de sortie, j'ai fixé un disque rond avec un boulon.

Par-dessus, j'ai placé la partie supérieure et fixé avec deux vis.

Même principe : servo, puis disque rond sur la pièce suivante, boulon sur l'arbre de sortie.

À l'axe d'épaule, il est judicieux d'inclure un ressort (ou dans mon cas un élastique) pour aider le servo qui supporte tout le poids du reste du bras et de la charge.

J'ai continué l'assemblage de la même façon. Pour la pince, j'ai utilisé des boulons et écrous de 4 mm.

Enfin, j'ai fixé la pince sur le dernier servo. Le bras robot Arduino était terminé.

Schéma de Câblage du Bras Robot Arduino

L'étape suivante : connecter l'électronique. Le schéma est assez simple. Il faut une carte Arduino et un module Bluetooth HC-05 pour la communication avec le smartphone. Les broches de contrôle des 6 servomoteurs sont connectées à 6 broches numériques de l'Arduino.

Pour alimenter les servos, il faut du 5V, mais depuis une source externe car l'Arduino ne peut pas fournir le courant nécessaire pour les 6 servos. La source doit délivrer au moins 2A. Une fois tout connecté, passons à la programmation Arduino et à la création de l'app Android.

Composants Nécessaires

Servomoteur MG996R
Servomoteur SG90 Micro
Module Bluetooth HC-05
Carte Arduino
Alimentation 5V 2A DC

Code Arduino du Bras Robot

Le code étant long, je le présenterai par sections avec description, puis le code complet à la fin.

D'abord, on inclut SoftwareSerial pour la communication série du Bluetooth et Servo.h pour les servos. Les deux sont inclus dans l'IDE Arduino. On définit les 6 servos, le module HC-05, et des variables pour positions actuelles/précédentes, ainsi que des tableaux pour stocker les positions/étapes du mode automatique.

#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo01; Servo servo02; Servo servo03;
Servo servo04; Servo servo05; Servo servo06;

SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05(TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // Position actuelle
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // Position précédente
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // Positions/étapes
int speedDelay = 20;
int index = 0;
String dataIn = "";

Dans setup(), on initialise les servos et le Bluetooth, et on place le bras en position initiale avec write() (0-180°).

void setup() {
  servo01.attach(5); servo02.attach(6); servo03.attach(7);
  servo04.attach(8); servo05.attach(9); servo06.attach(10);
  
  Bluetooth.begin(38400); // Baud rate par défaut HC-05
  Bluetooth.setTimeout(1);
  delay(20);
  
  // Position initiale du bras robot
  servo1PPos = 90;  servo01.write(servo1PPos);
  servo2PPos = 150; servo02.write(servo2PPos);
  servo3PPos = 35;  servo03.write(servo3PPos);
  servo4PPos = 140; servo04.write(servo4PPos);
  servo5PPos = 85;  servo05.write(servo5PPos);
  servo6PPos = 80;  servo06.write(servo6PPos);
}

Dans loop(), avec Bluetooth.available() on vérifie s'il y a des données entrantes du smartphone. Si oui, readString() lit la chaîne et la stocke dans dataIn. Selon les données reçues, on dit au bras quoi faire.

void loop() {
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString(); // Lit les données comme chaîne

Application Android de Contrôle

Regardons l'application Android pour voir quelles données elle envoie à l'Arduino.

L'app a été faite avec MIT App Inventor. En haut : deux boutons pour connecter le smartphone au module HC-05. À gauche : image du bras robot. À droite : 6 curseurs pour contrôler les servos + 1 curseur pour la vitesse.

Chaque curseur a des valeurs initiales, min et max adaptées aux articulations du bras. En bas : 3 boutons SAVE, RUN, RESET pour programmer l'exécution automatique. Un label affiche le nombre d'étapes sauvegardées. Pour plus de détails sur la création d'apps avec MIT App Inventor, consultez mon autre tutoriel détaillé.

Voyons les blocs derrière l'application. À gauche : blocs pour la connexion Bluetooth.

Ensuite : blocs des curseurs pour position servos et boutons pour programmation. Quand on bouge un curseur, avec la fonction Bluetooth .SendText, on envoie un texte à l'Arduino. Ce texte contient un préfixe indiquant quel curseur a changé + la valeur actuelle.

Voici le fichier du projet MIT App Inventor et l'application Android prête à installer :

Projet MIT App Inventor - Contrôle Bras Robot Arduino

1 fichier(s) 24,85 KB Télécharger

Application Android - Contrôle Bras Robot Arduino

1 fichier(s) 2,57 MB Télécharger

Côté Arduino, avec startsWith() on vérifie le préfixe de chaque donnée entrante pour savoir quoi faire. Exemple : préfixe "s1" = bouger servo 1. Avec substring() on extrait le nombre (position), on le convertit en entier et on l'utilise pour positionner le servo.

// Si curseur "Taille" (s1) change - Bouger Servo 1
if (dataIn.startsWith("s1")) {
  String dataInS = dataIn.substring(2, dataIn.length()); // Ex: "s1120" -> "120"
  servo1Pos = dataInS.toInt(); // Convertit en entier

On pourrait juste appeler write(), mais le servo irait à vitesse max, trop rapide pour le bras. Il faut contrôler la vitesse : j'ai utilisé des boucles FOR pour déplacer progressivement le servo de la position précédente à l'actuelle avec un délai entre chaque itération. En changeant le délai, on change la vitesse.

// Boucles FOR pour contrôler la vitesse
if (servo1PPos > servo1Pos) {
  for (int j = servo1PPos; j >= servo1Pos; j--) {
    servo01.write(j); // Descend
    delay(20); // Vitesse rotation
  }
}
if (servo1PPos < servo1Pos) {
  for (int j = servo1PPos; j <= servo1Pos; j++) {
    servo01.write(j); // Monte
    delay(20);
  }
}
servo1PPos = servo1Pos; // Position actuelle devient précédente
}

Même méthode pour chaque axe du bras.

Le bouton SAVE : quand pressé, la position de chaque servo est stockée dans un tableau. À chaque pression, l'index augmente pour remplir le tableau étape par étape.

// Si bouton "SAVE" pressé
if (dataIn.startsWith("SAVE")) {
  servo01SP[index] = servo1PPos;
  servo02SP[index] = servo2PPos;
  servo03SP[index] = servo3PPos;
  servo04SP[index] = servo4PPos;
  servo05SP[index] = servo5PPos;
  servo06SP[index] = servo6PPos;
  index++; // Incrémente index
}

Si on appuie RUN, on appelle la fonction personnalisée runservo() qui exécute les étapes mémorisées. Cette fonction fait tourner les étapes en boucle jusqu'à appui sur RESET. Avec une boucle FOR, on parcourt toutes les positions des tableaux, et en même temps on vérifie s'il y a des données entrantes du smartphone : bouton RUN/PAUSE (met en pause, réappui continue), ou changement du curseur vitesse (modifie le délai entre itérations des boucles FOR, donc la vitesse des servos).

// Fonction mode automatique - exécute étapes sauvegardées
void runservo() {
  while (dataIn != "RESET") {
    for (int i = 0; i <= index - 2; i++) {
      if (Bluetooth.available() > 0) {
        dataIn = Bluetooth.readString();
        if (dataIn == "PAUSE") {
          while (dataIn != "RUN") {
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if (dataIn == "RESET") break;
            }
          }
        }
        // Si curseur vitesse changé
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt();
        }
      }
      
      // Servo 1
      if (servo01SP[i] == servo01SP[i + 1]) { }
      if (servo01SP[i] > servo01SP[i + 1]) {
        for (int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) {
          servo01.write(j); delay(speedDelay);
        }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for (int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) {
          servo01.write(j); delay(speedDelay);
        }
      }
      // ... (servos 2 à 6 identiques)
    }
  }
}

De la même façon (IF + boucles FOR), on déplace les servos vers leur position suivante. Enfin, si on appuie RESET, on efface tous les tableaux (remise à zéro) et on remet l'index à zéro pour reprogrammer de nouveaux mouvements.

// Si bouton "RESET" pressé
if (dataIn == "RESET") {
  memset(servo01SP, 0, sizeof(servo01SP));
  memset(servo02SP, 0, sizeof(servo02SP));
  memset(servo03SP, 0, sizeof(servo03SP));
  memset(servo04SP, 0, sizeof(servo04SP));
  memset(servo05SP, 0, sizeof(servo05SP));
  memset(servo06SP, 0, sizeof(servo06SP));
  index = 0;
}

C'est fini, vous pouvez maintenant profiter et vous amuser avec le bras robot !

Code Complet du Bras Robot Arduino

/* DIY Arduino Robot Arm Contrôle Smartphone par Dejan, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
#include <Servo.h>

Servo servo01; Servo servo02; Servo servo03;
Servo servo04; Servo servo05; Servo servo06;

SoftwareSerial Bluetooth(3, 4); // Arduino(RX, TX) - HC-05(TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos;
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos;
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50];
int speedDelay = 20;
int index = 0;
String dataIn = "";

void setup() {
  servo01.attach(5); servo02.attach(6); servo03.attach(7);
  servo04.attach(8); servo05.attach(9); servo06.attach(10);
  Bluetooth.begin(38400); Bluetooth.setTimeout(1); delay(20);
  
  servo1PPos = 90;  servo01.write(servo1PPos);
  servo2PPos = 150; servo02.write(servo2PPos);
  servo3PPos = 35;  servo03.write(servo3PPos);
  servo4PPos = 140; servo04.write(servo4PPos);
  servo5PPos = 85;  servo05.write(servo5PPos);
  servo6PPos = 80;  servo06.write(servo6PPos);
}

void loop() {
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();
    
    // Servo 1 (Base/Taille)
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo1Pos = dataInS.toInt();
      if (servo1PPos > servo1Pos) {
        for (int j = servo1PPos; j >= servo1Pos; j--) { servo01.write(j); delay(20); }
      }
      if (servo1PPos < servo1Pos) {
        for (int j = servo1PPos; j <= servo1Pos; j++) { servo01.write(j); delay(20); }
      }
      servo1PPos = servo1Pos;
    }
    
    // Servo 2 (Épaule)
    if (dataIn.startsWith("s2")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo2Pos = dataInS.toInt();
      if (servo2PPos > servo2Pos) {
        for (int j = servo2PPos; j >= servo2Pos; j--) { servo02.write(j); delay(50); }
      }
      if (servo2PPos < servo2Pos) {
        for (int j = servo2PPos; j <= servo2Pos; j++) { servo02.write(j); delay(50); }
      }
      servo2PPos = servo2Pos;
    }
    
    // Servo 3 (Coude)
    if (dataIn.startsWith("s3")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo3Pos = dataInS.toInt();
      if (servo3PPos > servo3Pos) {
        for (int j = servo3PPos; j >= servo3Pos; j--) { servo03.write(j); delay(30); }
      }
      if (servo3PPos < servo3Pos) {
        for (int j = servo3PPos; j <= servo3Pos; j++) { servo03.write(j); delay(30); }
      }
      servo3PPos = servo3Pos;
    }
    
    // Servo 4 (Poignet roulis)
    if (dataIn.startsWith("s4")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo4Pos = dataInS.toInt();
      if (servo4PPos > servo4Pos) {
        for (int j = servo4PPos; j >= servo4Pos; j--) { servo04.write(j); delay(30); }
      }
      if (servo4PPos < servo4Pos) {
        for (int j = servo4PPos; j <= servo4Pos; j++) { servo04.write(j); delay(30); }
      }
      servo4PPos = servo4Pos;
    }
    
    // Servo 5 (Poignet tangage)
    if (dataIn.startsWith("s5")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo5Pos = dataInS.toInt();
      if (servo5PPos > servo5Pos) {
        for (int j = servo5PPos; j >= servo5Pos; j--) { servo05.write(j); delay(30); }
      }
      if (servo5PPos < servo5Pos) {
        for (int j = servo5PPos; j <= servo5Pos; j++) { servo05.write(j); delay(30); }
      }
      servo5PPos = servo5Pos;
    }
    
    // Servo 6 (Pince)
    if (dataIn.startsWith("s6")) {
      String dataInS = dataIn.substring(2, dataIn.length());
      servo6Pos = dataInS.toInt();
      if (servo6PPos > servo6Pos) {
        for (int j = servo6PPos; j >= servo6Pos; j--) { servo06.write(j); delay(30); }
      }
      if (servo6PPos < servo6Pos) {
        for (int j = servo6PPos; j <= servo6Pos; j++) { servo06.write(j); delay(30); }
      }
      servo6PPos = servo6Pos;
    }
    
    // SAVE
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;
    }
    
    // RUN
    if (dataIn.startsWith("RUN")) {
      runservo();
    }
    
    // RESET
    if (dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP));
      memset(servo02SP, 0, sizeof(servo02SP));
      memset(servo03SP, 0, sizeof(servo03SP));
      memset(servo04SP, 0, sizeof(servo04SP));
      memset(servo05SP, 0, sizeof(servo05SP));
      memset(servo06SP, 0, sizeof(servo06SP));
      index = 0;
    }
  }
}

void runservo() {
  while (dataIn != "RESET") {
    for (int i = 0; i <= index - 2; i++) {
      if (Bluetooth.available() > 0) {
        dataIn = Bluetooth.readString();
        if (dataIn == "PAUSE") {
          while (dataIn != "RUN") {
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if (dataIn == "RESET") break;
            }
          }
        }
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt();
        }
      }
      
      // Servos 1 à 6 - même logique
      if (servo01SP[i] > servo01SP[i + 1]) {
        for (int j = servo01SP[i]; j >= servo01SP[i + 1]; j--) { servo01.write(j); delay(speedDelay); }
      }
      if (servo01SP[i] < servo01SP[i + 1]) {
        for (int j = servo01SP[i]; j <= servo01SP[i + 1]; j++) { servo01.write(j); delay(speedDelay); }
      }
      
      if (servo02SP[i] > servo02SP[i + 1]) {
        for (int j = servo02SP[i]; j >= servo02SP[i + 1]; j--) { servo02.write(j); delay(speedDelay); }
      }
      if (servo02SP[i] < servo02SP[i + 1]) {
        for (int j = servo02SP[i]; j <= servo02SP[i + 1]; j++) { servo02.write(j); delay(speedDelay); }
      }
      
      if (servo03SP[i] > servo03SP[i + 1]) {
        for (int j = servo03SP[i]; j >= servo03SP[i + 1]; j--) { servo03.write(j); delay(speedDelay); }
      }
      if (servo03SP[i] < servo03SP[i + 1]) {
        for (int j = servo03SP[i]; j <= servo03SP[i + 1]; j++) { servo03.write(j); delay(speedDelay); }
      }
      
      if (servo04SP[i] > servo04SP[i + 1]) {
        for (int j = servo04SP[i]; j >= servo04SP[i + 1]; j--) { servo04.write(j); delay(speedDelay); }
      }
      if (servo04SP[i] < servo04SP[i + 1]) {
        for (int j = servo04SP[i]; j <= servo04SP[i + 1]; j++) { servo04.write(j); delay(speedDelay); }
      }
      
      if (servo05SP[i] > servo05SP[i + 1]) {
        for (int j = servo05SP[i]; j >= servo05SP[i + 1]; j--) { servo05.write(j); delay(speedDelay); }
      }
      if (servo05SP[i] < servo05SP[i + 1]) {
        for (int j = servo05SP[i]; j <= servo05SP[i + 1]; j++) { servo05.write(j); delay(speedDelay); }
      }
      
      if (servo06SP[i] > servo06SP[i + 1]) {
        for (int j = servo06SP[i]; j >= servo06SP[i + 1]; j--) { servo06.write(j); delay(speedDelay); }
      }
      if (servo06SP[i] < servo06SP[i + 1]) {
        for (int j = servo06SP[i]; j <= servo06SP[i + 1]; j++) { servo06.write(j); delay(speedDelay); }
      }
    }
  }
}

J'espère que cette vidéo vous a plu et que vous avez appris quelque chose. Posez vos questions dans les commentaires et consultez ma collection de projets Arduino.