Construire un robot hexapode Arduino (Fourmi) : guide étape par étape

Présentation

Dans ce tutoriel, je vous montre comment j'ai construit un robot hexapode Arduino. Comme son nom l'indique, il a 6 pattes, mais aussi un abdomen (queue), une tête, des antennes, des mandibules et même des yeux fonctionnels. L'ensemble lui donne l'apparence d'une fourmi, d'où le nom "Arduino Ant Robot".

Vidéo ou tutoriel écrit ci-dessous.

Vue d'ensemble

Le robot est piloté via une application Android personnalisée (4 boutons : avancer, reculer, gauche, droite). Fonctions supplémentaires : mouvement tête/queue, mordre, saisir/lâcher, attaquer.

Les "yeux" intègrent un capteur ultrason HC-SR04. Si on approche la main, le robot prépare une attaque. Si on recule, il annule. Si on s'approche davantage, il mord !

Modélisation 3D

Conception sous logiciel 3D. 6 pattes × 3 articulations = 18 servos MG996R. Queue : 1 MG996R. Tête : 2 degrés de liberté (roulis/tangage) = 2 MG996R. Mandibules : 1 micro servo SG90. Total : 21 servos MG996R + 1 SG90.

Yeux conçus pour loger le HC-SR04. Assemblage entre deux plaques + couvercle courbé supérieur cachant câblage, Arduino et batterie.

Fichiers STL sur Thangs (visualisation navigateur + téléchargement).

Impression 3D

Imprimante Creality CR-10. Pièce la plus délicate : la tête (impression monobloc). Support surplomb 60° + bloqueurs de support. Résultat parfait.

Assemblage mécanique

Pattes (×6)

Fixation servos sur pièces imprimées : vis M3 + écrous + rondelles frein (longueur ≥12 mm, j'ai utilisé 16 mm). ~200 vis total.

Liaisons entre pièces : rondelles de servo (perçage 3 mm) ou rondelles métalliques filetées M3. Retrait de la petite languette triangulaire sur le dessus des servos (couteau) pour affleurement parfait.

Avant d'insérer le 3ème servo (rotation hanche), placement d'un boulon M4 pour fixation ultérieure sur plaque de base.

Corps : fixation pattes sur plaques

Rondelles sur plaque supérieure fixées (M3). Connexion aux arbres servos après centrage précis (position milieu = amplitude max + calibration simplifiée).

Rondelle arrière pour servo queue. Robot retourné : insertion plaque inférieure sur boulons M4 des pattes, fixation avec rondelles plates et écrous auto-freinants. Attention : serrage modéré (pivots des pattes).

Tête : mécanisme roulis/tangage

Servo roulis : perpendiculaire aux plaques → 2 petites plaquettes de fixation. Centrage impératif (±90°).

Support en U : 2 rondelles pour relier servos roulis/tangage. Centrage servo roulis avant fixation.

Support servo tangage : boulon M4 sur support U + 4 vis M3 pour future fixation tête. Insertion servo tangage (léger flex du support U).

Mécanisme tête terminé (roulis + tangage).

Tête : mandibules, capteur, antennes

Pré-assemblage tête : mandibules + micro servo SG90 + capteur ultrason. Serrage boulon M4 via trou d'accès au niveau yeux.

Micro servo SG90 en place (2 vis). 2ème mandibule : petit bras sur rondelle SG90, insertion, engrenage, fixation vis.

Capteur ultrason HC-SR04 : ajustement parfait dans les yeux, collage cyanoacrylate.

Antennes : fil 3 mm, ~13 cm, légèrement courbé, collé cyano. Fixation tête sur mécanisme (4 boulons M3 préinsérés).

Éléments restants : queue (coulisse dans support) + couvercle courbé (électronique). Résultat final bleu/blanc très réussi.

Schéma électronique

22 servos + module Bluetooth HC-05 + condensateurs/résistances. Cerveau : Arduino Mega (seule carte gérant >12 servos avec librairie Servo).

Alimentation : batterie 3S LiPo (~12 V, fort courant). Servos 4,8-7,2 V → convertisseur DC-DC buck 12V→5V (≥10-15 A recommandé, 8 A max utilisé, pic observé ~6 A).

Composants

• Servo MG996R (×21)
• Micro servo SG90
• Module Bluetooth HC-05
• Arduino Mega
• Batterie 3S LiPo
• Convertisseur DC-DC Buck (10-15 A)

PCB Shield Arduino Mega

Câblage 22 servos = chaos. PCB personnalisé (EasyEDA) agissant comme shield Mega : connecteurs servos regroupés, 2 gros condensateurs stabilisation, emplacement NRF24L01 (option radio), broches digitales/analogiques, 5V/GND, 2 LEDs, surveillance tension batterie (diviseur R1/R2 → pin analogique).

Fichiers projet PCB. Commande JLCPCB (sponsor), couleur bleue (assortie Mega), 10 PCB pour 2 $ (1ère commande).

Assemblage PCB

Soudure connecteurs mâles (côté verso pour insertion sur Mega). Technique : pose connecteurs, plaque maintient, retournement, soudure. Idem pour connecteurs servos. Puis composants CMS (résistances, condensateurs, borniers).

Réglage buck converter à 5V (potentiomètre). Interrupteur sur entrée, batterie 12V sur broche surveillance. Rappel : entrée puissance PCB = 5V.

Insertion électronique entre plaques : batterie (scotch), Arduino+shield, module NRF24L01 ou Bluetooth, LED alerte batterie (<11V), connexion tous servos (noter numéros broches !), couvercle courbé. Projet terminé mécaniquement.

Code Arduino Hexapode

Code long → présentation par sections. Librairies : Servo.h, SoftwareSerial.h (Bluetooth).

#include <Servo.h> 
#include <SoftwareSerial.h> 
#define trigPin 7 
#define echoPin 6 
#define ledB 10 
SoftwareSerial Bluetooth(12, 9); // Arduino RX, TX - HC-05 TX, RX

// 22 objets Servo
Servo s1, s2, s3, s4, s5, s6, s7, s8, s9, s10, s11, s12;
Servo s13, s14, s15, s16, s17, s18, s19, s20, s21, s22, s23, s24;

Setup : Bluetooth, capteurs, attache servos, position initiale

void setup() {
  Serial.begin(38400);
  Bluetooth.begin(38400); Bluetooth.setTimeout(1); delay(20);
  pinMode(trigPin, OUTPUT); pinMode(echoPin, INPUT); pinMode(ledB, OUTPUT);
  
  // Tête
  s15.attach(36, 600, 2400); s14.attach(35, 600, 2400); s13.attach(34, 600, 2400);
  // Mandibules
  s5.attach(26, 600, 2400);
  // Queue
  // Pattes 4,5,6,1,2,3 (3 servos chacune: hanche, genou, rotation)
  s10.attach(31,600,2400); s11.attach(32,600,2400); s12.attach(33,600,2400); // Patte 4
  s7.attach(28,600,2400); s8.attach(29,600,2400); s9.attach(30,600,2400);   // Patte 5
  s1.attach(22,600,2400); s2.attach(23,600,2400); s3.attach(24,600,2400);   // Patte 6
  s18.attach(39,600,2400); s17.attach(38,600,2400); s16.attach(37,600,2400); // Patte 1
  s21.attach(42,600,2400); s20.attach(41,600,2400); s19.attach(40,600,2400); // Patte 2
  s24.attach(45,600,2400); s23.attach(44,600,2400); s22.attach(43,600,2400); // Patte 3
  
  // Position initiale = calibration logicielle
  s15.write(72); s14.write(50); s13.write(90); // Tête
  s5.write(65); // Mandibules
  s10.write(65); s11.write(35); s12.write(40); // Patte 4
  s7.write(80); s8.write(50); s9.write(25);    // Patte 5
  s1.write(90); s2.write(45); s3.write(60);    // Patte 6
  s18.write(60); s17.write(90); s16.write(100); // Patte 1
  s21.write(50); s20.write(85); s19.write(75); // Patte 2
  s24.write(50); s23.write(80); s22.write(80); // Patte 3
}

Algorithme de marche (sans cinématique inverse)

Servos MG996R bas de gamme : couple insuffisant, positionnement imprécis → approche simplifiée. Fonction par patte avec compteurs. Cycle = phase balancement (pied en l'air) + phase appui (pied au sol).

void moveLeg1() {
  // Phase balancement : lever patte
  if (i1L1 <= 10) { s18.write(60 - i1L1*2); s17.write(90 - i1L1*3); i1L1++; }
  // Rotation hanche
  if (i2L1 <= 30) { s16.write(100 - i2L1); i2L1++; }
  // Reposer patte (10 étapes avant fin rotation)
  if (i2L1 > 20 && i3L1 <= 10) { s18.write(40 + i3L1*2); s17.write(60 + i3L1*3); i3L1++; }
  // Phase appui : rotation retour
  if (i2L1 >= 30) { s16.write(70 + i4L1); i4L1++; l1status = HIGH; }
  // Reset compteurs
  if (i4L1 >= 30) { i1L1=i2L1=i3L1=i4L1=i5L1=0; }
  // Chaque étape exécutée dans loop() avec délai vitesse
}

6 fonctions similaires pour autres pattes + fonctions marche arrière, gauche, droite (décalage phases). Tête, queue, mandibules : même principe avec compteurs.

Commandes via Bluetooth / App Android

if (Bluetooth.available() > 0) {
  dataIn = Bluetooth.read();
  // dataIn = 2 → avancer, 0 → arrêt/position initiale, etc.
}

Application Android (MIT App Inventor)

Interface : images boutons, curseur vitesse, boutons connexion Bluetooth.

Logique : bouton "Avant" → envoie '2' → exécute marche avant. 2ème appui → envoie '0' → arrêt. Changement image bouton (normal/surligné). Même principe pour tous boutons.

Fichier projet App Inventor (.aia) + APK.

Surveillance batterie & capteur ultrason

// Tension batterie (diviseur → A3)
int sensorValue = analogRead(A3);
float voltage = sensorValue * (5.0 / 1023.0) * 2.9; // Conversion vers 12V
if (voltage < 11) digitalWrite(ledB, HIGH); else digitalWrite(ledB, LOW);

// Ultrason : attaque si objet < 40 cm
if (getDistance() > 40) att = 0;
if (getDistance() <= 40) { att = 1; dataIn = 99; }

Logique attaque : préparation → si objet >30 cm annule, si <30 cm attaque. Fonctions prepareAttack(), dismissAttack(), attack() avec temporisations.

if (att == 1) { prepareAttack(); 
  if (aStatus == HIGH) { delay(2000); 
    if (getDistance() > 30) { att=2; dismissAttack(); }
    if (getDistance() < 30) { att=3; attack(); }
  }
}
if (att == 2) { dismissAttack(); if (aStatus==HIGH) { dataIn=0; att=0; } }
if (att == 3) { attack(); /* ... */ }

Code complet téléchargeable ici. Défis : performance servos bas de gamme. Amusez-vous bien ! Questions en commentaires, découvrez mes autres projets Arduino.