Raspberry Pi: come realizzare uno speaker Bluetooth

Raspberry Pi è un mini PC basato su un SoC ARM davvero versatile. Non solo può svolgere tutte le funzioni di un normale computer ma grazie ad una serie di soluzioni software è capace di trasformarsi in un device embedded che anima progetti di varia natura, come piccoli robot o prodotti IoT e di domotica. In questa guida spiegheremo come realizzare un un ricevitore audio Bluetooth con il Raspberry Pi. In modo tale da creare uno speaker Bluetooth fatto in casa con alcune casse audio di recupero.

Non si tratta di un'operazione difficile o che necessità di competenze particolari. Dunque tale tutorial può essere eseguito anche da coloro che sono alle prime armi con Raspberry Pi ed in generale con una distribuzione Linux.

Requisiti hardware

Per completare questo piccolo progetto avremo bisogno di un Raspberry Pi 4, ma va bene anche un modello meno recente come il Raspberry Pi 3, di una microSD da almeno 64GB di storage e di una coppia di altoparlanti da connettere all'ingresso jack da 3.5mm presente nella board.  Il nostro obbiettivo sarà infatti quello di riciclare delle vecchie casse audio che non utilizziamo più.

Installazione di RaspberryPi OS sul Raspberry Pi

Prima di tutto è necessari installare e configurare il sistema operativo di riferimento del Raspberry Pi ovvero RaspberryPi OS. Per farlo dobbiamo eseguire il flash di tale distribuzione Linux all'interno di una microSD. Questo procedimento può essere svolto senza problemi tramite il comodo imaging tool chiamato Raspberry Pi Imager, sviluppato dal team di coder della Raspberry Pi Foundation.

Eseguiamo il download di questo software dal sito ufficiale di RaspberryPi OS, avviamo l'applicativo, selezioniamo l'ultima edizione della distribuzione tramite il pulsante "Choose OS" e successivamente indichiamo la microSD da utilizzare per l'installazione cliccando sul tasto "Choose Storage". Infine avviamo il procedimento di flashing premendo su "Write".

L'intera operazione dovrebbe durare qualche minuto. Al suo termine chiudiamo Raspberry Pi Imager, inseriamo la microSD nel Raspberry Pi e connettiamo la board all'alimentazione, ad un monitor ed ovviamente a mouse e tastiera in modo tale da avviare il primo wizard di configurazione del sistema operativo. In questo tutorial non ci focalizzeremo su tale processo, che in ogni caso è davvero molto semplice.

Installazione del server audio PipeWire e WirePlumber

A questo punto siamo pronti per avviare la "trasformazione" vera e propria del dispositivo in uno speaker Bluetooth. Andremo sostanzialmente ad implementare una particolare soluzione software che sfrutta alcune funzionalità del server audio PipeWire, che è ormai di riferimento per innumerevoli distribuzioni Linux, oltre che del session & policy manager correlato, chiamato WirePlumber.

Per poter attingere alle feature di PipeWire che ci servono è necessario sfruttare la versione presente all'interno dei repository software di Debian testing. Per questo è necessario aggiungere manualmente un repository ed operare quello che viene definito come apt pinning, ovvero l'uso di specifici pacchetti provenienti da altri rami di sviluppo di Debian senza eseguire una migrazione dell'interno sistema.

RaspberryPi OS è ancora basata su Debian Bullseye e nei suoi repository è presente una vecchia versione di PipeWire che non è adatta al nostro scopo. Quindi procediamo all'aggiunta del repository che ci serve. Apriamo la shell e digitiamo:

echo 'APT::Default-Release "stable";' | sudo tee /etc/apt/apt.conf.d/99defaultrelease
echo "deb http://ftp.de.debian.org/debian/ testing main contrib non-free" | sudo tee /etc/apt/sources.list.d/testing.list
sudo apt update && sudo apt -t testing install pipewire wireplumber libspa-0.2-bluetooth

Configurazione di BlueZ

Ora che abbiamo ottenuto la release di PipeWire più recente possiamo passare alla configurazione del demone del Bluetooth, chiamato BlueZ, cosi da permettere la connessione e lo streaming della musica da altri dispositivi.

Procediamo quindi con l'installazione del pacchetto DBus Python necessario per fare in modo che un client Bluetooth possa connettersi automaticamente senza la necessità di una configurazione manuale per ogni singolo dispositivo:

sudo apt install python3-dbus

Ora dobbiamo copiare lo script chiamato pw_wp_bluetooth_rpi_speaker nella nostra home directory. Quindi generiamo il file tramite l'editor di testo nano:

sudo nano speaker-agent.py

ed incolliamo nel file appena creato lo script Python seguente:

#!/usr/bin/python3
# SPDX-License-Identifier: LGPL-2.1-or-later
import dbus
import dbus.service
import dbus.mainloop.glib
from gi.repository import GLib
BUS_NAME = 'org.bluez'
AGENT_INTERFACE = 'org.bluez.Agent1'
AGENT_PATH = "/speaker/agent"
A2DP = '0000110d-0000-1000-8000-00805f9b34fb'
AVRCP = '0000110e-0000-1000-8000-00805f9b34fb'
bus = None
class Rejected(dbus.DBusException):
_dbus_error_name = "org.bluez.Error.Rejected"
class Agent(dbus.service.Object):
exit_on_release = True
def set_exit_on_release(self, exit_on_release):
self.exit_on_release = exit_on_release
@dbus.service.method(AGENT_INTERFACE,
in_signature="", out_signature="")
def Release(self):
print("Release")
if self.exit_on_release:
mainloop.quit()
@dbus.service.method(AGENT_INTERFACE,
in_signature="os", out_signature="")
def AuthorizeService(self, device, uuid):
# Always authorize A2DP and AVRCP connection
if uuid in [A2DP, AVRCP]:
print("AuthorizeService (%s, %s)" % (device, uuid))
return
else:
print("Service rejected (%s, %s)" % (device, uuid))
raise Rejected("Connection rejected by user")
@dbus.service.method(AGENT_INTERFACE,
in_signature="", out_signature="")
def Cancel(self):
print("Cancel")
def start_speaker_agent():
# By default Bluetooth adapter is not discoverable and there's
# a 3 min timeout
# Set it as always discoverable
adapter = dbus.Interface(bus.get_object(BUS_NAME, "/org/bluez/hci0"),
"org.freedesktop.DBus.Properties")
adapter.Set("org.bluez.Adapter1", "DiscoverableTimeout", dbus.UInt32(0))
adapter.Set("org.bluez.Adapter1", "Discoverable", True)
print("RPi speaker discoverable")
# As the RPi speaker will not have any interface, create a pairing
# agent with NoInputNoOutput capability
obj = bus.get_object(BUS_NAME, "/org/bluez")
manager = dbus.Interface(obj, "org.bluez.AgentManager1")
manager.RegisterAgent(AGENT_PATH, "NoInputNoOutput")
print("Agent registered")
manager.RequestDefaultAgent(AGENT_PATH)
def nameownerchanged_handler(*args, **kwargs):
if not args[1]:
print('org.bluez appeared')
start_speaker_agent()
if __name__ == '__main__':
dbus.mainloop.glib.DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
agent = Agent(bus, AGENT_PATH)
agent.set_exit_on_release(False)
bus.add_signal_receiver(nameownerchanged_handler,
signal_name='NameOwnerChanged',
dbus_interface='org.freedesktop.DBus',
path='/org/freedesktop/DBus',
interface_keyword='dbus_interface',
arg0='org.bluez')
dbus_service = bus.get_object('org.freedesktop.DBus',
'/org/freedesktop/DBus')
dbus_dbus = dbus.Interface(dbus_service, 'org.freedesktop.DBus')
if (dbus_dbus.NameHasOwner('org.bluez')):
print('org.bluez already started')
start_speaker_agent()
mainloop = GLib.MainLoop()
mainloop.run()

Salviamo il file tramite la combinazione di tasti CTRL+O e chiudiamo il documento con CTRL+X. Questo file imposta l'adattatore Bluetooth del device in modo tale che sia sempre visibile e raggiungibile dagli altri dispositivi e ne consente il pairing automatico.

Ora è necessario creare un file per il gestore dei demoni systemd, chiamato systemd unit, in modo da rendere operativo lo script:

sudo nano ~/.config/systemd/user/speaker-agent.service

All'interno del nuovo file incolliamo queste stringhe di testo:

[Unit]
Description=Bluetooth speaker agent
[Service]
ExecStart=python speaker-agent.py
[Install]
WantedBy=default.target

Ora abilitiamo questa nuova regola tramite tale comando:

sudo systemctl --user enable speaker-agent.service

e infine impostiamo tale configurazione anche su BlueZ cosi da autorizzare l'auto re-pairing Bluetooth senza la necessità di interazione da parte dell'utente:

sudo sed -i 's/#JustWorksRepairing.*/JustWorksRepairing = always/' /etc/bluetooth/main.conf

La configurazione software è dunque terminata. Adesso è finalmente arrivato il momento di connettere le casse audio tramite l'ingresso jack da 3.5mm. Fatto questo eseguiamo il pairing del nostro telefono/tablet al Raspberry Pi e lanciamo in streaming la musica che desideriamo.