Mp3 Player Using DF Player – Full Design Details

In this post I will show how to construct an Mp3 player using arduino and DFPlayer. The proposed article has two Mp3 player designs, one with push button control and another one with IR remote control. We will also take a look at DFPlayer (Mp3 player module) and its specifications.

We all love music, we would like to hear it while at gym, reading, moments before sleeping or while soothing our self after a hard day work.

Constructing a music player at home few decades back was a near impossible for an electronics enthusiast because of constructional complexity due to mechanical components.

In those days only limited number of songs could be accommodated in a cassette. Replicating a song to another cassette was a nightmare too. But now, thanks to advancement in electronics an Mp3 player can be made from scratch with your pocket money.

Now let’s move on to technical details of the project.

The heart of the project is DFPlayer which is a small Mp3 player module which can accommodate micro SD card and can be controlled using a microcontroller.

Illustration of DFPlayer:

It has in-build amplifier which can drive 3 watt loudspeakers in stereo or mono. It has 24-bit digital to analog converter (DAC) which is pretty good for such low cost and compact module.

Bottom view of the DFPlayer:

It supports MP3 and WMV hardware decoding. It supports sampling rate of
8KHz,11.025KHz, 12KHz,1 6KHz, 22.05KHz, 24KHz, 32KHz, 44.1KHz, 48KHz.

It can support up to 32GB micro SD card. It supports up to 100 folders, each folder can be assigned up to 1000 songs.

It has 6 different levels of equalizer; and 30 levels of volume adjust control. It can operate from 3.2V to 5V.

Pin configuration of DFPlayer:

The above specifications are based on DFPlayer’s data sheet.

By now you would have familiar with DFPlayer and its specification. You can purchase this module from e-commerce sites or from local electronics market.

Now let’s jump into the schematic diagram.

Push-button Mp3 player design:

The above circuit is very simple; the arduino sends commands to the DFPlayer module to control the songs. The user can input their choice via push buttons.

The arduino’s built-in pull-up resistor has been activated in the program, so that we no need to attach a physical resistor to push buttons.

Try to use good quality speakers; the DFPlayer can deliver very good quality sound.

If you find any distortion in the sound at higher volume levels, power the DFPlayer module externally at 5V DC with common ground connection between arduino and DFPlayer.

If you want stereo sound setup, connect the one of the speaker to SPK1 of DFPlayer and another speaker to SPK2 and ground the remaining speaker wires.

Program for push button control:

//---------Developed by R.Girish------//

#include <SoftwareSerial.h>

/* ----------------------------------
   DFPlayer / MP3 module serial pins
   TX -> Arduino D10
   RX -> Arduino D11
-----------------------------------*/
SoftwareSerial mySerial(10, 11);

/* ----------------------------------
   DFPlayer protocol constants
-----------------------------------*/
#define Start_Byte     0x7E
#define Version_Byte   0xFF
#define Command_Length 0x06
#define End_Byte       0xEF
#define Acknowledge    0x00

/* ----------------------------------
   Button pin definitions
   (Using analog pins as digital inputs)
-----------------------------------*/
const int btnNext     = A0;
const int btnPause    = A1;
const int btnPrevious = A2;
const int volumeUP    = A3;
const int volumeDOWN  = A4;

/* ----------------------------------
   Global variables
-----------------------------------*/
int volume = 15;          // Initial volume level (0 to 30)
boolean Playing = false;  // Track current play state

/* ----------------------------------
   Setup function
-----------------------------------*/
void setup()
{
  // Configure button pins as inputs
  pinMode(btnPause, INPUT);
  pinMode(btnNext, INPUT);
  pinMode(btnPrevious, INPUT);
  pinMode(volumeUP, INPUT);
  pinMode(volumeDOWN, INPUT);

  // Enable internal pull-up resistors
  digitalWrite(btnPause, HIGH);
  digitalWrite(btnNext, HIGH);
  digitalWrite(btnPrevious, HIGH);
  digitalWrite(volumeUP, HIGH);
  digitalWrite(volumeDOWN, HIGH);

  // Start software serial communication with MP3 module
  mySerial.begin(9600);
  delay(1000);  // Allow module to initialize properly

  // Play first track on power-up
  playFirst();
  Playing = true;
}

/* ----------------------------------
   Main loop
-----------------------------------*/
void loop()
{
  // Pause / Play toggle button
  if (digitalRead(btnPause) == LOW)
  {
    delay(200); // Simple debounce delay

    if (Playing)
    {
      pause();
      Playing = false;
    }
    else
    {
      play();
      Playing = true;
    }
  }

  // Next track button
  if (digitalRead(btnNext) == LOW)
  {
    delay(200); // Debounce

    if (Playing)
    {
      next();
    }
  }

  // Previous track button
  if (digitalRead(btnPrevious) == LOW)
  {
    delay(200); // Debounce

    if (Playing)
    {
      previous();
    }
  }

  // Volume increase button
  if (digitalRead(volumeUP) == LOW)
  {
    delay(200); // Debounce
    volumeINC();
  }

  // Volume decrease button
  if (digitalRead(volumeDOWN) == LOW)
  {
    delay(200); // Debounce
    volumeDEC();
  }
}

/* ----------------------------------
   Play first track after reset
-----------------------------------*/
void playFirst()
{
  exe_cmd(0x3F, 0, 0);      // Reset command
  delay(500);

  exe_cmd(0x06, 0, volume); // Set initial volume
  delay(500);

  exe_cmd(0x11, 0, 1);     // Play track 1
  delay(500);
}

/* ----------------------------------
   Pause playback
-----------------------------------*/
void pause()
{
  exe_cmd(0x0E, 0, 0);     // Pause command
  delay(500);
}

/* ----------------------------------
   Resume playback
-----------------------------------*/
void play()
{
  exe_cmd(0x0D, 0, 1);     // Play command
  delay(500);
}

/* ----------------------------------
   Play next track
-----------------------------------*/
void next()
{
  exe_cmd(0x01, 0, 1);     // Next track command
  delay(500);
}

/* ----------------------------------
   Play previous track
-----------------------------------*/
void previous()
{
  exe_cmd(0x02, 0, 1);     // Previous track command
  delay(500);
}

/* ----------------------------------
   Increase volume
-----------------------------------*/
void volumeINC()
{
  volume = volume + 1;

  // Limit maximum volume
  if (volume >= 31)
  {
    volume = 30;
  }

  exe_cmd(0x06, 0, volume); // Set volume
  delay(500);
}

/* ----------------------------------
   Decrease volume
-----------------------------------*/
void volumeDEC()
{
  volume = volume - 1;

  // Limit minimum volume
  if (volume < 0)
  {
    volume = 0;
  }

  exe_cmd(0x06, 0, volume); // Set volume
  delay(500);
}

/* ----------------------------------
   Send command to MP3 module
-----------------------------------*/
void exe_cmd(byte CMD, byte Par1, byte Par2)
{
  // Calculate checksum as per DFPlayer protocol
  word checksum = -(Version_Byte + Command_Length + CMD + Acknowledge + Par1 + Par2);

  // Command packet structure
  byte Command_line[10] =
  {
    Start_Byte,
    Version_Byte,
    Command_Length,
    CMD,
    Acknowledge,
    Par1,
    Par2,
    highByte(checksum),
    lowByte(checksum),
    End_Byte
  };

  // Send command packet byte by byte
  for (byte x = 0; x < 10; x++)
  {
    mySerial.write(Command_line[x]);
  }
}

//---------Developed by R.Girish------//

Now let’s move on to IR remote based design.

Schematic for IR controlled Mp3 player:

 
The above design is simple as the push button based; the only difference is removal of push buttons and inclusion of TSOP 1738 IR receiver. The received signal from IR remote is fed to A0 pin of arduino.

Now to control this Mp3 player you need a spare TV, or any other IR based remote which might be lying on your junk box. You have to decide which the buttons for controlling the functions like play & pause etc.

There are 6 functions:

1)    Play and pause
2)    Next song
3)    Previous song
4)    Volume increase
5)    Volume decrease
6)    Sound equalizer (Normal/Pop/Rock/Jazz/Classic/Base)

You need to choose the buttons on the remote and find its Hexadecimal codes of those buttons which will be transmitted by the remote. To find the hexadecimal code, download the IR library if not done so.

github.com/z3t0/Arduino-IRremote

Add the library to arduino software and navigate to File> Examples> IRremote > IRrecvDemo and upload the code with completed hardware setup.

Open the serial monitor and press the buttons on remote, you will see the hexadecimal codes, note it down to corresponding button on piece of paper.

You need to enter the hexadecimal code on the program given below. Once you entered the hexadecimal codes in the given program, upload it. You are ready to control your songs from your remote.

Program for IR remote based design:

//---------Developed by R.Girish---------//

#include <SoftwareSerial.h>
#include <IRremote.h>

//--------------------------------------//
// DFPlayer Mini serial connection
// TX -> Pin 10
// RX -> Pin 11
//--------------------------------------//
SoftwareSerial mySerial(10, 11);

//--------------------------------------//
// DFPlayer command protocol bytes
//--------------------------------------//
#define Start_Byte      0x7E
#define Version_Byte    0xFF
#define Command_Length  0x06
#define End_Byte        0xEF
#define Acknowledge     0x00

//--------------------------------------//
// IR Remote button HEX codes
// Replace these with your own remote codes
//--------------------------------------//
#define pause_play       0x2FD08F7
#define next_song        0x2FDD827
#define prev_song        0x2FDF807
#define vol_inc          0x2FD58A7
#define vol_dec          0x2FD7887
#define sound_equalizer  0x2FD30CF

//--------------------------------------//
// IR Receiver pin
//--------------------------------------//
const int receive = A0;

// IR objects
IRrecv irrecv(receive);
decode_results dec;

//--------------------------------------//
// Playback state variables
//--------------------------------------//
int volume = 15;        // Initial volume (0 to 30)
int eqset  = 0;         // Equalizer mode (0 to 5)
boolean Playing = false;

void setup()
{
  // Enable IR receiver
  irrecv.enableIRIn();

  // Start serial communication with DFPlayer
  mySerial.begin(9600);

  // Give DFPlayer time to boot
  delay(1000);

  // Initialize player
  playFirst();
  Playing = true;
}

void loop()
{
  // Check if IR signal received
  if (irrecv.decode(&dec))
  {
    // Play / Pause toggle
    if (dec.value == pause_play)
    {
      if (Playing)
      {
        pause();
        Playing = false;
      }
      else
      {
        play();
        Playing = true;
      }
    }

    // Next track
    if (dec.value == next_song)
    {
      if (Playing)
      {
        next();
      }
    }

    // Previous track
    if (dec.value == prev_song)
    {
      if (Playing)
      {
        previous();
      }
    }

    // Volume up
    if (dec.value == vol_inc)
    {
      volumeINC();
    }

    // Volume down
    if (dec.value == vol_dec)
    {
      volumeDEC();
    }

    // Equalizer change
    if (dec.value == sound_equalizer)
    {
      equalizer();
    }

    // Ready for next IR signal
    irrecv.resume();
  }
}

//--------------------------------------//
// Initial startup configuration
//--------------------------------------//
void playFirst()
{
  exe_cmd(0x3F, 0, 0);       // Reset module
  delay(100);

  exe_cmd(0x06, 0, volume); // Set volume
  delay(100);

  exe_cmd(0x11, 0, 1);      // Play first track
  delay(100);
}

//--------------------------------------//
// Playback controls
//--------------------------------------//
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);
}

//--------------------------------------//
// Volume control functions
//--------------------------------------//
void volumeINC()
{
  volume++;

  // Limit max volume to 30
  if (volume > 30)
  {
    volume = 30;
  }

  exe_cmd(0x06, 0, volume);
  delay(100);
}

void volumeDEC()
{
  volume--;

  // Limit min volume to 0
  if (volume < 0)
  {
    volume = 0;
  }

  exe_cmd(0x06, 0, volume);
  delay(100);
}

//--------------------------------------//
// Equalizer mode cycling
// 0 to 5 (Normal, Pop, Rock, Jazz, Classic, Bass)
//--------------------------------------//
void equalizer()
{
  eqset++;

  if (eqset > 5)
  {
    eqset = 0;
  }

  exe_cmd(0x07, 0, eqset);
  delay(100);
}

//--------------------------------------//
// Core DFPlayer command execution
//--------------------------------------//
void exe_cmd(byte CMD, byte Par1, byte Par2)
{
  // Calculate checksum
  word checksum = -(Version_Byte + Command_Length + CMD + Acknowledge + Par1 + Par2);

  // Complete command packet
  byte Command_line[10] =
  {
    Start_Byte,
    Version_Byte,
    Command_Length,
    CMD,
    Acknowledge,
    Par1,
    Par2,
    highByte(checksum),
    lowByte(checksum),
    End_Byte
  };

  // Send command to DFPlayer
  for (byte x = 0; x < 10; x++)
  {
    mySerial.write(Command_line[x]);
  }
}

//---------Developed by R.Girish---------//

NOTE 1: you may see warning in the program while compiling, please ignore it.

NOTE 2: Try to put all your songs in SD card without folders.

 Author’s prototype: