Arduino Nano - Mini Mp3 Player
Este guia mostra tudo o que você precisa para fazer o módulo DIYables Mini Mp3 Player funcionar com um Arduino Nano. Ao final, você saberá como:
- Ligar o Mini Mp3 Player a um Arduino Nano em uma protoboard.
- Tocar, pausar, retomar e parar faixas mp3.
- Controlar o volume com botões físicos ou comandos seriais.
- Avançar e voltar entre as faixas.
- Repetir faixas individuais, repetir todas as faixas ou tocar em ordem aleatória.
- Organizar e tocar faixas de pastas numeradas.
- Ler de volta o volume atual, o número da faixa e o estado de reprodução.
O Que Você Vai Precisar
Or you can buy the following kits:
| 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.
Conhecendo o Módulo Mini Mp3 Player
O módulo DIYables Mini Mp3 Player reúne o chip decodificador YX5200-24SS em uma placa minúscula. Encaixe um cartão micro SD com arquivos mp3, conecte um alto-falante e pronto: você tem um player de áudio independente que o seu Nano controla por uma conexão serial simples.
Veja o que o módulo pode fazer:
- Controles de reprodução: tocar, pausar, retomar, parar, próxima, anterior
- Volume: ajustável de 0 (mudo) a 30 (máximo)
- Presets de EQ: Normal, Pop, Rock, Jazz, Classic, Bass
- Modos de repetição: repetir uma faixa, repetir uma pasta, repetir tudo, aleatório
- Pastas: organize as faixas em pastas numeradas para facilitar a seleção
- Anúncios: interrompem a faixa atual e depois continuam de onde você parou
- Consultas de status: pergunte ao módulo qual faixa está tocando, o volume atual, etc.
Toda a comunicação acontece por UART a 9600 baud — apenas dois fios (TX e RX) mais a alimentação.
Referência de Pinagem
| Pino | O Que Faz | |
|---|---|---|
| VCC | Entrada de alimentação (3,2V – 5,0V) | |
| GND | Conexão de terra | |
| RX | Recebe comandos seriais do Nano (através de resistor de 1K) | |
| TX | Envia dados seriais de volta ao Nano | |
| SPK_1 | Terminal positivo do alto-falante (amplificador de 3W embutido) | |
| SPK_2 | Terminal negativo do alto-falante | |
| DAC_R | Saída de linha de áudio direita (para amplificador externo) | |
| DAC_L | Saída de linha de áudio esquerda (para amplificador externo) | |
| BUSY | Fica em LOW enquanto uma faixa está tocando | |
| IO_1 | Gatilho | toque curto = anterior, toque longo = diminuir volume |
| IO_2 | Gatilho | toque curto = próxima, toque longo = aumentar volume |
Como Ligar
Como o Arduino Nano funciona a 5V, você deve colocar um resistor de 1K entre o pino TX do Nano e o pino RX do módulo. Isso reduz a tensão para um nível seguro para a lógica de 3,3V do módulo.
| Mini Mp3 Player | Arduino Nano | Observações |
|---|---|---|
| VCC | 5V | |
| GND | GND | |
| RX | D11 | Use um resistor de 1K em série! |
| TX | D10 | |
| SPK_1 | Alto-falante + | |
| SPK_2 | Alto-falante − |
Tanto o Nano quanto o Mini Mp3 Player cabem confortavelmente em uma protoboard padrão, o que torna esta montagem muito compacta.
This image is created using Fritzing. Click to enlarge image
Veja A melhor forma de alimentar o Arduino Nano e outros componentes.
Preparando o Cartão SD
Antes de inserir o cartão no módulo:
- Formate como FAT16 ou FAT32.
- Copie os arquivos mp3 para a raiz com números preenchidos com zeros:
/001.mp3
/002.mp3
/003.mp3
- Para reprodução por pasta, crie pastas numeradas:
/01/001.mp3
/01/002.mp3
/02/001.mp3
Atenção: O módulo numera as faixas pela ordem em que elas foram copiadas para o cartão, e não pelo nome do arquivo. Formate o cartão primeiro e depois copie cada arquivo, um de cada vez, na ordem correta.
- Nomes de pastas: 01 a 99 (dois dígitos, preenchidos com zeros)
- Nomes de arquivos dentro das pastas: 001 a 255 (três dígitos, preenchidos com zeros)
- A numeração das faixas começa em 1, não em 0
Instalação da Biblioteca
- Conecte o Nano ao seu computador pelo cabo USB Mini-B.
- Abra o Arduino IDE, escolha Arduino Nano como placa e selecione a porta COM correta.
- Clique no ícone Libraries na barra lateral esquerda do Arduino IDE.
- Pesquise por "DIYables_MiniMp3" e encontre a biblioteca da DIYables.
- Clique em Install.
Nenhuma dependência adicional é necessária — a biblioteca é totalmente independente.
Modelo Inicial
Esta é a estrutura mínima de código de que você precisa em todo sketch que usa este módulo:
#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
}
O delay(1000) depois de begin() é importante — o módulo precisa de cerca de um segundo para se inicializar após ser ligado. Sempre defina o volume explicitamente, porque o padrão pode ser 0 (mudo).
Exemplo de Código — Tocar Uma Faixa
Toca a faixa 001.mp3 uma vez e para.
/*
* 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
}
Passos para Testar
- Carregue seu cartão SD com pelo menos um arquivo mp3 (001.mp3).
- Insira o cartão SD no módulo e ligue tudo como mostrado acima.
- Conecte o Nano ao seu PC por USB.
- No Arduino IDE, selecione Arduino Nano e a porta correta.
- Cole o código e clique em Upload.
A faixa 1 toca pelo alto-falante.
Referência Rápida de Reprodução
| Função | Descrição | Código de Exemplo |
|---|---|---|
| play(track) | Toca uma faixa específica | mp3.play(1) |
| playNext() | Pula para a próxima faixa | mp3.playNext() |
| playPrevious() | Pula para a faixa anterior | mp3.playPrevious() |
| pause() | Pausa a faixa atual | mp3.pause() |
| resume() | Continua a faixa pausada | mp3.resume() |
| stop() | Para a reprodução | mp3.stop() |
Exemplo de Código — Tocar Várias Faixas
Percorre várias faixas, uma de cada vez.
/*
* 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();
}
}
Passos para Testar
- Coloque pelo menos 3 arquivos mp3 no cartão SD.
- Faça o upload do código. As faixas tocam em ciclo com um intervalo de 5 segundos.
Exemplo de Código — Botões de Volume Mais/Menos
Dois botões físicos aumentam e diminuem 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):
* 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
}
}
Passos para Testar
- Ligue dois botões como descrito no código e depois faça o upload.
- Pressione os botões enquanto uma faixa toca. Observe o nível de volume no Serial Monitor.
Referência Rápida de Volume
| Função | Descrição | Código de Exemplo |
|---|---|---|
| setVolume(val) | Define o volume (0 = mudo, 30 = máx.) | mp3.setVolume(20) |
| volumeUp() | Aumenta o volume em 1 | mp3.volumeUp() |
| volumeDown() | Diminui o volume em 1 | mp3.volumeDown() |
| getVolume() | Lê o nível de volume atual | mp3.getVolume() |
Exemplo de Código — Botões Próxima / Anterior
Pule faixas com dois botões.
/*
* 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
}
}
Passos para Testar
- Ligue os botões aos pinos 2 e 3, faça o upload e pressione para pular.
Exemplo de Código — Botão Pausar / Retomar
Um botão alterna entre pausar e retomar.
/*
* 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
}
}
Passos para Testar
- Ligue um botão ao pino 2. Faça o upload e pressione para alternar entre pausar/retomar.
Exemplo de Código — Repetir uma Faixa Para Sempre
Repete uma única faixa em um loop sem fim.
/*
* 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
}
Passos para Testar
- Faça o upload do código. A faixa 1 se repete indefinidamente.
Referência Rápida de Repetição e Aleatório
| Função | Descrição | Código de Exemplo |
|---|---|---|
| loopTrack(track) | Repete uma faixa sem parar | 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 o loop atual | mp3.stopLoop() |
| shuffle() | Reprodução aleatória de todas as faixas | mp3.shuffle() |
Exemplo de Código — Reprodução por Pasta
Selecione e toque faixas de pastas numeradas específicas no 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):
* 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
}
Passos para Testar
- Crie pastas (01, 02) no cartão SD com arquivos mp3 numerados dentro delas.
- Faça o upload do código. Ele toca a pasta 01 e depois a pasta 02.
Referência Rápida de Reprodução por Pasta
| Função | Descrição | Código de Exemplo |
|---|---|---|
| playFolder(f, t) | Toca a faixa t da pasta f (máx. 99 pastas, 255 faixas) | mp3.playFolder(1, 1) |
| playLargeFolder(f, t) | Toca de uma pasta (máx. 15 pastas, 3000 faixas) | mp3.playLargeFolder(1, 500) |
| playFromMP3Folder(t) | Toca da pasta especial /mp3 | mp3.playFromMP3Folder(1) |
Exemplo de Código — Controle Remoto pelo Serial Monitor
Controle a reprodução inteiramente pelo Serial Monitor — ótimo para testes.
/*
* 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;
}
}
}
Passos para Testar
- Faça o upload do código, abra o Serial Monitor a 9600 baud e digite os comandos.
Referência de Comandos
| Digite | O Que Acontece |
|---|---|
| 1–9 | Toca aquele número de faixa |
| + | Aumenta o volume |
| − | Diminui o volume |
| p | Pausa |
| r | Retoma |
| s | Para |
| n | Próxima faixa |
| b | Voltar (faixa anterior) |
| ? | Mostra informações de status |
Presets de EQ
| Constante | Valor | Estilo |
|---|---|---|
| DIYables_MiniMp3::EQ_NORMAL | 0 | Plano |
| 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 | Graves intensos |
mp3.setEQ(DIYables_MiniMp3::EQ_JAZZ);
Lendo o Status do Módulo
Estas chamadas permitem verificar o que o módulo está fazendo. Cada uma bloqueia brevemente (até 100 ms) enquanto espera pela resposta. Retorna −1 se o módulo não responder.
| Função | Retorna | O Que Você Obtém |
|---|---|---|
| isPlaying() | bool | true se o áudio estiver tocando no momento |
| getVolume() | int16_t | Nível de volume (0–30) |
| getEQ() | int16_t | Preset de equalizador ativo (0–5) |
| getTrackCount() | int16_t | Número total de faixas no cartão |
| getCurrentTrack() | int16_t | Número da faixa que está tocando agora |
| getFolderCount() | int16_t | Quantas pastas há no cartão |
| getTrackCountInFolder(f) | int16_t | Quantas faixas há na pasta f |