Le PWM sur Arduino ouvre la porte au contrôle précis de la lumière, de la vitesse des moteurs et du son, avec un simple signal numérique. En quelques lignes de code, une carte à moins de 30 € commence à moduler une LED, un servomoteur ou un ventilateur comme si vous disposiez d’un variateur professionnel.
Pour y parvenir sans griller un composant ni perdre des heures à déboguer, quelques notions clés deviennent indispensables : fréquence, rapport cyclique, broches compatibles, limites de courant, conversions analogiques… Le tutoriel qui suit détaille chaque étape et met en lien théorie, câblage et code Arduino.
| Élément clé | Synthèse |
| Définition du PWM | Modulation permettant de contrôler l’intensité d’un signal pour gérer luminosité, vitesse ou puissance ⚡ |
| Broches Arduino | Les pins marquées d’un ~ supportent le PWM sur la plupart des cartes (ex : 3, 5, 6, 9, 10, 11). |
| Commande principale | La fonction analogWrite permet d’envoyer une valeur modulée (0 à 255). |
| Usage typique | Contrôle de LED, moteurs, ventilateurs, servos basiques, avec variation fluide. |
| Avantage | Permet un contrôle précis sans matériel complexe, idéal pour les débutants 🎯 |
Comprendre le PWM sur Arduino : principe, fréquence et rapport cyclique
Le PWM (Pulse Width Modulation) sur Arduino correspond à une modulation de largeur d’impulsion. La carte ne génère pas vraiment une tension analogique variable. Elle commute en réalité la sortie entre 0 V et 5 V (ou 3,3 V selon le modèle) à très haute vitesse. La valeur « intermédiaire » perçue par un LED ou un moteur provient de la moyenne temporelle du signal.
Le PWM repose sur deux grandeurs clés : la fréquence du signal et le rapport cyclique (duty cycle). La fréquence définit le nombre de cycles par seconde. Le rapport cyclique indique la proportion de temps pendant laquelle la sortie reste à l’état haut sur un cycle complet.
Sur Arduino, la fonction analogWrite() masque tout ce fonctionnement interne. Une simple valeur comprise entre 0 et 255 pilote directement l’intensité perçue par une LED ou la vitesse d’un moteur. Derrière ce confort, les timers matériels génèrent un signal PWM stable avec une résolution de 8 bits.
Fréquence PWM sur Arduino Uno, Nano, Mega, Leonardo, Micro
Chaque carte Arduino présente plusieurs timers matériels, associés à des broches spécifiques. Les fréquences PWM par défaut varient selon ces timers et selon la carte. Cette nuance compte pour éviter des scintillements ou des sifflements audibles.
| Carte Arduino | Broches PWM concernées | Fréquence PWM typique |
|---|---|---|
| Uno / Nano | D3, D9, D10, D11 | ≈ 490,2 Hz |
| Uno / Nano | D5, D6 | ≈ 976,56 Hz |
| Mega | D44, D45, D46 | ≈ 490,2 Hz |
| Leonardo / Micro | D3, D11 | ≈ 976,56 Hz |
| Leonardo / Micro | D5, D6, D9, D10, D13 | ≈ 490,2 Hz |
Sur Arduino Uno et Nano, les fréquences PWM par défaut s’appuient sur deux horloges :
- Pin 5 et 6 : base à 62 500 Hz, divisée par un prédiviseur (1, 8, 64, 256, 1024) pour aboutir à ≈ 976,56 Hz.
- Pin 3, 9, 10, 11 : base à 31 250 Hz, divisée par le même type de prédiviseur pour arriver à ≈ 490,2 Hz.
Ce choix de fréquence s’adapte bien à l’éclairage de LED (pas de scintillement visible) et au pilotage de petits moteurs CC, tout en gardant un timer disponible pour les autres fonctionnalités de la carte.
Résolution et gamme de tension équivalente
Le PWM sur Arduino Uno / Nano offre une résolution de 8 bits, soit 256 niveaux possibles. La valeur passée à analogWrite() varie de 0 à 255 :
- 0 : rapport cyclique 0 %, sortie au niveau bas en permanence.
- 255 : rapport cyclique 100 %, sortie au niveau haut quasi permanente.
- 128 (environ) : rapport cyclique proche de 50 %.
Pour une carte en 5 V, la tension moyenne perçue par une charge avec un rapport cyclique donné reste proportionnelle à celui-ci. À 20 % de PWM, une LED alimentée en 5 V reçoit, en moyenne, une tension équivalente à environ 1 V, même si le signal instantané reste toujours à 0 V ou 5 V.
Sur certaines cartes comme la famille Arduino basées sur 3,3 V, la même logique s’applique, avec une sortie qui commute entre 0 V et 3,3 V. Le code PWM ne change pas, seule l’amplitude de la tension varie.
Broches PWM sur Arduino : où brancher LED et moteurs ?
Les broches PWM ne se confondent pas avec toutes les sorties numériques. Sur Arduino Uno et Nano, seules les broches marquées d’un petit signe « ~ » génèrent un signal PWM matériel. Les projets qui mélangent plusieurs sorties PWM (moteur, LED, buzzer) doivent tenir compte de cette limitation.
Sur un Arduino Nano, les broches PWM disponibles sont : D3, D5, D6, D9, D10, D11. L’Uno partage la même répartition. D’autres cartes comme la Mega ou la Leonardo proposent davantage de sorties PWM, mais les timers et leur configuration se complexifient.
Distribution par timers et contraintes associées
Chaque groupe de broches s’appuie sur un timer matériel. Par exemple, sur Uno/Nano :
- Timer0 : gère la fonction
millis()et certaines interruptions de base. - Timer1 : plus polyvalent, souvent utilisé pour les servomoteurs.
- Timer2 : alimente certaines broches PWM spécifiques.
Une modification de la fréquence d’un timer impacte toutes les broches associées. Un projet qui pilote plusieurs sorties PWM via le même timer doit prévoir ces interactions, surtout si des bibliothèques modifient la configuration des timers en arrière-plan.
« Chaque timer conditionne plusieurs broches PWM. Une configuration hâtive d’un seul timer finit souvent par perturber d’autres sorties. Une approche structurée évite les conflits difficiles à diagnostiquer. »
Fonction analogWrite() : syntaxe, échelle 0–255 et rapport cyclique
La fonction analogWrite() reste la porte d’entrée la plus simple vers le PWM sur Arduino. Elle dispense de manipuler les registres des timers et offre une abstraction efficace pour un débutant.
Signature de base : analogWrite(pin, value);. La broche doit appartenir à la liste des sorties PWM pour générer un signal modulé. Sur une broche non PWM, analogWrite() se comporte comme un simple digitalWrite() avec seuil haut/bas.
Correspondance entre value et rapport cyclique
La valeur transmise à analogWrite() s’étend de 0 à 255. Elle se convertit en rapport cyclique de la façon suivante :
- 0 → 0 % du temps à l’état haut.
- 127 → environ 49,8 % du temps à l’état haut.
- 255 → presque 100 % du temps à l’état haut.
La formule générale reste simple : duty_cycle(%) = value / 255 × 100. Inversement, pour un rapport cyclique désiré, la valeur PWM correspond à : value = duty_cycle(%) × 255 / 100.
Cette granularité de 8 bits suffit pour la plupart des usages : variation de luminosité, contrôle de vitesse, dosage de chauffage à faible inertie, pilotage d’un ventilateur ou d’un buzzer à fréquence fixe.
analogWrite() sur différentes valeurs (0, 64, 128, 192, 255) montre nettement les paliers d’intensité. Cet exercice clarifie la relation entre code numérique et perception lumineuse.Modes PWM matériels : Fast PWM et Phase Correct
L’architecture AVR utilisée par l’Arduino Uno/Nano propose plusieurs modes de génération PWM. Les deux plus courants : Fast PWM et Phase Correct PWM. La fonction analogWrite() s’appuie par défaut sur le mode Fast PWM dans la majorité des cas.
Fast PWM : rapidité et fréquence stable
En mode Fast PWM, le timer compte de 0 à 255, puis revient immédiatement à 0. La sortie PWM commute à une fréquence donnée par :
f_PWM = f_base / (prescaler × 256)
Sur Uno/Nano, avec une horloge à 16 MHz et un prédiviseur approprié, on obtient les valeurs classiques de ~490 Hz ou ~976 Hz selon la broche. La fréquence reste fixe, seule la durée du niveau haut varie avec la valeur de comparaison (OCRx).
Ce mode convient à la plupart des usages : pilotage de LED, moteurs DC, chauffage à commutation rapide, petits signaux audio bruts.
Phase Correct PWM : symétrie et réduction du bruit
En mode Phase Correct PWM, le timer réalise une montée et descente : il compte de 0 à 255, puis redescend à 0. Un cycle complet contient donc 510 pas, ce qui divise la fréquence PWM par deux par rapport au Fast PWM.
Ce mode améliore la symétrie du signal autour du centre du cycle, ce qui limite certains phénomènes de bruit électromagnétique ou des décalages de phase dans des circuits sensibles. La durée moyenne du niveau haut correspond toujours à la valeur PWM, mais son positionnement dans le temps se répartit différemment.
Pour un débutant, les modes internes restent souvent transparents. Un usage avancé qui touche aux registres de timers y trouve cependant une marge d’optimisation utile pour piloter des circuits de puissance, des ponts en H ou des convertisseurs DC-DC.
De l’analogique au PWM : utiliser analogRead(), map() et analogWrite()
De nombreux projets s’appuient sur une entrée analogique (potentiomètre, capteur de lumière, capteur de température) pour piloter une sortie PWM. Sur Arduino, le convertisseur analogique-numérique (ADC) travaille en 10 bits, avec une plage de mesure 0–1023.
Une tension comprise entre 0 et 5 V sur une entrée analogique se transforme ainsi :
- 0 V → valeur 0.
- 5 V → valeur 1023.
- 2,5 V → valeur approximative 512.
Pour convertir cette échelle 0–1023 vers l’échelle PWM 0–255, la fonction map() offre un raccourci pratique. La relation linéaire relie les deux gammes sans calcul manuel complexe.
Exemple complet : potentiomètre qui pilote l’intensité d’une LED
Supposons un potentiomètre alimenté en 5 V, connecté sur une entrée analogique A0, et une LED branchée sur une broche PWM D9 avec une résistance série. Un réglage du potentiomètre au milieu fournit une tension d’environ 2,5 V, soit une valeur lue proche de 512.
Dans ce cas :
analogRead(A0)→ ~512.- Conversion vers PWM : la fonction
map()ramène 512 vers ~128. analogWrite(9, 128)→ rapport cyclique d’environ 50 %.
Sur un Arduino typique, cette valeur mène à une intensité lumineuse proche de 50 % de la luminosité maximale perçue. La fréquence reste autour de 490 Hz sur la broche D9, ce qui évite un scintillement visible pour un observateur humain.
« Dans un montage pédagogique, relier directement un potentiomètre à une LED via le couple analogRead()/analogWrite() montre de manière concrète la transition du monde analogique au monde numérique. Le geste sur le potentiomètre se traduit instantanément en valeur binaire, puis en rapport cyclique. »
Exemple pratique : faire varier la luminosité d’une LED avec PWM
Le contrôle de la luminosité d’une LED avec le PWM reste une application classique. Elle permet d’assimiler le principe de rapport cyclique tout en gardant un montage très simple et peu coûteux. Un simple fil mal branché suffit cependant à endommager une LED, d’où l’intérêt d’un câblage rigoureux.
Sur une alimentation 5 V et une valeur de PWM correspondant à 20 % de rapport cyclique, la tension moyenne appliquée à la LED atteint environ 2 V. Le signal instantané reste toujours à 0 V ou 5 V, mais l’œil intègre cette modulation et perçoit une luminosité stable intermédiaire.
Matériel et câblage minimal
Pour ce tutoriel, la liste de composants reste courte :
- Une carte Arduino Uno ou Nano.
- Une LED standard (rouge, verte ou autre).
- Une résistance série adaptée (220 Ω ou 330 Ω en général).
- Des fils de connexion et une breadboard.
Le montage se résume à :
- Relier la broche D9 (PWM) à une extrémité de la résistance.
- Relier l’autre extrémité de la résistance à l’anode de la LED.
- Relier la cathode de la LED à la masse (GND).
Ce schéma protège la LED contre les surintensités et laisse le PWM jouer pleinement son rôle de variateur.
Création d’un effet de fondu (fading)
Une séquence de variation progressive de la valeur passée à analogWrite() produit un effet de fondu. La LED s’allume progressivement, atteint une intensité élevée, puis baisse jusqu’à s’éteindre. La perception visuelle reste fluide, même si le PWM se fait en paliers numériques.
Sur un Arduino Nano, la broche D9 utilise une fréquence d’environ 490 Hz. La LED ne scintille pas et le cycle de variation se gère via une simple boucle qui parcourt les valeurs de 0 à 255, puis dans l’autre sens.
Contrôler un moteur DC par PWM : tension moyenne et formule de calcul
Le PWM se prête très bien au contrôle de vitesse des moteurs à courant continu. Le principe repose sur la variation de la tension moyenne appliquée au moteur, tout en gardant une tension instantanée à 0 V ou à la tension d’alimentation. Le moteur réagit surtout à cette moyenne, ce qui permet une variation de vitesse assez linéaire sur une plage raisonnable.
Avec un rapport cyclique de 50 %, la tension moyenne appliquée au moteur suit la relation :
V_motor = V_supply × 0,5
Pour une alimentation de 12 V, la tension moyenne atteindra environ 6 V. En pratique, le frottement mécanique, l’inductance de l’enroulement et les pertes conduisent à un comportement légèrement non linéaire, mais la proportion reste parlante pour un dimensionnement de base.
Exemple numérique détaillé
Un montage alimenté par une source de 12 V, avec un MOSFET commandé via une broche PWM de l’Arduino, illustre bien la logique :
- V_supply = 12 V.
- Duty cycle = 50 %.
- V_motor ≈ 12 V × 0,5 = 6 V.
Le MOSFET agit alors en commutateur rapide. Lorsque la broche PWM passe à l’état haut, le MOSFET sature et applique la tension de 12 V au moteur. Lorsque la broche PWM passe à l’état bas, le MOSFET coupe le courant. La combinaison rapide des deux états crée la tension moyenne recherchée.
Dans certains schémas, la broche de commande du MOSFET se retrouve étiquetée avec une désignation comme « B11 » ou autre marque interne. Au niveau de l’Arduino, cette commande se relie à une broche PWM standard, par exemple D3, D5, D6, D9, D10 ou D11, selon la carte.
« Pour un moteur DC, le PWM offre une alternative sobre à un gros variateur linéaire. Le composant de puissance commute entre saturation et coupure, ce qui réduit fortement les pertes par dissipation thermique. »
Choix de la fréquence PWM pour les moteurs
Les moteurs DC peuvent émettre un sifflement audible lorsque la fréquence PWM se situe dans la bande audible (environ 20 Hz à 20 kHz). Les fréquences par défaut de 490 Hz ou 976 Hz restent parfois audibles selon le moteur et le montage mécanique.
Pour limiter ce bruit, certains projets ajustent les registres de timers pour passer la fréquence PWM au-dessus de la bande audible, par exemple autour de 20 kHz. Sur Uno/Nano, cette opération implique une modification de la configuration des timers, au prix d’une complexité accrue.
Convertir une lecture analogique en PWM : gestion fine de la plage 0–1023 à 0–255
Le passage de l’entrée analogique (10 bits, 0–1023) à la sortie PWM (8 bits, 0–255) s’effectue couramment via la fonction map(). Ce pont relie facilement un capteur analogique, une sonde ou un potentiomètre à une charge pilotée en PWM.
L’ADC de l’Arduino lit une plage de 0–5 V en 10 bits : chaque pas représente environ 4,88 mV. Cette résolution se réduit à 8 bits sur la sortie PWM : chaque pas correspond alors à environ 19,6 mV en termes de tension moyenne sur une alimentation 5 V.
Stratégies de conversion et lissage
Une conversion linéaire simple permet déjà une bonne exploitation :
- Lecture brute :
value_in = analogRead(A0); - Conversion vers PWM :
value_pwm = map(value_in, 0, 1023, 0, 255); - Application :
analogWrite(pinPWM, value_pwm);
Pour un capteur un peu bruité, un lissage logiciel via une moyenne mobile améliore la stabilité de la valeur PWM. Une simple moyenne de plusieurs lectures successives réduit les sauts brusques d’intensité sur une LED ou les à-coups sur un petit moteur.
Ce type de chaîne analogique → numérique → PWM se retrouve dans de nombreux systèmes : régulation de lumière, gestion de ventilateur, commande de pompe, interface homme‑machine via potentiomètre ou joystick analogique.
Fréquences PWM sur Arduino Nano : focus pratique
L’Arduino Nano revient souvent dans les projets compacts. Sa compatibilité avec l’Uno simplifie la transition pour un débutant. En matière de PWM, le Nano adopte les mêmes fréquences par défaut que l’Uno, avec toutefois une attention particulière sur les broches D5 et D6.
Par défaut, on observe deux familles de fréquence :
- Broches D3, D9, D10, D11 → ~490 Hz.
- Broches D5, D6 → ~980 Hz.
Ce contraste de fréquence permet un choix adapté à la nature de la charge : certains circuits de puissance, filtres RC ou transducteurs réagissent différemment selon la fréquence. Un test comparatif sur les broches de l’Arduino Nano illustre bien ces comportements.
Alimenter LED, moteurs et charges diverses : notion de tension moyenne et filtrage
Le PWM ne délivre jamais une vraie tension analogique continue. Pourtant, de nombreuses charges réagissent comme si la tension variait réellement. Ce comportement provient de la tension moyenne associée au rapport cyclique, combinée à l’inertie physique ou électrique de la charge.
Une LED possède une réponse lumineuse qui suit approximativement la moyenne du courant sur une période. Un petit moteur DC présente une inertie mécanique : son rotor ne s’arrête pas instantanément entre deux impulsions PWM. Les condensateurs et inductances introduisent aussi un filtrage naturel, ce qui renforce l’effet analogique apparent.
Ajouter un filtre RC pour obtenir une tension quasi-continue
Pour certains montages, un filtre RC (résistance + condensateur) derrière la sortie PWM crée une tension quasi-continue. Le condensateur se charge pendant les phases hautes et se décharge doucement pendant les phases basses. La valeur moyenne du signal se stabilise, au prix d’un temps de réponse plus lent.
ArduinoPiloter un relais 230 V avec Arduino en sécurité : 5 erreurs à éviterLa valeur du couple RC se choisit en fonction de la fréquence PWM et de la bande passante souhaitée sur la tension de sortie. Une fréquence PWM élevée facilite la conception du filtre, car l’écart entre la fréquence de découpage et la bande utile devient plus confortable.
Ce type de montage s’utilise parfois pour générer une tension de référence analogique, piloter une entrée analogique d’un autre circuit ou interfacer un Arduino avec un module qui n’accepte que des niveaux continus.
PWM et pilotage de servomoteurs : différences et compatibilité
Les servomoteurs classiques (type servo RC) s’appuient sur des impulsions de largeur variable mais ne se comportent pas comme un simple PWM de type analogWrite(). Le servo attend une trame de contrôle typique : des impulsions de 1 ms à 2 ms répétées toutes les 20 ms environ.
Cette norme se distingue clairement du PWM binaire 0–5 V à fréquence fixe autour de quelques centaines de hertz. Pourtant, les deux techniques partagent une idée commune : la largeur de l’impulsion encode une information analogique (position du servo, intensité lumineuse, etc.).
Pourquoi analogWrite() ne suffit pas pour un servo
Un servo classique n’interprète pas un simple signal PWM généré par analogWrite(). La fréquence ne correspond pas au standard attendu, et la plage d’impulsions ne reflète pas directement l’angle demandé. D’où l’usage habituel de la bibliothèque Servo.h, qui gère ses propres timers pour créer des impulsions adaptées.
Une fois ce point clarifié, il devient plus simple de choisir la bonne approche :
- analogWrite() → contrôle de puissance (LED, moteurs DC, résistances chauffantes, etc.).
- Servo.h → pilotage d’angle ou de position d’un servomoteur standard.
Pour aller plus loin dans le contrôle de servos via Arduino, un guide spécialisé fournit des exemples de code plus aboutis, notamment sur la gestion de plusieurs servos en parallèle : fonctionnement et code pour servomoteur Arduino.
Limitations du PWM sur Arduino : courant, résolution et interaction avec les timers
Le PWM via analogWrite() propose un compromis intéressant entre simplicité et contrôle de puissance. Ce compromis s’accompagne toutefois de plusieurs limites qu’un débutant gagne à intégrer dès les premiers projets.
La première contrainte réside dans le courant maximal par broche. Les microcontrôleurs utilisés sur Arduino tolèrent en général une vingtaine de milliampères par broche, avec une limite globale sur l’ensemble des broches d’un même port. Au‑delà, les risques de surchauffe ou de dégradation augmentent.
Résolution et précision
La résolution de 8 bits suffit dans la plupart des cas, mais certains projets exigent des paliers plus fins. Un éclairage architectural, une régulation thermique très précise ou des applications audio avancées peuvent réclamer davantage de nuances. Dans ce cas, des solutions alternatives interviennent :
- Microcontrôleur avec PWM en 10 ou 12 bits.
- DAC externe (convertisseur numérique‑analogique dédié).
- Techniques de dithering ou de sur‑échantillonnage logiciel.
Par ailleurs, la relation entre valeur numérique et rendu perçu (luminosité, volume sonore) n’est pas toujours linéaire aux yeux ou aux oreilles humaines. Une courbe de correction (gamma, log, etc.) ajuste parfois le rendu pour refléter une variation plus régulière.
Timers partagés et bibliothèques concurrentes
Les timers matériels servent à plusieurs fonctions systèmes : génération du PWM, gestion de millis(), interruptions de base, bibliothèques de servos, librairies de sons, etc. Une bibliothèque qui reconfigure un timer influence directement les broches PWM associées.
Un projet qui combine plusieurs librairies (Servo, tone, moteurs, PWM modifié) doit donc examiner les timers affectés par chacune. Sans cette vérification, un changement de fréquence inattendu ou une sortie PWM figée en état haut ou bas survient facilement.
Approfondir le PWM : vers des projets plus avancés
Une fois les bases du PWM maîtrisées avec analogWrite(), LED et moteurs, les projets plus ambitieux explorent la modification des registres de timers pour ajuster la fréquence, la phase ou le mode de fonctionnement. Les microcontrôleurs utilisés sur Arduino offrent une marge d’adaptation intéressante : choix du prédiviseur, mode Fast ou Phase Correct, complémentarité des sorties, etc.
Cette personnalisation ouvre la voie à des applications plus exigeantes : alimentation à découpage, ponts en H haute puissance, filtres actifs, synthèse audio, contrôle de drivers LED avancés. Dans ces contextes, une compréhension solide du fonctionnement interne du PWM devient décisive.
Pour rester à l’aise dans cette montée en complexité, un guide matériel détaillé sur la carte utilisée (par exemple l’Arduino Nano) fournit des schémas de brochage, des références de timers et des exemples de codes optimisés. Une bonne connaissance de la base PWM se combine alors avec une lecture plus pointue de la documentation technique.
En parallèle, certaines ressources pratiques sur la mise en œuvre du PWM pour des usages ciblés, comme le pilotage de LED ou de servos, complètent utilement l’apprentissage, par exemple ce tutoriel sur le PWM et les LED ou encore les exemples de code pour servomoteur Arduino. Ces liens illustrent concrètement comment les notions de fréquence, de rapport cyclique et de résolution se traduisent dans des projets du quotidien.
