ESP32 MicroPython - Mini-MP3-Player
Der ESP32 ist ein vielseitiger 3,3V-Mikrocontroller mit WLAN, Bluetooth und mehreren Hardware-UART-Ports. In Kombination mit dem DIYables Mini Mp3 Player-Modul und MicroPython können Sie alles bauen – vom einfachen Soundeffekt-Board bis hin zur per WLAN gesteuerten Jukebox.
Dieses Tutorial zeigt Ihnen:
- Wie Sie den Mini-MP3-Player direkt und ohne Widerstand mit einem ESP32 verbinden.
- Wie Sie MP3-Dateien korrekt auf die SD-Karte laden.
- Wie Sie Titel abspielen, pausieren, fortsetzen, stoppen und überspringen.
- Wie Sie die Lautstärke mit physischen Tastern einstellen.
- Wie Sie Titel wiederholen, zufällig abspielen und Audiodateien in Ordnern organisieren.
- Wie Sie den Wiedergabestatus aus Ihrem Code überwachen.
Benötigte 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,3V – genau der Spannung, die der UART des Mini-MP3-Players erwartet.
Das Mini-MP3-Player-Modul
Der DIYables Mini Mp3 Player ist eine kompakte Audio-Decoder-Platine auf Basis des Chips YX5200-24SS. Er liest MP3-Dateien von einer Micro-SD-Karte und gibt den Ton über einen eingebauten 3W-Verstärker oder über DAC-Pins für einen externen Verstärker aus.
Der ESP32 kommuniziert mit diesem Modul über UART mit 9600 Baud – eine perfekte Kombination, da der ESP32 drei Hardware-UART-Ports besitzt. Sie können UART2 für das MP3-Modul reservieren und UART0 für die REPL-Konsole von MicroPython frei halten.
Das Modul unterstützt umfangreiche serielle Befehle:
- Wiedergabe: abspielen, pausieren, fortsetzen, stoppen, nächster, vorheriger Titel
- Lautstärke: 31 Stufen (0–30), jederzeit einstellbar
- Equalizer: 6 Voreinstellungen – Normal, Pop, Rock, Jazz, Classic, Bass
- Wiederholungsmodi: einen einzelnen Titel wiederholen, einen Ordner wiederholen, alles wiederholen oder Zufallswiedergabe
- Ordnerwiedergabe: Audiodateien in nummerierten Verzeichnissen organisieren
- Durchsagen: den aktuellen Titel für eine Ansage unterbrechen und danach automatisch fortsetzen
- Statusabfragen: Titelnummer, Lautstärke, Wiedergabezustand und Dateianzahl auslesen
Pinbeschreibung
| Pin | Funktion | Verbindung zum ESP32 |
|---|---|---|
| VCC | 3,2V bis 5,0V Stromeingang | Mit ESP32 3,3V oder 5V (VIN) verbinden |
| GND | Masse | Mit ESP32 GND verbinden |
| RX | Serieller Dateneingang | Mit ESP32 GPIO17 (TX2) verbinden |
| TX | Serieller Datenausgang | Mit ESP32 GPIO16 (RX2) verbinden |
| SPK_1 | Lautsprecher + (eingebauter Verstärker, max. 3W) | Mit Lautsprecher verbinden |
| SPK_2 | Lautsprecher − | Mit Lautsprecher verbinden |
| DAC_R | Line-Ausgang rechter Kanal | Optional – für externen Verstärker |
| DAC_L | Line-Ausgang linker Kanal | Optional – für externen Verstärker |
| BUSY | LOW = spielt, HIGH = gestoppt | Optional – per GPIO auslesen |
| IO_1 | Kurz drücken → vorheriger; lang drücken → leiser | Nicht verwendet (Steuerung über UART) |
| IO_2 | Kurz drücken → nächster; lang drücken → lauter | Nicht verwendet (Steuerung über UART) |
Verdrahtung
Der ESP32 arbeitet nativ mit 3,3V-Logik, daher verbinden Sie die seriellen Leitungen direkt – ohne Pegelwandler oder Widerstände.
Wir empfehlen die Verwendung von UART2 (auf den meisten ESP32-DevKit-Boards standardmäßig verfügbar):
| Mini-MP3-Player | ESP32 | Hinweise |
|---|---|---|
| VCC | 3,3V | Oder 5V von VIN, falls verfügbar |
| GND | GND | |
| RX | GPIO 17 (TX2) | Direkte Verbindung |
| TX | GPIO 16 (RX2) | Direkte Verbindung |
| SPK_1 | Lautsprecher + | |
| SPK_2 | Lautsprecher − |
Dieses Bild wurde mit Fritzing erstellt. Klicken Sie, um das Bild zu vergrößern.
Tipp: Wenn Ihre ESP32-Variante GPIO 16/17 nicht herausführt (einige DevKit-C-V4-Boards verwenden sie für PSRAM), können Sie die UART-Pins im Code neu zuweisen:
uart = UART(2, baudrate=9600, tx=4, rx=5)
Die SD-Karte vorbereiten
Bevor Sie MicroPython-Code auf den ESP32 hochladen, bereiten Sie die Micro-SD-Karte vor:
- Formatieren Sie die Karte als FAT16 oder FAT32 (verwenden Sie das Datenträgerprogramm Ihres Computers).
- Kopieren Sie die MP3-Dateien mit führenden Nullen im Namen in das Stammverzeichnis:
/001.mp3
/002.mp3
/003.mp3
- Optional können Sie die Titel für die Wiedergabe nach Kategorien in nummerierten Ordnern organisieren:
/01/001.mp3 ← folder 1, track 1
/01/002.mp3 ← folder 1, track 2
/02/001.mp3 ← folder 2, track 1
Wichtige Regeln für den Aufbau mit ESP32 und Mini-MP3-Player:
- Titelnummern beginnen bei 1, nicht bei 0.
- Das Modul bestimmt die Titelreihenfolge anhand der Reihenfolge, in der die Dateien auf die Karte kopiert wurden – nicht anhand des Dateinamens. Formatieren Sie die Karte zuerst und kopieren Sie dann die Dateien einzeln in der richtigen Reihenfolge.
- Ordnernamen müssen zweistellig mit führender Null sein (01–99). Dateinamen in Ordnern müssen dreistellig mit führenden Nullen sein (001–255).
- Setzen Sie die SD-Karte in das Mini-MP3-Player-Modul ein, bevor Sie den ESP32 mit Strom versorgen.
Schnelle Schritte
So richten Sie Ihren MicroPython-Code auf dem ESP32 mit der Thonny IDE ein und führen ihn aus:
- Stellen Sie sicher, dass die Thonny IDE auf Ihrem Computer installiert ist.
- Vergewissern Sie sich, dass die MicroPython-Firmware auf Ihrem ESP32-Board installiert ist.
- Wenn Sie zum ersten Mal einen ESP32 mit MicroPython verwenden, lesen Sie die Anleitung ESP32 MicroPython Erste Schritte mit Schritt-für-Schritt-Anweisungen.
- Verbinden Sie das ESP32-Board gemäß dem Schaltplan mit dem Mini-MP3-Player-Modul.
- Verbinden Sie das ESP32-Board über ein USB-Kabel mit Ihrem Computer.
- Öffnen Sie die Thonny IDE auf Ihrem Computer.
- Gehen Sie in der Thonny IDE zu Tools Options.
- Wählen Sie im Tab Interpreter aus dem Dropdown-Menü MicroPython (ESP32) aus.
- Stellen Sie sicher, dass der richtige Port ausgewählt ist. Die Thonny IDE erkennt ihn normalerweise automatisch, eventuell müssen Sie ihn aber manuell auswählen (z. B. COM12 unter Windows oder /dev/ttyACM0 unter Linux).
- Navigieren Sie in der Thonny IDE zu Tools Manage packages.
- Suchen Sie nach "DIYables-MicroPython-MiniMp3" und finden Sie die von DIYables erstellte Mini-MP3-Player-Bibliothek.
- Klicken Sie auf DIYables-MicroPython-MiniMp3 und dann auf die Schaltfläche Install, um die Mini-MP3-Player-Bibliothek zu installieren.
- Kopieren Sie den bereitgestellten MicroPython-Code und fügen Sie ihn in den Editor von Thonny ein.
- Speichern Sie den Code auf Ihrem ESP32:
- Klicken Sie auf die Schaltfläche Save oder drücken Sie Ctrl+S.
- Wählen Sie im Speicherdialog MicroPython device.
- Nennen Sie die Datei main.py.
- Klicken Sie auf die grüne Schaltfläche Run (oder drücken Sie F5), um das Skript auszuführen.
- Setzen Sie die SD-Karte mit den MP3-Dateien in das Mini-MP3-Player-Modul ein.
- Hören Sie die Audiowiedergabe über den angeschlossenen Lautsprecher.
Code-Vorlage für den Einstieg
from machine import UART
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
uart = UART(2, baudrate=9600, tx=17, rx=16)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
mp3.set_volume(25) # 0 = silence, 30 = maximum
ESP32 MicroPython-Code — Einen Titel abspielen
"""
* DIYables MicroPython Mini Mp3 Player - Play One Track
*
* This example plays one track once then stops.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* 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.
"""
from machine import UART
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
mp3.set_volume(25) # Set volume (0 to 30)
print("Playing track 1...")
mp3.play(1) # Play track 001.mp3
Ausprobieren
- Legen Sie die SD-Karte ein, verdrahten Sie das Modul und verbinden Sie den ESP32 per USB.
- Laden Sie den Code mit der Thonny IDE oder Ihrem bevorzugten MicroPython-Tool hoch.
Wiedergabesteuerung
Alle Wiedergabebefehle sind nicht blockierend – der ESP32 sendet den Befehl über UART2 und kehrt sofort zurück, sodass Ihr MicroPython-Code weiterläuft.
| Methode | Was passiert | Codebeispiel |
|---|---|---|
| play(n) | Spielt Titel Nummer n aus dem Stammverzeichnis ab | mp3.play(1) |
| play_next() | Springt zum nächsten Titel | mp3.play_next() |
| play_previous() | Geht einen Titel zurück | mp3.play_previous() |
| pause() | Hält die Wiedergabe an der aktuellen Position an | mp3.pause() |
| resume() | Setzt die Wiedergabe an der pausierten Position fort | mp3.resume() |
| stop() | Stoppt die Wiedergabe vollständig | mp3.stop() |
ESP32 MicroPython-Code — Mehrere Titel
"""
* DIYables MicroPython Mini Mp3 Player - Play Multiple Tracks
*
* This example plays tracks one after another with a delay between them.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* 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
"""
from machine import UART
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
current_track = 1
total_tracks = 3 # Change this to match your SD card
track_duration = 5000 # Wait 5 seconds between tracks (adjust as needed)
mp3.set_volume(20)
print("Playing track 1...")
mp3.play(current_track)
last_track_time = time.ticks_ms()
while True:
if time.ticks_diff(time.ticks_ms(), last_track_time) >= track_duration:
current_track += 1
if current_track > total_tracks:
current_track = 1 # Loop back to first track
print("Playing track", current_track)
mp3.play(current_track)
last_track_time = time.ticks_ms()
ESP32 MicroPython-Code — Lautstärketaster
"""
* DIYables MicroPython Mini Mp3 Player - Volume Control
*
* This example uses two buttons to increase/decrease the volume.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> GPIO1 (other leg to GND)
* Button DOWN -> GPIO3 (other leg to GND)
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> GPIO2 (other leg to GND)
* Button DOWN -> GPIO3 (other leg to GND)
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> D2 (GPIO5, other leg to GND)
* Button DOWN -> D3 (GPIO6, other leg to GND)
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> D2 (other leg to GND)
* Button DOWN -> D3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
"""
from machine import UART, Pin
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
button_up = Pin(1, Pin.IN, Pin.PULL_UP)
button_down = Pin(3, Pin.IN, Pin.PULL_UP)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# button_up = Pin(2, Pin.IN, Pin.PULL_UP)
# button_down = Pin(3, Pin.IN, Pin.PULL_UP)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# button_up = Pin(5, Pin.IN, Pin.PULL_UP)
# button_down = Pin(6, Pin.IN, Pin.PULL_UP)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
# button_up = Pin(2, Pin.IN, Pin.PULL_UP)
# button_down = Pin(3, Pin.IN, Pin.PULL_UP)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
volume = 15 # Start at half volume
mp3.set_volume(volume)
mp3.loop_track(1) # Play track 1 on repeat
print("Volume:", volume)
while True:
if button_up.value() == 0:
if volume < 30:
volume += 1
mp3.set_volume(volume)
print("Volume:", volume)
time.sleep_ms(200) # Simple debounce
if button_down.value() == 0:
if volume > 0:
volume -= 1
mp3.set_volume(volume)
print("Volume:", volume)
time.sleep_ms(200) # Simple debounce
Lautstärke-API
Der ESP32 kann die Lautstärke sofort auf jede Stufe zwischen 0 (stumm) und 30 (maximal) setzen oder sie stufenweise erhöhen bzw. verringern – nützlich für die Steuerung per Taster.
| Methode | Aktion | Beispiel |
|---|---|---|
| set_volume(v) | Lautstärke auf eine bestimmte Stufe setzen (0–30) | mp3.set_volume(20) |
| volume_up() | Lautstärke um eine Stufe erhöhen | mp3.volume_up() |
| volume_down() | Lautstärke um eine Stufe verringern | mp3.volume_down() |
| get_volume() | Aktuelle Lautstärke abfragen | mp3.get_volume() |
ESP32 MicroPython-Code — Nächster/Vorheriger Titel
"""
* DIYables MicroPython Mini Mp3 Player - Next/Previous with Buttons
*
* This example uses two buttons to play next/previous tracks.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> GPIO1 (other leg to GND)
* Button PREV -> GPIO3 (other leg to GND)
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> GPIO2 (other leg to GND)
* Button PREV -> GPIO3 (other leg to GND)
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> D2 (GPIO5, other leg to GND)
* Button PREV -> D3 (GPIO6, other leg to GND)
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> D2 (other leg to GND)
* Button PREV -> D3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
"""
from machine import UART, Pin
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
button_next = Pin(1, Pin.IN, Pin.PULL_UP)
button_prev = Pin(3, Pin.IN, Pin.PULL_UP)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# button_next = Pin(2, Pin.IN, Pin.PULL_UP)
# button_prev = Pin(3, Pin.IN, Pin.PULL_UP)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# button_next = Pin(5, Pin.IN, Pin.PULL_UP)
# button_prev = Pin(6, Pin.IN, Pin.PULL_UP)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
# button_next = Pin(2, Pin.IN, Pin.PULL_UP)
# button_prev = Pin(3, Pin.IN, Pin.PULL_UP)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
mp3.set_volume(20)
mp3.play(1) # Start with track 1
print("Press NEXT or PREV button to change track")
while True:
if button_next.value() == 0:
print("Next track")
mp3.play_next()
time.sleep_ms(300) # Simple debounce
if button_prev.value() == 0:
print("Previous track")
mp3.play_previous()
time.sleep_ms(300) # Simple debounce
ESP32 MicroPython-Code — Pause/Fortsetzen
"""
* DIYables MicroPython Mini Mp3 Player - Pause and Resume
*
* This example demonstrates pausing and resuming playback using a button.
* Press the button to toggle between pause and resume.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> GPIO1 (other leg to GND)
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> GPIO2 (other leg to GND)
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> D2 (GPIO5, other leg to GND)
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> D2 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
"""
from machine import UART, Pin
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
button = Pin(1, Pin.IN, Pin.PULL_UP)
paused = False
mp3.set_volume(20)
mp3.play(1)
print("Playing. Press button to pause/resume.")
while True:
if button.value() == 0: # Button pressed (active LOW)
if paused:
mp3.resume()
print("Resumed")
else:
mp3.pause()
print("Paused")
paused = not paused
time.sleep_ms(300) # Simple debounce
ESP32 MicroPython-Code — Einen Titel wiederholen
"""
* DIYables MicroPython Mini Mp3 Player - Loop Track
*
* This example loops (repeats) a track continuously with EQ setting.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* 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
* ...
"""
from machine import UART
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
import DIYables_MicroPython_MiniMp3.DIYables_MicroPython_MiniMp3 as mp3_const
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
mp3.set_volume(25) # Volume: 0 to 30
mp3.set_eq(mp3_const.EQ_NORMAL)
print("Playing track 1 on loop...")
mp3.loop_track(1)
Wiederholung & Zufallswiedergabe
Diese Wiederholungsmodi laufen vollständig auf dem MP3-Modul – der ESP32 sendet den Befehl nur einmal, und das Modul übernimmt die fortlaufende Wiedergabe selbstständig.
| Methode | Verhalten | Beispiel |
|---|---|---|
| loop_track(n) | Einen Titel endlos wiederholen | mp3.loop_track(1) |
| loop_folder(f) | Alle Titel in einem Ordner nacheinander abspielen | mp3.loop_folder(1) |
| loop_all() | Alle Titel auf der SD-Karte abspielen und dann von vorn beginnen | mp3.loop_all() |
| stop_loop() | Wiederholung nach dem Ende des aktuellen Titels beenden | mp3.stop_loop() |
| shuffle() | Alle Titel in zufälliger Reihenfolge abspielen | mp3.shuffle() |
ESP32 MicroPython-Code — Ordnerwiedergabe
"""
* DIYables MicroPython Mini Mp3 Player - Play from Folder
*
* This example plays tracks from specific folders on the SD card.
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* 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 <- play_folder(1, 1)
* /01/002.mp3 <- play_folder(1, 2)
* /02/001.mp3 <- play_folder(2, 1)
* /02/002.mp3 <- play_folder(2, 2)
"""
from machine import UART
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
mp3.set_volume(20)
# Play track 1 from folder 01
print("Playing folder 01, track 001...")
mp3.play_folder(1, 1)
time.sleep(5)
# Play track 2 from folder 01
print("Playing folder 01, track 002...")
mp3.play_folder(1, 2)
time.sleep(5)
# Play track 1 from folder 02
print("Playing folder 02, track 001...")
mp3.play_folder(2, 1)
Ordner-API
Die ordnerbasierte Wiedergabe eignet sich hervorragend für ESP32-Projekte, die kategorisierte Audiodateien benötigen – zum Beispiel verschiedene Sprachen, Soundkategorien oder Playlists.
| Methode | Beschreibung | Beispiel |
|---|---|---|
| play_folder(f, t) | Titel t aus Ordner f abspielen (bis zu 99 Ordner mit je 255 Titeln) | mp3.play_folder(1, 1) |
| play_large_folder(f, t) | Modus für große Ordner (bis zu 15 Ordner mit je 3000 Titeln) | mp3.play_large_folder(1, 2000) |
| play_from_mp3_folder(t) | Aus dem speziellen Ordner /mp3 abspielen (bis zu 9999 Titel) | mp3.play_from_mp3_folder(1) |
ESP32 MicroPython-Code — Steuerung über die serielle Konsole
"""
* DIYables MicroPython Mini Mp3 Player - Serial Command Control
*
* Control the Mp3 player by typing commands in the serial console.
* Great for testing all functions without extra hardware.
*
* Commands (type in serial console, 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
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Wiring (ESP32):
* Mini Mp3 RX -> ESP32 TX (GPIO17)
* Mini Mp3 TX -> ESP32 RX (GPIO16)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Raspberry Pi Pico):
* Mini Mp3 RX -> Pico TX (GPIO4)
* Mini Mp3 TX -> Pico RX (GPIO5)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Nano ESP32):
* Mini Mp3 RX -> D1 (GPIO43, TX)
* Mini Mp3 TX -> D0 (GPIO44, RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* Wiring (Arduino Giga R1 WiFi):
* Mini Mp3 RX -> TX1
* Mini Mp3 TX -> RX1
* 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.
"""
import sys
import select
from machine import UART
import time
from DIYables_MicroPython_MiniMp3 import MiniMp3Player
# --- For ESP32 ---
uart = UART(2, baudrate=9600, tx=17, rx=16)
# --- For Raspberry Pi Pico (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=4, rx=5)
# --- For Arduino Nano ESP32 (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600, tx=43, rx=44)
# --- For Arduino Giga R1 WiFi (uncomment below, comment above) ---
# uart = UART(1, baudrate=9600)
mp3 = MiniMp3Player(uart)
time.sleep(1) # Wait for the module to initialize
mp3.set_volume(20)
print("=== DIYables Mini Mp3 Player ===")
print("Commands:")
print(" 1-9 Play track number")
print(" + Volume up")
print(" - Volume down")
print(" p Pause")
print(" r Resume")
print(" s Stop")
print(" n Next track")
print(" b Previous track")
print(" ? Show status")
print("================================")
poll = select.poll()
poll.register(sys.stdin, select.POLLIN)
while True:
events = poll.poll(100) # 100ms timeout
if events:
cmd = sys.stdin.read(1)
if cmd in '123456789':
track = int(cmd)
print("Playing track", track)
mp3.play(track)
elif cmd == '+':
print("Volume up")
mp3.volume_up()
elif cmd == '-':
print("Volume down")
mp3.volume_down()
elif cmd == 'p':
print("Paused")
mp3.pause()
elif cmd == 'r':
print("Resumed")
mp3.resume()
elif cmd == 's':
print("Stopped")
mp3.stop()
elif cmd == 'n':
print("Next track")
mp3.play_next()
elif cmd == 'b':
print("Previous track")
mp3.play_previous()
elif cmd == '?':
print("--- Status ---")
vol = mp3.get_volume()
print("Volume:", vol)
track = mp3.get_current_track()
print("Current track:", track)
playing = mp3.is_playing()
print("Playing:", "Yes" if playing else "No")
total = mp3.get_track_count()
print("Total tracks:", total)
print("--------------")
| Befehl | Wirkung |
|---|---|
| 1–9 | Titel abspielen |
| + / − | Lautstärke |
| p / r / s | Pause / Fortsetzen / Stopp |
| n / b | Nächster / Vorheriger |
| ? | Status |
Equalizer-Optionen
Das Modul verfügt über einen eingebauten DSP mit sechs EQ-Voreinstellungen. Auf dem ESP32 können Sie die EQ-Modi in Echtzeit umschalten – sogar während ein Titel läuft. Das ist nützlich für IoT-Projekte, bei denen Benutzer Audioprofile über eine Weboberfläche oder Bluetooth auswählen.
| Konstante | ID | Klangprofil |
|---|---|---|
| EQ_NORMAL | 0 | Linearer / neutraler Frequenzgang |
| EQ_POP | 1 | Klare Stimmen und Höhen |
| EQ_ROCK | 2 | Kräftige Mitten und Tiefen |
| EQ_JAZZ | 3 | Warmer, weicher Klang |
| EQ_CLASSIC | 4 | Ausgewogen über alle Frequenzen |
| EQ_BASS | 5 | Starke Bassanhebung |
import DIYables_MicroPython_MiniMp3.DIYables_MicroPython_MiniMp3 as mp3_const
mp3.set_eq(mp3_const.EQ_BASS) # Great for small speakers
Modulstatus prüfen
Statusabfragen senden eine Anfrage über UART2 und warten auf die Antwort des Moduls. Sie blockieren bis zu 100 ms (einstellbar mit set_timeout()). Kommt keine Antwort, geben sie −1 zurück.
Auf dem ESP32 können Sie diese z. B. in einem Webserver-Handler oder einer periodischen Prüfschleife verwenden – beachten Sie dabei nur die kurze Blockierzeit.
| Funktion | Rückgabe | Beschreibung |
|---|---|---|
| is_playing() | bool | True, wenn gerade ein Titel abgespielt wird |
| get_volume() | int | Aktuelle Lautstärke (0–30) |
| get_eq() | int | Aktive Equalizer-Voreinstellung (0–5) |
| get_track_count() | int | Anzahl der Titel auf der SD-Karte |
| get_current_track() | int | Nummer des aktuell abgespielten Titels |
| get_folder_count() | int | Anzahl der Ordner auf der SD-Karte |
| get_track_count_in_folder(f) | int | Anzahl der Titel in Ordner f |