Wat is PWM? Een gids voor analogWrite, duty cycle en frequentie op Arduino
Wat is PWM (pulsbreedtemodulatie) en hoe werkt het? Duty cycle en frequentie, Arduino-PWM-pins, ledhelderheid en motorsnelheid met analogWrite, het verschil met servo's, ESP32 LEDC en PWM op de Raspberry Pi Pico.
De digitale pins van Arduino kennen maar twee standen: 0 V of 5 V. Hoe dim je dan een led naar halve helderheid of laat je een motor langzaam draaien? Het antwoord is PWM (Pulse Width Modulation, pulsbreedtemodulatie). De pin wordt razendsnel aan- en uitgeschakeld, en door de verhouding van de tijd dat hij aan staat te veranderen, stel je het gemiddelde vermogen in dat naar de belasting gaat. Ledverlichting dimmen, motorsnelheid regelen, servo's aansturen, geluid maken en zelfs telefoonopladers gebruiken deze techniek.

Hoe werkt PWM?
Een PWM-signaal is een blokgolf: het is een tijdje HIGH, daarna LOW, en die cyclus herhaalt zich steeds weer. De lengte van één aan-uitcyclus is de periode, en het deel van de periode dat het signaal HIGH blijft is de duty cycle. Bij een duty cycle van 25% staat het signaal een kwart van de tijd aan, dus gedraagt een pin van 5 V zich gemiddeld als 1,25 V. De led knippert ongeveer 490 keer per seconde; je oog kan dat niet volgen en ziet alleen de gemiddelde helderheid. Een motor strijkt de pulsen door zijn traagheid glad en draait op de gemiddelde snelheid.
| Duty cycle | analogWrite-waarde | Gemiddelde spanning (5 V) | LED |
|---|---|---|---|
| 0% | 0 | 0 V | Uit |
| 25% | 64 | 1,25 V | Gedimd |
| 50% | 127 | 2,5 V | Half helder |
| 75% | 191 | 3,75 V | Helder |
| 100% | 255 | 5 V | Volle helderheid |
Onze ogen reageren niet lineair op licht: we merken veranderingen bij lage niveaus heel goed op en veranderingen bij hoge niveaus veel minder. Daarom lijkt een led met 50% duty cycle veel helderder dan half. Voor dimmen dat natuurlijk oogt gebruik je de gammacorrectie hieronder.
Frequentie: hoe snel is PWM?
Frequentie is hoe vaak per seconde het signaal aan- en uitgaat. Op de Arduino Uno draaien pin 5 en 6 op ongeveer 980 Hz en pin 3, 9, 10 en 11 op ongeveer 490 Hz. Voor leds is die frequentie ruim voldoende. Bij motoren ligt 490 Hz echter binnen het hoorbare bereik en kan de motor een beetje piepen; op de ESP32 en Pico kun je de frequentie verhogen naar 20 kHz om het te dempen. Als je de frequentie veel hoger zet dan nodig, worden transistors en MOSFET's wel warm.
| Board | PWM-pins | Standaardfrequentie | Resolutie |
|---|---|---|---|
| Arduino Uno / Nano | 3, 5, 6, 9, 10, 11 | 490 Hz (5 en 6: 980 Hz) | 8-bit (0–255) |
| Arduino Mega | 2–13, 44–46 | 490 Hz (4 en 13: 980 Hz) | 8-bit (0–255) |
| ESP32 | Bijna elke uitgangspin | Instelbaar (analogWrite: 1 kHz) | 1–16-bit |
| Raspberry Pi Pico | Elke GPIO-pin | Instelbaar | 16-bit (0–65535) |
Ledhelderheid met analogWrite
Op Arduino genereer je PWM met analogWrite(pin, value), waarbij de waarde tussen 0 en 255 ligt. Ondanks de misleidende naam levert dit commando geen echte analoge spanning, maar PWM. Het werkt alleen op pins met een ~. De code hieronder laat een led langzaam in- en uitfaden voor een "ademend" effect:
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}Helderheid regelen met een potmeter
Als je een potmeter aansluit op A0, kun je de helderheid van de led met de hand instellen. analogRead() geeft een waarde van 0 tot 1023; door te delen door 4 krijg je het bereik van 0–255 dat analogWrite verwacht. De bedrading van een potmeter staat in Wat is een potentiometer?
1void loop() {
2 int pot = analogRead(A0); // 0–1023
3 analogWrite(9, pot / 4); // 0–255
4}Snelheid van een gelijkstroommotor met PWM
Zelfs een kleine gelijkstroommotor trekt honderden milliampères, terwijl een Arduino-pin veilig maar zo'n 20 mA kan leveren. De motor stuur je dus aan via een transistor, MOSFET of een motordriver zoals de L298N, en het PWM-signaal gaat naar de snelheidsingang van de driver. Op de L298N is dat de ENA-pin (en ENB voor de tweede motor); om PWM te gebruiken moet je de jumper erop verwijderen. De pins IN1 en IN2 bepalen de draairichting.

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}Zijn servomotoren en PWM hetzelfde?
Servomotoren worden ook met pulsen aangestuurd, maar de logica is anders: de positie wordt bepaald door de breedte van de puls, niet door de duty cycle. Een servo verwacht 50 pulsen per seconde (50 Hz); een puls van 1 milliseconde betekent ongeveer 0°, 1,5 ms betekent 90° en 2 ms betekent 180°. analogWrite kan deze timing niet leveren, daarom gebruiken servo's de Servo-bibliotheek. Details staan in Wat is een servomotor?
Een echte analoge spanning uit PWM: het RC-filter
Soms heb je echt een stabiele spanning nodig, bijvoorbeeld om een opamp een referentie te geven of om een audio-uitgang te krijgen. Dan stuur je de PWM door een laagdoorlaatfilter van een weerstand en een condensator. Met 10 kΩ en 10 µF is de tijdconstante 0,1 seconde; de uitgang is vrij glad maar reageert traag op veranderingen. Met de rekenhulp RC-tijdconstante kun je verschillende waarden uitproberen. De klassieke ESP32 heeft ook twee DAC's op GPIO 25 en 26 die een echte analoge uitgang geven.
PWM op de ESP32: LEDC
Op de ESP32 wordt PWM gegenereerd door hardware die LEDC heet, en je kiest zelf de frequentie en resolutie. In Arduino core 3.x gebruik je ledcAttach(pin, frequency, resolution) en ledcWrite(pin, value); oudere 2.x-versies hadden de kanaalgebaseerde commando's ledcSetup en ledcAttachPin. Het voorbeeld hieronder laat een led faden op 5 kHz met een resolutie van 8 bit:
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}PWM op de Raspberry Pi Pico (MicroPython)
Elke GPIO-pin van de Pico kan PWM uitsturen. In MicroPython gebruik je de klasse PWM, met freq() voor de frequentie en duty_u16() voor de duty cycle, die waarden van 0 tot 65535 accepteert:
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)Projectideeën met PWM
- Ademende led: een statuslampje dat langzaam in- en uitfadet, zoals apparaten in stand-by.
- Dimbare bureaulamp: een ledlamp waarvan je de helderheid met een potmeter instelt.
- Ventilator met temperatuurregeling: laat een ventilator sneller draaien naarmate de temperatuur die een DHT11 meet stijgt.
- Kleuren mengen: maak miljoenen kleuren op een RGB-led met drie PWM-kanalen.
- Robotauto: maak bochten soepeler door de snelheid van twee motoren apart in te stellen.
- Zonsopganglamp: laat een lamp 15 minuten voor je wekker langzaam feller worden.
Veelgemaakte fouten en hoe je ze oplost
- analogWrite op een pin zonder PWM: op de Uno kunnen pins zonder ~ alleen aan of uit zijn; 128 en hoger telt als aan, alles lager als uit.
- Pin 9 en 10 met de Servo-bibliotheek: op de Uno gebruikt de Servo-bibliotheek Timer1 en schakelt PWM op deze twee pins uit; verplaats je led of motor naar een andere PWM-pin.
- Pin 3 en 11 met tone(): tone() gebruikt Timer2 en verstoort PWM op deze pins.
- Een motor rechtstreeks op een pin aansluiten: gebruik altijd een transistor, MOSFET of motordriver.
- Overflow in de gammaberekening: v * v overschrijdt de int-limiet; voeg de (long)-cast toe.
- PWM zien als echt analoog: een multimeter toont het gemiddelde, maar het signaal schommelt nog steeds tussen 0 en 5 V; gebruik een RC-filter of een DAC voor gevoelige schakelingen.
PWM is een van de nuttigste ideeën die je op Arduino leert: leds, motoren, ventilatoren en luidsprekers worden allemaal met deze simpele truc aangestuurd. Voor de basis kun je Wat is een led? lezen; in de BlueGrays-app vind je projecten met PWM-ledfading, helderheid met een potmeter en RGB-kleurfading stap voor stap met code.
Veelgestelde vragen
Wat is PWM in het kort?
PWM is een manier om het gemiddelde vermogen naar een belasting in te stellen door een pin razendsnel aan en uit te schakelen en de verhouding van de tijd dat hij aan staat (de duty cycle) te veranderen. Zo kan een digitale pin die alleen 0 of 5 V kan uitsturen een led dimmen of een motor vertragen.
Welke pins ondersteunen PWM op de Arduino Uno?
Op de Uno en Nano ondersteunen pin 3, 5, 6, 9, 10 en 11 PWM; ze zijn op het board gemarkeerd met een ~. Op de Mega kunnen pin 2–13 en 44–46 PWM uitsturen.
Geeft analogWrite een echte analoge uitgang?
Nee. analogWrite levert PWM; de pin schakelt razendsnel tussen 0 en 5 V. Het stelt de gemiddelde spanning in, maar voor een echt stabiele spanning moet je de PWM door een RC-filter sturen of een DAC gebruiken, zoals die op de ESP32.
Hoe bereken je de duty cycle?
De duty cycle is de tijd dat het signaal HIGH blijft gedeeld door de hele periode: (HIGH-tijd / periode) × 100. Op Arduino vind je hem door de analogWrite-waarde te delen door 255 en te vermenigvuldigen met 100; 64 is bijvoorbeeld ongeveer 25%.
Hoe verander ik de PWM-frequentie op Arduino?
analogWrite verandert de frequentie niet. Op de Uno kun je hem aanpassen door de timerregisters te wijzigen (bijvoorbeeld TCCR1B voor pin 9 en 10), maar dat kan millis en bibliotheken beïnvloeden. Op de ESP32 stel je de frequentie rechtstreeks in met ledcAttach, en op de Pico met freq().
Kan PWM een led beschadigen?
Nee. De led brandt tijdens elke puls op volle stroom, maar die stroom wordt al beperkt door de voorschakelweerstand, en de gemiddelde stroom daalt evenredig met de duty cycle. Zolang je de juiste weerstand gebruikt, verkort PWM de levensduur van de led niet.
Projecten om hierna te bouwen
Alle projecten bekijken
ESP32-led dimmen met PWM
De helderheid van de led soepel veranderen van 0 naar max en van max naar 0. We sturen PWM aan met analogWrite() zoals bij Arduino; dezelfde syntaxis werkt zonder problemen met ESP32 Arduino Core 3.0+. Een pindefinitie, pinMode en analogWrite zijn genoeg.

Raspberry Pi Pico PWM-led-fade (ademeffect)
De led knippert niet meer alleen, hij ademt! Met de PWM (Pulse Width Modulation) van de Raspberry Pi Pico wordt de helderheid van de led langzaam hoger en dan langzaam weer lager: een rustig "ademeffect" zoals het lampje van een slapende laptop. Je leert de klasse machine.PWM, de 16-bits helderheidswaarde van 0–65535 met duty_u16() en de PWM-frequentie.

ESP32 ledhelderheid regelen met een potmeter (analoog → PWM)
In dit project regel je de helderheid van een led analoog met een potmeter. De ADC-pin van de ESP32 leest de spanning van 0–3,3 V van de potmeter; die waarde wordt omgezet in een PWM-signaal (pulsbreedtemodulatie) en naar de led gestuurd. Als je aan de potmeter draait, wordt de led dus geleidelijk helderder en zwakker. Met Arduino Core 3.0+ kun je analogWrite() direct gebruiken; op de ESP32-S2/S3 ligt de ADC-resolutie vast op 12 bit.

Vloeiende kleurovergang met een RGB-led
Een enkele RGB-led gaat langzaam van rood naar groen, van groen naar blauw en weer terug naar rood, en doorloopt zo zonder te stoppen de regenboog.

ESP32 RGB-led aansturen
Onbeperkt kleuren maken met één RGB-led in plaats van 3 aparte leds. Net als op Arduino stel je met analogWrite() de R/G/B-waarden in en maak je een regenboogovergang. Kleurtheorie (zoals red+green=yellow) zie je in de praktijk.

Raspberry Pi Pico RGB-led-kleurcyclus (3-kanaals PWM)
Eén led, miljoenen kleuren! Een RGB-led bevat eigenlijk 3 aparte leds: rood, groen en blauw. Stel de helderheid van elk ervan apart in met de 3 PWM-kanalen van de Pico en de kleuren mengen: rood + groen = geel, groen + blauw = cyaan, alle drie = wit. In dit project doorloopt de led 8 kleuren.

ESP32-servomotor (bediening met potentiometer)
In dit project bedien je een SG90-servomotor met een potentiometer. De analoge waarde van de potentiometer zet je om naar het bereik van 0–180 graden en zo stel je de servohoek in. De ESP32Servo-bibliotheek maakt het servosignaal op geschikte GPIO-pinnen van de ESP32 die als uitgang kunnen dienen; dit project gebruikt GPIO 18. Dit is een basismethode voor robotarmen, cameragimbals en automatische deurmechanismen.

ESP32 kleurenmixlamp (3 potmeters + RGB-led + OLED)
Een slimme kleurenmixlamp: draai aan 3 potmeters op de ESP32 en mix elke kleur die je wilt! Terwijl je aan de rode, groene en blauwe potmeter draait, verandert de RGB-led met gemeenschappelijke kathode meteen van kleur. Het SSD1306 OLED-display toont per kanaal de waarde van 0-255, vulbalken en de HEX-webkleurcode (zoals #FF8040) live.
Meer artikelen
BlueGrays-app
Bouw deze schakeling stap voor stap op je telefoon
Schakelschema, code en onderdelenlijst op één scherm. Meer dan 500 Arduino-, ESP32- en Pico-projecten om te bouwen.
Scan met je telefoon
Richt je camera op de code en de appstore van je telefoon opent.
of open de store

