Bem-vindo!

Agradecemos por ter adquirido o módulo AZ-Delivery MP3 DFPlayer.

Nas páginas que se seguem, iremos explicar como usar e
configurer cet appareil pratique.

Divirtam-se!
O módulo MP3 DFPlayer Mini é um pequeno e acessível leitor de MP3 com
uma saída direta em um alto-falante ou fone de ouvido. O módulo pode ser
usado como um módulo autônomo com uma bateria, um alto-falante e
botões de pressão ou usados em combinação com um cartão Arduino ou
todas as outras placas com capacidades UART.

O módulo suporta formatos de áudio comuns como MP3, WAV

e WMA. Ele suporta cartões MicroSD com o sistema de arquivos
FAT16 ou FAT32. Você pode ouvir música através de uma porta simples
série sem nenhuma operação complexa.

O módulo é fornecido com dois conectores machos de 8 pinos pré-soldados,

ele tem um slot para um cartão de memória MicroSD. Há
também uma LED vermelha embutida usada para indicar o status de
leitura das peças. O LED está conectado ao pino BUSY do módulo.
O estado aceso do LED indica que uma peça está sendo reproduzida.
Especificação:

» Tension d’alimentation de 3.2V a 5V DC

» Corrente de vigilância 20mA20mA
» Temperatura de utilização de -40℃ a 70℃
» Porta USART Padrão (Nível TTL)
» Velocidade defeito 9600bps, ajustável
» Equalizador 6 modos, ajustáveis
» Volume 30 níveis, ajustáveis
» Taxa de amostragem (kHz) 8/11.025/12/16/22/24/32/44.1/4848
» Saída - 24 bits DAC para 90dB,
- SNR pour 85dB
» Potência de saída 3W
» Impedância HP 3Ω (máximo 8Ω)
» Sistema de arquivos FAT16 ou FAT32
» Taille maximum - 32GB em SDcard,
32GB em memória USB
- 64MB bytes NORFLASH
» Tipos de controle - Interface I/O
Porta Série
- Botão AD
» Função de espera do somINFOS(a música pode ser
suspendida, quando a INFOS está terminada a música continua a
jogar
» Dados de áudio organizados em pastas. O módulo suporta
até 100 pastas e cada pasta pode conter até 255
pedacinhos.
 Brochagem

As broches USART (UART) são usadas para comunicação serial.

Se você encontrar um ruído alto, conecte uma resistência de 1kΩ ao
brocheTX em série.

Os pinos do canal de saída de áudio são usados como pinos DAC

(Conversor Digital para Analógico), e você deve conectá-los ao amplificador
externo.

Os pinos do alto-falante são pinos do amplificador de 3W

embarcou, e você pode conectá-los diretamente ao alto-falante
externe (8Ω máx).

As broches ADKEY são utilizadas para o modo de controle AD.

Os pinos do portTRIGGER são usados para ajustar os níveis de

volume ou para mudar de faixa (material). Esses pinos estão ativos
BAIXO.

As pinos USB são utilizados para a conexão da memória USB.

 Alimentação e broche BUSY

O módulo suporta uma faixa de tensão de funcionamento de 3,2V a

5V CC. Conecte uma fonte de alimentação entre o pino de alimentação
e o pino de terra (GND).

A tensão do nível lógico TTL da porta serial do módulo é de 3,3V.

então, quando você usa níveis de 5V (por exemplo, a placa Uno)
conecte em série uma resistência de mais de 1kΩ ao pino RX
módulo. Se você não usar esta resistência, terá um ruído alto
nos canais de saída de áudio.

A broche de estado de leitura ou BUSY é utilizada para indicar o estado de

leitura de um pedaço. O estado LOW nesse pino indica que o módulo
está lendo um pedaço, e o estado HIGH indica que o módulo não lê
nenhum pedaço.
 Canais de saída de áudio e pinos de alto-falante

A chip principal do módulo é um conversor digital-analógico

24 bits (DAC). A chip possui dois pinos DAC que estão conectados
diretamente aos canais de saída de áudio do módulo. Você deve conectar
um amplificador externo nos pinos dos canais de saída de áudio para
de usar as capacidades DAC do módulo. Se você quiser usar esses pinos,
active primeiro a saída DAC enviando o comando correspondente para
a pulga (mais adiante no texto).

Um circuito de amplificação de 3W está integrado ao módulo. O núcleo deste

circuit é um dispositivo chamado "amplificador de áudio 8002", um circuito integrado
(CI) a 8 pinos cuja saída está conectada aos pinos Speaker+ e
O saída do CI 8002 é mono.

Conecte o alto-falante externo ao módulo conforme indicado neste

schéma de connexion :
 Portas de TRIGGER de acionamento (pinos IO)

Essas broches são usadas para a comutação das peças e o ajuste

níveis de volume através do hardware. Conecte botões de pressão a
esses broches como indicado neste diagrama:

Quando o botão de pressão está em estado de repouso, os pinos diagonais do

os botões de pressão não estão conectados. Quando você pressiona o
botão de pressão, esses pinos estão conectados, o que ativa o botão
pulsor em um estado ativo.

Uma pressão curta no botão pressionador IO2 permite ler o trecho

seguinte. Uma pressão longa no botão pushover IO2 aumenta o
nível do volume.

Uma pressão curta no botão de pressão IO1 permite ler o trecho

anterior. Uma pressão longa no botão de pressão IO2 diminui o
nível do volume.

A duração da pressão longa é superior a um segundo. Tudo o que

é inferior a um segundo é considerado um impulso curto.
 Broches ADKEY

A funcionalidade AD do chip embutido no módulo permite que você

conectar 20 resistências com botões em duas portas AD do módulo
como indicado neste diagrama de conexão:

NOTA: É necessário que a alimentação seja o mais estável possível

para que isso funcione corretamente!

Uma breve pressão no botão Play Mode faz a reprodução mudar para o modo
interrompu ou ininterrompu. Cela signifie que la lecture sera ou ne sera pas
interrompido por uma INFOS. Não há função de pressão longa
para este botão.

Uma breve pressão no botão U/TF/SPI faz passar o dispositivo de

leitura de um dos seguintes elementos: U= pen drive, TF= cartão SD,
SPI= NORFLASH ou Sleep. Não há função de pressão longa.
para este botão.
Uma pressão breve no botão Loop All permite alternar entre o modo de
leitura em loop de uma música à leitura em loop de todas as músicas
ou de não os ler em loop. Não há função de pressão longa
para este botão.

Uma breve pressão no botão Pausar/Reproduzir pausa ou reproduz o

morceau selecionado. Não há função de pressão longa para isso
botão.

Uma pressão curta no botão Pre/Vol+ permite passar para a música

anterior. Uma pressão longa no botão Pre/Vol+ aumenta o nível
do volume.

Uma pressão curta no botão Next/Vol permite passar para a música

seguinte. Uma pressão longa no botão Pre/Vol+ diminui o nível do
volume.

Uma pressão curta no botão Segmento1 permite tocar a música.

número 1. Uma pressão longa no botão Segmento1 repete a leitura
da mesma canção.

As funções são as mesmas para todos os outros botões de segmento, exceto

pour le numéro de chanson qui diffère.
 Porta Série

As broches RX e TX são usadas para estabelecer uma comunicação serial

com um microcontrolador externo. Não se esqueça de conectar uma resistência
à la brocheRXlorsque vous utilisez une logiqueTTL 5V. Le port série du
o módulo suporta o modo de comunicação série assíncrona. A taxa de transmissão em

A taxa de bauds padrão da comunicação serial é de 9600 bps e é

ajustável por software.

Você pode usar a porta serial para enviar comandos simples ao

módulo e assim controlar muitas funções suportadas pelo
módulo. Você saberá mais sobre os comandos no próximo capítulo.

Especificações

Taux de bauds 9600bps

Bit de dados 1
Finalizar compra não
Controle do fluxo não
 Formato dos pedidos

Para enviar um comando ao módulo, siga o formato específico:

$SB VB LB CMD ACK DATA1 DATA2 CHKS1 CHKS2 $EB

Nome Octeto Descrição de octeto

$SB 0x7E Octeto de início
VB octeto da versão 0xFF
LB 0xxxLe nombre d ’octets de la commande sans
octetos de início e de fim (No nosso caso, 0x06)
CMD 0xxxComo JOGAR, PAUSAR, etc.
ACK 0xxxACK0x00= NON,0x01= OUI
DADOS1 0xxxOcteto de dados alto
DADOS2 0xxxOcteto de dados baixo
CHKS1 0xxxOcteto ALTO da soma de verificação
CHKS2 0xxxOctet BAS da soma de verificação
$EB 0xEF Octeto de fim

O octeto ACK é usado para obter dados do módulo. Se estiver definido para
0x00, nenhum dado será enviado pelo módulo e se estiver definido para
0x01, você receberá dados de resposta do módulo. O comprimento dos
os dados não são limitados, mas geralmente são de dois bytes
(octetosdados1edados2).

Para enviar um comando específico, basta enviar um byte por

octeto em série na interface serial do software (você pode ver isso mais adiante
no código).
 Estrutura das pastas e nomes das músicas

O módulo suporta vários tipos de pastas e nomes

específicos para os pedaços. Os nomes das pastas são números, para
a exceção das pastas “mp3” e “ADVERT”. Os nomes das músicas
devem começar com um número seguido pela sequência de
caracteres sem espaço. Exemplo de nome de peça :
0001_Linking_Park_No_Fim.mp3

Existem cinco tipos de arquivos:

O primeiro pode conter 256 pedaços. O módulo suporta 256 de

esses dossiês no total. Os nomes desses dossiês são números compreendidos
entre 000 e 255. Os nomes das peças nestas pastas começam
por números entre 000 e 255. O módulo não leva em conta
carregar os subdiretórios.

O segundo pode conter 3000 peças. O módulo suporta 16 de

esses arquivos ao todo. Os nomes desses arquivos são números compreendidos
entre 00 e 15. Os nomes das músicas nessas pastas começam com
de números compreendidos entre 0000 e 2999. O módulo não leva em consideração

carregue as subpastas.

O terceiro é chamado de “mp3” e ele também pode conter 3000 faixas.

O módulo suporta apenas uma pasta "mp3" no total. Os nomes dos
morceaux neste dossiê começam com números entre
0000 e 2999. O módulo não suporta subpastas.
O quarto é chamado de “ADVERT”, que também pode conter 3000
morceaux e que é utilizado para INFOS. O módulo suporta um único
dossiê "ADVERT" ao todo. Os nomes dos arquivos neste dossiê
começando com números entre 0000 e 2999. O módulo não
não suporta subpastas.

Finalmente, o quinto é a pasta raiz “root”. Se for a única pasta de

o cartão SD ou a unidade USB (nenhuma outra pasta), esta pasta pode conter
até 65 536 partes. Esta pasta pode ter subpastas, y
compreende todos os tipos de pastas. A pasta "root" pode conter
canções e subpastas ao mesmo tempo.

Exemplo de estrutura de pasta :

raiz
---0001r.mp3
---0002r.mp3
---0003r.mp3
---0004r.mp3
---0001
--- ---0001x.mp3
--- ---0002x.mp3
---0002
--- ---0001y.mp3
---mp3
--- ---0001m.mp3
--- ---0002m.mp3
--- ---0003m.mp3
---ANÚNCIO
--- ---0001a.mp3
--- ---0002a.mp3
 Envio de comandos ao módulo

Para enviar comandos ao módulo, conecte o módulo com

o Arduino Uno conforme indicado no diagrama de conexão abaixo:

Módulo > Um
VCC > 5V Vermelho
RX > D7 (via une résistance de 1kΩ) Bleu
TX > D6 Vertical
GND > GND Noir

Module > Alto-falante

SPK - > Broche - do alto-falante Violeta
SPK+ > Broche + do alto-falante Violet

NOTA: Você pode usar qualquer outro cartão com um

microcontrolador que tem capacidades UART.
Utilizamos a interface de software serial nos pinos de I/O digitais 6
e 7 do Uno, pois o Uno utiliza os pinos seriais de hardware (pinos de E/S
números 0 e 1), para a programação do microcontrolador principal.

Le microcontrôleur ne peut pas envoyer de commandes pour contrôler le

módulo enquanto a inicialização do módulo não estiver concluída e que os
informaçōes de status não são retornadas. Caso contrário, os pedidos
enviadas pelo microcontrolador serão ignoradas e isso afetará o
processo de inicialização.
Se não for indicado de outra forma (enviando um comando após
a inicialização), quando o módulo é energizado, ele primeiro lê o cartão
SD e se não estiver disponível, ele passa para a memória USB.
Exemplo de código

#include "SoftwareSerial.h"
#defineInício_Byte 0x7E
#define Version_Byte 0xFF
#define Command_Length 0x06
#define End_Byte 0xEF
// Retorna info com o comando 0x41 [0x01: info, 0x00: sem info]
#define Acknowledge 0x01
SoftwareSerial mySerial(6, 7);// RX, TX
byte receive_buffer[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
char data;// Usado para comandos recebidos do Monitor Serial
byte volume = 0x00;// Usado para armazenar o nível de volume atual
bool mute_state =false;// Used to toggle mute state

// Execute o comando e os parâmetros

void executar_CMD(byte Comando, byte Dados1, byte Dados2) {
// Calcular o checksum (2 bytes)
soma de verificação = - ( Byte_Versão + Comprimento_Comando + Comando +
Reconhecer + Dados1 + Dados2);
// Construir o comando
byte comando_linha[10] = { Iniciar_Baquete, Versão_Baquete,
Command_Length, Command, Acknowledge,
Dados1, Dados2, byteAlto(Checksum),
lowByte(Checksum), End_Byte};
// Envie a linha de comando para o módulo
for(byte k = 0; k < 10; k++) {
[Link](command_line[k]);
}
}
void reset_rec_buf() {
para(uint8_t i = 0; i < 10; i++) {
receive_buffer[i] = 0;
}
}

bool receber() {
reiniciar_buf_rec();
se([Link]() < 10) {
retornar falso
}
for(uint8_t i = 0; i < 10; i++) {
curto b = [Link]();
se(b == -1) {
retornar falso
}
receive_buffer[i] = b;
}
Quando você reiniciar o módulo no software,
// os elementos do buffer recebidos são deslocados.
// Para corrigir isso, fazemos o seguinte:
short b = receive_buffer[0];
for(uint8_t i = 0; i < 10; i++) {
se(i == 9) {
receive_buffer[i] = b;
}
senão {
receive_buffer[i] = receive_buffer[i+1];
}
} // Fim da correção do buffer_receber
retornar verdadeiro;
}
void imprimir_recebido(bool imprimir) {
se(print_it) {
se(receber()) {
para(uint8_t i = 0; i < 10; i++) {
[Link](receive_buffer[i],HEX);[Link]("\t");
}
[Link]();
 }
}
senão { receber(); }
}
void module_init() {
execute_CMD(0x0C, 0, 0); delay(1000);// Reiniciar o módulo
imprimir_recebido(falso);atrasar(100);
[Link]("SDON\t");
imprimir_recebido(true);atrasar(100);
jogarPrimeiro();
definirVolume(0x09);
}
void jogar_primeiro() {
[Link]("PLYFST\t");
execute_CMD(0x03, 0, 1); delay(100); // Tocar a primeira música
imprimir_recebido(falso); atrasar(100);
execute_CMD(0x45, 0, 0); delay(100);// Obter status de reprodução
imprimir_recebido(falso);atrasar(100);
imprimir_recebido(true); atrasar(100);
}
void set_volume(uint8_t volume) {
[Link]("SETVOL\t");
execute_CMD(0x06, 0, volume); delay(100);// Definir nível de volume
imprimir_recebido(false);atraso(100);
execute_CMD(0x43, 0, 0); delay(100);// Obter nível de volume
imprimir_recebido(falso);delay(100);
imprimir_recebido(true);atraso(100);
}
void reproduzir_proximo() {
[Link]("PRÓXIMO\t");
execute_CMD(0x01, 0, 0); delay(100);
imprimir_recebido(falso);atraso(100);
execute_CMD(0x4C, 0, 0); delay(100);// Obter a música atual tocando
imprimir_recebido(falso);atrasar(100);
print_received(true);delay(100);
}
void silenciar() {
mute_state = !mute_state;
se(mudo_estado) {
execute_CMD(0x43, 0, 0); delay(100);// Retornar nível de volume
imprimir_recebido(falso);tempo(100);
imprimir_recebido(falso);delay(100);
volume = receive_buffer[6];
[Link]("MUDO\t");
execute_CMD(0x06, 0, 0x00); delay(100);// Definir nível de volume
print_received(falso);delay(100);
execute_CMD(0x43, 0, 0); delay(100);// Obter nível de volume
imprimir_recebido(falso);delay(100);
imprimir_recebido(true); atraso(100);
}
// uma aba
senão {
[Link]("VOL\t");
execute_CMD(0x06, 0, volume); delay(100);// Definir volume anterior
imprimir_recebido(falso);atraso(100);
execute_CMD(0x43, 0, 0); delay(100);// Obter nível de volume
imprimir_recebido(falso);atraso(100);
print_recebido(true);delay(100);
}
}

void jogar_aleatorio() {
// Aleatório toca todas as músicas, repete todas, repete as músicas na reprodução
execute_CMD(0x18, 0, 0);
atraso(100);
[Link]("RNDM ");
imprimir_recebido(falso);
atraso(100);
execute_CMD(0x4C, 0, 0); // Obter a música atual tocada
atraso(100);
print_received(falso);
atraso(100);
imprimir_recebido(true);
atraso(100);
}
void query_status() {
execute_CMD(0x42, 0, 0); delay(100);// Obter status do módulo
imprimir_recebido(falso); atraso(100);
[Link]("STATUS\t");
imprimir_recebidos(verdadeiro);atraso(100);
execute_CMD(0x43, 0, 0); delay(100);// Obter nível de volume
imprimir_recebido(falso);atrasar(100);
[Link]("VOLUME\t");
print_received(true);delay(100);
execute_CMD(0x44, 0, 0); delay(100);// Obter status do EQ
imprimir_recebido(falso);atraso(100);
[Link]("EQ\t");
imprimir_recebidos(true);delay(100);
execute_CMD(0x45, 0, 0); delay(100);// Obter status de reprodução
imprimir_recebido(falso);atraso(100);
[Link]("PLYBCK\t");
imprimir_recebido(true);delay(100);
execute_CMD(0x46, 0, 0); delay(100);// Obter versão do software
imprimir_recebido(falso);delayed(100);
[Link]("SFVER\t");
imprimir_recebido(true);atrasar(100);
// Obter o número total de arquivos no dispositivo de armazenamento
execute_CMD(0x48, 0, 0); delay(100);
imprimir_recebido(falso);delay(100);
[Link]("ARQUIVOS\t");
imprimir_recebido(true); atrasar(100);
execute_CMD(0x4C, 0, 0); delay(100);// Obter a música atual tocada
imprimir_recebido(falso);atraso(100);
[Link]("CRRTRK\t");
imprimir_recebido(verdadeiro);atrasar(100);
}
vazio configurar() {
[Link](115200);
[Link](9600);delay(1000);

Inicialização
module_init();
}
vazio loop() {
imprimir_recebido(true);

enquanto([Link]ível() > 0) {
dados = [Link]();
// [Link](data, HEX); // Para depuração
se(data !="/n") {
se(dados =='N') {
Tocar a próxima música
jogar_próximo();
}
senão se(dados == 'B') {
Reprodução aleatória
jogar_aleatório();
}
// .....
senão se(dado =='D') {
Consulta o status do módulo
status_da_consulta();
}
}
}
atraso(100);
}
O código começa incluindo uma biblioteca chamada
SoftwareSerial.h

Em seguida, definimos cinco macros. Essas macros representam os bytes

de comando que são os mesmos para todos os pedidos. O primeiro
o octeto é chamado de "Start_Byte" cujo valor é 0x7E, o segundo octeto é
chamado "Version_Byte" cujo valor é 0xFF, o terceiro octeto é
chamado "Comprimento_Comando" cujo valor é 0x06, o quarto octeto é
chamado "End_Byte" cujo valor é 0xEF e o quinto octeto é chamado
"Reconhecer" com o valor 0x01.

Em seguida, definimos o objeto de software série chamado "mySerial" com este

linha de código: SoftwareSerial mySerial(6, 7);
Onde representa o pino I/O digital do Uno no qual o pino RX
o módulo está conectado e representa o pino de entrada/saída digital do Uno
na qual a brocheTX do módulo está conectada.

Em seguida, criamos um array chamado "receive_buffer", que contém dez

elementos. Os elementos da tabela "receive_buffer" representam os bytes
que são enviados pelo módulo e recebidos pela Uno.

Depois disso, criamos três variáveis. A primeira é chamada de "data" e

ela é usada para armazenar os pedidos quando os enviamos
desde o monitor serial. A segunda variável é chamada de “volume” e ela
é utilizada para armazenar o nível de volume atual, quando enviamos
a comando "Silenciar". A terceira variável é chamada "estado_de_silêncio" e ela
é utilizada para alternar o estado silencioso do módulo.
Em seguida, criamos várias funções. A primeira função chama-se
"execute_CMD()" que aceita três argumentos e não retorna nenhum valor.
La fonctionexecute_CMD()est utilisée pour envoyer des commandes au
módulo. O primeiro argumento é o byte de comando, o segundo é
o octeto de dados 1 e o terceiro é o octeto de dados 2 da
comando. No início da função execute_CMD() calculamos os
octetos de verificação com esta linha de código:

palavra soma_de_verificação = -(Byte_Versão + Comprimento_Comando + CMD +

Reconhecer + Par1 + Par2);

Em seguida, criamos uma matriz de comandos, chamada "command_line".

Esta tabela contém dez elementos, que representam dez bytes do
comando :Byte_Inicial,Byte_Versão,Comprimento_Comando,Comando,
Reconhecer Data1 Data2 byteAlto(Checksum),
lowByte(Checksum), etEnd_Byte. À la fin de la fonctionexecute_CMD(),
nós usamos o loop for para enviar os dez bytes, um por um, ao
módulo via o software série.

A função seguinte chama-se "reset_rec_buf()" e é utilizada para

zerar todos os valores dos elementos de degreeive_buffer, ou para
réinitialiser o buffer. A função reset_rec_buf() não aceita nenhum
argumento e não retorna nenhum valor.

Em seguida, criamos uma função chamada "receive()", que é usada para

receber bytes do módulo e armazená-los na matriz
receive_buffer. A função receive() não aceita nenhum argumento e retorna
um valor booleano. No início da função receive(), chamamos
reset_rec_buf() para reinicializar o buffer_de_recepção.
Em seguida, verificamos se há dados na porta série software e se esses
os dados têm dez bytes.

Se os dados de retorno contêm dez bytes, usamos o loop for

pour lire les dix octets. Après avoir lu un octet, nous vérifions si sa valeur
est válida ao verificar se é diferente de “-1”. Se for diferente, nós
estoque o seu valor no buffer de recepção. Se um dos controles não estiver
não satisfeito, o valor booleano retornado é "falso" caso contrário, esse valor
é verdadeiro. Quando redefinimos o módulo no software, os
os elementos dureceive_buffers estão desalinhados, então precisamos corrigir isso.

Fazemos a correção com o código a seguir:

short b = receive_buffer[0];
para(uint8_t i = 0; i < 10; i++) {
se(i == 9) {
receive_buffer[i] = b;
}
senão {
receive_buffer[i] = receive_buffer[i+1];
}
}

Depois disso, criamos uma função chamada “print_received()” que é

utilizada para exibir os dados recebidos no monitor serial. A função
print_received() aceita um argumento, um valor booleano que é
utilizada para determinar se os dados devem ser impressos ou não. Se a
valeur de l'argument est égale à “true”, nous appelons la fonctionreceive()
e exibamos os dados do degreeive_buffer. Se o valor do argumento for
igual a "falso", chamamos apenas a função receive() sem
exibir os dados.
Após essas funções, criamos várias outras funções que utilizam os
funções anteriores. Todas essas novas funções são explícitas.

Na função setup() iniciamos a porta serial de hardware com uma

vitesse de transmissão de 115.200 bps, e a porta serial software com uma
vitesse de transmission de9.600 bps(qui est la vitesse de transmission par
defeito do módulo). Em seguida, chamamos a função module_init() que
inicializa o módulo, define o equalizador, o nível de volume, toca o primeiro
morceau sobre o periférico de armazenamento e exibe os dados de estado sobre o
monitor serial.

Na função loop() aguardamos dados na porta serial. Esses

os dados são enviados pelo monitor serial quando enviamos uma
comando. Os dados são uma das letras seguintes: N, B, D e
várias outras cartas. Nós verificamos qual carta é enviada e então
nós chamamos a função correspondente.

O código do esboço neste eBook é apenas um exemplo. Se você quiser ver

o sketch completo, visite o repositório no seguinte link do GitHub:

[Link]
Quando você baixa o exemplo completo do sketch no Arduino Uno
inicie o Monitor Serial e envie alguns comandos para o Arduino.
A saída deve se parecer com a da imagem abaixo:
 Exemples de commandes

Comando Bytes (HEX) * Description

Música seguinte 7E FF 060100 00 00 EF Leia o seguinte trecho

Morceau anterior 7E FF 060200 00 00 EF Leia o trecho anterior

7E FF 06030000 01EF Leia o primeiro pedaço

Leitura com índice
7E FF 06030000 02EF Leia o segundo pedaço

Volume mais 7E FF 060400 00 00 EF Monte o volume de um nível

Volume menos 7E FF 060500 00 00 EF Baixe o volume em um nível

Volume 7E FF 06060000 1EEF Defina o volume para 30 (=0x1E)

Coloque o equalizador em 02 - Rock

Modo equalizador 7E FF 060700 0002EF 00 / 01 / 02 / 03 / 04 / 05
Normal/Pop/Rock/Jazz/Classic/Base

Música em loop 7E FF 06080000 01EF Boucle o trecho 0001

7E FF 060900 0001EF Seleção de memória USB

Escolha do meio
7E FF 060900 0002EF Seleção de memória SDcard

Cuidado 7E FF 060A00 00 00 EF Vigiar

Despertar 7E FF 060B00 00 00 EF Ativação

Redefinir 7E FF 060C00 00 00 EF Redefinir

Palestra 7E FF 060D00 00 00 EF Recomece a leitura

Pausa 7E FF 060E00 00 00 EF Lecture en pause

Leitura de um trecho em um Toca a música

7E FF 060F0001 01EF
dossiê que pode conter 256 01/0001xxx.mp3
morceaux ; o módulo pode
conter 256 pastas (0 - 255) Toque a música
7E FF 060F0001 02EF
com 255 pedaços. 01/0002xxx.mp3

7E FF 06100001 0AEF 01 – Ampli ON; 0A – niveau (0-31)

Amplificador
7E FF 06100000 00EF 00 – Ampli DESLIGADO

7E FF 061100 0001EF Tudo ler em loop

Laço total
7E FF 061100 0000EF Pare a reprodução em loop

Ler 0001 na pasta mp3

Dossiê de palestra mp3 7E FF 06120000 01EF
(0x0001 – 0x0BB8; 3000 pedaços)

Ler 0001 na pasta ADVERT

Dossiê de palestra ANÚNCIO 7E FF 06130000 01EF
(0x0001 – 0x0BB8; 3000 pedaços)

* Octetos de comando sem os dois octetos de soma de verificação (Checksum)

 Comando Bytes (HEX) * Description

Leitura de um trecho em um 7E FF 06140000 01EF Dossiê 0 pedaço 001

dossiê contenedor 3000
7E FF 06140091 11EF Dossiê 9 pedaço 273 (=0x111)
morceaux; o módulo suporta
16 pastas (0-15) com 3000
7E FF 061400F0 05EF Dossiê 15 (=0xF) pedaço 005
canções.

Parada da leitura INFO e retorno à leitura

Parar leitura INFO 7E FF 061500 00 00 EF
anterior

Aula ativa em loop total desde o

Ativar loop total 7E FF 061600 0001EF
morceau 001

Parar leitura 7E FF 061600 0000EF Arrêt de la lecture

Morceau em loop em um
dossiê que pode conter 256 7E FF 06170001 02EF Boucle pedaço 02 Pasta 01
canções

Leitura aleatória 7E FF 061800 00 00 EF Reprodução aleatória de todas as faixas

7E FF 061900 0000EF Choix morceau départ boucle

Escolha laço simples
7E FF 061900 0001EF Escolha o trecho final do loop

7E FF 061A00 0000EF Saída ativa DAC

DAC
7E FF 061A00 0001EF Pare saída DAC

Volume à 30 (0x1E é 30) leitura

7E FF 0622001E 01EF
morceau 01
Ler trecho com volume
Volume à 15 (0x0F é 15) leitura
7E FF 0622000F 02EF
morceau 02

* Octetos de comando sem os dois octetos de soma de verificação (Checksum)

 Atualização do status do módulo

Há uma opção se você quiser obter os dados de retorno do módulo.

Esses dados são muito úteis, pois podem conter informações
sobre o estado atual da leitura, o nível de volume, a opção de equalização,
fim da faixa em reprodução, etc. Para ativar esta opção, você
deve definir o octeto ACK da comando para o valor 0x01 (0x00 não de
dados de retorno).

Quando você envia um comando com Acknowledge configurado para 0x01,

os dados estão voltando. Aqui está a lista de comandos a serem enviados ao módulo
na ordem para obter atualizações de status:

Comando (HEX) * Descrição

7E FF 063F00 00 00 EF Para obter o dispositivo de armazenamento atual

7E FF 064000 0001EF Dados de retorno que indicam o erro, onde 01 é o valor do erro.

Dados retornados sem erro. Isso indica que o pedido foi

7E FF 06410000 00EF
recebida e executada com sucesso, onde 00 00 está o estado do módulo.

7E FF 064200 00 00 EF Para obter o estado da leitura

7E FF 064300 00 00 EF Para obter o nível de volume atual

7E FF 064400 00 00 EF Para obter o estado atual do equalizador

7E FF 064700 00 00 EF Para obter o número total de arquivos no disco flash USB

7E FF 064800 00 00 EF Pour obtenir le nombre total de fichiers sur la carte SD

7E FF 064B00 00 00 EF Para obter o número da faixa atual no pen drive USB

7E FF 064C00 00 00 EF Para obter o número da faixa atual no cartão SD

7E FF 064E00 00 00 EF Para obter o número total de arquivos em um meio de armazenamento

7E FF 064E00 0002EF Pour obtenir le nombre total de fichiers dans le dossier 02

7E FF 064E00 000CEF Para obter o número total de arquivos na pasta 12

7E FF 064F00 00 00 EF Para obter o número total de pastas em um dispositivo de armazenamento

* Octetos de comando sem os dois octetos de soma de verificação (Checksum)

 Valores retornados

Os dados de retorno estão no formato

0x7E 0xFF 0x060x41 0x00A B verificação1 verificação0 0xEF

O valor 0x41 indica que um comando foi recebido pelo módulo e

executada com sucesso.

O valor "A" representa os suportes de armazenamento, onde

A = 0x01 Memória USB
A = 0x02 SDcard

O valor "B" indica o estado da leitura, onde

B = 0x00 indica que a leitura está parada
B = 0x01 indica que a leitura está em andamento
B = 0x02 indica que a leitura está em pausa

Exemplo de dados retornados:

0x7E 0xFF 0x060x41 0x000x02 0x01 0xFE 0xF7 0xEF

onde
0x02 o dispositivo de armazenamento é um cartão SD
0x01 a leitura está em andamento
 Erros

Se um erro ocorrer, os dados de retorno estarão no formato:

0x7E 0xFF 0x060x40 0x00 0x00 0x01 chks1 chks0 0xEF
Onde
0x40 indica que ocorreu um erro e 0x01 é o valor do erro.

Os valores de erro com suas descrições estão na tabela a seguir

abaixo :
Valor Erro (HEX) * Description
7E FF 064000 0001EF O módulo está ocupado

7E FF 064000 0002EF O módulo está em modo de espera

7E FF 064000 0003EF Erro de recepção em série

7E FF 064000 0004EF Erro de checksum incorreto

7E FF 064000 0005EF O trecho especificado está inacessível

7E FF 064000 0006EF O trecho especificado não foi encontrado

7E FF 064000 0007EF Erro de intercalação de INFOS

7E FF 064000 0008EF Erro de leitura do SDcard

7E FF 064000 000AEF O módulo entrou em modo de espera

* Octetos de erros sem os dois octetos de soma de verificação (Checksum)

 Dados específicos retornados

Se o octeto ACK estiver configurado para 0x01, o módulo emitirá dados quando o
o pedaço será concluído quando o cartão SD (ou o disco flash USB) estiver
inserida ou retirada ou quando o dispositivo de armazenamento está online. Esses
valeurs seront renvoyées sans envoyer de commande au module.

Les données retournées du dispositif de stockage lorsqu’il est inséré

0x7E 0xFF 0x060x3A 0x00 0x00 A 0xFE 0xF7 0xEF
onde
0x3A indique que o dispositivo de armazenamento está inserido

Os dados retornados do dispositivo de armazenamento quando ele foi retirado

0x7E 0xFF 0x060x3B0x00 0x00A0xFE 0xF7 0xEF
onde
0x3B indique que le dispositif de stockage estéjecté
A =0x01 indica que o dispositivo de armazenamento é uma memória USB
A =0x02 indica que o dispositivo de armazenamento é um cartão SD
A =0x04 indica se o cabo USB está conectado ou não

Os dados retornados da peça concluída estão no seguinte formato

0x7E 0xFF 0x060x3D 0x000x00 0x05 0xFE 0xF7 0xEF
onde
0x3D indique que o pedaço está terminado no cartão SD (0x3C = USB),
0x00 0x05 indique o trecho "0005"
Os dados retornados quando o dispositivo de armazenamento está online
0x7E 0xFF 0x060x3F 0x00 0x00 A 0xFE 0xF7 0xEF
onde
0x3F indique que o dispositivo de armazenamento está online, e "A" pode ter
várias valores diferentes :

A =0x01 indica uma memória USB

A =0x02 indica um cartão SD
A =0x03 indique une mémoire USB et une SDcard en même temps
A =0x04 indica uma conexão de PC
 Valores retornados de leitura

Se o octeto ACK estiver definido como 0x01, enviamos o comando para o status
de leitura :
0x7E 0xFF 0x060x45 0x00 0x00 0x00 chks1 chks0 0xEF

Os dados retornados estarão no formato:

0x7E 0xFF 0x060x41 0x00 0x00A chks1 chks0 0xEF

onde "A" pode ter vários valores diferentes :

A =0x00 indica que a leitura está configurada para ler e repetir

todas as partes do dispositivo de armazenamento
A =0x01indique que a leitura está ajustada para ler e colocar em loop
todos os pedaços do dossiê específico
A =0x02 indica que a leitura está configurada para ler e repetir um
morceau
A =0x03 indica que a leitura está ajustada para leitura aleatória e coloca em
reproduza todas as músicas do periférico de armazenamento
A = 0x04 indica que a leitura está configurada para ler um único pedaço e que
a leitura para quando a peça termina

Você conseguiu!
Agora você pode usar seu módulo para
diversos projetos.
Agora é hora de aprender e criar seus próprios projetos. Você
você pode fazer isso com a ajuda de muitos exemplos de scripts e outros
tutoriais que você pode encontrar na Internet.

Para produtos microeletrônicos Arduino e Raspberry Pi de

qualidade superior AZ-Delivery Vertriebs é o seu interlocutor
privilegiado. Fornecemos uma série de exemplos de aplicação,
guias de instalação completos, livros eletrônicos,
bibliotecas e uma assistência completa.

AZ-Delivery, seu especialista em microeletrônica.

[Link]

Divirtam-se!

Mensagens legais
[Link]