Heimkino im Smart Home mit Plex und Alexa

Träumst du nicht manchmal auch von der großen Leinwand im eigenen Zuhause? Popcorn zum Film oder automatisch dimmenden Lichtern, sobald es losgeht?

Den meisten fehlt jedoch die zündende Idee oder die Technik, damit man sich selbst ein eigenes Heimkino aufbauen kann.

Damit soll nun Schluss sein! Denn es geht auch ohne sich teure Technik vom Profi einbauen zu lassen oder die neuesten Geräte am Markt zu erwerben.

In diesem Artikel stelle ich dir mein Projekt Heimkino im Smart Home vor, in dem ich unterschiedliche Smart Home Geräte so miteinander verknüpfe, dass ich meinen Kinomodus automatisch starten lassen kann, sobald Alexa das Kommando von mir bekommt. Dabei greife ich unter anderem auf unterschiedliche Inhalte zurück, die ich bereits hier im Blog als Thema behandelt habe.

Zu diesen Themen gehören:

• Harmony Hub von Logitech – empfehlenswert?
• Plex Media Server im Heimnetzwerk zum Streaming
• Amazon Echo Control Beta für OpenHAB

Um dem Beitrag folgen zu können, musst du selbstverständlich nicht unbedingt alle Beiträge gelesen haben. Wenn du allerdings genauere Informationen zu einem Part brauchst, dann empfehle ich dir, diese Inhalte zuerst zu lesen.

Für das automatische Dimmen der Lichter per Webhook von Plex ist übrigens ein Plex Pass erforderlich. Das schon mal vorab.

Wie soll das Ganze ablaufen?

Meine Vorstellung eines Heimkino im Smart Home ist sehr simpel. Ich möchte per Sprachbefehl sämtliche Geräte einschalten und die Leinwand * herunterfahren. Ebenfalls soll der Beamer * auf den richtigen Eingang wechseln, damit das Erlebnis gleich losgehen kann.

Nur leider fehlt mit dazu der Beamer sowie eine Leinwand.

Schade!

Damit ich dennoch einen Kinomodus umsetzen kann, greife ich auf den Fernseher zurück, der möglicherweise eines Tages durch einen Beamer ergänzt oder gar ersetzt wird. In meinem Szenario geht also der Fernseher an, gefolgt von der Stereoanlage. Meine Inhalte rufe ich über den Fire TV Stick ab, der hierzu direkt am Fernseher angeschlossen ist.

Neben den wichtigen Geräten, sollen auch die Lichter entsprechend angesteuert werden können. Diese sind über den Amazon Echo * mit meinem Smart Home verbunden und können über OpenHAB kontrolliert werden.

Zu guter letzt empfand ich es noch als angenehm, wenn Alexa mir zu Beginn eines Films den Titel nennt. Sollte so einmal ein zufälliger Film abgespielt werden und man die Schrift auf die Distanz nicht erkennen, so weiß man dennoch um welchen Film es sich handelt. Natürlich muss man diese Funktion nicht integrieren. Für mich war es in erster Linie auch eine Spielerei, die jedoch schlussendlich bleiben durfte.

Die Funktionsweise des Heimkinos

Die Funktionsweise meines Projekts Heimkino mit Smart Home lässt sich ziemlich simpel in Worte fassen.

Ich starte per Sprachbefehl den Kinomodus, welcher in OpenHAB eine Regel auslöst. Diese Regel meldet an die FritzBox *, dass sie die jeweiligen Steckdosen einschalten soll. Im Anschluss daran wird dem Harmony Hub mitgeteilt, er soll die Geräte einschalten, welche Geräte mit Strom versorgt wurden. Auch die Lautstärke wird über den Harmony Hub * eingestellt.

Rufe ich nun über den Plex Media Server ein Video (Film oder Serie) ab, so wird automatisch das Licht gedimmt. Der Plex Media Server teilt per sogenannten Webhooks OpenHAB mit, dass sich der Zustand des Players geändert hat. Ebenso wird OpenHAB mitgeteilt, welcher Film gespielt wird und welches Cover zu diesem Film gehört.

Dabei kann OpenHAB selbst nicht einfach mit Webhooks umgehen. Ein Webhook ist eine Nachricht an einen bestimmten Endpunkt. Dennoch lassen sich Webhooks integrieren, indem man diese in MQTT übersetzt. OpenHAB selbst besitzt die Fähigkeit, über MQTT Nachrichten auszutauschen oder gar als sogenannter Broker zu arbeiten. Ein Broker ist dabei quasi der Server, über welchen alle Nachrichten ausgetauscht werden.

Um nun einen Webhook in MQTT zu übersetzen, habe ich mir ein Skript geschrieben, das ich auf dem gleichen Rechner ausführen kann, auf dem bereits OpenHAB läuft.

So kann ich schlussendlich mit dem Amazon Echo Control Binding den Namen des Films ausgeben lassen, da dieser OpenHAB über Webhooks und MQTT mitgeteilt wurde. Da auch ein Link zum Cover des Films enthalten ist, kann ich dieses Bild in die Sitemap integrieren.

Wie wird aus dem Webhook MQTT?

Das Prinzip ist ganz einfach. Es wird im Hintergrund ein Python-Skript ausgeführt, welches eine Schnittstelle besitzt. Innerhalb von Plex lassen sich nun Webhooks konfigurieren, die an diese eine Schnittstelle gesendet werden. Innerhalb des Skripts werden nun die Daten ausgelesen, die an OpenHAB weitergeleitet werden sollen. Aktuell handelt es sich dabei um die Ereignisse Typ, Titel, Thumbnail sowie das Event.

Plex liefert diese Daten als JSON, wodurch auf einfache Weise die Daten extrahiert und weitergeschickt werden können. Damit die Kommunikation eindeutig ist und die Geräte nicht verwechselt werden, wird für jedes Gerät ein Topic angelegt. Der Name des Topics entspricht dabei der ID des Players, welcher durch Plex selbst vergeben wird.

Was braucht man in OpenHAB?

In OpenHAB selbst wird das Amazon Echo Control Binding benötigt, welches die Steuerung der Lampen erlaubt. Dabei handelt es sich aktuell um eine Beta-Version, welche hoffentlich so schnell wie möglich standardmäßig in OpenHAB verfügbar sein wird. Bis dahin musst du es dir allerdings händisch herunterladen und in den Ordner Addons legen.

Den Downloadlink für dieses Binding findest du im Beitrag Amazon Echo Control Beta für OpenHAB. Sollte sich der Downloadlink einmal ändern, werde ich ihn dort entsprechend anpassen.

Weiterhin musst du innerhalb von deinem OpenHAB MQTT einrichten. Dazu benötigst du den Embedded System Broker sowie das MQTT Binding. Dieses musst du natürlich zuerst konfigurieren.

Danach musst du unterschiedliche Items für deine Topics anlegen. In diesen Items wird später der Wert der MQTT-Nachricht gespeichert und kann in OpenHAB genutzt werden.

MQTT-Things

mqtt:broker:myBroker [ host="127.0.0.1", secure=false ]

Bridge mqtt:broker:myBroker [ host="127.0.0.1", secure=false ]
{
    Thing mqtt:topic:mything {
    Channels:
        Type string : plex_wz "Plex Wohnzimmer" [ stateTopic="plex/[clientIdentifier]", commandTopic="plex/[clientIdentifier]" ]
        Type string : plex_wz_title "Plex WZ Title" [ stateTopic="plex/[clientIdentifier]/title", commandTopic="plex/[clientIdentifier]/title" ]
        Type string : plex_wz_type "Plex WZ Type" [ stateTopic="plex/[clientIdentifier]/type", commandTopic="plex/[clientIdentifier]/type" ]
        Type string : plex_wz_image "Plex WZ Image" [ stateTopic="plex/[clientIdentifier]/thumb", commandTopic="plex/[clientIdentifier]/thumb" ]
    }
}

Hier gilt zu beachten, dass der obere Teil eine eigenständige Things-Datei ist. Hier wird der MQTT-Broker definiert. Selbstverständlich kannst du das auch bequem über die PaperUI erledigen. Ich bevorzuge allerdings die Textdateien.

Im zweiten Teil definierst du die unterschiedlichen Channels. Dabei agiert das Thing mything als Verknüpfung zwischen MQTT und OpenHAB. Denn Things bilden quasi externe Geräte ab.

Um die ID deines Players herauszufinden, navigierst du zu plex.tv und loggst dich mit deinen Daten dort an. Du musst zuvor natürlich die App bereits auf dem gewünschten Gerät installiert und eingerichtet haben. Danach rufst du die folgende Adresse auf https://plex.tv/devices.xml

Hier findest du eine Datei, die all deine Geräte enthält. Du musst dir nun das passende Gerät heraussuchen und den Wert clientIdentifier in OpenHAB kopieren.

Bitte ersetze mit diesem Wert [clientIdentifier].

Items

Die Items sind sehr schnell definiert und einsatzbereit. Es genügen folgende Angaben

Switch Kinomodus "Kinomodus"

String Plex_Playstation_State "Status [%s]" { channel="mqtt:topic:mything:plex_wz" }
String Plex_Playstation_Title "Titel [%s]" { channel="mqtt:topic:mything:plex_wz_title" }
String Plex_Playstation_Type "Typ [%s]" { channel="mqtt:topic:mything:plex_wz_type" }
String Plex_Playstation_Image { channel="mqtt:topic:mything:plex_wz_image" }

In meinem Fall sind Plex_Playstation_State und Co. die Namen der Items. Diese kannst du natürlich nach Belieben anpassen.

Der obere Switch ist der eigentliche Kinomodus, welcher auch die automatische Lichtersteuerung ermöglicht. Ist dieser Switch nämlich nicht eingeschaltet, so werden keine Lichter gedimmt. Damit kann ich trotz des Heimkino im Smart Home auch noch „normal“ Filme schauen.

Die Regeln

Kommen wir nun zu den Regeln. Hierbei gibt es vier Stück, die eine in meinen Augen ideale Lösung bieten.

rule "Kinomodus Lichter ein"
when
    Item Plex_Playstation_State changed
then
    if (Kinomodus.state == ON && (Plex_Playstation_State.state == "media.stop" || Plex_Playstation_State.state == "media.pause")) {
        Wohnzimmer_Light_Brightness.sendCommand(50)
    }
end

rule "Kinomodus Lichter aus"
when
    Item Plex_Playstation_State changed
then
    if (Kinomodus.state == ON) {
        if (Plex_Playstation_State.state == "media.play" || Plex_Playstation_State.state == "media.resume") {
            Wohnzimmer_Light_Switch.sendCommand(OFF)
        }
    }
end

rule "Alexa Ankündigung Beginn"
when
    Item Plex_Playstation_Title changed
then
    if (Kinomodus.state == ON) {
        if (Plex_Playstation_State.state == "media.play") {
            Echo_WZ_TTS.sendCommand("Jetzt beginnt " + Plex_Playstation_Title.state)
        }
    }
end

rule "Alexa Ankündigung nach Pause"
when
    Item Plex_Playstation_State changed
then
    if (Kinomodus.state == ON) {
        if (Plex_Playstation_State.state == "media.resume") {
            Echo_WZ_TTS.sendCommand("Die Wiedergabe wird fortgesetzt.")
        }
    }
end

Die ersten beiden Regeln dimmen die Lichter bei Beginn und einer Pause bzw. dem Ende des Films.

Die anderen beiden Regeln sorgen für die Sprachausgabe über Alexa. Wer keine Sprachausgabe wünscht oder gar keinen Echo in seinem Besitz hat, der kann diese beiden Regeln einfach weglassen oder durch seine eigene Sprachausgabe ersetzen. Möglich wäre auch, dass man eine Push Notification bekommt, doch das empfand ich als nicht ideal.

Das MQTT-Skript

Bevor ich zum MQTT-Skript komme möchte ich anmerken, dass dieses vollständig auf GitHub verfügbar ist. Du kannst dort jederzeit Updates einsehen und dein bestehendes Skript erweitern oder ersetzen.

Das Skript hier im Blog werde ich vermutlich nur unregelmäßig updaten können. Schau also unbedingt hier auf GitHub vorbei und hole dir das Skript von dort!

Wichtig ist auch, dass du dir die Pakete installierst, die das Skript benötigt. Python sollte auf Linux-Systemen bereits verfügbar sein. Solltest du Windows verwenden, musst du Python manuell installieren.

Zu installierende Pakete sind:

• Flask
• jsonify
• request
• Resource
• api
• json5
• requests
• paho-mqtt

Alle Pakete installierst du dir mit pip install [Paketname]. Ersetzte dabei die eckigen Klammern und den Text darin mit dem jeweiligen Namen des Pakets aus der Liste.

Da ich noch relativ neu in der Entwicklung von Python-Skripten bin, gibt es sicherlich noch Optimierungsbedarf. Wer Lust hat dieses Skript weiterzuentwickeln, kann das gerne jederzeit tun und mir einen Pull Request zukommen lassen. Ich würde mich sehr freuen!

Das Python Skript sieht wie folgt aus:

from flask import Flask, jsonify, request
from flask_restful import Resource, Api
import requests
import json
import paho.mqtt.publish as publish

app = Flask(__name__)
api = Api(app)

host = 'HOST_OF_MQTT'
plexHost = 'HOST_OF_PLEX'
topic = 'plex/'

@app.route('/webhook', methods=['POST'])
def webhook():
    data = json.loads(request.form['payload'])
    print(data['event'])
    publish.single(topic + data['Player']['uuid'], data['event'], hostname=host)
    publish.single(topic + data['Player']['uuid'] + '/title', data['Metadata']['title'],
                   hostname=host)
    publish.single(topic + data['Player']['uuid'] + '/type', data['Metadata']['type'],
                   hostname=host)
    publish.single(topic + data['Player']['uuid'] + '/thumb', 'http://' + plexHost + data['Metadata']['thumb'],
                   hostname=host)
    return 'OK'

if __name__ == '__main__':
    app.run(host='0.0.0.0', port=5000, debug=False)

Ersetze hier bitte zu Beginn des Skripts die Werte von host und plexHost.

Anmerkung zu den Thumbnails

Die Thumbnails können normalerweise nicht einfach von einem Gerät abgerufen werden, da Plex eine Authentifizierung verlangt. Du kannst allerdings jene Geräte von der Authentifizierung ausnehmen, die per Basic UI oder HabPanel die Bilder abrufen wollen. Diese Einstellung kannst du in Plex unter dem Punkt Netzwerk bearbeiten. Ich habe dort beispielsweise mein Smartphone und Tablet sowie meinen PC hinterlegt. Diese Geräte können nun einfach ohne sich anzumelden die Bilder abrufen und in der Basic UI bzw. der OpenHAB App anzeigen.

Weitere Informationen

Ich habe bewusst in meiner Regel außen vor gelassen, wo die Geräte eingeschaltet werden. Hier ist die eingesetzte Technologie bei vielen Menschen so unterschiedlich, dass es sich nicht lohnt, diese hier aufzunehmen. Du müsstest in deinem Fall sowieso sehr viel anpassen.

Dennoch hast du mit all diesen Informationen nun eine wichtige Grundlage, denn du kannst darauf aufbauend deine Gerätesteuerung integrieren und dein eigenes Heimkino aufbauen.

Schreibe dir also einfach eine weitere Regel, die deine Geräte einschaltet und dein Heimkino im Smart Home ist in Windeseile fertig.

Wenn du dir nicht sicher bist, wie du deine Geräte am besten integrierst, dann wirst du hier im Blog fündig. Stöbere ein wenig nach Informationen und du wirst sehen, vieles habe ich bereits erklärt.

Was meinst du zur Heimkino-Funktion? Ist das eine tolle Spielerei oder doch eher unnütz? Hinterlasse deine Meinung unten in den Kommentaren!

(Titel-) Foto von Felix Mooneeram auf Unsplash