Note

Hello, welcome to the SunFounder Raspberry Pi & Arduino & ESP32 Enthusiasts Community on Facebook! Dive deeper into Raspberry Pi, Arduino, and ESP32 with fellow enthusiasts.

Why Join?

• Expert Support: Solve post-sale issues and technical challenges with help from our community and team.

• Learn & Share: Exchange tips and tutorials to enhance your skills.

• Exclusive Previews: Get early access to new product announcements and sneak peeks.

• Special Discounts: Enjoy exclusive discounts on our newest products.

• Festive Promotions and Giveaways: Take part in giveaways and holiday promotions.

👉 Ready to explore and create with us? Click [here] and join today!

8.14 Bluetooth Piano

The project uses a custom-built application to transform a Raspberry Pi Pico 2 W into a Bluetooth-enabled piano. The Pico 2 W runs a MicroPython script that sets up a BLE peripheral, enabling it to receive note data from a connected device. Upon receiving a note, the board processes the data and plays the corresponding frequency using a passive buzzer.

This project is a great way to explore the basics of Bluetooth Low Energy (BLE) communication, sound generation with PWM, and how to create interactive applications using Raspberry Pi Pico 2 W.

The app used in this project was developed with MIT App Inventor.

1. Build the Circuit

Required Components

In this project, we need the following components.

It’s definitely convenient to buy a whole kit, here’s the link:

Name	ITEMS IN THIS KIT	LINK
Pico 2 W Starter Kit	450+	Pico 2 W Kit

You can also buy them separately from the links below.

SN	COMPONENT	QUANTITY	LINK
1	Getting to Know Pico 2 W	1
2	Micro USB Cable	1
3	Breadboard	1	BUY
4	Jumper Wires	Several	BUY
5	Transistor	1(S8050)	BUY
6	Resistor	1(1KΩ)	BUY
7	Passive Buzzer	1	BUY

2. Create the Android App

You will develop the Android application using MIT App Inventor, a free web application ideal for beginners in Android development. It offers intuitive drag-and-drop features for creating functional applications.

Follow these steps to get started:

1. Go to Get Started with MIT App Inventor, and click “online tool” to login. You will need a Google account to register with MIT App Inventor.

   

2. After logging in, navigate to Projects -> Import project (.aia) from my computer. Subsequently, upload the ble_piano_picow.aia file located in the following path: pico-2w-kit/micropython/iot/8.14-ble_piano.

   Alternatively, you can download the file directly: ble_piano_picow.aia

   

3. Once uploaded, the app template will appear in the MIT App Inventor interface. This pre-configured template can be customized after you become familiar with the platform.

4. MIT App Inventor has two main sections: Designer and Blocks. You can switch between these two sections in the upper right corner of the page.

   

5. The Designer allows you to add buttons, text, screens, and modify the overall aesthetic of your app.

   

6. Next, there’s the Blocks section. This section lets you craft custom functionalities for your app, allowing you to program each component on the app’s GUI to achieve desired features.

   

7. To install the app on a phone, navigate to the Build tab.

   

   • Generate a .apk file. After selecting this option, a page will appear allowing you to choose between downloading a .apk file or scanning a QR code for installation. Follow the installation guide to complete the application installation.

     Alternatively, download our pre-compiled APK file here: ble_piano_picow.apk

   • If you wish to publish this app to Google Play or another app marketplace, you can generate a .aab file.

3. Run the Code

Open the 8.14-ble_piano.py file under the path of pico-2w-kit/micropython/iot/8.14-ble_piano, or copy this code into your IDE.

Note

This code depends on the ble_advertising.py file. Make sure to upload it to the Pico board before running the script.

import bluetooth
import random
import struct
import time
from ble_example.ble_advertising import advertising_payload
from machine import Pin, PWM
import time

from micropython import const

buzzer = PWM(Pin(15))

NOTES = {
    'NOTE_C4': 262,
    'NOTE_D4': 294,
    'NOTE_E4': 330,
    'NOTE_F4': 349,
    'NOTE_G4': 392,
    'NOTE_A4': 440,
    'NOTE_B4': 494,
    'NOTE_C5': 523
}

_IRQ_CENTRAL_CONNECT = const(1)
_IRQ_CENTRAL_DISCONNECT = const(2)
_IRQ_GATTS_WRITE = const(3)

_FLAG_READ = const(0x0002)
_FLAG_WRITE_NO_RESPONSE = const(0x0004)
_FLAG_WRITE = const(0x0008)
_FLAG_NOTIFY = const(0x0010)

_PIANO_UUID = bluetooth.UUID("952cc3a7-1801-4c07-b141-e1e3964f54b5")
_NOTE_CHAR = (
    bluetooth.UUID("ea30277b-d7a5-4eeb-af70-6179c45d7ee6"),
    _FLAG_READ | _FLAG_WRITE | _FLAG_WRITE_NO_RESPONSE,
)
_PIANO_SERVICE = (
    _PIANO_UUID,
    (_NOTE_CHAR,),
)


class BLEPiano:
    def __init__(self, ble, name="ble-piano"):

        self._ble = ble
        self._ble.active(True)
        self._ble.irq(self._irq)

        handles = self._ble.gatts_register_services((_PIANO_SERVICE,))
        # print("Registered handles:", handles)

        ((self._handle_note,),) = handles
        self._connections = set()

        self._write_callback = None

        self._payload = advertising_payload(name=name, services=[_PIANO_UUID])
        self._advertise()

    def _irq(self, event, data):
        # Track connections so we can send notifications.
        if event == _IRQ_CENTRAL_CONNECT:
            conn_handle, _, _ = data
            print("New connection", conn_handle)
            self._connections.add(conn_handle)
        elif event == _IRQ_CENTRAL_DISCONNECT:
            conn_handle, _, _ = data
            print("Disconnected", conn_handle)
            self._connections.remove(conn_handle)
            # Start advertising again to allow a new connection.
            self._advertise()
        elif event == _IRQ_GATTS_WRITE:
            conn_handle, value_handle = data
            value = self._ble.gatts_read(value_handle)
            # print("Write event: conn_handle={}, value_handle={}, value={}".format(conn_handle, value_handle, value))
            if value_handle == self._handle_note and self._write_callback:
                self._write_callback(value)


    def is_connected(self):
        return len(self._connections) > 0

    def _advertise(self, interval_us=500000):
        print("Starting advertising")
        self._ble.gap_advertise(interval_us, adv_data=self._payload)

    def on_write(self, callback):
        self._write_callback = callback

def note_update(data):
    print("Receive:", data)

    decoded_data = data.decode('utf-8').rstrip('*\x00')

    buzzer.freq(NOTES[decoded_data])
    buzzer.duty_u16(32768)
    time.sleep(0.15)
    buzzer.duty_u16(0)

def demo():
    ble = bluetooth.BLE()
    piano = BLEPiano(ble,"pico2w")

    while True:
        if piano.is_connected():
            piano.on_write(note_update)
        # time.sleep_ms(100)

if __name__ == "__main__":
    demo()

4. App and Bluetooth Connection

Ensure that the “BLE Piano” app created earlier is installed on your phone.

1. Enable Bluetooth on your phone.

2. Open the BLE Piano app.

   

3. When you open the app for the first time, you will see two consecutive prompts requesting permissions. These permissions are required for Bluetooth functionality.

   

4. In the APP, click on Connect button to establish a connection between the APP and Pico 2 W via bluetooth.

   

5. This page displays a list of all Bluetooth devices. Choose the xx.xx.xx.xx.xx.xx pico2w option from the list. Each device name is displayed alongside its MAC address.

   

6. If no devices appear in the list, try enabling the location feature on your phone. (On some Android versions, the location setting is linked to Bluetooth functionality.)

7. Once connected, the system will redirect you to the main screen. You can tap the music note button to play the corresponding note. The app sends the note data to the Pico board, which drives the buzzer to play the specified note based on the data.