¡Bienvenido!

Le agradecemos por haber comprado el módulo AZ-Delivery MP3 DFPlayer.

En las páginas que siguen, vamos a explicarte cómo usar y
configurar este dispositivo práctico.

¡Diviértete!
El módulo MP3 DFPlayer Mini es un reproductor MP3 pequeño y accesible con
una salida directa a un altavoz o auriculares. El módulo puede ser
utilizado como un módulo autónomo con una batería, un altavoz y
botones pulsadores o utilizados en combinación con una placa Arduino o
toda otra tarjeta con capacidades UART.

El módulo es compatible con los formatos de audio comunes como MP3, WAV
y WMA. Es compatible con tarjetas MicroSD con el sistema de archivos
FAT16 o FAT32. Puedes escuchar música a través de un puerto simple
serie sin ninguna operación compleja.

El módulo se entrega con dos conectores macho de 8 pines pre-soldados,

dispone de una ubicación para una tarjeta de memoria MicroSD. Hay
también un LED rojo incorporado utilizado para indicar el estado de
lectura de las piezas. El LED está conectado al pin BUSY del módulo.
El estado encendido del LED indica que se está reproduciendo una pieza.
Especificación:

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

» Corriente de vigilancia 20mA20mA
» Temperatura de uso de -40℃ a 70℃
» Puerto USART Estándar (Nivel TTL)
» Vitesse defecto 9600bps, ajustable
» Ecualizador 6 modos, ajustables
» Volumen 30 niveles, ajustables
» Tasa de muestreo (kHz) 8/11.025/12/16/22/24/32/44.1/4848
» Salida - 24 bits DAC para 90dB,
- SNR para 85dB
» Puissance de sortie 3W
» Impédancia HP 3Ω (máximo 8Ω)
» Sistema de archivos FAT16 o FAT32
» Tamaño máximo - 32GB en tarjeta SD
- 32GB sur mémoire USB
- 64MB bytes NORFLASH
» Tipos de control - Interfaz de Entrada/Salida

Puerto Serie
- Botón AD
» Función de espera del sonidoINFOS (la música puede ser
suspendido, cuando INFOS está terminada la música continúa en
jugar
» Datos de audio organizados por carpetas. El módulo admite
hasta 100 archivos y cada archivo puede contener hasta 255
trozos.
 Brochado

Las broches USART (UART) se utilizan para la comunicación en serie.

Si escuchas un ruido alto, conecta una resistencia de 1kΩ a la
brocheTXen serie.

Las pinzas del canal de salida de audio se utilizan como pinzas DAC
(Convertidor Digital a Analógico), y debes conectarlos al amplificador
externo.

Los pines del altavoz son pines del amplificador de 3W

embarque, y puedes conectarlos directamente al altavoz
externo (8Ω máximo).

Las broches ADKEY se utilizan para el modo de control AD.

Las broches del puerto TRIGGER se utilizan para ajustar los niveles de
volumen o para cambiar de pista (material). Estas clavijas están activas
BAJO.

Las broches USB se utilizan para la conexión de la memoria USB.

 Alimentación y broche BUSY

El módulo soporta un rango de tensión de funcionamiento de 3.2V a

5V CC. Conecte una fuente de alimentación externa entre la clavija de alimentación

y el pin de tierra (GND).

La tensión del nivel lógico TTL del puerto serie del módulo es de 3,3V,
por lo tanto, cuando utilizas niveles de 5V (por ejemplo, la placa Uno)
conecte en serie una resistencia de más de 1kΩ al pin RX
módulo. Si no utiliza esta resistencia, tendrá un ruido alto
sobre los canales de salida de audio.

La broche de estado de lectura o BUSY se utiliza para indicar el estado de

lectura de un trozo. El estado LOW en este pin indica que el módulo
está leyendo un fragmento, y el estado ALTO indica que el módulo no lee
ninguna pieza.
 Canaux de sortie audio et broches de haut-parleur

La chip principal del módulo es un convertidor digital-analógico

24 bits (DAC). La puce posee dos pines DAC que están conectados
directamente a los canales de salida de audio del módulo. Debe conectar
un amplificador externo en las clavijas de los canales de salida de audio para
d'utiliser les capacités DAC du module. Si vous voulez utiliser ces broches,
active primero la salida DAC enviando el comando correspondiente a
la pulga (más adelante en el texto).

Un circuito de amplificación de 3W está integrado en el módulo. El núcleo de este

el circuito es un dispositivo llamado "amplificador de audio 8002", un circuito integrado
(CI) a 8 pines cuya salida está conectada a los pines Speaker+ y
El salida del CI 8002 es mono.

Conecta el altavoz externo al módulo como se indica en este

esquema de conexión :
 Puertos TRIGGER de desencadenamiento (pines IO)

Estas broches se utilizan para la conmutación de piezas y el ajuste

niveles de volumen a través del hardware. Conecte botones pulsadores a
estos broches como se indica en este esquema :

Cuando el botón pulsador está en estado de reposo, las clavijas diagonales del
los botones pulsadores no están conectados. Cuando presiona el
botón pulsador, estos pines están conectados, lo que activa el botón-
pulsador en un estado activo.

Una presión corta en el botón pulsador IO2 permite leer el trozo

siguiente. Una presión larga en el botón pulsador IO2 aumenta el
nivel del volumen.

Une pression courte sur le bouton poussoirIO1permet de lire le morceau

anterior. Una presión prolongada en el botón pulsador IO2 disminuye el
nivel de volumen.

La duración del empuje largo es superior a un segundo. Todo lo que

es inferior a un segundo se considera un empuje corto.
 Broches ADKEY

La funcionalidad AD del chip integrado en el módulo te permite

conectar 20 resistencias con botones en dos puertos AD del módulo
comme indiqué sur ce schéma de connexion :

NOTA: Es necesario que la alimentación sea lo más estable posible.

¡Para que funcione correctamente!

Una breve presión en el botón Modo de reproducción cambia la lectura a modo

interrumpido o ininterrumpido. Esto significa que la lectura será o no será
interrumpida por una INFOS. No hay función de presión larga
para este botón.

Una breve presión sobre el botón U/TF/SPI pone en funcionamiento el dispositivo de

lectura de uno de los siguientes elementos: U= unidad flash USB, TF= tarjeta SD,
SPI= NORFLASH o Sueño. No hay función de presión prolongada.
para este botón.
Una presión breve en el botón Loop All permite pasar del modo de
lectura en bucle de una pieza a la lectura en bucle de todas las piezas
o no leerlos en bucle. No hay función de presión larga
para este botón.

Una breve presión en el botón Pausa/Reproducción pone en pausa o reproduce el

mordu seleccionado. No hay función de presionar largo para esto

botón.

Una presión corta en el botón Pre/Vol+ permite pasar a la siguiente pista

anterior. Mantener pulsado el botón Pre/Vol+ aumenta el nivel
del volumen.

Una presión corta en el botón Siguiente/Volumen permite pasar a la siguiente canción.

siguiente. Una presión larga en el botón Pre/Vol+ disminuye el nivel del

volumen.

Una presión corta en el botón Segment1 permite reproducir la pieza

número 1. Una presión larga en el botónSegment1repite la lectura
de la misma canción.

Las funciones son las mismas para todos los demás botones de segmento, excepto
para el número de canción que difiere.
 Puerto serie

Las broches RX y TX se utilizan para establecer una comunicación serie.

con un microcontrolador externo. No olvides conectar una resistencia
à la brocheRX lorsqueles vous utilisez une logique TTL 5V. Le port série du
el módulo soporta el modo de comunicación serie asíncrona. La velocidad en
La velocidad por defecto de la comunicación serie es de 9600 bps y es
ajustable por software.

Puede utilizar el puerto serie para enviar comandos simples al

módulo y así controlar muchas funciones admitidas por el
módulo. Aprenderás más sobre los comandos en el próximo capítulo.

Especificaciones

Tasa de baudios 9600bps

Bit de datos 1
Pagar no
Control de flujo no
 Formato de los pedidos

Para enviar un comando al módulo, siga el formato específico:

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

Nombre Octeto Descripción de octeto

$SB 0x7E Octeto de inicio
VB Octeto de versión 0xFF

LB 0xxxEl número de octetos del comando sin

octetos de inicio y fin (En nuestro caso, 0x06)
CMD 0xxxComo REPRODUCIR, PAUSAR, etc.

ACK 0xxxACK0x00= NON,0x01= OUI

DATOS1 0xxxOcteto de datos alto
DATOS2 0xxxOcteto de datos bajo
CHKS1 0xxxOcteto ALTO del checksum
CHKS2 0xxxOcteto BAS de la suma de verificación
$EB 0xEFOcteto de fin

El octeto ACK se utiliza para obtener datos del módulo. Si está definido a
0x00, ninguna dato será enviado por el módulo y si se establece en
0x01, recibirás datos de respuesta del módulo. La longitud de los
los datos no están limitados, pero generalmente son de dos bytes
(datosoctetos1etdatos2).

Para enviar un comando específico, solo hay que enviar un byte por
octeto en serie en la interfaz serie del software (puede ver esto más adelante
en el código).
 Estructura de las carpetas y nombres de las canciones

El módulo admite varios tipos de archivos y nombres

específicos para las piezas. Los nombres de las carpetas son números, a
la excepción de los archivos “mp3” y “ADVERT”. Los nombres de las canciones

deben comenzar con un número después del cual viene la cadena de

caracteres sin espacio. Ejemplo de nombre de pieza:
0001_Linking_Park_En_El_Final.mp3

Hay cinco tipos de archivos:

El primero puede contener 256 piezas. El módulo admite 256 de

ces dossiers au total. Les noms de ces dossiers sont des numéros compris
entre 000 y 255. Los nombres de las piezas en estas carpetas comienzan
por números comprendidos entre 000 y 255. El módulo no toma en
carga los subcarpetas.

El segundo puede contener 3000 piezas. El módulo soporta 16 de

Estos archivos son un total. Los nombres de estos archivos son números comprendidos

entre 00 y 15. Los nombres de las piezas en estas carpetas comienzan por
números comprendidos entre 0000 y 2999. El módulo no toma en cuenta
carga los subdirectorios.

El tercero se llama 'mp3' y también puede contener 3000 piezas.

El módulo admite una única carpeta 'mp3' en total. Los nombres de los
los trozos en este archivo comienzan con números entre
0000 y 2999. El módulo no soporta subcarpetas.
El cuarto se llama “ADVERT”, que también puede contener 3000
morceaux et qui est utilisé pour INFOS. Le module prend en charge un seul
dossier "ADVERT" au total. Les noms des fichiers dans ce dossier
comenzando por números entre 0000 y 2999. El módulo no
no admite subcarpetas.

Finalmente, el quinto es el directorio raíz "root". Si se trata del único directorio de

la tarjeta SD o la memoria USB (ninguna otra carpeta), esta carpeta puede contener
hasta 65 536 piezas. Esta carpeta puede tener subcarpetas, y
comprende todos los tipos de carpetas. La carpeta 'root' puede contener
canciones y subcarpetas al mismo tiempo.

Ejemplo de estructura de carpeta :

raíz
---0001r.mp3
---0002r.mp3
---0003r.mp3
---0004r.mp3
---0001
--- ---0001x.mp3
--- ---0002x.mp3
---0002
--- ---0001y.mp3
---mp3
--- ---0001m.mp3
--- ---0002m.mp3
--- ---0003m.mp3
---ANUNCIO
--- ---0001a.mp3
--- ---0002a.mp3
 Envío de comandos al módulo

Para enviar comandos al módulo, conecta el módulo con

el Arduino Uno como se indica en el diagrama de conexión a continuación:

Módulo > Uno

VCC > 5V Rojo
RX > D7 (a través de una resistencia de 1kΩ) Azul

TX > D6 Verde
GND > GND Noir

Módulo > Altavoz

SPK - > Broche - del altavoz Violeta
SPK+ > Broche + du haut-parleur Violeta

NOTA: Puedes usar cualquier otra tarjeta con un

microcontrolador que tiene capacidades UART.
Utilizamos la interfaz de software serie en los pines de E/S digitales 6
et 7 de l'Uno, car l'Uno utilise les broches série matérielles (broches d'E/S
números 0 y 1), para la programación del microcontrolador principal.

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

módulo mientras la inicialización del módulo no esté terminada y que los
las informaciones de estado no se han devuelto. De lo contrario, los pedidos
enviadas por el microcontrolador serán ignoradas y eso afectará el
proceso de inicialización.
Si no se indica lo contrario (enviando un comando después
la inicialización), cuando el módulo se enciende, primero lee la tarjeta
SD y si no está disponible, pasa a la memoria USB.
Ejemplo de código

#include "SoftwareSerial.h"
#define Byte_Inicial 0x7E
#define Version_Byte 0xFF
#define Longitud_Comando 0x06
#define Byte_Final 0xEF
// Devuelve información con el comando 0x41 [0x01: info, 0x00: sin información]
#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;// Utilizado para los comandos recibidos del Monitor Serial
byte volumen = 0x00;// Usado para almacenar el nivel de volumen actual
bool mute_state =false;// Used to toggle mute state

// Ejecutar el comando y los parámetros

void ejecutar_CMD(byte Comando, byte Datos1, byte Datos2) {
// Calcular la suma de verificación (2 bytes)
palabra Suma de verificación = -( Byte_Versión + Longitud_Comando + Comando +
Reconocer + Datos1 + Datos2);
// Construir el comando
byte command_line[10] = { Start_Byte, Version_Byte,
Command_Length, Command, Acknowledge,
Datos1, Datos2, byteAlto(Chequeo)
lowByte(Checksum), End_Byte};
Enviar la línea de comandos al 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 recibir() {
reset_rec_buf();
si([Link]() < 10) {
return falso;
}
para(uint8_t i = 0; i < 10; i++) {
short b = [Link]();
si(b == -1) {
regresar falso
}
receive_buffer[i] = b;
}
// When you reset the module in software,
Los elementos del búfer recibidos se desplazan.
Para corregir eso hacemos lo siguiente:
short b = receive_buffer[0];
por(uint8_t i = 0; i < 10; i++) {
si(i == 9) {
receive_buffer[i] = b;
}
sino {
receive_buffer[i] = receive_buffer[i+1];
}
} // Fin de corregir receive_buffer
volver verdadero;
}
void imprimir_recibido(bool imprimirlo) {
si(imprimirlo) {
si(recibir()) {
para(uint8_t i = 0; i < 10; i++) {
[Link](receive_buffer[i],HEX);[Link]("\t");
}
[Link]();
 }
}
otro { recibir(); }
}
void module_init() {
ejecutar_CMD(0x0C, 0, 0); retrasar(1000);// Reiniciar el módulo
imprimir_recibido(falso);demorar(100);
[Link]("SDON\t");
imprimir_recibido(true);esperar(100);
playFirst();
setVolume(0x09);
}
void jugar_primero() {
[Link]("PLYFST\t");
ejecutar_CMD(0x03, 0, 1); retrasar(100); // Reproducir la primera canción
imprimir_recibido(false);retardo(100);
ejecutar_CMD(0x45, 0, 0); retrasar(100);// Obtener estado de reproducción
imprimir_recibido(false); retrasar(100);
imprimir_recibido(true); retrasar(100);
}
void establecer_volumen(uint8_t volumen) {
[Link]("SETVOL\t");
ejecutar_CMD(0x06, 0, volumen); retraso(100);// Establecer nivel de volumen
imprimir_recibido(falso);demorar(100);
ejecutar_CMD(0x43, 0, 0); retrasar(100);// Obtener nivel de volumen
imprimir_recibido(falso); esperar(100);
imprimir_recibido(true);demorar(100);
}
void jugar_siguiente() {
[Link]("SIGUIENTE\t");
ejecutar_CMD(0x01, 0, 0); retrasar(100);
imprimir_recibido(falso);demorar(100);
ejecutar_CMD(0x4C, 0, 0); retrasar(100);// Obtener la canción actual reproducida
imprimir_recibido(falso); retrasar(100);
imprimir_recibidos(true); retrasar(100);
}
void silenciar() {
mute_state = !mute_state;
si(mute_state) {
ejecutar_CMD(0x43, 0, 0); retrasar(100);// Devolver nivel de volumen
imprimir_recibido(falso);esperar(100);
imprimir_recibido(falso); demora(100);
volumen = buffer_recibido[6];
[Link]("MUTE\t");
ejecutar_CMD(0x06, 0, 0x00); retrasar(100);// Establecer el nivel de volumen
imprimir_recibido(falso);retardo(100);
ejecutar_CMD(0x43, 0, 0); retrasar(100);// Obtener nivel de volumen
imprimir_recibido(falso);retrasar(100);
imprimir_recibido(true);demorar(100);
}
// una pestaña
else {
[Link]("VOL\t");
execute_CMD(0x06, 0, volumen); delay(100);// Establecer volumen anterior
imprimir_recibido(falso); retrasar(100);
ejecutar_CMD(0x43, 0, 0); retraso(100);// Obtener nivel de volumen
imprimir_recibido(falso);demorar(100);
print_recibido(true);delay(100);
}
}

void juego_aleatorio() {
// Aleatorio reproduce todas las canciones, las repite en un bucle, repite canciones en la reproducción
ejecutar_CMD(0x18, 0, 0);
delay(100);
[Link]("RNDM ");
imprimir_recibido(falso);
retraso(100);
execute_CMD(0x4C, 0, 0); // Obtener la canción actual reproducida
retraso(100);
imprimir_recibido(falso);
retraso(100);
imprimir_recibido(true);
retraso(100);
}
void query_status() {
ejecutar_CMD(0x42, 0, 0); esperar(100);// Obtener estado del módulo
imprimir_recibido(false); retraso(100);
[Link]("ESTADO\t");
imprimir_recibido(verdadero); retrasar(100);
execute_CMD(0x43, 0, 0); delay(100);// Obtener el nivel de volumen
imprimir_recibido(false);retardar(100);
[Link]("VOLUMEN ");
imprimir_recibido(true); retrasar(100);
execute_CMD(0x44, 0, 0); delay(100);// Obtener estado EQ
imprimir_recibido(falso); retrasar(100);
[Link]("EQ\t");
imprimir_recibido(true);retrasar(100);
execute_CMD(0x45, 0, 0); delay(100);// Obtener estado de reproducción
imprimir_recibido(falso);demorar(100);
[Link]("PLYBCK\t");
imprimir_recibido(true); retrasar(100);
ejecutar_CMD(0x46, 0, 0); retraso(100);// Obtener versión del software
imprimir_recibido(falso);retardo(100);
[Link]("SFVER\t");
imprimir_recibido(verdadero);retardo(100);
Obtener el número total de archivos en el dispositivo de almacenamiento
ejecutar_CMD(0x48, 0, 0); retraso(100);
imprimir_recibido(falso); retrasar(100);
[Link]("ARCHIVOS\t");
imprimir_recibido(true);demora(100);
execute_CMD(0x4C, 0, 0); delay(100);// Obtener la canción actual que se está reproduciendo
imprimir_recibido(falso);delay(100);
[Link]("CRRTRK\t");
imprimir_recibido(true); retrasar(100);
}
vacío configuración() {
[Link](115200);
[Link](9600);delay(1000);

Inicialización
module_init();
}
vacío bucle() {
imprimir_recibido(true);

mientras([Link]() > 0) {
data = [Link]();
// [Link](data, HEX); // Para depuración
si(data !="/n") {
si(data =='N') {
Reproducir la siguiente canción
play_siguiente();
}
else si(data =='B') {
Reproducción aleatoria
juego_aleatorio();
}
// .....
de lo contrario si(data =='D') {
Consultar estado del módulo
consultar_estado();
}
}
}
retraso(100);
}
El código comienza incluyendo una biblioteca llamada
SoftwareSerial.h

Luego, definimos cinco macros. Estas macros representan los bytes

de pedido que son los mismos para todos los pedidos. El primero
el octeto se llama "Start_Byte" cuyo valor es 0x7E, el segundo octeto es
llamado "Version_Byte" cuyo valor es 0xFF, el tercer octeto es
llamado "Command_Length" cuyo valor es 0x06, el cuarto octeto es
llamado "End_Byte" cuyo valor es 0xEF y el quinto octeto se llama
"Reconocer" con el valor 0x01.

A continuación, definimos el objeto de software en serie llamado “mySerial” con este

línea de código: SoftwareSerial mySerial(6, 7);
¿Dónde representa el pin I/O digital del Uno en el que está el pin RX?
tu módulo está conectado y representa el pin I/O digital del Uno
sobre la cual se conecta la brocheTX del módulo.

A continuación, creamos un arreglo llamado “receive_buffer”, que consta de diez

elementos. Los elementos de la tabla 'receive_buffer' representan los bytes
que son enviados por el módulo y recibidos por la Uno.

Después de eso, creamos tres variables. La primera se llama “data” y

se utiliza para almacenar los pedidos cuando los enviamos
desde el monitor serie. La segunda variable se llama 'volumen' y ella
est utilisée pour stocker le niveau de volume actuel, lorsque nous envoyons
la orden “Silenciar”. La tercera variable se llama “estado_silenciar” y ella
se utiliza para alternar el estado silencioso del módulo.
A continuación, creamos varias funciones. La primera función se llama
"execute_CMD()" que acepta tres argumentos y no devuelve ningún valor.
La función execute_CMD() se utiliza para enviar comandos a
módulo. El primer argumento es el byte de comando, el segundo es
el octeto de datos 1 y el tercero es el octeto de datos 2 de la
commande. Al principio de la función execute_CMD() calculamos los
octetos de verificación con esta línea de código:

palabra checksum = -(Byte_Versión + Longitud_Comando + CMD +

Reconocer + Par1 + Par2);

A continuación, creamos un arreglo de comandos, llamado 'command_line'.

Este cuadro contiene diez elementos, que representan diez bytes de la
comando :Byte_Inicial,Byte_Versión,Largo_Comando,Comando
Reconocer, Datos1 Datos2, byteAlto(CheckSum),
byteBajo(Checksum), etFin_Byte. Al final de la función ejecutar_CMD(),
utilizamos el bucle for para enviar los diez bytes, uno por uno, al
módulo a través del software de serie.

La función siguiente se llama “reset_rec_buf()” y se utiliza para

reestablecer a cero todos los valores de los elementos de dereceive_buffer, o para
reiniciar el búfer. La función reset_rec_buf() no acepta ninguno
argumento y no devuelve ningún valor.

Luego creamos una función llamada “receive()”, que se utiliza para

recibir bytes del módulo y almacenarlos en el arreglo
receive_buffer. La función receive() no acepta ningún argumento y devuelve
un valor booleano. Al inicio de la función receive(), llamamos
reset_rec_buf() para reiniciar el array receive_buffer.
A continuación, verificamos si hay datos en el puerto serie software y si estos
los datos tienen diez bytes.

Si los datos de retorno constan de diez bytes, utilizamos el bucle for

para leer los diez bytes. Después de leer un byte, verificamos si su valor
est válida al verificar si es diferente de “-1”. Si es diferente, nosotros
almacenar su valor en el búfer de recepción. Si uno de los controles no es
no satisfecho, el valor booleano devuelto es "falso" de lo contrario, este valor
es "verdadero". Cuando reiniciamos el módulo en el software, los
Los elementos de los buffers de dureza están desfasados, así que tenemos que corregir eso.

Hacemos la corrección con el siguiente código:

short b = receive_buffer[0];
para(uint8_t i = 0; i < 10; i++) {
si(i == 9) {
receive_buffer[i] = b;
}
else {
receive_buffer[i] = receive_buffer[i+1];
}
}

Después de eso, creamos una función llamada “print_received()” que es

utilizada para mostrar los datos recibidos en el monitor serie. La función
print_received() acepta un argumento, un valor booleano que es
utilizada para determinar si los datos deben imprimirse o no. Si el
valeur de l'argument est égale à “true”, nous appelons la fonctionreceive()
y mostramos los datos de dereceive_buffer. Si el valor del argumento es
égale à "false", nous appelons uniquement la fonction receive() sans
afficher les données.
Después de estas funciones, creamos varias otras funciones que utilizan los
fonctions précé[Link] ces nouvelles fonctions sont explicites.

En la función setup() iniciamos el puerto serie de hardware con una

vitesse de transmisión de 115.200 bps, y el puerto serie software con una
vitesse de transmission de 9.600 bps (qui est la vitesse de transmission par
defecto del módulo). A continuación, llamamos a la función module_init() que
inicializa el módulo, define el ecualizador, el nivel de volumen, reproduce el primero
muestra en el dispositivo de almacenamiento y muestra los datos de estado en el
monitor serial.

En la función loop() esperamos datos en el puerto serie. Estos

los datos son enviados por el monitor serial cuando enviamos una
comando. Los datos son una de las letras siguientes: N, B, D y
varias otras cartas. Verificamos qué carta se envía y luego
llamamos a la función correspondiente.

El código del sketch en este eBook es solo un ejemplo. Si deseas ver

el sketch completo, visite el repositorio en el siguiente enlace de GitHub:

[Link]
Lorsque vous téléchargez l'exemple complet du sketch sur l’Arduino Uno
inicie el Monitor Serial y envíe algunos comandos a la Arduino.
La salida debería parecerse a la de la imagen de abajo:
 Ejemplos de comandos

Orden Bytes (HEX) * Description

Morceau suivant 7E FF 060100 00 00 EF Lee el siguiente fragmento

Morceau précédent 7E FF 060200 00 00 EF Leer el trozo anterior

7E FF 06030000 01EF Leer la primera pieza

Lectura con índice
7E FF 06030000 02EF Leer el segundo trozo

Volumen más 7E FF 060400 00 00 EF Monte el volumen de un nivel

Volumen menos 7E FF 060500 00 00 EF Baja el volumen un nivel

Volumen 7E FF 06060000 1EEF Fija el volumen a 30 (=0x1E)

Pone el ecualizador a 02 - Rock
Modo ecualizador 7E FF 060700 0002EF 00 / 01 / 02 / 03 / 04 / 05
Normal/Pop/Rock/Jazz/Clásico/Baile

Morceau en boucle 7E FF 06080000 01EF Reproduce la pista 0001

7E FF 060900 0001EF Selección de memoria USB

Elección del medio
7E FF 060900 0002EF Sélection mémoire SDcard

Vigilia 7E FF 060A00 00 00 EF Vigilia

Despertar 7E FF 060B00 00 00 EF Activación

Reiniciar 7E FF 060C00 00 00 EF Restablecer

Conferencia 7E FF 060D00 00 00 EF Reanuda la lectura

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

Lectura de un fragmento en un Toca la pieza

7E FF 060F0001 01EF
dossier que puede contener 256 01/0001xxx.mp3
morceaux ; el módulo puede
contener 256 carpetas (0 - 255) 7E FF 060F0001 02EF Toca la pieza
con 255 piezas. 01/0002xxx.mp3

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

Amplificador
7E FF 06100000 00EF 00 – Ampli APAGADO

7E FF 061100 0001EF Leer todo en bucle

Bucle total
7E FF 061100 0000EF Detén la reproducción en bucle

Leer 0001 en la carpeta mp3

Dossier de conferencia mp3 7E FF 06120000 01EF
(0x0001 – 0x0BB8; 3000 piezas)

Leer 0001 en la carpeta ADVERT

Dossier de conferencia PUBLICIDAD 7E FF 06130000 01EF
(0x0001 – 0x0BB8; 3000 piezas)

Octetos de comando sin los dos octetos de suma de verificación (Checksum)

 Orden Bytes (HEX) * Description

Lectura de un fragmento en un 7E FF 06140000 01EF Dossier 0 trozo 001

dossier contenedor 3000
7E FF 06140091 11EF Dossier 9 morceau 273 (=0x111)
morceaux; el módulo soporta
16 dossiers (0-15) con 3000
7E FF 061400F0 05EF Dossier 15 (=0xF) pieza 005
canciones.
Parada de la lectura INFO y regreso a la lectura
Detener lectura INFO 7E FF 061500 00 00 EF
anterior

Conferencia activa en bucle total desde el

Activar bucle total 7E FF 061600 0001EF
morceau 001

Detener lectura 7E FF 061600 0000EF Detención de la lectura

Morceau en boucle dans un

dossie que puede contener 256 7E FF 06170001 02EF Boucle morceau 02 Dossier 01
canciones
Conferencia aleatoria 7E FF 061800 00 00 EF Reproducción aleatoria de todas las pistas

7E FF 061900 0000EF Elección de pieza de salida del bucle

Elección de bucle simple
7E FF 061900 0001EF Elección del trozo al final del bucle

7E FF 061A00 0000EF Salida activa DAC

DAC
7E FF 061A00 0001EF Detener salida DAC

Volumen a 30 (0x1E es 30) lectura

7E FF 0622001E 01EF
morceau 01
Leer fragmento con volumen
Volumen a 15 (0x0F es 15) lectura
7E FF 0622000F 02EF
morceau 02

* Octetos de comando sin los dos octetos de suma de verificación (Checksum)

 Actualización del estado del módulo

Hay una opción si desea obtener los datos de retorno del módulo.
Estos datos son muy útiles, ya que pueden contener información
sobre el estado actual de la lectura, el nivel de volumen, la opción de ecualización, la
fin del trozo en curso de lectura, etc. Para activar esta opción, usted
devez définir l'octetACKde la commande à la valeur0x01(0x00pas de
datos de retorno.

Cuando envía un comando con Acknowledge configurado en 0x01,

Los datos regresan. Aquí está la lista de los pedidos a enviar al módulo.
en orden para obtener actualizaciones de estado:

Comando (HEX) * Descripción

7E FF 063F00 00 00 EF Para obtener el dispositivo de almacenamiento actual

7E FF 064000 0001EF Datos de retorno que indican el error, donde 01 es el valor del error.

Datos de retorno sin error. Esto indica que el pedido ha sido

7E FF 06410000 00EF
recibida y ejecutada con éxito, ¿dónde está el estado del módulo?

7E FF 064200 00 00 EF Para obtener el estado de la lectura

7E FF 064300 00 00 EF Para obtener el nivel de volumen actual

7E FF 064400 00 00 EF Para obtener el estado actual del ecualizador

7E FF 064700 00 00 EF Para obtener el número total de archivos en la unidad flash USB

7E FF 064800 00 00 EF Para obtener el número total de archivos en la tarjeta SD

7E FF 064B00 00 00 EF Para obtener el número de la pista actual en la unidad flash USB

7E FF 064C00 00 00 EF Pour obtenir le numéro du morceau actuel sur la carte SD

7E FF 064E00 00 00 EF Para obtener el número total de archivos en un medio de almacenamiento

7E FF 064E00 0002EF Para obtener el número total de archivos en la carpeta 02

7E FF 064E00 000CEF Para obtener el número total de archivos en la carpeta 12

7E FF 064F00 00 00 EF Para obtener el número total de archivos en un dispositivo de almacenamiento

Octetos de comando sin los dos octetos de suma de comprobación (Checksum)

 Valores devueltos

Los datos de retorno están en formato

0x7E 0xFF 0x060x41 0x00A B checksum1 checksum0 0xEF

El valor 0x41 indica que se ha recibido un comando por el módulo y

ejecutada con éxito.

El valor “A” representa los soportes de almacenamiento, donde

A = 0x01 Memoria USB
A = 0x02 Tarjeta SD

El valor "B" indica el estado de la lectura, donde

B = 0x00 indica que la lectura está detenida
B = 0x01 indica que la lectura está en curso
B = 0x02 indica que la lectura está en pausa

Ejemplo de datos devueltos:

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

dónde
0x02 el dispositivo de almacenamiento es una tarjeta SD
0x01 la lectura está en curso
 Errores

Si se produce un error, los datos de retorno estarán en el formato:

0x7E 0xFF 0x060x40 0x00 0x00 0x01 chks1 chks0 0xEF
Dónde
0x40 indica que se ha producido un error y 0x01 es el valor del error.

Los valores de error con su descripción se encuentran en la tabla ci-

debajo
Valor Error (HEX) * Description
7E FF 064000 0001EF El módulo está ocupado

7E FF 064000 0002EF El módulo está en modo de espera

7E FF 064000 0003EF Error de recepción en serie

7E FF 064000 0004EF Error de checksum incorrecto

7E FF 064000 0005EF La pieza especificada es inaccesible

El trozo especificado no se encuentra

7E FF 064000 0007EF Error de intercalación de INFOS

7E FF 064000 0008EF Error de lectura de la tarjeta SD

El módulo ha entrado en modo de suspensión

Octetos de errores sin los dos octetos de suma de comprobación (Checksum)

 Datos específicos devueltos

Si el octeto ACK está configurado en 0x01, el módulo emitirá datos cuando el

el fragmento estará terminado cuando la tarjeta SD (o el disco flash USB) esté
insertada o retirada o cuando el dispositivo de almacenamiento está en línea. Estos

valeurs seront renvoyées sans envoyer de commande au module.

Los datos devueltos del dispositivo de almacenamiento cuando se inserta

0x7E 0xFF 0x060x3A 0x00 0x00 A 0xFE 0xF7 0xEF
dónde
0x3A indique que el dispositivo de almacenamiento está insertado

Los datos devueltos del dispositivo de almacenamiento cuando fue extraído

0x7E 0xFF 0x060x3B0x00 0x00A0xFE 0xF7 0xEF
dónde
0x3B indique que el dispositivo de almacenamiento esté ejectado
A =0x01 indica que el dispositivo de almacenamiento es una memoria USB
A =0x02 indica que el dispositivo de almacenamiento es una tarjeta SD

A =0x04 indica si el cable USB está conectado o no

Los datos devueltos de la pieza terminada están en el siguiente formato

0x7E 0xFF 0x060x3D 0x000x00 0x05 0xFE 0xF7 0xEF
dónde
0x3D indique que le morceau est terminé sur la carte SD (0x3C = USB),
0x00 0x05 indique la pieza "0005"
Los datos devueltos cuando el dispositivo de almacenamiento está en línea
0x7E 0xFF 0x060x3F 0x00 0x00 A 0xFE 0xF7 0xEF
donde
0x3F indique que el dispositivo de almacenamiento está en línea, y “A” puede tener
varias valores diferentes :

A =0x01 indique une mémoire USB

A =0x02 indica una tarjeta SD
A =0x03 indica una memoria USB y una tarjeta SD al mismo tiempo
A =0x04 indique une connection PC
 Valores devueltos de lectura

Si el octeto ACK está definido en 0x01, enviamos el comando para el estado.

de lectura :
0x7E 0xFF 0x060x45 0x00 0x00 0x00 chks1 chks0 0xEF

Los datos devueltos estarán en el formato:

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

donde "A" puede tener varios valores diferentes :

A =0x00 indica que la lectura está configurada para leer y reproducir en bucle
todos los trozos del dispositivo de almacenamiento
A =0x01 indica que la lectura está configurada para leer y hacer bucle
todos los fragmentos del expediente específico
A =0x02 indica que la lectura está configurada para leer y reproducir en bucle un

trozo
A =0x03 indica que la lectura está configurada en lectura aleatoria y pone en
reproduce todas las canciones del dispositivo de almacenamiento

A =0x04 indica que la lectura está configurada para leer una sola pieza y que
la lectura se detiene cuando la pieza ha terminado

¡Lo has logrado!

Ahora puede usar su módulo para
diversos proyectos.
Ahora es el momento de aprender y crear tus propios proyectos. Tú
puedes hacerlo con la ayuda de muchos ejemplos de guiones y otros
tutorías que puedes encontrar en Internet.

Para productos microelectrónicos de Arduino y Raspberry Pi de

calidad superior AZ-Delivery Vertriebs es su interlocutor
privilegiado. Proporcionamos una serie de ejemplos de aplicación,
guías de instalación completas, libros electrónicos,
bibliotecas y una asistencia completa.

AZ-Delivery, su experto en microelectrónica.

[Link]

¡Diviértanse!

Mentions légales
[Link]