Putting songs in a kid’s toy: an ESP32 MP3 player and a custom NS4168 amp board

Introduction

I wanted to put a few songs into a toy for my kid, so I built a player that stores MP3 files in the ESP32’s internal flash and plays them through an I2S amplifier.

The finished setup is simple, but I hit silence and noise several times before any music came out. This is a record of what I tried, in the order I tried it.

The finished setup

The ESP32 decodes MP3 files from its internal flash and sends the audio to the NS4168 over three I2S lines.

Parts and software

Wiring (with the module)

After this, I replaced the amp module with my own board. The same sketch runs on it from a 3.3 V supply.

Where I bought the module: AliExpress

Choosing where to store the songs

I looked at three options.

Voice IC: no stock

Voice ICs such as the WT588F are the usual way to put sound in a toy. My first choice was the WT588F02B-8S.

I planned to have JLCPCB assemble the board, so I checked stock. This is what I found in August 2026.

• JLCPCB has a part page for it (C2917616)
• The LCSC product page returns 404, and the part does not show up in stock search

I could not find stock for other voice ICs either, so I switched to an ESP32 with an I2S amplifier (NS4168, C910588), which is well stocked.

microSD card: it works, but it adds parts

I tried two microSD routes. One was a DFPlayer Mini, an MP3 player module with its own card slot that the ESP32 controls over UART. The other was a plain microSD module on SPI, with the ESP32 reading and decoding the files. Playback from the SPI card module worked.

Internal flash needs no extra parts and no extra wiring. That is what I went with.

Reference (in Japanese): Controlling a DFPlayer over UART

Internal flash: three songs fit in 4 MB

I split the 4 MB flash into 1 MB for the sketch and about 2.9 MB for LittleFS. Three songs of roughly two minutes each fit at 48 kbps.

The three songs are free tracks that are distributed at no charge. They are not my own recordings and not commercial releases.

Getting the songs onto the ESP32

1. Split the flash

Put partitions.csv in the same folder as the sketch, then choose Custom under Tools → Partition Scheme in the Arduino IDE.

# Name,   Type, SubType, Offset,   Size,     Flags
nvs,      data, nvs,     0x9000,   0x5000,
otadata,  data, ota,     0xe000,   0x2000,
app0,     app,  ota_0,   0x10000,  0x100000,
spiffs,   data, spiffs,  0x110000, 0x2F0000,

Each line is one partition. From the top:

2. Convert the MP3s

ffmpeg -i input.mp3 -ac 1 -ar 44100 -b:a 48k -map_metadata -1 00001.mp3

input.mp3 is the original file and 00001.mp3 is the converted one.

3. Build the LittleFS image

Normally the arduino-littlefs-upload plugin for Arduino IDE 2.x uploads the whole data folder for you.

On my machine (Arduino IDE 2.3.4) the command never appeared in the command palette, so I built the image with littlefs-python instead.

Lay out the folder like this.

work/
├─ make_littlefs.py   <- the script below
├─ data/
│   ├─ 00001.mp3
│   ├─ 00002.mp3
│   └─ 00003.mp3
└─ littlefs.bin       <- created when you run it

from littlefs import LittleFS
import os, glob
SIZE, BLOCK, PROG = 0x2F0000, 4096, 256
fs = LittleFS(block_size=BLOCK, block_count=SIZE // BLOCK,
              read_size=PROG, prog_size=PROG, disk_version=0x00020000)
for p in sorted(glob.glob("data/*.mp3")):
    with fs.open("/" + os.path.basename(p), "wb") as f:
        f.write(open(p, "rb").read())
open("littlefs.bin", "wb").write(bytes(fs.context.buffer))

Run these two lines. The first installs the library and is needed only once.

py -m pip install littlefs-python
py make_littlefs.py

An image built with these settings mounted correctly with LittleFS on ESP32 core 3.3.10.

4. Flash it with esptool

py -m esptool --chip esp32 --port COM5 --baud 921600 write-flash 0x110000 littlefs.bin

The commands above are for Windows, where py is the Python launcher. On macOS or Linux, use python3 instead of py, and a port name such as /dev/ttyUSB0.

The sketch

The sketch has five parts. Paste parts 1 to 5 one after another and you have the whole sketch.

For this English version I translated the comments and the serial messages. The code is otherwise the same as in the Japanese article.

Part 1: Settings

#include <Arduino.h>
#include <LittleFS.h>
#include <AudioFileSourceLittleFS.h>
#include <AudioFileSourceBuffer.h>
#include <AudioFileSourceID3.h>
#include <esp_partition.h>
#include <AudioGeneratorMP3.h>
#include <AudioOutputI2S.h>
constexpr int PIN_I2S_BCLK = 26;
constexpr int PIN_I2S_LRC  = 25;
constexpr int PIN_I2S_DOUT = 22;   // to SDATA on the amp
constexpr int PIN_NEXT_SW  = 0;    // next-track button (-1 to disable)
AudioGeneratorMP3       *mp3  = nullptr;
AudioFileSourceLittleFS *file = nullptr;
AudioFileSourceBuffer   *buff = nullptr;
AudioFileSourceID3      *id3  = nullptr;
AudioOutputI2S          *out  = nullptr;
const char *playlist[] = { "/00001.mp3", "/00002.mp3", "/00003.mp3" };
constexpr size_t PLAYLIST_LEN = sizeof(playlist) / sizeof(playlist[0]);
size_t currentTrack = 0;
float gain = 0.3f;

These are the four things to change for your own setup.

Part 2: Start and stop playback

void stopPlayback() {
  if (mp3 && mp3->isRunning()) mp3->stop();
  delete id3;  id3  = nullptr;
  delete buff; buff = nullptr;
  delete file; file = nullptr;
}
bool startTrack(size_t index) {
  stopPlayback();
  if (!LittleFS.exists(playlist[index])) {
    Serial.printf("File not found: %s\n", playlist[index]);
    return false;
  }
  file = new AudioFileSourceLittleFS(playlist[index]);
  buff = new AudioFileSourceBuffer(file, 8192);
  id3  = new AudioFileSourceID3(buff);
  if (!mp3) mp3 = new AudioGeneratorMP3();
  out->SetGain(gain);
  bool ok = mp3->begin(id3, out);
  Serial.printf("Playing: %s (%s)\n", playlist[index], ok ? "OK" : "FAILED");
  return ok;
}

The audio data flows in this order.

File → buffer → tag handling → MP3 decoder → I2S output

Part 3: File list

void listFiles() {
  Serial.println("--- Files in LittleFS ---");
  File root = LittleFS.open("/");
  for (File f = root.openNextFile(); f; f = root.openNextFile()) {
    Serial.printf("  %-16s %8u bytes\n", f.name(), (unsigned)f.size());
  }
  Serial.printf("Used: %u / %u bytes\n",
                (unsigned)LittleFS.usedBytes(), (unsigned)LittleFS.totalBytes());
}

This prints the stored files at boot, so you can see whether the songs are really there.

Part 4: setup()

void setup() {
  Serial.begin(115200);
  delay(300);
  if (PIN_NEXT_SW >= 0) pinMode(PIN_NEXT_SW, INPUT_PULLUP);
  // Print where the song partition actually is
  const esp_partition_t *p = esp_partition_find_first(
      ESP_PARTITION_TYPE_DATA, ESP_PARTITION_SUBTYPE_DATA_SPIFFS, NULL);
  if (p) {
    Serial.printf("Song partition: start=0x%06X  size=%u bytes\n",
                  (unsigned)p->address, (unsigned)p->size);
  } else {
    Serial.println("Song partition not found. Set Partition Scheme to Custom.");
  }
  out = new AudioOutputI2S();
  out->SetBuffers(12, 1024);
  out->SetPinout(PIN_I2S_BCLK, PIN_I2S_LRC, PIN_I2S_DOUT);
  out->SetRate(44100);
  out->SetGain(gain);
  if (!LittleFS.begin(false)) {
    Serial.println("LittleFS mount failed");
    return;
  }
  listFiles();
  startTrack(currentTrack);
  Serial.println("n=next / p=previous / s=stop / +,-=volume");
}

Part 5: loop()

void loop() {
  if (mp3 && mp3->isRunning()) {
    if (!mp3->loop()) {
      mp3->stop();
      currentTrack = (currentTrack + 1) % PLAYLIST_LEN;
      startTrack(currentTrack);
    }
  }
  if (Serial.available()) {
    char c = Serial.read();
    if (c == 'n') {
      currentTrack = (currentTrack + 1) % PLAYLIST_LEN;
      startTrack(currentTrack);
    } else if (c == 'p') {
      currentTrack = (currentTrack + PLAYLIST_LEN - 1) % PLAYLIST_LEN;
      startTrack(currentTrack);
    } else if (c == 's') {
      stopPlayback();
    } else if (c == '+' || c == '-') {
      gain += (c == '+') ? 0.1f : -0.1f;
      gain = constrain(gain, 0.0f, 2.0f);
      if (out) out->SetGain(gain);
      Serial.printf("gain=%.1f\n", gain);
    }
  }
  if (PIN_NEXT_SW >= 0 && digitalRead(PIN_NEXT_SW) == LOW) {
    delay(30);
    if (digitalRead(PIN_NEXT_SW) == LOW) {
      currentTrack = (currentTrack + 1) % PLAYLIST_LEN;
      startTrack(currentTrack);
      while (digitalRead(PIN_NEXT_SW) == LOW) delay(10);
    }
  }
}

The controls are as follows.

What you should see at boot

If the songs are stored correctly, the serial monitor shows something like this.

Song partition: start=0x110000  size=3080192 bytes
--- Files in LittleFS ---
  00001.mp3          681866 bytes
  00002.mp3          763525 bytes
  00003.mp3          742992 bytes
Playing: /00001.mp3 (OK)

What went wrong on the way to sound

The setups I went through

Pitfalls at a glance

1. No sound from the internal DAC

I had no I2S amplifier at first, so I tried feeding an analog amp (a GF1002 board with a PAM8403) from the ESP32’s internal DAC on GPIO25/26.

out = new AudioOutputI2S(0, AudioOutputI2S::INTERNAL_DAC);

It compiles, but the speaker gave only hiss.

In ESP8266Audio 2.4.1 this form is deprecated. The constructor in AudioOutputI2S.h carries a message telling you to use AudioOutputInternalDAC() for DAC output.

What helped me narrow it down was a sketch that outputs a sine wave with dacWrite() alone, without the library. That produced sound, which told me the wiring and the amp were fine and the problem was how I was using the library.

2. NoDAC output into a PAM8403 plays, but with noise

Next I tried AudioOutputI2SNoDAC. It puts a 1-bit signal on the I2S data pin, which you smooth with an RC filter (1 kΩ + 10 nF) and feed to an analog amp.

The music played, but with a constant hiss. Raising the oversampling ratio and changing the capacitor to 22 nF did not bring it down far enough.

At this point I decided to switch to an amplifier with an I2S input.

Reference: PAM8403 wiring examples (image search)

3. The module’s DATA pin is not the amplifier input

The module I bought carries both an NS4168 (amplifier) and an LMD2718 (MEMS microphone). It has two data pins.

I was sending audio into DATA, so nothing came out. After reading the pin description on the product page I moved the wire to SDATA, and it played.

On the board itself the amplifier input is printed as SDA. You can see it in the module photo above, grouped with LRCLK and BCLK, while DATA and CLK are grouped as the microphone pins.

The serial monitor kept printing “OK” for playback the whole time, so I assumed the fault was in the software. This is where I lost the most time.

4. Silent with 16 kHz files (the real cause was the wiring)

To save space I first encoded the MP3s at 32 kbps and 16 kHz. Those were silent.

When I played the same test melody and changed only the output rate, sound came out only at 44100 Hz. I concluded that the sample rate was the cause and re-encoded the MP3s at 44.1 kHz.

A reader on X suggested capturing LRCLK and BCLK at the amplifier pins, so I measured again with the wiring fixed.

Clock measurement

I counted LRCLK and BCLK at the amp board’s pins with the ESP32’s own pulse counter. The source was a 440 Hz tone, and only the sample rate changed.

These values are from starting at 44100 Hz and then switching with SetRate(). Starting directly at each rate gave the same result.

MP3 check

Next I played the same song encoded three ways. The 16 kHz file that had been silent now plays.

What this shows:

• 16 kHz audio plays. The sample rate was not the cause of the silence.
• I do not know why only 44100 Hz produced sound while the wire was on the wrong pin.
• After fixing a wiring mistake, earlier test results need to be taken again.

I ran these checks on my own board at 3.3 V. For the same song, the 16 kHz, 32 kbps file is 454,833 bytes, about two thirds of the 44.1 kHz, 48 kbps file (681,866 bytes). The high frequencies are cut, but it is an option when space matters more.

5. Mount fails with “Corrupted dir pair”

After reflashing the sketch many times, LittleFS stopped mounting.

E (326) esp_littlefs: ... lfs.c:1383:error: Corrupted dir pair at {0x1, 0x0}
E (327) esp_littlefs: mount failed,  (-84)

Flashing the LittleFS image again at the same address fixed it. I do not know why it was corrupted.

6. Small things

Building an amp board around the NS4168

Once the module worked, I designed a board with only the amplifier, without the microphone, and had JLCPCB build it.

Circuit highlights

The decoupling (100 µF + 1 µF) and the output filter (1000 Ω bead + 1 nF) follow the datasheet (NS4168, Nsiway, Apr. 2023, V1.2). The datasheet is in Chinese.

Bill of materials

The LCSC part numbers are there because JLCPCB assembled the board. JLCPCB sorts parts into Basic and Extended; Extended parts carry an extra fee per part type.

Why 3.3 V

The NS4168’s digital input threshold scales with the supply voltage (VIH = 0.7 × VDD). The ESP32 outputs 3.3 V logic.

The module ran at 5 V, but for my own board I chose 3.3 V so the logic levels are in spec. No level shifter is needed.

The output power is lower (datasheet figures: 1.2 W at 3.6 V into 4 Ω, 2.5 W at 5 V into 4 Ω).

The CTRL pin

CTRL selects one of three states by voltage.

ESP8266Audio sends a mono source to both left and right, so either channel gives the same sound. I tied CTRL to VDD through R1, which selects the right channel.

I2S is not I2C

The names are similar, but they are different buses.

Mistakes caught before ordering

Before ordering I reviewed the schematic, the BOM, and the Gerbers separately. That turned up eight problems.

Schematic

On the NS4168, pin 2 is LRCLK and pin 3 is BCLK. I had placed the net names from the top down, and that reversed them.

BOM

Moving to Basic parts reduces the extra fees for Extended parts. The corrected list is the bill of materials shown above.

Layout

I compared the copper connectivity in the Gerbers against the schematic and confirmed there were no shorts and no open nets.

The datasheet asks for output traces that are short and wide. I left the connector where it was this time, so SPK+ runs a long way through the ground pour on the bottom layer. On the next revision I plan to move the connector next to the output.

Testing the finished board

I connected the finished board to the ESP32 DevKit. The sketch is the same one I used on the breadboard.

Does the SD pin shut the amplifier down?

The SD pin connects to CTRL through R6 (1 kΩ). CTRL is pulled up to 3.3 V by R1 (10 kΩ).

For the test I wrote a sketch that keeps a 440 Hz tone playing and toggles only the SD pin. This is the part that does the switching.

constexpr int PIN_AMP_SD = 27;   // to SD on the board
void setAmp(bool on) {
  if (on) {
    pinMode(PIN_AMP_SD, INPUT);      // Hi-Z: R1 pulls CTRL up to 3.3 V
  } else {
    digitalWrite(PIN_AMP_SD, LOW);   // set the level low first, then enable the output
    pinMode(PIN_AMP_SD, OUTPUT);     // CTRL = about 0.3 V
  }
}

When the SD pin went low, the sound stopped. The ESP32 keeps sending I2S the whole time, so it is the amplifier that stops.

Not yet verified

Summary

• MP3 files stored in the ESP32’s internal flash (LittleFS) play through an I2S amplifier with ESP8266Audio.
• The silence came from a wrong pin (DATA instead of SDATA). I blamed the sample rate because I had tested it while that wiring mistake was still in place.
• After fixing a wiring mistake, take the earlier test results again.
• “Playing: OK” on the serial port does not mean sound is coming out. A minimal test without the library (a sine wave, a built-in melody) separates wiring problems from software problems quickly.
• Reviewing the schematic, the BOM, and the Gerbers separately before ordering finds mistakes. Because those were fixed first, the board worked on the first build.
• At 3.3 V the NS4168 is loud enough for a small toy speaker.

Links

• ESP8266Audio
• arduino-littlefs-upload (LittleFS upload plugin for Arduino IDE 2.x)
• esptool v5 migration guide
• NS4168 on JLCPCB