ESP32 MicroPython - Mini Lecteur Mp3
L'ESP32 est un microcontrôleur polyvalent 3,3V avec WiFi, Bluetooth et plusieurs ports UART matériels. Combiné avec le module DIYables Mini Mp3 Player et MicroPython, vous pouvez construire n'importe quoi, d'un simple tableau d'effets sonores à un jukebox contrôlé par WiFi.
Ce tutoriel vous guide à travers :
- La connexion du Mini Mp3 Player à un ESP32 — directement, sans résistance.
- Le chargement correct des fichiers mp3 sur la carte SD.
- La lecture, la pause, la reprise, l'arrêt et le passage aux pistes suivantes.
- Le réglage du volume avec des boutons physiques.
- La répétition de pistes, la lecture aléatoire et l'organisation de l'audio en dossiers.
- La surveillance de l'état de lecture depuis votre code.
Composants Nécessaires
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 (ESP32 inclus) | |
| 1 | × | Kit de Capteurs DIYables (18 capteurs/écrans) |
Divulgation : Certains des liens fournis dans cette section sont des liens affiliés Amazon. Nous pouvons recevoir une commission pour tout achat effectué via ces liens, sans coût supplémentaire pour vous. Nous vous remercions de votre soutien.
Aucune résistance requise. L'ESP32 fonctionne à 3,3V — la même tension attendue par l'UART du Mini Mp3 Player.
Le Module Mini Mp3 Player
Le DIYables Mini Mp3 Player est une carte décodeur audio compacte basée sur la puce YX5200-24SS. Il lit les fichiers mp3 depuis une micro carte SD et sort l'audio via un amplificateur intégré 3W ou via des broches DAC pour un amplificateur externe.
L'ESP32 communique avec ce module via UART à 9600 bauds — une correspondance parfaite car l'ESP32 possède trois ports UART matériels. Vous pouvez dédier UART2 au module mp3 tout en gardant UART0 libre pour la console REPL MicroPython.
Le module prend en charge un ensemble riche de commandes série :
- Transport : lecture, pause, reprise, arrêt, suivant, précédent
- Volume : 31 niveaux (0–30), réglable à la volée
- Égaliseur : 6 préréglages — Normal, Pop, Rock, Jazz, Classique, Basses
- Modes de répétition : boucler une seule piste, boucler un dossier, boucler tout, ou lecture aléatoire
- Lecture par dossier : organiser l'audio dans des répertoires numérotés
- Publicités : interrompre la piste en cours avec une annonce, puis reprendre automatiquement
- Requêtes d'état : lire le numéro de piste, le volume, l'état de lecture et le nombre de fichiers
Description des Broches
| Broche | Fonction | Connexion ESP32 |
|---|---|---|
| VCC | Alimentation 3,2V à 5,0V | Connecter à 3,3V ou 5V (VIN) de l'ESP32 |
| GND | Masse | Connecter au GND de l'ESP32 |
| RX | Entrée données série | Connecter à GPIO17 de l'ESP32 (TX2) |
| TX | Sortie données série | Connecter à GPIO16 de l'ESP32 (RX2) |
| SPK_1 | Haut-parleur + (ampli intégré, 3W max) | Connecter au haut-parleur |
| SPK_2 | Haut-parleur − | Connecter au haut-parleur |
| DAC_R | Sortie ligne canal droit | Optionnel — pour ampli externe |
| DAC_L | Sortie ligne canal gauche | Optionnel — pour ampli externe |
| BUSY | LOW = en lecture, HIGH = arrêté | Optionnel — lire avec GPIO |
| IO_1 | Appui court → préc. ; appui long → vol. bas | Non utilisé (contrôlé via UART) |
| IO_2 | Appui court → suiv. ; appui long → vol. haut | Non utilisé (contrôlé via UART) |
Câblage
L'ESP32 utilise la logique 3,3V nativement, donc vous câblez les lignes série directement — aucun adaptateur de niveau ni résistance n'est nécessaire.
Nous recommandons d'utiliser UART2 (disponible par défaut sur la plupart des cartes ESP32 DevKit) :
| Mini Mp3 Player | ESP32 | Notes |
|---|---|---|
| VCC | 3.3V | Ou 5V depuis VIN si disponible |
| GND | GND | |
| RX | GPIO 17 (TX2) | Connexion directe |
| TX | GPIO 16 (RX2) | Connexion directe |
| SPK_1 | Haut-parleur + | |
| SPK_2 | Haut-parleur − |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Conseil : Si votre variante ESP32 n'expose pas GPIO 16/17 (certaines cartes DevKit-C V4 les utilisent pour la PSRAM), vous pouvez réassigner les broches UART dans le code :
uart = UART(2, baudrate=9600, tx=4, rx=5)
Préparation de la Carte SD
Avant de téléverser du code MicroPython sur l'ESP32, préparez la micro carte SD :
- Formatez la carte en FAT16 ou FAT32 (utilisez l'utilitaire de disque de votre ordinateur).
- Copiez les fichiers mp3 dans le répertoire racine avec des noms avec zéros de tête :
/001.mp3
/002.mp3
/003.mp3
- Optionnellement, organisez les pistes dans des dossiers numérotés pour une lecture multi-catégorie :
/01/001.mp3 ← dossier 1, piste 1
/01/002.mp3 ← dossier 1, piste 2
/02/001.mp3 ← dossier 2, piste 1
Règles clés pour la configuration ESP32 + Mini Mp3 Player :
- Les numéros de piste commencent à 1, pas à 0.
- Le module détermine l'ordre des pistes par la séquence de copie sur la carte — pas par nom de fichier. Formatez d'abord la carte, puis copiez les fichiers un par un dans l'ordre.
- Les noms de dossiers doivent être à 2 chiffres avec zéros de tête (01–99). Les noms de fichiers dans les dossiers doivent être à 3 chiffres avec zéros de tête (001–255).
- Insérez la carte SD dans le module Mini Mp3 Player avant de mettre l'ESP32 sous tension.
Étapes Rapides
Voici les instructions pour configurer et exécuter votre code MicroPython sur l'ESP32 avec Thonny IDE :
- Assurez-vous que Thonny IDE est installé sur votre ordinateur.
- Confirmez que le firmware MicroPython est chargé sur votre carte ESP32.
- Si c'est la première fois que vous utilisez un ESP32 avec MicroPython, consultez le guide ESP32 - Premiers pas. pour des instructions étape par étape.
- Connectez la carte ESP32 au module Mini Mp3 Player selon le schéma fourni.
- Connectez la carte ESP32 à votre ordinateur avec un câble USB.
- Ouvrez Thonny IDE sur votre ordinateur.
- Dans Thonny IDE, allez dans Outils Options.
- Dans l'onglet Interpréteur, choisissez MicroPython (ESP32) dans le menu déroulant.
- Assurez-vous que le bon port est sélectionné. Thonny IDE le détecte généralement automatiquement, mais vous devrez peut-être le sélectionner manuellement (comme COM12 sur Windows ou /dev/ttyACM0 sur Linux).
- Naviguez vers Outils Gérer les packages dans Thonny IDE.
- Recherchez "DIYables-MicroPython-MiniMp3", puis trouvez la bibliothèque Mini Mp3 Player créée par DIYables.
- Cliquez sur DIYables-MicroPython-MiniMp3, puis cliquez sur le bouton Installer pour installer la bibliothèque.
- Copiez le code MicroPython fourni et collez-le dans l'éditeur de Thonny.
- Sauvegardez le code sur votre ESP32 en :
- Cliquant sur le bouton Enregistrer ou en appuyant sur Ctrl+S.
- Dans la boîte de dialogue d'enregistrement, choisissez Appareil MicroPython.
- Nommez le fichier main.py.
- Cliquez sur le bouton vert Exécuter (ou appuyez sur F5) pour exécuter le script.
- Insérez la carte SD avec les fichiers mp3 dans le module Mini Mp3 Player.
- Écoutez la lecture audio via le haut-parleur connecté.
Modèle de Code de Démarrage
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
Code ESP32 MicroPython — Lire une Piste
"""
* 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
Essayez
- Chargez la carte SD, câblez le module, connectez l'ESP32 via USB.
- Téléversez le code avec Thonny IDE ou votre outil MicroPython préféré.
Contrôle de Lecture
Toutes les commandes de lecture sont non bloquantes — l'ESP32 envoie la commande via UART2 et retourne immédiatement, donc votre code MicroPython continue de s'exécuter.
| Méthode | Action | Exemple de code |
|---|---|---|
| play(n) | Lit la piste numéro n depuis la racine | mp3.play(1) |
| play_next() | Passe à la piste suivante | mp3.play_next() |
| play_previous() | Revient à la piste précédente | mp3.play_previous() |
| pause() | Met la lecture en pause à la position actuelle | mp3.pause() |
| resume() | Continue depuis la position de pause | mp3.resume() |
| stop() | Arrête complètement la lecture | mp3.stop() |
Code ESP32 MicroPython — Plusieurs Pistes
"""
* 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()
Code ESP32 MicroPython — Boutons de Volume
"""
* 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
API Volume
L'ESP32 peut régler le volume à n'importe quel niveau entre 0 (muet) et 30 (maximum) instantanément, ou monter/descendre d'un niveau à la fois — utile pour le contrôle par boutons.
| Méthode | Action | Exemple |
|---|---|---|
| set_volume(v) | Régler le volume à un niveau spécifique (0–30) | mp3.set_volume(20) |
| volume_up() | Augmenter le volume d'un cran | mp3.volume_up() |
| volume_down() | Diminuer le volume d'un cran | mp3.volume_down() |
| get_volume() | Interroger le niveau de volume actuel | mp3.get_volume() |
Code ESP32 MicroPython — Suivant/Précédent
"""
* 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
Code ESP32 MicroPython — Pause/Reprise
"""
* 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
Code ESP32 MicroPython — Boucler une Piste
"""
* 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)
Répétition & Lecture Aléatoire
Ces modes de répétition s'exécutent entièrement sur le module mp3 — l'ESP32 envoie simplement la commande une fois et le module gère la lecture continue automatiquement.
| Méthode | Comportement | Exemple |
|---|---|---|
| loop_track(n) | Répéter une seule piste indéfiniment | mp3.loop_track(1) |
| loop_folder(f) | Parcourir toutes les pistes d'un dossier | mp3.loop_folder(1) |
| loop_all() | Lire toutes les pistes sur la carte SD, puis recommencer | mp3.loop_all() |
| stop_loop() | Arrêter la répétition après la fin de la piste actuelle | mp3.stop_loop() |
| shuffle() | Lire toutes les pistes dans un ordre aléatoire | mp3.shuffle() |
Code ESP32 MicroPython — Lecture par Dossier
"""
* 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)
API Dossier
La lecture par dossier est idéale pour les projets ESP32 nécessitant de l'audio catégorisé — par exemple, différentes langues, catégories de sons ou listes de lecture.
| Méthode | Description | Exemple |
|---|---|---|
| play_folder(f, t) | Lire la piste t du dossier f (jusqu'à 99 dossiers, 255 pistes chacun) | mp3.play_folder(1, 1) |
| play_large_folder(f, t) | Mode grand dossier (jusqu'à 15 dossiers, 3000 pistes chacun) | mp3.play_large_folder(1, 2000) |
| play_from_mp3_folder(t) | Lire depuis le dossier /mp3 spécial (jusqu'à 9999 pistes) | mp3.play_from_mp3_folder(1) |
Code ESP32 MicroPython — Contrôle via Console Série
"""
* 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("--------------")
| Commande | Effet |
|---|---|
| 1–9 | Lire une piste |
| + / − | Volume |
| p / r / s | Pause / Reprise / Arrêt |
| n / b | Suivant / Précédent |
| ? | État |
Options d'Égaliseur
Le module intègre un DSP avec six préréglages EQ. Sur l'ESP32, vous pouvez changer les modes EQ en temps réel — même pendant la lecture d'une piste.
| Constante | ID | Profil Sonore |
|---|---|---|
| EQ_NORMAL | 0 | Réponse plate / neutre |
| EQ_POP | 1 | Voix et aigus brillants |
| EQ_ROCK | 2 | Médiums et basses percutants |
| EQ_JAZZ | 3 | Ton chaud et doux |
| EQ_CLASSIC | 4 | Équilibré sur toutes les fréquences |