Lecteur MP3 utilisant DF Player - Détails de conception complets

Dans cet article, nous allons construire un lecteur MP3 en utilisant Arduino et DFPlayer. L'article proposé a deux modèles de lecteur MP3, un avec commande par bouton poussoir et un autre avec télécommande infrarouge. Nous allons également jeter un œil à DFPlayer (module de lecteur MP3) et ses spécifications.

Nous aimons tous la musique, nous aimerions l'entendre au gymnase, en train de lire, quelques instants avant de dormir ou en nous apaisant après une dure journée de travail.

Construire un lecteur de musique à la maison il y a quelques décennies était presque impossible pour un passionné d'électronique en raison de la complexité de construction due aux composants mécaniques.

À cette époque, seul un nombre limité de chansons pouvait être enregistré dans une cassette. Répliquer une chanson sur une autre cassette était aussi un cauchemar. Mais maintenant, grâce aux progrès de l'électronique, un lecteur MP3 peut être fabriqué à partir de zéro avec votre argent de poche.

Passons maintenant aux détails techniques du projet.

Le cœur du projet est DFPlayer qui est un petit module de lecteur MP3 qui peut accueillir une carte micro SD et peut être contrôlé à l'aide d'un microcontrôleur.

Illustration de DFPlayer:

Il dispose d'un amplificateur intégré pouvant alimenter des haut-parleurs de 3 watts en stéréo ou en mono. Il dispose d'un convertisseur numérique-analogique (DAC) 24 bits, ce qui est assez bon pour un module aussi peu coûteux et compact.

Vue de dessous du DFPlayer:

Il prend en charge le décodage matériel MP3 et WMV. Il prend en charge le taux d'échantillonnage de
8 KHz, 11,025 KHz, 12 KHz, 1 6 KHz, 22,05 KHz, 24 KHz, 32 KHz, 44,1 KHz, 48 KHz.

Il peut prendre en charge jusqu'à 32 Go de carte micro SD. Il prend en charge jusqu'à 100 dossiers, chaque dossier peut être attribué jusqu'à 1000 chansons.

Il dispose de 6 niveaux différents d'égaliseur et de 30 niveaux de contrôle de réglage du volume. Il peut fonctionner de 3,2V à 5V.

Configuration des broches de DFPlayer:

Les spécifications ci-dessus sont basées sur la fiche technique de DFPlayer.

À présent, vous vous êtes familiarisé avec DFPlayer et ses spécifications. Vous pouvez acheter ce module sur des sites de commerce électronique ou sur le marché local de l'électronique.

Passons maintenant au diagramme schématique.

Conception du lecteur MP3 à bouton-poussoir:

Le circuit ci-dessus est très simple, l'arduino envoie des commandes au module DFPlayer pour contrôler les chansons. L'utilisateur peut saisir son choix via des boutons poussoirs.

La résistance de pull-up intégrée de l’arduino a été activée dans le programme, de sorte que nous n’avons pas besoin de connecter une résistance physique aux boutons-poussoirs.

Essayez d'utiliser des haut-parleurs de bonne qualité, le DFPlayer peut fournir un son de très bonne qualité.

Si vous constatez une distorsion dans le son à des niveaux de volume plus élevés, alimentez le module DFPlayer en externe à 5 V CC avec une connexion de masse commune entre arduino et DFPlayer.

Si vous souhaitez une configuration de son stéréo, connectez celui du haut-parleur à SPK1 de DFPlayer et un autre haut-parleur à SPK2 et mettez à la terre les fils de haut-parleur restants.

Programme de commande par bouton poussoir:

//---------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------//

Passons maintenant à la conception à distance infrarouge.

Schéma du lecteur MP3 contrôlé par IR:

La conception ci-dessus est simple car le bouton-poussoir basé sur la seule différence est le retrait des boutons-poussoirs et l'inclusion du récepteur IR TSOP 1738. Le signal reçu de la télécommande IR est transmis à la broche A0 de l'arduino.

Maintenant, pour contrôler ce lecteur MP3, vous avez besoin d'un téléviseur de rechange ou de toute autre télécommande infrarouge qui pourrait se trouver sur votre boîte de courrier indésirable. Vous devez décider quels boutons pour contrôler les fonctions telles que lecture et pause, etc.

Il existe 6 fonctions:

1) Lecture et pause
2) Chanson suivante
3) Chanson précédente
4) Augmentation du volume
5) Diminution du volume
6) Égaliseur de son (Normal / Pop / Rock / Jazz / Classique / Base)

Vous devez choisir les boutons de la télécommande et trouver ses codes hexadécimaux de ces boutons qui seront transmis par la télécommande. Pour trouver le code hexadécimal, téléchargez la bibliothèque IR si ce n'est pas fait.

github.com/z3t0/Arduino-IRremote

Ajoutez la bibliothèque au logiciel arduino et accédez à Fichier> Exemples> IRremote> IRrecvDemo et téléchargez le code avec la configuration matérielle terminée.

Ouvrez le moniteur série et appuyez sur les boutons de la télécommande, vous verrez les codes hexadécimaux, notez-le au bouton correspondant sur une feuille de papier.

Vous devez entrer le code hexadécimal sur le programme ci-dessous. Une fois que vous avez entré les codes hexadécimaux dans le programme donné, téléchargez-le. Vous êtes prêt à contrôler vos chansons depuis votre télécommande.

Programme pour la conception à distance 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------//

REMARQUE 1: vous pouvez voir un avertissement dans le programme lors de la compilation, veuillez l'ignorer.

REMARQUE 2: essayez de mettre toutes vos chansons sur la carte SD sans dossiers.

Prototype de l'auteur: