ESP32 PWM: Complete Guide to PWM, Pins, Frequency & Duty Cycle

What PWM is

PWM stands for Pulse Width Modulation. A pulse is the ON part of a digital signal. Width means how long that ON part lasts. Modulation means changing it.

An ESP32 GPIO pin normally has two simple output states: LOW and HIGH. PWM still uses those same two states, but repeats them quickly. If the pin is ON for most of each cycle, an LED looks bright. If the pin is ON for only a small part of each cycle, the LED looks dim.

That is the key idea: PWM does not create a true adjustable analog voltage on a GPIO pin. It creates an adjustable average effect by switching fast.

PWM vs simple digital HIGH/LOW

If you have not uploaded code yet, start with the ESP32 Arduino IDE guide. If you have never controlled a GPIO output, build Blink an LED with ESP32 first.

ESP32 PWM terminology

Frequency

PWM frequency is how many complete ON/OFF cycles happen each second. A frequency of 5000 Hz means 5000 PWM cycles per second. LED dimming usually uses a frequency high enough that your eyes do not see obvious blinking. Buzzers, motor drivers, servos, and LEDs may need different frequency ranges, so match the load instead of assuming one value fits everything.

Duty cycle

Duty cycle is the ON-time portion of each cycle. A 25% duty cycle is ON for one quarter of the cycle and OFF for the rest. A 75% duty cycle is ON for most of the cycle. For an LED, higher duty usually looks brighter.

Resolution

Resolution controls how many duty steps are available. With 8-bit resolution, duty can range from 0 to 255. With 10-bit resolution, duty can range from 0 to 1023. More resolution gives finer brightness steps, but very high frequency and high resolution compete for timing resources.

Channels

The ESP32 LEDC peripheral uses PWM channels/timers internally. Older Arduino-ESP32 examples made you choose channel numbers manually. Current Arduino-ESP32 examples can attach PWM directly to a pin with ledcAttach(pin, frequency, resolution), and then write duty with ledcWrite(pin, duty). The underlying channel idea still matters when you run many PWM outputs, but beginners usually start with one pin.

ESP32 PWM pins and GPIO selection

Many output-capable ESP32 GPIO pins can generate LEDC PWM. For a first LED brightness example, use a common output-capable pin such as GPIO18. Avoid these beginner mistakes:

• Do not use input-only pins such as GPIO34-GPIO39 on classic ESP32 boards for PWM output.
• Do not use pins connected to internal flash on classic ESP32 modules.
• Be careful with boot/strapping pins if external wiring could hold them at the wrong level during reset.
• Do not assume every ESP32 variant exposes the same safe pins in the same place. Check your board label and the ESP32 DevKit guide.

Simple LED brightness wiring

This guide uses an LED because it makes PWM visible immediately. Wire it as a low-current learning circuit:

• ESP32 GPIO18 -> 220 ohm or 330 ohm resistor
• Resistor -> LED anode, the longer leg
• LED cathode, the shorter leg -> ESP32 GND

The resistor is required. PWM changes average brightness, but when the pin is ON, the LED still needs current limiting.

ESP32 PWM with Arduino IDE

Current Arduino-ESP32 cores support the pin-based LEDC helpers shown below. This keeps the beginner sketch clear: attach PWM to a pin, then write duty values to that same pin.

const int PWM_PIN = 18;
  const int PWM_FREQUENCY = 5000;
  const int PWM_RESOLUTION = 8;
  const int DUTY_MAX = (1 << PWM_RESOLUTION) - 1;

  void setup() {
    Serial.begin(115200);

    bool attached = ledcAttach(PWM_PIN, PWM_FREQUENCY, PWM_RESOLUTION);
    if (!attached) {
      Serial.println("PWM attach failed. Check board selection and pin.");
      while (true) {
        delay(1000);
      }
    }

    Serial.println("ESP32 PWM fade ready");
  }

  void loop() {
    for (int duty = 0; duty <= DUTY_MAX; duty += 5) {
      ledcWrite(PWM_PIN, duty);
      Serial.print("Duty: ");
      Serial.println(duty);
      delay(20);
    }

    for (int duty = DUTY_MAX; duty >= 0; duty -= 5) {
      ledcWrite(PWM_PIN, duty);
      Serial.print("Duty: ");
      Serial.println(duty);
      delay(20);
    }
  }

Expected behavior: the LED fades from off to bright, then bright to off. Serial Monitor prints changing duty values from 0 toward 255 and back down because this example uses 8-bit resolution.

How to change duty cycle

With 8-bit resolution, these fixed duty values are easy to understand:

To hold one brightness level, call ledcWrite(PWM_PIN, 128) in your code. To build a dimmer, change the duty value when a button event, analog reading, or web command changes.

PWM frequency and resolution tradeoff

Frequency and resolution are connected. A very high PWM frequency leaves less timing room for very fine duty steps. A very high resolution gives more duty steps, but may limit how high the frequency can be. For beginner LED dimming, 5000 Hz and 8-bit resolution are a practical starting point.

If an LED flickers, try a higher frequency or check for loose wiring. If brightness jumps feel coarse, try more resolution or smaller duty changes. If a motor driver behaves strangely, read that driver module's documentation before changing random PWM values.

Legacy Arduino-ESP32 PWM examples

You will still see older tutorials using code like this:

ledcSetup(channel, frequency, resolution);
  ledcAttachPin(pin, channel);
  ledcWrite(channel, duty);

That style is common in older Arduino-ESP32 core examples and in some existing learning material. For new code on current Arduino-ESP32 cores, prefer the pin-based style:

ledcAttach(pin, frequency, resolution);
  ledcWrite(pin, duty);

If old code fails with an error such as ledcAttachPin was not declared, check your installed ESP32 board package version and update the PWM API style.

Common PWM mistakes

• Using PWM without a resistor: an LED still needs current limiting.
• Expecting true analog voltage: PWM is fast switching, not a DAC output.
• Driving motors directly: GPIO pins send control signals, not motor power.
• Choosing input-only GPIO: input-only pins cannot drive PWM output.
• Confusing frequency with brightness: duty cycle controls average brightness; frequency controls switching speed.
• Mixing old and new LEDC APIs: keep code style consistent for your ESP32 Arduino core version.

Troubleshooting ESP32 PWM

Practical next steps

Use the idea here in real ESP32 Engine builds:

• PWM Fundamentals - hands-on LED fade mission with wiring details.
• Analog Inputs - read a changing value that can later control PWM brightness.
• Button Controls LED - use button events to step through duty levels.
• ESP32 RGB LED Pattern Controller - PWM-style brightness mixing for color effects.
• ESP32 WiFi Robot Controller - motor-driver control concepts with separate motor power.
• ESP32 Line Following Robot - robot outputs and sensor decisions.
• ESP32 Smart Street Light - practical lighting automation where dimming concepts matter.