33 DAC and PWM: Loads, Filters, and Code

33.1 Start With the Decision

A PWM waveform may look smooth until the load draws current. Simulate the RC filter and load before choosing code and frequency.

33.2 Route Overview

This is part 2 of 3. Review DAC and PWM: Output Foundations for the preceding evidence.

33.3 Learning Objectives

• Calculate PWM ripple for an RC filter and load.
• Implement DAC and PWM output on Arduino and ESP32.

33.4 Chapter Roadmap

• PWM, DAC, and RC Simulator
• Load Experience with PWM/DAC
• Checkpoint: What the Load Sees
• Arduino DAC/PWM Implementation
• Arduino PWM Fade Code
• ESP32 DAC Output Code
• Try It: ESP32 DAC Output Simulation
• PWM as Pseudo-DAC
• Knowledge Check: PWM Duty Cycle
• PWM Duty Cycle & DAC Output Calculator
• PWM to Analog Conversion (RC Filter)
• Checkpoint: PWM Filtering
• PWM Low-Pass Filter Calculator
• Hands-On Labs
• ESP32 DAC Sweep Code
• Arduino PWM Dimming Code
• Common Pitfalls
• DAC Resolution vs Accuracy
• PWM Frequency Too Low
• For Kids: Meet the Sensor Squad!
• Matching Quiz: DAC and PWM Concepts
• PWM to Analog Pipeline Quiz
• Knowledge Check: DAC and PWM
• ESP32 DAC: Digital to 2.59V
• DAC vs PWM for LED Brightness
• DAC/PWM Actuator Control
• Checkpoint: Choosing DAC or PWM

33.5 PWM, DAC, and RC Simulator

The code examples below are useful when you have an Arduino, ESP32, Wokwi, or TinkerCAD open. Before writing code, use this simulator to see the core idea directly: PWM is a fast square wave, a load may average it, and an RC filter can turn it into a smoother voltage.

33.6 Arduino DAC/PWM Implementation

With the behavior visible, implementation is easier to judge: Arduino starts from PWM, while ESP32 gives PWM plus two true DAC pins.

// Fade LED using PWM (simulated DAC)
const int ledPin = 9;  // PWM-capable pin
int brightness = 0;

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

void loop() {
    analogWrite(ledPin, brightness);  // 0-255
    brightness = (brightness + 5) % 256;
    delay(30);
}

// True analog output on ESP32
void setup() {
    // No setup needed for DAC
}

void loop() {
    // Output ~1.66V on DAC channel 1 (GPIO25)
    dacWrite(25, 128);  // 0-255, Vref = 3.3V
    // 128/255 * 3.3V = 1.66V
}

33.7 PWM as Pseudo-DAC

Most microcontrollers lack true DACs but use PWM (Pulse Width Modulation) to simulate analog output.

How PWM Works:

• Rapidly toggle digital output between 0V and 5V
• Duty cycle (% time HIGH) determines average voltage
• Low-pass filter smooths PWM to quasi-analog signal

PWM Formula:

$V_{average} = V_{high} \times \frac{\text{Duty Cycle}}{100\%}$

Example: 50% Duty Cycle at 5V

$V_{average} = 5V \times 0.5 = 2.5V$

PWM Specifications:

• Resolution: Arduino Uno = 8-bit (0-255); ESP32 = 8-16 bit. Typical use: motor speed control and LED dimming.
• Frequency: Arduino Uno = 490-980 Hz; ESP32 = 1 Hz to 312 kHz at 8-bit resolution. Typical use: audio-oriented PWM usually needs >20 kHz to avoid audible whine.
• Channels: Arduino Uno = 6; ESP32 = 16. Typical use: multiple motors or LED channels at the same time.

Resolution, frequency, and channel count decide whether a design stays simple or needs extra hardware.

33.8 PWM to Analog Conversion (RC Filter)

For smooth analog output, add RC low-pass filter:

$f_{cutoff} = \frac{1}{2\pi RC}$

Example: Smoothing 1 kHz PWM for motor control

• Choose $f_c$ = 100 Hz (10x below PWM frequency)
• Use R = 10k ohm, solve for C:

$C = \frac{1}{2\pi \times 10000\Omega \times 100\text{Hz}} = 0.159\mu\text{F} \approx 0.22\mu\text{F}$

Result: The ideal 100 Hz design gives 0.159uF. A common 0.22uF capacitor with 10k ohm resistance gives about 72 Hz cutoff, which is still low enough to smooth a 1 kHz PWM signal but responds more slowly.

RC Filter Design Guidelines:

• f_cutoff should be 10-20x below PWM frequency
• Higher cutoff = faster response, more ripple
• Lower cutoff = slower response, smoother output
• Settling time = 5 x RC (to reach 99% of target)

33.9 Hands-On Labs

The labs turn the same formulas into measurement tasks: code value, expected voltage, and load behavior should agree.

void setup() {
    // DAC channels: 25 and 26
    Serial.begin(115200);
}

void loop() {
    // Sweep from 0V to 3.3V
    for (int i = 0; i <= 255; i += 5) {
        dacWrite(25, i);  // 8-bit DAC (0-255)

        float voltage = (i / 255.0) * 3.3;
        Serial.print("DAC Value: ");
        Serial.print(i);
        Serial.print(" | Voltage: ");
        Serial.print(voltage);
        Serial.println("V");

        delay(100);
    }
}

const int ledPin = 9;  // PWM pin

void setup() {
    pinMode(ledPin, OUTPUT);
    Serial.begin(9600);
}

void loop() {
    // Sweep brightness up
    for (int duty = 0; duty <= 255; duty += 5) {
        analogWrite(ledPin, duty);

        float dutyCyclePct = (duty / 255.0) * 100.0;
        float avgVoltage = (duty / 255.0) * 5.0;

        Serial.print("PWM: ");
        Serial.print(duty);
        Serial.print(" | Duty: ");
        Serial.print(dutyCyclePct, 1);
        Serial.print("% | V_avg: ");
        Serial.print(avgVoltage, 2);
        Serial.println("V");

        delay(50);
    }

    // Sweep brightness down
    for (int duty = 255; duty >= 0; duty -= 5) {
        analogWrite(ledPin, duty);
        delay(50);
    }
}

33.10 Common Pitfalls

These mistakes happen when a design assumes ideal DAC accuracy, ignores PWM frequency, or forgets what the load averages.

33.11 Continue to the Next Part

Carry this evidence into DAC and PWM: Actuator Selection and Validation, which begins with Key Takeaway.