2021-01-28 01:50:38 +01:00
[//]: # (title: Build your multi-room and multi-provider sound server with Platypush, Mopidy and Snapcast)
[//]: # (description: How to leverage Platypush and other open-source projects to build an extensible and versatile music server.)
[//]: # (image: /img/mpd-1.png)
[//]: # (published: 2019-10-22)
Today’
wherever you like, but there’ ’
industry yet.
Spotify allows you to find and discover a lot of tunes, but not all the music is there.
You may want to integrate your collection of mp3s into your Spotify collection, but that is simply not an option.
You may have favourite tracks that are only available on SoundCloud or albums that aren’
you’ ’
solution comes with its separate app.
You may want to integrate your favourite online radios or podcasts into your music app, but that’
— TuneIn, Podcast Addict or Google Podcasts are distinct apps.
You may want to easily stream your playlists to any speaker or pair of headphones you own, but that’
sounds. You may have to replace your existing speakers with expensive solutions (like Sonos or Bose) to enjoy a proper
multi-room setup. Apps like Spotify come with their solutions (e.g. Spotify Connect), but only a limited number of
devices is supported and, again, it works as a solution only as long as you stream Spotify content from the Spotify app.
There have been commercial solutions that have tried to tackle this fragmentation problem and provide you with the
possibility to stream music from any app to any speaker without having to replace your audio system, but the situation
isn’
has [discontinued its Chromecast Audio support ](https://www.theverge.com/2019/1/11/18178751/google-chromecast-audio-discontinued-sale ),
and AirPlay works relatively well only as long as you’
As of today the problem “how do I play whichever piece of music I like, from whichever service I like, on whichever
device I like, all in one interface, without having to install 10 different apps” is still largely unsolved if you rely
on commercial solutions.
Luckily, we’
downloading an app and logging in, but the rewards are priceless.
## One music server to rule them all
[Mopidy ](https://mopidy.com/ ) is one of the best open source solutions around when it comes to integrating multiple
music services under one single interface. It’ ’
with [MPD ](https://www.musicpd.org/doc/html/protocol.html ), a music protocol that has been around since 2003 and comes
with lots of compatible clients (command-line, web-based, mobile apps etc.), and there are countless plugins that let
Mopidy integrate with any kind of music service around.
It’
- Add the mopidy repository to your apt lists and install the base package:
```shell
wget -q -O - https://apt.mopidy.com/mopidy.gpg | sudo apt-key add -
# Run the following if you're running Raspbian/Debian Buster
sudo wget -q -O /etc/apt/sources.list.d/mopidy.list https://apt.mopidy.com/buster.list
# Run the following command if you're running Raspbian/Debian Stretch
sudo wget -q -O /etc/apt/sources.list.d/mopidy.list https://apt.mopidy.com/stretch.list
# Update the repositories and install mopidy
sudo apt-get update
sudo apt-get install mopidy mopidy-mpd
```
- Install any additional extension for the music services you like:
```shell
# Spotify support
sudo apt-get install mopidy-spotify
# Local files support
sudo apt-get install mopidy-local
# Dirble support
sudo apt-get install mopidy-dirble
# Podcast support
sudo apt-get install mopidy-podcast mopidy-podcast-gpodder mopidy-podcast-itunes
# Last.FM scrobbling support
sudo apt-get install mopidy-scrobbler
# Soma.FM support
sudo apt-get install mopidy-somafm
# Soundcloud support
sudo apt-get install mopidy-soundcloud
# TuneIn support
sudo apt-get install mopidy-tunein
# YouTube support
sudo apt-get install mopidy-youtube
```
And there are even more extensions available for Mopidy - you may want to take a look on
[their website ](https://mopidy.com/ext/ ) to get an overview of the compatible services.
Head to the pages of those extensions to find out whether they need some extra dependencies or extra configuration to be
added to your `~/.config/mopidy/mopidy.conf` file.
You may also want to make sure that the HTTP module is enabled in your mopidy configuration, since most of the web
frontends (including Platypush) rely on it to interact with mopidy over websockets:
```yaml
[http]
enabled = true
hostname = 0.0.0.0
port = 6680
```
There is also a wide range of frontend clients available for Mopidy, from command-line MPD clients to full-blown web
clients that do a very good job replicating the UI of some of the most popular music apps around. Let's have a quick
overview of my favourite solutions to interact with Mopidy:
- `netcat` /`telnet`. Mopidy is compatible with the MPD protocol, and once started it will listen by default on port 6600
for MPD commands. It’
installing another client (although it’
some scripts):
```shell
$ echo status | nc localhost 6600
OK MPD 0.19.0
volume: 100
repeat: 0
random: 1
single: 0
consume: 0
playlist: 3
playlistlength: 1489
xfade: 0
state: stop
song: 513
songid: 560
nextsong: 173
nextsongid: 220
OK
$ echo currentsong | nc localhost 6600
OK MPD 0.19.0
file: spotify:track:218UgZapIcNRP9f38C5cMp
Time: 365
Artist: 3rd Force
Album: Vital Force
Title: Echoes Of A Dream
Date: 1997
Track: 6
Pos: 513
Id: 560
AlbumArtist: 3rd Force
X-AlbumUri: spotify:album:3mSCVZabNB0rUmpYgPkDuV
OK
$ echo play | nc localhost 6600
OK MPD 0.19.0
OK
$ echo stop | nc localhost 6600
OK MPD 0.19.0
OK
```
- `mpc` is a tiny command-line utility that makes it a bit easier to interact with MPD/mopidy instances for scripting
purposes without handling low-level protocol messages:
```shell
sudo apt-get install mpc
mpc help # To see available commands
mpc play # Play the music
```
- `ncmpcpp` is a ncurses-based terminal client that I've been using for more than a decade, and it's probably one of
the lightest yet most versatile music clients I've seen around - and definitely my favourite:
```shell
sudo apt-get install ncmpcpp
```
- `mopidy-iris` is probably one of the most user-friendly, well-maintained and feature-rich Mopidy clients around, and
it's compatible with desktop, tablet and mobile and it comes with a UI that successfully mimics that of many popular
music apps:
```shell
sudo apt-get install mopidy-iris
```
After installing it head to `http://your-raspberry:6680` and select Iris as the web interface.
And you have many more compatible clients available (just check the list of extensions), from minimal, to feature-rich
(such as MusicBox), to a specific client for party mode optimized for multiple users! And, being compatible with MPD,
all the MPD clients out there should also work out of the box. And the list also includes a *Mopidy Mobile* app and
several MPD apps for Android and iOS.
## Hook Mopidy to Platypush
You can connect Platypush to Mopidy. That provides you with one more UI for interacting with your instance (embedded in
the Platypush web panel), and it opens a world of possibilities when it comes to automating music interactions.
- Install Platypush with the HTTP and MPD dependencies:
```shell
[sudo] pip install 'platypush[http,mpd]'
```
- Enable the MPD/mopidy plugin and backend in your platypush configuration file:
```yaml
music.mpd:
host: localhost
port: 6600
backend.music.mopidy:
host: localhost
```
A `backend.music.mpd` is also provided, but if you use Mopidy instead of a bare MPD server then it's advised to use
`backend.music.mopidy` instead - the former checks for updates by polling the server at regular intervals, while the
Mopidy-specific backend listens for events continuously over the provided websocket interface.
- Restart Platypush and head to `http://your-raspberry:8008` . You should see a new tab for Mopidy — yet another web
interface to interact with the server.
Before proceeding on how to automate the interaction with your new music server, let's see how to turn Mopidy into a
full multi-room music server with Snapcast.
## Multi-room setup
The ability to synchronize music across multiple rooms and devices is a great feature of a modern smart home. However,
most of the commercial solutions available today (like Sonos or Bose) are expensive and require in most of the cases to
replace your speakers with theirs. Luckily it’
RaspberryPis, without having to change your speakers. Let’
- Install Snapcast by following the instructions on their [Github page ](https://github.com/badaix/snapcast )
- Create an `/etc/default/snapserver` file on the machine(s) where you’
following content:
```yaml
USER_OPTS="--user snapserver:snapserver --stream=pipe:///tmp/snapfifo?name=mopidy& codec=pcm --codec=pcm"
SNAPSERVER_OPTS=""
```
In the example above we’ ’ `/tmp/snapfifo` as a
file queue where Mopidy will push its audio stream.
- Start snapserver on your Mopidy machine(s) by simply running the executable, and optionally add it to your startup
configuration.
- Configure the [audio] section of your mopidy.conf file to stream to the Snapcast FIFO (note: with this configuration
Mopidy will only stream to the new file and not to your speakers, you'll need to run `snapclient` to play the audio):
```yaml
[audio]
mixer = software
mixer_volume = 100
output = audioconvert ! audio/x-raw,rate=48000,channels=2,format=S16LE ! wavenc ! filesink location=/tmp/snapfifo
```
The `audio.output` setting of Mopidy is actually a very flexible way of building GStreamer pipelines to redirect and
transform the audio however you like. In this example I'm transforming the audio to stereo WAV at 48 kHz, which may be
perfect if you're seeking for a true loseless audio experience, but may cause some glitches if your network isn't very
stable (we're basically passing uncompressed audio around). It's possible to encode and compress the stream by applying
e.g. an MP3 or OGG encoder to the pipeline, but this causes the GStreamer pipeline to become very unstable for some
reason (the bug has been opened for a couple of years and Mopidy developers are still scratching their head on why it
happens), so the loseless stream option may be the only one that works for now.
- Create an `/etc/default/snapclient` file on all the machines that will be connecting to your Snapserver, included the
Mopidy machine itself if you want to directly play music from too (opposed to using it just as a music backend):
```yaml
START_SNAPCLIENT=true
USER_OPTS="--user snapclient:audio"
```
- Start `snapclient` on the machines that will be connecting to your Mopidy instance. The command will
be `snapclient -h localhost` on the machine that runs mopidy itself and `snapclient -h remote-host-ip-or-name` on the
other machines. You can run as many `snapclient` instances on a host as the servers you want to connect it to.
- Enable the Snapcast backend and plugin in the Platypush configuration of each of the machines that will be running the
client or the server:
```yaml
backend.music.snapcast:
hosts:
- server1
- server2
- server3
music.snapcast:
host: default-server-ip-or-name
```
- Restart Platypush and head to the web panel on port 8008. You should see a new tab for Snapcast, identified by the
speaker icon. From here you can control which stream will be playing on which host, you can create streaming groups,
change the volume etc.
- You can also install an [Android app ](https://play.google.com/store/apps/details?id=de.badaix.snapcast ) to control
your multi-room setup, even though the app allows you to control one server at the time. The app however will allow
you to play audio streams also on your smartphone.
If you use Iris as a web interface to Mopidy you can now head to settings and enable the Snapcast plugin. A speaker icon
will appear in the bottom bar, and you’
Time to enjoy your low-cost but powerful multi-room music setup!
2021-01-28 20:59:57 +01:00
## Build your remote to control the music
All of us have some unused infrared remote collecting dust somewhere in the living room. In this section I’
to turn it into a universal remote for controlling your music (and not only) with some Platypush automation. You’
the following:
- An infrared receiver — they’
used [this model ](https://www.banggood.in/Universal-IR-Infrared-Receiver-Head-With-Iron-Shell-TL1838-VS1838B-1838-38Khz-p-1204379.html?p=1L111111347088201706 ).
- An Arduino or Arduino-compatible device (or an ESP8266, or a RaspberryPi Pico, or any other microcontroller, although
the code may be different). Most of the infrared sensors around communicate over an analog interface, but
the RaspberryPi doesn’
changes on the detected infrared signal.
- A breadboard.
Once you’
- Plug the infrared receiver to GND and Vcc, and the data PIN to e.g. the Arduino PIN 2, as shown in the figure below:
- Download and install the Arduino [IRremote library ](https://github.com/z3t0/Arduino-IRremote ).
- Prepare a sketch that reads the data from the infrared receiver PIN and writes it over serial interface as a JSON:
```c
#include <IRremote.h>
// When a signal with all bits set to 1 is received it
// usually means that the previous pressed key is still
// being pressed, until a signal with all bits set to
// zero is received.
#define IR_REPEAT 0xFFFFFFFF
const int RECV_PIN = 2;
IRrecv irrecv(RECV_PIN);
decode_results results;
unsigned int latest_value = 0;
void setup(){
Serial.begin(9600);
irrecv.enableIRIn();
irrecv.blink13(true);
}
void send_value(unsigned int value) {
Serial.print("{\"ir\":");
Serial.print(value, HEX);
Serial.println("}");
}
void loop(){
if (irrecv.decode(& results)){
if (results.value == IR_REPEAT & & latest_value != 0) {
send_value(latest_value);
} else if (results.value & & results.value != latest_value) {
send_value(results.value);
}
latest_value = results.value;
irrecv.resume();
}
}
```
- Compile the sketch and upload it to the Arduino.
- Open the Arduino serial monitor and verify that you see the JSON string when you press a key on the remote.
- Enable the serial plugin and backend in your platypush configuration:
```yaml
serial:
device: /dev/ttyUSB0
backend.sensor.serial:
enabled: True
```
- Restart platypush, check the output and press a key on your remote. You should see an event in the logs that looks
like this:
```
INFO|platypush|Received event: {"type": "event", "target": "hostname", "origin": "hostname", "args": {"type": "platypush.message.event.sensor.SensorDataChangeEvent", "data": {"ir": "4b34d827"}}}
```
- Take note of the hexadecimal code reported on the event, that’
button. Then add an event hook to deal with the actions to be run when a certain button is pressed:
```python
from platypush.config import Config
from platypush.event.hook import hook
from platypush.utils import run
from platypush.message.event.sensor import SensorDataChangeEvent
@hook (SensorDataChangeEvent)
def on_remote_key_press(event, **context):
ir_code = event.data.get('ir')
if not ir_code:
return
# Playback control logic
if ir_code == 'code1':
run('music.mpd.play')
elif ir_code == 'code2':
run('music.mpd.pause')
elif ir_code == 'code3':
run('music.mpd.stop')
elif ir_code == 'code5':
run('music.mpd.previous')
elif ir_code == 'code6':
run('music.mpd.next')
# ...
# Multi-room setup logic
elif ir_code == 'code7':
# Un-mute the stream to another host
run('music.snapcast.mute', host=Config.get('device_id'), client='some-client',
mute=False)
elif ir_code == 'code8':
# Mute the stream to another host
run('music.snapcast.mute', host=Config.get('device_id'), client='some-client',
mute=True)
```
Congratulations, you’
## Voice assistant integration
A smart music setup isn’ ’
[in a previous article ](https://blog.platypush.tech/article/Build-your-customizable-voice-assistant-with-Platypush ) how
to set up platypush to turn your device into a full-featured Google Assistant. If you’
assistant up and running, you can add some rules to control your music, play specific content, or synchronize your audio
stream to another room. Let’
```python
from platypush.config import Config
from platypush.event.hook import hook
from platypush.utils import run
from platypush.message.event.assistant import SpeechRecognizedEvent
@hook (SpeechRecognizedEvent, phrase='play (the)? music')
def on_music_play(*args, **context):
run('music.mpd.play')
@hook (SpeechRecognizedEvent, phrase='stop (the)? music')
def on_music_pause(*args, **context):
run('music.mpd.stop')
@hook (SpeechRecognizedEvent, phrase='play (the)? radio')
def on_play_radio(*args, **context):
run('music.mpd.play', resource='tunein:station:s13606')
@hook (SpeechRecognizedEvent, phrase='play playlist ${name}')
def on_play_playlist(event, name=None, **context):
run('music.mpd.load', resource=name)
@hook (SpeechRecognizedEvent, phrase='play ${title} by ${artist}')
def search_and_play_song(event, title=None, artist=None, **context):
results = run('music.mpd.search', artist=artist, title=title)
if results > 0:
run('music.mpd.play', resource=results[0]['file'])
@hook (SpeechRecognizedEvent, phrase='play (the)? music to (the)? bedroom')
def sync_music_to_bedroom(event, **context):
run('music.snapcast.mute', host=Config.get('device_id'), client='bedroom', mute=False)
run('music.snapcast.volume', host=Config.get('device_id'), client='bedroom', volume=90)
```
## Conclusions
The current situation when it comes to music streaming and multi-room setup in a home automation environment is still
extremely fragmented. Each commercial solution out there seems more interested in building its own walled garden, and a
proper multi-room setup usually comes with high costs and in most of the cases it won’
speakers. With the ingredients provided in this article you should be able to walk around most of these limitations and:
- Set up your multi-service music player controllable by any interface you like
- Set up your multi-room configuration that makes it possible to add a new room by simply adding one more RaspberryPi
- Use any existing infrared remote to control the music
- Integrate custom music actions into a voice assistant
With these foundations in place the only limit to what you can do with your new music set up comes from your own
imagination!
