Calibrage précis de servomoteurs avec Arduino UNO et shield PWM Adafruit

Composants et fournitures

Arduino UNO	×1
Shield pilote PWM pour servomoteurs Adafruit	×1
Boulons M3	×8
Rondelles M3	×8
Convertisseur abaisseur de tension LM2596 DC-DC	×1
Filament PLA rouge	×1
Filament PLA blanc	×1
Équerre de 180° transparente	×1
Potentiomètre rotatif (générique)	×1
Servomoteur 9g	×1

Outils et machines nécessaires

• Imprimante 3D (générique)

Applications et services en ligne

• Arduino IDE
• Autodesk Fusion 360

À propos du projet

Dans un précédent article sur Hackster, j'ai présenté un dispositif pour comparer la rotation de différents servomoteurs d'un même lot, montrant qu'un même signal PWM produit des comportements significativement différents. L'image ci-dessous illustre des servomoteurs tous partis de leur position extrême anti-horaire et recevant le même signal PWM — tous ont un comportement légèrement différent.

Pourquoi ne pas utiliser les bibliothèques servo existantes pour Arduino ?

J'utilise le pilote de servomoteurs PWM Adafruit pour commander plusieurs servos, ce qui permet d'envoyer un signal PWM différent à chaque servo. Je pourrais utiliser la bibliothèque Servo intégrée à Arduino, mais plusieurs raisons m'en empêchent :

• Avec le pilote Adafruit, je contrôle mes servos via seulement deux broches en I2C, au lieu de dédier une broche Arduino par servo.
• J'ai parfois constaté qu'avec la bibliothèque Servo d'Arduino, lors de l'attachement à un servo et l'envoi d'un signal pour la position zéro degré, celui-ci tourne jusqu'à la butée de fin de course et grince les engrenages internes.

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 pouvoir en tirer plus de valeur. Je veux les utiliser pour un robot marcheur et ai besoin que leur comportement soit plus précis et prévisible.

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

Le constat que mes servos se comportent tous différemment m'a poussé à construire un dispositif de calibration : quelles valeurs PWM envoyer pour atteindre 0° ? Le point central à 90° ? Comment éviter d'envoyer une valeur PWM qui claque le servo en butée avec grincement d'engrenages ?

J'ai combiné deux concepts simples :

• Aligner mon servo au centre d'un rapporteur simple, de sorte qu'en tournant le palonnier, je puisse mesurer sa position angulaire.
• Connecter un potentiomètre à une entrée analogique de l'Arduino, pour contrôler la position du palonnier du servo en ajustant la valeur PWM via l'axe du potentiomètre.

Pour cette version, j'utilise le moniteur série de l'IDE Arduino pour lire la valeur du signal PWM, que je note manuellement.

J'ai utilisé Autodesk 123D pour concevoir un support simple maintenant le potentiomètre, le rapporteur, un servo unique, l'Arduino, le pilote PWM Adafruit et une alimentation.

Je veux continuer d'utiliser le pilote PWM Adafruit pour la calibration, car c'est ce que j'utiliserai dans mon projet final. Si je devais commander le servo directement depuis une broche Arduino, je reproduirais cela dans le dispositif pour calibrer contre le PWM de l'Arduino.

Construction du dispositif

J'ai imprimé chaque pièce et les ai assemblées avec les boulons et rondelles M3.

Les trous de fixation sont ajustés à mes composants — d'autres composants peuvent avoir des variations de diamètres et positions.

Côté électronique : la broche centrale du potentiomètre est reliée à la broche A0 de l'Arduino, les deux autres au 0V et 5V. Le pilote PWM est emboîté sur l'Arduino, puis j'ai connecté le convertisseur abaisseur (réglé pour convertir 9V en 5V). Le servo 9g est connecté au premier slot du shield, puis j'ai téléversé le programme sur l'Arduino.

Le résultat final est visible sur les photos. En tournant le bouton en haut à gauche, je contrôle la position du servo, et via le moniteur série de l'IDE Arduino, je lis la valeur PWM envoyée pour tout angle donné.

Ce que m'apprend le dispositif

Pour mon servo, je l'ai tourné à sa limite horaire maximale, et placé le palonnier juste au-delà du repère 180° du rapporteur.

J'ai alimenté le dispositif, puis tourné le potentiomètre jusqu'à aligner l'aiguille du servo sur 0°, et noté la valeur PWM sur le moniteur série. Puis j'ai tourné jusqu'à 10°, noté la valeur, et ainsi de suite par pas de 10° jusqu'à 180°. Les résultats sont dans le tableau ci-dessous.

J'ai tracé un graphique des résultats (ci-dessous), montrant une relation fortement linéaire entre PWM et angle, comme prévu.

J'ai maintenant des paires valeurs PWM/angle caractéristiques de ce servo précis — d'autres servos auront des caractéristiques similaires mais non identiques.

Deux options s'offrent à moi pour une meilleure précision :

• Enregistrer ces paires dans un tableau dans mon programme Arduino, et pour déplacer le palonnier à 90° (par exemple), consulter la valeur PWM correspondante et l'envoyer au servo. Inconvénient : je ne peux atteindre que des angles multiples de 10.
• Utiliser une régression linéaire sur les données pour trouver la formule reliant angle et valeur PWM (pour ce servo : PWM = 2,35 × Angle + 159,4). Ainsi je peux passer l'angle souhaité en paramètre et calculer programmatiquement la PWM nécessaire pour ce servo précis.

Dans les deux cas, je contrôle ce servo avec plus de précision et de confiance. C'est plus d'effort pour calibrer chaque servo précisément, mais pour mon projet, cela en vaut la peine pour la précision accrue.

Bien sûr, quand je retire le servo du dispositif, je dois conserver le palonnier attaché, car les mesures correspondent à la façon dont le palonnier était fixé pendant la calibration.

Améliorations pour la prochaine version

Après avoir calibré plusieurs servos, voici les améliorations prévues :

• Mécanisme de libération rapide pour le servo — par exemple, fixation par clip avec aimants néodyme au lieu de boulons M3.
• Réduire la taille — peut-être réorienter l'Arduino et l'alimentation.
• Ajouter un interrupteur entre la pile 9V et le convertisseur abaisseur, pour ne pas devoir débrancher la pile à chaque arrêt.
• Imprimer le support en moins de pièces.
• Remplacer la lecture manuelle du rapporteur par un capteur détectant les positions angulaires précises et renvoyant l'info à l'Arduino — éliminant l'erreur de parallaxe.
• Ajouter un écran LCD pour afficher les résultats, sans avoir besoin de l'ordinateur connecté.

Conclusion

Voilà — mes servos de modélisme sont bon marché et pas conçus pour la précision — et pour beaucoup d'applications, ils suffisent. Cependant, je veux en tirer un peu plus de précision et de répétabilité, et ce dispositif m'y aide.

Code

Programme pour dispositif de calibration de servo

#include <Adafruit_PWMServoDriver.h>
#define analogIn A0
Adafruit_PWMServoDriver pwm = Adafruit_PWMServoDriver();
int inputValue = 0;
int tmpPwmValue = 0;

void setup() {
  Serial.begin(9600);
  pwm.begin();
  pwm.setPWMFreq(60);
}

void loop() {
  inputValue = analogRead(analogIn); // 0 à 1024
  // Par observation, valeurs PWM min/max servo généralement entre 100 et 612
  int pwmValue = (int)(100 + (inputValue / 2));
  pwm.setPWM(0, 0, pwmValue);
  
  // Éviter d'afficher des données dupliquées
  if (pwmValue != tmpPwmValue) {
    Serial.print("Potentiometer Input = ");
    Serial.print(inputValue);
    Serial.print(", PWM = ");
    Serial.println(pwmValue);
  }
  tmpPwmValue = pwmValue;
  delay(15);
}

Pièces personnalisées et boîtiers

Dépôt des pièces pour le calibrateur de servo :
https://github.com/jeremylindsayni/ServoCalibrator