Kit de robot araignée bionique quadrupède

Le kit robot araignée quadrupède est un robot marcheur livré en pièces : une structure en acrylique découpé, huit servomoteurs à pignons métalliques, une carte de commande ESP8266 et sa carte d’extension qui rassemble tous les connecteurs. On le monte soi-même, on le met au point, puis on le pilote depuis un téléphone par Wi-Fi ou en écrivant son propre programme. C’est le produit de référence pour comprendre ce qu’est un robot à plusieurs degrés de liberté : ici, chaque patte est menée par deux moteurs, et c’est la coordination des huit qui fait avancer la bête.

Le kit porte la référence ACEBOTT QD020, de la gamme Inventor Series du fabricant. La carte se programme de deux façons : par l’IDE Arduino en C++, comme n’importe quelle carte ESP8266, ou par ACECode et sa programmation par blocs, qui fait glisser des instructions à la souris. Le fabricant fournit huit leçons qui suivent l’assemblage, la mise au point puis le code, ce qui en fait un support de classe autant qu’un objet de loisir.

Deux points à prévoir avant de commander : la cellule 18650 qui alimente le robot n’est pas fournie, et le montage se fait entièrement à la vis, sans soudure, ce qui prend une soirée la première fois.

Caractéristiques techniques

Brochage des huit servomoteurs

Les huit servomoteurs ne sont pas branchés au hasard : chaque fiche a sa place, marquée sur la carte par un repère de broche. Le tableau ci-dessous reprend la répartition du montage d’origine, celle que reprend le programme plus bas.

Les repères D0 à D10 sont ceux de la sérigraphie de la carte ESP8266 : chaque repère correspond à une broche du microcontrôleur, et c’est cette correspondance que le programme utilise. Sur ce kit, les servomoteurs sont commandés directement par les broches de la carte, sans circuit intermédiaire : c’est le programme qui engendre les impulsions des huit moteurs.

Ce que fait chaque servomoteur

Sur un robot à quatre pattes, deux servomoteurs par patte ne sont pas un luxe mais une nécessité. Le servomoteur du corps, vissé sur le châssis, fait tourner la patte dans le plan horizontal : c’est lui qui fait avancer ou reculer le pied. Le servomoteur de patte, porté par la patte, la soulève et la repose : c’est lui qui décide si le pied est en l’air ou posé au sol. Pour marcher, il faut donc que les deux se répondent — avancer une patte au sol ne sert à rien, la faire tourner en l’air non plus.

C’est aussi la raison pour laquelle un robot de ce genre ne peut pas lever une patte à la fois : il tomberait. La marche se fait par groupes de pattes, en diagonale, et c’est cette coordination que l’on règle en écrivant des tables de positions plutôt qu’en pilotant les moteurs un par un.

Le montage, et la mise au point qui décide de tout

L’assemblage suit les étapes de la notice : visser les entretoises sur le plateau inférieur, y fixer les quatre servomoteurs du corps, monter la carte d’extension, puis assembler les pattes et les visser sur les palonniers. Aucune soudure : tout se visse, et chaque servomoteur se branche par sa fiche à trois fils.

Il y a une étape que l’on saute quand on est pressé, et qu’il faut au contraire faire le plus tôt possible : mettre chaque servomoteur au milieu, à 90 degrés, avant de visser son palonnier. Le palonnier est la pièce en plastique qui coiffe l’axe du moteur et sur laquelle vient la patte. Un servomoteur ne tourne pas indéfiniment : il balaie environ un demi-tour de part et d’autre de son point milieu. Si le palonnier est vissé alors que le moteur est déjà à 20 degrés de son milieu, la patte n’aura plus que 70 degrés de débattement d’un côté et 110 de l’autre — le robot penchera, une patte forcera en fin de course et le moteur grognera à chaque pas. Le programme ci-dessous sert exactement à ça.

Mini-projet : mettre les huit servomoteurs au point depuis le moniteur série

Le programme met les huit servomoteurs à 90 degrés à l’allumage, puis vous laisse déplacer chaque moteur à la demande depuis le moniteur série de l’IDE Arduino. Vous pouvez ainsi repérer, pour chacun des huit, l’angle exact qui met la patte au milieu de son débattement, et le noter avant de visser les palonniers. C’est la séance de réglage que réclame ce kit, et une bonne première leçon de commande de servomoteurs : huit positions, un tableau, et un dialogue avec l’ordinateur.

Ce qu’il faut

Le câblage

Rien à ajouter : les huit servomoteurs se branchent sur la carte d’extension, un par un, en suivant les repères de broches du tableau ci-dessus — les quatre premiers sur D1, D2, D6 et D7, les quatre autres sur D0, D4, D5 et D8. Le sens de la fiche compte : le fil brun va du côté de la masse. Vérifiez chaque fiche avant de mettre sous tension, un connecteur décalé d’un cran alimente le signal à la place de la masse.

Le programme

À copier dans l’IDE Arduino, puis à téléverser sur la carte. Laissez ouvert le moniteur série réglé sur 115200 bauds : c’est lui qui vous parle.

/*
 * Robot araignee ACEBOTT QD020 : mise au point des huit servomoteurs
 * Carte : ESP8266 posee sur la carte d'extension Spider Shield
 * Bibliotheque Servo fournie avec le coeur ESP8266 pour Arduino
 *
 * Composants, brochage et fiche complete : www.marocproduits.com
 */
#include "Servo.h"
// Les quatre servomoteurs fixes sur le corps du robot
const int CORPS[4] = {D1, D2, D6, D7};
// Les quatre servomoteurs portes par les pattes
const int PATTES[4] = {D0, D4, D5, D8};
const int MILIEU = 90;
// Position debout : a remplacer par les angles releves pendant le reglage
int POSITION[8] = {90, 90, 90, 90, 90, 90, 90, 90};
Servo servo[8];
int angle[8];
String ligne = "";
// Broche du servomoteur numero, de 1 a 8.
// Les quatre premiers sont sur le corps, les quatre suivants sur les pattes.
int broche(int numero) {
  if (numero == 1) return CORPS[0];
  if (numero == 2) return CORPS[1];
  if (numero == 3) return CORPS[2];
  if (numero == 4) return CORPS[3];
  if (numero == 5) return PATTES[0];
  if (numero == 6) return PATTES[1];
  if (numero == 7) return PATTES[2];
  return PATTES[3];
}
// Ramene un angle demande dans l'intervalle 0 a 180 degres.
int borner(int valeur) {
  if (valeur > 180) return 180;
  if (valeur > 0) return valeur;
  return 0;
}
// Envoie un servomoteur a une position, si le numero est valide.
void ecrire(int numero, int valeur) {
  if (numero == 0) return;
  if (numero > 8) return;
  angle[numero - 1] = borner(valeur);
  servo[numero - 1].write(angle[numero - 1]);
}
void afficher() {
  Serial.print("Angles :");
  for (int i = 0; i != 8; i++) {
    Serial.print(" ");
    Serial.print(angle[i]);
  }
  Serial.println();
}
void traiter(String texte) {
  texte.trim();
  if (texte == "m") {
    for (int i = 0; i != 8; i++) ecrire(i + 1, MILIEU);
    afficher();
    return;
  }
  if (texte == "d") {
    for (int i = 0; i != 8; i++) ecrire(i + 1, POSITION[i]);
    afficher();
    return;
  }
  int espace = texte.indexOf(32);   // 32 = code ASCII de l'espace
  if (espace == -1) {
    Serial.println("Format attendu : le numero du servo puis l'angle, par exemple 3 95");
    return;
  }
  int numero = texte.substring(0, espace).toInt();
  int valeur = texte.substring(espace + 1).toInt();
  if (numero == 0) {
    Serial.println("Le numero du servo va de 1 a 8.");
    return;
  }
  if (numero > 8) {
    Serial.println("Le numero du servo va de 1 a 8.");
    return;
  }
  ecrire(numero, valeur);
  afficher();
}
void setup() {
  Serial.begin(115200);
  for (int i = 0; i != 8; i++) {
    int numero = i + 1;
    servo[i].attach(broche(numero));
    angle[i] = MILIEU;
    servo[i].write(MILIEU);
    Serial.print("Servo ");
    Serial.print(numero);
    Serial.println(" pret");
  }
  Serial.println("Les huit servomoteurs sont au milieu, a 90 degres.");
  Serial.println("Tapez le numero du servo puis l'angle, par exemple : 3 95");
  Serial.println("m : remettre les huit servomoteurs au milieu");
  Serial.println("d : position debout enregistree dans POSITION");
}
void loop() {
  if (Serial.available() == 0) return;
  char c = Serial.read();
  if (c == 10) {          // 10 = code ASCII du retour a la ligne
    traiter(ligne);
    ligne = "";
    return;
  }
  if (c == 13) return;    // 13 = code ASCII du retour chariot
  ligne = ligne + c;
}

Comment ça marche

• broche() traduit un numéro de servomoteur, de 1 à 8, en broche de la carte. Les quatre premiers numéros désignent les servomoteurs du corps, les quatre suivants ceux des pattes : vous n’avez donc jamais à retenir les repères pendant le réglage.
• borner() ramène la valeur demandée entre 0 et 180 degrés. Un servomoteur ne peut pas aller au-delà de ses butées mécaniques, et une valeur aberrante envoyée par erreur ferait grogner les pignons sans rien apprendre.
• ecrire() vérifie le numéro, borne l’angle, l’enregistre dans le tableau angle et l’envoie au moteur. C’est le seul endroit du programme qui parle aux servomoteurs, et c’est ce qui permet à la commande d d’appliquer la position debout sans la recopier.
• traiter() lit la ligne saisie. m remet les huit moteurs au milieu, d applique la position debout, toute autre ligne est lue comme « numéro puis angle » — les deux nombres sont séparés par une espace.
• loop() assemble la saisie caractère par caractère. Le retour à la ligne déclenche le traitement ; le retour chariot est ignoré, car certains moniteurs série envoient les deux. C’est ce qui évite qu’une ligne vide soit interprétée comme un ordre.

Pour aller plus loin

Notez les huit angles trouvés, puis recopiez-les dans POSITION au début du programme : c’est cette ligne que la commande d applique, et c’est votre position debout à vous. Les valeurs diffèrent de quelques degrés d’un servomoteur à l’autre — c’est normal, deux pignons ne sont jamais montés au même cran. Une fois ces huit nombres en place, vous avez sous la main la brique de tout le reste : faire marcher le robot, c’est enchaîner des lignes comme celle-là, avec des temps de pause entre elles.

Variante : la marche, et pourquoi elle se fait en diagonale

Votre position debout est le point de départ de la marche. Sur quatre pattes, la séquence est toujours la même : on soulève une paire de pattes opposées — celle de devant à gauche et celle de derrière à droite —, on les fait avancer, on les repose, puis on recommence avec l’autre paire. Le robot n’est jamais en appui sur moins de deux pattes, et c’est ce qui l’empêche de tomber.

En pratique, cela s’écrit comme une suite de lignes dans le même style que POSITION : une ligne par temps du mouvement, et une pause de quelques dizaines de millisecondes entre deux lignes. Les six postures de l’application ACEBOTT donnent la référence du résultat à atteindre, et l’on retrouve leurs valeurs en observant le robot piloté depuis le téléphone. Le réglage qui compte est la vitesse : trop rapide, le robot sautille et perd l’équilibre ; trop lente, le mouvement se découpe en saccades.

Questions fréquentes

Les servomoteurs tremblent ou le robot n’avance pas

Dans l’ordre : vérifiez la charge de la cellule 18650, c’est la première cause — une cellule à plat fait perdre du couple aux huit moteurs, et c’est en fin de décharge que le robot marche le plus mal. Contrôlez ensuite que les huit fiches sont bien enfoncées sur les bonnes broches, puis les angles enregistrés dans POSITION : un robot qui penche a un palonnier vissé hors du point milieu. Et vérifiez enfin que les deux pattes d’une même paire sont montées en miroir, comme sur la vue de la notice : deux pattes orientées du même côté font sautiller le robot au lieu de le faire avancer.

Que faut-il comme alimentation ?

Une cellule lithium-ion au format 18650, que vous trouverez ici : elle se glisse dans le logement du robot et se recharge par le port USB type C de la carte, sans qu’il faille l’en sortir. Prenez une cellule de marque plutôt qu’une capacité annoncée invraisemblable — c’est la qualité de la cellule, pas le chiffre imprimé sur la gaine, qui fait la différence sur huit servomoteurs métalliques. Un câble USB type C est également nécessaire pour téléverser les programmes.

Un servomoteur grogne en fin de course ou ne revient plus au même point

Le grognement vient presque toujours d’un palonnier vissé hors du point milieu : le moteur force contre sa butée mécanique. Si le grognement persiste après avoir remis le servomoteur à 90 degrés, ou si le moteur ne rend plus la même position deux fois de suite, il a pris du jeu. Les huit moteurs du kit sont des MG90 à pignons métalliques : un servomoteur MG90S de rechange se visse à la même place, avec la même fiche à trois fils et la même commande.

Faut-il savoir souder, et faut-il savoir programmer ?

Non aux deux. Le montage se fait entièrement à la vis, avec la visserie et les entretoises fournies, et les servomoteurs se branchent par leurs fiches. Pour la programmation, l’application ACEBOTT prend le relais dès la sortie de la boîte : elle propose les six postures et les neuf actions du robot sans écrire une ligne. Le passage au code vient ensuite, avec ACECode pour une première approche par blocs, puis l’IDE Arduino pour aller plus loin.

Quelle carte y a-t-il dans le kit ?

Une carte ESP8266, montée sur la carte d’extension Spider Shield. C’est elle qui exécute le programme et qui porte le Wi-Fi : les huit broches de servomoteurs, les repères D0 à D10 et le port USB type C sont ceux de cette carte. Les autres kits de la même gamme, le bipède et le bras articulé, sont bâtis sur une carte ESP32 : un programme écrit pour l’un ne se téléverse pas tel quel sur l’autre, et les repères de broches y sont différents.

Peut-on ajouter des capteurs au robot ?

Oui, et les trois broches laissées libres — D3, D9 et D10 — sont là pour ça. Un capteur à ultrasons monté à l’avant fait reculer le robot devant un obstacle, un suiveur de ligne infrarouge le fait suivre une bande noire : ce sont les deux évolutions les plus fréquentes de ce kit, et elles se contentent d’un capteur et de quelques lignes dans la boucle principale.

À combiner avec

La cellule 18650 se recharge par le port USB type C du robot, mais disposer d’un chargeur avec deux batteries évite d’immobiliser le robot pendant la charge : une cellule travaille pendant que l’autre se recharge. Pour aller plus loin dans le pilotage, un driver de servomoteurs PCA9685 déporte la commande des huit moteurs sur un circuit dédié qui se pilote en I2C : les broches de la carte se libèrent pour les capteurs, et le débattement de chaque servomoteur se règle par logiciel plutôt que par la mécanique. Enfin, un multimètre numérique sert dès la première séance de réglage : relire la tension de la cellule et la sortie d’alimentation du robot, avant de chercher une cause dans le programme, fait gagner beaucoup de temps.