KITtyBot : kit robot intelligent DIY avec Arduino Pro Mini, servos, télécommande IR et alimentation

Composants et fournitures

Arduino Pro Mini 328 - 5V/16MHz (SparkFun)	×1
Servomoteurs (Tower Pro MG996R) — SG-90 ou servo 9g même format	×12
Convertisseur abaisseur UBEC 5V @ 3A (Adafruit)	×1
Télécommande mini (Adafruit) — toute télécommande compatible bibliothèque IRLib	×1
Récepteur IR TSOP38238 (Adafruit)	×1
Résistance 1 kΩ	×1
Résistance 2,2 kΩ	×1
Batterie LiPo 7,4 V / 500 mAh — capacité type modélisme RC	×1

Outils nécessaires

• Imprimante 3D
• Fer à souder (le montage sur breadboard peut s'en passer)

Applications et services en ligne

• Arduino IDE

À propos du projet

Introduction

Je voulais construire un robot quadrupède marcheur, style « mammifère » plutôt que « araignée » ou « insecte ». L'inspiration vient des robots bien connus de Boston Dynamics et autres robots de recherche à quatre pattes. C'est un défi : le centre de gravité haut et les pieds sous le corps (pas écartés aux coins) le font basculer facilement.

Objectif : robot peu coûteux, Arduino + microservos bon marché. Évidemment, des limites existent : ne pas s'attendre à la perfection, mais j'ai réussi à en construire plusieurs qui marchent comme montré dans la vidéo. Faire le maximum avec un minuscule budget est un défi en soi, que les projets de recherche bien financés ne connaissent pas ! :)

L'étude de la cinématique inverse (IK) s'est imposée. Le code contient des équations pour calculer les angles d'articulation selon les mouvements de pieds souhaités. Ces équations servent à des fonctions récurrentes : mouvement du corps (déplacer les 4 pieds en sens inverse) et mouvement complet d'un pied (lever, déplacer dans une direction, reposer).

Vient l'étude des gaits (modes de marche) : définir comment le robot marche et tourne en termes de mouvements corps/pieds. Mon robot utilise des gaits statiquement stables : un pied à la fois levé et repositionné. Le corps repose sur les 3 autres pieds ; pour ne pas basculer, le centre de gravité doit rester dans le tripode formé par ces 3 pieds. J'ai développé 4 gaits standards : avant, arrière, gauche, droite, combinant les fonctions de mouvement pied et corps.

J'ai aussi conçu une fonction de mouvements synchrones des servos : plusieurs servos font des courses différentes sur un temps donné, doivent être synchronisés pour la fluidité.

Enfin, j'utilise une batterie LiPo non protégée. Risques : décharge trop rapide ou trop profonde. Le premier est évité tant qu'il n'y a pas de court-circuit (batterie RC typique : 25C → 12 A max ; l'UBEC limite à 2 A). Le second est géré par une fonction de surveillance logicielle : tension mesurée sur broche analogique, si < 7,0 V → robot mis au repos.

Important : Charger les LiPo avec un chargeur dédié, ne jamais laisser charger sans surveillance. Détacher la batterie du robot (fixation velcro) et charger dans un sac ignifugé ou loin de tout inflammable. Stocker les batteries en sécurité. Si vous ne connaissez pas les LiPo, consultez un magasin de modélisme RC et achetez batterie + chargeur + sac ignifugé. Lisez les avertissements et usez de votre jugement ! :)

Construction du robot

Imprimer les pièces selon les fichiers fournis. Prendre le temps d'étudier les images pour comprendre l'assemblage avant de commencer. Je suis scandinave mais ces instructions sont loin du niveau IKEA/LEGO ! :)

Articulation de hanche : assembler en premier. J'ai utilisé du ruban double face de qualité pour joindre les pièces. Le collage est possible mais rend impossible la réparation (un servo cassé = remplacement de toute l'articulation).

Mettre le support de servo sous un servo, aligné avec l'axe d'actionnement. En joindre un second avec son axe perpendiculaire. L'image montre l'articulation hanche pour avant-droit et arrière-gauche. Pour les deux autres coins, faire des articulations miroir.

Avant de continuer : centrer les 12 servos. Meilleur moyen : assembler le PCB (ou breadboard), connecter tous les servos, charger le code. Au démarrage, l'Arduino centre tous les servos (signal 90°). Un affinage sera nécessaire après assemblage complet.

Cuisse (thigh) : partie « membre supérieur » de la patte. Elle a des logements pour les cames de servo (fournies avec). Coller les cames dans les logements. Utiliser une colle compatible impression 3D + nylon de la came. Mon pistolet à colle a fonctionné, la cyanoacrylate donne des résultats variables selon les marques.

La cuisse se joint à l'articulation hanche à 60°. Trouver la position la plus proche de cet angle avec servos centrés. Fixer la came sur l'axe du servo avec la vis fournie (souvent la plus courte des trois).

Partie inférieure de la patte : un servo fixé sur la pièce patte avec vis (vis « bois » plus longues fournies avec le servo).

Assemblage des pattes sur le corps : deux pièces « bumper » (pare-chocs) à l'avant et l'arrière. Elles ont des logements pour cames comme la cuisse. Coller les cames. Glisser le support de servo d'une cuisse dans le trou correspondant du corps. Faire les deux côtés, puis fixer le bumper. Laisser les pattes pointées vers l'extérieur à ~12° (écartement 20 mm au niveau du pied). Fixer le bumper au corps avec les vis de servo restantes (les plus longues).

Enfin, fixer les pattes inférieures. Elles doivent être orientées en sens inverse de la cuisse, pour que l'extrémité du pied se trouve juste sous l'articulation hanche de chaque assemblage patte.

Le robot est assemblé. Doit ressembler à l'image ci-dessous. Note : le design a légèrement changé par rapport à l'image du haut et à la vidéo. Le corps a été redessiné pour simplifier et robustifier. Le support de servo et la came de l'articulation hanche ont échangé leur place. Suivez les images 3D et évitez la confusion avec les photos/vidéos.

Les angles ne peuvent pas être exacts : un servo SG-90 a 21 crans → 17° entre positions. On assemble au mieux dans les 10-20°, l'erreur restante se corrige en changeant la position neutre dans le code (voir plus bas). Reconnecter tous les servos, démarrer l'Arduino, vérifier les positions neutres et ajuster mécaniquement si besoin (décaler d'un ou deux crans). On tourne souvent les servos sans faire exprès en les manipulant.

Connexion de l'électronique

Deux options : tout sur une demi-breadboard, ou PCB avec le fichier Fritzing fourni. Sur breadboard, attention aux connexions d'alimentation/terre des servos : un servo peut consommer 600 mA, de mauvais contacts causent un comportement erratique. Le PCB a de larges pistes de cuivre pour l'alimentation, un bon soudage suffit.

Pas d'interrupteur d'alimentation dans mon design : le robot s'allume/éteint en connectant/déconnectant la batterie. Si vous en voulez un, le placer après le connecteur batterie, coupant le 7,4 V vers Arduino et UBEC.

Version breadboard

Possible de mettre Pro Mini, connecteurs servos et électronique sur une demi-breadboard. Schéma ci-dessous. Utiliser des fils de liaison courts, surtout pour l'alimentation 5V et masse des servos. Connecteurs servos = longs connecteurs mâles coupés par groupes de 3 et pressés dans la breadboard.

Non montré sur l'image : batterie et UBEC. Peut nécessiter un peu de soudure pour adapter un connecteur batterie. Du connecteur, deux fils vers le rail d'alimentation « bas » de la breadboard pour alimenter le Pro Mini (broches RAW et GND). Aussi connecter deux résistances du 7,4 V vers la broche A0 : 2,2 kΩ du côté +, 1 kΩ vers la masse. Cela divise la tension ( > 8 V batterie pleine) à une valeur < 5 V mesurable par la broche analogique.

La sortie de l'UBEC a un connecteur servo. Pratique d'ajouter deux connecteurs mâles sur le rail d'alimentation « haut » quelque part au milieu pour équilibrer la distribution d'énergie vers les servos.

Le récepteur IR sur A1 avec alimentation 5V. Ses broches sont assez longues pour s'insérer directement dans la breadboard.

Schéma et photo d'une breadboard finie ci-dessous. Note : la photo montre une version plus ancienne avec brochage/connexions différents, mais donne une idée du câblage.

Version PCB

Fichier Fritzing ci-dessous pour fabrication PCB (service Fritzing ou export pour fabrication externe). PCB sur mesure pour ce robot : connecteurs pour tous les servos, IR, mesure tension. Aussi des connecteurs pour les broches restantes, pour extensions futures.

Petits « plots » sur le corps pour les coins du PCB. Le coin avec connecteur D3-D5 doit être à l'avant/gauche. Trous de fixation sur le PCB mais j'ai utilisé juste du ruban double face sur le corps. Ça tient.

Batterie

Fixée sous le corps par velcro. Surface plane dédiée. Une LiPo 7,4V/500mAh fait ~55×30×10 mm et s'y loge bien.

Enfin, « finition » : regrouper les fils des servos en faisceaux propres pour ne pas trébucher dedans en marchant. Donne aussi un aspect soigné de créature quadrupède, pas un tas de fils ! :)

Finalisation

Avant utilisation, affiner les positions centrales en modifiant le tableau servodeg0 dans le code :

const float servodeg0[12] = {90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90};

Ordre : alfa, bêta, gamma pour avant-gauche, arrière-gauche, avant-droit, arrière-droit. Ex: bêta avant-droit = 8e position = servodeg0[7] (indexation à 0).

Tableau servodir définissant le sens de rotation :

const int servodir[12] = { +1, +1, -1, -1, -1, +1, -1, -1, -1, +1, +1, +1 };
// Sens de rotation (positif = servo anti-horaire)

Mes servos vont de 0 à 180° en sens anti-horaire. S'ils vont dans l'autre sens, inverser tous les signes de servodir.

Démarrer l'Arduino et vérifier les angles de tous les servos. Mesurer, vérifier que tout est droit et symétrique. Distances et angles selon l'image ci-dessous.

Difficile d'être au millimètre près, ±1 cm est acceptable. Voir les corrections nécessaires et les ajouter/soustraire aux valeurs du tableau servodeg0. Plusieurs itérations nécessaires. Résultat typique (extrait de code d'un de mes robots) :

const float servodeg0[12] = {80, 95, 100, 100, 110, 90, 100, 115, 100, 80, 80, 100};

Au final : robot reposant sur ses 4 pieds, bien droit.

Quelques conseils :

• Les servos peuvent nécessiter un recalibrage avec le temps (dérive position centrale). Vérifier l'alignement régulièrement.
• Si le robot bascule malgré tout, vérifier le centre de gravité. La batterie (velcro) peut être déplacée pour l'équilibrer.
• Encore une fois : traitez vos batteries LiPo avec soin !

Améliorations futures

En publiant ce robot, j'invite à affiner le design : ajouter des fonctions ou changer la disposition (plus grand, plus petit, plus stylé). Le code devrait être réutilisable sur un robot de gabarit/légèrement différent. Le schéma ci-dessous montre les constantes du code. Toutes les fonctions IK et de mouvement devraient fonctionner si on change les dimensions. Montre aussi la définition des coordonnées : x pointe vers l'avant.

Intéressant aussi d'ajouter des fonctions : plusieurs boutons sur la télécommande inutilisés (pourquoi pas danse ou autres séquences).

Personnellement, j'expérimente le contrôle analogique. J'ai travaillé sur un gait « virage en marchant » pour piloter le robot ou corriger les déviations via gyroscope/boussole. J'ai aussi ajouté un capteur ultrason et comportement autonome (évitement d'obstacles). Mon projet actuel : combiner contrôle analogique + autonomie, tout piloté depuis un smartphone. Cela m'a forcé à apprendre plein de nouvelles choses (Blynk, ESP8266, communication série entre appareils...) et j'espère lancer une version améliorée (ou que quelqu'un de plus compétent me devance !) :)

Code

Code pour KITtyBot2 (Arduino)

Téléverser sur l'Arduino Mini

/* Version IR du KITtyBot 2. Utilise Arduino Pro Mini et PCB conçu par moi (Fritzing Kittybotmini.fzz)
   Basé sur les précédents KITtyBot et KITtyBot mini avec télécommande IR
   Utilise télécommande NEC (Adafruit) et bibliothèques IRLib2, voir https://github.com/cyborg5/IRLib2
   Télécharger et installer IRLib2 selon instructions.
   Dimensions générales similaires au KITtyBot original mais décalage 12 mm entre axes gamma et alfa
   (servos montés l'un sur l'autre). J'ai continûment affiné les gaits marche/virage, ce qui donne
   le comportement le plus stable à ce jour.
   Créé par Staffan Ek 2017 */

#include <IRLibRecv.h>
#include <Servo.h>
#include <IRLibDecodeBase.h>
#include <IRLib_P01_NEC.h>

#define MY_PROTOCOL NEC
long Previous;
IRrecv My_Receiver(A1);
IRdecodeNEC My_Decoder;

const int servonum = 12;
Servo servo[servonum];

const float servodeg0[12] = {90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90};
float servodegnew[servonum];
float servodegold[servonum];

const int servodir[12] = { +1, +1, -1, -1, -1, +1, -1, -1, -1, +1, +1, +1 };
const float pi = 3.1416;
const float alfa0 = pi / 6;
const float beta0 = pi / 3;
const float jointlength = 50;
const float width = 120;
const float leng = 120;
const float distag = 12;
const float toeout0 = 20;
const float leglength0 = 2 * jointlength * cos(alfa0);
const float gamma0 = asin(toeout0 / (leglength0 + distag));
const float bodyradius = sqrt(pow((width / 2), 2) + pow((leng / 2), 2));
const float phi0 = atan(width / leng);
const float height0 = sqrt(pow(leglength0 + distag, 2) - pow(toeout0, 2));

float leglength[4] = {sqrt(pow(height0, 2) + pow(toeout0, 2)), sqrt(pow(height0, 2) + pow(toeout0, 2)), sqrt(pow(height0, 2) + pow(toeout0, 2)), sqrt(pow(height0, 2) + pow(toeout0, 2))};

unsigned long timestep = 500;
int steplength = 40;
float phi = 20;

float footpos[12];
float stepturn[12] = {0};
const float jointangle0[12] = {alfa0, beta0, 0, alfa0, beta0, 0, alfa0, beta0, 0, alfa0, beta0, 0};
float jointangle[12];

const int voltagepin = A0;
int lowvolt = 0;
int mode = 0;

void setup() {
  Serial.begin(9600);
  Serial.println("KITtyBot mini");
  Serial.print("Gamma0: "); Serial.println(gamma0);
  Serial.print("Leglength0: "); Serial.println(leglength0);
  Serial.print("Bodyradius: "); Serial.println(bodyradius);
  Serial.print("Phi0: "); Serial.println(phi0);
  Serial.print("Height0: "); Serial.println(height0);

  servo[0].attach(3); servo[1].attach(4); servo[2].attach(5);
  servo[3].attach(6); servo[4].attach(7); servo[5].attach(8);
  servo[6].attach(2); servo[7].attach(A3); servo[8].attach(12);
  servo[9].attach(11); servo[10].attach(10); servo[11].attach(9);

  for (int i = 0; i < servonum; i++) {
    servodegnew[i] = servodeg0[i];
    servodegold[i] = servodegnew[i];
    servo[i].write(servodegnew[i]);
  }
  delay(5000);
  My_Receiver.enableIRIn();
}

void loop() {
  voltmeasure();
  while (lowvolt == 0) {
    bodyxyz(0, 0, 0);
    servomove();
    mode = 0;
    IRread();
    Serial.print("Mode: "); Serial.println(mode);
    switch (mode) {
      case 1: forwardcreep(); break;
      case 2: reversecreep(); break;
      case 3: leftturn(); break;
      case 4: rightturn(); break;
    }
    voltmeasure();
    delay(500);
  }
  if (lowvolt == 1) {
    bodyxyz(0, 0, -30);
    servomove();
  }
}

// Fonctions de cinématique inverse, gaits, contrôle servos synchronisés, lecture IR, mesure tension...
// (Code complet disponible sur le dépôt GitHub du projet)

Pièces personnalisées et boîtiers

• Corps du robot : porte le PCB et la batterie
• Bumpers (pare-chocs) : un à chaque extrémité du corps (2 nécessaires)
• Support hanche : 4 à imprimer
• Cuisse (membre supérieur) : 4 à imprimer
• Partie inférieure (pied) : 4 à imprimer
• Assemblage complet : non pour impression

Schémas

Fichier Fritzing pour production PCB. Utilisable pour commander via Fritzing ou exporter vers un format de fabrication adapté.

kittybotmini_XKZYltyQVJ.fzz