ESP32 C3 Super Mini - Lecteur Mini Mp3
L'ESP32 C3 Super Mini est une petite carte de développement 3.3V parfaite 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 C3 Super Mini.
Ce que vous apprendrez :
- Qu'est-ce que le module Mini Mp3 Player et comment fonctionne-t-il
- Comment câbler le module mp3 à ESP32 C3 Super Mini (aucune résistance nécessaire)
- Comment préparer votre carte SD avec des fichiers mp3 correctement nommés
- Comment écrire du code pour la lecture, le volume, la boucle et le contrôle de dossier
- Comment lire le statut du module et contrôler la lecture via des commandes série
Matériel Requis
| 1 | × | ESP32 C3 Super Mini | |
| 1 | × | Câble USB Type-C | |
| 1 | × | Module DIYables Mini Mp3 Player | |
| 1 | × | Carte Micro SD | |
| 1 | × | Haut-parleur | |
| 1 | × | Plaque d'essai | |
| 1 | × | Fils Jumper |
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 Mini Mp3 Player
Le DIYables Mini Mp3 Player est un module décodeur mp3 YX5200-24SS qui lit des fichiers audio d'une carte micro SD via un amplificateur intégré.
Caractéristiques clés :
- Fonctionne à 3.3V–5V (parfait pour la logique 3.3V de l'ESP32 C3 Super Mini)
- Contrôlé via UART série à 115200 baud
- Amplificateur 3W intégré pour connexion directe du haut-parleur
- Supporte jusqu'à 255 pistes et 99 dossiers
- 31 niveaux de volume (0–30)
- 6 présets d'égaliseur (Normal, Pop, Rock, Jazz, Classique, Bass)
- Plusieurs modes de répétition et de lecture aléatoire
- Capacités de requête de statut pour le volume, le numéro de piste et l'état de lecture
- Aucun décodeur externe ou amplificateur IC requis
- Convivial pour les débutants avec des commandes série simples
Brochage
Le module Mini Mp3 Player a 11 broches pour l'alimentation, la communication, la sortie audio et le contrôle.
- VCC : Alimentation électrique (3.2V–5.0V)
- GND : Connexion de terre
- RX : Réception UART (connecter à la broche TX de l'ESP32)
- TX : Transmission UART (connecter à la broche RX de l'ESP32)
- SPK_1 : Terminal positif du haut-parleur (amplificateur intégré 3W)
- SPK_2 : Terminal négatif du haut-parleur
- DAC_R : Sortie audio du canal droit au niveau de ligne
- DAC_L : Sortie audio du canal gauche au niveau de ligne
- BUSY : Broche de statut (BAS pendant la lecture, HAUT au repos)
- IO_1 : Entrée bouton (appui court = précédent, appui long = baisse volume)
- IO_2 : Entrée bouton (appui court = suivant, appui long = augmente volume)
Schéma de Câblage
Voici comment connecter le Mini Mp3 Player à votre ESP32 C3 Super Mini en utilisant le Serial1 matériel.
- Important : L'ESP32 C3 Super Mini utilise la logique 3.3V, correspondant parfaitement au module—aucune résistance nécessaire pour les lignes TX/RX
- Broches Serial1 : TX1 est GPIO5 (D5), RX1 est GPIO4 (D4)
- Options d'alimentation : Utilisez la broche 3.3V ou 5V (VBUS) selon vos besoins de haut-parleur
| Lecteur Mini Mp3 | ESP32 C3 Super Mini | Remarques |
|---|---|---|
| VCC | 3.3V | Le module accepte également 5V du VBUS si nécessaire |
| GND | GND | Terre commune |
| RX | TX1 (D5) | Connexion directe — aucune résistance nécessaire |
| TX | RX1 (D4) | Connexion directe — logique 3.3V compatible |
| SPK_1 | Haut-parleur + | Sortie amplifiée |
| SPK_2 | Haut-parleur − | 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'à 32GB recommandé
Nomenclature basique (répertoire racine) :
/001.mp3
/002.mp3
/003.mp3
Nomenclature basée sur les dossiers (lecture organisée) :
/01/001.mp3
/01/002.mp3
/02/001.mp3
Règles de nomenclature critiques :
- La numérotation des pistes commence à 1 (pas 0)
- Fichiers racine : noms zéro-complétés à 3 chiffres (001–255)
- Noms de dossiers : zéro-complétés à 2 chiffres (01–99)
- Fichiers dans les dossiers : noms zéro-complétés à 3 chiffres (001–255)
- L'ordre de copie importe : Le module détermine l'ordre de lecture à partir de la séquence des fichiers copiés, pas de la nomenclature alphabétique
- Meilleure pratique : Formatez d'abord la carte, puis copiez les fichiers un par un dans votre 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 C3 Super Mini.
- Connectez votre ESP32 C3 Super Mini à votre ordinateur via câble USB-C
- Ouvrez l'Arduino IDE
- Sélectionnez ESP32 C3 Super Mini comme votre carte
- Choisissez le port COM correct
- Cliquez sur l'icône Bibliothèques dans la barre latérale gauche
- Recherchez "DIYables_MiniMp3"
- Trouvez la bibliothèque par DIYables
- Cliquez sur Installer
Avantages de la bibliothèque :
- Zéro dépendance externe
- Fonctions de commandes simples pour toutes les fonctionnalités de lecture
- Fonctionne parfaitement avec la série matérielle ESP32
Code ESP32 C3 Super Mini — Configuration Basique
Ce code montre le modèle basique pour contrôler le Mini Mp3 Player avec ESP32 C3 Super Mini en utilisant le Serial1 matériel.
Ce que fait ce code :
- Initialise Serial1 pour la communication du module mp3 à 115200 baud
- 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(115200); // 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 la série matérielle ?
- L'ESP32 C3 Super Mini a du matériel UART dédié
- Plus fiable que la série logicielle
- Aucun problème de timing à 115200 baud
- Laisse la série USB libre pour le débogage
Code ESP32 C3 Super Mini — Lire une Piste Simple
/*
* 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 -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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 ESP32 C3 Mini ? Complétez d'abord notre tutoriel ESP32 C3 Super Mini - Premiers pas pour configurer votre environnement de développement.
- Préparez la carte SD : Formatez en FAT32 et copiez les fichiers mp3 avec les noms 001.mp3, 002.mp3, etc.
- Insérez la carte SD : Placez la carte micro SD dans l'emplacement du module
- Connectez le câblage : Suivez le schéma de câblage ci-dessus (VCC, GND, TX1, RX1, haut-parleur)
- Connectez le haut-parleur : Attachez votre haut-parleur aux terminaux SPK_1 et SPK_2
- Ouvrez Arduino IDE : Lancez l'IDE sur votre ordinateur
- Sélectionnez la carte : Choisissez ESP32 C3 Super Mini dans le menu des cartes
- Sélectionnez le port : Choisissez le port COM correct pour votre carte
- Téléchargez le code : Copiez le code ci-dessus et téléchargez-le sur votre ESP32 C3 Super Mini
- Écoutez : La piste 001.mp3 doit être lue via le haut-parleur
- Pro Tip : Si vous n'entendez aucun son, vérifiez le format de la carte SD et la nomenclature des fichiers—le module est très sensible aux conventions de nomenclature
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 C3 Super Mini — Lire 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 Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Préparez la carte SD : Assurez-vous que vous avez au moins 3 fichiers mp3 nommés 001.mp3, 002.mp3, 003.mp3
- Câblez le module : Utilisez le même câblage de l'exemple précédent
- Téléchargez le code : Copiez et téléchargez l'esquisse ci-dessus
- Écoutez : Les pistes tourneront tous les 5 secondes automatiquement
- Regardez le série : Ouvrez le Moniteur Série à 115200 baud pour voir les changements de pistes
- Pro Tip : Ajustez la valeur delay(5000) pour modifier combien de temps chaque piste est lue avant d'avancer
Sortie du Moniteur Série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Playing track: 1
Playing track: 2
Playing track: 3
Playing track: 1
Playing track: 2
Playing track: 3
Code ESP32 C3 Super Mini — Contrôle du 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 2 to volume up, pin 3 to volume down.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Ajoutez des boutons : Câblez deux boutons à GPIO6 et GPIO7 (plus GND)
- Téléchargez le code : Copiez l'esquisse ci-dessus dans Arduino IDE et téléchargez
- Testez les boutons : Appuyez sur les boutons pendant la lecture de musique pour ajuster le volume
- Regardez le série : Le Moniteur Série affiche le niveau de volume actuel
- Pro Tip : La plage de volume est 0–30, avec 15 étant un bon point de départ pour la plupart des haut-parleurs
Commandes de Volume
| Méthode | Objectif | Exemple |
|---|---|---|
| setVolume(v) | Accéder à un niveau de volume spécifique | mp3.setVolume(20) |
| volumeUp() | Augmenter d'1 étape | mp3.volumeUp() |
| volumeDown() | Diminuer d'1 étape | 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 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Volume: 25
Volume: 26
Volume: 25
Volume: 24
Volume: 23
Code ESP32 C3 Super Mini — Boutons 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 Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Câblez les boutons : Connectez le bouton SUIVANT à GPIO6 et le bouton PRÉCÉDENT à GPIO7
- Connectez la terre : Câblez les autres terminaux des boutons à GND
- Téléchargez l'esquisse : Chargez le code ci-dessus sur votre ESP32 C3 Super Mini
- Testez la navigation : Appuyez sur les boutons pour sauter en avant ou en arrière à travers les pistes
- Regardez la sortie : Le Moniteur Série affiche le numéro de piste actuel
- Pro Tip : Utilisez des résistances de pull-up (10kΩ) pour un fonctionnement plus fiable des boutons dans les environnements bruyants
Sortie du Moniteur Série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Current track: 1
Current track: 2
Current track: 3
Current track: 2
Current track: 1
Code ESP32 C3 Super Mini — Basculer Pause/Lecture
/*
* 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 -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Câblez le bouton : Connectez le bouton pause/lecture à GPIO6 et GND
- Téléchargez le code : Chargez l'esquisse sur votre carte
- Démarrez la lecture : La musique commence automatiquement
- Basculez la pause : Appuyez sur le bouton pour mettre en pause, appuyez à nouveau pour reprendre
- Vérifiez le statut : Le Moniteur Série affiche l'état de la lecture
- Pro Tip : La broche BUSY sur le module peut également indiquer l'état de lecture/pause pour les retours visuels avec une LED
Sortie du Moniteur Série
8
Serial.println("Hello World!");
Message (Enter to send message to 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Playing track 1
Music paused
Music resumed
Music paused
Music resumed
Code ESP32 C3 Super Mini — 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 Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Téléchargez l'esquisse : Chargez le code ci-dessus
- Écoutez : La piste 1 se répètera continuellement
- Pro Tip : Utilisez loopAll() pour les projets de musique de fond qui ont besoin d'une lecture continue
Commandes de Répétition et de Lecture Aléatoire
| Méthode | Objectif | Exemple |
|---|---|---|
| loopTrack(t) | Garder la relecture d'une seule piste | mp3.loopTrack(1) |
| loopFolder(f) | Relire toutes les pistes dans un dossier | mp3.loopFolder(1) |
| loopAll() | Relire tout sur la carte | mp3.loopAll() |
| stopLoop() | Terminer le mode de répétition actuel | mp3.stopLoop() |
| shuffle() | Randomiser l'ordre de lecture | mp3.shuffle() |
Code ESP32 C3 Super Mini — Lire depuis un 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 Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Créez des dossiers : Sur votre carte SD, créez des dossiers nommés 01, 02, etc.
- Ajoutez des fichiers : Placez les fichiers mp3 dans chaque dossier (001.mp3, 002.mp3, etc.)
- Téléchargez le code : Chargez l'esquisse sur ESP32 C3 Super Mini
- Testez la lecture : Le code lit la première piste du dossier 01
- Pro Tip : Organisez les effets sonores, les genres musicaux ou les langues dans des dossiers séparés pour une organisation facile des projets
Méthodes de Dossier
| Méthode | Objectif | Exemple |
|---|---|---|
| playFolder(f, t) | Sélectionner la piste t depuis le 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 C3 Super Mini — Contrôle du 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 Table:
* Mini Mp3 RX -> Arduino Pin 11
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> Vbus
* 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
- Téléchargez le code : Chargez l'esquisse sur votre ESP32 C3 Super Mini
- Ouvrez le Moniteur Série : Réglez la vitesse en bauds à 115200
- Envoyez des commandes : Tapez les commandes du tableau ci-dessous
- Contrôlez la lecture : Utilisez le clavier pour tester toutes les fonctionnalités du lecteur mp3
- Pro Tip : C'est parfait pour tester votre module mp3 avant de l'intégrer dans un projet plus large
Commandes Série
| Entrée | Résultat |
|---|---|
| 1–9 | Jouer cette piste |
| + / − | Volume plus / moins |
| p | Pause |
| r | Lecture |
| s | Arrêt |
| 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 'ESP32C3 Dev Module' on 'COM15')
New Line
9600 baud
Mp3 Player Control Menu:
1-9: Play track, +/-: Volume, p: Pause, r: Resume, s: Stop, n: Next, b: Previous, ?: Status
Command: 1
Playing track 1
Command: +
Volume increased
Command: n
Next track
Présets d'Égaliseur
Le Mini Mp3 Player offre six modes d'égaliseur intégrés pour améliorer la qualité audio pour différents genres musicaux.
Présets d'EQ disponibles :
| Constant | ID | Ton |
|---|---|---|
| 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 | Augmentation des basses |
Exemple d'utilisation :
mp3.setEQ(DIYables_MiniMp3::EQ_POP);
Conseils :
- EQ_NORMAL fonctionne bien pour les enregistrements vocaux et les podcasts
- EQ_BASS améliore les petits haut-parleurs avec une réponse en basses fréquences limitée
- Essayez différents présets pour correspondre à vos caractéristiques de haut-parleur
Fonctions de Requête de Statut
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 retournent −1 sur délai d'attente ou erreur de communication
- Utilisez-les avec parcimonie dans les applications sensibles au temps
Fonctions de statut disponibles :
| Méthode | Retour | Info |
|---|---|---|
| isPlaying() | bool | Si une piste est active |
| getVolume() | int16_t | Volume (0–30) |
| getEQ() | int16_t | Préset d'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 |
Code d'exemple :
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);
}
Application et Idées de Projets
Voici quelques façons créatives d'utiliser l'ESP32 C3 Super Mini avec le module Mini Mp3 Player dans vos projets.
- Construire un lecteur audio domestique contrôlé par WiFi avec interface web
- Créer un réveil parlant avec des annonces programmées
- Concevoir un guide d'exposition de musée avec descriptions audio automatiques
- Créer un jouet interactif avec des effets sonores déclenchés par des capteurs
- Construire un appareil d'apprentissage des langues avec des leçons organisées par dossier
- Créer une sonnette avec des carillons mp3 personnalisables
- Concevoir un minuteur de méditation avec musique de fond et invites vocales
- Construire une démo de produit de détail avec audio publicitaire en boucle
Tutoriel Vidéo
Regardez la vidéo ci-dessous pour une présentation visuelle de ce projet.
Défi Yourself
Testez vos compétences avec ces modifications du lecteur mp3 ESP32 C3 Super Mini progressivement difficiles.
- Facile : Ajoutez une LED qui s'illumine quand la musique est lue en utilisant la broche BUSY
- Facile : Créez un jukebox à 3 boutons (jouer piste 1, 2 ou 3)
- Moyen : Construire une interface web pour contrôler la lecture sur WiFi
- Moyen : Ajoutez un affichage LCD montrant le nom de la piste actuelle et le volume
- Avancé : Créez un lecteur mp3 activé par la voix en utilisant un module microphone
- Avancé : Construire un système audio multi-pièces avec plusieurs cartes ESP32 synchronisées sur WiFi