Minilos: a device for intentional listening in the digital age

It’s funny how in the age of digital music, vinyl sales are soaring. Sure, Spotify and the likes put all the music in the world at our grasp - but we’ve lost something along the way. We end up just listening to whatever the algorithm fancies, rather than curating our own musical choices. Which is why people are turning to the physical experience of collecting records and playing them intentionally.

That’s all very romantic, but impractical: vinyls are expensive to buy (and more so now that they have turned into collector’s items), and let’s be real, they don’t have the best sound quality (although some people actually prefer it that way).

So, we invented our own solution: minilos. A device that uses mini vinyl records as triggers to play digital music from a speaker. Read on for all the details about the implementation.

First prototype, with Raspberry Pi

If you’ve been following our blog closely, you’ll notice a lot of similarities with another project we’ve shown you before: the NFC floppy disk launcher. Indeed, minilos follows exactly the same approach, only applied to music.

We did a first version of this project several years ago actually. At that time, we played music at home through a Google smart speaker, casted from Spotify. The process was kind of a PITA, since it involved opening the Spotify app on the phone, searching for the music you want to listen to, and then casting to the speaker, and praying that it works.

At some point we discovered some cute coasters on Aliexpress in the shape of mini vinyl records, and we thought, wouldn’t it be cool to play music from these instead?

And thus, we devised a system to bridge both ends: we sticked NFC tags into the mini-vinyls, and used a Raspberry Pi running a python script to read them, match each tag with a spotify album ID, and then tell the Spotify API to play it in our Google Speaker. We made a little plywood case to enclose the RPi, and place the minilo on top - so it all felt like you were playing an old-school record.

The full code and BOM for this version are on Github.

Revision, with ESPHome and domotics

The device worked just nicely, but after some time, we started progressively incorporating domotics into our home, to the point where most of our devices are now connected with a Home Assistant instance. And it turns out we could migrate the logic of the device into different parts of our domotics system.

First, we replaced with Raspberry Pi with an ESP32 board running the ESPHome firmware. This way, with just a bit of config (describing a pn532 NFC component, and a text sensor), we can continuously read from the NFC and publish to a HA entity:

text_sensor:
  - platform: template
    id: last_tag
    name: "Last NFC Tag"

pn532_i2c:
  update_interval: 2s
  on_tag:
    then:
      - lambda: |-
          ESP_LOGI("pn532", "Tag scanned: %s", x.c_str());
          id(last_tag).publish_state(x);
  on_tag_removed:
    then:
      - lambda: |-
          ESP_LOGI("pn532", "Tag removed");
          id(last_tag).publish_state("None");

Last NFC Tag value now accessible from HA

Then, our Node-RED instance has a workflow that monitors that entity, and triggers when its value changes.

Set playlist is a custom function that contains the mapping between NFC ids and Spotify album ids:

function translate (payload) {
    node.warn(`Reading minilo ID ${msg.payload}`)
    switch(msg.payload){

        case '04-59-4A-3A-BC-2B-80': return '3ai8NgXP53ehLXGcA839CF'; 
        case '04-5C-4A-3A-BC-2B-80': return '37i9dQZF1DZ06evO0ENBD2'; 
        case '04-FB-7F-72-5D-67-80': return '2uQmaiOrGukfHhZAm15x4K'; 
        case '04-EA-7D-72-5D-67-80': return '1SwyMhnJyMEvpel7ystCEB'; 
        case '04-2C-C9-6A-28-73-81': return '0lWFpTETkmMBmy5xt1Ujtv'; 
        case '04-20-C9-6A-28-73-81': return '7fxPnuKXtJ3STCfWcqTLup'; 
        case '04-5B-4A-3A-BC-2B-80': return '2P5BwSSmpZUgOBLLuSbZzB'; 
        default: 
            node.warn(`Missing minilo ID ${msg.payload}`)
            return null 

    }

}
const playlist = translate(msg.payload)
msg.payload = playlist
return msg;

Then our self-hosted MusicAssistant instance gets called to play the Spotify album in our Google Speaker (both have been previously configured there as providers [1][2]).

It works just the same from an end user perspective, but updating the mapping to add new minilos is now easier, and it integrates seamlessly with other automations (eg, stop the music when we leave home).

Form factor

The original wooden box was not very elegant, but the mini-vinyl coasters came with an equally cute holder base in the shape of a record player. The ESP32 board was small enough the fit underneath, so we did just that, and now it serves as the device case.

To craft the minilos themselves, we just conceal the NFC tag underneath a sticker that serves as the record label. We use a GIMP template to adapt the label image to the correct size for the minilo stickers, and then we print it into glossy sticker paper. Then we print it on glossy sticker paper, concealing the NFC tag under the label.

Each minilo needs a dummy read first, to obtain the NFC id, and then we need to update the mapping function in Node-RED for it to trigger the right music the next time it’s played.

Future

This setup works well for us, since it’s neatly integrated with our home system, but is not easily replicable, and it has too many moving parts. So we would like to rework this project to turn it into a standalone device, without the need of a Google Speaker, Spotify, or domotics - stay tuned!

If you enjoyed this post, you’ll also appreciate its cousin project: the NFC floppy disk game launcher.