By the end of this section, you will be able to:
While ADCs translate sensor signals into numbers a computer can read, DACs do the reverse – they turn digital numbers back into smooth voltages that can control things like speakers and motors. Most microcontrollers use a shortcut called PWM instead, which rapidly flickers power on and off. To a motor or LED, this flickering feels like a steady, adjustable voltage because it happens too fast for them to notice the individual pulses.
Before diving into this chapter, you should be familiar with:
DAC = Device that converts digital numbers into analog voltage
\[V_{out} = V_{ref} \times \frac{Digital\ Input}{2^n - 1}\]
Example (8-bit DAC, Vref = 5V):
| Digital Input | Calculation | Voltage Output |
|---|---|---|
| 0 | 5 x (0/255) | 0.00 V |
| 64 | 5 x (64/255) | 1.25 V |
| 128 | 5 x (128/255) | 2.51 V |
| 192 | 5 x (192/255) | 3.76 V |
| 255 | 5 x (255/255) | 5.00 V |
For an 8-bit DAC with \(V_{ref} = 5\) V, the step size (resolution) is \(V_{step} = V_{ref} / (2^n - 1) = 5 / 255 = 19.6\) mV. To output 3.0V, you need digital value \(D = \lfloor V_{out} \times (2^n - 1) / V_{ref} \rfloor = \lfloor 3.0 \times 255 / 5 \rfloor = 153\). Actual output is \(V_{actual} = 153 \times 5 / 255 = 3.0\) V exactly. With a 12-bit DAC (\(2^{12} - 1 = 4095\)), step size shrinks to \(5 / 4095 = 1.22\) mV – 16× finer than 8-bit, enabling smooth audio waveforms where 8-bit would sound grainy.
| Application | Example | DAC Type |
|---|---|---|
| Audio Output | Music playback | 12-16 bit, 44.1 kHz |
| Motor Speed Control | PWM alternative | 8-10 bit |
| LED Brightness | Smooth dimming | 8-12 bit |
| Analog Sensor Simulation | Testing | 12 bit |
| Waveform Generation | Signal generator | 12-16 bit |
R-2R Ladder Network:
Problem: DAC output is not truly analog - it’s discrete steps
Quantization Error = Difference between ideal smooth output and actual stepped output
Reducing Error:
Option A (True DAC - ESP32 GPIO25/26, MCP4725):
Option B (PWM Pseudo-Analog - Any GPIO):
Decision Factors: Choose true DAC when driving audio amplifiers, generating test signals, providing reference voltages, or interfacing with analog-input devices sensitive to ripple. Choose PWM when controlling inductive loads (motors inherently filter PWM), dimming LEDs (human eye cannot perceive >100Hz flicker), or when all DAC pins are already used. Note: ESP32 has only 2 DAC channels but 16+ PWM-capable GPIOs, making PWM more flexible for multi-channel applications.
Solution: Use PWM (Pulse Width Modulation) to simulate analog output
PWM Pins: 3, 5, 6, 9, 10, 11
// 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);
}PWM Characteristics:
DAC Pins: GPIO25, GPIO26
// 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
}Experience true analog output with the ESP32 DAC in Wokwi:
Challenge: Generate a smooth voltage sweep from 0V to 3.3V
Steps:
dacWrite(25, value) where value sweeps from 0 to 255What to observe: True DAC provides genuine analog voltage with no high-frequency switching, ideal for audio and precision applications where PWM ripple would cause problems.
Most microcontrollers lack true DACs but use PWM (Pulse Width Modulation) to simulate analog output.
How PWM Works:
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:
| Parameter | Arduino Uno | ESP32 | Typical Use |
|---|---|---|---|
| Resolution | 8-bit (0-255) | 8-16 bit | Motor speed, LED dimming |
| Frequency | 490-980 Hz | 1 Hz - 312 kHz (8-bit) | Audio requires >20 kHz |
| Channels | 6 | 16 | Multiple motors/LEDs |
Use the sliders below to explore how duty cycle, supply voltage, and DAC input value affect output voltage.
For smooth analog output, add RC low-pass filter:
\[f_{cutoff} = \frac{1}{2\pi RC}\]
Example: Smoothing 1 kHz PWM for motor control
\[C = \frac{1}{2\pi \times 10000\Omega \times 100\text{Hz}} = 0.159\mu\text{F} \approx 0.22\mu\text{F}\]
Result: 0.22uF capacitor with 10k ohm resistor converts 1 kHz PWM to smooth analog voltage.
RC Filter Design Guidelines:
Objective: Generate analog voltages using ESP32’s built-in DAC.
Materials:
Circuit:
ESP32 Code:
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);
}
}Measurements:
Expected Learning:
Objective: Use PWM to smoothly dim an LED and observe the relationship between duty cycle and perceived brightness.
Materials (or simulate in TinkerCAD / Wokwi): - Arduino Uno - 1x LED (any color) - 1x 220 ohm resistor - Jumper wires
Circuit:
Arduino Code:
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);
}
}Expected Learning:
The Mistake: Assuming an 8-bit DAC with a 3.3V reference produces exact voltages at every step (e.g., expecting exactly 1.650V for value 128).
Why It Happens: The formula \(V_{out} = V_{ref} \times D / (2^n - 1)\) gives the ideal voltage, but real DAC output is affected by integral nonlinearity (INL), differential nonlinearity (DNL), offset error, and gain error. An 8-bit DAC has 12.9 mV steps at 3.3V, but typical INL of +/-1 LSB means actual output can deviate by +/-12.9 mV from the ideal.
The Fix: Check the DAC IC datasheet for INL and DNL specifications. For precision applications, use a higher-resolution DAC (12-bit or 16-bit) and calibrate against a known reference voltage. ESP32 built-in DAC has approximately +/-1% accuracy without calibration.
Rule of Thumb: Usable accuracy is typically 2-3 bits fewer than advertised resolution once all error sources are combined.
The Mistake: Using the default Arduino PWM frequency (490 Hz on most pins) for motor control, resulting in audible motor whine, or for LED dimming causing visible flicker in video recordings.
Why It Happens: The default frequency is a compromise that works for basic demos but is too low for many real applications. Cameras recording at 30-60 fps can capture individual PWM cycles, and human hearing extends to ~20 kHz.
The Fix: Increase PWM frequency to match the application: - LED dimming: >200 Hz for flicker-free to human eye; >1 kHz for flicker-free on camera - DC motor control: >20 kHz (ultrasonic) to eliminate audible whine - Servo motors: Fixed at 50 Hz (industry standard), do not change
On ESP32, use ledcSetup(channel, freq, resolution) to set custom PWM frequency. On Arduino Uno, modify timer prescaler registers.
Rule of Thumb: Use the highest PWM frequency your hardware supports, keeping in mind that higher frequency reduces effective resolution.
DACs are like translators who speak the language of motors and lights!
Max the Microcontroller had a new challenge. “I know the motor needs to spin at 50% speed, and I can think in numbers like 128 out of 255. But the motor only understands smooth voltage, not step-numbers!”
Lila the LED agreed. “Same for me! I want to glow at half brightness, but I need a smooth amount of power, not a number!”
That is when DAC Danny showed up. “I am the opposite of ADC Andy! Andy translates smooth signals INTO numbers for Max. I translate numbers FROM Max back into smooth signals for motors and LEDs!”
Bella the Battery was impressed. “So you are a reverse translator!”
Danny smiled. “Exactly! When Max says 128, I convert that into 1.65 volts – just the right amount to make Lila glow at half brightness.”
But Sammy the Sensor noticed something. “Wait, Danny, you are not on every microcontroller. What happens when you are not around?”
Danny pointed to his friend PWM Pete. “Pete has a clever trick! He blinks the power ON and OFF really, really fast. If he is ON half the time and OFF half the time, the average power is 50% – and it happens so fast that Lila cannot even tell she is blinking!”
Lila blinked. “I had no idea! I thought I was glowing smoothly this whole time!”
| Word | What It Means |
|---|---|
| DAC | A reverse translator that turns numbers into smooth voltage |
| PWM | Blinking power ON and OFF so fast it looks smooth |
| Duty Cycle | How much of the time the power is ON (50% = half the time) |
| Motor Control | Changing how fast a motor spins using voltage |
| LED Dimming | Making a light brighter or dimmer |
The Blinking Brightness Game!
What you learned: When blinking is fast enough, your eyes blend it into steady light. That is exactly how PWM works – it blinks so fast (hundreds of times per second) that LEDs and motors respond smoothly!
The big picture: A DAC is the reverse of an ADC - it uses an R-2R resistor ladder to convert an 8-bit digital value (0-255) into a proportional analog voltage (0-3.3V).
Step-by-step breakdown:
dacWrite(25, 200) - 200 in binary is 11001000 - Real example: ESP32 GPIO25 DAC receives this 8-bit valueWhy this matters: Understanding that PWM average voltage (3.75V at 75% duty cycle) requires RC filtering to become smooth DC explains why motors work with PWM directly (coil inductance acts as filter) but audio needs a true DAC.
| Concept | Relates To | Relationship |
|---|---|---|
| DAC Resolution (8-bit) | ADC Resolution | Same 2^n formula - 8-bit DAC has 256 output levels, 12-bit ADC has 4,096 input levels |
| PWM Duty Cycle | Motor Speed Control | Average voltage = V_high × duty_cycle - motors respond to average, not individual pulses |
| RC Filter Cutoff Frequency | Sampling Theory | Filter fc should be 10× below PWM frequency to smooth ripple (inverse of Nyquist) |
Cross-module connection: PWM Actuator Control - Explains how DC motors respond to PWM average voltage via back-EMF and inductance
DACs and PWM are the two main ways IoT microcontrollers produce analog-like output signals for actuator control. True DACs provide smooth voltage output ideal for audio and precision applications, while PWM offers a flexible, cost-free alternative for LED dimming and motor speed control available on every GPIO pin. Understanding the tradeoffs between these approaches is essential for designing effective IoT actuator interfaces.
Use this decision table to choose the right output method based on your application requirements.
| Application Requirement | True DAC | PWM | Recommended Choice |
|---|---|---|---|
| Audio output (music, voice) | ✓ Smooth analog, >90dB SNR possible | ✗ High-frequency ripple audible as hiss | DAC — Audio requires clean signals |
| LED brightness control | ✓ Flicker-free at any frequency | ✓ Flicker-free above 100 Hz | PWM — Saves DAC pins, perceptually identical |
| DC motor speed control | ✓ Smooth speed, no torque ripple | ✓ Motor inductance filters PWM naturally | PWM — Motor coils act as low-pass filter |
| Servo motor positioning | ~ Acceptable but not standard | ✓ Industry standard 50 Hz PWM signal | PWM — Servos expect PWM input (1-2 ms pulse width) |
| Precision voltage reference | ✓ Stable DC output, <1 mV noise | ✗ Ripple voltage 2-10% even with RC filter | DAC — Reference voltages must be clean |
| Analog sensor simulation (testing) | ✓ Can mimic smooth sensor output | ~ Only for slowly-changing signals | DAC — Faster signals need true analog |
| Multi-channel output (8+ channels) | ✗ Most MCUs have only 1-2 DAC pins | ✓ Every GPIO can generate PWM | PWM — Scalability advantage |
| Battery-powered application | ~ Consumes 0.5-5 mA continuous | ✓ <0.1 mA average at low duty cycles | PWM — Lower average current |
Key Decision Factors:
Choose True DAC When:
Choose PWM When:
Real-World Example: Smart Lighting System
| Output Channel | Load | Method Used | Reasoning |
|---|---|---|---|
| Channel 1-8 (RGB LEDs) | 8× RGB strips | PWM @ 1 kHz | Human eye can’t detect flicker, saves DAC pins |
| Channel 9 (Audio alert) | Piezo buzzer | DAC @ 44.1 kHz | Generates smooth tones, PWM would sound harsh |
| Channel 10 (Fan speed) | 12V DC fan | PWM @ 25 kHz | Ultrasonic frequency eliminates motor whine |
Cost Comparison:
Rule of Thumb: Start with PWM for actuators (motors, LEDs, heaters). Only use true DAC when you observe problems (audible noise, instability, ripple voltage) or need to interface with analog circuitry expecting clean DC.
This chapter covered Digital-to-Analog Converters (DACs) and PWM output for actuator control:
Understanding DAC and PWM is essential for controlling actuators in IoT systems.
You’ve completed the Analog and Digital Electronics series! You now have the complete hardware foundation for IoT sensor and actuator interfaces.
| Chapter | Topic | Why It Matters |
|---|---|---|
| Analog and Digital Electronics Overview | Series overview | Return to the full electronics series index |
| ADC/DAC Worked Examples | Practical calculations | Apply DAC and PWM formulas to real-world design problems |
| PWM Actuator Control | Motor and LED control | Hands-on PWM for DC motors, servos, and LED dimming |
| Sensor Circuits and Signals | Sensor interface circuits | Connect DAC/ADC knowledge to complete sensor signal chains |
| Networking Basics Introduction | Module 3: Networking | Discover how IoT devices connect and communicate over networks |
| Energy-Aware Power Analysis | Power budgets | Factor in DAC current (0.5-5 mA) vs PWM average current for battery life |