Leçons · Leçon A2 · Actionneurs et moteurs · 35 min
Les servos et le PWM
Comprends le PWM et le rapport cyclique, puis commande un servo vers un angle avec des impulsions de 1 à 2 ms, avec sa propre alimentation. Environ 35 minutes, avec un curseur que tu peux déplacer.
Un moteur qui sait où il est
Un petit moteur ordinaire tourne quand tu l’alimentes, et tu ne sais pas de combien il a tourné. Un servo est différent. Il réunit dans un petit boîtier un moteur, un réducteur et un moyen de vérifier sa propre position [3]. Tu ne lui dis pas « tourne » ; tu lui dis « va à cet angle », et il y va.
Comment dire un angle avec un seul fil ? Pas avec une tension, mais avec la durée d’une impulsion : le servo attend une impulsion à peu près toutes les 20 millisecondes, et la durée de cette impulsion fixe l’angle [2].
Dans cette leçon, tu vas :
- apprendre le PWM, l’astuce marche/arrêt qui porte ce message,
- voir comment la durée de l’impulsion devient un angle,
- déplacer un servo avec un bouton, avec une alimentation sûre.
Le PWM et le rapport cyclique
PWM veut dire « modulation de largeur d’impulsion » (pulse width modulation en anglais). Une broche numérique ne peut être qu’allumée ou éteinte, mais si elle s’allume et s’éteint sans cesse, tu peux contrôler combien de temps elle reste allumée à chaque fois. Ce temps est la largeur d’impulsion [1].
Deux nombres décrivent le motif :
- la fréquence : combien de cycles marche/arrêt par seconde. La durée d’un cycle, la période, est son inverse [1]. À 50 cycles par seconde, une période dure 1 / 50 = 0,02 s = 20 ms.
- le rapport cyclique : la part de chaque période pendant laquelle le signal est allumé [1]. Toujours allumé, c’est 100 % ; allumé la moitié du temps, 50 %.
Pour une DEL, tu règles le rapport cyclique et l’œil fait la moyenne des éclats : tu vois une luminosité entre éteint et pleine [1]. Sur une carte Arduino courante, le PWM tourne à environ 500 Hz, donc chaque période dure environ 2 ms [1]. Sur ces cartes, analogWrite() utilise une échelle de 0 à 255 : 255 veut dire toujours allumé, 127 à peu près la moitié du temps [1].
Un servo, lui, ne fait pas de moyenne : il mesure l’impulsion. Une impulsion de 1,5 ms dans une période de 20 ms donne un rapport cyclique de 1,5 / 20 = 7,5 %. Le servo réagit à ces 1,5 ms, pas à la moyenne [2].
Essaie dans le widget ci-dessous : déplace le curseur et vois l’impulsion, la barre de rapport cyclique et l’angle du palonnier bouger ensemble.
Simulation d’un servo typique, pas ton servo.
impulsion 1,5 ms, rapport 7,5 %, angle environ 90°
ledcWrite(18, 1228);
Dans la plage habituelle : 1,0 à 2,0 ms.
Voici l’état de départ : les commandes ont besoin de JavaScript.
De la durée d’impulsion à l’angle
Voici la règle pour un servo de loisir typique [2][3] :
| Durée de l’impulsion | Où va le servo |
|---|---|
| environ 1 ms | une extrémité de sa course (angle zéro) |
| environ 1,5 ms | le milieu |
| environ 2 ms | l’autre extrémité (environ 180°) |
L’impulsion se répète à peu près toutes les 20 ms [2].
Là où l’image s’arrête. Ces nombres sont un repère, pas une loi. Les extrémités varient, et beaucoup de servos ne tournent que d’environ 170° [2]. La page d’un vendeur de micro-servo prévient que les 1 à 2 ms habituelles peuvent ne pas donner les 180° complets ; elle suggère d’essayer de 0,75 à 2,25 ms, mais avertit qu’aller plus loin risque de casser le servo [3]. Commence donc à 1 à 2 ms, et n’élargis que très peu à la fois. Si le servo bourdonne ou force à une extrémité, reviens en arrière aussitôt. Il existe aussi des servos « à rotation continue » qui tournent sur un tour complet [2] ; ils ne suivent pas ce tableau, lis donc la fiche du tien.
Le programme ci-dessous utilise map() : il transforme un angle entre 0 et 180 en une impulsion entre 1000 et 2000 microsecondes (une microseconde est un millionième de seconde : 1000 µs = 1 ms).
L’alimentation : la sienne
Un servo tire un vrai courant. Il consomme beaucoup, surtout au démarrage du moteur, et cet appel brusque peut faire chuter la tension de la carte au point de la faire redémarrer [4]. Une carte qui redémarre quand le servo bouge en est un signe [4].
La règle est donc simple :
- Le servo a sa propre alimentation, qui correspond à ce que dit sa fiche. (Adafruit indique pour un micro-servo 3 à 6 V, 4,8 V nominal [3].) Pour ce servo, un boîtier de 4 piles AA NiMH avec interrupteur donne 4,8 V (voir la leçon E4). Quatre piles alcalines donnent environ 6 V, et un jeu neuf peut dépasser 6 V, soit en haut de cette plage ou au-dessus : préfère 4 piles NiMH (4,8 V). Ne prends jamais l’alimentation du servo sur la broche
3V3de la carte, et ne relie jamais le + de l’alimentation du servo à une broche de la carte. - Relie les masses. La masse de l’alimentation du servo va à une broche
GNDde l’ESP32, pour que le signal et l’alimentation partagent le même zéro. - Le fil de signal va sur une broche GPIO : ici la GPIO 18. Ce fil ne transporte aucune puissance, seulement les impulsions.
- Un gros condensateur sur l’alimentation du servo est un remède connu quand les chutes de tension provoquent des redémarrages [4]. La leçon Adafruit sur les servos suggère 470 µF ou plus [4]. Un condensateur aussi gros est en général un électrolytique : une bande marque sa patte −, qui va au − de l’alimentation, et sa tension maximale doit dépasser celle de l’alimentation (10 V minimum, 16 V pour une marge confortable). Nous verrons les condensateurs dans la leçon C1.
N’alimente pas le servo depuis une broche de la carte, et ne continue pas si la carte redémarre : règle d’abord l’alimentation.
Commander le servo
Fixe le palonnier sur l’axe après le premier essai, pas avant : le programme commence par aller au milieu. Câble selon le schéma : signal sur la GPIO 18, alimentation séparée, masses reliées, bouton sur la GPIO 27 (autre patte à GND).
L’ESP32 a un matériel dédié pour générer du PWM, le périphérique LEDC, conçu surtout pour régler la luminosité des DEL mais utilisable pour d’autres signaux PWM [5]. Pas besoin d’une bibliothèque en plus : deux fonctions suffisent.
// Tinker Mission, leçon A2 : commander un servo avec du PWM (50 Hz, impulsions de 1 à 2 ms)
// Câblage (le servo a sa PROPRE alimentation : ne la prends jamais sur la carte) :
// Fil de signal du servo -> GPIO 18
// Fil d'alimentation du servo -> + d'une alimentation séparée qui convient à ton servo (voir sa fiche ; par ex. 4 piles AA NiMH = 4,8 V)
// Fil de masse du servo -> - de cette alimentation
// (la fiche ou la prise de ton servo indique lequel de ses trois fils est lequel)
// Masse de cette alimentation -> une broche GND de l'ESP32 (les masses doivent être reliées)
// Bouton : une patte à la GPIO 27, la patte diagonalement opposée à GND (pas de résistance nécessaire)
// Chaque appui amène le servo à la position suivante : 0, 90, 180, 90 degrés, et ainsi de suite.
// Le programme utilise le matériel PWM de la carte (LEDC), donc aucune bibliothèque en plus.
const int SERVO_PIN = 18;
const int BUTTON_PIN = 27;
const int SERVO_FREQ = 50; // 50 impulsions par seconde : une toutes les 20 ms
const int SERVO_BITS = 14; // rapport cyclique compté en pas de 1/16384 des 20 ms
const unsigned long PERIOD_US = 1000000UL / SERVO_FREQ; // 20000 microsecondes
const int MIN_US = 1000; // impulsion pour 0 degré (1 ms)
const int MAX_US = 2000; // impulsion pour 180 degrés (2 ms)
// Certains servos vont un peu plus loin avec 750 à 2250 us. N'élargis ces deux nombres
// que très peu à la fois, et arrête tout de suite si le servo force contre sa butée.
const int positions[] = {0, 90, 180, 90}; // angles à visiter, en degrés
const int POSITION_COUNT = sizeof(positions) / sizeof(positions[0]);
int positionIndex = 0;
bool wasPressed = false;
// Transforme un angle (0 à 180) en durée d'impulsion en microsecondes.
int angleToPulseUs(int angle) {
return map(angle, 0, 180, MIN_US, MAX_US);
}
// Envoie la durée d'impulsion au matériel PWM, sous forme de valeur de rapport cyclique.
void setServoPulseUs(int pulseUs) {
uint32_t maxDuty = (1UL << SERVO_BITS) - 1; // 16383, la valeur maximale : toujours allumé
uint32_t duty = (uint32_t)pulseUs * maxDuty / PERIOD_US; // part des 20 ms
ledcWrite(SERVO_PIN, duty);
}
void moveTo(int angle) {
int pulseUs = angleToPulseUs(angle);
setServoPulseUs(pulseUs);
Serial.print("angle ");
Serial.print(angle);
Serial.print(" deg -> pulse ");
Serial.print(pulseUs);
Serial.println(" us");
}
void setup() {
Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
ledcAttach(SERVO_PIN, SERVO_FREQ, SERVO_BITS); // broche, fréquence, résolution (bits)
moveTo(90); // départ au milieu
}
void loop() {
bool pressed = (digitalRead(BUTTON_PIN) == LOW);
if (pressed && !wasPressed) { // vient d'être appuyé (pas maintenu)
positionIndex = (positionIndex + 1) % POSITION_COUNT;
moveTo(positions[positionIndex]);
}
wasPressed = pressed;
delay(20); // masque aussi les rebonds du contact
}
Télécharger le dossier du croquis (.zip)
Ouvre le moniteur série à 115200 baud. Chaque appui déplace le servo et affiche l’angle et l’impulsion.
Comment le lire :
ledcAttach(pin, frequency, resolution)prépare le PWM sur cette broche. Tu choisis la fréquence et une résolution en bits (de 1 à 14, ou jusqu’à 20 sur l’ESP32 classique) [5]. Nous choisissons 50 Hz et 14 bits.- Une résolution de 14 bits coupe la période de 20 ms en 16 384 pas, d’environ 1,2 µs chacun. La valeur de rapport cyclique compte combien de pas le signal reste allumé.
ledcWrite(pin, duty)fixe cette valeur [5].duty = durée de l’impulsion en µs × nombre de pas / 20 000 µsest toute la conversion. Pour 1500 µs, cela donne 1228 pas (le programme laisse tomber les décimales) sur une période de 16 384 pas : 7,5 %.angleToPulseUs()utilisemap()pour passer de l’angle à l’impulsion. EnsuitesetServoPulseUs()convertit l’impulsion en rapport cyclique.- Le bouton fonctionne sur le front : le servo bouge une fois par appui, pas à chaque tour de boucle. La variable
wasPressedgarde en mémoire la dernière lecture.
À toi de modifier
Change une seule chose, téléverse, observe.
- D’autres positions. Modifie la liste
positions: essaie {0, 45, 90, 135, 180}. Vérifie quepositionIndexreboucle : il utilise% POSITION_COUNT. - Trouve les extrémités de ton servo. Mets
MIN_USà 900, puis 800, etMAX_USà 2100, puis 2200, un pas à la fois. Arrête-toi dès que le servo force ou bourdonne en fin de course [3]. - Un balayage lent. Remplace le bouton par une boucle qui avance d’un degré toutes les 15 ms, de 0 à 180 puis retour. Pourquoi
delay(15)convient-il ici, et quand ne conviendrait-il pas (voir K4) ? - Lis le rapport cyclique. Affiche
dutydanssetServoPulseUs(). Les nombres correspondent-ils à 5 %, 7,5 % et 10 % de 16 384 ?
Quand ça ne marche pas
- Rien ne bouge. Vérifie le fil de signal sur la GPIO 18 et que l’alimentation est allumée. Vérifie que la masse de l’alimentation du servo rejoint une broche
GNDde l’ESP32. - Le servo tressaute ou la carte redémarre. L’alimentation est trop faible ou partagée avec la carte [4]. Donne au servo sa propre alimentation. Un gros condensateur sur cette alimentation peut aider [4].
- Il bouge un peu puis s’arrête, ou ne marche que sur certains ports USB. Même cause : la tension chute sous la charge [4].
- Il bourdonne ou force à une extrémité. Les impulsions demandent plus de course que le servo n’en a [2][3]. Resserre
MIN_USetMAX_US. - Il n’atteint jamais les 180° complets. Beaucoup de servos ne tournent que d’environ 170° [2]. Élargis un peu les impulsions, comme dans les modifications ci-dessus.
- « ledcAttach was not declared » à la compilation. Ton paquet de cartes esp32 est trop ancien. Dans le gestionnaire de cartes, mets à jour « esp32 by Espressif Systems » vers la version 3 ou plus récente [5].
- Rien dans le moniteur série. Règle-le sur 115200 baud, comme
Serial.begin(115200).
Vérifie-toi
Trois petites questions. Rien n’est enregistré, prends ton temps.
Un signal PWM se répète toutes les 20 ms et reste allumé 1,5 ms à chaque fois. Quel est son rapport cyclique ?
- 1,5 %
- 7,5 %
- 75 %
D’où le servo doit-il tirer son alimentation ?
- De la broche 3V3 de la carte, c’est la plus proche
- D’une alimentation séparée qui lui convient, avec sa masse reliée au GND de la carte
- De la broche de signal elle-même
Voir la réponse
D’une alimentation séparée qui lui convient, avec sa masse reliée au GND de la carte. Un servo consomme beaucoup, surtout au démarrage, et cet appel brusque peut faire chuter la tension de la carte jusqu’à la faire redémarrer [4]. Il a donc sa propre alimentation [4]. Les masses sont reliées pour que le signal et l’alimentation partagent le même zéro.
Dans ledcAttach(18, 50, 14), que veut dire 50 ?
- 50 degrés
- 50 impulsions par seconde, une toutes les 20 ms
- Un rapport cyclique de 50 %
En bref
- Le PWM allume et éteint une broche sans cesse. La fréquence est le nombre de cycles par seconde, et le rapport cyclique la part de chaque cycle passée allumée [1].
- Un servo lit la durée de l’impulsion, envoyée à peu près toutes les 20 ms : environ 1 ms pour une extrémité, 1,5 ms pour le milieu, 2 ms pour l’autre extrémité. Les extrémités exactes varient [2][3].
- Sur l’ESP32,
ledcAttach()fixe la fréquence et la résolution, etledcWrite()fixe le rapport cyclique [5]. - Un servo consomme beaucoup au démarrage. Donne-lui sa propre alimentation, relie les masses, et ne l’alimente jamais depuis la broche
3V3de la carte [4].
Prochaine étape : C1, les condensateurs, pour comprendre pourquoi un gros condensateur calme une alimentation nerveuse.
Sources
Voir les 5 sources
- Arduino, « Basics of PWM (Pulse Width Modulation) » (le PWM donne des résultats de type analogique avec des moyens numériques en allumant et éteignant un signal ; le temps allumé est la largeur d’impulsion ; la période est l’inverse de la fréquence du PWM ; le PWM d’Arduino à environ 500 Hz donne des périodes de 2 ms ; analogWrite sur une échelle de 0 à 255, 255 vaut 100 % de rapport cyclique, 127 à peu près 50 %) — https://docs.arduino.cc/learn/microcontrollers/analog-output/
- Adafruit, « Arduino Lesson 14. Servo Motors », « Servo Motors » (le servo attend une impulsion à peu près toutes les 20 ms ; 1 ms donne l’angle zéro, 1,5 ms le centre, 2 ms 180 degrés ; les extrémités varient et beaucoup de servos ne tournent que d’environ 170 degrés ; les servos à rotation continue tournent sur un tour complet) — https://learn.adafruit.com/adafruit-arduino-lesson-14-servo-motors/servo-motors
- Adafruit, « Micro servo - TowerPro SG92R » (référence 169) (tourne d’environ 180 degrés ; évite de construire un contrôleur de moteur avec retour de position et réducteur ; 1,5 ms est le milieu, environ 2 ms et environ 1 ms les extrémités ; les 1 ms à 2 ms par défaut peuvent ne pas donner les 180 degrés complets, essayer 0,75 ms à 2,25 ms ; aller trop loin pourrait casser le servo ; tension 4,8 V nominale, 3 V à 6 V) — https://www.adafruit.com/product/169
- Adafruit, « Arduino Lesson 14. Servo Motors », « If the Servo Misbehaves » (un servo consomme beaucoup, surtout au démarrage, et cet appel brusque peut faire chuter la tension de la carte jusqu’à son redémarrage ; un condensateur de 470 µF ou plus entre GND et 5 V aide) — https://learn.adafruit.com/adafruit-arduino-lesson-14-servo-motors/if-the-servo-misbehaves
- Espressif, documentation Arduino-ESP32, « LED Control (LEDC) » (le périphérique LEDC est conçu surtout pour régler l’intensité des DEL et peut aussi générer des signaux PWM à d’autres fins ; ledcAttach(pin, freq, resolution) avec une résolution de 1 à 14 bits, 1 à 20 bits pour l’ESP32 ; ledcWrite(pin, duty) fixe le rapport cyclique) — https://docs.espressif.com/projects/arduino-esp32/en/latest/api/ledc.html