Bildschirmsteuerung mit ioBroker und Raspberry Pi

ioBroker erlaubt durch seine VIS die Erstellung von individuellen Oberflächen für das Smart Home. Diese Oberflächen lassen sich zu Hause auf einem Bildschirm anzeigen, der für gewöhnlich eingeschaltet ist. Doch man möchte nicht immer, dass der Bildschirm eingeschaltet bleibt. In diesem Beitrag möchte ich mich daher der Bildschirmsteuerung mit ioBroker und dem Raspberry Pi widmen.

Konkret wünsche ich mir eine Steuerung, die den Bildschirm bei Betreten des Raums einschaltet und beim Verlassen wieder ausschaltet. Als besonderes Extra möchte ich, dass ich per VIS die Oberfläche tauschen kann, die am Raspberry Pi angezeigt wird.

Damit du besser verstehst wovon ich spreche, möchte ich dir gleich meine Ausgangssituation genauer beschreiben. Auf Basis dieser Ausgangssituation werde ich dir in diesem Beitrag erklären, wie wir mein Vorhaben umsetzen können.

Diese Hardware brauchst du

Damit du die Steuerung genauso umsetzen kannst, wie ich es bereits getan habe, benötigst du ein paar Dinge. Doch keine Sorge, man kann sie leicht online auftreiben.

Zuerst benötigst du einen Raspberry Pi. Dieser stellt die Brücke zwischen unserem Smart Home und dem Bildschirm da. Er erhält ein Linux, das wir später mittels ioBroker fernsteuern können.

Weiterhin brauchst du einen Monitor, der per HDMI an den Raspberry Pi angeschlossen wird. Er zeigt dir später die entsprechende Oberfläche an, die zu anzeigen möchtest.

Ebenso brauchen wir einen Homematic IP Durchgangssensor. Er soll später erkennen, ob sich eine (oder mehrere) Person(en) im Raum aufhält/aufhalten. Selbstverständlich kannst du auch auf eine andere Technologie setzen, die dir eine Anwesenheit im Raum verrät. Denkbar ist zum Beispiel, dass du bei Betreten des Raums einen Knopf drückst.

Was ich in diesem Beitrag schon voraussetzen werde, ist eine Installation von ioBroker. Sie muss nicht auf dem Raspberry Pi installiert werden, sondern kann auf einem beliebigen anderen Gerät betrieben werden. Ich nutze hierfür beispielsweise einen eigenen Server. Ich setze außerdem voraus, dass du den Raspberry Pi für den Monitor schon mit Linux ausgestattet hast. Hierzu gibt es bereits diverse Anleitungen im Internet.

jetzt 9% günstiger

Raspberry Pi 4 Modell B; 4 GB, ARM-Cortex-A72 4 x,...

Jetzt shoppen * Preis inkl. MwSt., zzgl. Versandkosten

DELL P2719H 68,6 cm (27 Zoll) Monitor (VGA, HDMI,...

Jetzt shoppen * Preis inkl. MwSt., zzgl. Versandkosten

Homematic IP Smart Home Durchgangssensor mit...

Jetzt shoppen * Preis inkl. MwSt., zzgl. Versandkosten

Zuletzt aktualisiert 2024-11-17 / (*) Affiliate Links / (**) Affiliate Links, Preis kann abweichen (andere Plattform) / Bilder von der Amazon Product Advertising API / Der angegebene Preis kann seit der letzten Aktualisierung gestiegen sein.

Alle drei dieser Komponenten habe ich selbst im Einsatz. Lediglich an meinem Raspberry Pi nutze ich noch einen uralten Monitor. Den abgebildeten Monitor habe ich allerdings an meinem Schreibtisch im Einsatz.

Meine Ausgangssituation knapp erklärt

Ich habe in meinem Arbeitszimmer einen Monitor, der an meinen Raspberry Pi 4 angeschlossen ist. Er zeigt meine VIS, die ich speziell für diesen Monitor zusammengestellt habe. Neben einem Live-Bild enthält der Bildschirm noch Informationen zur Wetterstation und meinem Stromverbrauch.

Am Türrahmen ist der Durchgangssensor befestigt, der mir in ioBroker bereits auswertet, wie viele Personen im Raum sind. Auf Basis dieser Information wird bei mir das Licht gesteuert, sobald es im Außenbereich entsprechend dunkel wird.

Diese Funktion wollte ich erweitern, so dass der Bildschirm automatisch ausgeschaltet wird, wenn die letzte Person den Raum verlässt. Ebenso soll der Bildschirm wieder eingeschaltet werden, wenn sich mindestens eine Person im Raum aufhält. Die Lichtsteuerung hingegen bleibt auf Basis des Außenbereichs unberührt.

Neben all diesen Funktionen wünsche ich mir, dass ich über die VIS am Tablet eine andere Oberfläche auswählen kann. Wenn ich beispielsweise Besuch habe, möchte ich gewisse Elemente gerne ausblenden oder gar ein ganz anderes Bild zeigen. Dazu kommen wir im weiteren Verlauf des Artikels.

SSH im Raspberry Pi aktivieren

Damit wir unseren Pi fernsteuern können, müssen wir die SSH-Verbindung erlauben. Damit wird von deinem ioBroker eine Verbindung zum Pi aufgebaut, um Befehle ausführen zu können. Die SSH-Verbindung kannst du außerdem nutzen, um dich von deinem Computer zu verbinden. Unter Windows genügt dafür sie Powershell. Alternativ kannst du aber auch eine Zusatzsoftware, wie beispielsweise PuTTy, verwenden.

Um SSH zu aktivieren verwende ich den VNC-Viewer. Du kannst aber natürlich auch direkt an deinem Pi die Einstellung vornehmen. Einen Monitor musst du ohnehin angeschlossen haben. Vorübergehend kann daher eine Maus und Tastatur auch nicht schaden.

Klicke auf das Icon oben links, um das Menü aufzurufen. Navigiere zu den Einstellungen und klicke auf Raspberry-Pi-Konfiguration. In diesem Fenster wechselst du zum Tab Schnittstellen und aktivierst SSH. Klicke danach auf OK, um deine vorgenommene Einstellung zu speichern. Sobald das passiert ist, kannst du dich per SSH mit deinem Raspberry Pi verbinden und wir können mit der Einrichtung von ioBroker fortfahren.

Adapterinstallation in ioBroker

Damit wir den Raspberry Pi fernsteuern können, brauchen wir in ioBroker einen Adapter. Er stellt die Brücke zwischen dem Smart Home und dem Raspberry dar. Dieser Adapter ist dann in der Lage, Befehle auf dem Pi auszuführen, die wir zum Beispiel in einer Regel definieren.

Suche in deiner ioBroker-Installation nach dem Adapter Linux Control und füge ihn hinzu.

Du wirst dann auf die Adapterkonfiguration weitergeleitet, in der du einige Werte und Daten eingeben musst. Andernfalls kann die Verbindung leider nicht hergestellt werden. Folgende Werte musst du konfigurieren:

Alle anderen Werte musst du in der Adapterkonfiguration nicht bearbeiten. Auch in keinem anderen Tab. Du kannst nun auf Speichern und Schließen klicken, wenn du die in der Tabelle aufgeführten Werte eingegeben hast.

Sobald du deine Einstellungen gespeichert hast und eine Verbindung hergestellt wurde, wirst du in den Objekten neue Einträge finden. Die Datenpunkte, die wir für die Steuerung benötigen, befinden sich im Ordner command und nennen sich command, execute und host. Doch dazu kommen wir gleich, wenn wir zu den Skripten übergehen.

Wie steuert man den Bildschirm am Pi?

Für den Raspberry Pi gibt es einen Befehl, der den HDMI-Ausgang aktivieren und deaktivieren kann. Sobald man den Ausgang deaktiviert, sollte der Bildschirm in den Standby-Modus gehen. Wir der Ausgang hingegen wieder aktiviert, schaltet sich der Bildschirm automatisch ein. Diesen Mechanismus machen wir uns für dieses Projekt zunutze.

Folgender Befehl schaltet den HDMI-Ausgang ein: vcgencmd display_power 1

Ausschalten kannst du den Ausgang mit: vcgencmd display_power 0

Wenn du diese Befehle über SSH ausführen möchtest, musst du außerdem noch das richtige Display auswählen. Die Auswahl geschieht mit dem Befehl export DISPLAY=:0

Für das Aufrufen einer speziellen VIS-Oberfläche nutzen wir einfach die Parameter, die uns der Chromium-Browser zur Verfügung stellt. Hier kannst du eine Seite beispielsweise mit dem folgenden Befehl aufrufen:

chromium-browser „https://hobbyblogging.de“

Skripte für deinen Bildschirm erstellen

Den Abschnitt über die Skripte werde ich zum besseren Verständnis in mehrere Teile unterteilen. Insgesamt arbeite ich mit 3 Skripten, wobei natürlich die Steuerung für den Durchgangssensor noch oben drauf kommt.

Wir beginnen an dieser Stelle mit der Erstellung eines Skripts für den Durchgangssensor und arbeiten und dann Stück für Stück bis zur Steuerung des Bildschirms vor. An dieser Stelle solltest du den Durchgangssensor bereits mit deinem ioBroker verbunden haben, so dass seine Daten entsprechend zur Verfügung stehen.

Zähler für den Durchgangssensor

Bevor wir mit dem Skript beginnen, erstelle bitte einen Datenpunkt in den Objekten. Klicke dazu auf den Ordner javascript.0 und danach oben unterhalb der blauen Leiste auf das Plus. Nun erstellst du einen Datenpunkt (den Namen darfst du dir aussuchen). Bei Typ gibst du Datenpunkt an, bei Datenpunkttyp wählst du Zahl.

Nun beginnen wir mit der Erstellung des Skripts, damit die Personen in deinem Raum gezählt werden können.

Wir müssen bei unserem Durchgangssensor unterscheiden, in welche Richtung die Bewegung stattfindet. Auf Basis dieser beiden Datenpunkte, können wir dann unseren eben erstellten Datenpunkt mit der genauen Anzahl der Personen befüllen. Daher gibt es in diesem Skript genau zwei Trigger.

Im ersten Fall wird der Datenpunkt AZ_DS_Zähler (der Datenpunkt, den du eben erstellt hast) genommen und die Anzahl 1 abgezogen.

Der zweite Fall hingegen rechnet die Anzahl 1 auf den Wert drauf.

Der erste Fall bedeutet also, dass eine Person den Raum verlässt, während im zweiten Fall eine Person den Raum betritt.

Die Bildschirmsteuerung erstellen

Bevor wir nun mit der Bildschirmsteuerung fortfahren, musst du einen weiteren Datenpunkt erstellen. Dazu kannst du nach der Anleitung von oben verfahren. Nutze bei diesem Datenpunkt allerdings bitte den Datenpunkttyp Logik. Denn wir wollen an dieser Stelle nur auswerten können, ob der Bildschirm eingeschaltet werden soll (wahr) oder ob er ausgeschaltet werden soll (falsch).

Nun erstellen wir eine Regel. Als Auslöser haben wir den vorher erstellten Datenpunkt, der die Anzahl der Personen im Raum für uns bereit hält. Wir prüfen nun, ob die Anzahl der Personen größer gleich 1 ist oder ob die Anzahl der Personen kleiner 1 ist.

Sofern Personen im Raum sind (Anzahl größer gleich 1), setzen wir die gerade neu erstellte Variable auf wahr. Andernfalls setzen wir sie auf falsch. Auf Basis dieser Information können wir nun ein weiteres Skript erstellen, dass uns nun die Befehle an den Raspberry Pi sendet.

Ich habe mich an dieser Stelle bewusst dafür entschieden eine Variable zu nutzen und die Regel nicht zu komplex zu machen, da ich nun noch andere Automatisierungen einfügen kann, sobald sich jemand im Raum aufhält. Außerdem bleiben die Skripte so übersichtlicher und möglichst klein.

Den Bildschirm steuern

Nun kommen wir zum eigentlichen Kern des Artikels. Wir bauen nun ein Skript, welches unseren Bildschirm ein- und ausschaltet. Dazu erstellen wir ein neues Skript, das wir wie folgt aufbauen werden.

Wir prüfen im Trigger unseres Skripts, ob sich der Zustand des Datenpunkts geändert hat, den wir mit unserer letzten Regel manipulieren.

Sollte der Wert auf wahr gesetzt worden sein, setzen wir den Datenpunkt command (aus den Objekten und dem Ordner linux-control.0 dort im Ordner command deines erstellten Datenpunkts aus der Instanz). Hierzu übergeben wir den Befehl vcgencmd display_power 1. Danach setzen wir den Host. Dazu musst du den Namen deines Pis angeben, wie du ihn in der Instanz des Adapters genannt hast.

Ich habe nun eine kurze Verzögerung eingebaut von genau einer Sekunde. Sobald die Sekunde abgelaufen ist, wird der Wert des Datenpunkts execute auf wahr und zwei Sekunden später wieder auf falsch gesetzt. Danach ist der Pi bereit für den nächsten Befehl, sofern ich noch einen verschicken möchte.

Sollte der Wert unseres Datenpunkts hingegen auf falsch gesetzt werden (also niemand im Raum), versende ich den Befehl mit dem Wert 0. Dadurch wird der Bildschirm ausgeschaltet.

Wenn du Probleme beim Ein- und Ausschalten des Displays hast, musst du eventuell noch das Display auswählen. Hierzu kann dein Befehl dann wie folgt aussehen:

export DISPLAY=:0; vcgencmd display_power 1

Ersetze die 1 durch den Wert 0, wenn du den Bildschirm ausschalten möchtest.

Auswahl der richtigen Oberfläche

Nun möchte ich als besonderes Extra über mein Tablet noch die richtige Oberfläche auswählen können. Wenn der Bildschirm eingeschaltet ist, soll bei Bedarf eine andere VIS angezeigt werden können. Diese Funktion ist relativ einfach umzusetzen und bedarf keiner allzu großen Programmierung des ioBrokers. Das Skript sieht auf den ersten Blick irritierend aus, doch wenn du einmal genau hinschaust wirst du erkennen, dass es gar nicht so kompliziert ist.

Bevor wir allerdings starten, erstellst du wieder einen neuen Datenpunkt (analog zu den Datenpunkten oben) mit dem Datenpunkttyp Zahl. Darin speichern wir, welche Oberfläche später angezeigt werden soll.

Dann gehen wir über zum entsprechenden Skript.

Das Skript zur VIS-Auswahl

Ich zeige dir hier nun einen Ausschnitt eines Skripts. Da ich mehrere Werte hinterlegt habe, ist mein Skript entsprechend lang. Doch schon anhand des Ausschnitts kann ich dir erklären, wie du das für deine Zwecke umsetzen kannst.

Meinen Datenpunkt habe ich Bildschirm_Anzeige genannt. In diesen Datenpunkt trage ich später den Wert ein, je nachdem welche Oberfläche anzeigt werden soll. Sobald dieser Datenpunkt geändert wird, reagiert der Trigger des Skripts und die Regel wird ausgeführt.

Zuerst steuere ich das command mit dem Wert pkill -o chromium. Damit werden alle aktiven Chromium-Fenster beendet und ich öffne nicht unzählige Fenster. Danach wähle ich wieder meinen Host aus, auf dem der Befehl ausgeführt werden soll. Ich stelle nun wieder einen Timer, der genau eine Sekunde abwartet. Danach wird der Befehl ausgeführt.

Nun prüfe ich, welchen Wert mein Datenpunkt enthält. Dazu erstelle ich eine Bedingung, die mir den Wert entsprechend prüft. Für jede Oberfläche, die du anzeigen möchtest, brauchst du eine eigene Bedingung.

Wenn der Wert des Datenpunkts auf 0 gesetzt ist, stelle ich wieder einen Timer. Danach setze ich den Befehl. Die URL bekommst du, wenn du mit deinem Computer auf die VIS zugreifst. Der vollständige Befehl, den du einsetzen musst, sieht wie folgt aus:

export DISPLAY=:0; chromium-browser „https://hobbyblogging.de“ –start-fullscreen &

Ersetze die URL dabei bitte mit der URL deiner VIS, wie eben angemerkt. Wenn du keinen Vollbildmodus möchtest, kannst du den Parameter –start-fullscreen einfach weglassen. Das &-Zeichen am Ende muss auf jeden Fall erhalten bleiben, da der Prozess (Chromium) damit im Hintergrund gestartet wird und der Browser sich nicht schließt, wenn die SSH-Verbindung zum Raspberry Pi unterbrochen wird (sehr wichtig!).

Nun wird wieder der richtige Host ausgewählt, ein Timer gestellt und schlussendlich das execute auf wahr gesetzt.

Außerhalb der Bedingung (das siehst du im Screenshot nicht), setzt du den Datenpunkt execute wieder auf falsch. Damit ist die Regel beendet und dein Raspberry Pi zeigt dir die entsprechende Oberfläche.

Du kannst statt der URL deiner VIS auch eine beliebige Adresse im Internet eingeben. Dein Pi wird daraufhin die Website öffnen.

Das Steuerungselement in der VIS

Damit du die Oberfläche nun auch komfortabel auswählen kannst, musst du in deiner Steuerungs-VIS (also der Oberfläche, von wo du den Bildschirm steuern möchtest) entsprechend anpassen.

Hierzu brauchst du ein Dropdown-Element in der VIS, wo du die entsprechenden Werte einträgst. Das sieht dann so aus:

In den Eigenschaften des Dropdowns kannst du nun die richtigen Werte festlegen. Dabei müssen die Werte denen entsprechen, die du in deiner Regel prüfst (also zum Beispiel 0). Ich habe mir testweise vier Werte angelegt, um im Dropdown auswählen zu können. Die Eigenschaften sehen demnach so aus:

Wähle bei der Objekt ID den Datenpunkt aus, den du im Skript prüfst. Bei mir nennt er sich Bildschirm_Anzeige. Bei den Werten vergibst du Zahlen, die du innerhalb deines Skripts in den Bedingungen prüfst. Hier kannst du beliebig viele hinzufügen. Die Texte sind die Anzeigewerte in der VIS, dass du später auch noch weißt, was für eine Oberfläche es ist.

Alles weitere wird in deinem Skript geregelt und muss hier nicht eingestellt werden.

Wenn du nun eine andere Oberfläche im Dropdown auswählst, wird dein Bildschirm dir die entsprechende Oberfläche anzeigen. So kannst du per Tablet deinen Monitor am Raspberry Pi bequem umstellen, wenn du das möchtest.

Bildschirmsteuerung mit ioBroker und Raspberry Pi

Wie du in diesem Beitrag sehen konntest, sind die Möglichkeiten im Smart Home nahezu ohne Grenzen. Die Steuerung eines Monitors ist dabei so komfortabel möglich, dass du jederzeit von einem Tablet alles im Griff hast.

An Weihnachten kannst du zum Beispiel ein schönes Weihnachtsfoto von der Familie anzeigen, während du an sonstigen Tagen deiner VIS im Blick behältst. Es ist mit dieser Möglichkeit auch denkbar, dass dein ioBroker auf Basis von anderen Ereignissen die Oberfläche selbstständig wechselt. Der eigene Fantasie sind hier nahezu keine Grenzen gesetzt.

Du kannst den Adapter Linux Control natürlich auch dazu verwenden, andere Befehle auf deinem Pi auszuführen. Anstatt einfach nur den Bildschirm auszuschalten, kannst du den Pi auch komplett herunterfahren.

Mich begeistert an dieser Umsetzung, dass ich nun flexibel anzeigen kann, was ich möchte. Ohne dass ich hierfür Maus und Tastatur in die Hand nehmen muss. Ich kann außerdem den Raum verlassen und weiß, dass der Bildschirm ausgeschaltet ist. Hier greift natürlich der Aspekt des Stromsparens.

Solltest du weitere Ideen haben, was man damit anstellen kann, würde ich mich über dein Feedback in den Kommentaren freuen. Scrolle dazu einfach weiter nach unten und hinterlasse deine Gedanken. Ich freue mich auf den Austausch mit dir!