ESP32 S3 - Mini-MP3-Player
Der ESP32 S3 ist ein leistungsstarkes 3,3V-Entwicklungsboard mit Dual-Core-Verarbeitung und umfangreicher Peripherieunterstützung und damit eine ausgezeichnete Wahl für Audioprojekte. In diesem Tutorial lernen Sie, wie Sie mit dem DIYables Mini-MP3-Player-Modul und Ihrem ESP32 S3 Board ein komplettes MP3-Player-System bauen.
Was Sie bauen werden:
- Einen funktionierenden MP3-Player, der Audiodateien von einer microSD-Karte abspielt
- Eine Lautstärkeregelung mit physischen Tastern
- Eine Titelnavigation mit Vor- und Zurück-Steuerung
- Ein Steuerpult im Serial Monitor zum Testen aller Wiedergabefunktionen
Erforderliche Hardware
Oder Sie können die folgenden Kits kaufen:
| 1 | × | DIYables ESP32 S3 Starter-Kit (ESP32 S3 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.
Überblick über the Mini Mp3 Player Module
Der DIYables Mini-MP3-Player ist ein MP3-Decodermodul auf Basis des YX5200-24SS, das Audiodateien von einer microSD-Karte über einen eingebauten Verstärker abspielt. Er kommuniziert über UART-Serial mit 9600 Baud und enthält einen 3W-Verstärker zum direkten Anschluss eines Lautsprechers – eine in sich geschlossene Audiolösung, die keinen externen Decoder- oder Verstärker-IC benötigt.
Wichtige Spezifikationen
- Betrieb mit 3,3V–5V (ideal für die 3,3V-Logik des ESP32 S3)
- Steuerung über UART-Serial mit 9600 Baud
- Eingebauter 3W-Verstärker zum direkten Anschluss eines Lautsprechers
- Unterstützt bis zu 255 Titel und 99 Ordner
- 31 Lautstärkestufen (0–30)
- 6 Equalizer-Voreinstellungen (Normal, Pop, Rock, Jazz, Classic, Bass)
- Mehrere Wiederholungs- und Zufallsmodi
- Statusabfragen für Lautstärke, Titelnummer und Wiedergabezustand
- Kein externer Decoder- oder Verstärker-IC erforderlich
- Einsteigerfreundlich dank einfacher serieller Befehle
Pinbelegung
Das Mini-MP3-Player-Modul hat 11 Pins für Stromversorgung, Kommunikation, Audioausgang und Steuerfunktionen.
- VCC: Stromversorgung (3,2V–5,0V)
- GND: Masseanschluss
- RX: UART-Empfang (mit dem TX-Pin des ESP32 S3 verbinden)
- TX: UART-Senden (mit dem RX-Pin des ESP32 S3 verbinden)
- SPK_1: Pluspol des Lautsprechers (eingebauter 3W-Verstärker)
- SPK_2: Minuspol des Lautsprechers
- DAC_R: Audioausgang rechter Kanal mit Line-Pegel
- DAC_L: Audioausgang linker Kanal mit Line-Pegel
- BUSY: Status-Pin (LOW während der Wiedergabe, HIGH im Leerlauf)
- IO_1: Tastereingang (kurz drücken = vorheriger Titel, lang drücken = leiser)
- IO_2: Tastereingang (kurz drücken = nächster Titel, lang drücken = lauter)
Verdrahtungsdiagramm
Schließen Sie den Mini-MP3-Player über die Hardware-Schnittstelle Serial1 an Ihren ESP32 S3 an, die eine zuverlässige UART-Kommunikation mit der erforderlichen Baudrate bietet. Der ESP32 S3 arbeitet mit 3,3V-Logik, die perfekt zu den Signalpegeln des Moduls passt, sodass an den TX/RX-Leitungen keine Pegelwandler-Widerstände nötig sind.
Sicherheitshinweise
Versorgen Sie das Modul für Anwendungen mit geringer Lautstärke über den 3,3V-Pin oder über 5V (VBUS), wenn Sie die maximale Lautsprecherlautstärke benötigen – der eingebaute Verstärker arbeitet mit höherer Versorgungsspannung besser. Verbinden Sie immer zuerst GND, bevor Sie Spannung anlegen, und stellen Sie sicher, dass die Impedanz Ihres Lautsprechers zur 3W-Verstärkerleistung des Moduls passt, um Schäden zu vermeiden.
| Mini-MP3-Player | ESP32 S3 | Hinweise |
|---|---|---|
| VCC | 3.3V | Das Modul akzeptiert bei Bedarf auch 5V von VBUS |
| GND | GND | Gemeinsame Masse |
| RX | TX1 (GPIO17) | Direkte Verbindung – kein Widerstand nötig |
| TX | RX1 (GPIO18) | Direkte Verbindung – 3,3V-Logik-kompatibel |
| SPK_1 | Lautsprecher + | Verstärkter Ausgang |
| SPK_2 | Lautsprecher − | Verstärkter Ausgang |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
SD-Karten-Einrichtung
Der Mini-MP3-Player benötigt korrekt formatierte und benannte Dateien auf Ihrer microSD-Karte.
Anforderungen an die Formatierung:
- Dateisystem: FAT16 oder FAT32
- Kartengröße: bis zu 32GB empfohlen
Einfache Dateibenennung (Stammverzeichnis):
/001.mp3
/002.mp3
/003.mp3
Ordnerbasierte Benennung (organisierte Wiedergabe):
/01/001.mp3
/01/002.mp3
/02/001.mp3
Wichtige Benennungsregeln:
- Die Titelnummerierung beginnt bei 1 (nicht bei 0)
- Dateien im Stammverzeichnis: dreistellige Namen mit führenden Nullen (001–255)
- Ordnernamen: zweistellig mit führenden Nullen (01–99)
- Dateien in Ordnern: dreistellig mit führenden Nullen (001–255)
- Die Kopierreihenfolge ist entscheidend: Das Modul bestimmt die Wiedergabereihenfolge anhand der Reihenfolge, in der die Dateien kopiert wurden, nicht anhand der alphabetischen Benennung
- Bewährte Vorgehensweise: Formatieren Sie zuerst die Karte und kopieren Sie dann die Dateien einzeln in der gewünschten Wiedergabereihenfolge
Installation der Bibliothek
Die Bibliothek DIYables_MiniMp3 vereinfacht die Steuerung des MP3-Moduls in ESP32 S3 Projekten. Installieren Sie sie direkt über den Bibliotheksverwalter der Arduino IDE, bevor Sie einen der Beispiel-Sketches hochladen.
- Verbinden Sie Ihren ESP32 S3 über ein USB-C-Kabel mit Ihrem Computer
- Öffnen Sie die Arduino IDE
- Wählen Sie ESP32 S3 als Board aus
- Wählen Sie den richtigen COM-Port
- Klicken Sie auf das Symbol Libraries in der linken Seitenleiste
- Suchen Sie nach "DIYables_MiniMp3"
- Suchen Sie die Bibliothek von DIYables
- Klicken Sie auf Install
- Search for DIYables_MiniMp3 created by DIYables
and click the Install button.
1
void setup() {
Vorteile der Bibliothek:
- Keine externen Abhängigkeiten
- Einfache Befehlsfunktionen für alle Wiedergabefunktionen
- Funktioniert perfekt mit der Hardware-Serial-Schnittstelle des ESP32 S3
ESP32 S3 Code — Grundeinrichtung
Der folgende Code zeigt die Grundvorlage zur Steuerung des Mini-MP3-Players mit dem ESP32 S3 über die Hardware-Schnittstelle Serial1. Er initialisiert die serielle Schnittstelle, wartet auf den Start des Moduls und stellt eine anfängliche Lautstärke ein, sodass Sie prüfen können, ob die Verbindung funktioniert, bevor Sie Wiedergabelogik hinzufügen.
Was dieser Code macht:
- Initialisiert Serial1 für die Kommunikation mit dem MP3-Modul mit 9600 Baud
- Richtet das MP3-Player-Objekt ein
- Wartet auf den Start des Moduls
- Stellt die anfängliche Lautstärke auf Stufe 25 ein
#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
}
Warum Hardware-Serial?
- Der ESP32 S3 hat eigene UART-Hardware
- Zuverlässiger als Software-Serial
- Keine Timing-Probleme bei 9600 Baud
- Die USB-Serial-Schnittstelle bleibt für die Fehlersuche frei
ESP32 S3 Code — Einen einzelnen Titel abspielen
Der folgende Code zeigt, wie Sie mit dem ESP32 S3 einen einzelnen Titel von Ihrer SD-Karte abspielen. Er initialisiert das MP3-Modul und beginnt sofort mit der Wiedergabe von Titel 001.mp3, sodass Sie bestätigen können, dass die gesamte Hardware korrekt funktioniert.
/*
* 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 -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* 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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
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
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- SD-Karte vorbereiten: Formatieren Sie sie als FAT32 und kopieren Sie MP3-Dateien mit den Namen 001.mp3, 002.mp3 usw.
- SD-Karte einsetzen: Stecken Sie die microSD-Karte in den Steckplatz des Moduls.
- Verdrahtung herstellen: Folgen Sie dem obigen Schaltplan (VCC, GND, TX1, RX1, Lautsprecher).
- Lautsprecher anschließen: Schließen Sie Ihren Lautsprecher an die Klemmen SPK_1 und SPK_2 an.
- Arduino IDE öffnen: Starten Sie die IDE auf Ihrem Computer.
- Board auswählen: Wählen Sie im Board-Menü ESP32 S3 aus.
- Port auswählen: Wählen Sie den richtigen COM-Port für Ihr Board.
- Code hochladen: Kopieren Sie den obigen Code und laden Sie ihn auf Ihren ESP32 S3 hoch.
- Zuhören: Titel 001.mp3 sollte über den Lautsprecher abgespielt werden.
- Profi-Tipp: Wenn Sie keinen Ton hören, prüfen Sie das Format der SD-Karte und die Dateibenennung – das Modul reagiert sehr empfindlich auf die Namenskonventionen.
Wiedergabebefehle
| Methode | Zweck | Beispiel |
|---|---|---|
| play(trackNum) | Einen bestimmten Titel starten | mp3.play(1) |
| playNext() | Zum nächsten Titel wechseln | mp3.playNext() |
| playPrevious() | Zum vorherigen Titel wechseln | mp3.playPrevious() |
| pause() | Den aktuellen Titel pausieren | mp3.pause() |
| resume() | Den Titel fortsetzen | mp3.resume() |
| stop() | Wiedergabe anhalten | mp3.stop() |
ESP32 S3 Code — Mehrere Titel abspielen
Der folgende Code zeigt, wie Sie automatisch durch mehrere Titel schalten und alle paar Sekunden zum nächsten Lied wechseln. Dieses Muster ist nützlich für Hintergrundmusiksysteme oder Demoprojekte, bei denen eine fortlaufende Wiedergabe ohne Benutzereingriff gewünscht ist.
/*
* 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 -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* 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 (10, 11); // 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(115200);
mp3Serial.begin(115200);
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();
}
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- SD-Karte vorbereiten: Stellen Sie sicher, dass mindestens 3 MP3-Dateien mit den Namen 001.mp3, 002.mp3, 003.mp3 vorhanden sind.
- Modul verdrahten: Verwenden Sie dieselbe Verdrahtung wie im vorherigen Beispiel.
- Code hochladen: Kopieren Sie den obigen Sketch und laden Sie ihn hoch.
- Zuhören: Die Titel wechseln automatisch alle 5 Sekunden.
- Serial beobachten: Öffnen Sie den Serial Monitor mit 115200 Baud, um die Titelwechsel zu sehen.
- Profi-Tipp: Passen Sie den Wert delay(5000) an, um zu ändern, wie lange jeder Titel spielt, bevor zum nächsten gewechselt wird.
Ausgabe im Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:12:01] Playing track: 1
[2026-01-15 09:12:06] Playing track: 2
[2026-01-15 09:12:11] Playing track: 3
[2026-01-15 09:12:16] Playing track: 1
ESP32 S3 Code — Lautstärkeregelung
Der folgende Code fügt Ihrem ESP32 S3 Projekt zwei Hardware-Taster hinzu, mit denen der Benutzer die Lautstärke des MP3-Players in Echtzeit erhöhen oder verringern kann. Jeder Tastendruck erhöht oder verringert die Lautstärke um eine Stufe, und die aktuelle Stufe wird zur Fehlersuche im Serial Monitor ausgegeben.
/*
* 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 2 to volume up, pin 3 to volume down.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin 2 (other leg to GND)
* Button DOWN -> Pin 3 (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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = 2;
const int BUTTON_VOL_DOWN = 3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
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
}
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Taster hinzufügen: Verbinden Sie zwei Taster mit GPIO4 und GPIO5 (sowie GND).
- Code hochladen: Kopieren Sie den obigen Sketch in die Arduino IDE und laden Sie ihn hoch.
- Taster testen: Drücken Sie während der Musikwiedergabe die Taster, um die Lautstärke anzupassen.
- Serial beobachten: Der Serial Monitor zeigt die aktuelle Lautstärkestufe an.
- Profi-Tipp: Der Lautstärkebereich ist 0–30; 15 ist für die meisten Lautsprecher ein guter Ausgangswert.
Lautstärkebefehle
| Methode | Zweck | Beispiel |
|---|---|---|
| setVolume(v) | Direkt auf eine bestimmte Lautstärke springen | mp3.setVolume(20) |
| volumeUp() | Um 1 Stufe erhöhen | mp3.volumeUp() |
| volumeDown() | Um 1 Stufe verringern | mp3.volumeDown() |
| getVolume() | Aktuelle Stufe abfragen | mp3.getVolume() |
Ausgabe im Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:15:03] Volume: 25
[2026-01-15 09:15:07] Volume: 26
[2026-01-15 09:15:11] Volume: 25
[2026-01-15 09:15:14] Volume: 24
ESP32 S3 Code — Taster für Weiter/Zurück
Der folgende Code verbindet zwei Taster mit Ihrem ESP32 S3 zur manuellen Titelnavigation, sodass Benutzer in der Playlist der SD-Karte vor- oder zurückspringen können. Bei jedem Tastendruck wird die aktuelle Titelnummer an den Serial Monitor gesendet.
/*
* 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 Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> Pin 2 (other leg to GND)
* Button PREV -> Pin 3 (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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_NEXT = 2;
const int BUTTON_PREV = 3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
pinMode(BUTTON_NEXT, INPUT_PULLUP);
pinMode(BUTTON_PREV, INPUT_PULLUP);
mp3.begin(mp3Serial);
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
}
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Taster verdrahten: Verbinden Sie den NEXT-Taster mit GPIO4 und den PREV-Taster mit GPIO5.
- Masse anschließen: Verbinden Sie die anderen Anschlüsse der Taster mit GND.
- Sketch hochladen: Laden Sie den obigen Code auf Ihren ESP32 S3.
- Navigation testen: Drücken Sie die Taster, um in den Titeln vor- oder zurückzuspringen.
- Ausgabe beobachten: Der Serial Monitor zeigt die aktuelle Titelnummer an.
- Profi-Tipp: Verwenden Sie Pull-up-Widerstände (10kΩ) für einen zuverlässigeren Tasterbetrieb in störungsreichen Umgebungen.
Ausgabe im Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:18:02] Current track: 1
[2026-01-15 09:18:05] Current track: 2
[2026-01-15 09:18:09] Current track: 3
[2026-01-15 09:18:13] Current track: 2
ESP32 S3 Code — Pause/Fortsetzen umschalten
Der folgende Code verwendet einen einzelnen Taster an Ihrem ESP32 S3, um zwischen Pause und Wiedergabe umzuschalten. So können Benutzer die Musik einfach pausieren, ohne den Titel ganz zu stoppen. Der Wiedergabezustand wird im Serial Monitor ausgegeben, damit Sie die Logik beim Testen verfolgen können.
/*
* 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 -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin 2 (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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = 2;
bool paused = false;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
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
}
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Taster verdrahten: Verbinden Sie den Pause/Fortsetzen-Taster mit GPIO4 und GND.
- Code hochladen: Laden Sie den Sketch auf Ihr Board.
- Wiedergabe starten: Die Musik startet automatisch.
- Pause umschalten: Drücken Sie den Taster zum Pausieren und erneut zum Fortsetzen.
- Status prüfen: Der Serial Monitor zeigt den Wiedergabezustand an.
- Profi-Tipp: Der BUSY-Pin des Moduls kann den Wiedergabe-/Pausenzustand auch für eine optische Rückmeldung per LED anzeigen.
Ausgabe im Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:21:01] Playing track 1
[2026-01-15 09:21:08] Music paused
[2026-01-15 09:21:14] Music resumed
[2026-01-15 09:21:20] Music paused
ESP32 S3 Code — Einen Titel wiederholen
Der folgende Code programmiert den Mini-MP3-Player so, dass er einen einzelnen Titel fortlaufend wiederholt – ideal für Hintergrundmusik oder Warntöne, die nie aufhören sollen. Nach dem Hochladen auf Ihren ESP32 S3 ist kein weiterer Eingriff nötig – die Wiedergabe wiederholt sich automatisch.
/*
* 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 -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* 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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
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
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Sketch hochladen: Laden Sie den obigen Code hoch.
- Zuhören: Titel 1 wird fortlaufend wiederholt.
- Profi-Tipp: Verwenden Sie loopAll() für Hintergrundmusikprojekte, die eine fortlaufende Wiedergabe aller Titel benötigen.
Befehle für Wiederholung & Zufallswiedergabe
| Methode | Zweck | Beispiel |
|---|---|---|
| loopTrack(t) | Einen Titel immer wieder abspielen | mp3.loopTrack(1) |
| loopFolder(f) | Alle Titel eines Ordners wiederholen | mp3.loopFolder(1) |
| loopAll() | Alles auf der Karte wiederholen | mp3.loopAll() |
| stopLoop() | Den aktuellen Wiederholungsmodus beenden | mp3.stopLoop() |
| shuffle() | Wiedergabereihenfolge zufällig mischen | mp3.shuffle() |
ESP32 S3 Code — Aus einem Ordner abspielen
Der folgende Code zeigt, wie Sie einen bestimmten Titel aus einem nummerierten Ordner auf Ihrer SD-Karte abspielen. Das ermöglicht eine organisierte Wiedergabe für Projekte mit mehreren Audiokategorien wie Soundeffekten, Musikgenres oder Sprachpaketen.
/*
* 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 -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* 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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
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
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Ordner erstellen: Legen Sie auf Ihrer SD-Karte Ordner mit den Namen 01, 02 usw. an.
- Dateien hinzufügen: Legen Sie MP3-Dateien in jeden Ordner (001.mp3, 002.mp3 usw.).
- Code hochladen: Laden Sie den Sketch auf den ESP32 S3.
- Wiedergabe testen: Der Code spielt den ersten Titel aus Ordner 01 ab.
- Profi-Tipp: Ordnen Sie Soundeffekte, Musikgenres oder Sprachen in separaten Ordnern, um Ihr Projekt übersichtlich zu halten.
Ordner-Methoden
| Methode | Zweck | Beispiel |
|---|---|---|
| playFolder(f, t) | Titel t aus Ordner f auswählen | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Modus für große Ordner (bis zu 3000 Titel) | mp3.playLargeFolder(1, 1500) |
| playFromMP3Folder(t) | Auf den speziellen Ordner /mp3 zugreifen | mp3.playFromMP3Folder(1) |
ESP32 S3 Code — Steuerung über den Serial Monitor
Der folgende Code macht den Serial Monitor der Arduino IDE zu einem vollständigen Steuerpult für Ihren Mini-MP3-Player, mit dem Sie jede Wiedergabefunktion durch Eingabe von Einzelzeichen-Befehlen testen können. Dies ist der empfohlene erste Sketch nach der Verdrahtung Ihres ESP32 S3, da Sie damit alle Funktionen prüfen können, bevor Sie eine physische Bedienoberfläche bauen.
/*
* 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 -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* 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 (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
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;
}
}
}
Schnelle Schritte
- Neu beim ESP32 S3? Arbeiten Sie zuerst unsere Anleitung Erste Schritte mit dem ESP32 S3 durch.
- Code hochladen: Laden Sie den Sketch auf Ihren ESP32 S3.
- Serial Monitor öffnen: Stellen Sie die Baudrate auf 115200 ein.
- Befehle senden: Geben Sie Befehle aus der folgenden Tabelle ein.
- Wiedergabe steuern: Testen Sie alle Funktionen des MP3-Players über die Tastatur.
- Profi-Tipp: Das ist ideal, um Ihr MP3-Modul zu testen, bevor Sie es in ein größeres Projekt einbauen.
Serielle Befehle
| Eingabe | Ergebnis |
|---|---|
| 1–9 | Diesen Titel abspielen |
| + / − | Lauter / leiser |
| p | Pause |
| r | Fortsetzen |
| s | Stopp |
| n | Nächster Titel |
| b | Vorheriger Titel |
| ? | Status anzeigen |
Ausgabe im Serial Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:30:00] Mp3 Player Control Menu:
[2026-01-15 09:30:00] 1-9: Play track, +/-: Volume, p: Pause, r: Resume, s: Stop, n: Next, b: Previous, ?: Status
[2026-01-15 09:30:05] Command: 1
[2026-01-15 09:30:05] Playing track 1
[2026-01-15 09:30:10] Command: +
[2026-01-15 09:30:10] Volume increased
[2026-01-15 09:30:15] Command: n
[2026-01-15 09:30:15] Next track
Equalizer-Voreinstellungen
Der Mini-MP3-Player bietet sechs eingebaute Equalizer-Modi, um die Klangqualität für verschiedene Musikgenres zu verbessern.
Verfügbare EQ-Voreinstellungen:
| Konstante | ID | Klang |
|---|---|---|
| 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 | Klassik |
| DIYables_MiniMp3::EQ_BASS | 5 | Bassverstärkung |
Anwendungsbeispiel:
mp3.setEQ(DIYables_MiniMp3::EQ_POP);
Tipps:
- EQ_NORMAL eignet sich gut für Sprachaufnahmen und Podcasts
- EQ_BASS verbessert kleine Lautsprecher mit begrenzter Tieftonwiedergabe
- Probieren Sie verschiedene Voreinstellungen aus, um sie an die Eigenschaften Ihres Lautsprechers anzupassen
Funktionen zur Statusabfrage
Die Bibliothek bietet Funktionen, um den aktuellen Zustand des Mini-MP3-Player-Moduls in Echtzeit auszulesen.
Wichtige Hinweise:
- Jede Abfrage blockiert die Ausführung für bis zu 100 Millisekunden
- Die Funktionen geben bei Zeitüberschreitung oder Kommunikationsfehler −1 zurück
- Verwenden Sie sie in zeitkritischen Anwendungen sparsam
Verfügbare Statusfunktionen:
| Methode | Rückgabe | Info |
|---|---|---|
| isPlaying() | bool | Ob gerade ein Titel läuft |
| getVolume() | int16_t | Lautstärke (0–30) |
| getEQ() | int16_t | EQ-Voreinstellung (0–5) |
| getTrackCount() | int16_t | Gesamtzahl der Titel auf der Karte |
| getCurrentTrack() | int16_t | Aktuell abgespielter Titel |
| getFolderCount() | int16_t | Anzahl der Ordner |
| getTrackCountInFolder(f) | int16_t | Titel in Ordner f |
Beispielcode:
if (mp3.isPlaying()) {
int currentTrack = mp3.getCurrentTrack();
int currentVolume = mp3.getVolume();
Serial.print("Playing track ");
Serial.print(currentTrack);
Serial.print(" at volume ");
Serial.println(currentVolume);
}
Anwendungs- & Projektideen
Die Dual-Core-Verarbeitung und das eingebaute WiFi des ESP32 S3 machen ihn besonders geeignet für vernetzte Audioanwendungen, die über eine einfache lokale Wiedergabe hinausgehen.
- WiFi-Audioplayer: Bauen Sie einen per WiFi gesteuerten Audioplayer für zu Hause mit einer Weboberfläche zur Titelauswahl aus der Ferne.
- Sprechende Uhr: Erstellen Sie einen sprechenden Wecker mit geplanten Sprachansagen zu verschiedenen Tageszeiten.
- Museumsführer: Entwerfen Sie einen Ausstellungsführer, der automatisch Audiobeschreibungen abspielt, wenn sich Besucher nähern.
- Interaktives Spielzeug: Bauen Sie ein interaktives Spielzeug mit Soundeffekten, die durch Bewegungs- oder Berührungssensoren ausgelöst werden.
- Sprachtrainer: Bauen Sie ein Sprachlerngerät mit in Ordnern organisierten Lektionen für Vokabeln und Aussprache.
- Intelligente Türklingel: Erstellen Sie eine Türklingel mit anpassbaren MP3-Klingeltönen, die über eine Weboberfläche ausgewählt werden können.
- Meditations-Timer: Entwerfen Sie einen Meditations-Timer mit Hintergrundmusik und Sprachhinweisen in festgelegten Abständen.
- Demo-Einheit für den Handel: Bauen Sie eine Produkt-Demostation mit Werbeaudio in Dauerschleife, die aus der Ferne gesteuert wird.
Video-Tutorial
Sehen Sie sich unten die Schritt-für-Schritt-Videoanleitung für dieses ESP32 S3 Projekt an.
Fordern Sie sich heraus
Diese Projekte bauen schrittweise auf den Fähigkeiten auf, die Sie in diesem Tutorial erworben haben, und machen Ihren ESP32 S3 MP3-Player von einer einfachen Demo zu einem ausgereiften, funktionsreichen Gerät.
- Anfänger: Fügen Sie eine LED hinzu, die über den BUSY-Pin leuchtet, wenn Musik abgespielt wird.
- Anfänger: Erstellen Sie eine Jukebox mit 3 Tastern, die auf Knopfdruck Titel 1, 2 oder 3 abspielt.
- Fortgeschritten: Bauen Sie eine Weboberfläche, um die Wiedergabe über die WiFi-Verbindung des ESP32 S3 zu steuern.
- Fortgeschritten: Fügen Sie ein LCD-Display hinzu, das die aktuelle Titelnummer und die Lautstärke anzeigt.
- Experte: Erstellen Sie einen sprachgesteuerten MP3-Player mit einem Mikrofonmodul und dem ADC des ESP32 S3.
- Experte: Bauen Sie ein Multiroom-Audiosystem mit mehreren ESP32 S3 Boards, die über WiFi per UDP-Broadcasts synchronisiert werden.