ESP32 C3 Super Mini - Mini-MP3-Player
Der ESP32 C3 Super Mini ist ein kompaktes 3,3V-Entwicklungsboard, das sich perfekt für Audioprojekte eignet. In diesem Tutorial lernen Sie, wie Sie mit dem DIYables Mini-MP3-Player-Modul und Ihrem ESP32 C3 Super Mini ein komplettes MP3-Player-System aufbauen.
Was Sie lernen werden:
- Was das Mini-MP3-Player-Modul ist und wie es funktioniert
- Wie Sie das MP3-Modul mit dem ESP32 C3 Super Mini verdrahten (kein Widerstand erforderlich)
- Wie Sie Ihre SD-Karte mit korrekt benannten MP3-Dateien vorbereiten
- Wie Sie Code für Wiedergabe, Lautstärke, Wiederholung und Ordnersteuerung schreiben
- Wie Sie den Modulstatus auslesen und die Wiedergabe über serielle Befehle steuern
Erforderliche Hardware
| 1 | × | ESP32 C3 Super Mini | |
| 1 | × | USB-Kabel Typ-A zu Typ-C (für USB-A PC) | |
| 1 | × | USB-Kabel Typ-C zu Typ-C (für USB-C PC) | |
| 1 | × | DIYables Mini Mp3 Player module | |
| 1 | × | Micro-SD-Karte | |
| 1 | × | Speaker | |
| 1 | × | Breadboard | |
| 1 | × | Verbindungskabel |
Oder Sie können die folgenden Kits kaufen:
| 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 YX5200-24SS-MP3-Decodermodul, das Audiodateien von einer Micro-SD-Karte über einen eingebauten Verstärker abspielt.
Hauptmerkmale:
- Betrieb mit 3,3V–5V (perfekt für die 3,3V-Logik des ESP32 C3 Super Mini)
- Steuerung über UART seriell mit 115200 Baud
- Eingebauter 3W-Verstärker für den direkten Lautsprecheranschluss
- 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 mit einfachen seriellen Befehlen
Pinbelegung
Das Mini-MP3-Player-Modul hat 11 Pins für Stromversorgung, Kommunikation, Audioausgang und Steuerung.
- VCC: Stromversorgung (3,2V–5,0V)
- GND: Masseanschluss
- RX: UART-Empfang (mit dem TX-Pin des ESP32 verbinden)
- TX: UART-Senden (mit dem RX-Pin des ESP32 verbinden)
- SPK_1: Pluspol des Lautsprechers (eingebauter 3W-Verstärker)
- SPK_2: Minuspol des Lautsprechers
- DAC_R: Audioausgang rechter Kanal (Line-Pegel)
- DAC_L: Audioausgang linker Kanal (Line-Pegel)
- BUSY: Status-Pin (LOW bei 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
So schließen Sie den Mini-MP3-Player über die Hardware-Serial1 an Ihren ESP32 C3 Super Mini an.
- Wichtig: Der ESP32 C3 Super Mini verwendet 3,3V-Logik, die perfekt zum Modul passt – für die TX/RX-Leitungen ist kein Widerstand nötig
- Serial1-Pins: TX1 ist GPIO5 (D5), RX1 ist GPIO4 (D4)
- Stromversorgungsoptionen: Verwenden Sie je nach Anforderung Ihres Lautsprechers den 3,3V-Pin oder 5V (VBUS)
| Mini-MP3-Player | ESP32 C3 Super Mini | Hinweise |
|---|---|---|
| VCC | 3,3V | Das Modul akzeptiert bei Bedarf auch 5V von VBUS |
| GND | GND | Gemeinsame Masse |
| RX | TX1 (D5) | Direkte Verbindung – kein Widerstand nötig |
| TX | RX1 (D4) | 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 Micro-SD-Karte.
Formatierungsanforderungen:
- Dateisystem: FAT16 oder FAT32
- Kartengröße: Bis zu 32GB empfohlen
Grundlegende 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 wichtig: Das Modul bestimmt die Wiedergabereihenfolge anhand der Reihenfolge, in der die Dateien kopiert wurden, nicht anhand der alphabetischen Benennung
- Beste Vorgehensweise: Formatieren Sie zuerst die Karte und kopieren Sie dann die Dateien einzeln in der gewünschten Wiedergabereihenfolge
Bibliotheksinstallation
Die DIYables_MiniMp3-Bibliothek vereinfacht die Steuerung des MP3-Moduls in ESP32 C3 Super Mini-Projekten.
- Verbinden Sie Ihren ESP32 C3 Super Mini über ein USB-C-Kabel mit Ihrem Computer
- Öffnen Sie die Arduino IDE
- Wählen Sie ESP32 C3 Super Mini als Ihr 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
Vorteile der Bibliothek:
- Keine externen Abhängigkeiten
- Einfache Befehlsfunktionen für alle Wiedergabefunktionen
- Funktioniert perfekt mit der Hardware-Seriellen des ESP32
ESP32 C3 Super Mini Code — Grundeinrichtung
Dieser Code zeigt die Grundvorlage zur Steuerung des Mini-MP3-Players mit dem ESP32 C3 Super Mini über die Hardware-Serial1.
Was dieser Code macht:
- Initialisiert Serial1 für die Kommunikation mit dem MP3-Modul mit 115200 Baud
- Richtet das MP3-Player-Objekt ein
- Wartet auf den Start des Moduls
- Setzt die Anfangslautstärke auf Stufe 25
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup() {
Serial.begin(115200);
Serial1.begin(115200); // 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-Serielle?
- Der ESP32 C3 Super Mini verfügt über dedizierte UART-Hardware
- Zuverlässiger als Software-Serielle
- Keine Timing-Probleme bei 115200 Baud
- Die USB-Serielle bleibt für das Debugging frei
ESP32 C3 Super Mini Code — Einen einzelnen Titel 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 Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* 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 (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 C3 Mini? Absolvieren Sie zuerst unser Tutorial Erste Schritte mit dem ESP32 C3 Mini, um Ihre Entwicklungsumgebung einzurichten.
- SD-Karte vorbereiten: Als FAT32 formatieren und MP3-Dateien mit den Namen 001.mp3, 002.mp3 usw. kopieren
- SD-Karte einsetzen: Stecken Sie die Micro-SD-Karte in den Steckplatz des Moduls
- Verdrahtung anschließen: Folgen Sie dem obigen Schaltplan (VCC, GND, TX1, RX1, Lautsprecher)
- Lautsprecher anschließen: Verbinden Sie Ihren Lautsprecher mit den Anschlüssen SPK_1 und SPK_2
- Arduino IDE öffnen: Starten Sie die IDE auf Ihrem Computer
- Board auswählen: Wählen Sie ESP32 C3 Super Mini im Board-Menü
- 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 C3 Super Mini hoch
- Anhören: Der Titel 001.mp3 sollte über den Lautsprecher abgespielt werden
- Profi-Tipp: Wenn Sie keinen Ton hören, überprü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 aktiven Titel pausieren | mp3.pause() |
| resume() | Die Pause des Titels aufheben | mp3.resume() |
| stop() | Wiedergabe anhalten | mp3.stop() |
ESP32 C3 Super Mini Code — Mehrere Titel abspielen
/*
* 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 11
* Mini Mp3 TX -> Arduino Pin 10
* 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 (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
- SD-Karte vorbereiten: Stellen Sie sicher, dass Sie mindestens 3 MP3-Dateien mit den Namen 001.mp3, 002.mp3, 003.mp3 haben
- Modul verdrahten: Verwenden Sie die gleiche Verdrahtung wie im vorherigen Beispiel
- Code hochladen: Kopieren Sie den obigen Sketch und laden Sie ihn hoch
- Anhören: Die Titel wechseln automatisch alle 5 Sekunden
- Seriellen Monitor beobachten: Öffnen Sie den Seriellen 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 Seriellen Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Playing track: 1
Playing track: 2
Playing track: 3
Playing track: 1
Playing track: 2
Playing track: 3
ESP32 C3 Super Mini Code — Lautstärkeregelung
/*
* 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 -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Taster hinzufügen: Verdrahten Sie zwei Taster mit GPIO6 und GPIO7 (plus GND)
- Code hochladen: Kopieren Sie den obigen Sketch in die Arduino IDE und laden Sie ihn hoch
- Taster testen: Drücken Sie die Taster während der Musikwiedergabe, um die Lautstärke anzupassen
- Seriellen Monitor beobachten: Der Serielle Monitor zeigt die aktuelle Lautstärkestufe an
- Profi-Tipp: Der Lautstärkebereich ist 0–30, wobei 15 für die meisten Lautsprecher ein guter Ausgangswert ist
Lautstärkebefehle
| Methode | Zweck | Beispiel |
|---|---|---|
| setVolume(v) | Auf eine bestimmte Lautstärkestufe springen | mp3.setVolume(20) |
| volumeUp() | Um 1 Stufe erhöhen | mp3.volumeUp() |
| volumeDown() | Um 1 Stufe verringern | mp3.volumeDown() |
| getVolume() | Die aktuelle Stufe abfragen | mp3.getVolume() |
Ausgabe im Seriellen Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Volume: 25
Volume: 26
Volume: 25
Volume: 24
Volume: 23
ESP32 C3 Super Mini Code — Weiter-/Zurück-Taster
/*
* 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 -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Taster verdrahten: Verbinden Sie den NEXT-Taster mit GPIO6 und den PREV-Taster mit GPIO7
- Masse anschließen: Verbinden Sie die anderen Tasteranschlüsse mit GND
- Sketch hochladen: Laden Sie den obigen Code auf Ihren ESP32 C3 Super Mini
- Navigation testen: Drücken Sie die Taster, um vorwärts oder rückwärts durch die Titel zu springen
- Ausgabe überwachen: Der Serielle Monitor zeigt die aktuelle Titelnummer an
- Profi-Tipp: Verwenden Sie Pull-up-Widerstände (10kΩ) für einen zuverlässigeren Tasterbetrieb in störanfälligen Umgebungen
Ausgabe im Seriellen Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Current track: 1
Current track: 2
Current track: 3
Current track: 2
Current track: 1
ESP32 C3 Super Mini Code — Pause/Fortsetzen umschalten
/*
* 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 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Taster verdrahten: Verbinden Sie den Pause/Fortsetzen-Taster mit GPIO6 und GND
- Code hochladen: Laden Sie den Sketch auf Ihr Board
- Wiedergabe starten: Die Musik beginnt automatisch
- Pause umschalten: Drücken Sie den Taster zum Pausieren und erneut zum Fortsetzen
- Status prüfen: Der Serielle Monitor zeigt den Wiedergabezustand an
- Profi-Tipp: Der BUSY-Pin am Modul kann den Wiedergabe-/Pausenzustand auch über eine LED visuell anzeigen
Ausgabe im Seriellen Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Playing track 1
Music paused
Music resumed
Music paused
Music resumed
ESP32 C3 Super Mini Code — Einen Titel wiederholen
/*
* 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 11
* Mini Mp3 TX -> Arduino Pin 10
* 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 (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
- Sketch hochladen: Laden Sie den obigen Code hoch
- Anhören: Titel 1 wird fortlaufend wiederholt
- Profi-Tipp: Verwenden Sie loopAll() für Hintergrundmusik-Projekte, die eine durchgehende Wiedergabe benötigen
Wiederholungs- und Zufallsbefehle
| Methode | Zweck | Beispiel |
|---|---|---|
| loopTrack(t) | Einen Titel immer wieder abspielen | mp3.loopTrack(1) |
| loopFolder(f) | Alle Titel in einem Ordner 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 C3 Super Mini Code — Aus einem Ordner abspielen
/*
* 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 11
* Mini Mp3 TX -> Arduino Pin 10
* 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 (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
- Ordner erstellen: Erstellen Sie auf Ihrer SD-Karte Ordner mit den Namen 01, 02 usw.
- Dateien hinzufügen: Legen Sie MP3-Dateien in jeden Ordner (001.mp3, 002.mp3 usw.)
- Code hochladen: Laden Sie den Sketch auf den ESP32 C3 Super Mini
- Wiedergabe testen: Der Code spielt den ersten Titel aus Ordner 01 ab
- Profi-Tipp: Ordnen Sie Soundeffekte, Musikgenres oder Sprachen in separaten Ordnern an, um Ihr Projekt einfach zu organisieren
Ordnermethoden
| 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 C3 Super Mini Code — Steuerung über den Seriellen Monitor
/*
* 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 11
* Mini Mp3 TX -> Arduino Pin 10
* 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 (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
- Code hochladen: Laden Sie den Sketch auf Ihren ESP32 C3 Super Mini
- Seriellen 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: Dies 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 Seriellen Monitor
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Mp3 Player Control Menu:
1-9: Play track, +/-: Volume, p: Pause, r: Resume, s: Stop, n: Next, b: Previous, ?: Status
Command: 1
Playing track 1
Command: +
Volume increased
Command: n
Next track
Equalizer-Voreinstellungen
Der Mini-MP3-Player bietet sechs eingebaute Equalizer-Modi, um die Audioqualitä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 begrenztem Tieftonbereich
- Probieren Sie verschiedene Voreinstellungen aus, um sie an die Eigenschaften Ihres Lautsprechers anzupassen
Statusabfragefunktionen
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 diese in zeitkritischen Anwendungen sparsam
Verfügbare Statusfunktionen:
| Methode | Rückgabe | Info |
|---|---|---|
| isPlaying() | bool | Ob ein Titel aktiv ist |
| 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 gespielter 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- und Projektideen
Hier sind einige kreative Möglichkeiten, den ESP32 C3 Super Mini mit dem Mini-MP3-Player-Modul in Ihren Projekten einzusetzen.
- Bauen Sie einen WLAN-gesteuerten Audioplayer für zu Hause mit Weboberfläche
- Erstellen Sie einen sprechenden Wecker mit geplanten Ansagen
- Gestalten Sie einen Museumsführer mit automatischen Audiobeschreibungen
- Bauen Sie ein interaktives Spielzeug mit Soundeffekten, die durch Sensoren ausgelöst werden
- Bauen Sie ein Sprachlerngerät mit in Ordnern organisierten Lektionen
- Erstellen Sie eine Türklingel mit anpassbaren MP3-Klingeltönen
- Gestalten Sie einen Meditations-Timer mit Hintergrundmusik und Sprachansagen
- Bauen Sie eine Produktdemo für den Einzelhandel mit sich wiederholendem Werbeaudio
Video-Tutorial
Sehen Sie sich das folgende Video an, um eine visuelle Schritt-für-Schritt-Anleitung zu diesem Projekt zu erhalten.
Herausforderungen
Testen Sie Ihre Fähigkeiten mit diesen zunehmend anspruchsvollen Änderungen am ESP32 C3 Super Mini MP3-Player.
- Einfach: Fügen Sie eine LED hinzu, die über den BUSY-Pin leuchtet, wenn Musik spielt
- Einfach: Erstellen Sie eine Jukebox mit 3 Tastern (Titel 1, 2 oder 3 abspielen)
- Mittel: Bauen Sie eine Weboberfläche, um die Wiedergabe über WLAN zu steuern
- Mittel: Fügen Sie ein LCD-Display hinzu, das den aktuellen Titelnamen und die Lautstärke anzeigt
- Fortgeschritten: Erstellen Sie einen sprachgesteuerten MP3-Player mit einem Mikrofonmodul
- Fortgeschritten: Bauen Sie ein Multiroom-Audiosystem mit mehreren ESP32-Boards, die über WLAN synchronisiert werden