PWM verstehen: Frequenz, Duty-Cycle & Anwendungen im Alltag

PWM (Pulsweitenmodulation) steuert Leistung über die Einschaltzeit eines digitalen Signals. Statt analoge Spannungen auszugeben, schaltet die MCU schnell zwischen HIGH und LOW. Die mittlere Leistung ergibt sich aus dem Duty-Cycle (Tastgrad) bei gegebener Frequenz.

Kurzüberblick

• Duty-Cycle D = ton / T (0…1) → mittlere Spannung Ū = D · UV an rein ohmscher Last.
• Frequenz f = 1 / T → bestimmt Flimmern/Brummen und Anforderungen an Treiber & Filter.
• Auflösung: Anzahl diskreter Duty-Cycle-Stufen (z. B. 8-Bit = 256 Stufen).
• Hardware-PWM (Timer) ist jitterarm und effizienter als Software-PWM.

Formeln & Praxiswerte

• LED-Dimmung: 500 Hz – 2 kHz (keine Wahrnehmung, wenig EMV-Probleme).
• DC-Motor: 10 kHz – 25 kHz (außerhalb des Hörbereichs; Treiberverluste beachten).
• Analog-Ersatz: PWM + Tiefpass (RC) → Glättung auf Ū.

Arduino: LED dimmen mit analogWrite()

Bei klassischen AVR-Arduinos liefert analogWrite() 8-Bit PWM, Frequenz je nach Pin/Timer (~490/976 Hz standardmäßig).

const int PIN_PWM = 9;  // LED an D9 + Vorwiderstand

void setup() {
  pinMode(PIN_PWM, OUTPUT);
}

void loop() {
  // sanft hoch und runter dimmen
  for (int d=0; d<=255; ++d) {
    analogWrite(PIN_PWM, d);  // Duty 0..255
    delay(5);
  }
  for (int d=255; d>=0; --d) {
    analogWrite(PIN_PWM, d);
    delay(5);
  }
}
    

ESP32: Hochauflösende PWM mit LEDC

Der ESP32 besitzt mehrere LEDC-Kanäle mit einstellbarer Frequenz/Bit-Tiefe – ideal für flackerfreie Dimmung oder Motor-PWM.

#include <Arduino.h>

const int PIN_LED = 5;
const int PWM_FREQ = 20000;     // 20 kHz (außerhalb Hörbereich)
const int PWM_BITS = 12;        // 0..4095
const int PWM_CH = 0;

void setup() {
  ledcSetup(PWM_CH, PWM_FREQ, PWM_BITS);
  ledcAttachPin(PIN_LED, PWM_CH);
}

void loop() {
  for (int d=0; d<=4095; d+=16) {
    ledcWrite(PWM_CH, d);
    delay(3);
  }
}
    

RC-Tiefpass für „analoge“ Spannung

Ein einfacher RC-Filter glättet PWM zu einer quasi-analogen Spannung. Die Eckfrequenz fc=1/(2πRC) sollte deutlich unterhalb der PWM-Frequenz liegen (z. B. f/fc ≥ 20).

def fc_for_pwm(f_pwm, ratio=20):
    """Wähle Eckfrequenz fc so, dass f_pwm / fc = ratio."""
    return f_pwm / ratio

def rc_from_fc(fc, C=1e-6):
    # R = 1/(2π f C)
    import math
    return 1 / (2*math.pi*fc*C)

fc = fc_for_pwm(20000, 40)  # PWM 20 kHz, Verhältnis 40
R = rc_from_fc(fc, 0.47e-6)       # C = 0,47 µF
print("fc=", fc, "Hz, R≈", R, "Ohm")
    

Typische Anwendungen

• LED-Dimmung über Vorwiderstand oder Konstantstromtreiber.
• Motor-Drehzahl via MOSFET/Brückentreiber (Low-/High-Side, Halbbrücke).
• „Analogausgang“ per PWM+RC → z. B. Referenzspannung, Audio-Prototyping.

PWM vs. DAC vs. PFM – kurz verglichen

Fehler, die man nur einmal macht

1. Frequenz zu niedrig → sichtbares Flimmern/Brummen.
2. Kein gemeinsamer GND zwischen MCU und Lasttreiber.
3. Zu wenig Auflösung → sichtbare Helligkeitsstufen (Banding).
4. EMV-Spitzen durch lange Leitungen/steile Flanken → Gate-Widerstand, Snubber, sauberes Layout nutzen.
5. Treiber unterschätzt bei hohen Strömen/Frequenzen → dedizierter MOSFET-Treiber statt direkter MCU-Ansteuerung.

Checkliste

• Frequenz passend zur Anwendung (LED/Motor/Audio)
• Ausreichende Bit-Auflösung
• Hardware-PWM bevorzugen, Timer-Konflikte prüfen
• Gemeinsame Masse, saubere Rückstrompfade
• Treiber & Schutz (MOSFET, Diode, Snubber) eingeplant
• Optional RC-Filter korrekt dimensioniert

Fazit

PWM ist das Schweizer Taschenmesser der Leistungsteuerung: flexibel, effizient und mit jedem Mikrocontroller nutzbar. Mit passender Frequenz, genügend Auflösung und einem sauberen Treiber erreichst du flackerfreie LEDs, leise Motoren und stabile „Analog“-Spannungen.

Tipp: Für LED-Dimmung reichen 1 kHz/8-Bit oft aus; für Motoren lieber ≥20 kHz und einen Gate-Treiber verwenden.