Arduino Nano - Mini Lecteur Mp3
Ce guide vous montre tout ce dont vous avez besoin pour faire fonctionner le module DIYables Mini Mp3 Player avec un Arduino Nano. À la fin, vous saurez comment :
- Câbler le Mini Mp3 Player à un Arduino Nano sur une breadboard.
- Lire, mettre en pause, reprendre et arrêter des pistes mp3.
- Contrôler le volume avec des boutons physiques ou des commandes série.
- Passer aux pistes suivantes et précédentes.
- Lire des pistes individuelles en boucle, toutes les pistes en boucle ou en mode aléatoire.
- Organiser et lire des pistes depuis des dossiers numérotés.
- Lire le volume actuel, le numéro de piste et l'état de lecture.
Ce Dont Vous Aurez Besoin
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.
Découverte du Module Mini Mp3 Player
Le module DIYables Mini Mp3 Player intègre la puce décodeur YX5200-24SS sur une petite carte. Insérez une carte micro SD chargée de fichiers mp3, connectez un haut-parleur, et vous avez un lecteur audio autonome que votre Nano contrôle via une simple connexion série.
Voici ce que le module peut faire :
- Contrôles de lecture : lire, mettre en pause, reprendre, arrêter, suivant, précédent
- Volume : réglable de 0 (silencieux) à 30 (maximum)
- Préréglages EQ : Normal, Pop, Rock, Jazz, Classique, Basse
- Modes de répétition : boucle d'une piste, boucle d'un dossier, boucle de tout, aléatoire
- Dossiers : organisez les pistes dans des dossiers numérotés pour une sélection facile
- Publicités : interrompre la piste en cours, puis continuer là où vous vous étiez arrêté
- Requêtes d'état : demandez au module quelle piste est en cours, le volume actuel, etc.
Toute la communication se fait via UART à 9600 bauds — juste deux fils (TX et RX) plus l'alimentation.
Référence du Brochage
| Pin | What It Does | |
|---|---|---|
| VCC | Power in (3.2V – 5.0V) | |
| GND | Ground connection | |
| RX | Receives serial commands from the Nano (through 1K resistor) | |
| TX | Sends serial data back to the Nano | |
| SPK_1 | Positive speaker terminal (built-in 3W amp) | |
| SPK_2 | Negative speaker terminal | |
| DAC_R | Right audio line out (for external amp) | |
| DAC_L | Left audio line out (for external amp) | |
| BUSY | Goes LOW while a track is playing | |
| IO_1 | Trigger | short press = previous, long press = vol down |
| IO_2 | Trigger | short press = next, long press = vol up |
Comment Câbler
Puisque l'Arduino Nano fonctionne à 5V, vous devez placer une résistance 1K entre la broche TX du Nano et la broche RX du module. Cela abaisse la tension à un niveau sûr pour la logique 3,3V du module.
| Mini Mp3 Player | Arduino Nano | Notes |
|---|---|---|
| VCC | 5V | |
| GND | GND | |
| RX | D11 | Use a 1K resistor in series! |
| TX | D10 | |
| SPK_1 | Speaker + | |
| SPK_2 | Speaker − |
Le Nano et le Mini Mp3 Player tiennent tous les deux confortablement sur une breadboard standard, ce qui en fait une construction très compacte.
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Configuration de la Carte SD
Avant d'insérer la carte dans le module :
- Formatez-la en FAT16 ou FAT32.
- Copiez les fichiers mp3 à la racine avec des numéros à zéros non significatifs :
/001.mp3
/002.mp3
/003.mp3
- Pour la lecture par dossier, créez des dossiers numérotés :
/01/001.mp3
/01/002.mp3
/02/001.mp3
Attention : Le module numérote les pistes selon l'ordre dans lequel elles ont été copiées sur la carte, pas par nom de fichier. Formatez d'abord la carte, puis copiez chaque fichier un par un dans le bon ordre.
- Noms de dossiers : 01 à 99 (deux chiffres, avec zéros non significatifs)
- Noms de fichiers dans les dossiers : 001 à 255 (trois chiffres, avec zéros non significatifs)
- La numérotation des pistes commence à 1, pas 0
Installation de la Bibliothèque
- Branchez le Nano à votre ordinateur via le câble USB Mini-B.
- Ouvrez l'Arduino IDE, choisissez Arduino Nano comme carte et sélectionnez le bon port COM.
- Cliquez sur l'icône Bibliothèques dans la barre latérale gauche de l'Arduino IDE.
- Recherchez "DIYables_MiniMp3" et trouvez la bibliothèque par DIYables.
- Cliquez sur Installer.
Aucune dépendance supplémentaire n'est nécessaire — la bibliothèque est entièrement autonome.
Modèle de Démarrage
Voici la structure de code minimale dont vous avez besoin pour chaque sketch utilisant ce module :
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // RX on D10, TX on D11
DIYables_MiniMp3 mp3;
void setup() {
mp3Serial.begin(9600);
mp3.begin(mp3Serial);
delay(1000); // Let the module boot up
mp3.setVolume(25); // Range: 0 to 30
}
void loop() {
// Your playback logic here
}
Le delay(1000) après begin() est important — le module a besoin d'environ une seconde pour s'initialiser après la mise sous tension. Définissez toujours le volume explicitement, car la valeur par défaut peut être 0 (silencieux).
Exemple de Code — Lire une Piste
Lit la piste 001.mp3 une fois et s'arrête.
/*
* DIYables Mini Mp3 Player - Play One Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Plays track 001 once, then stops.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // 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
}
Étapes pour l'Essayer
- Chargez votre carte SD avec au moins un fichier mp3 (001.mp3).
- Insérez la carte SD dans le module et câblez tout comme indiqué ci-dessus.
- Connectez le Nano à votre PC via USB.
- Dans l'Arduino IDE, sélectionnez Arduino Nano et le bon port.
- Collez le code et cliquez sur Téléverser.
La piste 1 se joue via le haut-parleur.
Référence Rapide de Lecture
| Function | Description | Example Code |
|---|---|---|
| play(track) | Play a specific track | mp3.play(1) |
| playNext() | Jump to next track | mp3.playNext() |
| playPrevious() | Jump to previous track | mp3.playPrevious() |
| pause() | Pause current track | mp3.pause() |
| resume() | Continue paused track | mp3.resume() |
| stop() | Stop playback | mp3.stop() |
Exemple de Code — Lire Plusieurs Pistes
Passe par plusieurs pistes une à la fois.
/*
* DIYables Mini Mp3 Player - Play Multiple Tracks
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Plays tracks one after another with a delay between them.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, 003.mp3
*/
#include <DIYables_MiniMp3.h>
#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(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();
}
}
Étapes pour l'Essayer
- Mettez au moins 3 fichiers mp3 sur la carte SD.
- Téléversez le code. Les pistes se jouent en boucle avec un intervalle de 5 secondes.
Exemple de Code — Boutons Volume Haut/Bas
Deux boutons physiques augmentent et diminuent le volume en temps réel.
/*
* DIYables Mini Mp3 Player - Volume Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Use two buttons to increase/decrease the volume.
* Press button on pin 2 to volume up, pin 3 to volume down.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* 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(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
}
}
Étapes pour l'Essayer
- Câblez deux boutons comme décrit dans le code, puis téléversez.
- Appuyez sur les boutons pendant qu'une piste joue. Regardez le Moniteur Série pour le niveau de volume.
Référence Rapide Volume
| Function | Description | Example Code |
|---|---|---|
| setVolume(val) | Set volume (0 = mute, 30 = max) | mp3.setVolume(20) |
| volumeUp() | Bump volume up by 1 | mp3.volumeUp() |
| volumeDown() | Bump volume down by 1 | mp3.volumeDown() |
| getVolume() | Read current volume level | mp3.getVolume() |
Exemple de Code — Boutons Suivant / Précédent
Passez aux pistes avec deux boutons.
/*
* DIYables Mini Mp3 Player - Next/Previous with Buttons
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Use two buttons to play next/previous tracks.
* Displays the current track number on the Serial Monitor.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* 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(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
}
}
Étapes pour l'Essayer
- Câblez des boutons aux broches 2 et 3, téléversez et appuyez pour passer.
Exemple de Code — Bouton Pause / Reprise
Un seul bouton bascule entre pause et reprise.
/*
* DIYables Mini Mp3 Player - Pause and Resume
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Demonstrates pausing and resuming playback using a single button.
* Press the button to toggle between pause and resume.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* 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(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
}
}
Étapes pour l'Essayer
- Câblez un bouton à la broche 2. Téléversez et appuyez pour basculer la pause/reprise.
Exemple de Code — Lire une Piste en Boucle Indéfiniment
Répète une seule piste en boucle sans fin.
/*
* DIYables Mini Mp3 Player - Loop Track
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Loops (repeats) a track continuously with EQ setting.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /001.mp3
* /002.mp3
* ...
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // 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
}
Étapes pour l'Essayer
- Téléversez le code. La piste 1 se répète indéfiniment.
Référence Rapide Répétition & Aléatoire
| Function | Description | Example Code |
|---|---|---|
| loopTrack(track) | Repeat one track nonstop | mp3.loopTrack(1) |
| loopFolder(folder) | Repeat all tracks in a folder | mp3.loopFolder(1) |
| loopAll() | Repeat every track on the card | mp3.loopAll() |
| stopLoop() | Cancel the current loop | mp3.stopLoop() |
| shuffle() | Random playback of all tracks | mp3.shuffle() |
Exemple de Code — Lecture par Dossier
Sélectionnez et lisez des pistes depuis des dossiers numérotés spécifiques sur la carte SD.
/*
* DIYables Mini Mp3 Player - Play from Folder
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Plays tracks from specific folders on the SD card.
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card file structure:
* /01/001.mp3 <- playFolder(1, 1)
* /01/002.mp3 <- playFolder(1, 2)
* /02/001.mp3 <- playFolder(2, 1)
* /02/002.mp3 <- playFolder(2, 2)
*
* IMPORTANT:
* - Numbering starts from 1, NOT 0
* - Folder names must be 2-digit zero-padded (01-99)
* - Track names must be 3-digit zero-padded (001-255)
* - Format SD card as FAT32, then copy files one by one in order
* - Track order is determined by the order files were copied,
* NOT by filename. So copy them in the correct sequence.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // 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
}
Étapes pour l'Essayer
- Créez des dossiers (01, 02) sur la carte SD avec des fichiers mp3 numérotés à l'intérieur.
- Téléversez le code. Il lit depuis le dossier 01, puis le dossier 02.
Référence Rapide Lecture par Dossier
| Function | Description | Example Code |
|---|---|---|
| playFolder(f, t) | Play track t from folder f (99 folders max, 255 tracks) | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Play from folder (15 folders max, 3000 tracks) | mp3.playLargeFolder(1, 500) |
| playFromMP3Folder(t) | Play from the special /mp3 folder | mp3.playFromMP3Folder(1) |
Exemple de Code — Télécommande via Moniteur Série
Contrôlez la lecture entièrement depuis le Moniteur Série — idéal pour les tests.
/*
* DIYables Mini Mp3 Player - Serial Command Control
*
* Product: DIYables Mini Mp3 Player Module
* https://diyables.io/products/mini-mp3-player-module
*
* Tested with:
* - Arduino Uno R3
* - Arduino Uno R4 WiFi / R4 Minima
* - Arduino Mega
* - Arduino Due
* - Arduino Giga
* - DIYables STEM V3 https://diyables.io/stem-v3
* - DIYables STEM V4 IoT https://diyables.io/stem-v4-iot
* - DIYables STEM V4B IoT https://diyables.io/stem-v4b-iot
* - DIYables STEM V4 Edu https://diyables.io/stem-v4-edu
* - DIYables MEGA2560 R3 https://diyables.io/atmega2560-board
* - DIYables Nano R3 https://diyables.io/nano-board
* - DIYables ESP32 Board https://diyables.io/esp32-board
* - DIYables ESP32 S3 (Uno) https://diyables.io/esp32-s3-uno
* - Expected to work with other Arduino-compatible boards
*
* Control the Mp3 player by typing commands in the Serial Monitor.
* Great for testing all functions without extra hardware.
*
* Commands (type in Serial Monitor, then press Enter):
* 1-9 Play track 1 to 9
* + Volume up
* - Volume down
* p Pause
* r Resume
* s Stop
* n Next track
* b Previous track (back)
* ? Show current status
*
* Wiring (Arduino Uno):
* Mini Mp3 RX -> Arduino Pin 11 (via 1K resistor)
* Mini Mp3 TX -> Arduino Pin 10
* Mini Mp3 VCC -> 5V
* Mini Mp3 GND -> GND
* Speaker connected to SPK_1 and SPK_2 pins
*
* SD Card: Put mp3 files in root, named 001.mp3, 002.mp3, etc.
*/
#include <DIYables_MiniMp3.h>
#include <SoftwareSerial.h>
SoftwareSerial mp3Serial(10, 11); // 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;
}
}
}
Étapes pour l'Essayer
- Téléversez le code, ouvrez le Moniteur Série à 9600 bauds, et tapez des commandes.
Référence des Commandes
| Type | What Happens |
|---|---|
| 1–9 | Plays that track number |
| + | Volume up |
| − | Volume down |
| p | Pause |
| r | Resume |
| s | Stop |
| n | Next track |
| b | Back (previous track) |
| ? | Show status info |
Préréglages EQ
| Constant | Value | Style |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Flat |
| DIYables_MiniMp3::EQ_POP | 1 | Pop |
| DIYables_MiniMp3::EQ_ROCK | 2 | Rock |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Jazz |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Classical |
| DIYables_MiniMp3::EQ_BASS | 5 | Bass heavy |
mp3.setEQ(DIYables_MiniMp3::EQ_JAZZ);
Lecture de l'État du Module
Ces appels vous permettent de vérifier ce que fait le module. Chacun se bloque brièvement (jusqu'à 100 ms) en attendant la réponse. Renvoie −1 si le module ne répond pas.
| Function | Returns | What You Get |
|---|---|---|
| isPlaying() | bool | true if audio is currently playing |
| getVolume() | int16_t | Volume level (0–30) |
| getEQ() | int16_t | Active equalizer preset (0–5) |
| getTrackCount() | int16_t | Total number of tracks on the card |
| getCurrentTrack() | int16_t | Track number that's playing right now |
| getFolderCount() | int16_t | How many folders are on the card |
| getTrackCountInFolder(f) | int16_t | How many tracks are in folder f |