Benvenuto!

Vi ringraziamo per aver acquistato il modulo AZ-Delivery MP3 DFPlayer.

Nelle pagine che seguono, ti spiegheremo come utilizzare e
configurare questo dispositivo pratico.

Divertiti!
Il modulo MP3 DFPlayer Mini è un lettore MP3 piccolo e accessibile con
un'uscita diretta su un altoparlante o una cuffia. Il modulo può essere
utilizzato come un modulo autonomo con una batteria, un altoparlante e
pulsanti o utilizzati in combinazione con una scheda Arduino o
tutte le altre schede con capacità UART.

Il modulo supporta i formati audio comuni come MP3, WAV

et WMA. Supporta le schede MicroSD con il filesystem
FAT16 o FAT32. Puoi leggere musica tramite una semplice porta
serie senza alcuna operazione complessa.

Il modulo è fornito con due connettori maschi a 8 pin pre-saldati,

dispone di uno slot per una scheda di memoria MicroSD. Ci sono
anche un LED rosso integrato utilizzato per indicare lo stato di
lettura dei pezzi. Il LED è collegato al pin BUSY del modulo.
Lo stato acceso del LED indica che un brano è in fase di riproduzione.
Specificazione:

» Tensione di alimentazione da 3.2V a 5V DC

» Corrente di sorveglianza 20mA20mA
» Temperatura di utilizzo da -40℃ a 70℃
» Porta USART Standard (Livello TTL)
» Velocità default 9600bps, regolabile
» Equalizzatore 6 modalità, regolabili
» Volume 30 livelli, regolabili
» Frequenza di campionamento (kHz) 8/11.025/12/16/22/24/32/44.1/4848
» Uscita - 24 bit DAC per 90dB,
- SNR per 85dB
» Potenza di uscita 3W
» Impedanza HP 3Ω (massimo 8Ω)
» Sistema di file FAT16 o FAT32
» Dimensione massima - 32GB su SDcard,
32GB su memoria USB
- 64MB byte NORFLASH
» Tipi di controllo - Interfaccia I/O
- Porta seriale
- Pulsante AD
» Funzione di attesa del suonoINFOS(la musica può essere
sospesa, quando le INFOS sono terminate la musica continua a
giocare
» Dati audio ordinati per cartelle. Il modulo supporta
fino a 100 cartelle e ogni cartella può contenere fino a 255
pezzetti.
 Broccaggio

Le pin USART (UART) sono utilizzate per la comunicazione seriale.

Se si verifica un rumore elevato, collegare una resistenza di 1kΩ a
brocheTXen serie.

I pin del canale di uscita audio sono utilizzati come pin DAC.
(Convertitore da Digitale ad Analogico), e devi collegarli all'amplificatore
esterne.

I pin del diffusore sono pin dell'amplificatore da 3W

imbarcato, e puoi collegarli direttamente all'altoparlante
esterni (8Ω max).

Le broches ADKEY sono utilizzate per la modalità di controllo AD.

I pin del portTRIGGER sono utilizzati per regolare i livelli di

volume o per cambiare brano (materiale). Questi pin sono attivi
BASSO.

Le chiavette USB vengono utilizzate per collegare la memoria USB.

 Alimentazione e bus di collegamento BUSY

Il modulo supporta un intervallo di tensione di funzionamento da 3.2V a

5V DC. Collegare un'alimentazione esterna tra il pin di alimentazione
e il pin di massa (GND).

La tension del livello logico TTL della porta seriale del modulo è di 3,3V,
quindi quando utilizzi livelli di 5V (ad esempio la scheda Uno)
collegare in serie una resistenza di oltre 1kΩ al pin RX
Modulo. Se non utilizzi questa resistenza, avrai un rumore elevato
sui canali di uscita audio.

La broche d’état di lettura o BUSY è utilizzata per indicare lo stato di

lettura di un pezzo. Lo stato LOW su questo pin indica che il modulo
sta leggendo un pezzo, e lo stato HIGH indica che il modulo non legge
nessun pezzo.
 Canali di uscita audio e pin degli altoparlanti

La chip principale del modulo è un convertitore digitale-analogico

24 bit (DAC). La scheda ha due pin DAC che sono connessi
direttamente ai canali di uscita audio del modulo. Devi collegare
un amplificatore esterno sui pin dei canali di uscita audio affinché
di utilizzare le capacità DAC del modulo. Se vuoi utilizzare questi pin,
attiva prima l'uscita DAC inviando il comando corrispondente a
la pulce (più lontano nel testo).

Un circuito di amplificazione da 3W è integrato nel modulo. Il cuore di questo

circuit est un dispositif appelé "amplificateur audio 8002", un circuit intégré
(CI) a 8 pinne di cui l'uscita è collegata ai pin Speaker+ e
L'uscita del CI 8002 è mono.

Collegare l'altoparlante esterno al modulo come indicato su questo

schema di connessione :
 Porte TRIGGER di attivazione (pin IO)

Questi pin sono utilizzati per la commutazione dei pezzi e la regolazione

livelli di volume tramite l'hardware. Collega i pulsanti a pressione a
questi impulsi come indicato in questo schema :

Lorsque le bouton poussoir est à l’état de repos, les broches diagonales du

i pulsanti non sono connessi. Quando premi il
pulsante, questi pin sono collegati, il che attiva il pulsante-
pulsante in uno stato attivo.

Una pressione breve sul pulsante IO2 permette di leggere il brano

seguente. Una pressione lunga sul pulsante IO2 aumenta il
livello del volume.

Una pressione breve sul pulsante IO1 permette di leggere il brano

precedente. Una pressione prolungata sul pulsante IO2 diminuisce il
livello del volume.

La durata della spinta lunga è superiore a un secondo. Tutto ciò che

è inferiore a un secondo ed è considerato un impulso breve.
 Fibbietti ADKEY

La funzionalità AD del chip integrato nel modulo ti consente di

collegare 20 resistenze con dei pulsanti su due porte AD del modulo
come indicato in questo schema di connessione:

NOTA: È necessario che l'alimentazione sia il più stabile possibile

affinché funzioni correttamente!

Una breve pressione sul pulsante Modalità riproduzione attiva la lettura in modalità

interrotto o ininterrotto. Ciò significa che la lettura sarà o non sarà

interrotta da unaINFOS. Non c'è funzione di pressione prolungata
per questo pulsante.

Una breve pressione sul pulsante U/TF/SPI fa passare il dispositivo da

lettura di uno dei seguenti elementi: U= chiavetta USB, TF= scheda SD,
SPI= NORFLASH o Sleep. Non c'è una funzione di pressione prolungata
per questo pulsante.
Una pressione breve sul pulsante Loop All permette di passare dalla modalità di

lettura in loop di un brano alla lettura in loop di tutti i brani

o di non leggerli in loop. Non c'è una funzione di pressione prolungata.
per questo pulsante.

Una breve pressione sul pulsante Pause/Play pausa o avvia la riproduzione

pezzo selezionato. Non c'è funzione di pressione lunga per questo

pulsante.

Una pressione breve sul pulsante Pre/Vol+ consente di passare al brano

precedente. Una pressione prolungata sul pulsante Pre/Vol+ aumenta il livello
del volume.

Una pressione breve sul pulsante Next/Vol consente di passare al brano

suivant. Une pression longue sur le bouton Pre/Vol+ diminue le niveau du
volume.

Una pressione breve sul pulsanteSegment1 consente di riprodurre il brano

numero 1. Una pressione prolungata sul pulsante Segmento1 ripete la lettura
dalla stessa canzone.

Le funzioni sono le stesse per tutti gli altri pulsanti Segmento, tranne
per il numero di canzone che differisce.
 Porta Seriale

Le brocche RX e TX vengono utilizzate per stabilire una comunicazione seriale

con un microcontrollore esterno. Non dimenticate di collegare una resistenza
à la broche RX lorsque vous utilisez une logique TTL 5V. Le port série du
il modulo supporta la modalità di comunicazione seriale asincrona. La velocità in

I baud di default della comunicazione seriale sono 9600 bps ed è

regolabile tramite software.

Puoi utilizzare la porta seriale per inviare comandi semplici al

modulo e così controllare molte funzioni supportate dal
modulo. Scoprirete di più sui comandi nel capitolo successivo.

Specifiche

Tasso di baud 9600bps

Bit di dati 1
Cassa non
Controllo del flusso non
 Formato degli ordini

Per inviare un comando al modulo, segui il formato specifico:

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

Nome Ottetto Descrizione dell'ottetto

$SB 0x7E Ottetto di inizio

VB 0xFFVersion ottetto
LB 0xxxIl numero di byte del comando senza
ottetti di inizio e di fine (Nel nostro caso, 0x06)
CMD 0xxxCome GIOCA, PAUSA, ecc.
ACK 0xxxACK0x00= NON,0x01= OUI
DATA1 0xxxOctet de données haut
DATA2 0xxxOttetto di dati bas
CHKS1 0xxxOttetto ALTO del checksum
CHKS2 0xxxOttetto BAS del checksum
$EB 0xEF Ottetto di fine

L’octet ACK est utilisé pour ottenere dati dal modulo. Se è impostato a
0x00, nessun dato sarà inviato dal modulo e se è impostato su
0x01, riceverete i dati di risposta dal modulo. La lunghezza dei
i dati non sono limitati, ma di solito sono di due byte
(datiottetti1edati2).

Per inviare un comando specifico, basta inviare un byte per

ottetto in serie sull'interfaccia serie del software (puoi vedere questo più avanti
nel codice).
 Structure des dossiers et noms des chansons

Il modulo supporta diversi tipi di file e nomi

specifici per i brani. I nomi delle cartelle sono numeri, a
l'eccezione dei dossier "mp3" e "ADVERT". I nomi dei pezzi
devono iniziare con un numero dopo il quale viene la stringa di
caratteri senza spazio. Esempio di nome del brano:
0001_Linkin_Park_Nella_Fine.mp3

Ci sono cinque tipi di file:

Il primo può contenere 256 pezzi. Il modulo supporta 256 di

questi fascicoli in totale. I nomi di questi fascicoli sono numeri compresi
tra 000 e 255. I nomi dei brani in queste cartelle iniziano
da numeri compresi tra 000 e 255. Il modulo non considera
carica le sottocartelle.

Il secondo può contenere 3000 pezzi. Il modulo supporta 16 di

questi dossier in totale. I nomi di questi dossier sono numeri compresi
tra 00 e 15. I nomi dei brani in queste cartelle iniziano con
numeri compresi tra 0000 e 2999. Il modulo non prende in
carica le sottocartelle.

Il terzo si chiama “mp3” e può anch'esso contenere 3000 brani.

Il modulo supporta una sola cartella "mp3" in totale. I nomi dei
i pezzi in questa cartella iniziano con numeri compresi tra
0000 e 2999. Il modulo non supporta le sottocartelle.
Il quarto è chiamato “ADVERT”, che può anch'esso contenere 3000
morceaux e che è utilizzato per INFOS. Il modulo supporta un solo
dossier "ADVERT" in totale. I nomi dei file in questo dossier
iniziano con numeri compresi tra 0000 e 2999. Il modulo non
non supporta le sottocartelle.

Infine, il quinto è la cartella radice "root". Se si tratta dell'unica cartella di

la scheda SD o della chiavetta USB (nessun'altra cartella), questa cartella può contenere

fino a 65.536 pezzi. Questa cartella può avere sottocartelle, y

comprende tutti i tipi di dossier. Il dossier "root" può contenere dei
canzoni e sottocartelle allo stesso tempo.

Esempio di struttura della cartella :

radice
---0001r.mp3
---0002r.mp3
---0003r.mp3
---0004r.mp3
---0001
--- ---0001x.mp3
--- ---0002x.mp3
---0002
--- ---0001y.mp3
---mp3
--- ---0001m.mp3
--- ---0002m.mp3
--- ---0003m.mp3
---PUBBLICITÀ
--- ---0001a.mp3
--- ---0002a.mp3
 Invio di comandi al modulo

Per inviare comandi al modulo, collega il modulo con

l'Arduino Uno come indicato nello schema di connessione qui sotto:

Modulo > Uno

VCC > 5V Rosso
RX > D7 (attraverso una resistenza di 1kΩ) Blu

TX > D6 Vert
GND > GND Noir

Modulo > Altoparlante

SPK - > Broche - dell'altoparlante Violetto
SPK+ > Broche + altoparlante Viola

NOTA: Puoi utilizzare qualsiasi altra carta con un

microcontrollore che ha capacità UART.
Utilizziamo l'interfaccia software seriale sui pin di I/O digitali 6
e 7 dell'Uno, poiché l'Uno utilizza i pin serie hardware (pin di I/O
numerici 0 e 1), per la programmazione del microcontrollore principale.

Il microcontrollore non può inviare comandi per controllare il

modulo finché l'inizializzazione del modulo non è completata e che i
Le informazioni sullo stato non sono state restituite. Altrimenti gli ordini
inviati dal microcontrollore saranno ignorati e ciò influenzerà il
processo di inizializzazione.
Se non diversamente indicato (inviando un comando dopo
l'inizializzazione), quando il modulo è acceso, legge prima la scheda
SD e se non è disponibile, passa alla memoria USB.
Esempio di codice

#include "SoftwareSerial.h"
#defineByte_Inizio 0x7E
#define Version_Byte 0xFF
#define Lunghezza_Comando 0x06
#define End_Byte 0xEF
// Restituisce informazioni con comando 0x41 [0x01: informazioni, 0x00: nessuna informazione]
#define Acknowledge 0x01
SoftwareSerial mySerial(6, 7);// RX, TX
byte ricevi_buffer[10] = {0, 0, 0, 0, 0, 0, 0, 0, 0, 0};
char data;// Utilizzato per i comandi ricevuti dal Monitor Seriale
byte volume = 0x00;// Utilizzato per memorizzare il livello attuale del volume
bool mute_state = false; // Usato per attivare/disattivare lo stato muto

// Esegui il comando e i parametri

void eseguire_CMD(byte Comando, byte Dati1, byte Dati2) {
// Calcola il checksum (2 byte)
word Checksum = -( Version_Byte + Command_Length + Command +
Riconosci + Dati1 + Dati2);
// Build the command
byte command_line[10] = { Start_Byte, Version_Byte,
Command_Length, Command, Acknowledge,
Data1, Data2, byteAlto(Checksum),
lowByte(Checksum), End_Byte};
Invia la riga di comando al modulo
per(byte k = 0; k < 10; k++) {
[Link](command_line[k]);
}
}
void reset_rec_buf() {
per(uint8_t i = 0; i < 10; i++) {
receive_buffer[i] = 0;
}
}

bool ricevi() {
reset_rec_buf();
se([Link]() < 10) {
ritorna falso;
}
per(uint8_t i = 0; i < 10; i++) {
short b = [Link]();
se(b == -1) {
ritorna falso;
}
receive_buffer[i] = b;
}
Quando ripristini il modulo nel software,
Gli elementi del buffer ricevuti vengono spostati.
// Per correggere ciò facciamo quanto segue:
short b = ricevi_buffer[0];
per(uint8_t i = 0; i < 10; i++) {
se(i == 9) {
receive_buffer[i] = b;
}
altrimenti {
receive_buffer[i] = receive_buffer[i+1];
}
} // Fine correzione receive_buffer
restituire vero;
}
void print_received(bool print_it) {
se(stampa) {
se(ricevi()) {
per(uint8_t i = 0; i < 10; i++) {
[Link](receive_buffer[i],HEX);[Link]("\t");
}
[Link]();
 }
}
altrimenti { ricevi(); }
}
void modulo_inizializzazione() {
esegui_CMD(0x0C, 0, 0); ritarda(1000);// Ripristina il modulo
print_received(falso);delay(100);
[Link]("SDON\t");
stampa_ricevuto(true);ritardo(100);
giocaPrimo();
impostaVolume(0x09);
}
void play_first() {
[Link]("PLYFST\t");
esegui_CMD(0x03, 0, 1); ritardo(100); // Suona la prima canzone
stampa_ricevuta(falso);ritardo(100);
esegui_COMANDO(0x45, 0, 0); ritardo(100);// Ottieni stato di riproduzione
print_ricevuto(falso);ritarda(100);
stampa_ricevuto(true);ritarda(100);
}
void set_volume(uint8_t volume) {
[Link]("IMPOSTA VOLUME\t");
execute_CMD(0x06, 0, volume); delay(100);// Imposta il livello del volume
stampa_ricevuto(falso);ritarda(100);
eseguire_CMD(0x43, 0, 0); ritardo(100);// Ottieni il livello del volume
stampa_ricevuto(false);ritarda(100);
stampa_ricevuto(true);ritardo(100);
}
void play_next() {
[Link]("NEXT\t");
esegui_CMD(0x01, 0, 0); ritardo(100);
print_received(false);delay(100);
esegui_CMD(0x4C, 0, 0); ritardo(100);// Ottieni la canzone attualmente riprodotta
stampa_ricevuto(false);ritarda(100);
stampa_ricevuto(true);ritardo(100);
}
void silenzia() {
mute_state = !mute_state;
se(mute_state) {
execute_CMD(0x43, 0, 0); delay(100);// Restituisci il livello del volume
stampa_ricevuto(falso);ritardo(100);
stampa_ricevuto(false);ritarda(100);
volume = ricevi_buffer[6];
[Link]("MUTE\t");
esegui_CMD(0x06, 0, 0x00); ritardo(100);// Imposta il livello del volume
stampa_ricevuto(falso);ritarda(100);
esegui_CMD(0x43, 0, 0); ritardo(100);// Ottieni il livello del volume
stampa_ricevuto(false);ritardo(100);
stampa_ricevuto(true);ritardo(100);
}
// una scheda
altro {
[Link]("VOL\t");
esegui_CMD(0x06, 0, volume); ritardo(100);// Imposta volume precedente
stampa_ricevuto(falso);ritardo(100);
esegui_CMD(0x43, 0, 0); ritardo(100);// Ottieni il livello del volume
stampa_ricevuto(falso);ritardo(100);
stampa_ricevuto(true);ritarda(100);
}
}

void gioca_a_caso() {
La riproduzione casuale riproduce tutte le canzoni, le ripete in loop e ripete le canzoni durante la riproduzione
esegui_CMD(0x18, 0, 0);
ritardo(100);
[Link]("RNDM\t");
stampa_ricevuto(false);
ritarda(100);
execute_CMD(0x4C, 0, 0); // Ottieni la canzone attuale riprodotta
ritarda(100);
stampa_ricevuta(falso);
ritarda(100);
stampa_ricevuto(true);
ritarda(100);
}
void query_status() {
esegui_CMD(0x42, 0, 0); ritardo(100);// Ottieni stato del modulo
print_received(false); delay(100);
[Link]("STATO\t");
stampa_ricevuto(true);ritardo(100);
esegui_CMD(0x43, 0, 0); ritardo(100);// Ottieni il livello di volume
stampa_ricevuto(falso);ritardo(100);
[Link]("VOLUME\t");
stampa_ricevuto(true);ritardo(100);
esegui_CMD(0x44, 0, 0); ritardo(100);// Ottieni lo stato EQ
stampa_ricevuto(falso);ritarda(100);
[Link]("EQ\t");
stampa_ricevuto(true);ritardo(100);
execute_CMD(0x45, 0, 0); delay(100);// Ottieni stato di riproduzione
stampa_ricevuto(false);ritarda(100);
[Link]("PLYBCK\t");
stampa_ricevuto(true);ritarda(100);
esegui_CMD(0x46, 0, 0); ritardo(100);// Ottieni versione software
stampa_ricevuto(false);ritarda(100);
[Link]("SFVER\t");
stampa_ricevuto(true);ritardo(100);
Ottieni il numero totale di file sul dispositivo di archiviazione
esegui_CMD(0x48, 0, 0); ritardo(100);
stampa_ricevuto(falso);ritardo(100);
[Link]("FILE ");
stampa_ricevuto(true);ritardo(100);
execute_CMD(0x4C, 0, 0); delay(100);// Ottieni la canzone attualmente in riproduzione
print_received(false);delay(100);
[Link]("CRRTRK\t");
stampa_ricevuto(true);ritardo(100);
}
vuoto setup() {
[Link](115200);
[Link](9600);delay(1000);

Inizializzazione
modulo_inizializza();
}
vuoto ciclo() {
stampa_ricevuto(true);

while([Link]() > 0) {
data = [Link]();
// [Link](data, HEX); // Per il debug
se(data !="/n") {
se(data =='N') {
Riproduci la prossima canzone
play_next();
}
altrimenti se(data =='B') {
Riproduzione casuale
gioco_random();
}
// .....
altrimenti se(data =='D') {
Richiedi lo stato del modulo
query_status();
}
}
}
ritarda(100);
}
Il codice inizia includendo una libreria chiamata
SoftwareSerial.h

Successivamente, definiamo cinque macro. Queste macro rappresentano i byte

di ordine che sono gli stessi per tutti gli ordini. Il primo
l'ottetto è chiamato "Start_Byte" il cui valore è 0x7E, il secondo ottetto è
chiamato "Version_Byte" il cui valore è 0xFF, il terzo ottetto è
chiamato "Command_Length" di cui il valore è 0x06, il quarto ottetto è
chiamato "End_Byte" il cui valore è 0xEF e il quinto byte è chiamato
Riconosci

Successivamente, definiamo l'oggetto software seriale chiamato "mySerial" con questo

linea di codice: SoftwareSerial mySerial(6, 7);
Dove rappresenta il pin I/O digitale dell'Uno su cui si trova il pin RX
il modulo è connesso e rappresenta il pin I/O digitale dell'Uno
sulla quale è connessa la brocheTX del modulo.

Successivamente, creiamo un array chiamato "receive_buffer", che comprende dieci

elementi. Gli elementi della tabella “receive_buffer” rappresentano i byte
che sono inviati dal modulo e ricevuti dalla Uno.

Dopo ciò, creiamo tre variabili. La prima si chiama "data" e

è utilizzata per memorizzare gli ordini quando li inviamo
dal monitor seriale. La seconda variabile si chiama "volume" e essa
viene utilizzato per memorizzare il livello di volume attuale, quando inviamo
la comando “Mute”. La terza variabile è chiamata “mute_state” e essa
è utilizzata per commutare lo stato muto del modulo.
Poi creiamo diverse funzioni. La prima funzione si chiama
"execute_CMD()" accetta tre argomenti e non restituisce alcun valore.
La funzione execute_CMD() è utilizzata per inviare comandi al
modulo. Il primo argomento è il byte di comando, il secondo è
l'octetto di dati 1 e il terzo è l'octetto di dati 2 della
ordine. All'inizio della funzione execute_CMD() calcoliamo i
ottetti di checksum con questa riga di codice:

checksum = -(Versione_Byte + Lunghezza_Comando + CMD +

Riconosci + Par1 + Par2);

Successivamente, creiamo un array di comandi, chiamato 'command_line'.

Questo tableau comprende dieci elementi, che rappresentano dieci byte di
comando: Byte_Inizio, Byte_Versione, Lunghezza_Comando, Comando,
Riconosci Data1 Data2 highByte(Checksum),
lowByte(Checksum), etEnd_Byte. Alla fine della funzione execute_CMD(),
Utilizziamo il ciclo for per inviare i dieci byte, uno alla volta, al
modulo tramite il software seriale.

La funzione seguente si chiama “reset_rec_buf()” e viene utilizzata per

reimpostare a zero tutti i valori degli elementi derecive_buffer, o per
reimpostare il buffer. La funzione reset_rec_buf() non accetta alcun
argomento e non restituisce alcun valore.

Creiamo quindi una funzione chiamata “receive()”, che viene utilizzata per
ricevere byte dal modulo e memorizzarli nell'array
receive_buffer. La funzione receive() non accetta alcun argomento e restituisce
un valore booleano. All'inizio della funzione receive(), chiamiamo
reset_rec_buf() per reimpostare il tableau receive_buffer.
Successivamente, verifichiamo se ci sono dati sulla porta seriale software e se questi
i dati hanno dieci byte.

Se i dati di ritorno contengono dieci byte, utilizziamo il ciclo for

per leggere i dieci byte. Dopo aver letto un byte, verifichiamo se il suo valore
è valida controllando se è diversa da “-1”. Se è diversa, noi
memorizza il suo valore nel buffer di ricezione. Se uno dei controlli non è
non soddisfatto, il valore booleano restituito è "falso" altrimenti, questo valore
è "vero". Quando ripristiniamo il modulo nel software, i
gli elementi di buffer di durezza sono sfalsati, quindi dobbiamo correggere ciò.

Facciamo la correzione con il codice seguente :

short b = ricevi_buffer[0];
per(uint8_t i = 0; i < 10; i++) {
if(i == 9) {
receive_buffer[i] = b;
}
altrimenti {
receive_buffer[i] = receive_buffer[i+1];
}
}

Dopo di ciò, creiamo una funzione chiamata "print_received()" che è

utilizzata per visualizzare i dati ricevuti sul monitor seriale. La funzione
print_received() accetta un argomento, un valore booleano che è
utilizzata per determinare se i dati devono essere stampati o meno. Se la
valeur de l'argument est égale à “true”, nous appelons la fonctionreceive()
e visualizziamo i dati di recibe_buffer. Se il valore dell'argomento è
uguale a "false", chiamiamo solo la funzione receive() senza
afficher les données.
Dopo queste funzioni, creiamo diverse altre funzioni che utilizzano i
funzioni precedenti. Tutte queste nuove funzioni sono esplicite.

Nella funzione setup() iniziamo la porta seriale hardware con una

velocità di trasmissione di 115.200 bps e la porta seriale software con una
velocità di trasmissione di 9.600 bps (che è la velocità di trasmissione per
difetto del modulo). Poi, chiamiamo la funzione module_init() che
inizia il modulo, imposta l'equalizzatore, il livello del volume, riproduci il primo
morsetto sul dispositivo di archiviazione e visualizza i dati di stato su
monitor serie.

Nella funzione loop() aspettiamo dati sulla porta seriale. Questi

I dati vengono inviati dal monitor seriale quando inviamo una
ordine. I dati sono una delle lettere seguenti: N, B, D e
diverse altre lettere. Controlliamo quale lettera viene inviata e poi
chiamiamo la funzione corrispondente.

Il codice dello sketch in questo eBook è solo un esempio. Se vuoi vedere

lo sketch completo, visita il deposito al seguente link GitHub:

[Link]
Quando scaricate l'esempio completo dello sketch sull'Arduino Uno
avvia il Monitor Serial e invia alcuni comandi all'Arduino.
L'uscita dovrebbe somigliare a quella dell'immagine qui sotto:
 Esempi di comandi

Comando Byte (HEX) * Description

Pezzo successivo 7E FF 060100 00 00 EF Leggi il brano seguente

Morso precedente 7E FF 060200 00 00 EF Lire le morceau précédent

7E FF 06030000 01EF Leggi il primo pezzo

Lettura con indice
7E FF 06030000 02EF Leggere il secondo pezzo

Volume più 7E FF 060400 00 00 EF Monte il volume di un livello

Volume meno 7E FF 060500 00 00 EF Abbassa il volume di un livello

Volume 7E FF 06060000 1EEF Imposta il volume a 30 (=0x1E)

Metti l'egalizzatore a 02 - Rock

Modalità equalizzatore 7E FF 060700 0002EF 00 / 01 / 02 / 03 / 04 / 05
Normale/Pop/Rock/Jazz/Classica/Base

Morbido in loop 7E FF 06080000 01EF Ripeti il brano 0001

7E FF 060900 0001EF Selezione chiavetta USB

Choix du média
7E FF 060900 0002EF Selezione memoria SDcard

Veille 7E FF 060A00 00 00 EF Veglia

Sveglia 7E FF 060B00 00 00 EF Attivazione

Reset 7E FF 060C00 00 00 EF Ripristina

Lezione 7E FF 060D00 00 00 EF Riprendi la lettura

Pausa 7E FF 060E00 00 00 EF Lettura in pausa

Lettura di un pezzo in un Suona il pezzo

7E FF 060F0001 01EF
dossier che può contenere 256 01/0001xxx.mp3
morceaux ; il modulo può
contenere 256 cartelle (0 - 255) 7E FF 060F0001 02EF Suona il brano
con 255 pezzi. 01/0002xxx.mp3

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

Amplificatore
7E FF 06100000 00EF 00 – Ampli OFF

7E FF 061100 0001EF Leggi tutto in loop

Boucle totale
7E FF 061100 0000EF Ferma la riproduzione in loop

Leggi 0001 nella cartella mp3

Dossier di lezione mp3 7E FF 06120000 01EF
(0x0001 – 0x0BB8; 3000 pezzi)

Leggi 0001 nella cartella ADVERT

Dossier di lezione PUBBLICITÀ 7E FF 06130000 01EF
(0x0001 – 0x0BB8; 3000 pezzi)

* Ottetti di comando senza i due ottetti di controllo (Checksum)

 Comando Byte (HEX) * Descrizione

Lettura di un pezzo in un 7E FF 06140000 01EF Dossier 0 pezzo 001

dossier contenitore 3000
7E FF 06140091 11EF Dossier 9 pezzo 273 (=0x111)
morceaux ; il modulo supporta
16 dossier (0-15) con 3000
7E FF 061400F0 05EF Dossier 15 (=0xF) pezzo 005
canzoni.
Interruzione della lettura INFO e ritorno alla lettura
Interruzione lettura INFO 7E FF 061500 00 00 EF
precedente

Lezione attiva in loop totale dal

Attivare il ciclo totale 7E FF 061600 0001EF
pezzo 001

Arrêt lecture 7E FF 061600 0000EF Interruzione della lettura

Morsetto in loop in un
dossier che può contenere 256 7E FF 06170001 02EF Boucle pezzo 02 Cartella 01
canzoni

Lezione casuale 7E FF 061800 00 00 EF Riproduzione casuale di tutti i brani

7E FF 061900 0000EF Scelta del pezzo di partenza del loop

Scelta del ciclo semplice
7E FF 061900 0001EF Scelta brano fine ciclo

7E FF 061A00 0000EF Sortita attiva DAC

DAC
7E FF 061A00 0001EF Fermare uscita DAC

Volume a 30 (0x1E è 30) lettura

7E FF 0622001E 01EF
morceau 01
Lettura brano con volume
Volume a 15 (0x0F è 15) lettura
7E FF 0622000F 02EF
pezzo 02

* Ottetti di comando senza i due ottetti di controllo (Checksum)

 Aggiornamento dello stato del modulo

C'è un'opzione se vuoi ottenere i dati di ritorno dal modulo.

Questi dati sono molto utili, poiché possono contenere informazioni
sullo stato attuale della lettura, il livello di volume, l'opzione di equalizzazione, la
fine del brano in riproduzione, ecc. Per attivare questa opzione, voi
devi definire l'octetto ACK del comando al valore 0x01 (0x00 no)
dati di ritorno).

Quando invii un ordine con Acknowledge impostato su 0x01,

I dati ritornano. Ecco l'elenco degli ordini da inviare al modulo
nell'ordine per ottenere aggiornamenti di stato:

Comando (HEX) * Descrizione

7E FF 063F00 00 00 EF Per ottenere il dispositivo di archiviazione attuale

7E FF 064000 0001EF Dati di ritorno che indicano l'errore, dove 01 è il valore dell'errore.

Dati di ritorno senza errori. Ciò indica che l'ordine è stato

7E FF 06410000 00EF
ricevuta ed eseguita con successo, dove 00 00 è lo stato del modulo.

7E FF 064200 00 00 EF Per ottenere lo stato della lettura

7E FF 064300 00 00 EF Per ottenere il livello di volume attuale

7E FF 064400 00 00 EF Per ottenere lo stato attuale dell'equalizzatore

7E FF 064700 00 00 EF Per ottenere il numero totale di file sulla chiavetta USB

7E FF 064800 00 00 EF Per ottenere il numero totale di file sulla scheda SD

7E FF 064B00 00 00 EF Per ottenere il numero del brano attuale sulla chiavetta USB

7E FF 064C00 00 00 EF Per ottenere il numero del brano attuale sulla scheda SD

7E FF 064E00 00 00 EF Per ottenere il numero totale di file su un supporto di archiviazione

7E FF 064E00 0002EF Per ottenere il numero totale di file nella cartella 02

7E FF 064E00 000CEF Per ottenere il numero totale di file nella cartella 12

7E FF 064F00 00 00 EF Per ottenere il numero totale di file su un dispositivo di archiviazione

* Ottetti di comando senza i due ottetti di somma di controllo (Checksum)

 Valori restituiti

I dati di ritorno sono nel formato

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

Il valore 0x41 indica che un comando è stato ricevuto dal modulo e

eseguita con successo.

Il valore "A" rappresenta i supporti di memorizzazione, dove

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

Il valore "B" indica lo stato della lettura, dove

B = 0x00 indica che la lettura è fermata
B = 0x01 indica che la lettura è in corso
B = 0x02 indica che la lettura è in pausa

Esempio di dati restituiti :

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

dove
0x02 il dispositivo di archiviazione è una scheda SD
0x01 La lettura è in corso
 Errori

Se si verifica un errore, i dati di ritorno saranno nel formato:

0x7E 0xFF 0x060x40 0x00 0x00 0x01 chks1 chks0 0xEF
Dove
0x40 indica che si è verificato un errore e 0x01 è il valore dell'errore.

I valori di errore con la loro descrizione sono riportati nella tabella qui sotto.

sotto
Valore Errore (HEX) * Description
7E FF 064000 0001EF Il modulo è occupato

7E FF 064000 0002EF Il modulo è in modalità standby

7E FF 064000 0003EF Errore di ricezione in serie

7E FF 064000 0004EF Errore di checksum errato

7E FF 064000 0005EF Il brano specificato è inaccessibile

7E FF 064000 0006EF Il pezzo specificato non è trovato

7E FF 064000 0007EF Errore di intercalazione di INFOS

Errore di lettura SDcard

Il modulo è entrato in modalità sospensione

* Ottetti di errore senza i due ottetti di somma di controllo (Checksum)

 Dati specifici restituiti

Se l'octetto ACK è impostato su 0x01, il modulo emetterà dati quando il

Il pezzo sarà completato quando la scheda SD (o l'unità flash USB) sarà
inserita o rimossa o quando il dispositivo di archiviazione è online. Questi
i valori saranno restituiti senza inviare alcun comando al modulo.

I dati restituiti dal dispositivo di archiviazione quando viene inserito

0x7E 0xFF 0x060x3A 0x00 0x00 A 0xFE 0xF7 0xEF
dove
0x3A indica che il dispositivo di archiviazione è inserito

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

0x7E 0xFF 0x060x3B0x00 0x00A0xFE 0xF7 0xEF
dove
0x3B indica che il dispositivo di memorizzazione è espulso
A =0x01 indica che il dispositivo di archiviazione è una memoria USB
A =0x02 indica che il dispositivo di archiviazione è una SDcard
A =0x04 indica se il cavo USB è connesso o meno

I dati restituiti del pezzo completato sono nel seguente formato

0x7E 0xFF 0x060x3D 0x000x00 0x05 0xFE 0xF7 0xEF
dove
0x3D indica che il pezzo è terminato sulla scheda SD (0x3C = USB)
0x00 0x05 indique le morceau "0005"
I dati restituiti quando il dispositivo di archiviazione è online
0x7E 0xFF 0x060x3F 0x00 0x00 A 0xFE 0xF7 0xEF
dove
0x3F indica che il dispositivo di archiviazione è online, e 'A' può avere
diverse valori diversi :

A =0x01 indica una memoria USB

A =0x02 indica una SDcard
A =0x03 indica una memoria USB e una scheda SD contemporaneamente
A =0x04 indica una connessione PC
 Valori restituiti di lettura

Se l'octet ACK è definito a 0x01, inviamo il comando per lo stato

di lettura :
0x7E 0xFF 0x060x45 0x00 0x00 0x00 chks1 chks0 0xEF

I dati restituiti saranno nel formato:

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

dove "A" può avere più valori diversi :

A =0x00 indica che la lettura è impostata per leggere e ripetere

tutti i pezzi del dispositivo di archiviazione
A =0x01 indica che la lettura è impostata per leggere e ripetere
tutti i pezzi della cartella specifica
A =0x02 indica che la lettura è impostata per leggere e ripetere un
pezzo
A =0x03 indica che la lettura è impostata sulla lettura casuale e mette in
ripeti tutte le canzoni dalla memoria di archiviazione
A =0x04 indica che la lettura è impostata per leggere un solo pezzo e che
la lettura si ferma quando il brano è finito

Ce l'hai fatta!
Ora puoi usare il tuo modulo per
diversi progetti.
È ora di imparare e creare i propri progetti. Tu
puoi farlo utilizzando numerosi esempi di script e altro
tutorial che puoi trovare su Internet.

Per prodotti microelettronici Arduino e Raspberry Pi di

qualità superiore AZ-Delivery Vertriebs è il tuo interlocutore
privilegiato. Forniamo una serie di esempi di applicazione,
guide di installazione complete, eBook, delle
biblioteche e un'assistenza completa.

AZ-Delivery, il tuo esperto in microelettronica.

[Link]

Divertiti!

Note Legali
[Link]