Bras de robot DIY Arduino avec contrôle par smartphone

Dans ce didacticiel, nous allons apprendre à créer un bras de robot Arduino qui peut être contrôlé et programmé sans fil à l'aide d'une application Android personnalisée. Je vais vous montrer tout le processus de construction, depuis la conception et l'impression 3D des pièces du robot, la connexion des composants électroniques et la programmation de l'Arduino, jusqu'au développement de notre propre application Android pour contrôler le Robot Arm.

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

Aperçu

En utilisant les curseurs de l'application, nous pouvons contrôler manuellement le mouvement de chaque servo ou axe du bras du robot. En utilisant également le bouton "Enregistrer", nous pouvons enregistrer chaque position ou étape, puis le bras du robot peut automatiquement exécuter et répéter ces étapes. Avec le même bouton, nous pouvons mettre en pause le fonctionnement automatique ainsi que réinitialiser ou supprimer toutes les étapes afin de pouvoir en enregistrer de nouvelles.

Modèle 3D du bras robotisé Arduino

Pour commencer, j'ai conçu le Robot Arm à l'aide du logiciel de modélisation 3D Solidworks. Le bras a 5 degrés de liberté.

Pour les 3 premiers axes, la taille, l'épaule et le coude, j'ai utilisé les servos MG996R, et pour les 2 autres axes, le roulis et le tangage du poignet, ainsi que la pince j'ai utilisé les plus petits servos micro SG90.

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

Téléchargez le modèle 3D d'assemblage à partir de Thangs.

Merci Thang d'avoir soutenu ce tutoriel.

Fichiers STL pour l'impression 3D :

Fichiers STL Arduino Robot Arm

Impression 3D du bras du robot

À l'aide de ma nouvelle imprimante 3D, Creality CR-10, j'ai imprimé en 3D toutes les pièces du bras du robot Arduino.

Ici, je voudrais remercier Banggood.com de m'avoir fourni cette superbe imprimante 3D. La qualité d'impression Creality CR-10 est incroyable pour son prix et ce qui est également génial, c'est qu'elle est pré-assemblée à près de 90 %.

Pour terminer l'assemblage, il suffit de connecter les cadres des parties supérieure et inférieure à l'aide de boulons et de supports, puis de connecter les composants électroniques au boîtier de commande à l'aide des câbles fournis.

Avant de l'essayer, il est recommandé de vérifier si les roues du rouleau sont suffisamment serrées, et si ce n'est pas le cas, vous pouvez simplement utiliser les écrous excentriques pour les serrer. Et voilà, après avoir nivelé votre lit d'impression 3D, vous êtes prêt à transformer vos créations 3D en réalité.

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

Lire la suite :Top 15 des accessoires et outils indispensables pour les imprimantes 3D

Assemblage du bras du robot

Ok, donc à ce stade, nous sommes prêts à assembler le bras du robot. J'ai commencé par la base sur laquelle j'ai fixé le premier servomoteur à l'aide des vis incluses dans son emballage. Ensuite, sur l'arbre de sortie du servo, j'ai fixé un klaxon rond un boulon.

Et dessus, j'ai placé la partie supérieure et je l'ai fixée à l'aide de deux vis.

Là encore, le servo va d'abord, puis le klaxon rond sur la pièce suivante, puis ils sont fixés l'un à l'autre à l'aide du boulon sur l'arbre de sortie.

Nous pouvons remarquer ici qu'au niveau de l'axe de l'épaule, il est judicieux d'inclure une sorte de ressort ou dans mon cas, j'ai utilisé un élastique pour aider le servo car ce servo supporte également tout le poids du reste du bras comme charge utile.

De la même manière, j'ai continué à assembler le reste du bras du robot. Quant au mécanisme de préhension, j'ai utilisé des boulons et des écrous de 4 millimètres pour l'assembler.

Enfin, j'ai fixé le mécanisme de préhension sur le dernier servo et le bras du robot Arduino était terminé.

Schéma du circuit du bras du robot Arduino

L'étape suivante consiste à connecter l'électronique. Le schéma de circuit de ce projet est en fait assez simple. Nous avons juste besoin d'une carte Arduino et d'un module Bluetooth HC-05 pour communiquer avec le smartphone. Les broches de commande des six servomoteurs sont connectées à six broches numériques de la carte Arduino.

Pour alimenter les servos, nous avons besoin de 5V, mais cela doit provenir d'une source d'alimentation externe car l'Arduino n'est pas capable de gérer la quantité de courant qu'ils peuvent tous tirer. La source d'alimentation doit être capable de gérer au moins 2A de courant. Ainsi, une fois que nous avons tout connecté ensemble, nous pouvons passer à la programmation de l'Arduino et créer l'application Android.

Vous pouvez obtenir les composants nécessaires pour cet exemple à partir des liens ci-dessous :

• Servomoteur MG996R……………………….….
• Micro servomoteur SG90 ……..…….….…….
• Module Bluetooth HC-05 ………………….… 
• Carte Arduino …………………………………………….
• Alimentation CC 5 V 2 A ………………….….. 

Code du bras du robot Arduino

Comme le code est un peu plus long, pour une meilleure compréhension, je posterai le code source du programme dans des sections avec une description pour chaque section. Et à la fin de cet article, je posterai le code source complet.

Nous devons donc d'abord inclure la bibliothèque SoftwareSerial pour la communication série du module Bluetooth ainsi que la bibliothèque servo. Ces deux bibliothèques sont incluses avec l'IDE Arduino, vous n'avez donc pas besoin de les installer en externe. Ensuite, nous devons définir les six servos, le module Bluetooth HC-05 et certaines variables pour stocker la position actuelle et précédente des servos, ainsi que des tableaux pour stocker les positions ou les étapes pour le 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 Bluetooth (TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
int speedDelay = 20;
int index = 0;
String dataIn = "";Code language: Arduino (arduino)

Dans la section de configuration, nous devons initialiser les servos et le module Bluetooth et déplacer le bras du robot dans sa position initiale. Nous faisons cela en utilisant la fonction write() qui déplace simplement le servo vers n'importe quelle position de 0 à 180 degrés.

void setup() {
  servo01.attach(5);
  servo02.attach(6);
  servo03.attach(7);
  servo04.attach(8);
  servo05.attach(9);
  servo06.attach(10);
  Bluetooth.begin(38400); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  // Robot arm initial position
  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);
}Code language: Arduino (arduino)

Ensuite, dans la section boucle, en utilisant la fonction Bluetooth.available() , nous vérifions constamment s'il y a des données entrantes du Smartphone. Si vrai, en utilisant la fonction readString(), nous lisons les données sous forme de chaîne et les stockons dans la variable dataIn. En fonction des données reçues, nous dirons au bras du robot quoi faire.

// Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();  // Read the data as stringCode language: Arduino (arduino)

Contrôle de l'application Android

Jetons maintenant un coup d'œil à l'application Android et voyons quel type de données elle envoie réellement à l'Arduino.

J'ai créé l'application à l'aide de l'application en ligne MIT App Inventor et voici comment cela fonctionne. En haut, nous avons deux boutons pour connecter le smartphone au module Bluetooth HC-05. Ensuite, sur le côté gauche, nous avons une image du bras du robot, et sur le côté droit, nous avons les six curseurs pour contrôler les servos et un curseur pour le contrôle de la vitesse.

Chaque curseur a une valeur initiale, minimale et maximale différente qui convient aux articulations du bras du robot. Au bas de l'application, nous avons trois boutons, SAVE, RUN et RESET à travers lesquels nous pouvons programmer le bras du robot pour qu'il s'exécute automatiquement. Il y a aussi une étiquette ci-dessous qui indique le nombre d'étapes que nous avons enregistrées. Néanmoins, pour plus de détails sur la façon de créer des applications comme celle-ci à l'aide de MIT App Inventor, vous pouvez consulter mon autre didacticiel détaillé.

Ok, voyons maintenant le programme ou les blocs derrière l'application. Tout d'abord, sur le côté gauche, nous avons les blocs pour connecter le smartphone au module Bluetooth.

Ensuite, nous avons les blocs de curseurs pour le contrôle de la position du servo et les blocs de boutons pour la programmation du bras du robot. Donc, si nous modifions la position du curseur, en utilisant la fonction Bluetooth .SendText, nous envoyons un texte à l'Arduino. Ce texte consiste en un préfixe qui indique quel curseur a été modifié ainsi que la valeur actuelle du curseur.

Voici un fichier de téléchargement du projet MIT App Inventor ci-dessus, ainsi que l'application Android prête à être installée sur votre smartphone :

Fichier de projet Arduino Robot Arm Control MIT App Inventor

Application Android Arduino Robot Arm Control

Donc, sur l'Arduino, en utilisant la fonction startsWith(), nous vérifions le préfixe de chaque donnée entrante et nous savons donc quoi faire ensuite. Par exemple, si le préfixe est "s1", nous savons que nous devons déplacer le servo numéro un. En utilisant la fonction substring() nous obtenons le texte restant, ou c'est la valeur de la position, nous le convertissons en entier et utilisons la valeur pour déplacer le servo à cette position.

// If "Waist" slider has changed value - Move Servo 1 to position
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length()); // Extract only the number. E.g. from "s1120" to "120"
      servo1Pos = dataInS.toInt();  // Convert the string into integerCode language: Arduino (arduino)

Ici, nous pouvons simplement appeler la fonction write () et le servo ira à cette position, mais de cette façon, le servo fonctionnera à sa vitesse maximale, ce qui est trop pour le bras du robot. Au lieu de cela, nous devons contrôler la vitesse des servos, j'ai donc utilisé des boucles FOR afin de déplacer progressivement le servo de la position précédente à la position actuelle en mettant en place un délai entre chaque itération. En modifiant le temps de retard, vous pouvez modifier la vitesse du servo.

// We use for loops so we can control the speed of the servo
      // If previous position is bigger then current position
      if (servo1PPos > servo1Pos) {
        for ( int j = servo1PPos; j >= servo1Pos; j--) {   // Run servo down
          servo01.write(j);
          delay(20);    // defines the speed at which the servo rotates
        }
      }
      // If previous position is smaller then current position
      if (servo1PPos < servo1Pos) {
        for ( int j = servo1PPos; j <= servo1Pos; j++) {   // Run servo up
          servo01.write(j);
          delay(20);
        }
      }
      servo1PPos = servo1Pos;   // set current position as previous position
    }Code language: Arduino (arduino)

La même méthode est utilisée pour entraîner chaque axe du bras du robot.

En dessous se trouve le bouton SAVE. Si nous appuyons sur le bouton SAVE, la position de chaque servomoteur est stockée dans un tableau. À chaque pression, l'index augmente de sorte que le tableau se remplit pas à pas.

// If button "SAVE" is pressed
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
    }Code language: Arduino (arduino)

Ensuite, si nous appuyons sur le bouton RUN, nous appelons la fonction personnalisée runservo() qui exécute les étapes stockées. Jetons un coup d'œil à cette fonction. Donc, ici, nous exécutons les étapes stockées encore et encore jusqu'à ce que nous appuyions sur le bouton RESET. À l'aide de la boucle FOR, nous parcourons toutes les positions stockées dans les tableaux et, en même temps, nous vérifions si nous avons des données entrantes du smartphone. Ces données peuvent être le bouton RUN/PAUSE, qui met le robot en pause et, s'il est à nouveau cliqué, il continue avec les mouvements automatiques. De plus, si nous modifions la position du curseur de vitesse, nous utiliserons cette valeur pour modifier le temps de retard entre chaque itération dans les boucles FOR ci-dessous, qui contrôlent la vitesse des servomoteurs.

// Automatic mode custom function - run the saved steps
void runservo() {
  while (dataIn != "RESET") {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.readString();
        if ( dataIn == "PAUSE") {           // If button "PAUSE" is pressed
          while (dataIn != "RUN") {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if ( dataIn == "RESET") {     
                break;
              }
            }
          }
        }
        // If SPEED slider is changed
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Change servo speed (delay time)
        }
      }
      // 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);
        }
      }Code language: Arduino (arduino)

De la même manière qu'expliqué précédemment avec ces instructions IF et boucles FOR, nous déplaçons les servos vers leur position suivante. Enfin, si nous appuyons sur le bouton RESET, nous effacerons toutes les données des tableaux à zéro et réinitialiserons également l'index à zéro afin que nous puissions reprogrammer le bras du robot avec de nouveaux mouvements.

// If button "RESET" is pressed
    if ( dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
      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;  // Index to 0
    }Code language: Arduino (arduino)

Et voilà, maintenant nous pouvons profiter et nous amuser avec le bras du robot.

Voici le code complet du bras robotique Arduino :

/*        
       DIY Arduino Robot Arm Smartphone Control  
        by 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 Bluetooth (TX, RX)

int servo1Pos, servo2Pos, servo3Pos, servo4Pos, servo5Pos, servo6Pos; // current position
int servo1PPos, servo2PPos, servo3PPos, servo4PPos, servo5PPos, servo6PPos; // previous position
int servo01SP[50], servo02SP[50], servo03SP[50], servo04SP[50], servo05SP[50], servo06SP[50]; // for storing positions/steps
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); // Default baud rate of the Bluetooth module
  Bluetooth.setTimeout(1);
  delay(20);
  // Robot arm initial position
  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() {
  // Check for incoming data
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.readString();  // Read the data as string
    
    // If "Waist" slider has changed value - Move Servo 1 to position
    if (dataIn.startsWith("s1")) {
      String dataInS = dataIn.substring(2, dataIn.length()); // Extract only the number. E.g. from "s1120" to "120"
      servo1Pos = dataInS.toInt();  // Convert the string into integer
      // We use for loops so we can control the speed of the servo
      // If previous position is bigger then current position
      if (servo1PPos > servo1Pos) {
        for ( int j = servo1PPos; j >= servo1Pos; j--) {   // Run servo down
          servo01.write(j);
          delay(20);    // defines the speed at which the servo rotates
        }
      }
      // If previous position is smaller then current position
      if (servo1PPos < servo1Pos) {
        for ( int j = servo1PPos; j <= servo1Pos; j++) {   // Run servo up
          servo01.write(j);
          delay(20);
        }
      }
      servo1PPos = servo1Pos;   // set current position as previous position
    }
    
    // Move Servo 2
    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;
    }
    // Move Servo 3
    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;
    }
    // Move Servo 4
    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;
    }
    // Move Servo 5
    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;
    }
    // Move Servo 6
    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; 
    }
    // If button "SAVE" is pressed
    if (dataIn.startsWith("SAVE")) {
      servo01SP[index] = servo1PPos;  // save position into the array
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++;                        // Increase the array index
    }
    // If button "RUN" is pressed
    if (dataIn.startsWith("RUN")) {
      runservo();  // Automatic mode - run the saved steps 
    }
    // If button "RESET" is pressed
    if ( dataIn == "RESET") {
      memset(servo01SP, 0, sizeof(servo01SP)); // Clear the array data to 0
      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;  // Index to 0
    }
  }
}

// Automatic mode custom function - run the saved steps
void runservo() {
  while (dataIn != "RESET") {   // Run the steps over and over again until "RESET" button is pressed
    for (int i = 0; i <= index - 2; i++) {  // Run through all steps(index)
      if (Bluetooth.available() > 0) {      // Check for incomding data
        dataIn = Bluetooth.readString();
        if ( dataIn == "PAUSE") {           // If button "PAUSE" is pressed
          while (dataIn != "RUN") {         // Wait until "RUN" is pressed again
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.readString();
              if ( dataIn == "RESET") {     
                break;
              }
            }
          }
        }
        // If speed slider is changed
        if (dataIn.startsWith("ss")) {
          String dataInS = dataIn.substring(2, dataIn.length());
          speedDelay = dataInS.toInt(); // Change servo speed (delay time)
        }
      }
      // 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);
        }
      }

      // Servo 2
      if (servo02SP[i] == servo02SP[i + 1]) {
      }
      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);
        }
      }

      // Servo 3
      if (servo03SP[i] == servo03SP[i + 1]) {
      }
      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);
        }
      }

      // Servo 4
      if (servo04SP[i] == servo04SP[i + 1]) {
      }
      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);
        }
      }

      // Servo 5
      if (servo05SP[i] == servo05SP[i + 1]) {
      }
      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);
        }
      }

      // Servo 6
      if (servo06SP[i] == servo06SP[i + 1]) {
      }
      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);
        }
      }
    }
  }
}Code language: Arduino (arduino)

J'espère que cette vidéo vous a plu et que vous avez appris quelque chose de nouveau. N'hésitez pas à poser des questions dans la section des commentaires ci-dessous et à consulter ma collection de projets Arduino.