KITtyBot

Outils et machines nécessaires

	Imprimante 3D (générique)
	Fer à souder (générique) La conception de la maquette peut se passer de soudure

Applications et services en ligne

Arduino IDE

À propos de ce projet

Présentation

Je voulais faire un robot à quatre pattes marchant, plus dans un style "mammifère" que la normale "araignée" ou "insecte". L'inspiration vient des robots bien connus de Boston Dynamics et d'autres robots de recherche à quatre pattes. Faire un robot comme celui-ci est assez difficile car il bascule assez facilement en raison d'un centre de gravité élevé et des pieds sous le corps au lieu de s'étendre dans les coins.

L'objectif était de construire un robot bon marché, utilisant Arduino et des micro servos à faible coût. Cette solution a bien sûr ses limites. On ne peut pas s'attendre à ce que ce soit parfait, mais j'ai réussi à construire quelques robots maintenant qui peuvent exécuter le comportement de marche décrit dans ce film. Et faire de son mieux avec un très petit budget est un défi en soi et peut-être quelque chose que les gars sur des projets de recherche fortement financés n'auront jamais à affronter. :)

Il a été identifié très tôt qu'une étude de la cinématique inversée (IK) était nécessaire pour bien faire les choses. Le code a un ensemble d'équations pour calculer les angles articulaires en fonction des mouvements de pied souhaités. Ceux-ci peuvent également être utilisés dans des fonctions pour certaines tâches récurrentes comme faire un mouvement du corps (déplacer les quatre pieds dans la direction opposée) et faire un mouvement complet du pied (soulever vers le haut en déplaçant dans une direction spécifiée et le reposer à nouveau).

Le prochain défi est de faire des études de marche, c'est-à-dire de définir comment le robot doit marcher et tourner en termes de mouvements du corps et du pied. Mon robot utilise des allures statiquement stables tout le temps. Un pied à la fois est levé et mis dans une nouvelle position. Le corps repose sur les trois autres pieds et afin de ne pas basculer le centre de gravité doit rester dans le trépied que forment ces pieds. J'ai développé quatre allures standard - avant, arrière, gauche et droite. Cela utilise à son tour les fonctions de mouvement du pied et du corps pour être combinées en une séquence complète.

J'ai également conçu une fonction pour les mouvements d'asservissement synchrones. Dans certains cas, plusieurs servos effectuent des courses différentes pendant un temps défini. Cela doit être synchronisé afin d'obtenir des mouvements fluides.

Enfin, j'utilise une batterie LiPo complètement non protégée. Cela peut être risqué, le risque majeur est de le décharger trop vite ou trop profondément. Le premier danger est évité tant qu'il n'est pas accidentellement court-circuité. Une batterie R/C normale a un taux de décharge de 25 C qui dans ce cas autorise 12 A. L'UBEC l'empêchera d'être supérieur à 2 A en toutes circonstances. Le deuxième danger est évité grâce à une fonction de surveillance dans le logiciel. La tension est mesurée sur l'une des broches analogiques et si elle est inférieure à 7,0 V, le robot est mis au repos.

Et enfin, je dois souligner que les batteries doivent être chargées avec un chargeur spécialement conçu et manipulées avec les soins habituels, ne jamais laisser la charge sans surveillance. La batterie doit être détachée du robot (utilisez du velcro pour la monter) et chargée à l'intérieur d'un sac résistant au feu ou au moins à une distance de sécurité des matériaux inflammables afin qu'un incendie puisse être contenu et ne pas se propager. Rangez également vos batteries en toute sécurité.

Si vous n'êtes pas familier avec les batteries LiPo, consultez un magasin de loisirs R/C local et achetez des batteries avec un chargeur approprié et éventuellement un sac/conteneur ignifuge pour la charge et le stockage. Ces articles sont souvent pleins de signes avant-coureurs. Reprenez-les et utilisez votre bon jugement. :)

Construire le robot

Imprimez les pièces selon les fichiers fournis. Prenez le temps de regarder les photos et de comprendre comment assembler les pièces avant de commencer. Je suis scandinave mais cette instruction est loin du niveau d'une instruction IKEA ou LEGO :)

L'articulation de la hanche doit être assemblée en premier. J'ai utilisé du ruban adhésif double face de bonne qualité pour joindre les pièces. Ils peuvent également être collés mais dans le cas où il serait nécessaire de réparer une pièce cassée, ils sont impossibles à démonter, un servo cassé entraîne le remplacement du joint complet.

Placez le support de servo au bas d'un servo, en ligne avec l'axe d'actionnement. Ensuite, rejoignez un autre servo avec son axe perpendiculaire. L'image ci-dessous montre l'articulation de la hanche pour l'avant droit et l'arrière gauche. Pour les deux autres coins, des joints miroir doivent être faits.

Avant de continuer, c'est une bonne idée de s'assurer que les 12 servos sont centrés. Le meilleur moyen est d'assembler le PCB (ou la maquette, voir ci-dessous), de connecter tous les servos et de charger le code. Lorsque l'Arduino est démarré, tous les servos seront centrés (signal de commande à 90 degrés). Il sera nécessaire d'affiner les positions centrales plus tard une fois le robot assemblé.

L'étape suivante consiste à attacher la partie appelée cuisse, le "membre supérieur" d'un assemblage de jambe. Cette pièce a des évidements qui s'emboîtent avec les palonniers de servo qui sont normalement livrés avec le servo. Collez les cornes dans les évidements. Assurez-vous d'utiliser une colle qui fonctionne pour joindre le matériau imprimé en 3D et le plastique nylon dont est fait la corne. Le pistolet à colle que j'ai utilisé a bien fonctionné, mais j'ai eu un succès mitigé avec la colle CA (certaines marques fonctionnent, d'autres non).

La cuisse est jointe à l'articulation de la hanche à un angle de 60 degrés. Essayez de trouver une position qui se rapproche le plus possible de cet angle lorsque les servos ont été centrés. Fixez le klaxon sur la cannelure du servo avec la vis fournie (souvent la plus courte des trois fournies avec un servo). Vous trouverez ci-dessous deux images de la cuisse et de la hanche assemblées, le servo-cornet n'est pas inclus pour plus de clarté (ou jamais modélisé par paresse de mon côté).

La partie inférieure de la jambe doit également être assemblée. Dans ce cas, un servo est fixé à la partie jambe à l'aide de vis. Il y a des vis fournies avec le servo (souvent deux vis "à bois" plus longues).

Maintenant, les jambes peuvent être assemblées sur le corps. Il y a deux parties que j'ai appelées "pare-chocs" qui se trouvent à l'avant et à l'arrière du robot (comme les pare-chocs d'une voiture). Ils ont des évidements pour les palonniers, tout comme la partie cuisse. Collez-y des cornes. Glissez ensuite le support d'asservissement d'un haut de jambe dans le trou correspondant du corps. Lorsque cela est fait des deux côtés, l'ensemble peut être sécurisé par le pare-chocs. Laissez les jambes pointer à environ 12 degrés (un écartement de 20 mm de la jambe). Le pare-chocs est fixé à la carrosserie à l'aide de vis d'asservissement restantes (plus longues).

Enfin, les jambes inférieures du robot peuvent être attachées. Ils doivent être inclinés dans la direction opposée de la cuisse, de sorte que la pointe du pied se trouve juste sous l'articulation de la hanche de chaque assemblage de jambe.

Par cela, le robot est assemblé. Cela devrait ressembler à l'image ci-dessous. Notez que la conception du robot a légèrement changé par rapport à l'image du haut et au clip du film. Le corps a été repensé pour simplifier et rendre une conception plus robuste. Le support du servo et le klaxon pour l'articulation de la hanche ont changé de place. Assemblez donc selon les images 3D et évitez d'être confus par les photos et les extraits de film.

Bien sûr, les angles de chaque articulation ne peuvent pas être exactement aux angles requis, le nombre de cannelures sur un servo SG-90 est de 21, ce qui conduit à un angle de 17 degrés entre deux positions. Vous pouvez au mieux assembler le robot à moins de 10-20 degrés, l'erreur restante doit être ajustée en changeant la position neutre dans le code, voir plus bas dans cette instruction. Ce peut être une bonne idée de reconnecter tous les servos et d'allumer l'Arduino et de vérifier les positions neutres et, si nécessaire, de faire quelques ajustements mécaniques (déplacer une articulation d'une cannelure ou deux). On a tendance à tourner accidentellement les servos en travaillant avec eux.

Connexion de l'électronique

Il y a deux options, avoir tout sur une planche à pain ou produire un PCB avec le fichier Fritzing fourni. Vous pourriez rencontrer des problèmes de tension dans la maquette si vous ne faites pas attention lorsque vous connectez toutes les lignes d'alimentation et de masse aux servos. Dans les cas extrêmes, un servo peut consommer 600 mA et de mauvaises connexions entraînent un comportement erratique. Le PCB a de très larges traces de cuivre pour les lignes électriques, donc si vous soudez correctement, cela fonctionnera bien.

Il n'y a pas d'interrupteur d'alimentation dans ma conception. Le robot s'allume et s'éteint simplement en connectant la batterie. Si vous souhaitez en ajouter un, ce devrait être après le connecteur de la batterie, en coupant l'alimentation 7,4 V à la fois de l'Arduino et de l'UBEC.

Version planche à pain

Il est possible d'avoir le Pro Mini, les connecteurs pour les servos et la plupart des autres composants électroniques sur une planche à pain demi-taille. Je dessine les schémas dans l'image ci-dessous. Assurez-vous d'utiliser des câbles de démarrage courts, en particulier pour les connexions d'alimentation 5 V et de terre aux servos. Les connecteurs d'asservissement sont simplement des embases mâles extra longues qui sont coupées en morceaux de trois et enfoncées dans la planche à pain.

Ce qui n'est pas montré sur la photo, c'est la batterie et l'UBEC. Il peut y avoir des soudures pour réparer cela afin de fixer un connecteur à la batterie. À partir du connecteur, deux fils de liaison doivent être connectés au "rail d'alimentation" inférieur de la planche à pain afin d'alimenter le Pro Mini (connecté à RAW et GND). Connectez également deux résistances de l'alimentation 7,4 V à la broche A0. 2.2k va du côté positif et 1k du sol. Cela divisera la tension, qui est supérieure à 8 V sur une batterie pleine, à une valeur inférieure à 5 V qui peut être mesurée par la broche analogique.

Le côté sortie de l'UBEC a un connecteur servo. Il est assez pratique d'ajouter un en-tête à deux mâles sur le "rail d'alimentation" supérieur. Placez-le quelque part au milieu comme sur l'image pour vous assurer que la distribution de puissance aux servos est aussi équilibrée que possible.

Le récepteur IR doit être connecté à A1 et avoir une alimentation 5V. Les broches du récepteur sont suffisamment longues pour être insérées dans des trous directement sur la planche à pain.

Il y a un schéma ci-dessous et une image de l'apparence de la maquette finie. Notez que l'image montre une ancienne version du robot avec différents brochages et connexions. Cela donne toujours une idée sur la façon de connecter les câbles de démarrage et les connecteurs de servo.

La planche à pain est fixée au corps avec son dos autocollant. Orientez-le de manière à ce que le coin avec les servos connectés aux broches D3, D4 et D5 (en haut à droite sur le schéma) se trouve sur le coin avant/gauche du robot et assurez-vous que la carte est centrée sur le corps (centre correct de la gravité est vitale).

Version PCB

J'ai ajouté un fichier Fritzing ci-dessous. Celui-ci peut être utilisé pour produire un PCB, soit en commandant auprès du service disponible chez Fritzing, soit en exportant des fichiers pour la fabrication de PCB. J'ai fait une série de photos pour montrer le montage ci-dessous. Le PCB est fait sur mesure pour ce robot avec des connecteurs pour tous les servos, IR et mesure de tension. Mais il y a aussi des connecteurs qui sortent des broches restantes. Ceux-ci peuvent être utilisés pour connecter d'autres équipements si vous souhaitez étendre le robot à l'avenir.

Il y a de petits "patins" sur le corps qui s'adaptent aux coins du PCB. Ici aussi, le coin avec le connecteur D3 à D5 doit être à l'avant/à gauche. Il y a des trous de montage sur le PCB mais je n'ai utilisé qu'un morceau de ruban adhésif double face sur le corps pour le fixer. Il restera en place.

Batterie

La batterie est fixée sur le dessous avec du velcro. Il y a une surface plane dédiée à cela sur le corps. Une batterie LiPo 7.4V/500mAh a normalement un facteur de forme d'environ 55x30x10 mm (plus ou moins quelques mm) et elle s'intègre assez bien dans cet endroit.

Enfin, le robot peut être « retouché » en attachant les câbles des servos dans de jolis faisceaux afin qu'ils ne trébuchent pas en marchant. Cela donne également au robot une belle apparence d'être en réalité une créature à quatre pattes qui se promène et non un tas de câbles d'asservissement. :)

Finalisation

Avant d'utiliser les robots, les positions centrales doivent être affinées. Cela se fait en éditant le tableau servodeg0 dans le code :

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

Les valeurs sont dans l'ordre alfa, bêta gamma et avant/gauche, arrière/gauche, avant/droite, arrière/droite. Ainsi, bêta à l'avant à droite est la huitième position dans le tableau ou servodeg0[7] (la numérotation du tableau commence par 0).

Il existe également un tableau appelé servodir qui définit le sens de rotation des servos.

const int rép servo[12] ={ +1, +1, -1, -1, -1, +1, -1, -1, -1, +1, +1, +1}; // Sens de rotation (le positif correspond au servo dans le sens inverse des aiguilles d'une montre)  

Les servos que j'ai utilisés se déplacent de 0 à 180 degrés dans le sens inverse des aiguilles d'une montre. J'ai lu quelque part qu'il y a des servos qui vont dans l'autre sens. Dans ce cas, les signes du servodir du tableau doivent être modifiés en permanence.

Démarrez l'Arduino et vérifiez les angles sur tous les servos. Prenez des mesures et regardez, tout a l'air droit et symétrique. Les distances et les angles doivent être conformes à l'image ci-dessous.

Il est difficile d'être à un millimètre près sur chaque mesure, être à moins d'un cm est raisonnable. Voyez quels changements sont nécessaires et ajoutez/soustrayez-les à la valeur dans le tableau servodeg0. Cela nécessitera certainement quelques itérations avant que tout soit correct. Vous finirez avec un tableau servodeg0 qui ressemble à ceci (un vrai morceau de code d'un de mes robots). Et le plus important, vous devriez au final avoir un robot qui repose sur ses quatre pieds et se tient droit.

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

Maintenant tout est fini. Profitez-en !

Juste peut-être quelques conseils sur le chemin.

Les servos pourraient avoir besoin d'être recalibrés après un certain temps. La position centrale peut dériver avec le temps. Vérifiez simplement si tout est aligné de temps en temps.

Si vous avez tout fait correctement et que vous avez toujours un robot qui va basculer, vérifiez le centre de gravité. La batterie peut être déplacée pour équilibrer cela, une bonne chose avec l'utilisation de velcro.

Et encore une fois. Traitez vos batteries LiPo avec soin.

Autres améliorations

En soumettant mon robot ici, j'invite également les gens à affiner le design, soit en ajoutant plus de fonctions, soit en créant une disposition légèrement différente (plus grande, plus petite, plus cool). Le code doit pouvoir être réutilisé sur un robot d'une disposition ou d'une taille légèrement différente. Le croquis ci-dessous montre quelles sont les différentes constantes dans le code. Toutes les fonctions IK et de mouvement devraient toujours fonctionner si un robot avec des mesures différentes est fabriqué. Il montre également que les coordonnées sont définies, x pointe vers l'avant.

Et bien sûr, il serait intéressant que les gens ajoutent des fonctions au robot. Il y a plusieurs boutons sur la télécommande qui pourraient avoir des fonctions (pourquoi ne pas danser ou faire une autre séquence de mouvements si un bouton est enfoncé).

Personnellement, j'expérimente avec l'entrée analogique. J'ai également travaillé avec une démarche "tournant en marchant" pour pouvoir diriger le robot dans une certaine mesure, ou pour corriger des déviations de cap à l'aide d'un gyroscope ou d'une boussole. Et j'ai aussi ajouté un capteur à ultrasons et un comportement autonome (éviter les obstacles). Mon projet actuel est de combiner le contrôle analogique avec l'autonomie et de tout contrôler depuis un smartphone. Cela m'a forcé à apprendre beaucoup de nouvelles choses (Blynk, ESP6822, communication série entre appareils, etc.) et j'espère pouvoir lancer une version raffinée du robot (ou peut-être que quelqu'un avec de meilleures compétences m'a battu sur cette chose) :)

Code

• Le code pour KITtyBot2

Le code pour KITtyBot2Arduino

/* Une version contrôlée par IR du KITtyBot 2. Il utilise Arduino Pro Mini et la carte PCB conçue par moi (Fritzing sketch Kittybotmini.fzz) Il est basé sur les robots précédents KITtyBot et KITtyBot mini utilisant une télécommande IR pour contrôler le robot Il utilise une télécommande NEC (Adafruit) et les bibliothèques IRLib2, voir https://github.com/cyborg5/IRLib2. Téléchargez les bibliothèques IRLib2 à partir du référentiel et installez-les conformément aux instructions. Les dimensions générales sont similaires au KITtyBot d'origine mais il y a un décalage entre les axes gamma et alfa de 12 mm (les servos montés les uns sur les autres) étant donné le comportement le plus stable. Créé par Staffan Ek 2017*/#include #include #include  // D'abord inclure la base de décodage#include  // Inclure uniquement le protocole que vous êtes using#define MY_PROTOCOL NEC //Définit le contrôle IR (NEC)long Previous;IRrecv My_Receiver(A1);//Receive on pin A0IRdecodeNEC My_Decoder;const int servonum =12; // La quantité de servosServo servo[servonum]; // Créer un servo objectconst float servodeg0[12] ={90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90, 90} ; // Positions neutres pour les servos ajustées à partir de 90 degrés nominaux ( un étalonnage est nécessaire pour ajuster ces valeurs)float servodegnew[servonum] ; // La position souhaitée du servo en degrésfloat servodegold[servonum]; // L'ancienne (ou actuelle) position du servo // Mettre à jour les valeurs ci-dessous vers le KITtyBot miniconst int servodir[12] ={ +1, +1, -1, -1, -1, +1, -1, -1, -1, +1, +1, +1} ; // Sens de rotation (le positif est le servo dans le sens inverse des aiguilles d'une montre)const float pi =3.1416;const float alfa0 =pi / 6; // La position neutre d'alfa (30 deg)const float beta0 =pi / 3; // La position neutre de beta (60 deg)const float jointlength =50; // La longueur d'une partie de jambe (les deux ont la même longueur) const float width =120; // La largeur (distance entre les pieds dans la direction y, avec toeout0 ajouté) const float leng =120; // La longueur (distance entre les pieds dans la direction x) const float distag =12; // Distance entre les axes alfa et gammaconst float toeout0 =20; // La distance extérieure des pieds depuis le centre du servo gamma (la distance à laquelle le pied est pointé vers l'extérieur) const float leglength0 =2 * jointlength * cos(alfa0);const float gamma0 =asin(toeout0 / (leglength0 + distag)); // La position neutre de gamma (en raison d'un pincement de 20 mm et d'un distag de 12 mm)const float bodyradius =sqrt(pow((width/2), 2) + pow((long/2, 2)); // La longueur de la diagonale (distance du centre au coin du pied)const float phi0 =atan(width / leng); // L'angle du rayon du corps par rapport à l'axe x (pointant vers l'avant) axisconst float height0 =sqrt(pow(leglength0 + distag, 2) - pow(toeout0, 2)); // La hauteur normale du robot (si des angles ou des distances sont modifiés, cela doit être mis à jour) 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)) } ;// Valeurs de départ de longueur de jambe pas de temps long non signé =500 ; // Temps pris par chaque séquence (lors de l'utilisation de servomove())int steplength =40; //La longueur d'un pas dans la direction x pendant la marche (fluage avant et arrière)float phi =20; // angle de rotation pendant le virage (en degrés, pas en radians !) // Variable pour le mouvement flottant footpos[12] ; // Positions des pieds, ordre LeftFrontxyz, LeftRearxyz, RightFrontxyz, RightRearxyzfloat stepturn[12] ={0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0} ; // Mouvement du pied en cas de virage// Les positions des pieds sont calibrées avec leurs positions de départ respectivesconst float jointangle0[12] ={alfa0, beta0, 0, alfa0, beta0, 0, alfa0, beta0, 0, alfa0, beta0, 0};flottant jointangle[12]; //En utilisant un vecteur pour les angles, commandez LeftFrontAlfaBetaGamma etcconst int voltagepin =A0; // La broche assignée pour la tension meassureint lowvolt =0; // Une variable qui arrête le robot si la tension va <7.0 Vint mode =0; // Le mode de marche ordonné actuel ; forward, reverse, left, rightvoid setup() { Serial.begin(9600); Serial.println("KITtyBot mini"); //Ces lignes sont juste pour vérifier la configuration. Peut être supprimé. 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("Hauteur0:"); Serial.println(hauteur0) ; servo[0].attach(3) ; servo[1].attach(4) ; servo[2].attach(5); servo[3].attache(6) ; servo[4].attach (7) ; servo[5].attach(8) ; servo[6].attach(2); servo[7].attache (A3) ; servo[8].attache(12); servo[9].attache(11); servo[10].attache(10) ; servo[11].attache(9) ; for (int i =0; i  2 * jointlength) lresult =2 * jointlength; // Si leglength est plus élevé que possible, certaines fonctions suivantes deviennent instables return lresult;}float legright(float dx, float dz, float gamma) { float lresult =sqrt(pow(leglength0 - (dz / cos(gamma0 - gamma)), 2) + puissance(dx, 2)); if (lresult> 2 * jointlength) lresult =2 * jointlength; // Si la longueur de jambe est plus élevée que possible, certaines fonctions suivantes deviennent instables return lresult;}// Beta, le "joint du genou" float beta (jambe flottante) { float bresult =2 * acos(leg / (2 * jointlength)); return bresult;}// Alfa, L'autre hanche servofloat alfafront(float dx, float beta, float leg) { float aresult =(beta / 2) - asin(dx / leg); return aresult;}float alfarear(float dx, float beta, float leg) { float aresult =(beta / 2) + asin(dx / leg); return aresult;}// Donner les positions des pieds en fonction d'un angle de rotation f (en degrés). Stepturn est utilisé pour faire des footpos valuesvoid turnpos(float f) { stepturn[0] =bodyradius * cos(phi0 + (f * pi / 180)) - leng / 2; stepturn[1] =bodyradius * sin(phi0 + (f * pi / 180)) - largeur / 2; stepturn[3] =bodyradius * cos(pi - phi0 + (f * pi / 180)) + long / 2; stepturn[4] =bodyradius * sin(pi - phi0 + (f * pi / 180)) - width / 2; stepturn[6] =bodyradius * cos(2 * pi - phi0 + (f * pi / 180)) - long / 2; stepturn[7] =rayon du corps * sin(2 * pi - phi0 + (f * pi / 180)) + largeur / 2 ; stepturn[9] =bodyradius * cos(pi + phi0 + (f * pi / 180)) + long / 2; stepturn[10] =bodyradius * sin(pi + phi0 + (f * pi / 180)) + width / 2;}// Calcule les positions des servos (en degrés) en fonction des angles des articulations dans la fonction au-dessus du vide servopos() { for ( int i =0; i <12; i++) { servodegnew[i] =servodeg0[i] + servodir[i] * (jointangle[i] - jointangle0[i]) * 180 / pi; }}// L'algorithme d'asservissement pour des mouvements contrôlés et synchronisés. Tous les servos doivent atteindre leur position finale à la fin d'un timestepvoid servomove() { int servotimeold[servonum]; // Variable locale pour l'heure de la dernière position du servo int servotimenew[servonum]; // Variable locale pour l'heure actuelle lorsque le servo i positionné int SERVOPULSE[servonum]; // Variable locale à écrire dans le servodriver float servodeg[servonum]; // Variable locale pour la position actuelle du servo float servodegspeed[servonum]; // Variable locale pour la vitesse d'asservissement souhaitée par milliseconde non signée long starttime =millis(); // Horodatage du début de l'algorithme non signé long timenow =starttime; // Réinitialisation du temps maintenant pour (int i =0; i  

Pièces et boîtiers personnalisés

Schémas