Arduino Uno R4 - Mini Lecteur Mp3
Dans ce tutoriel, vous allez apprendre à utiliser le module DIYables Mini Mp3 Player avec l'Arduino Uno R4 (variantes WiFi et Minima). Nous couvrirons :
- Le câblage du Mini Mp3 Player à l'Arduino Uno R4.
- La lecture de pistes mp3 stockées sur une carte SD.
- L'ajustement du volume, y compris l'augmentation et la diminution du volume.
- La mise en pause, la reprise et l'arrêt de la lecture.
- La navigation entre les pistes (suivante et précédente).
- La lecture en boucle d'une seule piste, de toutes les pistes et en mode aléatoire.
- La lecture de pistes spécifiques depuis des dossiers numérotés.
- L'interrogation de l'état de lecture.
Matériel Requis
Ou vous pouvez acheter les kits suivants:
| 1 | × | Kit de Démarrage DIYables STEM V4 IoT (Arduino 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 compact construit autour de la puce YX5200-24SS. Il lit des fichiers mp3 directement depuis une carte micro SD et peut piloter un haut-parleur (jusqu'à 3W) via son amplificateur intégré, ou émettre un audio de niveau ligne via des broches DAC pour une utilisation avec un amplificateur externe.
La communication se fait via UART à 9600 bauds, ce qui le rend facile à contrôler depuis n'importe quelle carte Arduino. Les capacités clés incluent :
- Lecture, pause, reprise et arrêt
- Réglage du volume de 0 à 30
- Six préréglages d'égaliseur : Normal, Pop, Rock, Jazz, Classique, Basse
- Boucle de piste, boucle de dossier, lecture aléatoire complète
- Lecture basée sur des dossiers avec des répertoires numérotés
- Interrompre la lecture avec des publicités
- Interroger la piste actuelle, le volume, l'état de lecture et plus encore
Brochage du Module
| Pin | Description |
|---|---|
| VCC | Power input (3.2V to 5.0V) |
| GND | Ground |
| RX | Serial data in — connect to Arduino TX through a 1K resistor |
| TX | Serial data out — connect to Arduino RX |
| SPK_1 | Speaker positive terminal (direct drive, 3W max) |
| SPK_2 | Speaker negative terminal (direct drive, 3W max) |
| DAC_R | Right channel line output (for external amplifier) |
| DAC_L | Left channel line output (for external amplifier) |
| BUSY | LOW during playback, HIGH when idle |
| IO_1 | Short press = previous track, long press = volume down |
| IO_2 | Short press = next track, long press = volume up |
Schéma de Câblage
L'Arduino Uno R4 fonctionne à une logique 5V, donc une résistance 1K est nécessaire sur la ligne RX du module pour protéger son entrée 3,3V.
| Mini Mp3 Player Pin | Arduino Uno R4 Pin | Note |
|---|---|---|
| VCC | 5V | |
| GND | GND | |
| RX | Pin 11 | Via 1K resistor (required for 5V boards) |
| TX | Pin 10 | |
| SPK_1 | Speaker + | |
| SPK_2 | Speaker − |
Cette image a été créée avec Fritzing. Cliquez pour agrandir l'image.
Voir Comment alimenter l'Arduino UNO R4..
Conseil : L'Uno R4 a un port série matériel (Serial1 sur les broches 0 et 1), mais comme les broches 0/1 sont partagées avec USB, l'utilisation de SoftwareSerial sur les broches 10/11 est l'approche la plus sûre.
Préparation de la Carte SD
- Formatez la carte micro SD en FAT16 ou FAT32.
- Copiez vos fichiers mp3 dans le répertoire racine avec des noms à zéros non significatifs :
/001.mp3
/002.mp3
/003.mp3
- Pour la lecture basée sur des dossiers, créez des dossiers numérotés avec des fichiers numérotés :
/01/001.mp3
/01/002.mp3
/02/001.mp3
Points clés :
- La numérotation des pistes commence à 1, pas 0.
- Le module détermine l'ordre des pistes par la séquence dans laquelle les fichiers sont copiés, pas par le nom de fichier. Formatez toujours la carte en premier, puis copiez les fichiers un à la fois dans l'ordre souhaité.
- Noms de dossiers : 2 chiffres, à zéros non significatifs (01 à 99).
- Noms de fichiers dans les dossiers : 3 chiffres, à zéros non significatifs (001 à 255).
Installation de la Bibliothèque
- Branchez l'Arduino Uno R4 à votre ordinateur avec un câble USB-C.
- Ouvrez l'Arduino IDE et sélectionnez la bonne carte et le bon port.
- Cliquez sur l'icône Bibliothèques dans la barre latérale gauche.
- Tapez "DIYables_MiniMp3" dans la zone de recherche et localisez la bibliothèque par DIYables.
- Cliquez sur Installer pour ajouter la dernière version de la bibliothèque.
Cette bibliothèque n'a pas de dépendances externes.
Code Arduino Uno R4 - Lire une Seule Piste
Le sketch ci-dessous lit une piste mp3 depuis la carte SD.
/*
* 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 R4):
* 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
}
Comment Exécuter
- Préparez une carte SD avec des fichiers mp3 (001.mp3, 002.mp3, etc.) et insérez-la dans le module.
- Câblez le Mini Mp3 Player à l'Uno R4 selon le schéma de câblage ci-dessus.
- Connectez l'Uno R4 à votre ordinateur avec un câble USB-C.
- Ouvrez l'Arduino IDE, choisissez Arduino Uno R4 WiFi (ou Minima) comme carte et sélectionnez le bon port.
- Collez le code ci-dessus dans l'éditeur IDE.
- Appuyez sur Téléverser.
Vous devriez entendre la piste 001.mp3 via le haut-parleur.
Fonctions de Lecture en Un Coup d'Œil
| Function | What It Does | Usage |
|---|---|---|
| play(trackNum) | Starts a specific track | mp3.play(1) |
| playNext() | Skips to the next track | mp3.playNext() |
| playPrevious() | Goes back to the previous track | mp3.playPrevious() |
| pause() | Pauses the current track | mp3.pause() |
| resume() | Resumes a paused track | mp3.resume() |
| stop() | Stops playback entirely | mp3.stop() |
Code Arduino Uno R4 - Lire Plusieurs Pistes en Séquence
Ce sketch lit plusieurs pistes l'une après l'autre, avec un délai configurable entre chacune.
/*
* 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 R4):
* 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();
}
}
Comment Exécuter
- Assurez-vous que la carte SD contient au moins 3 pistes (001.mp3, 002.mp3, 003.mp3).
- Téléversez le code sur l'Uno R4.
Les pistes 1 à 3 se joueront en cycle répété avec un intervalle de 5 secondes.
Code Arduino Uno R4 - Contrôle du Volume avec Boutons
Câblez deux boutons poussoirs pour ajuster 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 R4):
* 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
}
}
Comment Exécuter
- Connectez deux boutons comme décrit dans les commentaires du code, puis téléversez.
- Appuyez sur les boutons pendant que la musique joue pour augmenter ou diminuer le volume. Le Moniteur Série affiche le niveau actuel.
Fonctions de Volume
| Function | What It Does | Usage |
|---|---|---|
| setVolume(level) | Sets volume directly (0–30) | mp3.setVolume(25) |
| volumeUp() | Raises volume by 1 | mp3.volumeUp() |
| volumeDown() | Lowers volume by 1 | mp3.volumeDown() |
| getVolume() | Returns the current volume | mp3.getVolume() |
Code Arduino Uno R4 - Boutons Piste Suivante et Précédente
Deux boutons permettent de passer en avant ou en arrière dans votre liste de lecture.
/*
* 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 R4):
* 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
}
}
Comment Exécuter
- Câblez les boutons SUIVANT et PRÉCÉDENT aux broches 2 et 3.
- Téléversez le sketch et appuyez sur les boutons pour naviguer entre les pistes.
Code Arduino Uno R4 - Basculer Pause et Reprise
Un seul bouton bascule la lecture entre pause et en cours.
/*
* 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 R4):
* 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
}
}
Comment Exécuter
- Câblez un bouton à la broche 2, puis téléversez.
- Appuyez une fois pour mettre en pause, appuyez à nouveau pour reprendre.
Code Arduino Uno R4 - Lire une Piste en Boucle
Ce sketch répète une seule piste indéfiniment.
/*
* 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 R4):
* 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
}
Comment Exécuter
- Téléversez le code. La piste 001.mp3 se jouera en boucle en continu.
Fonctions de Répétition et Aléatoire
| Function | What It Does | Usage |
|---|---|---|
| loopTrack(trackNum) | Repeats one track forever | mp3.loopTrack(1) |
| loopFolder(folder) | Repeats every track in a folder | mp3.loopFolder(1) |
| loopAll() | Repeats all tracks on the card | mp3.loopAll() |
| stopLoop() | Cancels any active loop | mp3.stopLoop() |
| shuffle() | Plays all tracks in random order | mp3.shuffle() |
Code Arduino Uno R4 - Lire depuis un Dossier
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 R4):
* 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
}
Comment Exécuter
- Configurez la carte SD avec des dossiers (01, 02) contenant des fichiers numérotés (001.mp3, 002.mp3).
- Téléversez le sketch. Il lit les pistes du dossier 01 puis du dossier 02.
Fonctions de Lecture par Dossier
| Function | What It Does | Usage |
|---|---|---|
| playFolder(folder, track) | Plays a track from a folder (up to 99 folders, 255 tracks) | mp3.playFolder(1, 1) |
| playLargeFolder(folder, track) | Plays from a folder (up to 15 folders, 3000 tracks) | mp3.playLargeFolder(1, 1500) |
| playFromMP3Folder(trackNum) | Plays from the /mp3 folder | mp3.playFromMP3Folder(1) |
Code Arduino Uno R4 - Contrôle via le Moniteur Série
Tapez des commandes à un seul caractère dans le Moniteur Série pour contrôler chaque aspect de la lecture. Aucun matériel supplémentaire nécessaire.
/*
* 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 R4):
* 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;
}
}
}
Comment Exécuter
- Téléversez le code, puis ouvrez le Moniteur Série à 9600 bauds.
- Entrez n'importe quelle commande du tableau ci-dessous :
| Key | Action |
|---|---|
| 1–9 | Play track number 1 through 9 |
| + | Turn volume up |
| − | Turn volume down |
| p | Pause playback |
| r | Resume playback |
| s | Stop playback |
| n | Skip to next track |
| b | Go back to previous track |
| ? | Print current status |
Modes d'Égaliseur
Six préréglages EQ intégrés sont disponibles :
| Constant | ID | Sound Profile |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Flat / neutral |
| 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 emphasis |
mp3.setEQ(DIYables_MiniMp3::EQ_ROCK);
Interrogation de l'État de Lecture
Les fonctions suivantes vous permettent de lire l'état du module à l'exécution. Chaque appel se bloque jusqu'à 100 ms en attendant une réponse. Une valeur de retour de −1 indique une erreur ou un délai d'attente.
| Function | Return Type | Description |
|---|---|---|
| isPlaying() | bool | true while a track is actively playing |
| getVolume() | int16_t | Current volume level (0–30) |
| getEQ() | int16_t | Active EQ preset (0–5) |
| getTrackCount() | int16_t | Number of tracks on the SD card |
| getCurrentTrack() | int16_t | Track number currently playing |
| getFolderCount() | int16_t | Number of folders on the SD card |
| getTrackCountInFolder(folder) | int16_t | Tracks inside a specific folder |