ESP32 - Mini Lecteur Mp3
L'ESP32 est un microcontrôleur polyvalent 3,3V avec WiFi, Bluetooth et plusieurs ports série matériels. Combiné avec le module DIYables Mini Mp3 Player, 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 petite carte basée sur la puce YX5200-24SS. Il décode les fichiers mp3 depuis une micro carte SD et peut piloter directement un haut-parleur via son amplificateur intégré 3W. Vous pouvez également utiliser les broches DAC pour alimenter un amplificateur externe afin d'obtenir une puissance sonore plus élevée.
Tout est contrôlé via des commandes série à 9600 bauds :
- Transport : lecture, pause, reprise, arrêt, suivant, précédent
- Volume : 31 niveaux (0–30)
- Égaliseur : Normal, Pop, Rock, Jazz, Classique, Basses
- Répétition : boucler une seule piste, boucler un dossier, boucler toutes les pistes, lecture aléatoire
- Dossiers : lecture depuis des répertoires numérotés sur la carte
- Publicités : interrompre temporairement la lecture, puis reprendre
- Requêtes : lire le numéro de piste, le volume, l'état de lecture, le nombre de pistes
Description des Broches
| Broche | Fonction |
|---|---|
| VCC | Alimentation 3,2V à 5,0V |
| GND | Masse |
| RX | Entrée données série (connecter à la broche TX de l'ESP32) |
| TX | Sortie données série (connecter à la broche RX de l'ESP32) |
| SPK_1 | Haut-parleur + (ampli intégré, 3W max) |
| SPK_2 | Haut-parleur − |
| DAC_R | Sortie ligne canal droit |
| DAC_L | Sortie ligne canal gauche |
| BUSY | LOW = en lecture, HIGH = arrêté |
| IO_1 | Appui court → piste préc. ; appui long → vol. bas |
| IO_2 | Appui court → piste suiv. ; appui long → vol. haut |
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 Serial2 (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.
Si vous ne savez pas comment alimenter l'ESP32 et d'autres composants, consultez les instructions dans le tutoriel suivant : Comment alimenter l'ESP32..
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 de Serial2 dans le code :
Serial2.begin(9600, SERIAL_8N1, 4, 5); // RX=GPIO4, TX=GPIO5
Préparation de la Carte SD
- Formatez en FAT16 ou FAT32.
- Placez les fichiers mp3 à la racine :
/001.mp3
/002.mp3
/003.mp3
- Pour une lecture organisée, utilisez des dossiers numérotés :
/01/001.mp3
/01/002.mp3
/02/001.mp3
Notes importantes :
- Les numéros de piste commencent à 1.
- Le module indexe les pistes selon l'ordre dans lequel elles ont été copiées sur la carte, pas par nom de fichier. Formatez toujours d'abord, puis copiez séquentiellement.
- Noms de dossiers : 01–99 (2 chiffres), noms de fichiers : 001–255 (3 chiffres).
Installation de la Bibliothèque
- Connectez l'ESP32 à votre ordinateur.
- Dans l'IDE Arduino, sélectionnez votre variante de carte ESP32 et le port correct.
- Ouvrez le gestionnaire de Bibliothèques.
- Recherchez "DIYables_MiniMp3" et installez la bibliothèque de DIYables.
Aucune dépendance — fonctionne immédiatement.
Modèle de Code de Démarrage
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup() {
Serial.begin(115200); // Debug output
Serial2.begin(9600); // Mp3 module communication
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(25); // 0 = silence, 30 = maximum
}
void loop() {
// Add your logic
}
Code ESP32 — Lire une Piste
/*
* DIYables Mini Mp3 Player - Play One Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays track 001 once, then stops.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Set volume (0 to 30)
Serial.println("Playing track 1...");
mp3.play(1); // Play track 001.mp3
}
void loop()
{
// Nothing to do here
}
Essayez
- Chargez la carte SD, câblez le module, connectez l'ESP32 via USB.
- Sélectionnez votre carte ESP32 dans l'IDE et téléversez.
Contrôle de Lecture
| Méthode | Action | Exemple de code |
|---|---|---|
| play(n) | Lit la piste numéro n | mp3.play(1) |
| playNext() | Passe à la piste suivante | mp3.playNext() |
| playPrevious() | Revient à la piste précédente | mp3.playPrevious() |
| pause() | Met la lecture en pause | mp3.pause() |
| resume() | Reprend là où vous vous êtes arrêté | mp3.resume() |
| stop() | Arrête complètement la lecture | mp3.stop() |
Code ESP32 — Plusieurs Pistes
/*
* DIYables Mini Mp3 Player - Play Multiple Tracks
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays tracks one after another with a delay between them.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, 003.mp3
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
int currentTrack = 1;
int totalTracks = 3; // Change this to match your SD card
unsigned long lastTrackTime = 0;
unsigned long trackDuration = 5000; // Wait 5 seconds between tracks (adjust as needed)
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(20);
Serial.println("Playing track 1...");
mp3.play(currentTrack);
lastTrackTime = millis();
}
void loop()
{
// After trackDuration, play the next track
if (millis() - lastTrackTime >= trackDuration)
{
currentTrack++;
if (currentTrack > totalTracks)
currentTrack = 1; // Loop back to first track
Serial.print("Playing track ");
Serial.println(currentTrack);
mp3.play(currentTrack);
lastTrackTime = millis();
}
}
Code ESP32 — Boutons de Volume
/*
* DIYables Mini Mp3 Player - Volume Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Use two buttons to increase/decrease the volume.
* Press button on pin GPIO1 to volume up, pin GPIO3 to volume down.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin GPIO1 (other leg to GND)
* Button DOWN -> Pin GPIO3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = 1;
const int BUTTON_VOL_DOWN = 3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
pinMode(BUTTON_VOL_UP, INPUT_PULLUP);
pinMode(BUTTON_VOL_DOWN, INPUT_PULLUP);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(volume);
mp3.loopTrack(1); // Play track 1 on repeat
Serial.print("Volume: ");
Serial.println(volume);
}
void loop()
{
// Volume Up button (pressed = LOW because of INPUT_PULLUP)
if (digitalRead(BUTTON_VOL_UP) == LOW)
{
if (volume < 30)
{
volume++;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
// Volume Down button
if (digitalRead(BUTTON_VOL_DOWN) == LOW)
{
if (volume > 0)
{
volume--;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
}
API Volume
| Méthode | Action | Exemple |
|---|---|---|
| setVolume(v) | Passer au niveau v | mp3.setVolume(20) |
| volumeUp() | Incrémenter de 1 | mp3.volumeUp() |
| volumeDown() | Décrémenter de 1 | mp3.volumeDown() |
| getVolume() | Lire le niveau actuel | mp3.getVolume() |
Code ESP32 — Suivant/Précédent
/*
* DIYables Mini Mp3 Player - Next/Previous with Buttons
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Use two buttons to play next/previous tracks.
* Displays the current track number on the Serial Monitor.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> Pin GPIO1 (other leg to GND)
* Button PREV -> Pin GPIO3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
const int BUTTON_NEXT = 1;
const int BUTTON_PREV = 3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
pinMode(BUTTON_NEXT, INPUT_PULLUP);
pinMode(BUTTON_PREV, INPUT_PULLUP);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(20);
mp3.play(1); // Start with track 1
Serial.println("Press NEXT or PREV button to change track");
}
void loop()
{
if (digitalRead(BUTTON_NEXT) == LOW)
{
Serial.println("Next track");
mp3.playNext();
delay(300); // Simple debounce
}
if (digitalRead(BUTTON_PREV) == LOW)
{
Serial.println("Previous track");
mp3.playPrevious();
delay(300); // Simple debounce
}
}
Code ESP32 — Pause/Reprise
/*
* DIYables Mini Mp3 Player - Pause and Resume
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Demonstrates pausing and resuming playback using a single button.
* Press the button to toggle between pause and resume.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin GPIO1 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = 1;
bool paused = false;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
pinMode(BUTTON_PIN, INPUT_PULLUP);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(20);
mp3.play(1);
Serial.println("Playing. Press button to pause/resume.");
}
void loop()
{
if (digitalRead(BUTTON_PIN) == LOW)
{
if (paused)
{
mp3.resume();
Serial.println("Resumed");
}
else
{
mp3.pause();
Serial.println("Paused");
}
paused = !paused;
delay(300); // Simple debounce
}
}
Code ESP32 — Boucler une Piste
/*
* DIYables Mini Mp3 Player - Loop Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Loops (repeats) a track continuously with EQ setting.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /001.mp3
* /002.mp3
* ...
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Volume: 0 to 30
mp3.setEQ(DIYables_MiniMp3::EQ_NORMAL);
Serial.println("Playing track 1 on loop...");
mp3.loopTrack(1);
}
void loop()
{
// Your code here
}
Répétition & Lecture Aléatoire
| Méthode | Comportement | Exemple |
|---|---|---|
| loopTrack(n) | Répéter la piste n indéfiniment | mp3.loopTrack(1) |
| loopFolder(f) | Répéter toutes les pistes du dossier f | mp3.loopFolder(1) |
| loopAll() | Répéter toutes les pistes | mp3.loopAll() |
| stopLoop() | Annuler la boucle active | mp3.stopLoop() |
| shuffle() | Aléatoiriser la lecture | mp3.shuffle() |
Code ESP32 — Lecture par Dossier
/*
* DIYables Mini Mp3 Player - Play from Folder
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays tracks from specific folders on the SD card.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /01/001.mp3 <- playFolder(1, 1)
* /01/002.mp3 <- playFolder(1, 2)
* /02/001.mp3 <- playFolder(2, 1)
* /02/002.mp3 <- playFolder(2, 2)
*
* IMPORTANT:
* - Numbering starts from 1, NOT 0
* - Folder names must be 2-digit zero-padded (01-99)
* - Track names must be 3-digit zero-padded (001-255)
* - Format SD card as FAT32, then copy files one by one in order
* - Track order is determined by the order files were copied,
* NOT by filename. So copy them in the correct sequence.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(20);
// Play track 1 from folder 01
Serial.println("Playing folder 01, track 001...");
mp3.playFolder(1, 1);
delay(5000);
// Play track 2 from folder 01
Serial.println("Playing folder 01, track 002...");
mp3.playFolder(1, 2);
delay(5000);
// Play track 1 from folder 02
Serial.println("Playing folder 02, track 001...");
mp3.playFolder(2, 1);
}
void loop()
{
// Nothing to do here
}
API Dossier
| Méthode | Description | Exemple |
|---|---|---|
| playFolder(f, t) | Lire la piste t du dossier f | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Grand dossier (15 dossiers, 3000 pistes) | mp3.playLargeFolder(1, 2000) |
| playFromMP3Folder(t) | Lire depuis le dossier /mp3 | mp3.playFromMP3Folder(1) |
Code ESP32 — Contrôle via le Moniteur Série
/*
* DIYables Mini Mp3 Player - Serial Command Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Control the Mp3 player by typing commands in the Serial Monitor.
* Great for testing all functions without extra hardware.
*
* Commands (type in Serial Monitor, then press Enter):
* 1-9 Play track 1 to 9
* + Volume up
* - Volume down
* p Pause
* r Resume
* s Stop
* n Next track
* b Previous track (back)
* ? Show current status
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> ESP32 pin GPIO 17 (TX2)
* Mini Mp3 TX -> ESP32 pin GPIO 16 (RX2)
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
Serial2.begin(9600);
mp3.begin(Serial2);
delay(1000);
mp3.setVolume(20);
Serial.println("=== DIYables Mini Mp3 Player ===");
Serial.println("Commands:");
Serial.println(" 1-9 Play track number");
Serial.println(" + Volume up");
Serial.println(" - Volume down");
Serial.println(" p Pause");
Serial.println(" r Resume");
Serial.println(" s Stop");
Serial.println(" n Next track");
Serial.println(" b Previous track");
Serial.println(" ? Show status");
Serial.println("================================");
}
void loop()
{
if (Serial.available())
{
char cmd = Serial.read();
switch (cmd)
{
case '1': case '2': case '3':
case '4': case '5': case '6':
case '7': case '8': case '9':
Serial.print("Playing track ");
Serial.println(cmd - '0');
mp3.play(cmd - '0');
break;
case '+':
Serial.println("Volume up");
mp3.volumeUp();
break;
case '-':
Serial.println("Volume down");
mp3.volumeDown();
break;
case 'p':
Serial.println("Paused");
mp3.pause();
break;
case 'r':
Serial.println("Resumed");
mp3.resume();
break;
case 's':
Serial.println("Stopped");
mp3.stop();
break;
case 'n':
Serial.println("Next track");
mp3.playNext();
break;
case 'b':
Serial.println("Previous track");
mp3.playPrevious();
break;
case '?':
{
Serial.println("--- Status ---");
int16_t vol = mp3.getVolume();
Serial.print("Volume: ");
Serial.println(vol);
int16_t track = mp3.getCurrentTrack();
Serial.print("Current track: ");
Serial.println(track);
bool playing = mp3.isPlaying();
Serial.print("Playing: ");
Serial.println(playing ? "Yes" : "No");
int16_t total = mp3.getTrackCount();
Serial.print("Total tracks: ");
Serial.println(total);
Serial.println("--------------");
break;
}
default:
break;
}
}
}
| 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
| Constante | ID | Caractère |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Neutre |
| DIYables_MiniMp3::EQ_POP | 1 | Brillant |
| DIYables_MiniMp3::EQ_ROCK | 2 | Percutant |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Chaleureux |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Équilibré |
| DIYables_MiniMp3::EQ_BASS | 5 | Grave prononcé |
mp3.setEQ(DIYables_MiniMp3::EQ_BASS);
Vérification de l'État du Module
Ces fonctions bloquent pendant 100 ms maximum en attendant la réponse du module. Elles retournent −1 si aucune réponse n'arrive.
| Fonction | Retour | Description |
|---|---|---|
| isPlaying() | bool | true pendant la lecture active |
| getVolume() | int16_t | Volume actuel (0–30) |
| getEQ() | int16_t | Égaliseur actif (0–5) |
| getTrackCount() | int16_t | Nombre total de pistes sur la carte SD |
| getCurrentTrack() | int16_t | Numéro de la piste en cours de lecture |
| getFolderCount() | int16_t | Nombre total de dossiers sur la carte SD |
| getTrackCountInFolder(f) | int16_t | Nombre de pistes dans le dossier f |