Team Makers: MakerMG, CR555

Published February 28, 2023 © GPL3+

Music Map Player

A simple project to create a music player that plays the most suitable songs for every moment.

BeginnerFull instructions provided3 hours144

Things used in this project

Hardware components

Cypress CapSense CY8CKIT-041-41XX

Product status: Discontinued

Raspberry Pi 4 Model B

Power supply 5v 3A USB C

USB-A to Micro-USB Cable

Software apps and online services

Cypress PSoC Creator

Raspberry Pi Raspbian

Thonny

A simple Python IDE for beginners

Story

Introduction

This project is made to control an mp3 player using a touchpad.

The novelty we propose is to use a touchpad to select the mp3 songs to listen to.

In fact, we have imagined arranging the musical pieces in a sort of grid, ordering them according to criteria chosen by the user.

For example, I can use one of this "maps" to rapresent the music I like.

Obviously it would be quite simple to make an eye-catching cover for the trackpad to make the project pleasing to the eye.

The components and the functioning

As for the components used, in addition to PSoC™ 4100S Capsense Pioneer Kit we will only use a Raspberry pi4 to contain the music tracks and send them running with VLC.

The songs will be labeled with a name that has the form:

xx_yy_Title

where xx and yy are respectively the abscissa and the ordinate, ie the coordinates in which the user will choose to insert the piece in the table corresponding to the points on the touchpad.

A directory contains all the songs and the program uses it to create a list of songs ordered by distance from the point I touched.

For example, if I want to insert a song that is a love song but a pop song, too, for example Blue Eyes by Elton John, I will insert it in the grid with coordinates between pop and love song area.

If, on the other hand, I want to listen to a piece by Miles Davis, I should assign coordinates in the "Jazz" area, etc.

Obviously the classification of the songs must be done by the user according to the criteria chosen by him.

In our case, we have only inserted a few dozen pieces of music but we could insert many.

When we start the program and touch a point on the capacitive panel with our finger, the program will order the songs according to their "distance" with respect to the coordinates chosen by the user on the touchpad and the music will start starting from the song with the smallest distance compared to the coordinates chosen with the finger and the mp3 player.

1 / 2

Once that song is finished, it will continue to propose songs, passing to the one with greater distance and continuing in this way until all the songs present in the chosen folder have been played.

The software

We started this project using one of the examples (CE224821 CapSense Touchpad) we found for the PSoC™ 4100S Capsense Pioneer Kit,

We modified it to configure a serial connection with the Raspberry pi4.

We have this python to create the song selection algorithm starting from the one at the minimum distance from the point chosen by the user, until all the songs in the directory are played.

Conclusions

This project is only a first realization of an idea, it still needs to be perfected and enriched with functionality. For example, songs are now played based on distance from the center point on the touchpad, playing songs one by one, in full.

The first improvement I can think of is obviously also using the two buttons to navigate between the songs, for example going to the previous or next one, without having to wait for the conclusion.

Obviously they are small operations that would require little time to be implemented.

It would have been really great to be able to use bluetooth, it could in fact be connected to a PC or a Raspberry directly without using any cables.

Code

#include "project.h"

/* PWM duty cycles for zero and fifty percent */
#define PWM_LED_OFF         10001
#define PWM_LED_HALF_POWER  5000

/* Scales x and y value of the touchpad to PWM compare value */
#define PWM_SCALAR          100

/*  */
#define LED_OFF             1
#define LED_ON              0

int main(void)
{
    /* Stores the current touchpad X and Y values */
    uint32 Xcord;
    uint16 Ycord;
    
    /* Stores the current gesture */
    uint32 gesture;
    
    UART_1_Start();    //prova
    
    CyGlobalIntEnable; /* Enable global interrupts. */
    
    /* Starts all Componenets */
    EZI2C_Start();
    CapSense_Start();
    PWM_Blue_Start();
    PWM_Green_Start();
    
    /* Set up communication data buffer to CapSense data structure to be exposed to
       I2C master */
    EZI2C_EzI2CSetBuffer1(sizeof(CapSense_dsRam), sizeof(CapSense_dsRam), (uint8 *)&CapSense_dsRam);
    
    /* Sets up a callback function using sysTick timer isr, the callback function
       is part of the CySysTickSetCallback API */
    CapSense_dsRam.timestampInterval = 2u;
    CySysTickStart();
    CySysTickSetCallback(0u, CapSense_IncrementGestureTimestamp);
    
    CapSense_ScanAllWidgets();
    
    for(;;)
    {
        /* Checks if the scan was completed before trying to process data */
        if(CapSense_NOT_BUSY == CapSense_IsBusy())
        {
            CapSense_ProcessAllWidgets();
            
            /* Stores the current detected gesture */
            gesture = CapSense_DecodeWidgetGestures(CapSense_TOUCHPAD0_WDGT_ID);
            
            /* Stores current finger position on the touchpad */            
            Xcord = CapSense_GetXYCoordinates(CapSense_TOUCHPAD0_WDGT_ID);
            Ycord = Xcord >> 16;
            Xcord = (uint16)Xcord;

            UART_1_SpiUartWriteTxData((uint16)Xcord);  
            UART_1_SpiUartWriteTxData((uint16)Ycord);

            /* Controls specific LEDs based on the gesture that was captured */
            switch(gesture)
            {
            case CapSense_ONE_FINGER_SINGLE_CLICK:
                PWM_Blue_WriteCompare(PWM_LED_HALF_POWER);
                PWM_Green_WriteCompare(PWM_LED_HALF_POWER);
                break;
            case CapSense_ONE_FINGER_EDGE_SWIPE_LEFT:
                /* If Led was off turn it to half power, if on turn it off */
                PWM_Blue_WriteCompare(PWM_Blue_ReadCompare() == PWM_LED_OFF ? PWM_LED_HALF_POWER: PWM_LED_OFF);
                break;
            case CapSense_ONE_FINGER_EDGE_SWIPE_RIGTH:
                /* If Led was off turn it to half power, if on turn it off */
                PWM_Green_WriteCompare(PWM_Green_ReadCompare() == PWM_LED_OFF ? PWM_LED_HALF_POWER: PWM_LED_OFF);
                break;
            case CapSense_ONE_FINGER_ROTATE_CW:
                /* Turns off the red LED */
                Red_LED_Write(LED_OFF);
                break;
            case CapSense_ONE_FINGER_ROTATE_CCW:
                /* Turns on the red LED */
                Red_LED_Write(LED_ON);
                break;
            default:
                /* Check if the touchpad was touched */
                if(CapSense_GetXYCoordinates(CapSense_TOUCHPAD0_WDGT_ID) != CapSense_TOUCHPAD_NO_TOUCH)
                {
                    /* Change the PWM compare value based on finger position as long as the light was not off */
                    PWM_Blue_WriteCompare(PWM_Blue_ReadCompare() == PWM_LED_OFF ? PWM_LED_OFF : (Xcord * PWM_SCALAR));
                    PWM_Green_WriteCompare(PWM_Green_ReadCompare() == PWM_LED_OFF ? PWM_LED_OFF : (Ycord * PWM_SCALAR));
                }
                break;
            }
            
            /* Required to maintain sychronization with tuner interface */
            CapSense_RunTuner();
            
            /* Initiates the next scan of all widgets */
            CapSense_ScanAllWidgets();
        }
    }
}

import os
import math  
import pygame
import serial
port = serial.Serial("/dev/ttyACM0", baudrate=115200, timeout=3.0)


SONG_END = pygame.USEREVENT + 1
pygame.mixer.init()

def init():

    directory = "/home/pi/Desktop/musica/"      
    songs = []
    os.chdir(directory)
    x=0
    y=0
    
    while True:
        rcv=port.read(2)
        if ((rcv[0] !=10) and (rcv[0] !=255) and (rcv[1] !=255)):
            x=rcv[0]
            x=int(x)
            y=rcv[1]
            y=int(y)
        # create a new list with the songs in the directory    
            for root, folders, files in os.walk(directory):
                folders.sort()
                files.sort()
                for file in files:
                    print(file)
                    if file.endswith(".mp3"):
                        songs.append(os.path.join(root, file))
                            
            #play a song from the list until it became empty
            while songs:
                play_songs(songs,x,y)

            print("Queue is empty!")

def play_songs(songs,x,y):

    curr_song = min_distance(songs,x,y)
    print(curr_song)
    print("Now playing: " + curr_song)
    pygame.mixer.music.load(curr_song)
    pygame.mixer.music.play()

    while pygame.mixer.music.get_busy():
        pygame.time.Clock().tick(100)

    pygame.mixer.music.set_endevent(SONG_END)

    if pygame.mixer.music.get_endevent() == SONG_END:
        songs.remove(curr_song)



def min_distance(songs,x,y):
    min_dist = 1000
    for song in songs:
        xs=song[24:26]
        xs=int(xs)
        ys=song[27:29]
        ys=int(ys)
        dist=math.sqrt((pow((x-xs),2))+pow((y-ys),2))
        if (dist<min_dist):
            min_song = song
            min_dist = dist
    return min_song


if __name__ == '__main__':
    while True:
        init()

Credits

MakerMG

3 projects • 0 followers

CR555

2 projects • 5 followers

Music Map Player