English

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 :

  1. apprendre le PWM, l’astuce marche/arrêt qui porte ce message,
  2. voir comment la durée de l’impulsion devient un angle,
  3. déplacer un servo avec un bouton, avec une alimentation sûre.
La longueur de l’impulsion règle l’angle Trois dessins du même servo de modélisme, l’axe vers toi, avec le palonnier, le petit bras, à trois angles : vers la gauche à l’angle zéro, tout droit vers le haut au milieu, environ 90 degrés, et vers la droite à environ 180 degrés. Sous chacun, une trame de 20 ms du signal : une impulsion au début, puis bas jusqu’à la trame suivante. À gauche, une impulsion de 1 ms ; au milieu, 1,5 ms ; à droite, 2 ms. Une impulsion arrive environ toutes les 20 ms. Le côté du zéro et les fins de course exactes varient d’un servo à l’autre. FIG. 1 — DE L’IMPULSION À L’ANGLEaangle zéro (une extrémité)1 ms020 msune trame de 20 msble milieu (environ 90°)1,5 ms020 msune trame de 20 mscenviron 180° (autre extrémité)2 ms020 msune trame de 20 msUn repère, pas une loi : le côté du zéro et les fins de course exactes varient d’un servo à l’autre.
Touche le schéma pour l’ouvrir en plein écran.

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.

De la largeur d’impulsion à l’angle (interactif)
De la largeur d’impulsion à l’angle (interactif) Simulation interactive, pas le vrai servo. En haut, un servo vu l’axe vers toi, un arc de course marqué 0, 90 et 180 degrés, et son palonnier. En bas, une période de 20 ms du signal avec son impulsion. Déplace le curseur de 0,5 à 2,5 ms ; la plage habituelle, de 1,0 à 2,0 ms, est mise en évidence. L’impulsion, la barre de rapport cyclique et le palonnier bougent ensemble : 1,0 ms est l’angle zéro, 1,5 ms le milieu, environ 90 degrés, 2,0 ms environ 180 degrés. Hors de la plage habituelle, le palonnier reste en bout de course et un avertissement dit que la fin de course varie d’un servo à l’autre. simulation, pas le servo0°90°180°01020 msgrisé : 1 à 2 ms

Simulation d’un servo typique, pas ton servo.

impulsion 1,5 ms, rapport 7,5 %, angle environ 90°

rapport 7,5 %

ledcWrite(18, 1228);

Dans la plage habituelle : 1,0 à 2,0 ms.

Voici l’état de départ : les commandes ont besoin de JavaScript.

Même période, largeurs d’impulsion différentes Trois signaux PWM de même période, dessinés sur trois périodes chacun. En haut, allumé 25 % de chaque période ; au milieu, 50 % ; en bas, 75 %. Des flèches repèrent une période et une largeur d’impulsion sur chacun. La période ne change pas, seule la largeur d’impulsion change. En dessous, le cas du servo : une période de 20 ms avec une fine impulsion de 1,5 ms, un rapport cyclique de 7,5 %. Un servo mesure cette impulsion ; il n’en fait pas la moyenne. FIG. 2 — RAPPORT CYCLIQUEaRapport cyclique : la part de chaque période où c’est allumé25 %périodelargeur d’impulsion50 %75 %La période reste la même : seule la largeur d’impulsion change.bLe cas du servo1,5 mspériode 20 ms7,5 %= 1,5 / 20le servo mesure cette impulsion, il ne fait pas de moyenne
Touche le schéma pour l’ouvrir en plein écran.

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 3V3 de 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 GND de 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.

Câblage A2 : signal du servo sur 18, son propre bloc 4,8 V, GND commun Deux cadres. a, vue plaque d’essai. La DevKitC est hors de la plaque, USB à gauche, alimentée par son câble USB ; la GPIO 18 est sur sa rangée de broches du bas, donc des fils à embout femelle vont directement sur ses broches. Sur la plaque, les rails du bas sont l’alimentation du servo, 4,8 V ; les rails du haut ne sont pas utilisés. Un bloc de 4 piles AA NiMH, éteint pendant le câblage : 1 rouge, plus du bloc vers le rail plus du bas ; 2 noir, moins du bloc vers le rail moins du bas. La fiche du servo, marron moins, rouge plus, orange signal : 3 rouge, plus du servo vers le rail plus ; 4 noir, moins du servo vers le rail moins ; 5 jaune, signal du servo vers la GPIO 18. 6 noir, un fil épais étiqueté GND commun, du rail moins vers une broche GND de la DevKitC. Un condensateur électrolytique de 470 microfarads est à cheval sur les deux rails du bas, à côté de la fiche du servo, bande sur le rail moins, tension nominale 10 V ou plus. Le bouton est à cheval sur la rainure en rangées 10 et 12 : 7 bleu, GPIO 27 vers la rangée 10 ; 8 noir, sa patte opposée, rangée 12, vers le rail moins. Une ligne rouge en pointillés part de la broche 3V3, barrée : n’alimente jamais le servo par la 3V3. Le plus du servo va seulement à son propre bloc, jamais à une broche de la carte. b, schéma : la GPIO 18 de l’ESP32 commande l’entrée de signal du servo. La pile et le condensateur polarisé sont en parallèle entre le plus et le moins du servo. Un trait épais relie le moins de la pile, le moins du servo et le GND de l’ESP32 : GND commun. Le bouton est entre la GPIO 27 et cette ligne GND. Une ligne en pointillés barrée va de la 3V3 au plus du servo. FIG. 3 — CÂBLAGE, SERVO SUR SA PROPRE ALIMENTATIONaVue plaque d’essaiENBOOT5VCLKCMDD0D3D1D215132GND0124141627172652518331932GND352134RXVNTXVP22EN233V3GND+−−+jihgfedcba1510121518rails du haut : pas utilisésGND communservofiche : marron −, rouge +, orange signal−++++ONOFF4 × NiMH AA, 4,8 Véteint pendant le câblage470 µF,bande sur −10 V ou plusrails du bas :alim. du servobouton3V3 → servo : jamaisGND2718GNDGNDcâble USB :alimente lacarte123456781rouge : + du bloc → rail + du bas2noir : − du bloc → rail − du bas3rouge : rouge du servo (+) → rail +4noir : marron du servo (−) → rail −5jaune : orange du servo (signal) → GPIO 186noir : rail − → broche GND : GND commun7bleu : GPIO 27 → bouton (rangée 10)8noir : bouton, patte opposée → rail −Le + du servo va seulement à son bloc de piles, jamais à une broche de la carte. Le rail + n’alimente que le servo et le condensateur.La GPIO 18 est sur la rangée du bas : la carte reste hors de la plaque, des fils à embout femelle vont sur ses broches.bSchémaESP32DevKitC3V31827GNDMservoS+−signal : seulement les impulsions++4 × NiMH4,8 V470 µF10 V ou plusGND communboutonjamais : la 3V3 n’alimente pas le servo
Touche le schéma pour l’ouvrir en plein écran.

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 µs est 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() utilise map() pour passer de l’angle à l’impulsion. Ensuite setServoPulseUs() 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 wasPressed garde en mémoire la dernière lecture.
14 bits : la période de 20 ms découpée en 16 384 pas Une longue barre représente une période de 20 ms, découpée en 16 384 tranches fines, trop fines pour être dessinées une à une. Les 1 228 premières tranches sont colorées : c’est l’impulsion de 1,5 ms, 7,5 % de la barre. Un encart agrandi autour de la fin de l’impulsion montre des tranches une par une : chacune dure environ 1,2 microseconde ; la tranche 1 228 est la dernière allumée, la tranche 1 229 la première éteinte. La conversion : duty = 1500 µs × 16 384 / 20 000 µs = 1 228,8, et le croquis supprime les décimales : 1 228. FIG. 4 — LE RAPPORT EN PAS020 ms16 384 pas = 20 ms1 228 pas allumés ≈ 1,5 ms (7,5 %)tranches pas à l’échelle1 228 : dernière allumée1 229 : première éteinte1 pas ≈ 1,2 µszoomduty = 1500 µs × 16 384 / 20 000 µs = 1 228,8le croquis supprime les décimales : ledcWrite(18, 1228)
Touche le schéma pour l’ouvrir en plein écran.

À toi de modifier

Change une seule chose, téléverse, observe.

  1. D’autres positions. Modifie la liste positions : essaie {0, 45, 90, 135, 180}. Vérifie que positionIndex reboucle : il utilise % POSITION_COUNT.
  2. Trouve les extrémités de ton servo. Mets MIN_US à 900, puis 800, et MAX_US à 2100, puis 2200, un pas à la fois. Arrête-toi dès que le servo force ou bourdonne en fin de course [3].
  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) ?
  4. Lis le rapport cyclique. Affiche duty dans setServoPulseUs(). 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 GND de 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_US et MAX_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.

  1. 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 %
    Voir la réponse

    7,5 %. Le rapport cyclique est la part de chaque période pendant laquelle le signal est allumé [1]. 1,5 ms sur 20 ms, c’est 1,5 / 20 = 0,075, soit 7,5 %. Pour un servo typique, une impulsion proche de 1,5 ms correspond à la position du milieu [2][3].

  2. 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.

  3. 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 %
    Voir la réponse

    50 impulsions par seconde, une toutes les 20 ms. Le deuxième nombre est la fréquence du PWM [5]. 50 par seconde, c’est une impulsion toutes les 1 / 50 = 0,02 s, soit 20 ms, le rythme qu’un servo attend [2]. Le 14 est la résolution en bits [5].


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, et ledcWrite() 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 3V3 de la carte [4].

Prochaine étape : C1, les condensateurs, pour comprendre pourquoi un gros condensateur calme une alimentation nerveuse.


Sources

Voir les 5 sources
  1. 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/
  2. 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
  3. 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
  4. 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
  5. 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

Pince ou touche deux fois pour zoomer, glisse pour changer de schéma.Molette avec Ctrl ou double-clic pour zoomer. Les flèches changent de schéma.