ESP32 - Mini MP3-Spieler
Der ESP32 ist ein vielseitiger 3,3-V-Mikrocontroller mit WiFi, Bluetooth und mehreren Hardware-Seriellen Anschlüssen. In Kombination mit dem DIYables Mini MP3-Spieler-Modul können Sie alles von einer einfachen Soundeffekt-Platine bis zu einem WiFi-gesteuerten Jukebox bauen.
Dieses Tutorial führt Sie durch:
- Verbinden des Mini MP3-Spielers mit einem ESP32 — direkt, ohne Widerstand.
- Laden von MP3-Dateien auf die SD-Karte korrekt.
- Abspielen, Pausieren, Fortsetzen, Stoppen und Überspringen von Tracks.
- Einstellen der Lautstärke mit physischen Tasten.
- Wiederholen von Tracks, Shuffle und Organisieren von Audio in Ordnern.
- Überwachung des Wiedergabestatus von Ihrem Code.
Erforderliche Komponenten
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 Starter-Kit (ESP32 enthalten) | |
| 1 | × | DIYables Sensor-Kit (18 Sensoren/Displays) |
Offenlegung: Einige der in diesem Abschnitt bereitgestellten Links sind Amazon-Affiliate-Links. Wir können eine Provision für Käufe erhalten, die über diese Links getätigt werden, ohne zusätzliche Kosten für Sie. Wir schätzen Ihre Unterstützung.
Kein Widerstand erforderlich. Der ESP32 arbeitet mit 3,3 V — die gleiche Spannung, die der Mini MP3-Spieler UART erwartet.
Das Mini MP3-Spieler-Modul
Der DIYables Mini MP3-Spieler ist eine kleine Platine, die auf dem YX5200-24SS-Chip basiert. Sie dekodiert MP3-Dateien von einer Micro-SD-Karte und kann einen Lautsprecher direkt über ihren eingebauten 3-W-Verstärker antreiben. Alternativ können Sie die DAC-Pins verwenden, um einen externen Verstärker für lautere Ausgabe zu speisen.
Alles wird über serielle Befehle mit 9600 Baud gesteuert:
- Transport: Abspielen, Pausieren, Fortsetzen, Stoppen, Weiter, Zurück
- Lautstärke: 31 Stufen (0–30)
- Equalizer: Normal, Pop, Rock, Jazz, Classic, Bass
- Wiederholen: Einzelnen Track wiederholen, Ordner wiederholen, Alle Tracks wiederholen, Zufälliges Shuffle
- Ordner: Abspielen aus nummerierten Verzeichnissen auf der Karte
- Ankündigungen: Wiedergabe unterbrechen und dann fortsetzen
- Abfragen: Tracknummer, Lautstärke, Wiedergabestatus, Track-Anzahl lesen
Pin-Beschreibung
| Pin | Zweck |
|---|---|
| VCC | 3,2V bis 5,0V Stromversorgung |
| GND | Masse |
| RX | Serielles Dateneingangssignal (an ESP32 TX anschließen) |
| TX | Serielles Datenausgangssignal (an ESP32 RX anschließen) |
| SPK_1 | Lautsprecher + (eingebauter Verstärker, 3W max) |
| SPK_2 | Lautsprecher − |
| DAC_R | Rechter Kanal Linienausgang |
| DAC_L | Linker Kanal Linienausgang |
| BUSY | LOW = wird abgespielt, HIGH = gestoppt |
| IO_1 | Kurzer Druck → vorheriger Track; langer Druck → Lautstärke runter |
| IO_2 | Kurzer Druck → nächster Track; langer Druck → Lautstärke rauf |
Verkabelung
Der ESP32 verwendet nativ eine 3,3V-Logik, daher verbinden Sie die Serienleitungen direkt — kein Pegelumschalter oder Widerstände erforderlich.
Wir empfehlen die Verwendung von Serial2 (standardmäßig auf den meisten ESP32 DevKit-Boards verfügbar):
| Mini MP3-Spieler | ESP32 | Notizen |
|---|---|---|
| VCC | 3.3V | Oder 5V von VIN falls verfügbar |
| GND | GND | |
| RX | GPIO 17 (TX2) | Direktverbindung |
| TX | GPIO 16 (RX2) | Direktverbindung |
| SPK_1 | Lautsprecher + | |
| SPK_2 | Lautsprecher − |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Wenn Sie nicht wissen, wie Sie ESP32 und andere Komponenten mit Strom versorgen, finden Sie Anleitungen im folgenden Tutorial: Wie man ESP32 mit Strom versorgt.
Tipp: Falls Ihr ESP32-Variante nicht GPIO 16/17 verfügbar macht (einige DevKit-C V4 Boards verwenden sie für PSRAM), können Sie Serial2 Pins im Code neu zuordnen:
Serial2.begin(9600, SERIAL_8N1, 4, 5); // RX=GPIO4, TX=GPIO5
SD-Karte vorbereiten
- Formatieren Sie als FAT16 oder FAT32.
- Platzieren Sie MP3-Dateien im Stammverzeichnis:
/001.mp3
/002.mp3
/003.mp3
- Für organisierte Wiedergabe verwenden Sie nummerierte Ordner:
/01/001.mp3
/01/002.mp3
/02/001.mp3
Wichtige Hinweise:
- Tracknummern beginnen bei 1.
- Das Modul indiziert Tracks nach der Reihenfolge, in der sie auf die Karte kopiert wurden, nicht nach dem Dateinamen. Formatieren Sie immer zuerst, dann kopieren Sie nacheinander.
- Ordnernamen: 01–99 (2-stellig), Dateinamen: 001–255 (3-stellig).
Installieren der Bibliothek
- Verbinden Sie den ESP32 mit Ihrem Computer.
- In der Arduino IDE wählen Sie Ihr ESP32-Board und den richtigen Port.
- Öffnen Sie den Bibliotheken-Manager.
- Suchen Sie "DIYables_MiniMp3" und installieren Sie die Bibliothek von DIYables.
Keine Abhängigkeiten — funktioniert sofort einsatzbereit.
Starter-Code-Vorlage
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup() {
Serial.begin(115200); // Debug output
Serial2.begin(9600); // Mp3 module communication
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(25); // 0 = silence, 30 = maximum
}
void loop() {
// Add your logic
}
ESP32 Code — Einen Track abspielen
/*
* 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 (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* 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>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
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
}
Probieren Sie es aus
- Laden Sie die SD-Karte, verbinden Sie das Modul, verbinden Sie den ESP32 über USB.
- Wählen Sie Ihr ESP32-Board in der IDE und laden Sie es hoch.
Wiedergabesteuerung
| Methode | Was passiert | Code-Beispiel |
|---|---|---|
| play(n) | Spielt Track Nummer n ab | mp3.play(1) |
| playNext() | Wechselt zum nächsten Track | mp3.playNext() |
| playPrevious() | Geht einen Track zurück | mp3.playPrevious() |
| pause() | Friert die Wiedergabe ein | mp3.pause() |
| resume() | Nimmt an der Stelle wieder auf, an der es aufgehört hat | mp3.resume() |
| stop() | Beendet die Wiedergabe vollständig | mp3.stop() |
ESP32 Code — Mehrere 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 (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* 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>
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);
Serial2.begin(9600);
mp3.begin(Serial2);
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();
}
}
ESP32 Code — Lautstärketasten
/*
* 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 GPIO1 to volume up, pin GPIO3 to volume down.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin GPIO1 (other leg to GND)
* Button DOWN -> Pin GPIO3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = 1;
const int BUTTON_VOL_DOWN = 3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
pinMode(BUTTON_VOL_UP, INPUT_PULLUP);
pinMode(BUTTON_VOL_DOWN, INPUT_PULLUP);
mp3.begin(Serial2);
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
}
}
Lautstärke-API
| Methode | Aktion | Beispiel |
|---|---|---|
| setVolume(v) | Springe zu Stufe v | mp3.setVolume(20) |
| volumeUp() | Erhöhe um 1 | mp3.volumeUp() |
| volumeDown() | Verringere um 1 | mp3.volumeDown() |
| getVolume() | Aktuelle Stufe lesen | mp3.getVolume() |
ESP32 Code — Weiter/Zurück
/*
* DIYables Mini Mp3 Player - Next/Previous with Buttons
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Use two buttons to play next/previous tracks.
* Displays the current track number on the Serial Monitor.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> Pin GPIO1 (other leg to GND)
* Button PREV -> Pin GPIO3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
const int BUTTON_NEXT = 1;
const int BUTTON_PREV = 3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
pinMode(BUTTON_NEXT, INPUT_PULLUP);
pinMode(BUTTON_PREV, INPUT_PULLUP);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(20);
mp3.play(1); // Start with track 1
Serial.println("Press NEXT or PREV button to change track");
}
void loop()
{
if (digitalRead(BUTTON_NEXT) == LOW)
{
Serial.println("Next track");
mp3.playNext();
delay(300); // Simple debounce
}
if (digitalRead(BUTTON_PREV) == LOW)
{
Serial.println("Previous track");
mp3.playPrevious();
delay(300); // Simple debounce
}
}
ESP32 Code — Pausieren/Fortsetzen
/*
* 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 (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin GPIO1 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = 1;
bool paused = false;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
mp3.begin(Serial2);
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
}
}
ESP32 Code — Track in Schleife
/*
* 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 (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* 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>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
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
}
Wiederholen und Shuffle
| Methode | Verhalten | Beispiel |
|---|---|---|
| loopTrack(n) | Endlos Track n wiederholen | mp3.loopTrack(1) |
| loopFolder(f) | Alle Tracks in Ordner f wiederholen | mp3.loopFolder(1) |
| loopAll() | Alle Tracks wiederholen | mp3.loopAll() |
| stopLoop() | Aktive Schleife abbrechen | mp3.stopLoop() |
| shuffle() | Wiedergabe randomisieren | mp3.shuffle() |
ESP32 Code — Ordner-Wiedergabe
/*
* 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 (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* 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>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
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
}
Ordner-API
| Methode | Beschreibung | Beispiel |
|---|---|---|
| playFolder(f, t) | Spiele Track t aus Ordner f ab | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Großer Ordner (15 Ordner, 3000 Tracks) | mp3.playLargeFolder(1, 2000) |
| playFromMP3Folder(t) | Abspielen aus /mp3 Ordner | mp3.playFromMP3Folder(1) |
ESP32 Code — Serielle Monitor-Steuerung
/*
* 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 (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* 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>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
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;
}
}
}
| Befehl | Auswirkung |
|---|---|
| 1–9 | Track abspielen |
| + / − | Lautstärke |
| p / r / s | Pausieren / Fortsetzen / Stoppen |
| n / b | Weiter / Zurück |
| ? | Status |
Equalizer-Optionen
| Konstante | ID | Zeichen |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Neutral |
| DIYables_MiniMp3::EQ_POP | 1 | Helligkeit |
| DIYables_MiniMp3::EQ_ROCK | 2 | Punchy |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Warm |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Ausgeglichen |
| DIYables_MiniMp3::EQ_BASS | 5 | Tiefbass |
mp3.setEQ(DIYables_MiniMp3::EQ_BASS);
Überprüfung des Modulstatus
Diese Funktionen blockieren bis zu 100 ms, während sie auf die Antwort des Moduls warten. Sie geben −1 zurück, wenn keine Antwort ankommt.
| Funktion | Rückgabe | Beschreibung |
|---|---|---|
| isPlaying() | bool | true während aktiver Wiedergabe |
| getVolume() | int16_t | Aktuelle Lautstärke (0–30) |
| getEQ() | int16_t | Aktiver Equalizer (0–5) |
| getTrackCount() | int16_t | Gesamtanzahl Tracks auf SD |
| getCurrentTrack() | int16_t | Gerade abgespielte Tracknummer |
| getFolderCount() | int16_t | Gesamtordner auf SD |
| getTrackCountInFolder(f) | int16_t | Tracks in Ordner f |