Arduino Nano ESP32 - Module lecteur Mini Mp3
L'Arduino Nano ESP32 est une carte puissante à 3,3V avec WiFi et Bluetooth intégrés. Dans ce tutoriel, nous allons l'associer au module DIYables Mini Mp3 Player pour construire un lecteur mp3 entièrement contrôlable. Voici ce que nous allons aborder :
- Connexion du module au Nano ESP32 — aucune résistance nécessaire grâce aux niveaux logiques 3,3V.
- Préparation de la carte SD avec des fichiers mp3 correctement nommés.
- Écriture de code pour lire, mettre en pause, reprendre, arrêter et passer les pistes.
- Contrôle du volume via des boutons et des commandes série.
- Configuration de la boucle de pistes, lecture aléatoire complète et lecture basée sur les dossiers.
- Lecture de l'état du module (piste actuelle, volume, état de lecture).
Matériel nécessaire
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.
Remarque : Aucune résistance de 1K n'est nécessaire — le Nano ESP32 utilise la logique 3,3V, qui correspond nativement au module.
Présentation du module Mini Mp3 Player
Le DIYables Mini Mp3 Player est un module décodeur mp3 autonome alimenté par la puce YX5200-24SS. Insérez une carte micro SD avec des fichiers mp3, connectez un petit haut-parleur et envoyez des commandes série pour contrôler la lecture.
Le module accepte des commandes UART à 9600 bauds et fournit les fonctionnalités suivantes :
- Contrôle de lecture complet : lecture, pause, reprise, arrêt, suivant, précédent
- 31 niveaux de volume (0 à 30)
- 6 préréglages d'égaliseur (Normal, Pop, Rock, Jazz, Classic, Bass)
- Modes de répétition : boucle de piste unique, boucle de dossier, boucle de tout, lecture aléatoire
- Lecture organisée par dossiers pour l'audio catégorisé
- Insertion de publicité (interrompre et reprendre)
- Requêtes de statut en temps réel
Brochage
| Broche | Fonction |
|---|---|
| VCC | Alimentation de 3,2V à 5,0V |
| GND | Masse |
| RX | Entrée UART (connecter à TX de la carte) |
| TX | Sortie UART (connecter à RX de la carte) |
| SPK_1 | Haut-parleur + (amplificateur intégré 3W) |
| SPK_2 | Haut-parleur − |
| DAC_R | Sortie ligne droite |
| DAC_L | Sortie ligne gauche |
| BUSY | LOW = en lecture, HIGH = inactif |
| IO_1 | Appui court → précédent, appui long → volume bas |
| IO_2 | Appui court → suivant, appui long → volume haut |
Schéma de câblage
Le Nano ESP32 fonctionne à une logique 3,3V — la même tension que le Mini Mp3 Player utilise en interne. Cela signifie que vous pouvez connecter TX/RX directement sans aucune résistance.
Nous utiliserons Serial1 sur le Nano ESP32 pour la communication avec le module, en gardant le Serial par défaut libre pour le Moniteur Série.
| Mini Mp3 Player | Arduino Nano ESP32 | Remarques |
|---|---|---|
| VCC | 3.3V | Le module accepte aussi 5V depuis VBUS si nécessaire |
| GND | GND | |
| RX | TX1 (D5) | Connexion directe — aucune résistance nécessaire |
| TX | RX1 (D4) | Connexion directe |
| SPK_1 | Haut-parleur + | |
| SPK_2 | Haut-parleur − |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Configuration de la carte SD
Préparez la carte micro SD avant de l'insérer dans le module :
- Formatez en FAT16 ou FAT32.
- Copiez les fichiers mp3 à la racine avec des noms complétés par des zéros :
/001.mp3
/002.mp3
/003.mp3
Pour la lecture par dossiers :
/01/001.mp3
/01/002.mp3
/02/001.mp3
Rappel :
- La numérotation des pistes commence à 1 (pas 0).
- Le module détermine l'ordre des pistes à partir de la séquence de copie, pas des noms de fichiers. Formatez d'abord la carte, puis copiez les fichiers individuellement dans l'ordre.
- Noms de dossiers : 2 chiffres, complétés par des zéros (01–99). Noms de fichiers à l'intérieur : 3 chiffres, complétés par des zéros (001–255).
Installation de la bibliothèque
- Connectez le Nano ESP32 à votre ordinateur via USB-C.
- Ouvrez l'Arduino IDE, sélectionnez Arduino Nano ESP32 comme votre carte, et choisissez le port correct.
- Allez dans le panneau Bibliothèques sur la gauche.
- Recherchez "DIYables_MiniMp3" et installez la bibliothèque par DIYables.
- Cliquez sur Installer.
La bibliothèque n'a aucune dépendance externe.
Code Nano ESP32 — Modèle de base
Puisque le Nano ESP32 a des ports série matériels, nous utilisons Serial1 au lieu de SoftwareSerial :
#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
}
Aucune bibliothèque SoftwareSerial nécessaire ! Le port série matériel est plus fiable, surtout au faible débit de 9600 bauds que ce module utilise.
Code Nano ESP32 — Lire une seule 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 Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* 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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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
}
Comment tester
- Chargez la carte SD avec des fichiers mp3 et insérez-la dans le module.
- Câblez le module au Nano ESP32 comme indiqué ci-dessus (sans résistance !).
- Connectez la carte via USB-C, sélectionnez Arduino Nano ESP32, et téléversez.
Vous devriez entendre la piste 001.mp3 via le haut-parleur connecté.
Commandes de lecture
| Méthode | Objectif | Exemple |
|---|---|---|
| play(trackNum) | Démarrer une piste spécifique | mp3.play(1) |
| playNext() | Passer à 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 Nano ESP32 — 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 D11
* Mini Mp3 TX -> Arduino Pin D10
* 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(D10, D11); // 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(9600);
mp3Serial.begin(9600);
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();
}
}
Comment tester
- Assurez-vous que la carte SD a au moins 3 pistes. Téléversez, et les pistes vont se succéder toutes les 5 secondes.
Code Nano ESP32 — 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 D2 to volume up, pin D3 to volume down.
*
* Wiring Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button UP -> Pin D2 (other leg to GND)
* Button DOWN -> Pin D3 (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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_VOL_UP = D2;
const int BUTTON_VOL_DOWN = D3;
int volume = 15; // Start at half volume
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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
}
}
Comment tester
- Câblez deux boutons, téléversez le sketch, et appuyez sur les boutons pendant la lecture de musique.
Commandes de volume
| Méthode | Objectif | Exemple |
|---|---|---|
| setVolume(v) | Passer à un niveau de volume spécifique | mp3.setVolume(20) |
| volumeUp() | Augmenter d'un pas | mp3.volumeUp() |
| volumeDown() | Diminuer d'un pas | mp3.volumeDown() |
| getVolume() | Interroger le niveau actuel | mp3.getVolume() |
Code Nano ESP32 — 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 D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button NEXT -> Pin D2 (other leg to GND)
* Button PREV -> Pin D3 (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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_NEXT = D2;
const int BUTTON_PREV = D3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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
}
}
Comment tester
- Câblez des boutons et téléversez. Appuyez sur NEXT ou PREV pour naviguer dans vos pistes.
Code Nano ESP32 — Basculer 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 Table:
* Mini Mp3 RX -> Arduino Pin D11
* Mini Mp3 TX -> Arduino Pin D10
* Mini Mp3 VCC -> Vbus
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
* Button -> Pin D2 (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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
const int BUTTON_PIN = D2;
bool paused = false;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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
}
}
Code Nano ESP32 — Mettre une piste en boucle
/*
* 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 D11
* Mini Mp3 TX -> Arduino Pin D10
* 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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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
}
Commandes de répétition et lecture aléatoire
| Méthode | Objectif | Exemple |
|---|---|---|
| loopTrack(t) | Répéter continuellement une piste | mp3.loopTrack(1) |
| loopFolder(f) | Répéter toutes les pistes d'un dossier | mp3.loopFolder(1) |
| loopAll() | Répéter tout sur la carte | mp3.loopAll() |
| stopLoop() | Terminer le mode de répétition actuel | mp3.stopLoop() |
| shuffle() | Ordre de lecture aléatoire | mp3.shuffle() |
Code Nano ESP32 — 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 D11
* Mini Mp3 TX -> Arduino Pin D10
* 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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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
}
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 Nano ESP32 — Contrôle par 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 D11
* Mini Mp3 TX -> Arduino Pin D10
* 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(D10, D11); // RX, TX
DIYables_MiniMp3 mp3;
void setup()
{
Serial.begin(9600);
mp3Serial.begin(9600);
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;
}
}
}
Commandes série
| Entrée | Résultat |
|---|---|
| 1–9 | Lire cette piste |
| + / − | Volume haut / bas |
| p | Pause |
| r | Reprendre |
| s | Arrêter |
| n | Piste suivante |
| b | Piste précédente |
| ? | Afficher le statut |
Préréglages d'égaliseur
| 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 | Basses renforcées |