PWM-Controlled Loads: How Duty Cycle Replaces Linear Voltage in Embedded Design

A pwm-controlled circuit regulates power delivery not by dropping voltage like a resistor, but by rapidly switching the full supply voltage on and off at a specific duty cycle. When you program a microcontroller to run a 12V cooling fan at '50% speed', it does not output 6V. Instead, it slams the full 12V into the fan for 10 milliseconds, cuts it to 0V for 10 milliseconds, and repeats. The mechanical inertia of the fan blades averages this rapid pulsing into a smooth, reduced-speed rotation. This switching approach fundamentally changes what happens in a real circuit: it shifts the system from burning excess energy as waste heat to delivering only the exact energy the load requires, pushing electrical efficiency near 100%.

The Core Mechanism: Duty Cycle vs. Analog Voltage

To understand why embedded designers rely on PWM (Pulse Width Modulation) instead of linear voltage reduction, we have to look at the thermal math. The duty cycle is simply the percentage of time the signal is 'HIGH' (on) during one complete period. A 25% duty cycle means the switch is closed for a quarter of the time and open for the remaining three-quarters.

Let us run a worked numeric example using a common DIY load: a 12V, 5A (60W) LED light strip. Suppose you want to dim this strip to 50% brightness.

This massive divergence in thermal performance is why PWM is the undisputed standard for power control in modern electronics. The table below breaks down how different control methods handle this exact 60W load.

Where You Meet PWM-Controlled Devices in Practice

You will encounter PWM control across almost every embedded subsystem, but the implementation details—specifically the switching frequency—change drastically depending on the physical nature of the load.

LED Lighting and Display Backlights

For LEDs, PWM controls perceived brightness. The human eye integrates light over time, so a 1kHz PWM signal looks like a steady, dimmed light. However, if you are building a device that will be recorded on video, you must push the PWM frequency above 3kHz to 5kHz. Lower frequencies interact with the rolling shutters of CMOS camera sensors, causing visible horizontal banding or flicker on screen. The Espressif LEDC peripheral allows you to dial in these exact frequencies independently of the main CPU.

DC Motors and Solenoids

Motors are inductive loads. When you switch an inductive load off, the collapsing magnetic field generates a high-voltage spike. PWM-controlled motor circuits require a flyback diode (or a body diode in the MOSFET) to recirculate this current. For DC motors, the PWM frequency is typically set between 15kHz and 20kHz. Why? Because frequencies below 15kHz fall into the human hearing range, causing the motor windings to physically vibrate and emit an audible, high-pitched whine. Pushing it to 20kHz moves the switching noise just past the upper limit of human hearing.

Resistive Heating Elements

Heaters (like 3D printer hotends or sous-vide water baths) have massive thermal inertia. They take seconds or minutes to change temperature. Therefore, hitting them with a 20kHz PWM signal is unnecessary and only generates electromagnetic interference (EMI). Instead, embedded systems use 'Slow PWM' or 'Time Proportioning Control', switching the load on and off at 1Hz to 10Hz (a 1-second period). This is usually handled by a Solid State Relay (SSR) rather than a raw MOSFET.

What People Commonly Confuse PWM-Control With

Because the term 'PWM' is thrown around loosely in hobbyist forums, it is frequently conflated with two entirely different concepts.

Confusion 1: PWM vs. Buck Conversion (Analog Smoothing)
A raw PWM signal is a square wave—it is either fully ON or fully OFF. It is not a reduced DC voltage. Many beginners measure a 50% duty cycle 12V PWM signal with a multimeter, see '6V' on the screen, and assume the circuit is outputting 6V DC. The multimeter is just averaging the square wave. If you actually need a smooth 6V DC rail to power a sensitive analog sensor, you do not use raw PWM; you use a Buck Converter. A buck converter uses PWM internally, but adds an inductor and capacitor (an LC filter) to smooth the pulses into a flat DC line. Raw PWM is only for loads that can average the pulses themselves (motors, LEDs, heaters).

Confusion 2: Power PWM vs. Servo/RC PWM
When an introductory electronics article mentions PWM, they usually mean power control (varying duty cycle from 0-100% at 1kHz+). However, in the RC (radio control) and robotics world, 'PWM' refers to the control signal used for hobby servos (like the SG90). Servo PWM operates at a fixed 50Hz (a 20ms period), and the absolute pulse width (usually between 1ms and 2ms) dictates the shaft angle, not the duty cycle percentage. Sending a 50% duty cycle signal to a standard hobby servo will not move it to 180 degrees; it will send a 10ms pulse, which is wildly out of spec and will likely cause the servo to jitter or strip its internal gears.

Sizing the Switch: Logic-Level MOSFETs for 3.3V Microcontrollers

The most common point of failure in DIY pwm-controlled circuits is selecting the wrong switching transistor. The Arduino Uno era popularized the IRF520 MOSFET module. The IRF520 is a 'standard' MOSFET, meaning it requires a Gate-to-Source voltage (Vgs) of 10V to fully turn on and achieve its advertised low resistance.

Modern microcontrollers like the ESP32, Raspberry Pi Pico, and STM32 operate on 3.3V logic. If you drive an IRF520 with 3.3V, the gate never fully opens. The MOSFET enters its linear (resistive) region, its internal resistance skyrockets, and it begins dissipating massive amounts of heat—defeating the entire purpose of using PWM. In extreme cases, the silicon die melts and shorts the power supply directly to ground.

For 3.3V embedded systems, you must specify Logic-Level MOSFETs. These are designated with an 'L' in the part number (e.g., IRLZ44N instead of IRF520, or IRLB8721). A logic-level MOSFET is engineered to achieve its minimum Rds_on at a Vgs of 4.5V or even 2.5V, making it perfectly compatible with 3.3V GPIO pins.

Here is how you implement a stable, 5kHz PWM control loop on an ESP32 using the modern Arduino Core v3.x API, which deprecated the older channel-based setup in favor of direct pin attachment:

// ESP32 Arduino Core v3.x PWM API for Logic-Level MOSFET Control
const int PWM_PIN = 18;      // GPIO 18 (supports high-speed PWM)
const int PWM_FREQ = 5000;   // 5kHz (avoids camera flicker on LEDs)
const int PWM_RES = 8;       // 8-bit resolution (0 to 255)

void setup() {
  // Attach the PWM peripheral directly to the pin
  ledcAttach(PWM_PIN, PWM_FREQ, PWM_RES);
  
  // Set initial duty cycle to ~50% (127 out of 255)
  ledcWrite(PWM_PIN, 127); 
}

void loop() {
  // Example: Fade up over 2 seconds
  for (int duty = 0; duty <= 255; duty++) {
    ledcWrite(PWM_PIN, duty);
    delay(8); 
  }
  delay(1000);
}

By pairing a logic-level MOSFET with the ESP32's dedicated LEDC hardware peripheral, you offload the timing critical switching from the CPU. The hardware peripheral maintains the exact 5000Hz square wave with zero jitter, even if your main loop is busy handling WiFi stacks or reading I2C sensors, ensuring your pwm-controlled load receives clean, efficient, and thermally safe power.