Contrôle fluide d'un bras robot Arduino sur plateforme à roues Mecanum

Dans ce tutoriel, je vous montre comment j'ai fait fonctionner ensemble ma plateforme robot à roues Mecanum (vidéo précédente) et mon bras robotique imprimé en 3D (autre projet Arduino précédent), de manière automatique et synchronisée.

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

Vue d'ensemble

On contrôle la plateforme à roues Mecanum via l'application Android personnalisée, comme expliqué dans la vidéo précédente. En plus, l'application inclut maintenant des boutons pour contrôler le bras robotique.

Contrôle fluide d un bras robot Arduino sur plateforme à roues Mecanum

L'application originale de contrôle du bras utilisait des curseurs pour les articulations, mais cela posait des problèmes de stabilité. Cette nouvelle version fonctionne beaucoup mieux, je la fournirai donc en mise à jour du projet original avec le code Arduino.

La fonctionnalité la plus cool : la capacité d'enregistrer les mouvements et de les rejouer automatiquement en boucle.

Avec le bouton « Save », on enregistre simplement les positions des moteurs à chaque étape. Ensuite, « Run » lance la répétition automatique infinie de la séquence enregistrée.

Construction du robot Arduino

J'ai la plateforme à roues Mecanum déjà assemblée (détails dans vidéo précédente).

Voici les pièces imprimées 3D du bras robotique et les servomoteurs, voyons l'assemblage. Modèle 3D du projet :

Disponible en téléchargement et exploration navigateur sur Thangs.

Télécharger le modèle 3D sur Thangs.

Fichiers STL pour impression 3D :

Le premier servo du bras se monte directement sur le couvercle supérieur de la plateforme Mecanum.

Marquage de l'emplacement, perçage de plusieurs trous à la mèche 10mm.

Découpe à la râpe entre les trous, ajustage de l'ouverture pour le servo. Fixation par 4 boulons/écrous M3.

Sur l'arbre de sortie de ce servo, avec le disque rond fourni en accessoire, on fixe la pièce suivante (le « taille » du bras). Mais la pièce reste ~8mm au-dessus de la plaque. J'ai donc ajouté deux plaques MDF 8mm pour que la pièce glisse dessus, stabilisant l'articulation.

Le disque rond est fixé à la pièce taille par les vis auto-taraudeuses fournies avec le servo, puis le disque est fixé à l'arbre du servo par la vis appropriée fournie.

Servo d'épaule : mise en place et fixation à la pièce imprimée par vis auto-taraudeuses.

Disque rond sur la pièce suivante, les deux pièces fixées ensemble par boulon sur l'arbre de sortie du servo.

Important : avant fixation, vérifier l'amplitude complète de mouvement. J'ai aussi ajouté un élastique sur l'articulation d'épaule pour aider le servo, qui porte le poids du reste du bras et de la charge.

Assemblage du reste du bras de manière similaire.

Assemblage de la pince. Contrôlée par un servo SG90, sur lequel on fixe d'abord un lien denté conçu sur mesure. On l'associe à un autre lien denté de l'autre côté, fixé par boulon/écrou M4. Tous les autres liens sont connectés par boulons/écrous M4.

Le modèle 3D de la pince avait des trous 3mm, mais je manquais de boulons M3, donc j'ai élargi à 4mm à la perceuse et utilisé des M4.

Pince assemblée, fixée au dernier servo, bras robotique terminé.

Gestion des câbles : passage des fils des servos dans les trous prévus du bras. Perçage 10mm sur la plaque supérieure pour passage des fils.

Regroupement des fils par collier de serrage, reste à les connecter à la carte Arduino.

Schéma circuit robot Arduino

Voici le schéma de câblage complet.

Composants nécessaires :

Moteur pas-à-pas NEMA 17
Driver pas-à-pas DRV8825
Servomoteur MG996R
Micro servo SG90
Module Bluetooth HC-05
Batterie Li-Po
Carte Arduino Mega

Dans le tutoriel précédent, j'expliquais le fonctionnement de la plateforme Mecanum et montrais mon PCB personnalisé pour elle.

J'ai inclus un régulateur 5V (LM350, jusqu'à 3A) sur ce PCB pour alimenter les servos. Les 6 servos du bras peuvent tirer 2-3A, ce que le régulateur peut tenir mais il chauffe beaucoup.

J'ai donc ajouté un radiateur et un petit ventilateur 12V DC pour le refroidir, le radiateur seul ne suffisait pas.

Connexion des fils de signal des servos aux broches numériques 5 à 10 de l'Arduino, alimentation via le connecteur 5V du PCB. Tous les fils rentrés dans la plateforme, plaque supérieure fixée par les deux écrous.

Assemblage terminé.

Code Arduino

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

D'abord : définition des 6 servos, 4 moteurs pas-à-pas, communication Bluetooth, et variables. Dans setup() : vitesse max des pas-à-pas, broches servos, initialisation Bluetooth, position initiale du bras.

#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01;
Servo servo02;
Servo servo03;
Servo servo04;
Servo servo05;
Servo servo06;
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
// Définition moteurs pas-à-pas et broches
AccelStepper LeftBackWheel(1, 42, 43); // (Type:driver, STEP, DIR) - Stepper1
AccelStepper LeftFrontWheel(1, 40, 41); // Stepper2
AccelStepper RightBackWheel(1, 44, 45); // Stepper3
AccelStepper RightFrontWheel(1, 46, 47); // Stepper4
#define led 14
int wheelSpeed = 1500;
int lbw[50], lfw[50], rbw[50], rfw[50]; // tableaux stockage positions/pas
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]; // stockage positions
int speedDelay = 20;
int index = 0;
int dataIn;
int m = 0;
void setup() {
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);
  pinMode(led, OUTPUT);
  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 module Bluetooth
  Bluetooth.setTimeout(5);
  delay(20);
  Serial.begin(38400);
  // Position initiale bras robotique
  servo1PPos = 90; servo01.write(servo1PPos);
  servo2PPos = 100; servo02.write(servo2PPos);
  servo3PPos = 120; servo03.write(servo3PPos);
  servo4PPos = 95; servo04.write(servo4PPos);
  servo5PPos = 60; servo05.write(servo5PPos);
  servo6PPos = 110; servo06.write(servo6PPos);
}

Dans loop(), on commence par vérifier les données entrantes.

// Vérification données entrantes
if (Bluetooth.available() > 0) {
  dataIn = Bluetooth.read(); // Lecture donnée

Ces données viennent du smartphone/app Android, faite avec MIT App Inventor. Boutons simples avec images en arrière-plan.

Dans les blocs de l'app, on voit qu'elle envoie des nombres sur un octet quand les boutons sont pressés.

Selon le bouton, on dit à l'Arduino quoi faire. Exemple : réception '2' → plateforme avance via fonction moveForward().

if (dataIn == 2) { m = 2; }
if (m == 2) { moveForward(); }

Cette fonction met les 4 moteurs pas-à-pas en rotation avant.

void moveForward() {
  LeftFrontWheel.setSpeed(wheelSpeed);
  LeftBackWheel.setSpeed(wheelSpeed);
  RightFrontWheel.setSpeed(wheelSpeed);
  RightBackWheel.setSpeed(wheelSpeed);
}

Pour les autres directions, on fait tourner les roues dans les sens appropriés.

Pour le bras robotique, même méthode : boutons dans l'app, maintien enfoncé = mouvement de l'articulation dans la direction correspondante.

Dans l'app originale, on utilisait des curseurs pour les positions des servos, mais cela posait problème : envoi de texte au lieu d'un octet unique. L'Arduino perdait parfois le texte, causant erreurs ou tremblements du bras.

Ici, on envoie un seul octet quand un bouton est pressé (touch down).

Le code Arduino entre dans la boucle while de ce nombre, y reste jusqu'au relâchement (touch up) qui envoie 0 = ne rien faire.

// Servo 1 direction positive
while (m == 16) {
  if (Bluetooth.available() > 0) { m = Bluetooth.read(); }
  servo01.write(servo1PPos);
  servo1PPos++;
  delay(speedDelay);
}
// Servo 1 direction négative
while (m == 17) {
  if (Bluetooth.available() > 0) { m = Bluetooth.read(); }
  servo01.write(servo1PPos);
  servo1PPos--;
  delay(speedDelay);
}

Selon boutons pressés, servos bougent en positif ou négatif. Même principe pour tous les servos. Vitesse modifiée via curseur (valeurs 100-250).

// Si curseur vitesse bras modifié
if (dataIn > 101 & dataIn < 250) {
  speedDelay = dataIn / 10; // Changement vitesse servo (délai)
}

Division par 10 → valeurs 10-25 utilisées comme délai en microsecondes dans les boucles while.

Pour stocker les mouvements : sauvegarde positions actuelles servos et pas-à-pas dans tableaux à chaque pression « Save ».

// Si bouton "SAVE" pressé
if (m == 12) {
  if (index == 0) {
    LeftBackWheel.setCurrentPosition(0);
    LeftFrontWheel.setCurrentPosition(0);
    RightBackWheel.setCurrentPosition(0);
    RightFrontWheel.setCurrentPosition(0);
  }
  lbw[index] = LeftBackWheel.currentPosition();
  lfw[index] = LeftFrontWheel.currentPosition();
  rbw[index] = RightBackWheel.currentPosition();
  rfw[index] = RightFrontWheel.currentPosition();
  servo01SP[index] = servo1PPos;
  servo02SP[index] = servo2PPos;
  servo03SP[index] = servo3PPos;
  servo04SP[index] = servo4PPos;
  servo05SP[index] = servo5PPos;
  servo06SP[index] = servo6PPos;
  index++;
  m = 0;
}

Puis bouton « Run » appelle runSteps() qui exécute les étapes stockées via boucles for/while.

if (m == 14) {
  runSteps();
  if (dataIn != 14) {
    stopMoving();
    memset(lbw, 0, sizeof(lbw));
    memset(lfw, 0, sizeof(lfw));
    memset(rbw, 0, sizeof(rbw));
    memset(rfw, 0, sizeof(rfw));
    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;
  }
}

Note : ça repart de la première à la dernière position en boucle. Donc lors de l'enregistrement, il faut que la première étape ait la même position que la dernière. Pendant l'exécution, on peut changer vitesse plateforme et bras, pauser, réinitialiser.

Téléchargement app et fichier projet modifiable :

Code Arduino complet :

/* Bras robot Arduino et Robot roues Mecanum - Contrôle Smartphone via Bluetooth par Dejan, www.HowToMechatronics.com */
#include <SoftwareSerial.h>
#include <AccelStepper.h>
#include <Servo.h>
Servo servo01; Servo servo02; Servo servo03; Servo servo04; Servo servo05; Servo servo06;
SoftwareSerial Bluetooth(A8, 38); // Arduino(RX, TX) - HC-05 Bluetooth (TX, RX)
AccelStepper LeftBackWheel(1, 42, 43);
AccelStepper LeftFrontWheel(1, 40, 41);
AccelStepper RightBackWheel(1, 44, 45);
AccelStepper RightFrontWheel(1, 46, 47);
#define led 14
int wheelSpeed = 1500;
int lbw[50], lfw[50], rbw[50], rfw[50];
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;
int dataIn;
int m = 0;
void setup() {
  LeftFrontWheel.setMaxSpeed(3000);
  LeftBackWheel.setMaxSpeed(3000);
  RightFrontWheel.setMaxSpeed(3000);
  RightBackWheel.setMaxSpeed(3000);
  pinMode(led, OUTPUT);
  servo01.attach(5); servo02.attach(6); servo03.attach(7);
  servo04.attach(8); servo05.attach(9); servo06.attach(10);
  Bluetooth.begin(38400);
  Bluetooth.setTimeout(5);
  delay(20);
  Serial.begin(38400);
  servo1PPos = 90; servo01.write(servo1PPos);
  servo2PPos = 100; servo02.write(servo2PPos);
  servo3PPos = 120; servo03.write(servo3PPos);
  servo4PPos = 95; servo04.write(servo4PPos);
  servo5PPos = 60; servo05.write(servo5PPos);
  servo6PPos = 110; servo06.write(servo6PPos);
}
void loop() {
  if (Bluetooth.available() > 0) {
    dataIn = Bluetooth.read();
    if (dataIn == 0) { m = 0; }
    if (dataIn == 1) { m = 1; }
    if (dataIn == 2) { m = 2; }
    if (dataIn == 3) { m = 3; }
    if (dataIn == 4) { m = 4; }
    if (dataIn == 5) { m = 5; }
    if (dataIn == 6) { m = 6; }
    if (dataIn == 7) { m = 7; }
    if (dataIn == 8) { m = 8; }
    if (dataIn == 9) { m = 9; }
    if (dataIn == 10) { m = 10; }
    if (dataIn == 11) { m = 11; }
    if (dataIn == 12) { m = 12; }
    if (dataIn == 14) { m = 14; }
    if (dataIn == 16) { m = 16; }
    if (dataIn == 17) { m = 17; }
    if (dataIn == 18) { m = 18; }
    if (dataIn == 19) { m = 19; }
    if (dataIn == 20) { m = 20; }
    if (dataIn == 21) { m = 21; }
    if (dataIn == 22) { m = 22; }
    if (dataIn == 23) { m = 23; }
    if (dataIn == 24) { m = 24; }
    if (dataIn == 25) { m = 25; }
    if (dataIn == 26) { m = 26; }
    if (dataIn == 27) { m = 27; }
    if (m == 4) { moveSidewaysLeft(); }
    if (m == 5) { moveSidewaysRight(); }
    if (m == 2) { moveForward(); }
    if (m == 7) { moveBackward(); }
    if (m == 3) { moveRightForward(); }
    if (m == 1) { moveLeftForward(); }
    if (m == 8) { moveRightBackward(); }
    if (m == 6) { moveLeftBackward(); }
    if (m == 9) { rotateLeft(); }
    if (m == 10) { rotateRight(); }
    if (m == 0) { stopMoving(); }
    if (dataIn > 30 & dataIn < 100) { wheelSpeed = dataIn * 20; }
    while (m == 16) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo01.write(servo1PPos); servo1PPos++; delay(speedDelay); }
    while (m == 17) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo01.write(servo1PPos); servo1PPos--; delay(speedDelay); }
    while (m == 19) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo02.write(servo2PPos); servo2PPos++; delay(speedDelay); }
    while (m == 18) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo02.write(servo2PPos); servo2PPos--; delay(speedDelay); }
    while (m == 20) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo03.write(servo3PPos); servo3PPos++; delay(speedDelay); }
    while (m == 21) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo03.write(servo3PPos); servo3PPos--; delay(speedDelay); }
    while (m == 23) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo04.write(servo4PPos); servo4PPos++; delay(speedDelay); }
    while (m == 22) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo04.write(servo4PPos); servo4PPos--; delay(speedDelay); }
    while (m == 25) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo05.write(servo5PPos); servo5PPos++; delay(speedDelay); }
    while (m == 24) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo05.write(servo5PPos); servo5PPos--; delay(speedDelay); }
    while (m == 26) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo06.write(servo6PPos); servo6PPos++; delay(speedDelay); }
    while (m == 27) { if (Bluetooth.available() > 0) { m = Bluetooth.read(); } servo06.write(servo6PPos); servo6PPos--; delay(speedDelay); }
    if (dataIn > 101 & dataIn < 250) { speedDelay = dataIn / 10; }
    if (m == 12) {
      if (index == 0) {
        LeftBackWheel.setCurrentPosition(0);
        LeftFrontWheel.setCurrentPosition(0);
        RightBackWheel.setCurrentPosition(0);
        RightFrontWheel.setCurrentPosition(0);
      }
      lbw[index] = LeftBackWheel.currentPosition();
      lfw[index] = LeftFrontWheel.currentPosition();
      rbw[index] = RightBackWheel.currentPosition();
      rfw[index] = RightFrontWheel.currentPosition();
      servo01SP[index] = servo1PPos;
      servo02SP[index] = servo2PPos;
      servo03SP[index] = servo3PPos;
      servo04SP[index] = servo4PPos;
      servo05SP[index] = servo5PPos;
      servo06SP[index] = servo6PPos;
      index++; m = 0;
    }
    if (m == 14) {
      runSteps();
      if (dataIn != 14) {
        stopMoving();
        memset(lbw, 0, sizeof(lbw));
        memset(lfw, 0, sizeof(lfw));
        memset(rbw, 0, sizeof(rbw));
        memset(rfw, 0, sizeof(rfw));
        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;
      }
    }
  }
  LeftFrontWheel.runSpeed();
  LeftBackWheel.runSpeed();
  RightFrontWheel.runSpeed();
  RightBackWheel.runSpeed();
  int sensorValue = analogRead(A0);
  float voltage = sensorValue * (5.0 / 1023.00) * 3;
  if (voltage < 11) { digitalWrite(led, HIGH); } else { digitalWrite(led, LOW); }
}
void moveForward() { LeftFrontWheel.setSpeed(wheelSpeed); LeftBackWheel.setSpeed(wheelSpeed); RightFrontWheel.setSpeed(wheelSpeed); RightBackWheel.setSpeed(wheelSpeed); }
void moveBackward() { LeftFrontWheel.setSpeed(-wheelSpeed); LeftBackWheel.setSpeed(-wheelSpeed); RightFrontWheel.setSpeed(-wheelSpeed); RightBackWheel.setSpeed(-wheelSpeed); }
void moveSidewaysRight() { LeftFrontWheel.setSpeed(wheelSpeed); LeftBackWheel.setSpeed(-wheelSpeed); RightFrontWheel.setSpeed(-wheelSpeed); RightBackWheel.setSpeed(wheelSpeed); }
void moveSidewaysLeft() { LeftFrontWheel.setSpeed(-wheelSpeed); LeftBackWheel.setSpeed(wheelSpeed); RightFrontWheel.setSpeed(wheelSpeed); RightBackWheel.setSpeed(-wheelSpeed); }
void rotateLeft() { LeftFrontWheel.setSpeed(-wheelSpeed); LeftBackWheel.setSpeed(-wheelSpeed); RightFrontWheel.setSpeed(wheelSpeed); RightBackWheel.setSpeed(wheelSpeed); }
void rotateRight() { LeftFrontWheel.setSpeed(wheelSpeed); LeftBackWheel.setSpeed(wheelSpeed); RightFrontWheel.setSpeed(-wheelSpeed); RightBackWheel.setSpeed(-wheelSpeed); }
void moveRightForward() { LeftFrontWheel.setSpeed(wheelSpeed); LeftBackWheel.setSpeed(0); RightFrontWheel.setSpeed(0); RightBackWheel.setSpeed(wheelSpeed); }
void moveRightBackward() { LeftFrontWheel.setSpeed(0); LeftBackWheel.setSpeed(-wheelSpeed); RightFrontWheel.setSpeed(-wheelSpeed); RightBackWheel.setSpeed(0); }
void moveLeftForward() { LeftFrontWheel.setSpeed(0); LeftBackWheel.setSpeed(wheelSpeed); RightFrontWheel.setSpeed(wheelSpeed); RightBackWheel.setSpeed(0); }
void moveLeftBackward() { LeftFrontWheel.setSpeed(-wheelSpeed); LeftBackWheel.setSpeed(0); RightFrontWheel.setSpeed(0); RightBackWheel.setSpeed(-wheelSpeed); }
void stopMoving() { LeftFrontWheel.setSpeed(0); LeftBackWheel.setSpeed(0); RightFrontWheel.setSpeed(0); RightBackWheel.setSpeed(0); }
void runSteps() {
  while (dataIn != 13) {
    for (int i = 0; i <= index - 2; i++) {
      if (Bluetooth.available() > 0) {
        dataIn = Bluetooth.read();
        if (dataIn == 15) {
          while (dataIn != 14) {
            if (Bluetooth.available() > 0) {
              dataIn = Bluetooth.read();
              if (dataIn == 13) { break; }
            }
          }
        }
        if (dataIn > 100 & dataIn < 150) { speedDelay = dataIn / 10; }
        if (dataIn > 30 & dataIn < 100) { wheelSpeed = dataIn * 10; dataIn = 14; }
        if (dataIn == 13) { break; }
      }
      LeftFrontWheel.moveTo(lfw[i]); LeftFrontWheel.setSpeed(wheelSpeed);
      LeftBackWheel.moveTo(lbw[i]); LeftBackWheel.setSpeed(wheelSpeed);
      RightFrontWheel.moveTo(rfw[i]); RightFrontWheel.setSpeed(wheelSpeed);
      RightBackWheel.moveTo(rbw[i]); RightBackWheel.setSpeed(wheelSpeed);
      while (LeftBackWheel.currentPosition() != lbw[i] & LeftFrontWheel.currentPosition() != lfw[i] & RightFrontWheel.currentPosition() != rfw[i] & RightBackWheel.currentPosition() != rbw[i]) {
        LeftFrontWheel.runSpeedToPosition(); LeftBackWheel.runSpeedToPosition();
        RightFrontWheel.runSpeedToPosition(); RightBackWheel.runSpeedToPosition();
      }
      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); } }
      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); } }
      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); } }
      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); } }
      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); } }
      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); } }
    }
  }
}

Ce projet fonctionne bien, mais n'est pas parfait. Les mouvements automatiques manquent de précision à cause du patinage des roues Mecanum et des servos bon marché qui tremblotent même à l'arrêt, faute de couple pour maintenir le poids des pièces imprimées.

J'espère que ce tutoriel vous a plu et appris quelque chose. Questions en commentaires, et découvrez ma collection de projets Arduino.