Arduino Nano ESP32 - Mini Mp3 Player Module
The Arduino Nano ESP32 is a powerful 3.3V board with built-in WiFi and Bluetooth. In this tutorial, we will pair it with the DIYables Mini Mp3 Player module to build a fully controllable mp3 player. Here is what we will go through:
- Connecting the module to the Nano ESP32 — no resistor needed thanks to 3.3V logic levels.
- Preparing the SD card with properly named mp3 files.
- Writing code to play, pause, resume, stop, and skip tracks.
- Controlling volume through buttons and serial commands.
- Setting up track looping, full shuffle, and folder-based playback.
- Reading the module's status (current track, volume, play state).
Hardware Preparation
Or you can buy the following kits:
| 1 | × | DIYables Sensor Kit (30 sensors/displays) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Disclosure: Some of the links provided in this section are Amazon affiliate links. We may receive a commission for any purchases made through these links at no additional cost to you.
Additionally, some of these links are for products from our own brand, DIYables .
Additionally, some of these links are for products from our own brand, DIYables .
Note: No 1K resistor is needed — the Nano ESP32 uses 3.3V logic, which matches the module natively.
Mini Mp3 Player Module Overview
The DIYables Mini Mp3 Player is a self-contained mp3 decoder module powered by the YX5200-24SS chip. Insert a micro SD card with mp3 files, connect a small speaker, and send serial commands to control playback.
The module accepts 9600 baud UART commands and provides these features:
- Full playback control: play, pause, resume, stop, next, previous
- 31 volume levels (0 through 30)
- 6 equalizer presets (Normal, Pop, Rock, Jazz, Classic, Bass)
- Repeat modes: single track loop, folder loop, loop all, shuffle
- Folder-organized playback for categorized audio
- Advertisement insertion (interrupt and resume)
- Real-time status queries
Pinout
| Pin | Function |
|---|---|
| VCC | 3.2V to 5.0V power supply |
| GND | Ground |
| RX | UART input (connect to board TX) |
| TX | UART output (connect to board RX) |
| SPK_1 | Speaker + (onboard 3W amplifier) |
| SPK_2 | Speaker − |
| DAC_R | Right line-level output |
| DAC_L | Left line-level output |
| BUSY | LOW = playing, HIGH = idle |
| IO_1 | Short press → previous, long press → volume down |
| IO_2 | Short press → next, long press → volume up |
Wiring Diagram
The Nano ESP32 operates at 3.3V logic — the same voltage the Mini Mp3 Player uses internally. This means you can connect TX/RX directly without any resistor.
We will use Serial1 on the Nano ESP32 for communication with the module, keeping the default Serial free for the Serial Monitor.
| Mini Mp3 Player | Arduino Nano ESP32 | Notes |
|---|---|---|
| VCC | 3.3V | Module also accepts 5V from VBUS if needed |
| GND | GND | |
| RX | TX1 (D5) | Direct connection — no resistor needed |
| TX | RX1 (D4) | Direct connection |
| SPK_1 | Speaker + | |
| SPK_2 | Speaker − |
This image is created using Fritzing. Click to enlarge image
SD Card Setup
Prepare the micro SD card before inserting it into the module:
- Format as FAT16 or FAT32.
- Copy mp3 files to the root with zero-padded names:
/001.mp3
/002.mp3
/003.mp3
For folder playback:
/01/001.mp3
/01/002.mp3
/02/001.mp3
Remember:
- Track numbering starts at 1 (not 0).
- The module determines track order from the copy sequence, not filenames. Format the card first, then copy files individually in order.
- Folder names: 2 digits, zero-padded (01–99). File names inside: 3 digits, zero-padded (001–255).
Library Installation
- Connect the Nano ESP32 to your computer via USB-C.
- Open the Arduino IDE, select Arduino Nano ESP32 as your board, and choose the correct port.
- Go to the Libraries panel on the left.
- Search for "DIYables_MiniMp3" and install the library by DIYables.
- Click Install.
The library has zero external dependencies.
Nano ESP32 Code — Basic Template
Since the Nano ESP32 has hardware serial ports, we use Serial1 instead of SoftwareSerial:
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup() {
Serial.begin(115200);
Serial1.begin(9600); // Hardware serial for the mp3 module
mp3.begin(Serial1);
delay(1000); // Wait for the module to boot
mp3.setVolume(25);
}
void loop() {
// Your code here
}
No SoftwareSerial library needed! Hardware serial is more reliable, especially at the low 9600 baud rate this module uses.
Nano ESP32 Code — Play a Single Track
/*
* DIYables Mini Mp3 Player - Play One Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays track 001 once, then stops.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Set volume (0 to 30)
Serial.println("Playing track 1...");
mp3.play(1); // Play track 001.mp3
}
void loop()
{
// Nothing to do here
}
How To Test
- Load the SD card with mp3 files and insert it into the module.
- Wire the module to the Nano ESP32 as shown above (no resistor!).
- Connect the board via USB-C, select Arduino Nano ESP32, and upload.
You should hear track 001.mp3 through the connected speaker.
Playback Commands
| Method | Purpose | Example |
|---|---|---|
| play(trackNum) | Start a specific track | mp3.play(1) |
| playNext() | Advance to the next track | mp3.playNext() |
| playPrevious() | Go to the previous track | mp3.playPrevious() |
| pause() | Pause the active track | mp3.pause() |
| resume() | Unpause the track | mp3.resume() |
| stop() | Halt playback | mp3.stop() |
Nano ESP32 Code — Play Multiple Tracks
/*
* DIYables Mini Mp3 Player - Play Multiple Tracks
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays tracks one after another with a delay between them.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, 003.mp3
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
int currentTrack = 1;
int totalTracks = 3; // Change this to match your SD card
unsigned long lastTrackTime = 0;
unsigned long trackDuration = 5000; // Wait 5 seconds between tracks (adjust as needed)
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
Serial.println("Playing track 1...");
mp3.play(currentTrack);
lastTrackTime = millis();
}
void loop()
{
// After trackDuration, play the next track
if (millis() - lastTrackTime >= trackDuration)
{
currentTrack++;
if (currentTrack > totalTracks)
currentTrack = 1; // Loop back to first track
Serial.print("Playing track ");
Serial.println(currentTrack);
mp3.play(currentTrack);
lastTrackTime = millis();
}
}
How To Test
- Ensure the SD card has at least 3 tracks. Upload, and the tracks will rotate every 5 seconds.
Nano ESP32 Code — Volume Control
/*
* DIYables Mini Mp3 Player - Volume Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Use two buttons to increase/decrease the volume.
* Press button on pin D2 to volume up, pin D3 to volume down.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin D2 (other leg to GND)
* Button DOWN -> Pin D3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = D2;
const int BUTTON_VOL_DOWN = D3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
pinMode(BUTTON_VOL_UP, INPUT_PULLUP);
pinMode(BUTTON_VOL_DOWN, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(volume);
mp3.loopTrack(1); // Play track 1 on repeat
Serial.print("Volume: ");
Serial.println(volume);
}
void loop()
{
// Volume Up button (pressed = LOW because of INPUT_PULLUP)
if (digitalRead(BUTTON_VOL_UP) == LOW)
{
if (volume < 30)
{
volume++;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
// Volume Down button
if (digitalRead(BUTTON_VOL_DOWN) == LOW)
{
if (volume > 0)
{
volume--;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
}
How To Test
- Wire two buttons, upload the sketch, and press buttons while music plays.
Volume Commands
| Method | Purpose | Example |
|---|---|---|
| setVolume(v) | Jump to a specific volume level | mp3.setVolume(20) |
| volumeUp() | Increase by 1 step | mp3.volumeUp() |
| volumeDown() | Decrease by 1 step | mp3.volumeDown() |
| getVolume() | Query the current level | mp3.getVolume() |
Nano ESP32 Code — Pause/Resume Toggle
/*
* DIYables Mini Mp3 Player - Pause and Resume
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Demonstrates pausing and resuming playback using a single button.
* Press the button to toggle between pause and resume.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin D2 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = D2;
bool paused = false;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
mp3.play(1);
Serial.println("Playing. Press button to pause/resume.");
}
void loop()
{
if (digitalRead(BUTTON_PIN) == LOW)
{
if (paused)
{
mp3.resume();
Serial.println("Resumed");
}
else
{
mp3.pause();
Serial.println("Paused");
}
paused = !paused;
delay(300); // Simple debounce
}
}
Nano ESP32 Code — Loop a Track
/*
* DIYables Mini Mp3 Player - Loop Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Loops (repeats) a track continuously with EQ setting.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /001.mp3
* /002.mp3
* ...
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Volume: 0 to 30
mp3.setEQ(DIYables_MiniMp3::EQ_NORMAL);
Serial.println("Playing track 1 on loop...");
mp3.loopTrack(1);
}
void loop()
{
// Your code here
}
Repeat & Shuffle Commands
| Method | Purpose | Example |
|---|---|---|
| loopTrack(t) | Keep replaying one track | mp3.loopTrack(1) |
| loopFolder(f) | Replay all tracks in a folder | mp3.loopFolder(1) |
| loopAll() | Replay everything on the card | mp3.loopAll() |
| stopLoop() | End the current repeat mode | mp3.stopLoop() |
| shuffle() | Randomize playback order | mp3.shuffle() |
Nano ESP32 Code — Play from Folder
/*
* DIYables Mini Mp3 Player - Play from Folder
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays tracks from specific folders on the SD card.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /01/001.mp3 <- playFolder(1, 1)
* /01/002.mp3 <- playFolder(1, 2)
* /02/001.mp3 <- playFolder(2, 1)
* /02/002.mp3 <- playFolder(2, 2)
*
* IMPORTANT:
* - Numbering starts from 1, NOT 0
* - Folder names must be 2-digit zero-padded (01-99)
* - Track names must be 3-digit zero-padded (001-255)
* - Format SD card as FAT32, then copy files one by one in order
* - Track order is determined by the order files were copied,
* NOT by filename. So copy them in the correct sequence.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
// Play track 1 from folder 01
Serial.println("Playing folder 01, track 001...");
mp3.playFolder(1, 1);
delay(5000);
// Play track 2 from folder 01
Serial.println("Playing folder 01, track 002...");
mp3.playFolder(1, 2);
delay(5000);
// Play track 1 from folder 02
Serial.println("Playing folder 02, track 001...");
mp3.playFolder(2, 1);
}
void loop()
{
// Nothing to do here
}
Folder Methods
| Method | Purpose | Example |
|---|---|---|
| playFolder(f, t) | Select track t from folder f | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Large folder mode (up to 3000 tracks) | mp3.playLargeFolder(1, 1500) |
| playFromMP3Folder(t) | Access the special /mp3 folder | mp3.playFromMP3Folder(1) |
Nano ESP32 Code — Serial Monitor Control
/*
* DIYables Mini Mp3 Player - Serial Command Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Control the Mp3 player by typing commands in the Serial Monitor.
* Great for testing all functions without extra hardware.
*
* Commands (type in Serial Monitor, then press Enter):
* 1-9 Play track 1 to 9
* + Volume up
* - Volume down
* p Pause
* r Resume
* s Stop
* n Next track
* b Previous track (back)
* ? Show current status
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
Serial.println("=== DIYables Mini Mp3 Player ===");
Serial.println("Commands:");
Serial.println(" 1-9 Play track number");
Serial.println(" + Volume up");
Serial.println(" - Volume down");
Serial.println(" p Pause");
Serial.println(" r Resume");
Serial.println(" s Stop");
Serial.println(" n Next track");
Serial.println(" b Previous track");
Serial.println(" ? Show status");
Serial.println("================================");
}
void loop()
{
if (Serial.available())
{
char cmd = Serial.read();
switch (cmd)
{
case '1': case '2': case '3':
case '4': case '5': case '6':
case '7': case '8': case '9':
Serial.print("Playing track ");
Serial.println(cmd - '0');
mp3.play(cmd - '0');
break;
case '+':
Serial.println("Volume up");
mp3.volumeUp();
break;
case '-':
Serial.println("Volume down");
mp3.volumeDown();
break;
case 'p':
Serial.println("Paused");
mp3.pause();
break;
case 'r':
Serial.println("Resumed");
mp3.resume();
break;
case 's':
Serial.println("Stopped");
mp3.stop();
break;
case 'n':
Serial.println("Next track");
mp3.playNext();
break;
case 'b':
Serial.println("Previous track");
mp3.playPrevious();
break;
case '?':
{
Serial.println("--- Status ---");
int16_t vol = mp3.getVolume();
Serial.print("Volume: ");
Serial.println(vol);
int16_t track = mp3.getCurrentTrack();
Serial.print("Current track: ");
Serial.println(track);
bool playing = mp3.isPlaying();
Serial.print("Playing: ");
Serial.println(playing ? "Yes" : "No");
int16_t total = mp3.getTrackCount();
Serial.print("Total tracks: ");
Serial.println(total);
Serial.println("--------------");
break;
}
default:
break;
}
}
}
Serial Commands
| Input | Result |
|---|---|
| 1–9 | Play that track |
| + / − | Volume up / down |
| p | Pause |
| r | Resume |
| s | Stop |
| n | Next track |
| b | Previous track |
| ? | Display status |
Equalizer Presets
| Constant | ID | Tone | ||
|---|---|---|---|---|
| DIYables_MiniMp3 | EQ_NORMAL | 0 | Neutral | |
| DIYables_MiniMp3 | EQ_POP | 1 | Pop | |
| DIYables_MiniMp3 | EQ_ROCK | 2 | Rock | |
| DIYables_MiniMp3 | EQ_JAZZ | 3 | Jazz | |
| DIYables_MiniMp3 | EQ_CLASSIC | 4 | Classical | |
| DIYables_MiniMp3 | EQ_BASS | 5 | Bass boost |
mp3.setEQ(DIYables_MiniMp3::EQ_POP);
Status Query Functions
Each query blocks for up to 100 ms. Returns −1 on timeout.
| Method | Returns | Info |
|---|---|---|
| isPlaying() | bool | Whether a track is active |
| getVolume() | int16_t | Volume (0–30) |
| getEQ() | int16_t | EQ preset (0–5) |
| getTrackCount() | int16_t | Total tracks on card |
| getCurrentTrack() | int16_t | Currently playing track |
| getFolderCount() | int16_t | Number of folders |
| getTrackCountInFolder(f) | int16_t | Tracks in folder f |