Calibrage de mes servos

Outils et machines nécessaires

Imprimante 3D (générique)

Applications et services en ligne

	Arduino IDE
	Autodesk Fusion 360

À propos de ce projet

Dans un article précédent sur Hackster, j'ai expliqué comment j'avais créé une plate-forme pour comparer la rotation des différents servos du même lot et montré que l'envoi des mêmes signaux PWM à différents servos entraînait des différences significatives - l'image ci-dessous montre des servos qui ont tous commencé dans leur position la plus dans le sens inverse des aiguilles d'une montre et ont reçu le même signal PWM - ils ont tous un comportement légèrement différent.

Pourquoi ne pas utiliser les bibliothèques d'asservissement existantes pour l'Arduino ?

J'utilise le pilote de servomoteur Adafruit PWM pour piloter un tas de servos, ce qui me permet d'envoyer un signal PWM différent à chaque servo. Je pourrais utiliser la bibliothèque Servo qui est intégrée à mon installation Arduino - mais j'ai plusieurs raisons de ne pas le faire :

• Avec le pilote de servomoteur Adafruit PWM, je peux contrôler mes servos en utilisant seulement deux broches sur I2C, plutôt que de dédier une broche sur mon Arduino à chaque servo.

• J'ai parfois trouvé avec la bibliothèque Arduino Servo que lorsque je me connecte à un servo et envoie un signal pour qu'il tourne à la position zéro degré, il tourne jusqu'à la limite de course et broie les engrenages à l'intérieur du servo.

Bien sûr, les servos 9g que j'utilise sont bon marché et ne sont pas conçus pour la précision - mais je pense que je peux en tirer plus de valeur. Je souhaite les utiliser pour un robot marcheur et j'ai besoin que leur comportement soit un peu plus précis et prévisible.

Comment contrôler plus précisément mes servos de loisir ?

Confirmer que mes servos se comportent tous légèrement différemment m'a donné envie de construire un appareil qui me permettrait de calibrer un servo - de quelles valeurs PWM ai-je besoin pour envoyer un servo pour passer à une position de 0 degré ? Ou le point central à 90 degrés ? Comment éviter d'envoyer une valeur PWM qui enclenche le servo dans une position extrême avec beaucoup de craquements et de grincements d'engrenages ?

J'ai décidé de combiner quelques concepts simples.

• Alignez mon servo avec le centre d'un simple rapporteur, de sorte que l'essuie-glace du servo tourne, je puisse mesurer sa position.

• Connectez un potentiomètre à une entrée analogique de l'Arduino, afin que je puisse contrôler la position de l'essuie-glace du servo en ajustant la valeur PWM pendant que j'ajuste la position de l'arbre du potentiomètre.

Pour cette version, j'étais heureux d'utiliser le moniteur série de mon IDE Arduino pour me dire la valeur du signal PWM, que je peux enregistrer manuellement.

J'ai utilisé Autodesk 123D pour concevoir une plate-forme simple qui contiendrait le potentiomètre, le rapporteur, un seul servo, mon Arduino et le servomoteur Adafruit PWM ainsi qu'une alimentation.

Je souhaite continuer à utiliser le servodriver Adafruit PWM pour mon étalonnage, car c'est ce que je vais probablement utiliser dans mon projet final. Si je devais contrôler le servo directement à partir d'une broche sur l'Arduino, je le répliquerais dans l'appareil et calibrerais le servo par rapport au PWM de l'Arduino.

Construire l'appareil

J'ai imprimé chacune des pièces et les ai attachées ensemble à l'aide des boulons et des rondelles M3.

Les trous de montage dans la conception de mon appareil sont ajustés pour s'adapter à mes composants - différents composants peuvent avoir des variations dans les diamètres et les positions des trous.

Pour l'électronique, j'ai attaché la broche centrale du potentiomètre à la broche A0 de l'Arduino, et les autres broches à 0v et 5v sur l'Arduino. J'ai connecté le pilote de servomoteur PWM à l'Arduino, puis j'ai connecté le convertisseur abaisseur DC-DC (j'avais réglé pour convertir l'entrée d'alimentation 9v en une sortie 5v). J'ai connecté le servo 9g au premier emplacement sur le blindage du pilote du servomoteur, puis j'ai téléchargé mon croquis sur l'Arduino.

Le résultat final est montré dans les photographies ci-dessous. En tournant le bouton en haut à gauche de l'appareil, je peux contrôler la position du servo, et en utilisant le moniteur série dans l'IDE Arduino, je peux lire le signal PWM envoyé au servomoteur pour n'importe quel angle donné.

Alors que me dit l'appareil ?

Pour mon servomoteur, je l'ai tourné jusqu'à sa limite maximale dans le sens des aiguilles d'une montre et j'ai placé l'essuie-glace sur le servomoteur de manière à ce qu'il soit positionné juste au-delà de la marque de 180 degrés sur le rapporteur de mon appareil d'étalonnage.

J'ai connecté l'alimentation à l'appareil, puis j'ai tourné le bouton du potentiomètre jusqu'à ce que l'aiguille du servo soit alignée avec la marque 0 degré sur le rapporteur, et j'ai noté la valeur PWM écrite sur la sortie série de mon Arduino IDE. Ensuite, j'ai tourné le potentiomètre jusqu'à ce que l'aiguille du servo pointe à 10 degrés et j'ai à nouveau noté la valeur PWM. J'ai continué ce processus tous les 10 degrés jusqu'à ce que j'atteigne 180 degrés, et j'ai partagé les résultats dans le tableau ci-dessous.

J'ai créé un graphique des résultats (illustré ci-dessous), et comme vous vous en doutez, il est évident qu'il existe une relation fortement linéaire entre le PWM et l'angle d'asservissement.

Maintenant, j'ai des valeurs PWM et d'angle qui sont caractéristiques de ce servo particulier - d'autres servos peuvent avoir des caractéristiques similaires, mais ils ne seront pas identiques.

J'ai maintenant quelques options pour des performances d'asservissement plus précises :

• Enregistrez ces paires de valeurs et maintenez-les dans un tableau dans mon croquis Arduino, et lorsque je veux déplacer l'essuie-glace de servo à 90 degrés (par exemple), il suffit de se référer à la valeur PWM liée à cet angle et d'envoyer cette valeur PWM au servo. Cela a un inconvénient que je ne peux faire pivoter que vers des angles qui sont des multiples de 10.

• Ou si je veux un contrôle complet de l'angle auquel j'envoie, je peux utiliser la régression linéaire sur l'ensemble de données pour déterminer quelle formule relie l'angle et la valeur PWM (pour ce servo, PWM =2,35 * Angle + 159,4). De cette façon, je peux passer l'angle vers lequel je veux me tourner comme paramètre et calculer par programme le PWM nécessaire pour faire pivoter ce servo particulier vers cette position.

Quoi qu'il en soit, je suis capable de contrôler ce servo avec plus de précision et de confiance qu'auparavant. C'est un peu plus d'efforts pour calibrer chaque servo avec précision, mais pour mon projet, cela en vaut la peine pour la précision supplémentaire.

Bien sûr, lorsque je retire le servo de l'appareil, je garde l'essuie-glace du servo attaché, car les mesures se rapportent à la façon dont l'essuie-glace est attaché pendant son étalonnage.

Améliorations pour la prochaine version

Après avoir calibré quelques servos, j'ai pensé à quelques améliorations que j'intégrerai dans la prochaine version.

• Le servo doit avoir un mécanisme de dégagement rapide - peut-être fixer le servo en place à l'aide d'un clip avec des aimants en néodyme, au lieu de le fixer avec des boulons M3.

• Je veux le rendre plus petit - je pourrais peut-être réorienter l'Arduino et l'alimentation pour y parvenir.

• J'ai besoin d'un interrupteur d'alimentation entre la batterie 9 v et le convertisseur abaisseur, je n'ai donc pas besoin de déconnecter complètement la batterie chaque fois que je veux éteindre la machine.

• J'aimerais pouvoir imprimer le rig en moins de morceaux.

• Au lieu de lire manuellement les valeurs du rapporteur, il serait préférable qu'un capteur puisse détecter lorsque le servo est dans des positions angulaires spécifiques et le renvoyer à l'Arduino - cela pourrait éliminer certaines erreurs de parallaxe.

• Enfin, un écran LCD pour afficher les résultats serait très utile, car je n'aurais pas besoin de connecter mon ordinateur à l'appareil.

Conclusion

Alors c'est tout - mes servos de loisir sont bon marché et ne sont pas conçus pour la précision - et pour de nombreuses applications, ils sont parfaitement adaptés. Cependant, j'aimerais obtenir un peu plus de précision et des performances reproductibles de la mienne, et la plate-forme de cet article m'aide à y parvenir.

Code

• Esquisse d'un appareil de calibrage d'asservissement

Esquisse du dispositif de calibrage d'asservissementC/C++

#include #define analogIn A0Adafruit_PWMServoDriver pwm =Adafruit_PWMServoDriver();int inputValue =0;int tmpPwmValue =0;void setup() { Serial.begin(9600); pwm.begin(); pwm.setPWMFreq(60);}boucle vide() { inputValue =analogRead(analogIn); // inputValue sera compris entre 0 et 1024 // Par observation, les valeurs servo min et max PWM sont généralement comprises entre 100 et 612 // La formule ci-dessous nous permet de convertir simplement l'entrée analogique en PWM int pwmValue =(int) (100 + ( inputValue / 2)); pwm.setPWM(0, 0, pwmValue); // Vérifiez que nous n'affichons pas inutilement des données en double if (pwmValue !=tmpPwmValue) { Serial.print("Potentiometer Input ="); Serial.print(inputValue); Serial.print(", PWM ="); Serial.println(pwmValue); } tmpPwmValue =pwmValue; retard (15) ;}

Pièces et boîtiers personnalisés

Repo pour les pièces de Servo Calibrator