Create a new folder audio_player_lab4 under apps/training/solutions/dev/audio_player.

Copy the firmware folder from
apps/training/solutions/dev/audio_player/audio_player_lab3 to the newly created folder, audio_player_lab4.

Rename the project from audio_player_lab3 to audio_player_lab4.

• Open audio_player_lab3.
• Under Projects, right click on audio_player_lab3 and select Rename….
  

• In the pop up window, rename the project from audio_player_lab3 to audio_player_lab4.
  

• MPLAB X IDE then renames the project. It closes the old project audio_player_lab3 and opens the renamed project audio_player_lab4.
  

Verify that the project builds properly after renaming. Click the Clean and Build Project button .

Click Tools > Embedded > MPLAB Harmony 3 Configurator to open MHC.

Select the MHC Project Graph tab. Remember, if you ever lose the MHC tool, you can find it here: Tools > Embedded > MPLAB Harmony 3 Configurator.

Add the Audio Decoder Libraries into your project from the Available Components window.

Expand the tree Audio> Decoder> Audio Decoder and select Audio Decoder Libraries.

Your Project Graph should now resemble the screen shown below. Keep the decoder's default configuration options.

Click on the Audio Decoder Libraries component box to view the Configuration Options. When you add the Audio Decoder Libraries, by default it enables the WAV and ADPCM decoders. Uncheck the Enable ADPCM Decoder box because this format is not required by the application.

Save the MHC configuration by clicking the save button.

Expand the source file folders in the Projects pane. Notice that these are the files from Lab 3 that you copied to this directory.

Click on the Generate Code button as shown in the following figure. Notice the Merging Strategy option.

Note the new decoder folders added to the lab.

Save all files and build the code. To do this, click on the Clean and Build icon and verify the project builds successfully.

Copy source files into your project's source files folder:

• app_sdcard_audio_task.c
• app_sdcard_audio_task.h
• decoder.c
• decoder.h

Copy them from this folder:
apps/training/solutions/audio_player/audio_player_lab4/dev_files
to this one:
apps/training/solutions/dev/audio_player/audio_player_lab4/firmware/src

Add the copied source files to your project.

• Add app_sdcard_audio_task.c and decoder.c to Source Files\app by right clicking and selecting Add Existing Items…

• Add app_sdcard_audio_task.h and decoder.h to Header Files\app by right clicking and selecting Add Existing Items…
  

Remove app_tone_textfile_sdcard.c and app_tone_textfile_sdcard.h from the folder.

• Right click on the app_tone_textfile_sdcard.h file and select Remove From Project.

• Right click on the app_tone_textfile_sdcard.c file and select Remove From Project.
  

After performing this step, the files under the project should look like this:

Next, we need to tell the compiler about the path of the decoders and include files.

• To include this path, right click on the project name audio_player_lab4 in the MPLAB X Projects pane and select Properties.
• In the Categories pane, select Conf:[default] > XC32 (Global Options) > xc32-gcc.
• Now, click on the Option categories dropdown menu and select the Preprocessing and Messages option.
  

• Click on the box beside Include directories.
  

Browse to the following path:
..firmware\src\config\default\audio\decoder\audio_decoders.
Select OK.

As we did with the previous exercise, we will modify the app.c and app.h files from the previous exercise in order to change function names to match the function names in the newly included app_sdcard_audio_task.c file. Open the file app.c and find the APP_Initialize function. Change the function named:
APP_TONE_TEXTFILE_SDCARD_Initialize()
to:
APP_SDCARD_AUDIO_Initialize() as shown below.

Find the APP_Tasks function and change the function named:
APP_TONE_TEXTFILE_SDCARD_Tasks()
to:
APP_SDCARD_AUDIO_Tasks() as shown below.

At the top of app.c, change the name of the prtotypes as shown below:

Next, open app_button_press_task.c and change the name of the prototype/function from:
APP_TONE_TEXTFILE_SDCARD_SuspendStreaming
to:
APP_SDCARD_AUDIO_SuspendStreaming.
Also, change the name of the prototype/function from:
APP_TONE_TEXTFILE_SDCARD_Initialize
to:
APP_SDCARD_AUDIO_Initialize, as shown below.

Save all files and build the code. Click on the Clean and Build icon and verify that the project builds successfully.

Open the file app_sdcard_audio_task.h. This file defines application states, data, and Application Peripheal Interfaces (APIs).

Application states corresponding to the state machine described in the Overview section are as follows. (Note the newly added states are indicated by a red box.)

The audio player states are shown below.

All of the these enumerations should be self-explanatory.

The application data structure is shown below:

The variables state and codec are retained from the previous lab. They hold the state of application and codec related variables respectively.

The audio player data structure is shown below.

The functionality of some of the important structure members are explained below:

• fileHandle: holds "handle" to the audio file currently being played.
• fileStatus: holds the file status for the current audio file, returned by a call to SYS_FS_FileStat().
• state: holds the state of the audio player state machine.
• buffer: holds the buffer related information that is used by the decoder and the audio CODEC. The buffer members are:
  

• buffer: holds the decoded audio data.
• inUse: a buffer is marked to be in use when the buffer is queued for playing with the CODEC.
• decoded: a buffer is marked as decoded when the buffer contains the decoded audio data (output of decoder).
• writeHandler: holds the buffer handle returned by a call to DRV_CODEC_BufferAddWrite().
• bufferSize: indicates the number of decoded audio data elements available in the buffer.
• currentSongIdx, nextSongIdx, and previousSongIdx: point to index of the current song, next song, and previous song respectively in the global buffer that contains the path information of all the audio files.
• totalAudioFiles: holds the total number of WAV audio files found on the SD card.
• nBytesRead: holds the actual number of bytes read from the file; returned by a call to SYS_FS_FileRead().
• currentFilesize: holds the total size of the current audio file pointed by the fileHandle.
• readIdx and wrriteIdx: are used to index into the buffer containing audio data for the audio CODEC. writeIdx points to the index until the decoded audio data is available in the buffer. readIdx points to the index until the audio data is queued to the audio CODEC.
• decodeDataSize: holds the number of data bytes decoded by the decoder; returned by a call to DECODER_Decode().

APP_SDCARD_AUDIO_CARD_EVENT enumerates the events passed to the SD card event handler.

The enum APP_SDCARD_AUDIO_CARD_EVENT is passed to the SD card event handler, APP_SDCARD_AUDIO_Card_EventHandler(), allowing the application to take various actions based on the SD card events.

Open the file app_sdcard_audio_task.c. This file contains the application state machine and implements the APIs.

The implementation of function APP_SDCARD_AUDIO_Initialize sets up the default state of APP_SDCARD_AUDIO_Tasks and initializes the variables for the CODEC driver and player state machine along with other variables.

The function APP_SDCARD_AUDIO_Tasks implements the task’s state machine as shown in the figure in Overview section. As in the previous lab, SD Card Audio Player Lab 3, it starts in the APP_SDCARD_AUDIO_STATE_CODEC_OPEN state and remains in it until it opens the CODEC driver and gets a valid driver handle. After this, it registers a CODEC buffer handler in the APP_SDCARD_AUDIO_STATE_CODEC_SET_BUFFER_HANDLER state, mounts the file system in the APP_SDCARD_AUDIO_CARD_MOUNT state, and sets the current drive in the APP_SDCARD_AUDIO_CARD_CURRENT_DRIVE_SET state.

The application then enters the APP_SDCARD_AUDIO_STATE_RUNNING state where it calls the APP_SDCARD_AUDIO_Card_Tasks function that traverses through all the directories on the SD card and saves the path of all WAV files found to the AppSdCardAudioCardFilesTable. It also selects the first WAV file from the AppSdCardAudioCardFilesTable and a call to the APP_SDCARD_AUDIO_Card_OpenTrack function opens it for playing.

The audio player state machine then starts executing. The audio player state APP_SDCARD_AUDIO_PLAYER_STATE_RUNNING checks if any buffer is available and, if yes, reads the current audio file by a call to the APP_SDCARD_AUDIO_Card_FillBuffer function and passes the read data to the APP_SDCARD_AUDIO_Player_Decode function, which decodes the WAV formatted data read from the file. Finally, if the decoded buffer is not in use, it queues the decoded buffer to the CODEC driver for playing by sending a call to DRV_CODEC_BufferAddWrite function and marks it as in use.
The player state remains in the APP_SDCARD_AUDIO_PLAYER_STATE_RUNNING state until the entire audio file has been read out.

The CODEC driver calls the buffer event handler APP_SDCARD_AUDIO_BufferEventHandler (registered with the CODEC by a call to the DRV_CODEC_BufferEventHandlerSet function), upon completion of each queued buffer to the audio CODEC. The application checks if a decoded buffer is ready and, if yes, queues the decoded buffer for playing with the audio CODEC by sending a call to the DRV_CODEC_BufferAddWrite function.

Once the audio file is completely read out, or if the decoder output is zero (i.e., there is nothing to decode), the player state is changed to APP_SDCARD_AUDIO_PLAYER_STATE_TRACK_CHANGE, where it first waits for the already queued audio buffers to the CODEC driver to complete; after which it selects the next audio file from the AppSdCardAudioCardFilesTable, and opens it for playing. The player state machine then changes back to APP_SDCARD_AUDIO_PLAYER_STATE_RUNNING. This process continues and the audio files are continuously played in a circular manner from the AppSdCardAudioCardFilesTable, one after the other.

Several other APIs are developed that provide information on the current state of the audio player to other state machines or tasks.

Before we program and run our application, we need to program the micro SD card with the WAV audio files. Go to the dev_files folder of this exercise and copy a few sample WAV files to the micro SD card.

Insert the micro SD card into the micro SD card slot (J8) on the MEB II.

Before you start the debugger, you may want to set a breakpoint in the application file in app_sdcard_audio_task.c to verify the important stages of the application (like the opening of the CODEC driver and mounting of the file system on the SD card) were executed successfully.

Put a breakpoint in the APP_SDCARD_AUDIO_PLAYER_STATE_TRACK_CHANGE state which will indicate that an audio track is complete and the next track will be selected for playing.

Debug your application! Click the Debug Main Project icon.

Single step (by clicking F7) and observe the flow of control in the application state machine.

Put a breakpoint in the buffer event handler. Hitting the breakpoint in the event handler indicates that the last submitted buffer is transferred to the CODEC.

Remove all break points and click F5 to allow the application to run.

Connect a headphone to the HP Out connector on the MEB II and you should hear the audio track being played.

You may load more WAV audio files by switching to the USB SD card reader mode (by pressing the switch S1 on the MEB II). After loading, switch back to the player mode and you should hear the newly added audio tracks to the SD card.