ESP32 S3 - Mini lecteur Mp3
L'ESP32 S3 est une puissante carte de développement 3,3V avec traitement double cœur et une riche prise en charge des périphériques, ce qui en fait un excellent choix pour les projets audio. Dans ce tutoriel, vous apprendrez à construire un système complet de lecteur mp3 en utilisant le module DIYables Mini Mp3 Player avec votre carte ESP32 S3.
Ce que vous allez construire :
- Un lecteur mp3 fonctionnel qui lit des fichiers audio depuis une carte micro SD
- Un système de contrôle du volume utilisant des boutons physiques
- Une interface de navigation de pistes avec des commandes suivant/précédent
- Un panneau de contrôle via moniteur série pour tester toutes les fonctionnalités de lecture
Matériel nécessaire
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables ESP32 S3 (ESP32 S3 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.
À propos du module Mini Mp3 Player
Le DIYables Mini Mp3 Player est un module décodeur mp3 YX5200-24SS qui lit des fichiers audio depuis une carte micro SD via un amplificateur intégré. Il communique en série UART à 9600 bauds et inclut un amplificateur de 3W pour une connexion directe à un haut-parleur, ce qui en fait une solution audio autonome ne nécessitant aucun circuit décodeur ou amplificateur externe.
Spécifications clés
- Fonctionne entre 3,3V et 5V (parfait pour la logique 3,3V de l'ESP32 S3)
- Contrôle via série UART à 9600 bauds
- Amplificateur 3W intégré pour connexion directe à un haut-parleur
- Prend en charge jusqu'à 255 pistes et 99 dossiers
- 31 niveaux de volume (0 à 30)
- 6 préréglages d'égaliseur (Normal, Pop, Rock, Jazz, Classic, Bass)
- Plusieurs modes de répétition et de lecture aléatoire
- Fonctions de requête d'état pour le volume, le numéro de piste, et l'état de lecture
- Aucun circuit décodeur ou amplificateur externe nécessaire
- Convivial pour les débutants avec des commandes série simples
Brochage
Le module Mini Mp3 Player a 11 broches couvrant l'alimentation, la communication, la sortie audio, et les fonctions de contrôle.
- VCC : Alimentation (3,2V à 5,0V)
- GND : Connexion de masse
- RX : Réception UART (connecter à la broche TX de l'ESP32 S3)
- TX : Transmission UART (connecter à la broche RX de l'ESP32 S3)
- SPK_1 : Borne positive du haut-parleur (amplificateur 3W intégré)
- SPK_2 : Borne négative du haut-parleur
- DAC_R : Sortie audio ligne, canal droit
- DAC_L : Sortie audio ligne, canal gauche
- BUSY : Broche d'état (LOW pendant la lecture, HIGH au repos)
- IO_1 : Entrée bouton (appui court = précédent, appui long = volume moins)
- IO_2 : Entrée bouton (appui court = suivant, appui long = volume plus)
Schéma de câblage
Connectez le Mini Mp3 Player à votre ESP32 S3 en utilisant le port série matériel Serial1, qui fournit une communication UART fiable au débit requis. L'ESP32 S3 fonctionne en logique 3,3V, correspondant parfaitement aux niveaux de signal du module, donc aucune résistance d'adaptation de niveau n'est nécessaire sur les lignes TX/RX.
Notes de sécurité
Alimentez le module depuis la broche 3,3V pour les applications à faible volume, ou depuis le 5V (VBUS) si vous avez besoin du volume maximal du haut-parleur — l'amplificateur intégré fonctionne mieux avec une tension d'alimentation plus élevée. Connectez toujours GND avant de mettre sous tension, et assurez-vous que l'impédance de votre haut-parleur correspond à la puissance de 3W de l'amplificateur du module pour éviter tout dommage.
| Mini Mp3 Player | ESP32 S3 | Remarques |
|---|---|---|
| VCC | 3.3V | Le module accepte aussi 5V depuis VBUS si nécessaire |
| GND | GND | Masse commune |
| RX | TX1 (GPIO17) | Connexion directe — aucune résistance nécessaire |
| TX | RX1 (GPIO18) | Connexion directe — compatible logique 3,3V |
| SPK_1 | Speaker + | Sortie amplifiée |
| SPK_2 | Speaker − | Sortie amplifiée |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Configuration de la carte SD
Le Mini Mp3 Player nécessite des fichiers correctement formatés et nommés sur votre carte micro SD.
Exigences de formatage :
- Système de fichiers : FAT16 ou FAT32
- Taille de carte : Jusqu'à 32 Go recommandé
Nommage de base des fichiers (répertoire racine) :
/001.mp3
/002.mp3
/003.mp3
Nommage basé sur des dossiers (lecture organisée) :
/01/001.mp3
/01/002.mp3
/02/001.mp3
Règles de nommage essentielles :
- La numérotation des pistes commence à 1 (pas 0)
- Fichiers racine : noms à 3 chiffres avec zéros de remplissage (001–255)
- Noms de dossiers : 2 chiffres avec zéros de remplissage (01–99)
- Fichiers dans les dossiers : 3 chiffres avec zéros de remplissage (001–255)
- L'ordre de copie compte : Le module détermine l'ordre de lecture à partir de l'ordre de copie des fichiers, pas du nommage alphabétique
- Bonne pratique : Formatez d'abord la carte, puis copiez les fichiers un par un dans l'ordre de lecture souhaité
Installation de la bibliothèque
La bibliothèque DIYables_MiniMp3 simplifie le contrôle du module mp3 pour les projets ESP32 S3. Installez-la directement depuis le gestionnaire de bibliothèques de l'Arduino IDE avant de téléverser l'un des croquis d'exemple.
- Connectez votre ESP32 S3 à votre ordinateur via câble USB-C
- Ouvrez l'Arduino IDE
- Sélectionnez ESP32 S3 comme carte
- Choisissez le bon port COM
- Cliquez sur l'icône Libraries dans la barre latérale gauche
- Recherchez "DIYables_MiniMp3"
- Trouvez la bibliothèque de DIYables
- Cliquez sur Install
- Search for DIYables_MiniMp3 created by DIYables
and click the Install button.
1
void setup() {
Avantages de la bibliothèque :
- Zéro dépendance externe
- Fonctions de commande simples pour toutes les fonctionnalités de lecture
- Fonctionne parfaitement avec le port série matériel de l'ESP32 S3
Code ESP32 S3 — Configuration de base
Le code suivant montre le modèle de base pour contrôler le Mini Mp3 Player avec l'ESP32 S3 en utilisant le port série matériel Serial1. Il initialise l'interface série, attend le démarrage du module, et définit un niveau de volume initial afin que vous puissiez vérifier que la connexion fonctionne avant d'ajouter la logique de lecture.
Ce que fait ce code :
- Initialise Serial1 pour la communication avec le module mp3 à 9600 bauds
- Configure l'objet lecteur mp3
- Attend le démarrage du module
- Définit le volume initial au niveau 25
#include <DIYables_MiniMp3.h>
DIYables_MiniMp3 mp3;
void setup() {
Serial.begin(115200);
Serial1.begin(9600); // Hardware serial for the mp3 module
mp3.begin(Serial1);
delay(1000); // Wait for the module to boot
mp3.setVolume(25);
}
void loop() {
// Your code here
}
Pourquoi le port série matériel ?
- L'ESP32 S3 possède un matériel UART dédié
- Plus fiable que le port série logiciel
- Aucun problème de synchronisation à 9600 bauds
- Laisse le port série USB libre pour le débogage
Code ESP32 S3 — Lire une seule piste
Le code suivant montre comment lire une seule piste depuis votre carte SD avec l'ESP32 S3. Il initialise le module mp3 et commence immédiatement à lire la piste 001.mp3 afin que vous puissiez confirmer que toute la chaîne matérielle fonctionne correctement.
/*
* DIYables Mini Mp3 Player - Play One Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays track 001 once, then stops.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
mp3.begin(mp3Serial);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Set volume (0 to 30)
Serial.println("Playing track 1...");
mp3.play(1); // Play track 001.mp3
}
void loop()
{
// Nothing to do here
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Préparer la carte SD : Formatez en FAT32 et copiez les fichiers mp3 nommés 001.mp3, 002.mp3, etc.
- Insérer la carte SD : Placez la carte micro SD dans l'emplacement du module.
- Connecter le câblage : Suivez le schéma de câblage ci-dessus (VCC, GND, TX1, RX1, haut-parleur).
- Connecter le haut-parleur : Fixez votre haut-parleur aux bornes SPK_1 et SPK_2.
- Ouvrir l'Arduino IDE : Lancez l'IDE sur votre ordinateur.
- Sélectionner la carte : Choisissez ESP32 S3 dans le menu des cartes.
- Sélectionner le port : Choisissez le bon port COM pour votre carte.
- Téléverser le code : Copiez le code ci-dessus et téléversez-le vers votre ESP32 S3.
- Écouter : La piste 001.mp3 devrait jouer via le haut-parleur.
- Astuce : Si vous n'entendez aucun son, vérifiez le format de la carte SD et le nommage des fichiers — le module est très sensible aux conventions de nommage.
Commandes de lecture
| Méthode | Objectif | Exemple |
|---|---|---|
| play(trackNum) | Démarrer une piste spécifique | mp3.play(1) |
| playNext() | Avancer à la piste suivante | mp3.playNext() |
| playPrevious() | Aller à la piste précédente | mp3.playPrevious() |
| pause() | Mettre en pause la piste active | mp3.pause() |
| resume() | Reprendre la piste | mp3.resume() |
| stop() | Arrêter la lecture | mp3.stop() |
Code ESP32 S3 — Lire plusieurs pistes
Le code suivant montre comment parcourir automatiquement plusieurs pistes, en avançant à la chanson suivante toutes les quelques secondes. Ce modèle est utile pour les systèmes de musique de fond ou les projets de démonstration où vous voulez une lecture continue sans interaction utilisateur.
/*
* DIYables Mini Mp3 Player - Play Multiple Tracks
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays tracks one after another with a delay between them.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, 003.mp3
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
int currentTrack = 1;
int totalTracks = 3; // Change this to match your SD card
unsigned long lastTrackTime = 0;
unsigned long trackDuration = 5000; // Wait 5 seconds between tracks (adjust as needed)
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
Serial.println("Playing track 1...");
mp3.play(currentTrack);
lastTrackTime = millis();
}
void loop()
{
// After trackDuration, play the next track
if (millis() - lastTrackTime >= trackDuration)
{
currentTrack++;
if (currentTrack > totalTracks)
currentTrack = 1; // Loop back to first track
Serial.print("Playing track ");
Serial.println(currentTrack);
mp3.play(currentTrack);
lastTrackTime = millis();
}
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Préparer la carte SD : Assurez-vous d'avoir au moins 3 fichiers mp3 nommés 001.mp3, 002.mp3, 003.mp3.
- Câbler le module : Utilisez le même câblage que dans l'exemple précédent.
- Téléverser le code : Copiez et téléversez le croquis ci-dessus.
- Écouter : Les pistes tournent automatiquement toutes les 5 secondes.
- Surveiller le port série : Ouvrez le moniteur série à 115200 bauds pour voir les changements de piste.
- Astuce : Ajustez la valeur delay(5000) pour changer combien de temps chaque piste joue avant de passer à la suivante.
Sortie du moniteur série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:12:01] Playing track: 1
[2026-01-15 09:12:06] Playing track: 2
[2026-01-15 09:12:11] Playing track: 3
[2026-01-15 09:12:16] Playing track: 1
Code ESP32 S3 — Contrôle du volume
Le code suivant ajoute deux boutons matériels à votre projet ESP32 S3 afin que l'utilisateur puisse augmenter ou diminuer le volume du lecteur mp3 en temps réel. Chaque appui de bouton augmente ou diminue le volume d'un cran, et le niveau actuel est affiché dans le moniteur série pour le débogage.
/*
* DIYables Mini Mp3 Player - Volume Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Use two buttons to increase/decrease the volume.
* Press button on pin 2 to volume up, pin 3 to volume down.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin 2 (other leg to GND)
* Button DOWN -> Pin 3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = 2;
const int BUTTON_VOL_DOWN = 3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
pinMode(BUTTON_VOL_UP, INPUT_PULLUP);
pinMode(BUTTON_VOL_DOWN, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(volume);
mp3.loopTrack(1); // Play track 1 on repeat
Serial.print("Volume: ");
Serial.println(volume);
}
void loop()
{
// Volume Up button (pressed = LOW because of INPUT_PULLUP)
if (digitalRead(BUTTON_VOL_UP) == LOW)
{
if (volume < 30)
{
volume++;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
// Volume Down button
if (digitalRead(BUTTON_VOL_DOWN) == LOW)
{
if (volume > 0)
{
volume--;
mp3.setVolume(volume);
Serial.print("Volume: ");
Serial.println(volume);
}
delay(200); // Simple debounce
}
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Ajouter les boutons : Câblez deux boutons sur GPIO4 et GPIO5 (plus GND).
- Téléverser le code : Copiez le croquis ci-dessus dans l'Arduino IDE et téléversez-le.
- Tester les boutons : Appuyez sur les boutons pendant que la musique joue pour ajuster le volume.
- Surveiller le port série : Le moniteur série affiche le niveau de volume actuel.
- Astuce : La plage de volume est de 0 à 30, 15 étant un bon point de départ pour la plupart des haut-parleurs.
Commandes de volume
| Méthode | Objectif | Exemple |
|---|---|---|
| setVolume(v) | Passer directement à un niveau de volume spécifique | mp3.setVolume(20) |
| volumeUp() | Augmenter d'un cran | mp3.volumeUp() |
| volumeDown() | Diminuer d'un cran | mp3.volumeDown() |
| getVolume() | Interroger le niveau actuel | mp3.getVolume() |
Sortie du moniteur série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:15:03] Volume: 25
[2026-01-15 09:15:07] Volume: 26
[2026-01-15 09:15:11] Volume: 25
[2026-01-15 09:15:14] Volume: 24
Code ESP32 S3 — Boutons Suivant/Précédent
Le code suivant câble deux boutons à votre ESP32 S3 pour la navigation manuelle des pistes, permettant aux utilisateurs de passer en avant ou en arrière dans la playlist de la carte SD. Le numéro de piste actuel est envoyé au moniteur série chaque fois qu'un bouton est appuyé.
/*
* DIYables Mini Mp3 Player - Next/Previous with Buttons
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Use two buttons to play next/previous tracks.
* Displays the current track number on the Serial Monitor.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> Pin 2 (other leg to GND)
* Button PREV -> Pin 3 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_NEXT = 2;
const int BUTTON_PREV = 3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
pinMode(BUTTON_NEXT, INPUT_PULLUP);
pinMode(BUTTON_PREV, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
mp3.play(1); // Start with track 1
Serial.println("Press NEXT or PREV button to change track");
}
void loop()
{
if (digitalRead(BUTTON_NEXT) == LOW)
{
Serial.println("Next track");
mp3.playNext();
delay(300); // Simple debounce
}
if (digitalRead(BUTTON_PREV) == LOW)
{
Serial.println("Previous track");
mp3.playPrevious();
delay(300); // Simple debounce
}
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Câbler les boutons : Connectez le bouton NEXT sur GPIO4 et le bouton PREV sur GPIO5.
- Connecter la masse : Câblez les autres bornes des boutons à GND.
- Téléverser le croquis : Chargez le code ci-dessus sur votre ESP32 S3.
- Tester la navigation : Appuyez sur les boutons pour passer en avant ou en arrière dans les pistes.
- Surveiller la sortie : Le moniteur série affiche le numéro de piste actuel.
- Astuce : Utilisez des résistances de tirage (pull-up) de 10kΩ pour un fonctionnement des boutons plus fiable dans les environnements bruyants.
Sortie du moniteur série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:18:02] Current track: 1
[2026-01-15 09:18:05] Current track: 2
[2026-01-15 09:18:09] Current track: 3
[2026-01-15 09:18:13] Current track: 2
Code ESP32 S3 — Basculer Pause/Reprise
Le code suivant utilise un seul bouton sur votre ESP32 S3 pour basculer entre les états pause et lecture, offrant aux utilisateurs un moyen simple de mettre la musique en pause sans arrêter complètement la piste. L'état de lecture est affiché dans le moniteur série afin que vous puissiez suivre la logique pendant les tests.
/*
* DIYables Mini Mp3 Player - Pause and Resume
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Demonstrates pausing and resuming playback using a single button.
* Press the button to toggle between pause and resume.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin 2 (other leg to GND)
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = 2;
bool paused = false;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
pinMode(BUTTON_PIN, INPUT_PULLUP);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
mp3.play(1);
Serial.println("Playing. Press button to pause/resume.");
}
void loop()
{
if (digitalRead(BUTTON_PIN) == LOW)
{
if (paused)
{
mp3.resume();
Serial.println("Resumed");
}
else
{
mp3.pause();
Serial.println("Paused");
}
paused = !paused;
delay(300); // Simple debounce
}
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Câbler le bouton : Connectez le bouton pause/reprise sur GPIO4 et GND.
- Téléverser le code : Chargez le croquis sur votre carte.
- Démarrer la lecture : La musique démarre automatiquement.
- Basculer la pause : Appuyez sur le bouton pour mettre en pause, appuyez à nouveau pour reprendre.
- Vérifier le statut : Le moniteur série affiche l'état de lecture.
- Astuce : La broche BUSY du module peut aussi indiquer l'état lecture/pause pour un retour visuel avec une LED.
Sortie du moniteur série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:21:01] Playing track 1
[2026-01-15 09:21:08] Music paused
[2026-01-15 09:21:14] Music resumed
[2026-01-15 09:21:20] Music paused
Code ESP32 S3 — Boucler une piste
Le code suivant programme le Mini Mp3 Player pour répéter une seule piste en continu, ce qui est idéal pour la musique de fond ou les sons d'alerte qui ne doivent jamais s'arrêter. Une fois téléversé sur votre ESP32 S3, aucune autre interaction n'est nécessaire — la lecture boucle automatiquement.
/*
* DIYables Mini Mp3 Player - Loop Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Loops (repeats) a track continuously with EQ setting.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /001.mp3
* /002.mp3
* ...
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
mp3.begin(mp3Serial);
delay(1000); // Wait for the module to initialize
mp3.setVolume(25); // Volume: 0 to 30
mp3.setEQ(DIYables_MiniMp3::EQ_NORMAL);
Serial.println("Playing track 1 on loop...");
mp3.loopTrack(1);
}
void loop()
{
// Your code here
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Téléverser le croquis : Chargez le code ci-dessus.
- Écouter : La piste 1 se répétera en continu.
- Astuce : Utilisez loopAll() pour les projets de musique de fond nécessitant une lecture continue sur toutes les pistes.
Commandes de répétition et de lecture aléatoire
| Méthode | Objectif | Exemple |
|---|---|---|
| loopTrack(t) | Continuer à rejouer une piste | mp3.loopTrack(1) |
| loopFolder(f) | Rejouer toutes les pistes d'un dossier | mp3.loopFolder(1) |
| loopAll() | Rejouer tout ce qui est sur la carte | mp3.loopAll() |
| stopLoop() | Terminer le mode de répétition actuel | mp3.stopLoop() |
| shuffle() | Rendre aléatoire l'ordre de lecture | mp3.shuffle() |
Code ESP32 S3 — Lire depuis un dossier
Le code suivant montre comment lire une piste spécifique depuis un dossier numéroté sur votre carte SD, permettant une lecture organisée pour les projets avec plusieurs catégories audio comme des effets sonores, des genres musicaux, ou des packs de langues.
/*
* DIYables Mini Mp3 Player - Play from Folder
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Plays tracks from specific folders on the SD card.
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /01/001.mp3 <- playFolder(1, 1)
* /01/002.mp3 <- playFolder(1, 2)
* /02/001.mp3 <- playFolder(2, 1)
* /02/002.mp3 <- playFolder(2, 2)
*
* IMPORTANT:
* - Numbering starts from 1, NOT 0
* - Folder names must be 2-digit zero-padded (01-99)
* - Track names must be 3-digit zero-padded (001-255)
* - Format SD card as FAT32, then copy files one by one in order
* - Track order is determined by the order files were copied,
* NOT by filename. So copy them in the correct sequence.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
// Play track 1 from folder 01
Serial.println("Playing folder 01, track 001...");
mp3.playFolder(1, 1);
delay(5000);
// Play track 2 from folder 01
Serial.println("Playing folder 01, track 002...");
mp3.playFolder(1, 2);
delay(5000);
// Play track 1 from folder 02
Serial.println("Playing folder 02, track 001...");
mp3.playFolder(2, 1);
}
void loop()
{
// Nothing to do here
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Créer des dossiers : Sur votre carte SD, créez des dossiers nommés 01, 02, etc.
- Ajouter des fichiers : Placez des fichiers mp3 dans chaque dossier (001.mp3, 002.mp3, etc.).
- Téléverser le code : Chargez le croquis sur l'ESP32 S3.
- Tester la lecture : Le code lit la première piste du dossier 01.
- Astuce : Organisez les effets sonores, genres musicaux, ou langues dans des dossiers séparés pour une organisation de projet facile.
Méthodes de dossier
| Méthode | Objectif | Exemple |
|---|---|---|
| playFolder(f, t) | Sélectionner la piste t du dossier f | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Mode grand dossier (jusqu'à 3000 pistes) | mp3.playLargeFolder(1, 1500) |
| playFromMP3Folder(t) | Accéder au dossier spécial /mp3 | mp3.playFromMP3Folder(1) |
Code ESP32 S3 — Contrôle via moniteur série
Le code suivant transforme le moniteur série de l'Arduino IDE en un panneau de contrôle complet pour votre Mini Mp3 Player, vous permettant de tester chaque fonctionnalité de lecture en tapant des commandes à un seul caractère. C'est le premier croquis recommandé à exécuter après avoir câblé votre ESP32 S3, car il vous permet de vérifier toutes les fonctions avant de construire une interface physique.
/*
* DIYables Mini Mp3 Player - Serial Command Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Control the Mp3 player by typing commands in the Serial Monitor.
* Great for testing all functions without extra hardware.
*
* Commands (type in Serial Monitor, then press Enter):
* 1-9 Play track 1 to 9
* + Volume up
* - Volume down
* p Pause
* r Resume
* s Stop
* n Next track
* b Previous track (back)
* ? Show current status
*
* Wiring Table:
* Mini Mp3 RX -> GPIO17 (ESP32 S3 TX)
* Mini Mp3 TX -> GPIO18 (ESP32 S3 RX)
* Mini Mp3 VCC -> 3.3V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial (10, 11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(115200);
mp3Serial.begin(115200);
mp3.begin(mp3Serial);
delay(1000);
mp3.setVolume(20);
Serial.println("=== DIYables Mini Mp3 Player ===");
Serial.println("Commands:");
Serial.println(" 1-9 Play track number");
Serial.println(" + Volume up");
Serial.println(" - Volume down");
Serial.println(" p Pause");
Serial.println(" r Resume");
Serial.println(" s Stop");
Serial.println(" n Next track");
Serial.println(" b Previous track");
Serial.println(" ? Show status");
Serial.println("================================");
}
void loop()
{
if (Serial.available())
{
char cmd = Serial.read();
switch (cmd)
{
case '1': case '2': case '3':
case '4': case '5': case '6':
case '7': case '8': case '9':
Serial.print("Playing track ");
Serial.println(cmd - '0');
mp3.play(cmd - '0');
break;
case '+':
Serial.println("Volume up");
mp3.volumeUp();
break;
case '-':
Serial.println("Volume down");
mp3.volumeDown();
break;
case 'p':
Serial.println("Paused");
mp3.pause();
break;
case 'r':
Serial.println("Resumed");
mp3.resume();
break;
case 's':
Serial.println("Stopped");
mp3.stop();
break;
case 'n':
Serial.println("Next track");
mp3.playNext();
break;
case 'b':
Serial.println("Previous track");
mp3.playPrevious();
break;
case '?':
{
Serial.println("--- Status ---");
int16_t vol = mp3.getVolume();
Serial.print("Volume: ");
Serial.println(vol);
int16_t track = mp3.getCurrentTrack();
Serial.print("Current track: ");
Serial.println(track);
bool playing = mp3.isPlaying();
Serial.print("Playing: ");
Serial.println(playing ? "Yes" : "No");
int16_t total = mp3.getTrackCount();
Serial.print("Total tracks: ");
Serial.println(total);
Serial.println("--------------");
break;
}
default:
break;
}
}
}
Étapes rapides
- Nouveau sur l'ESP32 S3 ? Terminez d'abord notre guide ESP32 S3 - Premiers pas.
- Téléverser le code : Chargez le croquis sur votre ESP32 S3.
- Ouvrir le moniteur série : Réglez le débit en bauds sur 115200.
- Envoyer des commandes : Tapez les commandes du tableau ci-dessous.
- Contrôler la lecture : Utilisez le clavier pour tester toutes les fonctionnalités du lecteur mp3.
- Astuce : C'est parfait pour tester votre module mp3 avant de l'intégrer dans un projet plus grand.
Commandes série
| Saisie | Résultat |
|---|---|
| 1–9 | Lire cette piste |
| + / − | Volume plus / moins |
| p | Pause |
| r | Reprendre |
| s | Arrêter |
| n | Piste suivante |
| b | Piste précédente |
| ? | Afficher le statut |
Sortie du moniteur série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32S3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-01-15 09:30:00] Mp3 Player Control Menu:
[2026-01-15 09:30:00] 1-9: Play track, +/-: Volume, p: Pause, r: Resume, s: Stop, n: Next, b: Previous, ?: Status
[2026-01-15 09:30:05] Command: 1
[2026-01-15 09:30:05] Playing track 1
[2026-01-15 09:30:10] Command: +
[2026-01-15 09:30:10] Volume increased
[2026-01-15 09:30:15] Command: n
[2026-01-15 09:30:15] Next track
Préréglages d'égaliseur
Le Mini Mp3 Player offre six modes d'égaliseur intégrés pour améliorer la qualité audio selon différents genres musicaux.
Préréglages EQ disponibles :
| Constante | ID | Tonalité |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Neutre |
| DIYables_MiniMp3::EQ_POP | 1 | Pop |
| DIYables_MiniMp3::EQ_ROCK | 2 | Rock |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Jazz |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Classique |
| DIYables_MiniMp3::EQ_BASS | 5 | Boost des basses |
Exemple d'utilisation :
mp3.setEQ(DIYables_MiniMp3::EQ_POP);
Astuces :
- EQ_NORMAL fonctionne bien pour les enregistrements vocaux et les podcasts
- EQ_BASS améliore les petits haut-parleurs avec une réponse limitée dans les basses fréquences
- Essayez différents préréglages pour correspondre aux caractéristiques de votre haut-parleur
Fonctions de requête d'état
La bibliothèque fournit des fonctions pour lire l'état actuel du module Mini Mp3 Player en temps réel.
Remarques importantes :
- Chaque requête bloque l'exécution jusqu'à 100 millisecondes
- Les fonctions renvoient −1 en cas de délai dépassé ou d'erreur de communication
- Utilisez-les avec parcimonie dans les applications sensibles au temps
Fonctions d'état disponibles :
| Méthode | Renvoie | Info |
|---|---|---|
| isPlaying() | bool | Si une piste est active |
| getVolume() | int16_t | Volume (0–30) |
| getEQ() | int16_t | Préréglage EQ (0–5) |
| getTrackCount() | int16_t | Total des pistes sur la carte |
| getCurrentTrack() | int16_t | Piste en cours de lecture |
| getFolderCount() | int16_t | Nombre de dossiers |
| getTrackCountInFolder(f) | int16_t | Pistes dans le dossier f |
Exemple de code :
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);
}
Applications et idées de projets
Le traitement double cœur et le WiFi intégré de l'ESP32 S3 le rendent particulièrement adapté aux applications audio en réseau allant au-delà de la simple lecture locale.
- Lecteur audio WiFi : Construisez un lecteur audio domestique contrôlé par WiFi avec une interface Web pour la sélection de pistes à distance.
- Horloge parlante : Créez un réveil parlant avec des annonces vocales programmées à différents moments de la journée.
- Guide de musée : Concevez un guide d'exposition qui joue automatiquement des descriptions audio quand les visiteurs approchent.
- Jouet interactif : Fabriquez un jouet interactif avec des effets sonores déclenchés par des capteurs de mouvement ou de contact.
- Entraîneur de langues : Construisez un appareil d'apprentissage des langues avec des leçons organisées en dossiers pour le vocabulaire et la prononciation.
- Sonnette intelligente : Créez une sonnette avec des carillons mp3 personnalisables sélectionnables via une interface Web.
- Minuteur de méditation : Concevez un minuteur de méditation avec musique de fond et invites vocales à intervalles programmés.
- Unité de démonstration en magasin : Construisez une station de démonstration de produit avec un audio publicitaire en boucle contrôlé à distance.
Tutoriel vidéo
Regardez la vidéo pas à pas pour ce projet ESP32 S3 ci-dessous.
Relevez le défi
Ces projets s'appuient progressivement sur les compétences que vous avez développées dans ce tutoriel, faisant passer votre lecteur mp3 ESP32 S3 d'une simple démonstration à un appareil abouti et riche en fonctionnalités.
- Débutant : Ajoutez une LED qui s'allume quand la musique joue en utilisant la broche BUSY.
- Débutant : Créez un juke-box à 3 boutons qui lit la piste 1, 2, ou 3 à la demande.
- Intermédiaire : Construisez une interface Web pour contrôler la lecture via la connexion WiFi de l'ESP32 S3.
- Intermédiaire : Ajoutez un écran LCD affichant le numéro de piste actuel et le niveau de volume.
- Avancé : Créez un lecteur mp3 à commande vocale en utilisant un module microphone et l'ADC de l'ESP32 S3.
- Avancé : Construisez un système audio multi-pièces avec plusieurs cartes ESP32 S3 synchronisées via WiFi en utilisant des diffusions UDP.