Arduino Uno R4 - Mini Mp3 Player
Neste tutorial, você vai aprender a usar o módulo DIYables Mini Mp3 Player com o Arduino Uno R4 (nas versões WiFi e Minima). Vamos ver:
- Ligação do Mini Mp3 Player ao Arduino Uno R4.
- Reprodução de faixas mp3 armazenadas em um cartão SD.
- Ajuste do volume, incluindo aumentar e diminuir o volume.
- Pausar, retomar e parar a reprodução.
- Navegação entre as faixas (próxima e anterior).
- Repetição de uma única faixa, repetição de todas as faixas e modo aleatório.
- Reprodução de faixas específicas de pastas numeradas.
- Consulta do estado da reprodução.
Hardware Necessário
Or you can buy the following kits:
| 1 | × | DIYables STEM V4 IoT Starter Kit (Arduino included) | |
| 1 | × | DIYables STEM V4B IoT Starter Kit (Arduino included) | |
| 1 | × | DIYables Sensor Kit (18 sensors/displays) |
Divulgação: Alguns dos links desta seção são links de afiliado da Amazon. Podemos receber uma comissão pelas compras feitas por meio desses links, sem custo adicional para você. Agradecemos o seu apoio.
Sobre o Módulo Mini Mp3 Player
O DIYables Mini Mp3 Player é um módulo decodificador de mp3 compacto, construído em torno do chip YX5200-24SS. Ele toca arquivos mp3 diretamente de um cartão micro SD e pode acionar um alto-falante (até 3W) pelo amplificador integrado, ou enviar áudio em nível de linha pelos pinos DAC para uso com um amplificador externo.
A comunicação acontece por UART a 9600 baud, o que facilita o controle a partir de qualquer placa Arduino. Os principais recursos incluem:
- Tocar, pausar, retomar e parar
- Ajuste de volume de 0 a 30
- Seis predefinições de equalizador: Normal, Pop, Rock, Jazz, Classic, Bass
- Repetição de faixa, repetição de pasta, modo aleatório completo
- Reprodução por pastas com diretórios numerados
- Interrupção da reprodução com anúncios
- Consulta da faixa atual, do volume, do estado de reprodução e mais
Pinagem do Módulo
| Pino | Descrição |
|---|---|
| VCC | Entrada de alimentação (3,2V a 5,0V) |
| GND | Terra |
| RX | Entrada de dados seriais — conecte ao TX do Arduino por meio de um resistor de 1K |
| TX | Saída de dados seriais — conecte ao RX do Arduino |
| SPK_1 | Terminal positivo do alto-falante (acionamento direto, 3W no máximo) |
| SPK_2 | Terminal negativo do alto-falante (acionamento direto, 3W no máximo) |
| DAC_R | Saída de linha do canal direito (para amplificador externo) |
| DAC_L | Saída de linha do canal esquerdo (para amplificador externo) |
| BUSY | LOW durante a reprodução, HIGH quando está parado |
| IO_1 | Toque curto = faixa anterior, toque longo = diminuir volume |
| IO_2 | Toque curto = próxima faixa, toque longo = aumentar volume |
Diagrama de Ligação
O Arduino Uno R4 opera com lógica de 5V, por isso é necessário um resistor de 1K na linha RX do módulo para proteger a entrada de 3,3V dele.
| Pino do Mini Mp3 Player | Pino do Arduino Uno R4 | Observação |
|---|---|---|
| VCC | 5V | |
| GND | GND | |
| RX | Pino 11 | Por um resistor de 1K (necessário para placas de 5V) |
| TX | Pino 10 | |
| SPK_1 | Alto-falante + | |
| SPK_2 | Alto-falante − |
This image is created using Fritzing. Click to enlarge image
Veja A melhor forma de alimentar o Arduino Uno R4 e outros componentes.
Dica: O Uno R4 tem uma porta serial de hardware (Serial1 nos pinos 0 e 1), mas como os pinos 0/1 são compartilhados com o USB, usar SoftwareSerial nos pinos 10/11 é a abordagem mais segura.
Preparando o Cartão SD
- Formate o cartão micro SD como FAT16 ou FAT32.
- Copie seus arquivos mp3 para o diretório raiz usando nomes preenchidos com zeros à esquerda:
/001.mp3
/002.mp3
/003.mp3
- Para a reprodução por pastas, crie pastas numeradas com arquivos numerados:
/01/001.mp3
/01/002.mp3
/02/001.mp3
Pontos importantes:
- A numeração das faixas começa em 1, não em 0.
- O módulo define a ordem das faixas pela sequência em que os arquivos foram copiados, e não pelo nome do arquivo. Sempre formate o cartão primeiro e depois copie os arquivos um a um, na ordem desejada.
- Nomes das pastas: 2 dígitos, com zero à esquerda (01 a 99).
- Nomes dos arquivos dentro das pastas: 3 dígitos, com zeros à esquerda (001 a 255).
Instalando a Biblioteca
- Conecte o Arduino Uno R4 ao seu computador usando um cabo USB-C.
- Abra o Arduino IDE e selecione a placa e a porta corretas.
- Clique no ícone Libraries na barra lateral esquerda.
- Digite "DIYables_MiniMp3" na caixa de pesquisa e localize a biblioteca da DIYables.
- Clique em Install para adicionar a versão mais recente da biblioteca.
Esta biblioteca não tem dependências externas.
Código Arduino Uno R4 - Tocar uma Única Faixa
O sketch abaixo toca uma faixa mp3 do cartão 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
}
Como Executar
- Prepare um cartão SD com arquivos mp3 (001.mp3, 002.mp3, etc.) e insira-o no módulo.
- Ligue o Mini Mp3 Player ao Uno R4 de acordo com o diagrama de ligação acima.
- Conecte o Uno R4 ao seu computador com um cabo USB-C.
- Abra o Arduino IDE, escolha Arduino Uno R4 WiFi (ou Minima) como placa e selecione a porta correta.
- Cole o código acima no editor do IDE.
- Pressione Upload.
Você deve ouvir a faixa 001.mp3 pelo alto-falante.
Funções de Reprodução em Resumo
| Função | O Que Faz | Uso |
|---|---|---|
| play(trackNum) | Inicia uma faixa específica | mp3.play(1) |
| playNext() | Pula para a próxima faixa | mp3.playNext() |
| playPrevious() | Volta para a faixa anterior | mp3.playPrevious() |
| pause() | Pausa a faixa atual | mp3.pause() |
| resume() | Retoma uma faixa pausada | mp3.resume() |
| stop() | Para a reprodução por completo | mp3.stop() |
Código Arduino Uno R4 - Tocar Várias Faixas em Sequência
Este sketch toca várias faixas uma após a outra, com um intervalo configurável entre elas.
/*
* 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();
}
}
Como Executar
- Verifique se o cartão SD contém pelo menos 3 faixas (001.mp3, 002.mp3, 003.mp3).
- Faça o upload do código para o Uno R4.
As faixas de 1 a 3 vão tocar em ciclo repetido, com um intervalo de 5 segundos.
Código Arduino Uno R4 - Controle de Volume com Botões
Ligue dois botões de pressão para aumentar e diminuir o volume em tempo real.
/*
* 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
}
}
Como Executar
- Conecte dois botões como descrito nos comentários do código e faça o upload.
- Pressione os botões enquanto a música toca para aumentar ou diminuir o volume. O Serial Monitor mostra o nível atual.
Funções de Volume
| Função | O Que Faz | Uso |
|---|---|---|
| setVolume(level) | Define o volume diretamente (0–30) | mp3.setVolume(25) |
| volumeUp() | Aumenta o volume em 1 | mp3.volumeUp() |
| volumeDown() | Diminui o volume em 1 | mp3.volumeDown() |
| getVolume() | Retorna o volume atual | mp3.getVolume() |
Código Arduino Uno R4 - Botões de Próxima e Anterior
Dois botões permitem avançar ou voltar na sua lista de reprodução.
/*
* 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
}
}
Como Executar
- Ligue os botões NEXT e PREV aos pinos 2 e 3.
- Faça o upload do sketch e pressione os botões para navegar entre as faixas.
Código Arduino Uno R4 - Alternar entre Pausar e Retomar
Um único botão alterna a reprodução entre pausada e tocando.
/*
* 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
}
}
Como Executar
- Ligue um botão ao pino 2 e faça o upload.
- Pressione o botão uma vez para pausar e pressione de novo para retomar.
Código Arduino Uno R4 - Repetir uma Faixa
Este sketch repete uma única faixa sem parar.
/*
* 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
}
Como Executar
- Faça o upload do código. A faixa 001.mp3 vai repetir continuamente.
Funções de Repetição e Modo Aleatório
| Função | O Que Faz | Uso |
|---|---|---|
| loopTrack(trackNum) | Repete uma faixa para sempre | mp3.loopTrack(1) |
| loopFolder(folder) | Repete todas as faixas de uma pasta | mp3.loopFolder(1) |
| loopAll() | Repete todas as faixas do cartão | mp3.loopAll() |
| stopLoop() | Cancela qualquer repetição ativa | mp3.stopLoop() |
| shuffle() | Toca todas as faixas em ordem aleatória | mp3.shuffle() |
Código Arduino Uno R4 - Tocar de uma Pasta
Toque faixas de pastas numeradas específicas do cartão 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
}
Como Executar
- Prepare o cartão SD com pastas (01, 02) contendo arquivos numerados (001.mp3, 002.mp3).
- Faça o upload do sketch. Ele toca as faixas da pasta 01 e depois da pasta 02.
Funções de Reprodução por Pasta
| Função | O Que Faz | Uso |
|---|---|---|
| playFolder(folder, track) | Toca uma faixa de uma pasta (até 99 pastas, 255 faixas) | mp3.playFolder(1, 1) |
| playLargeFolder(folder, track) | Toca de uma pasta (até 15 pastas, 3000 faixas) | mp3.playLargeFolder(1, 1500) |
| playFromMP3Folder(trackNum) | Toca da pasta /mp3 | mp3.playFromMP3Folder(1) |
Código Arduino Uno R4 - Controle pelo Serial Monitor
Digite comandos de um único caractere no Serial Monitor para controlar todos os aspectos da reprodução. Não é necessário hardware extra.
/*
* 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;
}
}
}
Como Executar
- Faça o upload do código e depois abra o Serial Monitor a 9600 baud.
- Digite qualquer comando da tabela abaixo:
| Tecla | Ação |
|---|---|
| 1–9 | Tocar a faixa de número 1 a 9 |
| + | Aumentar o volume |
| − | Diminuir o volume |
| p | Pausar a reprodução |
| r | Retomar a reprodução |
| s | Parar a reprodução |
| n | Pular para a próxima faixa |
| b | Voltar para a faixa anterior |
| ? | Mostrar o estado atual |
Modos do Equalizador
Seis predefinições de EQ estão disponíveis:
| Constante | ID | Perfil de Som |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Plano / neutro |
| DIYables_MiniMp3::EQ_POP | 1 | Pop |
| DIYables_MiniMp3::EQ_ROCK | 2 | Rock |
| DIYables_MiniMp3::EQ_JAZZ | 3 | Jazz |
| DIYables_MiniMp3::EQ_CLASSIC | 4 | Clássico |
| DIYables_MiniMp3::EQ_BASS | 5 | Ênfase nos graves |
mp3.setEQ(DIYables_MiniMp3::EQ_ROCK);
Consultando o Estado da Reprodução
As funções a seguir permitem ler o estado do módulo durante a execução. Cada chamada bloqueia por até 100 ms enquanto espera uma resposta. Um valor de retorno de −1 indica erro ou tempo esgotado.
| Função | Tipo de Retorno | Descrição |
|---|---|---|
| isPlaying() | bool | true enquanto uma faixa está sendo tocada |
| getVolume() | int16_t | Nível de volume atual (0–30) |
| getEQ() | int16_t | Predefinição de EQ ativa (0–5) |
| getTrackCount() | int16_t | Número de faixas no cartão SD |
| getCurrentTrack() | int16_t | Número da faixa que está tocando |
| getFolderCount() | int16_t | Número de pastas no cartão SD |
| getTrackCountInFolder(folder) | int16_t | Faixas dentro de uma pasta específica |