Diversos dispositivos e máquinas ao nosso redor utilizam o som para gerar efeitos de sinalização ou auxiliar o usuário na execução de alguma atividade.
Entre esses dispositivos, destacamos os brinquedos, porteiro virtual de estacionamentos, caixas de saque de dinheiro e diversos equipamentos.
Para realização dessas tarefas, devemos utilizar dispositivos que sejam capazes de executar um arquivo de som. Portanto, de acordo com o princípio de funcionamento desses dispositivos, aprenderemos nesse artigo, como utilizar o módulo de som MP3 YX5300.
Esse módulo é capaz de executar som MP3 e, a partir dele, podemos conectá-lo em uma caixa de som ou em um headphone. Assim, é possível gerar efeitos sonos, executar vozes e músicas a partir de comandos de controle enviados pelo Arduino.
Portanto, nesse projeto você aprenderá:
- Aplicações do Módulo YX5300;
- Configuração do Módulo YX5300;
- Comandos básicos de controle do módulo;
- Projeto de controle de faixa musical com botões.
A seguir, apresentaremos como esse módulo funciona e um projeto de controle das faixas a partir de 2 botões.
Funcionamento do Módulo YX5300
Conforme citado anteriormente, o projeto consiste em apresentar o funcionamento do Módulo YX5300 e, em seguida, executar um projeto para controle das faixas musicais no cartão SD Card.
Para isto, foi desenvolvido o circuito apresentado na Figura 1. O circuito apresentado na Figura 1 utiliza um Módulo Bluetooth com o objetivo de representar o Módulo YX5300 e seus pinos.
Para compreendermos o funcionamento do Módulo YX5300, necessitaremos dos seguintes componentes e materiais:
Lista de Componentes Eletrônicos
- Protoboard;
- Arduino NANO;
- Módulo MP3 YX5300;
- Conjunto de Jumpers Rígidos;
- Conjunto de Jumpers Flexíveis;
- Botões Pushbuttons;
- Caixa de Som ou Fone de Ouvido com conector macho P2.
A partir da montagem do circuito com os componentes citados acima, dividiremos o circuito em 2 partes importantes:
- O Circuito de controle do Arduino;
- O módulo MP3 YX5300 e a saída de som.
Em seguida, iniciaremos a explicação de cada etapa.
O circuito de controle do Arduino
O Arduino será responsável por enviar comandos via serial para realizar o controle do módulo MP3 YX5300. A Figura 2 apresenta o circuito montado em bancada.
Dessa forma, esse circuito realizará o controle de faixas a partir de 2 botões. Um botão será utilizado para avançar e o outro, para retornar à música anterior.
Além disso, o usuário poderá realizar outros controles a partir da interface serial do Arduino. Assim, você poderá, por meio dela, realizar outros tipos de controle.
Portanto, utilizamos o seguinte código de controle para realizar o controle do dispositivo. O código a seguir pode ser baixado nesse link.
Controle do Modulo Serial MP3 Player Catalex (YX5300 chip)
#include <SoftwareSerial.h>
#define ARDUINO_RX 5 //should connect to TX of the Serial MP3 Player module
#define ARDUINO_TX 6 //connect to RX of the module
SoftwareSerial mp3(ARDUINO_RX, ARDUINO_TX);
static int8_t Send_buf[8] = {0}; //Buffer para enviar comandos para o modulo MP3
static uint8_t ansbuf[10] = {0}; //Buffer para receber a resposta do modulo MP3
String mp3Answer; //String para resposta do modulo MP3
String sanswer(void); //Prototipo de funcao
String sbyte2hex(uint8_t b); //Prototipo de funcao
/************ Command byte **************************/
#define CMD_NEXT_SONG 0X01 // Play next song.
#define CMD_PREV_SONG 0X02 // Play previous song.
#define CMD_PLAY_W_INDEX 0X03
#define CMD_VOLUME_UP 0X04
#define CMD_VOLUME_DOWN 0X05
#define CMD_SET_VOLUME 0X06
#define CMD_SNG_CYCL_PLAY 0X08 // Single Cycle Play.
#define CMD_SEL_DEV 0X09
#define CMD_SLEEP_MODE 0X0A
#define CMD_WAKE_UP 0X0B
#define CMD_RESET 0X0C
#define CMD_PLAY 0X0D
#define CMD_PAUSE 0X0E
#define CMD_PLAY_FOLDER_FILE 0X0F
#define CMD_STOP_PLAY 0X16 // Stop playing continuously.
#define CMD_FOLDER_CYCLE 0X17
#define CMD_SHUFFLE_PLAY 0x18 //
#define CMD_SET_SNGL_CYCL 0X19 // Set single cycle.
#define CMD_SET_DAC 0X1A
#define DAC_ON 0X00
#define DAC_OFF 0X01
#define CMD_PLAY_W_VOL 0X22
#define CMD_PLAYING_N 0x4C
#define CMD_QUERY_STATUS 0x42
#define CMD_QUERY_VOLUME 0x43
#define CMD_QUERY_FLDR_TRACKS 0x4e
#define CMD_QUERY_TOT_TRACKS 0x48
#define CMD_QUERY_FLDR_COUNT 0x4f
/************ Opitons **************************/
#define DEV_TF 0X02
/*********************************************************************/
bool ava_estado = 0, ret_estado = 0;
char c = ' ';
void setup()
{
Serial.begin(9600);
mp3.begin(9600);
delay(500);
pinMode(2, INPUT);
pinMode(3, INPUT);
sendCommand(CMD_SEL_DEV, 0, DEV_TF);
delay(500);
}
void loop()
{
//Se existir um caractere na serial, chama a função sendMP3Command para enviar um comando para o modulo MP3
if ( Serial.available() )
{
c = Serial.read();
sendMP3Command(c);
}
bool ret = digitalRead(3);
bool ava = digitalRead(2);
if(ret == 1 && ret_estado == 0)
{
c = '<';
sendMP3Command(c);
ret_estado = 1;
}
if(ret == 0 && ret_estado == 1)
{
ret_estado = 0;
}
if(ava == 1 && ava_estado == 0)
{
c = '<';
sendMP3Command(c);
ava_estado = 1;
}
if(ava == 0 && ava_estado == 1)
{
ava_estado = 0;
}
// Check for the answer.
if (mp3.available())
{
Serial.println(decodeMP3Answer());
}
delay(100);
//Serial.println("Tocando musica...");
}
/********************************************************************************/
//Menu de controles do Modulo MP3
void sendMP3Command(char c) {
switch (c) {
case '?':
case 'h':
Serial.println("HELP ");
Serial.println(" p = Play");
Serial.println(" P = Pause");
Serial.println(" > = Next");
Serial.println(" < = Previous");
Serial.println(" s = Stop Play");
Serial.println(" + = Volume UP");
Serial.println(" - = Volume DOWN");
Serial.println(" f = Play folder 1.");
Serial.println(" S = Sleep");
Serial.println(" W = Wake up");
Serial.println(" r = Reset");
break;
case 'p':
Serial.println("Play ");
sendCommand(CMD_PLAY);
break;
case 'P':
Serial.println("Pause");
sendCommand(CMD_PAUSE);
break;
case '>':
Serial.println("Next");
sendCommand(CMD_NEXT_SONG);
sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
break;
case '<':
Serial.println("Previous");
sendCommand(CMD_PREV_SONG);
sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
break;
case 's':
Serial.println("Stop Play");
sendCommand(CMD_STOP_PLAY);
break;
case '+':
Serial.println("Volume Up");
sendCommand(CMD_VOLUME_UP);
break;
case '-':
Serial.println("Volume Down");
sendCommand(CMD_VOLUME_DOWN);
break;
case 'f':
Serial.println("Playing folder 1");
sendCommand(CMD_FOLDER_CYCLE, 1, 0);
break;
case 'S':
Serial.println("Sleep");
sendCommand(CMD_SLEEP_MODE);
break;
case 'W':
Serial.println("Wake up");
sendCommand(CMD_WAKE_UP);
break;
case 'r':
Serial.println("Reset");
sendCommand(CMD_RESET);
break;
}
}
//Funcao para decodificar a resposta do modulo MP3
String decodeMP3Answer() {
String decodedMP3Answer = "";
decodedMP3Answer += sanswer();
switch (ansbuf[3]) {
case 0x3A:
decodedMP3Answer += " -> Cartao de Memoria inserido.";
break;
case 0x3D:
decodedMP3Answer += " -> Musica tocada completamente " + String(ansbuf[6], DEC);
break;
case 0x40:
decodedMP3Answer += " -> Erro!";
break;
case 0x41:
decodedMP3Answer += " -> Dados recebidos corretamente. ";
break;
case 0x42:
decodedMP3Answer += " -> Estado de Toque: " + String(ansbuf[6], DEC);
break;
case 0x4C:
decodedMP3Answer += " -> Tocando: " + String(ansbuf[6], DEC);
break;
}
return decodedMP3Answer;
}
/********************************************************************************/
//Funcao para enviar um comando para o modulo MP3
void sendCommand(byte command){
sendCommand(command, 0, 0);
}
void sendCommand(byte command, byte dat1, byte dat2){
delay(20);
Send_buf[0] = 0x7E; //
Send_buf[1] = 0xFF; //
Send_buf[2] = 0x06; // Len
Send_buf[3] = command; //
Send_buf[4] = 0x01; // 0x00 NO, 0x01 feedback
Send_buf[5] = dat1; // datah
Send_buf[6] = dat2; // datal
Send_buf[7] = 0xEF; //
Serial.print("Sending: ");
for (uint8_t i = 0; i < 8; i++)
{
mp3.write(Send_buf[i]) ;
Serial.print(sbyte2hex(Send_buf[i]));
}
Serial.println();
}
/********************************************************************************/
//Funcao para retornar um byte em formato hexadecimal
String sbyte2hex(uint8_t b)
{
String shex;
shex = "0X";
if (b < 16) shex += "0";
shex += String(b, HEX);
shex += " ";
return shex;
}
/********************************************************************************/
//Funcao de conversao de hexadecimal
int shex2int(char *s, int n){
int r = 0;
for (int i=0; i<n; i++){
if(s[i]>='0' && s[i]<='9'){
r *= 16;
r +=s[i]-'0';
}else if(s[i]>='A' && s[i]<='F'){
r *= 16;
r += (s[i] - 'A') + 10;
}
}
return r;
}
/********************************************************************************/
//Funcao que retorna uma string como resposta do módulo MP3
String sanswer(void)
{
uint8_t i = 0;
String mp3answer = "";
// Get only 10 Bytes
while (mp3.available() && (i < 10))
{
uint8_t b = mp3.read();
ansbuf[i] = b;
i++;
mp3answer += sbyte2hex(b);
}
// if the answer format is correct.
if ((ansbuf[0] == 0x7E) && (ansbuf[9] == 0xEF))
{
return mp3answer;
}
return "???: " + mp3answer;
}
O código apresentado é simples e, em seguida, apresentaremos o passo a passo do circuito de controle.
Envio de comandos para o Módulo MP3 Player
Primeiramente, foi definida a biblioteca para emular uma serial para o controle do módulo e a definição dos respectivos endereços de controle do módulo MP3. Portanto, cada endereço é definido como um comando de controle do módulo MP3.
Essas configurações são apresentadas no bloco de código a seguir.
//Controle do Modulo Serial MP3 Player Catalex (YX5300 chip)
#include <SoftwareSerial.h>
#define ARDUINO_RX 5 //should connect to TX of the Serial MP3 Player module
#define ARDUINO_TX 6 //connect to RX of the module
SoftwareSerial mp3(ARDUINO_RX, ARDUINO_TX);
static int8_t Send_buf[8] = {0}; //Buffer para enviar comandos para o modulo MP3
static uint8_t ansbuf[10] = {0}; //Buffer para receber a resposta do modulo MP3
String mp3Answer; //String para resposta do modulo MP3
String sanswer(void); //Prototipo de funcao
String sbyte2hex(uint8_t b); //Prototipo de funcao
/************ Command byte **************************/
#define CMD_NEXT_SONG 0X01 // Play next song.
#define CMD_PREV_SONG 0X02 // Play previous song.
#define CMD_PLAY_W_INDEX 0X03
#define CMD_VOLUME_UP 0X04
#define CMD_VOLUME_DOWN 0X05
#define CMD_SET_VOLUME 0X06
#define CMD_SNG_CYCL_PLAY 0X08 // Single Cycle Play.
#define CMD_SEL_DEV 0X09
#define CMD_SLEEP_MODE 0X0A
#define CMD_WAKE_UP 0X0B
#define CMD_RESET 0X0C
#define CMD_PLAY 0X0D
#define CMD_PAUSE 0X0E
#define CMD_PLAY_FOLDER_FILE 0X0F
#define CMD_STOP_PLAY 0X16 // Stop playing continuously.
#define CMD_FOLDER_CYCLE 0X17
#define CMD_SHUFFLE_PLAY 0x18 //
#define CMD_SET_SNGL_CYCL 0X19 // Set single cycle.
#define CMD_SET_DAC 0X1A
#define DAC_ON 0X00
#define DAC_OFF 0X01
#define CMD_PLAY_W_VOL 0X22
#define CMD_PLAYING_N 0x4C
#define CMD_QUERY_STATUS 0x42
#define CMD_QUERY_VOLUME 0x43
#define CMD_QUERY_FLDR_TRACKS 0x4e
#define CMD_QUERY_TOT_TRACKS 0x48
#define CMD_QUERY_FLDR_COUNT 0x4f
/************ Opitons **************************/
#define DEV_TF 0X02
/*********************************************************************/
bool ava_estado = 0, ret_estado = 0;
char c = ' ';
Após isto, temos as duas funções principais de controle: a void setup e a função void loop. Portanto, a partir dessas duas funções explicaremos o passo a passo de controle.
void setup()
{
Serial.begin(9600);
mp3.begin(9600);
delay(500);
pinMode(2, INPUT);
pinMode(3, INPUT);
sendCommand(CMD_SEL_DEV, 0, DEV_TF);
delay(500);
}
void loop()
{
//Se existir um caractere na serial, chama a função sendMP3Command para enviar um comando para o modulo MP3
if ( Serial.available() )
{
c = Serial.read();
sendMP3Command(c);
}
bool ret = digitalRead(3);
bool ava = digitalRead(2);
if(ret == 1 && ret_estado == 0)
{
c = '<';
sendMP3Command(c);
ret_estado = 1;
}
if(ret == 0 && ret_estado == 1)
{
ret_estado = 0;
}
if(ava == 1 && ava_estado == 0)
{
c = '<';
sendMP3Command(c);
ava_estado = 1;
}
if(ava == 0 && ava_estado == 1)
{
ava_estado = 0;
}
// Check for the answer.
if (mp3.available())
{
Serial.println(decodeMP3Answer());
}
delay(100);
//Serial.println("Tocando musica...");
}
Desse modo, analisaremos inicialmente a função setup. Primeiramente, foram inicializadas as duas comunicações seriais: a comunicação entre o Arduino e o Computador e a comunicação entre o Arduino e o Módulo MP3.
Em seguida, os pinos digitais de conexão dos botões foram configurados como entradas digitais e seleciona a dispositivo de leitura.
Por fim, o programa aguarda 500 ms para configuração e entra na função loop.
A princípio, no início da função loop é feita a verificação se há a chegada de caracteres na serial do Arduino. Esses caracteres são provenientes do PC.
Esses caracteres serão lidos, armazenados na variável “c” e enviados para o módulo MP3 através da função sendMP3Command. Essa função é responsável por enviar os comandos via emulação serial para o Módulo MP3 Player.
Além disso, temos a leitura dos dois botões, conforme apresentado no bloco de código a seguir. Cada botão é utilizado para avançar ou voltar para a faixa musical anterior.
bool ret = digitalRead(3);
bool ava = digitalRead(2);
if(ret == 1 && ret_estado == 0)
{
c = '<';
sendMP3Command(c);
ret_estado = 1;
}
if(ret == 0 && ret_estado == 1)
{
ret_estado = 0;
}
if(ava == 1 && ava_estado == 0)
{
c = '<';
sendMP3Command(c);
ava_estado = 1;
}
if(ava == 0 && ava_estado == 1)
{
ava_estado = 0;
}
Portanto, conforme é possível observar no código acima, quando o botão conectado no pino digital 3 é pressionado, é enviado o caractere ‘<‘ pela serial emulada para o Módulo MP3 YX5300. Dessa forma, voltaremos para a faixa anterior.
Entretanto, caso o botão conectado no pino digital 2 seja pressionado, enviaremos o caractere ‘>’ para avançar para a próxima faixa. Esses caracteres de controle são enviados através da função sendMP3Command.
De acordo com essa função, existem diversos comandos que podem ser utilizados para controlar o módulo MP3 YX5300.
A lista de comandos será apresentada a seguir.
A Lista de comandos para controle do Módulo MP3 Player
A lista de comandos pode ser vista ao enviar o caractere h pela serial. Em seguida, todos os caracteres de comandos serão apresentados no monitor serial, conforme apresentado na porção de código abaixo.
Portanto, a partir da lista abaixo, o usuário poderá dar play, parar a música, avançar, retornar, controlar volume, execução de pastas e muitas outras funcionalidades, conforme apresentadas em seguida.
void sendMP3Command(char c) {
switch (c) {
case '?':
case 'h':
Serial.println("HELP ");
Serial.println(" p = Play");
Serial.println(" P = Pause");
Serial.println(" > = Next");
Serial.println(" < = Previous");
Serial.println(" s = Stop Play");
Serial.println(" + = Volume UP");
Serial.println(" - = Volume DOWN");
Serial.println(" c = Query current file");
Serial.println(" q = Query status");
Serial.println(" v = Query volume");
Serial.println(" x = Query folder count");
Serial.println(" t = Query total file count");
Serial.println(" f = Play folder 1.");
Serial.println(" S = Sleep");
Serial.println(" W = Wake up");
Serial.println(" r = Reset");
break;
case 'p':
Serial.println("Play ");
sendCommand(CMD_PLAY);
break;
case 'P':
Serial.println("Pause");
sendCommand(CMD_PAUSE);
break;
case '>':
Serial.println("Next");
sendCommand(CMD_NEXT_SONG);
sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
break;
case '<':
Serial.println("Previous");
sendCommand(CMD_PREV_SONG);
sendCommand(CMD_PLAYING_N); // ask for the number of file is playing
break;
case 's':
Serial.println("Stop Play");
sendCommand(CMD_STOP_PLAY);
break;
case '+':
Serial.println("Volume Up");
sendCommand(CMD_VOLUME_UP);
break;
case '-':
Serial.println("Volume Down");
sendCommand(CMD_VOLUME_DOWN);
break;
case 'c':
Serial.println("Query current file");
sendCommand(CMD_PLAYING_N);
break;
case 'q':
Serial.println("Query status");
sendCommand(CMD_QUERY_STATUS);
break;
case 'v':
Serial.println("Query volume");
sendCommand(CMD_QUERY_VOLUME);
break;
case 'x':
Serial.println("Query folder count");
sendCommand(CMD_QUERY_FLDR_COUNT);
break;
case 't':
Serial.println("Query total file count");
sendCommand(CMD_QUERY_TOT_TRACKS);
break;
case 'f':
Serial.println("Playing folder 1");
sendCommand(CMD_FOLDER_CYCLE, 1, 0);
break;
case 'S':
Serial.println("Sleep");
sendCommand(CMD_SLEEP_MODE);
break;
case 'W':
Serial.println("Wake up");
sendCommand(CMD_WAKE_UP);
break;
case 'r':
Serial.println("Reset");
sendCommand(CMD_RESET);
break;
}
}
Após a letra selecionada, o programa entra no switch, envia o comando para o Módulo MP3 player e ele executará com base em nossa escolha.
Dessa forma, os comandos acima são relacionados pela definição de dados hexadecimais que serão enviados como parâmetros na função.
Isto pode ser visto no bloco de código a seguir.
************ Command byte **************************/ #define CMD_NEXT_SONG 0X01 // Play next song. #define CMD_PREV_SONG 0X02 // Play previous song. #define CMD_PLAY_W_INDEX 0X03 #define CMD_VOLUME_UP 0X04 #define CMD_VOLUME_DOWN 0X05 #define CMD_SET_VOLUME 0X06 #define CMD_SNG_CYCL_PLAY 0X08 // Single Cycle Play. #define CMD_SEL_DEV 0X09 #define CMD_SLEEP_MODE 0X0A #define CMD_WAKE_UP 0X0B #define CMD_RESET 0X0C #define CMD_PLAY 0X0D #define CMD_PAUSE 0X0E #define CMD_PLAY_FOLDER_FILE 0X0F #define CMD_STOP_PLAY 0X16 // Stop playing continuously. #define CMD_FOLDER_CYCLE 0X17 #define CMD_SHUFFLE_PLAY 0x18 // #define CMD_SET_SNGL_CYCL 0X19 // Set single cycle. #define CMD_SET_DAC 0X1A #define DAC_ON 0X00 #define DAC_OFF 0X01 #define CMD_PLAY_W_VOL 0X22 #define CMD_PLAYING_N 0x4C #define CMD_QUERY_STATUS 0x42 #define CMD_QUERY_VOLUME 0x43 #define CMD_QUERY_FLDR_TRACKS 0x4e #define CMD_QUERY_TOT_TRACKS 0x48 #define CMD_QUERY_FLDR_COUNT 0x4f
Por fim, a partir do comando recebido, o Módulo MP3 controlará a faixa a ser tocada no cartão de memória inserido e a caixa de som irá executar a faixa musical. O circuito é apresentado na Figura 3.
Além disso, toda vez que uma função é enviada, será retornado o pacote de informações enviadas e recebidas na serial do Arduino.
Assim, essas informações são úteis para você saber se os dados estão sendo enviados e recebidos corretamente pelo CHIP do módulo MP3.
Funções de Controle e Retorno de Estado do módulo
Primeiramente, essas duas funções são utilizadas para o controle das faixas e recepção do estado de funcionamento do módulo MP3.
Dessa forma, apresentaremos a seguir a função para enviar os comandos ao módulo MP3. Ela é responsável por montar um pacote de dados de 8 bits e enviar para o módulo.
Todas essas informações são responsáveis pelo controle e podem ser entendidas em detalhes no datasheet do dispositivo.
sendCommand(byte command, byte dat1, byte dat2){
delay(20);
Send_buf[0] = 0x7E; //
Send_buf[1] = 0xFF; //
Send_buf[2] = 0x06; // Len
Send_buf[3] = command; //
Send_buf[4] = 0x01; // 0x00 NO, 0x01 feedback
Send_buf[5] = dat1; // datah
Send_buf[6] = dat2; // datal
Send_buf[7] = 0xEF; //
Serial.print("Sending: ");
for (uint8_t i = 0; i < 8; i++)
{
mp3.write(Send_buf[i]) ;
Serial.print(sbyte2hex(Send_buf[i]));
}
Serial.println();
}
Após a execução dessa função, os dados são enviados para o módulo e em seguida, são convertidos para hexadecimal e apresentados na serial. Isto ocorre para que o usuário possa ver os dados enviados ao módulo.
Após o envio do comando de controle, o programa ficará em loop aguardando a recepção de dados de estado do módulo para o Arduino.
Caso algum dado seja recebido, a função a seguir irá tratar e exibir uma mensagem no monitor serial. Essa mensagem apresentará o estado de funcionamento do módulo MP3.
//Funcao para decodificar a resposta do modulo MP3
String decodeMP3Answer() {
String decodedMP3Answer = "";
decodedMP3Answer += sanswer();
switch (ansbuf[3]) {
case 0x3A:
decodedMP3Answer += " -> Cartao de Memoria inserido.";
break;
case 0x3D:
decodedMP3Answer += " -> Musica tocada completamente " + String(ansbuf[6], DEC);
break;
case 0x40:
decodedMP3Answer += " -> Erro!";
break;
case 0x41:
decodedMP3Answer += " -> Dados recebidos corretamente. ";
break;
case 0x42:
decodedMP3Answer += " -> Estado de Toque: " + String(ansbuf[6], DEC);
break;
case 0x4C:
decodedMP3Answer += " -> Tocando: " + String(ansbuf[6], DEC);
break;
}
return decodedMP3Answer;
}
Conforme é possível observar acima, temos uma função que receberá uma string e testará qual o valor retornado. Para cada valor recebido, conseguiremos saber qual o funcionamento atual do módulo.
Dessa forma, por exemplo, se o valor recebido for 0x3D, saberemos quando o arquivo MP3 foi finalizado. Além dele, temos a informação que o cartão foi inserido, o estado de toque, confirmação de dados de controle recebidos pelo módulo e muito mais.
Portanto, a partir de todas essas funções, conseguiremos determinar o controle das faixas MP3 e conhecer o estado de execução do nosso dispositivo.
Entretanto, precisamos compreender como os arquivos devem ser organizados no cartão de memória, para que o módulo execute-os de forma correta.
Organizando os arquivos MP3 YX5300 no cartão de memória
Para organizar os arquivos no cartão de memória, você deverá executar os seguintes passos:
- Formate o cartão em formato FAT16 ou FAT32;
- Crie pastas com números nos seguintes formatos de nome: 01, 02, 03, etc;
- Coloque o nome dos arquivos começando com 001, 002,003,etc;
Após isto, suas faixas MP3 estarão prontas para serem executadas em seu projeto.
Conclusão
Portanto, a partir do projeto apresentado foi possível compreender a estrutura de ligação do circuito, o processo de programação e controle das funcionalidades internas do Módulo MP3 YX5300.
Além disso, o módulo MP3 possui uma vantagem de uso em relação a outros módulos do mercado, pois ele possui uma saída para conector P2, o que lhe permite ser conectado em qualquer caixa de som ou fone de ouvido.
Dessa forma, evita-se o uso ou instalação de auto-falantes externos.
Portanto, a partir desse projeto, é possível desenvolver novas aplicações que necessitem do uso de sons e toques musicais.
Caso queira continuar aprendendo, acesse os artigos do blog e leia outros assuntos sobre o Arduino.