Arduino and Sound: Building a 16kHz WAV Player with SD and PWM

Getting an Arduino and sound to work together reliably requires navigating microcontroller hardware limitations. The ATmega328P lacks a native Digital-to-Analog Converter (DAC) and an I2S peripheral. To play stored audio without resorting to external MP3 decoder chips, the most robust method is using an SD card for storage, the TMRpcm library for WAV decoding, and a hardware PWM pin driving a Class-D amplifier like the PAM8403.

This guide walks through building a 16kHz mono WAV player on an Arduino Nano v3 (ATmega328P, 5V/16MHz). We will cover the exact hardware stack, signal conditioning for the SD card, compilable code with serial error handling, and the specific file-format traps that cause 90% of audio project failures.

Audio Output Methods for Microcontrollers

Before wiring the board, it is critical to understand why we are using PWM via Timer1 rather than other methods. Below is a data-dense comparison of the four common ways to generate audio on 8-bit and 32-bit microcontrollers.

Method	Resolution / Quality	CPU Overhead	Hardware Cost	Best Use Case
Direct PWM (TMRpcm)	8-bit / 16-32kHz (Timer1)	High (Interrupt driven)	~$2 (Amp only)	ATmega328P voice prompts, basic effects
R-2R Resistor Ladder	8-bit parallel DAC	Very High (Blocking loop)	~$1 (Resistors)	Simple tone generation, no SD streaming
I2S DAC (MAX98357A)	16-bit to 24-bit / 44.1kHz+	Low (DMA handled)	~$6 (I2S Amp)	ESP32 high-fidelity music streaming
DFPlayer Mini (MP3)	16-bit / 44.1kHz (Decoded)	Negligible (UART commands)	~$4 (Module)	Long music tracks, simple button triggers

For an Arduino Nano, Direct PWM is the only viable option for streaming from an SD card. The TMRpcm library hijacks Timer1 to toggle Pin D9 at frequencies up to 32kHz, using pulse-width modulation to approximate an analog waveform. A low-pass filter or a Class-D amplifier is required to convert this high-frequency PWM square wave into audible sound.

Parts List and Pin Mapping

Using the wrong SD card module is the most common point of failure in this build. You must use a module with a built-in 3.3V LDO and logic level shifters. The raw 4-pin modules will fry a 3.3V MicroSD card when connected to a 5V Arduino.

Required Components

• Microcontroller: Arduino Nano v3 (ATmega328P, 5V/16MHz) - ~$6.00
• Storage: MicroSD Card Adapter Module (6-pin, with LDO/Level Shifters) - ~$3.00
• Amplifier: PAM8403 Dual 3W Class-D Audio Amplifier Board - ~$2.00
• Output: 8-ohm 2W Full-Range Speaker - ~$4.00
• Storage Media: 8GB or 16GB MicroSD Card (Class 10, formatted FAT32 MBR)

Pin Mapping Table

Component	Module Pin	Arduino Nano Pin	Notes
SD Module	VCC	5V	Powers the onboard 3.3V LDO
SD Module	GND	GND	Common ground required
SD Module	MISO	D12	SPI Data In (Master In)
SD Module	MOSI	D11	SPI Data Out (Master Out)
SD Module	SCK	D13	SPI Clock
SD Module	CS	D10	Chip Select (Must be D10 for TMRpcm)
PAM8403 Amp	VCC	5V	Do not exceed 5.5V
PAM8403 Amp	GND	GND	Keep ground wires short to avoid hum
PAM8403 Amp	L_IN / R_IN	D9	PWM Audio Output (Timer1)

Wiring Steps and Signal Conditioning

1. Prepare the SD Card: Format your MicroSD card to FAT32 with an MBR (Master Boot Record) partition scheme. Modern Windows and macOS disk utilities often default to GPT or exFAT for cards larger than 32GB, which the Arduino SD library cannot read. Use a tool like SD Card Formatter to force FAT32/MBR.
2. Prepare the Audio File: Export your WAV file as 8-bit, 16kHz, Mono. Name it using the 8.3 format (e.g., sound.wav). The ATmega328P lacks the RAM and clock speed to decode 16-bit 44.1kHz stereo files in real-time.
3. Wire the SPI Bus: Connect the SD module to the Nano's hardware SPI pins (D11, D12, D13). Connect CS to D10. Note: The TMRpcm library hardcodes the SD CS pin to D10 on ATmega328P boards to optimize Timer1 interrupts.
4. Wire the Amplifier: Connect the Nano's 5V and GND to the PAM8403. Route the D9 PWM signal to the Left or Right audio input on the amp. Connect your speaker to the corresponding output channel.
5. Verify Power Draw: The PAM8403 can pull up to 1.5A at peak volume. If powering via USB, ensure your PC's USB port can supply at least 1A. For standalone use, use a 5V 2A buck converter or wall adapter.

Compilable Code: WAV Playback with Error Handling

This code targets the Arduino Nano v3 (ATmega328P). It initializes the SD card, checks for the specific WAV file, and triggers playback. It includes explicit serial debugging to catch initialization and file-format errors before they result in silent failures.

Prerequisite: Install the TMRpcm library via the Arduino Library Manager (search for TMRpcm by TMRh20).

#include <SD.h>
#include <TMRpcm.h>

// Pin definitions for Arduino Nano v3
#define SD_CS_PIN 10
#define SPEAKER_PIN 9
#define STATUS_LED_PIN 13 // Nano onboard LED

TMRpcm audio;

const char* targetFile = "sound.wav";

void setup() {
  Serial.begin(115200);
  while (!Serial) { ; } // Wait for serial port (native USB boards only, safe on Nano)
  
  pinMode(STATUS_LED_PIN, OUTPUT);
  digitalWrite(STATUS_LED_PIN, LOW);

  Serial.println(F("Initializing SD card..."));
  
  // TMRpcm requires the SD CS pin to be explicitly defined
  audio.speakerPin = SPEAKER_PIN;
  pinMode(SPEAKER_PIN, OUTPUT);

  if (!SD.begin(SD_CS_PIN)) {
    Serial.println(F("ERROR: SD initialization failed. Things to check:"));
    Serial.println(F("1. Is the SD card inserted and seated properly?"));
    Serial.println(F("2. Is the card formatted as FAT32 with an MBR partition?"));
    Serial.println(F("3. Are you using a 5V SD module with level shifters?"));
    // Blink LED rapidly to indicate fatal hardware error
    while (1) {
      digitalWrite(STATUS_LED_PIN, !digitalRead(STATUS_LED_PIN));
      delay(100);
    }
  }
  
  Serial.println(F("SD card initialized successfully."));

  // Verify file exists before attempting playback
  if (!SD.exists(targetFile)) {
    Serial.print(F("ERROR: File '"));
    Serial.print(targetFile);
    Serial.println(F("' not found on SD card."));
    Serial.println(F("Ensure filename is 8.3 format (e.g., SOUND.WAV)."));
  } else {
    Serial.println(F("File found. Starting playback..."));
    audio.setVolume(5); // Volume range: 0 to 7
    audio.play(targetFile);
    digitalWrite(STATUS_LED_PIN, HIGH);
  }
}

void loop() {
  // Check if audio is still playing
  if (!audio.isPlaying()) {
    digitalWrite(STATUS_LED_PIN, LOW);
    // Optional: Loop the track or put microcontroller to sleep
    // delay(2000);
    // audio.play(targetFile);
  }
  
  // Handle serial commands for volume control
  if (Serial.available() > 0) {
    char cmd = Serial.read();
    if (cmd == '+') {
      audio.volume(1); // Increment volume
      Serial.print(F("Volume: ")); Serial.println(audio.volume());
    } else if (cmd == '-') {
      audio.volume(0); // Decrement volume
      Serial.print(F("Volume: ")); Serial.println(audio.volume());
    }
  }
}

Troubleshooting: When the Speaker Stays Silent

Audio projects fail silently more often than they throw compile errors. If you upload the code and hear nothing, or just a loud static hiss, run through these diagnostics.

The First Three Things to Check

1. WAV File Encoding: Open your file in Audacity. Go to Tracks > Mix > Mix Stereo Down to Mono. Then go to File > Export > Export as WAV and select WAV (Microsoft) signed 8-bit PCM. Set the Project Rate in the bottom left corner to 16000 Hz. If you feed TMRpcm a 16-bit or 44.1kHz file, it will play at the wrong speed or output white noise.
2. SD Card Partition Scheme: If the card is 64GB or larger, Windows formats it as exFAT by default. The Arduino SD Library only supports FAT16 and FAT32. Reformat using a dedicated tool like the official SD Memory Card Formatter.
3. SPI Bus Contention: Ensure no other SPI devices (like an NRF24L01 or an ILI9341 display) are sharing the bus without proper CS pin management. The SD card will hold the MISO line low if its CS pin is not pulled HIGH when inactive, crashing the audio timer interrupts.

Exact Error Strings and Ranked Causes

Error String: "ERROR: SD initialization failed. Things to check:"

• Cause 1 (Most Likely): Wiring error on the SPI bus. Double-check that MISO is on D12, not D11. The Arduino SPI documentation confirms D11 is MOSI and D12 is MISO on the Nano.
• Cause 2: Using a raw 4-pin SD module without a 3.3V LDO. The card is browning out during the high-current initialization spike.
• Cause 3: The SD card is physically locked (write-protect switch engaged) or defective.

Error String: "ERROR: File 'sound.wav' not found on SD card."

• Cause 1: Long File Names (LFN). The standard SD library struggles with names exceeding 8 characters plus a 3-character extension. Rename my_audio_track.wav to track1.wav.
• Cause 2: Case sensitivity mismatch. The code looks for sound.wav but the file is named SOUND.WAV. Match the case exactly.

Symptom: No serial errors, but audio is heavily distorted, slowed down, or sounds like a robot.

• Cause: Incorrect WAV header. The TMRpcm library repository explicitly states it expects standard PCM headers. If you exported from a DAW using a compressed WAV codec (like ADPCM), the library will misinterpret the sample rate. Re-export as uncompressed 8-bit PCM.

Extending and Simplifying the Build

Building an Arduino and sound project teaches you exactly where the boundaries of 8-bit microcontrollers lie. By respecting the strict file format requirements, managing the SPI bus carefully, and conditioning your power rails for the Class-D amplifier, you can build a highly reliable audio playback system for under $15.