Designing a Low‑Cost Audio DAC with the MCP4921: A Step‑by‑Step Guide

If you’ve ever tried to stream music from a tiny microcontroller and heard more hiss than melody, you know why a decent digital‑to‑analog converter (DAC) matters. The MCP4921 is a 12‑bit chip that can turn a stream of numbers into a smooth analog signal without breaking the bank. In this post I’ll walk you through building a simple audio DAC that actually sounds good enough for a bedside speaker or a DIY headphone amp. No fancy parts, no endless spreadsheets—just a few components, a bit of solder, and a lot of curiosity.

Why the MCP4921?

The MCP4921 is a favorite in the hobby community for three reasons:

1. Price – A single chip costs less than a cup of coffee.
2. Simplicity – It talks SPI, a protocol most microcontrollers already support.
3. Performance – 12‑bit resolution and a 20 MHz max clock give you enough headroom for decent audio quality.

For many projects, especially when you’re learning the ropes, the extra bits of resolution you get from a 16‑bit DAC aren’t worth the extra cost or board space. The MCP4921 hits the sweet spot between quality and affordability.

What You’ll Need

• MCP4921 chip (single‑supply, 5 V version)
• A microcontroller with SPI (Arduino Uno, ESP32, etc.)
• 10 kΩ resistor (optional, for output filtering)
• 0.1 µF ceramic capacitor (output decoupling)
• Breadboard or a small perf‑board
• Wires, soldering iron, and a little patience

That’s it. You can find all of these parts at any local electronics store or online retailer. If you’re already a regular at DAC Dive, you probably have most of them lying around.

Wiring the MCP4921

Power and Ground

Connect VDD to 5 V (or 3.3 V if you’re using a 3.3 V MCU, but keep the reference voltage in mind). Pin 2 (VREF) should also be tied to the same supply voltage; this makes the full‑scale output equal to the supply voltage. Pin 8 is ground.

SPI Connections

If you prefer the chip to update its output only when you command it, leave LDAC floating and pulse the LDAC pin after each write. For a simple audio stream, grounding LDAC works fine and reduces code complexity.

Output Stage

The analog output appears on pin 5 (VOUT). Add a 0.1 µF capacitor from VOUT to ground to smooth out high‑frequency spikes. A 10 kΩ resistor in series can help protect the next stage (headphone driver, op‑amp, etc.) and forms a simple low‑pass filter together with the capacitor.

Getting the Data Out of Your MCU

Audio is just a stream of numbers that represent the shape of a sound wave. For 44.1 kHz CD‑quality audio, you need to push 44,100 samples per second to the DAC. The MCP4921 can handle that easily if you keep the SPI clock high enough (around 10 MHz works well).

Preparing the Sample Buffer

If you’re playing a WAV file from an SD card, read the file in 16‑bit chunks, then shift the data right by 4 bits to fit the 12‑bit range. For a quick test, you can generate a sine wave in code:

float phase = 0.0;
float inc   = 2.0 * 3.14159265 * 1000.0 / 44100.0; // 1 kHz tone
while (true) {
    uint16_t sample = (uint16_t)((sin(phase) + 1.0) * 2047.5); // 0‑4095 range
    phase += inc;
    if (phase > 2.0 * 3.14159265) phase -= 2.0 * 3.14159265;
    sendToMCP4921(sample);
}

The sendToMCP4921() function packs the 12‑bit value into the 16‑bit SPI frame required by the chip (4 control bits + 12 data bits) and toggles the CS line.

The SPI Write Routine

void sendToMCP4921(uint16_t value) {
    uint16_t command = 0x3000 | (value & 0x0FFF); // 0b0011 = write to DAC, unbuffered
    digitalWrite(CS_PIN, LOW);
    SPI.transfer16(command);
    digitalWrite(CS_PIN, HIGH);
}

The 0x3000 sets the configuration bits: DAC A, unbuffered, gain = 1, active mode. You can tweak these bits later if you need a different voltage range or want to use the buffered mode.

Putting It All Together

1. Initialize SPI – Set the clock divider so you get at least 10 MHz. On an Arduino Uno, SPI.beginTransaction(SPISettings(10000000, MSBFIRST, SPI_MODE0)); does the trick.
2. Load the Audio Data – Either stream from an SD card or generate on the fly.
3. Write Samples in a Tight Loop – Use a timer interrupt or a simple delayMicroseconds(23) to keep the sample rate near 44.1 kHz. The MCP4921 itself adds only a few hundred nanoseconds of latency, so the bottleneck is usually the MCU’s ability to fetch data.
4. Filter the Output – The 0.1 µF cap already smooths most high‑frequency noise, but if you hear hiss, add a small RC low‑pass (10 kΩ + 0.1 µF gives a cutoff around 160 Hz). For music, you’ll want a higher cutoff, so experiment with values that suit your speaker or headphone load.

Testing and Tweaking

When I first built this circuit, the output sounded thin—like a cheap phone speaker. The culprit was the reference voltage. I had tied VREF to 3.3 V while the rest of the circuit ran at 5 V, so the full‑scale output was limited to 3.3 V. Raising VREF to the same 5 V supply gave me the full swing and the volume jumped noticeably.

Another tip: keep the wiring short. Long SPI traces can introduce jitter, especially at high clock rates. A small perf‑board with tidy solder jumps works better than a sprawling breadboard for final builds.

Where to Go From Here

Now that you have a working audio DAC, you can:

• Add a headphone amp stage (simple op‑amp based design works well).
• Use a higher‑resolution DAC like the MCP4922 if you need stereo.
• Experiment with oversampling and digital filtering to improve SNR.

The beauty of the MCP4921 is that it lets you focus on the signal chain rather than fighting the hardware. In future DAC Dive posts I’ll dive deeper into digital filtering techniques, but for now you have a solid, low‑cost audio DAC that you can build in an afternoon.