Lettore Mp3 con lettore DF - Dettagli completi di progettazione

In questo post costruiremo un lettore Mp3 usando arduino e DFPlayer. L'articolo proposto ha due design di lettore Mp3, uno con comando a pulsante e un altro con telecomando IR. Daremo anche uno sguardo a DFPlayer (modulo lettore Mp3) e alle sue specifiche.

Tutti noi amiamo la musica, ci piacerebbe ascoltarla mentre siamo in palestra, leggiamo, pochi istanti prima di dormire o mentre ci rilassiamo dopo una dura giornata di lavoro.

Costruire un lettore musicale a casa qualche decennio fa era quasi impossibile per un appassionato di elettronica a causa della complessità costruttiva dovuta ai componenti meccanici.

A quei tempi solo un numero limitato di canzoni poteva essere contenuto in una cassetta. Anche replicare una canzone su un'altra cassetta è stato un incubo. Ma ora, grazie al progresso dell'elettronica, un lettore Mp3 può essere creato da zero con la tua paghetta.

Ora passiamo ai dettagli tecnici del progetto.

Il cuore del progetto è DFPlayer che è un piccolo modulo lettore Mp3 che può ospitare una scheda micro SD e può essere controllato utilizzando un microcontrollore.

Illustrazione di DFPlayer:

Ha un amplificatore integrato che può pilotare altoparlanti da 3 watt in stereo o mono. Ha un convertitore da digitale ad analogico (DAC) a 24 bit che è abbastanza buono per un modulo così compatto e a basso costo.

Vista dal basso di DFPlayer:

Supporta la decodifica hardware MP3 e WMV. Supporta la frequenza di campionamento di
8 KHz, 11,025 KHz, 12 KHz, 1 6 KHz, 22,05 KHz, 24 KHz, 32 KHz, 44,1 KHz, 48 KHz.

Può supportare fino a 32 GB di scheda micro SD. Supporta fino a 100 cartelle, ogni cartella può essere assegnata fino a 1000 brani.

Dispone di 6 diversi livelli di equalizzazione e 30 livelli di controllo del volume. Può funzionare da 3,2 V a 5 V.

Configurazione dei pin di DFPlayer:

Le specifiche di cui sopra si basano sulla scheda tecnica di DFPlayer.

A questo punto avresti familiarità con DFPlayer e le sue specifiche. È possibile acquistare questo modulo dai siti di e-commerce o dal mercato dell'elettronica locale.

Ora passiamo al diagramma schematico.

Design del lettore Mp3 a pulsante:

Il circuito sopra è molto semplice, arduino invia comandi al modulo DFPlayer per controllare le canzoni. L'utente può inserire la propria scelta tramite pulsanti.

La resistenza di pull-up incorporata di arduino è stata attivata nel programma, quindi non è necessario collegare una resistenza fisica ai pulsanti.

Prova a utilizzare altoparlanti di buona qualità, DFPlayer può fornire un suono di ottima qualità.

Se trovi distorsioni nel suono a livelli di volume più alti, alimenta esternamente il modulo DFPlayer a 5 V CC con una connessione a terra comune tra arduino e DFPlayer.

Se desideri impostare l'audio stereo, collega quello dell'altoparlante a SPK1 di DFPlayer e un altro altoparlante a SPK2 e collega a terra i cavi degli altoparlanti rimanenti.

Programma per comando a pulsante:

//---------Developed by R.Girish------//
#include
SoftwareSerial mySerial(10, 11)
# define Start_Byte 0x7E
# define Version_Byte 0xFF
# define Command_Length 0x06
# define End_Byte 0xEF
# define Acknowledge 0x00
const int btnNext = A0
const int btnPause = A1
const int btnPrevious = A2
const int volumeUP = A3
const int volumeDOWN = A4
int volume = 15
boolean Playing = false
void setup ()
{
pinMode(btnPause, INPUT)
pinMode(btnNext, INPUT)
pinMode(btnPrevious, INPUT)
pinMode(volumeUP, INPUT)
pinMode(volumeDOWN, INPUT)
digitalWrite(btnPause, HIGH)
digitalWrite(btnNext, HIGH)
digitalWrite(btnPrevious, HIGH)
digitalWrite(volumeUP, HIGH)
digitalWrite(volumeDOWN, HIGH)
mySerial.begin(9600)
delay(1000)
playFirst()
Playing = true
}
void loop ()
{
if (digitalRead(btnPause) == LOW)
{
if(Playing)
{
pause()
Playing = false
}
else
{
Playing = true
play()
}
}
if (digitalRead(btnNext) == LOW)
{
if(Playing)
{
next()
}
}
if (digitalRead(btnPrevious) == LOW)
{
if(Playing)
{
previous()
}
}
if(digitalRead(volumeUP) == LOW)
{
volumeINC()
}
if(digitalRead(volumeDOWN) == LOW)
{
volumeDEC()
}
}
void playFirst()
{
exe_cmd(0x3F, 0, 0)
delay(500)
exe_cmd(0x06, 0, volume)
delay(500)
exe_cmd(0x11,0,1)
delay(500)
}
void pause()
{
exe_cmd(0x0E,0,0)
delay(500)
}
void play()
{
exe_cmd(0x0D,0,1)
delay(500)
}
void next()
{
exe_cmd(0x01,0,1)
delay(500)
}
void previous()
{
exe_cmd(0x02,0,1)
delay(500)
}
void volumeINC()
{
volume = volume+1
if(volume==31)
{
volume=30
}
exe_cmd(0x06, 0, volume)
delay(500)
}
void volumeDEC()
{
volume = volume-1
if(volume==-1)
{
volume=0
}
exe_cmd(0x06, 0, volume)
delay(500)
}
void exe_cmd(byte CMD, byte Par1, byte Par2)
{
word checksum = -(Version_Byte + Command_Length + CMD + Acknowledge + Par1 + Par2)
byte Command_line[10] = { Start_Byte, Version_Byte, Command_Length, CMD, Acknowledge, Par1, Par2, highByte(checksum), lowByte(checksum), End_Byte}
for (byte x=0 x<10 x++)
{
mySerial.write(Command_line[x])
}
}
//---------Developed by R.Girish------//

Ora passiamo alla progettazione basata su telecomando IR.

Schema per lettore Mp3 controllato da IR:

Il design di cui sopra è semplice in quanto basato sul pulsante, l'unica differenza è la rimozione dei pulsanti e l'inclusione del ricevitore IR TSOP 1738. Il segnale ricevuto dal telecomando IR viene inviato al pin A0 di arduino.

Ora per controllare questo lettore Mp3 hai bisogno di una TV di riserva o di qualsiasi altro telecomando basato su IR che potrebbe trovarsi sulla tua casella di posta indesiderata. Devi decidere quali pulsanti per controllare le funzioni come play & pause ecc.

Ci sono 6 funzioni:

1) Riproduci e metti in pausa
2) Canzone successiva
3) Canzone precedente
4) Aumento del volume
5) Diminuzione del volume
6) Equalizzatore audio (Normale / Pop / Rock / Jazz / Classico / Base)

È necessario scegliere i pulsanti sul telecomando e trovare i suoi codici esadecimali di quei pulsanti che verranno trasmessi dal telecomando. Per trovare il codice esadecimale, scarica la libreria IR se non lo hai fatto.

github.com/z3t0/Arduino-IRremote

Aggiungi la libreria al software arduino e vai su File> Esempi> IRremote> IRrecvDemo e carica il codice con la configurazione hardware completata.

Apri il monitor seriale e premi i pulsanti sul telecomando, vedrai i codici esadecimali, annotalo sul pulsante corrispondente su un pezzo di carta.

È necessario inserire il codice esadecimale nel programma indicato di seguito. Dopo aver inserito i codici esadecimali nel programma dato, caricalo. Sei pronto per controllare le tue canzoni dal telecomando.

Programma per la progettazione basata su telecomando IR:

//---Developed by R.Girish--//
#include
#include
SoftwareSerial mySerial(10,11)
# define Start_Byte 0x7E
# define Version_Byte 0xFF
# define Command_Length 0x06
# define End_Byte 0xEF
# define Acknowledge 0x00
//--------------------------------------------------------//
# define pause_play 0x2FD08F7
# define next_song 0x2FDD827
# define prev_song 0x2FDF807 //REPLACE THESE HEX CODE WITH YOUR REMOTE BUTTON CODE STARTS “0x”
# define vol_inc 0x2FD58A7
# define vol_dec 0x2FD7887
# define sound_equalizer 0x2FD30CF
//-------------------------------------------------------//
const int receive = A0
IRrecv irrecv(receive)
decode_results dec
int volume = 15
int eqset = 0
boolean Playing = false
void setup ()
{
irrecv.enableIRIn()
mySerial.begin(9600)
delay(1000)
playFirst()
Playing = true
}
void loop ()
{
if(irrecv.decode(&dec))
{
if (dec.value==pause_play)
{
if(Playing)
{
pause()
Playing = false
}
else
{
Playing = true
play()
}
}
if (dec.value==next_song)
{
if(Playing)
{
next()
}
}
if (dec.value==prev_song)
{
if(Playing)
{
previous()
}
}
if(dec.value==vol_inc)
{
volumeINC()
}
if(dec.value==vol_dec)
{
volumeDEC()
}
if(dec.value==sound_equalizer)
{
equalizer()
}
irrecv.resume()
}
}
void playFirst()
{
exe_cmd(0x3F, 0, 0)
delay(100)
exe_cmd(0x06, 0, volume)
delay(100)
exe_cmd(0x11,0,1)
delay(100)
}
void pause()
{
exe_cmd(0x0E,0,0)
delay(100)
}
void play()
{
exe_cmd(0x0D,0,1)
delay(100)
}
void next()
{
exe_cmd(0x01,0,1)
delay(100)
}
void previous()
{
exe_cmd(0x02,0,1)
delay(100)
}
void volumeINC()
{
volume = volume+1
if(volume == 31)
{
volume = 30
}
exe_cmd(0x06, 0, volume)
delay(100)
}
void volumeDEC()
{
volume = volume-1
if(volume == -1)
{
volume = 0
}
exe_cmd(0x06, 0, volume)
delay(100)
}
void equalizer()
{
eqset = eqset+1
if(eqset == 6)
{
eqset = 0
}
exe_cmd(0x07, 0 ,eqset)
delay(100)
}
void exe_cmd(byte CMD, byte Par1, byte Par2)
{
word checksum = -(Version_Byte + Command_Length + CMD + Acknowledge + Par1 + Par2)
byte Command_line[10] = { Start_Byte, Version_Byte, Command_Length, CMD, Acknowledge, Par1, Par2, highByte(checksum), lowByte(checksum), End_Byte}
for (byte x=0 x<10 x++)
{
mySerial.write(Command_line[x])
}
}
//---------Developed by R.Girish------//

NOTA 1: potresti vedere un avviso nel programma durante la compilazione, ignoralo.

NOTA 2: prova a mettere tutti i tuoi brani nella scheda SD senza cartelle.

Prototipo dell'autore: