Mi è sempre piaciuto ascoltare musica. Cassette, vinili, CD, file mp3, streaming audio…

La musica digitale, però, mi ha tolto qualcosa. Sfogliare una cartella di file o aprire uno streaming audio sul pc non è come scegliere un disco. Mi manca la dimensione fisica della musica, scartabellare in mezzo ad un pacco di album e scegliere quello che voglio sentire.

Allora mi sono ingegnato. Come costruire un oggetto che abbia i pregi della musica digitale in termini di versatilità, disponibilità e costo (io ascolto musica soprattutto da Jamendo) ed il fascino del supporto fisico? La soluzione sta tutta in due cose: un raspberry pi, alcuni tag a radiofrequenza ed un lettore di tag a radiofrequenza. L’idea era: voglio mettere dei file mp3 in una chiavetta usb, divisi per cartelle. Voglio poi che un’interazione con un oggetto fisico avvii la riproduzione di tutti i brani in una determinata cartella. Dato che sono soddisfatto del risultato, mi va di condividere qualche dettaglio, così se qualcuno volesse, potrebbe realizzare lo stesso oggetto o un oggetto simile.

Parte uno – il raspberry e relativo software per la riproduzione musicale

Ho deciso di utilizzare raspbian, una distribuzione leggera e personalizzabile. Ho scaricato l’immagine dal sito web e l’ho scritta su una chiavetta sd. Una volta installato, tramite il tool di configurazione ho impostato l’avvio in modalità testuale – non serve un desktop per riprodurre musica. Ho quindi installato automount, un programma per montare velocemente e automaticamente la chiavetta usb

sudo apt-get install autofs

Da qui, ho iniziato con la configurazione personalizzata.

Per la riproduzione audio ho deciso di usare mplayer in modalità slave, ovvero controllandolo attraverso un file fifo.

mkdir musiscatola

cd musiscatola

mkfifo mplayer.fifo

In questo modo è possibile controllare mplayer attraverso una serie di comandi passati direttamente nel file fifo. A me interessano tre comandi soltanto (dev’essere un lettore musicale, non un computer che esegue un programma di musica): play/pausa, traccia avanti, traccia indietro.

Per provare se tutto è ok infilo la mia chiavetta usb (che contiene una cartella musiscatola, la quale a sua volta contiene una serie di cartelle, una per album, ed eseguo questi comandi:

mplayer -slave -input file=/home/pi/musiscatola/mplayer.fifo /media/usb/musiscatola/d1/*

Così inizia la riproduzione della musica.  Per mettere in pausa e far ripartire la riproduzione il comando è lo stesso:

echo pause > /home/pi/musiscatola/mplayer.fifo

per saltare avanti di una traccia:

echo pt_step +1 > /home/pi/musiscatola/mplayer.fifo

infine, per saltare indietro:

echo pt_step -1 > /home/pi/musiscatola/mplayer.fifo

Se tutto funziona, proseguiamo alla fase successiva.

Parte due – bottoni per controllare la riproduzione audio

A questo punto, la mia intenzione è di controllare la riproduzione tramite pulsanti. Prima l’elettronica, poi il software.

Il raspberry ha una porta GPIO che conta 26 pin di input ed output. Si trova molta documentazione in merito su internet, per esempio qui.

Alcuni dei pin sono programmabili, io ne uso tre per i pulsanti.

Saldo i miei pulsanti a due cavi, all’altra estremità saldo due connettori tipo jumper, di misura per i pin del raspberry. I pulsanti devono chiudere il circuito tra un pin programmabile e un pin ground.

Collego il pulsante pausa ai pin 13 e 14 (ovvero GPIO27 e ground). Traccia avanti va tra 22 e 20 (GPIO25 e ground) e traccia indietro tra 7 e 9 (GPIO4 e ground).

Aggiungo anche un led, collegato tra 23 e 25 (GPIO11 e ground). Un led fa sempre comodo. Già che ci sono collego anche un interruttore a leva tra i pin 5 e 6 (GPIO3 e ground), servirà poi per accensione e spegnimento.

Ora il software. Mi serve che un programma controlli la pressione dei bottoni, e che se i bottoni vengono premuti esegua un comando specifico. Con wiringPi non è difficile. Installo wiringPi e relative dipendenze seguendo le istruzioni presenti online, poi inizio a lavorare ai miei tre script.

cd musiscatola 
mkdir bottoni-wiringpi
nano avanti.sh
nano indietro.sh
nano pausa.sh

Fondamentalmente, ogni script è un ciclo while scritto in bash: per brevità non riporto qui il codice di tutti e tre, visto che sono molto simili. Li metto in questo archivio, insieme a tutto il resto del codice.

Ecco, per esempio, quello che controlla il tasto avanti. Da notare che il ciclo si chiude con mezzo secondo di sleep in funzione di debouncing.

#!/bin/sh
while :
do

gpio - g mode 25 up
gpio -g wfi 25 falling
echo pt_step +1 > /home/pi/musiscatola/mplayer.fifo 
sleep 0.5

done

Una volta realizzati i 3 script per i tasti posso testare il tutto, lanciando mplayer in modalità slave e schiacciando i bottoncini. Se tutto è ok, è ora di occuparmi di NFC. Led e accensione li sistemo per ultimi. 

Parte tre – lettore NFC per lanciare l’audio

Per far funzionare il lettore NFC uso libnfc e nfc-eventd, un servizio che monitora il lettore per la presenza e la rimozione dei tag a radiofrequenza. Download e documentazione sulla pagina del progetto.

Una volta installato tutto, è necessario configurare nfc-eventd. Il file di configurazione è /usr/local/etc/nfc-eventd.conf

La mia idea è la seguente: appoggio il tag rfid, il servizio ne legge la presenza e ne rileva il codice, dopodiché lo scrive in un file da cui un altro programma lo leggerà, lanciando la mia istanza di mplayer sulla cartella associata a quel particolare tag.

Nelle prime righe lo imposto in  modo che funzioni come daemon, ovvero come servizio e non in modalità debug.

Nella sezione “device” imposto driver e nome del mio lettore NFC, nella fattispecie “pn53x_usb” e “SCM Micro 7 SCL3711-NFCR&W”

Nella sezione “action” dell’evento “tag inserted” in nfc-eventd.conf scrivo:

action = "echo $TAG_UID > /home/pi/musiscatola/lettore-nfc/input.nfc"

Nella sezione “action” dell’evento “tag has been removed” scrivo:

action = "echo discorimosso > /home/pi/musiscatola/lettore-nfc/input.nfc"

a questo punto, creo il file e la cartella in cui il servizio deve scrivere:

cd /home/pi/musiscatola
mkdir lettore-nfc
nano input.nfc

ciò fatto, devo solo ottenere l’id dei miei tag per poi poterli associare ad una cartella di musica. Ci sono più modi di farlo. Io ho deciso di utilizzare il solito nfc-eventd con una configurazione differente. Copio il file di configurazione nfc-eventd.conf e lo chiamo nfc-eventd.conf.registradischi

Lo modifico come segue:

Nelle prime righe lo imposto in  modo che funzioni in modalità debug e non come daemon.

Nella sezione “action” dell’evento “tag inserted” in nfc-eventd.conf scrivo:

action = "echo disco numero $TAG_UID"

Nella sezione “action” dell’evento “tag has been removed” scrivo:

action = "echo discorimosso"

Per lanciare il servizio con questo secondo file di configurazione ed ottenere così gli id dei tag, basta usare il comando

sudo nfc-eventd config_file=/usr/local/etc/nfc-eventd.conf.registradischi

Se eseguo questo comando, posso vedere a terminale gli id delle tag ed annotarmeli a parte.

Ora mi serve un programma che controlli continuamente il mio file input.nfc e che, se dovesse scovarvi il codice del tag associato al disco uno, esegua il contenuto della rispettiva cartella. Se dovesse trovare invece la dicitura “discorimosso”, dovrebbe arrestare la riproduzione. Ne ho scritti due separati, uno lancia l’istanza di mplayer ed uno l’arresta. Anche in questo caso, il codice è nell’archivio (musiscatola/lettore-nfc). I due programmi si chiamano nfc.py e nfc-stop.py

Parte quattro – tutto assieme

Il raspberry pi normalmente si accende collegandolo alla corrente e si spegne con un comando da terminale. Tuttavia, io voglio che sia un lettore musicale, voglio quindi accenderlo e spegnerlo con un solo interruttore. Mi viene aiuto una caratteristica del raspberry pi: con la scheda spenta ma alimentata (ovvero connessa alla corrente) un cortocircuito dei pin 5 e 6 (GPIO3 e ground) avvia il sistema in modalità sicura. Dato che la modalità sicura non mi interessa, modifico il file /boot/config.txt aggiungendo alla fine

avoid_safe_mode=1

In questo modo ho la mia accensione. Ora devo fare in modo che l’apertura di quel circuito inneschi uno spegnimento sicuro. Creo un file spegnimento.sh nella cartella musiscatola/bottoni-wiringpi (anche questo visibile nell’archivio). Il funzionamento è semplice ed intuitivo, tanto quanto quello degli altri tre bottoni.

Avevo un led in sospeso, collegato a GPIO11. Decido di usarlo per vedere quando il lettore è pronto. Scrivo un semplicissimo script in bash che lo fa lampeggiare e lo lascia acceso (musiscatola/led). Sarà mia cura lanciarlo dopo tutti gli altri servizi. Forse in futuro ne aggiungo anche un altro, vedremo.

Dopo aver testato le varie parti una ad una, devo mettere assieme il tutto. Scrivo uno script in bash che mi lanci, in ordine, tutto quello che mi serve per far funzionare la mia musiscatola (anche questo è nell’archivio al percorso musiscatola/musiscatola.sh).

Modifico il file /home/pi/.bashrc aggiungendo i miei servizi in avvio, ovvero musiscatola.sh e sudo nfc-eventd

A questo punto è tutto pronto: spengo il raspberry, scarico una ventina di album da jamendo, li metto ordinatamente nella mia chiavetta, accendo il raspberry e mi godo la mia musiscatola.

Note conclusive: sono un filosofo, non un programmatore. Il codice si può sicuramente fare meglio, ma se non altro così funziona. Tutto il software in uso è licenziato con GPL quindi di codice non si spende un euro. Raspberry, lettore e 20 tag assieme costano sugli 80 euro. Fare delle buone casse è un casino, quindi ho preferito montare una presa jack da 3.5 ed usare quelle dell’impianto che già ho a casa. Per lavorare sul Pi conviene usare una chiavetta wifi e collegarsi in ssh, basta cercare su internet e si trova come fare. Il design della mia musiscatola è transitorio, appena ho tempo farò qualcosa di meglio, sia per il box che per i tag.