Was ist PWM? Ratgeber zu analogWrite, Tastgrad und Frequenz am Arduino

Die Digitalpins des Arduino kennen nur zwei Zustände: 0 V oder 5 V. Wie dimmst du dann eine LED auf halbe Helligkeit oder lässt einen Motor langsam drehen? Die Antwort heißt PWM (Pulsweitenmodulation). Der Pin wird sehr schnell ein- und ausgeschaltet, und über den Anteil der Einschaltzeit stellst du die mittlere Leistung an der Last ein. LED-Dimmer, Motordrehzahlregelung, Servoansteuerung, Tonerzeugung und sogar Handy-Ladegeräte nutzen diese Technik.

Wie funktioniert PWM?

Ein PWM-Signal ist ein Rechtecksignal: eine Weile HIGH, dann LOW, und das wiederholt sich ständig. Die Dauer eines Ein-Aus-Zyklus heißt Periode, der Anteil der Periode, in dem das Signal HIGH ist, Tastgrad (Duty Cycle). Bei 25 % Tastgrad ist das Signal ein Viertel der Zeit an, ein 5-V-Pin wirkt dann im Mittel wie 1,25 V. Die LED blinkt etwa 490-mal pro Sekunde; das Auge kommt nicht hinterher und sieht nur die mittlere Helligkeit. Ein Motor glättet die Pulse dank seiner Trägheit und dreht mit der mittleren Geschwindigkeit.

Unser Auge reagiert nicht linear auf Licht: Änderungen bei wenig Licht bemerkt es sehr gut, bei viel Licht deutlich weniger. Deshalb wirkt eine LED bei 50 % Tastgrad viel heller als halb hell. Für ein natürlich wirkendes Dimmen nutzt man die unten gezeigte Gammakorrektur.

Frequenz: Wie schnell ist PWM?

Die Frequenz gibt an, wie oft pro Sekunde das Signal ein- und ausschaltet. Beim Arduino Uno arbeiten die Pins 5 und 6 mit etwa 980 Hz, die Pins 3, 9, 10 und 11 mit etwa 490 Hz. Für LEDs reicht das völlig. Bei Motoren liegen 490 Hz aber im hörbaren Bereich, und der Motor kann leise pfeifen; am ESP32 und Pico kannst du die Frequenz auf 20 kHz anheben und ihn so leise machen. Eine unnötig hohe Frequenz lässt Transistoren und MOSFETs allerdings warm werden.

LED-Helligkeit mit analogWrite

Am Arduino erzeugst du PWM mit analogWrite(pin, wert), der Wert liegt zwischen 0 und 255. Trotz des irreführenden Namens erzeugt der Befehl keine echte Analogspannung, sondern PWM. Er funktioniert nur an Pins mit ~-Zeichen. Der folgende Code blendet eine LED langsam ein und aus und erzeugt so einen "atmenden" Effekt:

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}

Helligkeit mit einem Potentiometer regeln

Schließt du ein Potentiometer an A0 an, stellst du die Helligkeit der LED von Hand ein. analogRead() liefert 0–1023; geteilt durch 4 ergibt das den Bereich 0–255, den analogWrite erwartet. Den Anschluss eines Potentiometers erklärt Was ist ein Potentiometer?

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

Motordrehzahl mit PWM

Schon ein kleiner Gleichstrommotor zieht Hunderte Milliampere, ein Arduino-Pin liefert aber nur etwa 20 mA sicher. Der Motor wird deshalb über einen Transistor, MOSFET oder einen Motortreiber wie den L298N betrieben, und das PWM-Signal geht an den Drehzahleingang des Treibers. Beim L298N ist das der Pin ENA (und ENB für den zweiten Motor); für PWM musst du den Jumper darauf entfernen. Die Pins IN1 und IN2 legen die Drehrichtung fest.

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}

Sind Servomotoren und PWM dasselbe?

Auch Servos werden mit Pulsen gesteuert, aber nach einem anderen Prinzip: Die Position wird nicht durch den Tastgrad, sondern durch die Pulsbreite bestimmt. Ein Servo erwartet 50 Pulse pro Sekunde (50 Hz); ein Puls von 1 Millisekunde bedeutet etwa 0°, 1,5 ms 90° und 2 ms 180°. analogWrite kann dieses Timing nicht erzeugen, deshalb nutzt man für Servos die Bibliothek Servo. Einzelheiten stehen in Was ist ein Servomotor?

Echte Analogspannung aus PWM: der RC-Filter

Manchmal brauchst du wirklich eine konstante Spannung, etwa als Referenz für einen Operationsverstärker oder für einen Audioausgang. Dann schickst du das PWM-Signal durch einen Tiefpass aus Widerstand und Kondensator. Mit 10 kΩ und 10 µF beträgt die Zeitkonstante 0,1 Sekunden; der Ausgang ist recht glatt, reagiert aber langsam auf Änderungen. Verschiedene Werte probierst du mit dem Rechner RC-Zeitkonstante aus. Der klassische ESP32 hat außerdem an GPIO 25 und 26 zwei DACs mit echtem Analogausgang.

PWM am ESP32: LEDC

Am ESP32 erzeugt eine Hardware namens LEDC das PWM-Signal, und Frequenz sowie Auflösung legst du selbst fest. Im Arduino-Core 3.x nutzt du ledcAttach(pin, frequenz, aufloesung) und ledcWrite(pin, wert); ältere 2.x-Versionen hatten die kanalbasierten Befehle ledcSetup und ledcAttachPin. Das Beispiel unten blendet eine LED mit 5 kHz und 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 am Raspberry Pi Pico (MicroPython)

Am Pico kann jeder GPIO-Pin PWM ausgeben. In MicroPython nutzt du die Klasse PWM: Die Frequenz setzt du mit freq(), den Tastgrad mit duty_u16(), das Werte von 0 bis 65535 annimmt:

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)

Projektideen mit PWM

• Atmende LED: eine Statusleuchte, die wie Geräte im Standby langsam auf- und abblendet.
• Dimmbare Schreibtischlampe: eine LED-Lampe, deren Helligkeit du mit einem Potentiometer einstellst.
• Temperaturgesteuerter Lüfter: den Lüfter schneller drehen lassen, je wärmer es laut DHT11 wird.
• Farben mischen: mit drei PWM-Kanälen Millionen Farben auf einer RGB-LED erzeugen.
• Roboterauto: Kurven glätten, indem du die Drehzahl zweier Motoren getrennt einstellst.
• Sonnenaufgangslampe: das Licht vor dem Wecker über 15 Minuten langsam aufhellen.

Typische Fehler und ihre Lösungen

• analogWrite an einem Pin ohne PWM: Beim Uno sind Pins ohne ~ nur an oder aus; 128 und mehr gilt als an, alles darunter als aus.
• Pins 9 und 10 mit der Servo-Bibliothek: Beim Uno nutzt die Servo-Bibliothek Timer1 und schaltet PWM an diesen beiden Pins ab; leg LED oder Motor auf einen anderen PWM-Pin.
• Pins 3 und 11 mit tone(): tone() nutzt Timer2 und stört PWM an diesen Pins.
• Motor direkt am Pin: Immer einen Transistor, MOSFET oder Motortreiber verwenden.
• Überlauf bei der Gammaberechnung: v * v überschreitet die int-Grenze; ergänze den (long)-Cast.
• PWM für echt analog halten: Das Multimeter zeigt den Mittelwert, das Signal springt aber weiter zwischen 0 und 5 V; für empfindliche Schaltungen RC-Filter oder DAC verwenden.

PWM ist eines der nützlichsten Konzepte, die du am Arduino lernst: LEDs, Motoren, Lüfter und Lautsprecher werden alle mit diesem einfachen Trick gesteuert. Für die Grundlagen lies Was ist eine LED?; in der BlueGrays-App findest du Projekte zu LED-Dimmen mit PWM, Helligkeit per Potentiometer und RGB-Farbübergängen Schritt für Schritt mit Code.