Qu'est-ce que le PWM ? Guide d'analogWrite, du rapport cyclique et de la fréquence sur Arduino

Les broches numériques de l'Arduino ne connaissent que deux états : 0 V ou 5 V. Alors comment faire briller une LED à moitié ou faire tourner un moteur lentement ? La réponse est le PWM (Pulse Width Modulation, ou MLI : modulation de largeur d'impulsion). La broche est allumée et éteinte très vite, et en changeant la proportion du temps où elle reste allumée, on règle la puissance moyenne envoyée à la charge. Variateurs de LED, contrôle de vitesse des moteurs, servos, génération de sons et même chargeurs de téléphone utilisent cette technique.

Comment fonctionne le PWM ?

Un signal PWM est un signal carré : il reste HIGH un moment, puis LOW, et le cycle se répète sans fin. La durée d'un cycle marche-arrêt est la période, et la part de la période pendant laquelle le signal est HIGH s'appelle le rapport cyclique (duty cycle). À 25 % de rapport cyclique, le signal est allumé un quart du temps : une broche 5 V se comporte en moyenne comme 1,25 V. La LED clignote environ 490 fois par seconde ; l'œil ne peut pas suivre et ne voit que la luminosité moyenne. Un moteur, grâce à son inertie, lisse les impulsions et tourne à la vitesse moyenne.

Notre œil ne réagit pas à la lumière de façon linéaire : il perçoit très bien les variations à faible luminosité, beaucoup moins à forte luminosité. C'est pourquoi une LED à 50 % de rapport cyclique paraît bien plus lumineuse que « moitié ». Pour une variation qui paraisse naturelle, on utilise la correction gamma présentée plus bas.

La fréquence : à quelle vitesse va le PWM ?

La fréquence indique combien de fois par seconde le signal s'allume et s'éteint. Sur l'Arduino Uno, les broches 5 et 6 tournent à environ 980 Hz et les broches 3, 9, 10 et 11 à environ 490 Hz. Pour une LED, c'est largement suffisant. Pour un moteur, en revanche, 490 Hz se situe dans la plage audible et le moteur peut siffler légèrement ; sur l'ESP32 et le Pico, tu peux monter à 20 kHz pour le rendre silencieux. Monter beaucoup plus haut que nécessaire fait toutefois chauffer les transistors et les MOSFET.

Luminosité d'une LED avec analogWrite

Sur Arduino, le PWM se génère avec analogWrite(pin, valeur), la valeur allant de 0 à 255. Malgré son nom trompeur, cette commande ne produit pas une vraie tension analogique, mais du PWM. Elle ne fonctionne que sur les broches marquées ~. Le code ci-dessous allume et éteint une LED progressivement pour un effet de « respiration » :

1const int LED_PIN = 9;   // ~ işaretli PWM pini / PWM pin marked with ~
2
3void setup() {
4  pinMode(LED_PIN, OUTPUT);
5}
6
7void loop() {
8  for (int v = 0; v <= 255; v++) {   // yavaşça yan / fade in
9    analogWrite(LED_PIN, v);
10    delay(8);
11  }
12  for (int v = 255; v >= 0; v--) {   // yavaşça sön / fade out
13    analogWrite(LED_PIN, v);
14    delay(8);
15  }
16}

Régler la luminosité avec un potentiomètre

Si tu branches un potentiomètre sur A0, tu peux régler la luminosité de la LED à la main. analogRead() renvoie une valeur de 0 à 1023 ; en la divisant par 4, on obtient la plage 0–255 attendue par analogWrite. Le branchement d'un potentiomètre est expliqué dans Qu'est-ce qu'un potentiomètre ?

1void loop() {
2  int pot = analogRead(A0);   // 0–1023
3  analogWrite(9, pot / 4);    // 0–255
4}

Vitesse d'un moteur à courant continu en PWM

Même un petit moteur à courant continu consomme des centaines de milliampères, alors qu'une broche d'Arduino ne fournit sans risque qu'environ 20 mA. Le moteur est donc piloté via un transistor, un MOSFET ou un driver moteur comme le L298N, et le signal PWM va sur l'entrée de vitesse du driver. Sur le L298N, c'est la broche ENA (et ENB pour le second moteur) ; pour utiliser le PWM, il faut retirer son cavalier. Les broches IN1 et IN2 fixent le sens de rotation.

1const int ENA = 9;   // hız (PWM) / speed (PWM)
2const int IN1 = 8;   // yön / direction
3const int IN2 = 7;
4
5void setup() {
6  pinMode(ENA, OUTPUT);
7  pinMode(IN1, OUTPUT);
8  pinMode(IN2, OUTPUT);
9  digitalWrite(IN1, HIGH);   // ileri / forward
10  digitalWrite(IN2, LOW);
11}
12
13void loop() {
14  analogWrite(ENA, 255);  delay(2000);   // tam hız / full speed
15  analogWrite(ENA, 150);  delay(2000);   // orta hız / medium speed
16  analogWrite(ENA, 0);    delay(2000);   // dur / stop
17}

Servomoteur et PWM, est-ce la même chose ?

Les servos se commandent aussi par impulsions, mais selon une autre logique : la position dépend de la largeur de l'impulsion, pas du rapport cyclique. Un servo attend 50 impulsions par seconde (50 Hz) ; une impulsion de 1 milliseconde correspond à environ 0°, 1,5 ms à 90° et 2 ms à 180°. analogWrite ne sait pas produire ce minutage, c'est pourquoi les servos utilisent la bibliothèque Servo. Les détails sont dans Qu'est-ce qu'un servomoteur ?

Une vraie tension analogique à partir du PWM : le filtre RC

Parfois, il te faut vraiment une tension stable, par exemple comme référence pour un amplificateur opérationnel ou pour une sortie audio. Dans ce cas, on fait passer le PWM dans un filtre passe-bas formé d'une résistance et d'un condensateur. Avec 10 kΩ et 10 µF, la constante de temps est de 0,1 seconde : la sortie est assez lisse mais réagit lentement aux changements. Tu peux essayer d'autres valeurs avec le calculateur Constante de temps RC. L'ESP32 classique possède en plus deux DAC sur les GPIO 25 et 26, avec une vraie sortie analogique.

Le PWM sur l'ESP32 : LEDC

Sur l'ESP32, le PWM est généré par un périphérique matériel appelé LEDC, et c'est toi qui choisis la fréquence et la résolution. Avec le cœur Arduino 3.x, on utilise ledcAttach(pin, fréquence, résolution) et ledcWrite(pin, valeur) ; les anciennes versions 2.x utilisaient les commandes par canal ledcSetup et ledcAttachPin. L'exemple ci-dessous fait varier une LED à 5 kHz sur 8 bits :

1const int LED_PIN = 2;
2
3void setup() {
4  ledcAttach(LED_PIN, 5000, 8);   // 5 kHz, 8 bit (0–255) — ESP32 Arduino core 3.x
5}
6
7void loop() {
8  for (int d = 0; d <= 255; d++) { ledcWrite(LED_PIN, d); delay(5); }
9  for (int d = 255; d >= 0; d--) { ledcWrite(LED_PIN, d); delay(5); }
10}

Le PWM sur le Raspberry Pi Pico (MicroPython)

Sur le Pico, toutes les GPIO peuvent sortir du PWM. En MicroPython, on utilise la classe PWM : la fréquence se règle avec freq() et le rapport cyclique avec duty_u16(), qui accepte des valeurs de 0 à 65535 :

1from machine import Pin, PWM
2import time
3
4led = PWM(Pin(15))
5led.freq(1000)                        # 1 kHz
6
7while True:
8    for d in range(0, 65536, 512):    # yavaşça yan / fade in
9        led.duty_u16(d)
10        time.sleep_ms(5)
11    for d in range(65535, -1, -512):  # yavaşça sön / fade out
12        led.duty_u16(d)
13        time.sleep_ms(5)

Idées de projets avec le PWM

• LED qui respire : un voyant d'état qui s'allume et s'éteint lentement, comme les appareils en veille.
• Lampe de bureau à variateur : une lampe LED dont tu règles la luminosité avec un potentiomètre.
• Ventilateur selon la température : accélère le ventilateur quand la température mesurée par un DHT11 augmente.
• Mélange de couleurs : crée des millions de couleurs sur une LED RGB avec trois canaux PWM.
• Voiture robot : adoucis les virages en réglant séparément la vitesse de deux moteurs.
• Lampe lever de soleil : augmente progressivement la lumière pendant 15 minutes avant ton réveil.

Erreurs fréquentes et solutions

• analogWrite sur une broche sans PWM : sur l'Uno, les broches sans ~ ne peuvent être qu'allumées ou éteintes ; 128 et plus compte comme allumé, en dessous comme éteint.
• Broches 9 et 10 avec la bibliothèque Servo : sur l'Uno, la bibliothèque Servo utilise le Timer1 et désactive le PWM sur ces deux broches ; déplace ta LED ou ton moteur sur une autre broche PWM.
• Broches 3 et 11 avec tone() : tone() utilise le Timer2 et perturbe le PWM sur ces broches.
• Brancher un moteur directement sur une broche : utilise toujours un transistor, un MOSFET ou un driver moteur.
• Débordement dans le calcul gamma : v * v dépasse la limite d'un int ; ajoute la conversion (long).
• Prendre le PWM pour du vrai analogique : le multimètre affiche la moyenne, mais le signal oscille toujours entre 0 et 5 V ; pour les circuits sensibles, utilise un filtre RC ou un DAC.

Le PWM est l'une des notions les plus utiles que tu apprendras avec Arduino : LED, moteurs, ventilateurs et haut-parleurs se pilotent tous avec cette astuce toute simple. Pour les bases, jette un œil à Qu'est-ce qu'une LED ? ; dans l'application BlueGrays, tu trouveras des projets de variation de LED en PWM, de luminosité au potentiomètre et de dégradés de couleurs RGB, pas à pas avec le code.