ESP32 C3 Super Mini - Lecteur MP3
Apprenez à construire un petit lecteur MP3 avec l'ESP32 C3 Super Mini, un module lecteur MP3 série, une carte Micro SD et un haut-parleur. Vos chansons sont stockées sur la carte Micro SD, et l'ESP32 C3 Super Mini envoie de simples commandes série pour indiquer au module ce qu'il doit lire. Ce projet de lecteur MP3 ESP32 C3 Super Mini adapté aux débutants ne nécessite que quelques fils et un court sketch.
Dans ce tutoriel, vous apprendrez :
- Comment fonctionne un module lecteur MP3 série
- Comment câbler le module lecteur MP3 et le haut-parleur à l'ESP32 C3 Super Mini
- Comment programmer l'ESP32 C3 Super Mini pour lire une chanson depuis la carte Micro SD
- Comment ajouter des boutons lecture, pause, suivant et précédent
- Comment étendre le projet avec un contrôle du volume
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 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 Lecteur MP3 Série et du Haut-parleur
Le module lecteur MP3 série est un petit lecteur audio qui lit les fichiers MP3 d'une carte Micro SD et les transforme en son.
Caractéristiques Principales :
- Lit les fichiers MP3 stockés sur une carte Micro SD
- Contrôlé par de simples commandes série (UART)
- Possède un amplificateur intégré et une sortie Aux 3,5 mm
- Peut lire, mettre en pause, passer, répéter et changer le volume
- Fonctionne bien avec l'ESP32 C3 Super Mini
Spécifications Techniques :
- Alimentation : 5V
- Vitesse série : 9600 bauds, 8 bits de données, pas de parité, 1 bit de stop
- Niveau logique sur RX : compatible 3,3V, mais une résistance en série est recommandée
- Stockage : carte Micro SD (FAT16 / FAT32)
- Sortie audio : prise jack femelle Aux 3,5 mm
Brochage du Module Lecteur MP3 Série
Le module possède trois interfaces.
- L'interface vers l'ESP32 C3 Super Mini comprend 4 broches :
- Broche RX : broche de données, connectez-la à une broche TX de l'ESP32 C3 Super Mini
- Broche TX : broche de données, connectez-la à une broche RX de l'ESP32 C3 Super Mini
- Broche VCC : broche d'alimentation, connectez-la au 5V
- Broche GND : broche d'alimentation, connectez-la à GND (0V)
- L'interface vers le haut-parleur est une prise jack femelle de sortie Aux 3,5 mm.
- L'interface vers la carte Micro SD est un emplacement pour carte Micro SD situé à l'arrière du module.
Brochage du Haut-parleur
Un haut-parleur possède généralement deux interfaces.
- Interface du signal audio : un connecteur mâle Aux 3,5 mm qui se branche sur le module lecteur MP3
- Interface d'alimentation : elle peut être USB, un adaptateur secteur 5V ou toute autre source d'alimentation
Comment Ça Fonctionne
Obtenir du son avec le lecteur MP3 ESP32 C3 Super Mini ne demande que quelques étapes.
- Préparez la carte : Copiez les chansons ou les enregistrements audio que vous voulez lire sur une carte Micro SD.
- Insérez la carte : Enfoncez la carte Micro SD dans l'emplacement du module lecteur MP3.
- Câblez le tout : Connectez le module lecteur MP3 à l'ESP32 C3 Super Mini et branchez le haut-parleur sur le module.
- Alimentez le haut-parleur : Assurez-vous que le haut-parleur dispose de sa propre source d'alimentation.
Chaque fichier MP3 sur la carte Micro SD reçoit un identifiant, à partir de 0. L'ESP32 C3 Super Mini peut alors demander au module de faire les actions suivantes :
- Lecture : Lancer la lecture de la chanson sélectionnée.
- Pause : Mettre la chanson en pause.
- Suivant : Passer à la chanson suivante.
- Précédent : Revenir à la chanson précédente.
- Changer le Volume : Régler le niveau sonore de la musique.
Lorsque le module lecteur MP3 reçoit une commande, il lit le fichier MP3 depuis la carte Micro SD, le transforme en signal audio et envoie ce signal au haut-parleur via la connexion Aux 3,5 mm.
※ Note:
L'ESP32 C3 Super Mini utilise GPIO20 et GPIO21 pour le Moniteur Série. Ces deux broches doivent rester libres. C'est pourquoi ce tutoriel utilise un second port série matériel sur GPIO6 et GPIO7 pour le module lecteur MP3.
Schéma de Câblage
Câblez le module lecteur MP3 à l'ESP32 C3 Super Mini comme indiqué ci-dessous.
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
- Remarque : TX va vers RX et RX va vers TX. Inverser ces deux fils est l'erreur la plus fréquente.
- Remarque : Alimentez le module en 5V, pas en 3,3V. Il a besoin du 5V pour piloter le haut-parleur.
- Remarque : Ne connectez aucune broche du module à GPIO20 ou GPIO21 — elles sont réservées au Moniteur Série.
| Broche du Module Lecteur MP3 Série | Broche de l'ESP32 C3 Super Mini |
|---|---|
| VCC | 5V |
| GND | GND |
| RX | GPIO6 (TX de l'ESP32) |
| TX | GPIO7 (RX de l'ESP32) |
※ Note:
Le module lecteur MP3 série a besoin d'une alimentation 5V, mais sa broche RX attend une logique 3,3V. L'ESP32 C3 Super Mini est une carte 3,3V, donc son niveau TX est déjà sans danger. Pour protéger le module et garder un signal propre, il est recommandé de placer une résistance de 1kΩ en série sur la ligne RX, entre la broche GPIO6 de l'ESP32 C3 Super Mini et la broche RX du module.
Code ESP32 C3 Super Mini - Lire de la Musique
Ce premier sketch lit la première chanson stockée sur la carte Micro SD.
Ce que Fait ce Code :
- Démarre le Moniteur Série à 115200 bauds
- Démarre un second port série matériel sur GPIO6 (TX) et GPIO7 (RX) à 9600 bauds
- Indique au module d'utiliser la carte Micro SD comme périphérique de stockage
- Envoie une commande Lecture pour que la première chanson démarre immédiatement
- Construit chaque commande sous forme d'une trame de 8 octets que le module comprend
/*
* Ce code ESP32 C3 Super Mini a été développé par newbiely.fr
* Ce code ESP32 C3 Super Mini est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-c3/esp32-c3-super-mini-mp3-player
*/
#include <HardwareSerial.h>
#define CMD_PLAY_NEXT 0x01
#define CMD_PLAY_PREV 0x02
#define CMD_PLAY_W_INDEX 0x03
#define CMD_SET_VOLUME 0x06
#define CMD_SEL_DEV 0x09
#define CMD_PLAY_W_VOL 0x22
#define CMD_PLAY 0x0D
#define CMD_PAUSE 0x0E
#define CMD_SINGLE_CYCLE 0x19
#define DEV_TF 0x02
#define SINGLE_CYCLE_ON 0x00
#define SINGLE_CYCLE_OFF 0x01
#define RX1PIN 7 // The ESP32 C3 SuperMini pin connected to the TX of the Serial MP3 Player module
#define TX1PIN 6 // The ESP32 C3 SuperMini pin connected to the RX of the Serial MP3 Player module
HardwareSerial mp3Serial(1); // use UART1 of ESP32 C3 SuperMini, UART0 is used by Serial Monitor
void setup() {
Serial.begin(115200);
mp3Serial.begin(9600, SERIAL_8N1, RX1PIN, TX1PIN); // the MP3 module always uses 9600 baud
delay(500); // wait chip initialization is complete
mp3_command(CMD_SEL_DEV, DEV_TF); // select the TF card
delay(200); // wait for 200ms
mp3_command(CMD_PLAY, 0x0000); // Play mp3
//mp3_command(CMD_PAUSE, 0x0000); // Pause mp3
//mp3_command(CMD_PLAY_NEXT, 0x0000); // Play next mp3
//mp3_command(CMD_PLAY_PREV, 0x0000); // Play previous mp3
//mp3_command(CMD_SET_VOLUME, 30); // Change volume to 30
}
void loop() {
}
void mp3_command(int8_t command, int16_t dat) {
int8_t frame[8] = { 0 };
frame[0] = 0x7e; // starting byte
frame[1] = 0xff; // version
frame[2] = 0x06; // The number of bytes of the command without starting byte and ending byte
frame[3] = command; //
frame[4] = 0x00; // 0x00 = no feedback, 0x01 = feedback
frame[5] = (int8_t)(dat >> 8); // data high byte
frame[6] = (int8_t)(dat); // data low byte
frame[7] = 0xef; // ending byte
for (uint8_t i = 0; i < 8; i++) {
mp3Serial.write(frame[i]);
}
}
Étapes Rapides
- Nouveau avec l'ESP32 C3 Super Mini ? Suivez d'abord notre tutoriel ESP32 C3 Super Mini - Premiers pas pour configurer votre environnement de développement.
- Préparez la carte : Copiez quelques fichiers MP3 sur la carte Micro SD et insérez-la dans le module.
- Câblez les composants : Suivez le schéma de câblage ci-dessus et branchez le haut-parleur sur la prise Aux du module.
- Connectez la carte : Branchez l'ESP32 C3 Super Mini à votre ordinateur avec le câble USB Type-C.
- Sélectionnez la carte : Assurez-vous que l'ESP32 C3 Super Mini est sélectionné dans Outils > Carte.
- Sélectionnez le port : Choisissez le bon port COM dans Outils > Port.
- Téléversez le code : Copiez le code ci-dessus dans Arduino IDE et cliquez sur le bouton Téléverser.
- Ouvrez le Moniteur Série : Réglez le débit en bauds sur 115200 pour voir les messages.
- Profitez de la musique : La première chanson de la carte commence à jouer dans le haut-parleur.
- Astuce de Pro : Si vous n'entendez rien, inversez d'abord les fils RX et TX — des lignes de données croisées en sont la cause habituelle.
Code ESP32 C3 Super Mini - Lire de la Musique avec des Boutons de Contrôle
Ce second sketch est une amélioration du premier. Il ajoute quatre boutons pour que vous puissiez contrôler le lecteur MP3 ESP32 C3 Super Mini à la main.
Ce que Fait ce Code :
- Lit quatre boutons avec la bibliothèque ezButton, avec un anti-rebond de 50 ms
- Envoie une commande Lecture lorsque le bouton sur GPIO2 est appuyé
- Envoie une commande Pause lorsque le bouton sur GPIO3 est appuyé
- Envoie une commande Suivant lorsque le bouton sur GPIO4 est appuyé
- Envoie une commande Précédent lorsque le bouton sur GPIO5 est appuyé
- Affiche ce qu'il fait sur le Moniteur Série
/*
* Ce code ESP32 C3 Super Mini a été développé par newbiely.fr
* Ce code ESP32 C3 Super Mini est mis à disposition du public sans aucune restriction.
* Pour des instructions complètes et des schémas de câblage, veuillez visiter:
* https://newbiely.fr/tutorials/esp32-c3/esp32-c3-super-mini-mp3-player
*/
#include <HardwareSerial.h>
#include <ezButton.h>
#define CMD_PLAY_NEXT 0x01
#define CMD_PLAY_PREV 0x02
#define CMD_PLAY_W_INDEX 0x03
#define CMD_SET_VOLUME 0x06
#define CMD_SEL_DEV 0x09
#define CMD_PLAY_W_VOL 0x22
#define CMD_PLAY 0x0D
#define CMD_PAUSE 0x0E
#define CMD_SINGLE_CYCLE 0x19
#define DEV_TF 0x02
#define SINGLE_CYCLE_ON 0x00
#define SINGLE_CYCLE_OFF 0x01
#define RX1PIN 7 // The ESP32 C3 SuperMini pin connected to the TX of the Serial MP3 Player module
#define TX1PIN 6 // The ESP32 C3 SuperMini pin connected to the RX of the Serial MP3 Player module
HardwareSerial mp3Serial(1); // use UART1 of ESP32 C3 SuperMini, UART0 is used by Serial Monitor
ezButton button_play(2); // create ezButton object for pin GPIO2
ezButton button_pause(3); // create ezButton object for pin GPIO3
ezButton button_next(4); // create ezButton object for pin GPIO4
ezButton button_prev(5); // create ezButton object for pin GPIO5
void setup() {
Serial.begin(115200);
mp3Serial.begin(9600, SERIAL_8N1, RX1PIN, TX1PIN); // the MP3 module always uses 9600 baud
delay(500); // wait chip initialization is complete
mp3_command(CMD_SEL_DEV, DEV_TF); // select the TF card
delay(200); // wait for 200ms
button_play.setDebounceTime(50); // set debounce time to 50 milliseconds
button_pause.setDebounceTime(50); // set debounce time to 50 milliseconds
button_next.setDebounceTime(50); // set debounce time to 50 milliseconds
button_prev.setDebounceTime(50); // set debounce time to 50 milliseconds
}
void loop() {
button_play.loop(); // MUST call the loop() function first
button_pause.loop(); // MUST call the loop() function first
button_next.loop(); // MUST call the loop() function first
button_prev.loop(); // MUST call the loop() function first
if (button_play.isPressed()) {
Serial.println("Play mp3");
mp3_command(CMD_PLAY, 0x0000);
}
if (button_pause.isPressed()) {
Serial.println("Pause mp3");
mp3_command(CMD_PAUSE, 0x0000);
}
if (button_next.isPressed()) {
Serial.println("Play next mp3");
mp3_command(CMD_PLAY_NEXT, 0x0000);
}
if (button_prev.isPressed()) {
Serial.println("Play previous mp3");
mp3_command(CMD_PLAY_PREV, 0x0000);
}
}
void mp3_command(int8_t command, int16_t dat) {
int8_t frame[8] = { 0 };
frame[0] = 0x7e; // starting byte
frame[1] = 0xff; // version
frame[2] = 0x06; // The number of bytes of the command without starting byte and ending byte
frame[3] = command; //
frame[4] = 0x00; // 0x00 = no feedback, 0x01 = feedback
frame[5] = (int8_t)(dat >> 8); // data high byte
frame[6] = (int8_t)(dat); // data low byte
frame[7] = 0xef; // ending byte
for (uint8_t i = 0; i < 8; i++) {
mp3Serial.write(frame[i]);
}
}
Le schéma de câblage pour le code ci-dessus :
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
| Bouton | Broche de l'ESP32 C3 Super Mini |
|---|---|
| Bouton Lecture | GPIO2 |
| Bouton Pause | GPIO3 |
| Bouton Suivant | GPIO4 |
| Bouton Précédent | GPIO5 |
| Autre côté de chaque bouton | GND |
- Remarque : Chaque bouton se connecte entre sa broche GPIO et GND. La bibliothèque ezButton active la résistance de pull-up interne pour vous.
- Remarque : Le module MP3 utilise toujours GPIO6 et GPIO7, donc ne réutilisez pas ces broches pour les boutons.
Sortie du Moniteur Série
Appuyez sur les boutons et vous verrez des messages comme ceux-ci à 115200 bauds.
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
[2026-04-15 09:12:03] Play mp3
[2026-04-15 09:12:19] Pause mp3
[2026-04-15 09:12:27] Play mp3
[2026-04-15 09:13:41] Play next mp3
[2026-04-15 09:14:58] Play previous mp3
※ Note:
Il se peut que vous ne voyiez PAS la première ligne sur le Moniteur Série si le téléversement se termine avant que vous n'ouvriez le Moniteur Série. Appuyez simplement à nouveau sur un bouton.
Vous pouvez maintenant étendre le lecteur MP3 ESP32 C3 Super Mini avec d'autres fonctionnalités, par exemple :
- Bouton de volume : Ajoutez un potentiomètre pour contrôler le volume, consultez le tutoriel ESP32 C3 Super Mini - Potentiomètre
- Télécommande : Ajoutez une télécommande IR pour pouvoir changer de chanson depuis l'autre bout de la pièce
- Lecteur RFID : Ajoutez un lecteur RFID et des cartes pour réaliser un lecteur MP3 RFID, consultez le tutoriel ESP32 C3 Super Mini - RFID
Applications et Idées de Projets
Voici quelques projets amusants que vous pouvez construire avec un lecteur MP3 ESP32 C3 Super Mini.
- Boîte à histoires pour enfants : Lire une histoire du soir lorsqu'on appuie sur un gros bouton.
- Sonnette : Jouer une mélodie personnalisée ou un message d'accueil enregistré lorsque quelqu'un sonne.
- Guide de musée : Lire le bon extrait audio pour chaque étiquette RFID.
- Réveil : Se réveiller avec sa propre musique au lieu d'un bip.
- Robot parlant : Lire des répliques vocales enregistrées pendant que votre robot se déplace.
- Annonceur de magasin : Lire un message de bienvenue lorsqu'un capteur de mouvement détecte un client.
Mettez-vous au Défi
Essayez ces petites améliorations pour en apprendre davantage.
- Facile : Modifiez le code pour commencer à lire la chanson numéro 3 au lieu de la chanson numéro 1.
- Facile : Réglez le volume dans setup() avec la commande CMD_SET_VOLUME.
- Moyen : Ajoutez un cinquième bouton qui active et désactive la répétition d'une seule chanson.
- Moyen : Utilisez un potentiomètre sur GPIO4 pour régler le volume en temps réel.
- Avancé : Ajoutez un écran OLED qui affiche le numéro de la piste en cours.
- Avancé : Contrôlez le lecteur MP3 via WiFi depuis une page web hébergée sur l'ESP32 C3 Super Mini.