Odtwarzacz MP3 za pomocą odtwarzacza DF - pełne szczegóły projektu

W tym poście zamierzamy zbudować odtwarzacz MP3 przy użyciu arduino i DFPlayer. Proponowany artykuł ma dwa projekty odtwarzaczy Mp3, jeden z przyciskiem, a drugi z pilotem na podczerwień. Przyjrzymy się również DFPlayer (modułowi odtwarzacza MP3) i jego specyfikacjom.

Wszyscy kochamy muzykę, chcielibyśmy ją usłyszeć na siłowni, czytając, chwilę przed snem lub uspokajając się po ciężkim dniu pracy.

Zbudowanie odtwarzacza muzycznego w domu kilka dekad temu było prawie niemożliwe dla entuzjastów elektroniki ze względu na złożoność konstrukcyjną związaną z elementami mechanicznymi.

W tamtych czasach na kasecie mieściła się tylko ograniczona liczba piosenek. Kopiowanie piosenki na inną kasetę też było koszmarem. Ale teraz, dzięki postępowi w elektronice, odtwarzacz MP3 można zrobić od podstaw za kieszonkowe.

Przejdźmy teraz do szczegółów technicznych projektu.

Sercem projektu jest DFPlayer, czyli niewielki moduł odtwarzacza Mp3, który może pomieścić kartę micro SD i może być sterowany za pomocą mikrokontrolera.

Ilustracja DFPlayer:

Posiada wbudowany wzmacniacz, który może sterować 3-watowymi głośnikami w trybie stereo lub mono. Posiada 24-bitowy przetwornik cyfrowo-analogowy (DAC), co jest całkiem dobre jak na tak tani i kompaktowy moduł.

Widok z dołu DFPlayer:

Obsługuje dekodowanie sprzętowe MP3 i WMV. Obsługuje częstotliwość próbkowania
8 KHz, 11,025 KHz, 12 KHz, 1 6 KHz, 22,05 KHz, 24 KHz, 32 KHz, 44,1 KHz, 48 KHz.

Może obsługiwać do 32 GB karty micro SD. Obsługuje do 100 folderów, do każdego folderu można przypisać do 1000 utworów.

Posiada 6 różnych poziomów korektora i 30 poziomów regulacji głośności. Może pracować w zakresie od 3,2 V do 5 V.

Konfiguracja pinów DFPlayer:

Powyższe specyfikacje są oparte na arkuszu danych DFPlayer.

Do tej pory znasz DFPlayera i jego specyfikację. Możesz kupić ten moduł w witrynach e-commerce lub na lokalnym rynku elektroniki.

Przejdźmy teraz do schematu.

Projekt odtwarzacza MP3 z przyciskiem:

Powyższy obwód jest bardzo prosty, arduino wysyła polecenia do modułu DFPlayer w celu sterowania utworami. Użytkownik może wprowadzić swój wybór za pomocą przycisków.

Wbudowany rezystor podciągający arduino został aktywowany w programie, więc nie musimy podłączać fizycznego rezystora do przycisków.

Spróbuj użyć głośników dobrej jakości, a DFPlayer może zapewnić bardzo dobrą jakość dźwięku.

Jeśli zauważysz jakiekolwiek zniekształcenie dźwięku przy wyższych poziomach głośności, zasil moduł DFPlayer zewnętrznie napięciem 5 V DC ze wspólnym uziemieniem między arduino i DFPlayer.

Jeśli chcesz ustawić dźwięk stereo, podłącz jeden z głośników do SPK1 programu DFPlayer, a drugi głośnik do SPK2 i uziemić pozostałe przewody głośnikowe.

Program do sterowania przyciskiem:

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

Przejdźmy teraz do projektowania w oparciu o pilota na podczerwień.

Schemat dla odtwarzacza MP3 sterowanego IR:

Powyższy projekt jest prosty, ponieważ oparty na przycisku jedyną różnicą jest usunięcie przycisków i włączenie odbiornika podczerwieni TSOP 1738. Odebrany sygnał z pilota IR jest podawany na pin A0 arduino.

Teraz, aby sterować tym odtwarzaczem Mp3, potrzebujesz zapasowego telewizora lub innego pilota na podczerwień, który może leżeć na twoim śmieciowym pudełku. Musisz zdecydować, które przyciski sterują funkcjami takimi jak odtwarzanie i pauza itp.

Istnieje 6 funkcji:

1) Odtwórz i wstrzymaj
2) Następna piosenka
3) Poprzednia piosenka
4) Zwiększenie głośności
5) Zmniejszenie głośności
6) Korektor dźwięku (Normal / Pop / Rock / Jazz / Classic / Base)

Musisz wybrać przyciski na pilocie i znaleźć jego szesnastkowe kody tych przycisków, które będą przesyłane przez pilota. Aby znaleźć kod szesnastkowy, pobierz bibliotekę IR, jeśli tego nie zrobiono.

github.com/z3t0/Arduino-IRremote

Dodaj bibliotekę do oprogramowania arduino i przejdź do Plik> Przykłady> IRremote> IRrecvDemo i prześlij kod z zakończoną konfiguracją sprzętu.

Otwórz monitor szeregowy i naciśnij przyciski na pilocie, zobaczysz kody szesnastkowe, zanotuj je do odpowiedniego przycisku na kartce papieru.

Musisz wpisać kod szesnastkowy w programie podanym poniżej. Po wpisaniu kodów szesnastkowych w danym programie wgraj go. Możesz sterować swoimi utworami za pomocą pilota.

Program do projektowania w oparciu o pilota 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------//

UWAGA 1: możesz zobaczyć ostrzeżenie w programie podczas kompilacji, zignoruj ​​je.

UWAGA 2: Spróbuj umieścić wszystkie swoje utwory na karcie SD bez folderów.

Prototyp autora: