Published May 5, 2020 © MIT

My Little Piano

A web application using Raspberry Pi which provides an interactive way with song samples to play the piano using a buzzer and RGB led

IntermediateFull instructions provided1,064

Things used in this project

Hardware components

Raspberry Pi Zero Wireless

Breadboard (generic)

Buzzer

1N4007 – High Voltage, High Current Rated Diode

General Purpose Transistor NPN

Resistor 1k ohm

Male/Male Jumper Wires

Male/Female Jumper Wires

Through Hole Resistor, 150 ohm

LED, RGB

SparkFun Pushbutton switch 12mm

Software apps and online services

Raspberry Pi Raspbian

Story

This project is about simulating a piano via a web application that runs using Flask in Python. The web page has 4 pages: Home, Single Octave Piano, Three Octave Piano, and Samples which are constructed using Bootstrap 4 and Font Awesome 4. To make the piano more 'friendly' I used an RGB LED for different musical notes pressed on the piano. Also, I added 3 samples of songs: Coffin Dance, Smells Like Teen Spirits, and Sweet Dreams, which can be played either through the Samples page, either through those 3 push buttons on the breadboard.

Images

1 / 6

Intro

Short Presentation of the Project

How it works

Piano musical notes frequencies are stored in a JSON file. The program runs on 2 threads: one for the web application and another one for the 3 push buttons inputs. The Http requests are sent using ajax and jquery.

Each song sample has its own class. They extend Abstract_Song class and have methods that contain specific sequences of notes and delays. If the project is cloned, each user can add their own songs there if they want to.

Each musical note has its own color displayed on the RGB LED. The colors are as follows:

C (Do) - red
C# (Do Major) - pale cyan
D (Re) - yellow
D# (Re Major) - pale magenta
E (Mi) - green
F (Fa) - cyan
F# (Fa major) - orange
G (Sol) - blue
G# (Sol major) - pale yellow
A (La) - magenta
A# (La major) - pale blue
B (Si) - white

Note: The pale colors could be displayed a little bit differently, according to your RGB LED. You can change those colors in the raspberrypi_configurations.py file.

How to run the program

Becauseof the PWM output from the Rpi.GPIO library is not stable enough, we are going to use the pigpio library to use the hardware PWM capability of the development board.

Pigpio is a library that allows control over all the GPIO pins on a raspberry pi, just as the Rpi.GPIO library. It usually comes pre-installed with the Raspbian.

If you don't have it, install it using the following commands:

wget abyz.me.uk/rpi/pigpio/pigpio.zip
unzip pigpio.zip
cd PIGPIO
make
sudo make install

In order to start the application, you need to do the following steps:

1) Run a pigpiod daemon:

sudo pigpiod

Every time you start the terminal you need to start the pigpiod daemon if you want to use a script that uses the pigpio library.

2) Install flask web framework in python:

sudo pip3 install flask

3) Clone the Github repository:

git clone https://github.com/enaky/My_Little_Piano.git

4) Run the application using the following command:

python3 my_little_piano_app.py

The server runs on port 2014. You can change the port in the my_little_piano_app.py. The link for the website is:
rasp_ip:2014/

where rasp_ip - is your raspberry pi IP address. Example: 192.168.1.106:2014/

Note: You can find this IP address typing the following command in the terminal of your raspberry pi.

ifconfig

Project Structure and Code

Note: The total code contains 1870 lines including blank spaces.

So, please check the Github Page for full code.

1 / 5

Short Project Structure Modules Analysis:

raspberrypi_configurations - contains all the configurations for raspberry Pi including buzzer and RGB led colors settings
resources - contains the JSON which holds all 7 octaves of the piano with notes frequencies
samples - includes the abstract class abstract_song.py which can be extended to implement a new song and three implemented song classes included in sweet_dreams.py, coffin_dance.py and smells_like_teen_spirit.py
utilities - includes loading the JSON function into an array or JSON object
web_services - contains all files for the web application

1) web_services.py holds the flask routes which provides to assign URLs in our app to functions easily

2) templates - contains 4 HTML files (HTML and js) for the 4 pages of the website (Bootstrap 4 and Font Awesome 4 are used)

3) static - contains the CSS for the piano octaves and the images used in the web pages (Home Page and Samples Page)

The main program is located in my_little_piano_app.py. Here are included all the modules specified above and also a function is constructed here (for playing the samples using the pushbuttons) which runs on a different thread.

Song Samples

Sample 1 - Coffin Dance

"Coffin Dance" Sample (using local push button)

Sample 2 - Smells Like Teen Spirits

"Smells Like Teen Spirit" Sample (using local push button)

Sample 3 - Sweet Dreams

"Sweet Dreams" Sample (using local push button)

Code

my_little_piano_app.py

"""
 * In HTML and using JavaScript we will call special functions that
 * will play a specific note on the buzzer when any key of the piano
 * is pressed. Also we have 3 pages on the web, one for single octave piano,
 * another for three octave piano, and last one are for the sample songs.
 * You can enable those songs using the 3 inputs of the breadboard.
 * Before you run the code, do not forget to start the pigpiod daemon
 * using "sudo pigpiod".

 """
import threading

from samples.coffin_dance import CoffinDance
from samples.sweet_dreams import SweetDreams
from samples.smells_like_teen_spirit import SmellsLikeTennSpirit
from utilities.utilities import load_piano_octaves, get_piano_octaves_json
from web_services import web_services as web
from raspberrypi_configurations import raspberrypi_configurations as rasp

running_flag = True


def local_input_piano_samples():
    global running_flag, web_song
    try:
        data = get_piano_octaves_json()
        sweet_dreams = SweetDreams(data['octave_4'], data['octave_5'], 3)
        smells_like_teen_spirits = SmellsLikeTennSpirit(data['octave_4'], data['octave_5'], data['octave_6'], 1.2)
        coffin_dance = CoffinDance(data['octave_4'], data['octave_5'], 1.2)
        print("Loaded piano json for local input. Thread: {}".format(threading.current_thread()))
        while running_flag:
            # if the first button was pressed, play the first song
            if (rasp.GPIO.input(rasp.button1) == rasp.GPIO.LOW or web.web_song == 1) and rasp.is_buzzer_off:
                rasp.is_buzzer_off = False
                rasp.is_buzzer_used_locally = True
                coffin_dance.play()
                rasp.is_buzzer_off = True
                rasp.is_buzzer_used_locally = False
                web.web_song = 0

            # if the second button was pressed, play the second song
            if (rasp.GPIO.input(rasp.button2) == rasp.GPIO.LOW or web.web_song == 2) and rasp.is_buzzer_off:
                rasp.is_buzzer_off = False
                rasp.is_buzzer_used_locally = True
                smells_like_teen_spirits.play()
                rasp.is_buzzer_off = True
                rasp.is_buzzer_used_locally = False
                web.web_song = 0

            # if the third button was pressed, play the third song
            if (rasp.GPIO.input(rasp.button3) == rasp.GPIO.LOW or web.web_song == 3) and rasp.is_buzzer_off:
                rasp.is_buzzer_off = False
                rasp.is_buzzer_used_locally = True
                sweet_dreams.play()
                rasp.is_buzzer_off = True
                rasp.is_buzzer_used_locally = False
                web.web_song = 0
    except (RuntimeError, OSError, AttributeError, KeyboardInterrupt):
        print("Unexpected event in the main thread. Exiting thread {}".format(threading.current_thread()))
    finally:
        print("Thread {} stopped.".format(threading.current_thread()))


def main():
    global running_flag
    web.octave_array = load_piano_octaves()

    if web.octave_array is None:
        return

    try:
        # we will run the app on port 2014
        # run(host='0.0.0.0', port='2014')
        local_input_thread = threading.Thread(target=local_input_piano_samples)
        local_input_thread.daemon = True
        local_input_thread.start()

        web.app.debug = False
        web.app.use_reloader = False
        web.app.run(host='0.0.0.0', port=2014)

    except KeyboardInterrupt:
        pass
    finally:
        #stop the local thread
        running_flag = False

        # stop the pwm signal
        rasp.pi.hardware_PWM(web.buzzer, 0, 0)
        rasp.rgb_led_configure()
        rasp.GPIO.cleanup()

        # stop the connection with the daemon
        rasp.pi.stop()


if __name__ == '__main__':
    main()

Credits

Vasile Enachi

1 project • 1 follower

Thanks to Plusivo.

My Little Piano

Things used in this project

Hardware components

Software apps and online services

Story

Images

Intro

How it works

How to run the program

Project Structure and Code

Song Samples

Schematics

Visualisation using Fritzing

Schematics

Code

my_little_piano_app.py

My Little Piano

Credits

Vasile Enachi

Comments

Embed the widget on your own site

My Little Piano

My Little Piano

Things used in this project

Hardware components

Software apps and online services

Story

Images

Intro

How it works

How to run the program

Project Structure and Code

Song Samples

Schematics

Visualisation using Fritzing

Schematics

Code

my_little_piano_app.py

My Little Piano

Credits

Vasile Enachi

Comments

Related channels and tags