Schlagwort-Archive: HomeMatic

Dieser Bereich beinhaltet alle Themen zu dem Schlagwort “HomeMatic”.

E-Mail

E-Mail aus der HomeMatic heraus senden

Wenn alle Schaltungen oder Timer in Deiner HomeMatic Installation reibungslos laufen, ist dies ein beruhigendes Gefühl. Doch, was ist, wenn plötzlich ein Fehler auftritt und du unterwegs bist? Oder, Du möchtest benachrichtigt werden, wenn ein gewisses Ereignis eintritt? In solchen Fällen benötigst Du, um eine E-Mail Benachrichtigung aus der HomeMatic heraus senden zu können, das E-Mail Plugin, welches Du hier herunterladen kannst.
Bitte die tar.gz-Datei nicht entpacken.

Installation auf der HomeMatic

Die Installation des Plugin läuft genauso ab, wie die Installation der anderen Plugins.

HomeMatic WebUI über Einstellungen -> Systemsteuerung -> Zusatzsoftware

Installation des E-Mail Plugin
Installation des E-Mail Plugin

Konfiguration des Plugin

Um das Plugin einzustellen, gehst Du nach der Installation auf Einstellen.

Einstellung des E-Mail Plugin
Einstellung des E-Mail Plugin

E-Mails

In diesem Bereich richtest Du zuerst eine Testmail unter der Vorlage 01 ein. Diese einhält eine funktionierende Adresse, einen Betreff und einen Test-Text.

E-Mail Vorlage erstellen
E-Mail Vorlage erstellen

Account

Danach wechselst Du in den Reiter Account. Dort kannst Du die Einstellungen deines E-Mail Kontos angeben.

Account Einstellungen
Account Einstellungen

Nach einem Klick auf Übernehmen. Kannst Du in der Karteikarte Hilfe einsehen, ob die Einstellungen korrekt sind. Für gmail, web.de oder o.ä. muss ggf. der Versand über SMTP noch im Kundenkonto aktiviert werden.

Tcl

Tcl Einstellungen
Tcl Einstellungen

Die Tcl Einstellungen (Tool command language) kannst Du verwenden, um Variablen in einer E-Mail zu übergeben. Ich verwende hier einen kleinen Code, der den Betreff (Subject) und E-Mail Text (Body) aus HomeMatic Variablen ausliest und diese entsprechend formatiert einfügt.

load tclrega.so

array set values [rega_script {

var subject = dom.GetObject("E-Mail.Subject").Value();
var body = dom.GetObject("E-Mail.Body").Value();

} ]

set subject $values(subject)
set body [encoding convertto $values(body)]

Hinweis: Mittels der im Tcl-Skript definierten Platzhalter können nicht nur Werte und Zustände von HomeMatic Geräten oder Variablen in den Email-Text oder den Betreff übergeben werden, sondern auch die Empfänger Email-Adresse oder einen Pfad für den Dateianhang.

Hilfe

In diesem Bereich kannst du nun eine Testmail versenden, um Deine Konfiguration zu testen.

Testmail versenden
Testmail versenden

Nachdem nun der Versand der Mails problemlos funktioniert, können wir uns an die Einrichtung der Vorlagen machen.

E-Mail Vorlagen erstellen

In diesem Bereich kannst Du Vorlagen für verschiedene Ereignisse anlegen. Ich benutze bei mir 4 Vorlagen (Fehler, Status, Abgeschlossen und Alarm). Diese kannst Du natürlich an Deine Bedürfnisse anpassen. Im weiteren Verlauf werden wir diese in HomeMatic einrichten. Hier sind die 2 ersten Vorlagen, die ich verwende:

Hier kannst Du direkt sehen, das die Variablen $subject und $body von oben erneut auftauchen. So lässt sich das Layout der Mail schon festlegen und später über die HomeMatic Variablen befüllen.

Mit der Einrichtung des Plugins sind wir nun fertig. Mit einem Klick auf Übernehmen werden die Vorlagen gespeichert und das Plugin ist einsatzbereit.

Einrichtung auf der HomeMatic

Anlegen der Systemvariablen

Insgesamt benötigst Du 3 Systemvariablen. 2 vom Typ Zeichenkette und 1 vom Typ Werteliste.

Name:Typ:
E-Mail.BodyZeichenkette
E-Mail.SubjectZeichenkette
E-Mail.VersandWerteliste
Folgende Systemvariablen müssen angelegt werden
HomeMatic Variablen anlegen
HomeMatic Variablen anlegen

Die Werteliste beinhaltet kein Versand;Fehler;Status;Abgeschlossen;Alarm als Werte. Somit baut sich die Vorlagenliste von oben wir folgt auf:

Werteliste-Element:Vorlage:
0
101
202
303
404
Vorlage und Werteliste-Element

Nachdem wir nun alle Variablen angelegt haben, erstellen wir das Herzstück: das Programm.

E-Mail Programm erstellen

Damit das Versenden von E-Mails zentral gesteuert wird, legst Du ein Programm an, welches den Zustand der Werteliste E-Mail.Versand überwacht.

E-Mail Programm auf der HomeMatic
E-Mail Programm auf der HomeMatic

Skript:

! Servicemeldungen versenden ####################################
object subject = dom.GetObject ("E-Mail.Subject");
object body = dom.GetObject ("E-Mail.Body");
object versand = dom.GetObject ("E-Mail.Versand");

if ((subject.Value() != "") && (body.Value() != "") && (versand.Value() > 0)) {
	system.Exec ("/etc/config/addons/email/email 0" # versand.Value());
	
	subject.State ("");
	body.State ("");
	versand.State (0);
}

Damit Du nun endlich eine E-Mail beim Eintreten eines Ereignisses versenden kannst, zeige ich Dir nun die Einrichtung.

Du kannst zum Beispiel ein Programm erstellen, welches Dich benachrichtigt, sobald die Waschmaschine fertig ist. Dies ist bei mir eine “Abgeschlossen” Meldung.

E-Mail beim Eintreten eines Ereignisses versenden
E-Mail beim Eintreten eines Ereignisses versenden

Implementierung per Skript

Eine Implementierung per Skript lässt sich wie folgt durchführen. Das Skript lässt sich so schnell kopieren und erneut ans Ende eines Programms einfügen, als jedes Mal 5 zusätzliche Felder anzuklicken.

Skript:

! Servicemeldungen versenden ####################################
object subject = dom.GetObject ("E-Mail.Subject");
object body = dom.GetObject ("E-Mail.Body");
object versand = dom.GetObject ("E-Mail.Versand");

subject.State ("Waschmaschine");
body.State ("Die Waschmaschine ist fertig!");
versand.State (3);
Fenster

Shelly Fensterkontakt mit HomeMatic Heizkörperthermostat

Seit geraumer Zeit bietet Shelly auch Fensterkontakte an. Diese haben zusätzlich einen Helligkeitssensor eingebaut, den Du für die Rollladensteuerung mit einem Shelly 2.5 nutzen kannst. Aber, was ist, wenn Du bereits Heizkörperthermostate von HomeMatic verbaut hast? Normalerweise verknüpft man die Komponenten in HomeMatic per direkter Verknüpfung. Dies klappt mit einem Shelly natürlich nicht.

Aber halt, hier gibt es Abhilfe mit einem Skript in ioBroker. Du abonnierst einfach den Datenpunkt des Shelly und reagierst auf die Öffnung des Fenster und schaltest so das Heizkörperthermostat auf den manuellen Modus. Später, wenn das Fenster wieder verschlossen ist, kannst Du wieder den Auto-Modus aktivieren.

Installation des Shelly Adapter

Installation des Shelly Adapter
Installation des Shelly Adapter

Nach kurzer Zeit stehen die Datenpunkte aller gefundenen Shellys unter shelly.0 zur Verfügung.

Skript für das Heizkörperthermostat in ioBroker

on({id: "shelly.0.SHWND-S#XXXXXX5#1.open", change: "ne"}, function (obj) {
    if (obj.state.val === true) {
        setState("hm-rpc.0.KEQ10419XX.4.AUTO_MODE",false);
    } else {
        setState("hm-rpc.0.KEQ10419XX.4.AUTO_MODE",true);
    }  
});

Jetzt schaltet sich das Heizkörperthermostat auf den manuellen Modus, sobald das Fenster geöffnet wurde.

Hast Du allerdings ein Wandthermostat per direkter Verknüpfung an das Heizkörperthermostat angelernt, so macht es Sinn, dieses anzusteuern, da das Wandthermostat das Heizkörperthermostat in diesem Fall steuert und so die Werte immer überschreiben würde.

Skript für das Wandthermostat

on({id: "shelly.0.SHWND-S#XXXXXX5#1.open", change: "ne"}, function (obj) {
    if (obj.state.val === true) {
        setState("hm-rpc.0.LEQ09997XX.2.AUTO_MODE",false);
    } else {
        setState("hm-rpc.0.LEQ09997XX.2.AUTO_MODE",true);
    }  
});
KeyMatic

HomeMatic KeyMatic mit NFC Tag öffnen und schließen

Die KeyMatic von HomeMatic habe ich bereits seit Jahren im Einsatz und sie läuft ohne Probleme. Nun habe ich mir überlegt, wie man NFC in die KeyMatic integrieren kann, damit auch eine Öffnung möglich ist, wenn man das Smartphone benutzt.

Um dies zu realisieren benötigst Du nur ein Set von NFC Tags (Aufkleber). Diese dienen hier nur als Auslöser für ein Makro und beinhalten keine sonstigen Informationen.

Programm für die HomeMatic

Ich habe hier ein Programm erstellt, welches zuerst den Status des Schlosses ermittelt (geöffnet/geschlossen). Somit wird das Schloss geöffnet, wenn es verschlossen ist und verschlossen, wenn es aufgeschlossen ist.

Programm zum Öffnen oder Schließen der Tür
Programm zum Öffnen oder Schließen der Tür

Achtung: Dieses Programm hat keinen Auslöser, somit wird das Programm immer ausgeführt, wenn die Zentrale neu startet.

! KeyMatic steuern ####################################
var schloss = dom.GetObject("BidCos-RF.LEQXXXXXX:1.STATE").Value();

if (schloss) {
	WriteLine("Schloss ist auf und wird abgeschlossen!");
	dom.GetObject("BidCos-RF.LEQXXXXXX:1.STATE").State(0);
	dom.GetObject(950).State(0);
} else {
	WriteLine("Schloss ist abgeschlossen und wird geöffnet!");
	dom.GetObject(950).State(1);
	dom.GetObject("BidCos-RF.LEQXXXXXX:1.OPEN").State(1);
}

Der Name des Programms sollte nach Möglichkeit keine Sonderzeichen oder Leerzeichen enthalten, da er sonst später nicht aufgerufen werden kann.

Nachdem das Programm erstellt worden ist, kannst Du dich an die Einrichtung eines Makros in MacroDroid machen.

Als Auslöser stellst Du NFC Sticker ein und als Aktion den Aufruf als HTTP GET (Ohne Web Browser). Beim Auswählen des NFC Sticker muss dieser bereitliegen, da er gescannt wird. Ein Name “Haustuer” o.ä. ist hier hilfreich, damit man die Sticker später auseinander halten kann. MacroDroid schreibt nun nur den Namen auf den Sticker und speichert diesen ab. Es kann also mit dem NFC Tag ansich kein Unfug getrieben werden, da er nur die Information seines Namens beinhaltet.

Die Adresse für den Aufruf über MacroDroid stellst Du wie folgt ein:

http://IP-DEINER-CCU:8181/x.exe?Antwort=dom.GetObject("geheimer_Tueroeffner").ProgramExecute()

geheimer_Tueroeffner ist hier der Name des Programms, welches über den Aufruf der URL gestartet wird. Ich habe hier bewusst die lokale IP benutzt, da somit auch sichergestellt ist, dass die CCU weiterhin nicht von Außen erreichbar sein muss.

Solltest Du nur die Öffnung der Türe benötigen, so kannst Du das HomeMatic Programm von oben wieder entfernen und den Aufruf der Adresse von MacroDroid in folgenden Aufruf abändern:

http://IP-DEINER-CCU:8181/x.exe?Antwort=dom.GetObject("BidCos-RF.LEQXXXXXXX:1.OPEN").State(1)

Nun kannst Du den Sticker in die Nähe Deines Türschlosses o. ä. kleben und zum Testen Dein Handy an diesen halten.
Bitte beachte: Bei neueren Android Versionen muss das Handy entsperrt sein, damit der Tag gelesen werden kann. Dies ist aus Sicherheitsgründen so gewollt, da so auch Zahlungen bei gesperrtem Smartphone getätigt werden könnten.

Sprachausgabe

HomeMatic Sprachausgabe mit Alexa, ioBroker und JavaScript

HomeMatic ist die Grundbasis, die die Funkverbindung zu den Geräten von eQ3 herstellt. Durch die Installation von Plugins kann die Zentrale ein wenig erweitert werden – jedoch lassen sich keine übergreifenden Plugins wie bei ioBroker installieren. Dazu ist das System auch nicht konzipiert. Daher verwenden wir hier den ioBroker, der viele Adapter mitbringt, auf die wir die Sprachausgabe weiterleiten können. Somit steht der Ausgabe von HomeMatic Variablen nichts im Wege!

Hinweis:
Dieser Beitrag baut auf einen vorherigen Beitrag auf, in dem bereits der Alexa Adapter in ioBroker installiert und ein Grund-Skript erstellt wurde.

Vorbereitungen auf der HomeMatic

Auf der HomeMatic legen wir zuerst 3 Systemvariablen an.

name:Typ:
Echo.GeraetWerteliste
Echo.TextZeichenkette
Echo.VersandLogikwert
Folgende Systemvariablen müssen angelegt werden

In der Werteliste kannst Du alle Echos, die Du verwenden möchtest, mit Namen auflisten. Bitte achte darauf, das die Reihenfolge mit der Werteliste des Arrays aus dem vorherigen Beitrag
var echos = ['kein Gerät','Fire TV Cube','Echo Dot Küche','Echo Dot Schlafzimmer','Echo Dot Flur','Wohnung','Überall'];
überein stimmt.

Der Logikwert von Echo.Versand lautet: wahr = sprachen, nicht wahr = Standby

Variablen zur Ausgabe von Informationen
Variablen zur Ausgabe von Informationen

Anlegen eines Programms auf der HomeMatic

Als Beispiel dient hier ein einfaches Programm, welches auf die Öffnung eines Fensters reagiert. Ich habe hier den Echo “Fire TV Cube” gewählt, da dieser im Wohnzimmer steht und ich das Fenster im Wohnzimmer öffne 🙂

Anlegen des Programms für die Sprachausgabe
Anlegen des Programms für die Sprachausgabe

Wichtig ist das Gerät HM-RCV-50 BidCoS-RF:50 am Ende einzufügen. Dies ist die Trigger-Funktion (Auslöse-Funktion) für ioBroker, um neue Daten von der HomeMatic abzuholen. Dies geschieht normalerweise nämlich nur alle 30 Sekunden!

Solltest Du das Gerät nicht finden können, so betätige bei der Gerätseauswahl einmal die Schaltfläche:

Virtuelle Kanäle anzeigen
Virtuelle Kanäle anzeigen

Wenn du nun das Fenster geöffnet hast, kannst du in der Übersicht der Systemvariablen sehen, das die entsprechenden Werte gesetzt worden sind.

Variablen wurden gesetzt
Variablen wurden gesetzt

Vorbereitungen für das Skript in ioBroker

Im vorherigen Beitrag haben wir bereits das dynamische Skript angelegt, welches Ausgaben auf Alexa tätigt. Damit nun die Ausgaben von HomeMatic auch auf Alexa ausgegeben werden, benötigen wir ein zusätzliches Skript, welches das bereits angelegte Skript anspricht. Zuerst aber solltest du den ReGa-Adapter neu starten, damit die eben angelegten Variablen auch ihre Datenpunkte erhalten.

Jetzt wirst Du, wenn Du nach “Echo.” suchst, die passenden 3 Datenpunkte finden. Hier sind die ID’s der Datenpunkte wichtig, da wir hiermit weiterarbeiten.

Datenpunkte der HomeMatic Variablen
Datenpunkte der HomeMatic Variablen

Skript in ioBroker anlegen

Das folgende Skript kann ruhig im common Bereich angelegt werden, da es keine Funktion enthält, auf die global zugegriffen wird.

// var Geraet aus HomeMatic
 var geraet_dp = "hm-rega.0.3118";
 
 // var Text aus HomeMatic
 var text_dp = "hm-rega.0.3119";
 
 // var Versand aus HomeMatic
 var versand_dp = "hm-rega.0.3120";
 
 on({id: versand_dp, change: "ne"}, function (obj) {
     // Prüfen, ob Versand auf "sprechen" steht
     if (obj.state.val==true) {
         
         // Hole Text aus Datenpunkt
         var text = getState(text_dp).val;
         
         // Hole Gerät aus Datenpunkt
         var echo = getState(geraet_dp).val;
         
         // Alexa Ausgabe
         Alexa_sprechen(echo,text);
        
         // Alle Werte zurücksetzen
         setState(geraet_dp,0);
         setState(text_dp,'');
         setState(versand_dp,false);
     }
 });

Sobald Du das Skript abgespeichert und “Skript ausführen” betätigt hast, sollte auch direkt eine Ausgabe erfolgen, da ioBroker ja immer noch die Werte gespeichert hat und der Versand immer noch auf true (wahr) steht. Danach werden die Variablen zurückgesetzt und wieder zu HomeMatic übermittelt. Sollte ein Fehler erscheinen, dass “Alexa_Sprechen” nicht gefunden werden kann, so stelle bitte sicher, das Du meinen
vorherigen Beitrag gelesen und umgesetzt hast 🙂

Ausgabe von Werten der HomeMatic Geräte

Um den Wert von einem Gerät an Alexa weiterzuleiten, benötigst Du ein Skript, welches die Werte ausliest. Dies lässt sich leider nicht mit den normalen Blöcken von HomeMatic realisieren.

Ich verwende hier ein Beispiel, welches den neu eingestellten Wert des Heizkörperthermostats ausgibt.

Anlegen des Programms für die Sprachausgabe mit Auslesen von Werten
Anlegen des Programms für die Sprachausgabe mit Auslesen von Werten

Um nun die Werte aus dem Heizkörperthermostat auslesen zu können, benötigt man den Übertragungsstandard(Bid-Cos-RF oder HmIP), die Seriennummer des Gerätes und den entsprechenden Kanal (hier Kanal 4) und den Datenpunkt in HomeMatic (die Datenpunkte kannst Du hier herunterladen).

! Lese Soll-Temperatur aus ####################################
 ! Hole Temperatur aus dem Gerät in einen String mit einer Nachkommastelle
 var soll_temp = dom.GetObject("BidCos-RF.KEQ1041939:4.SET_TEMPERATURE").Value().ToString(1);
 ! Temperatur in Komma statt Punkt umschreiben
 soll_temp = soll_temp.Replace('.',',');
 var AText = "Die eingestellte Temperatur im Wohnzimmer beträgt: " # soll_temp # " Grad!";
 ! Ansage für Alexa
 dom.GetObject('Echo.Text').State(AText);
 ! Gerät 1 'Fire TV Cube'
 dom.GetObject('Echo.Geraet').State(1);
 ! Versand auf true stellen
 dom.GetObject('Echo.Versand').State(true);
 ! Trigger für ioBroker auslösen
 ! dom.GetObject("BidCos-RF.BidCoS-RF:50.PRESS_SHORT").State(1);

Nun solltest Du beim Verändern der Soll-Temperatur eine Sprachausgabe von Alexa erhalten, die Dir die aktuell eingestellte Temperatur mitteilt.

Erweiterung des Skripts in ioBroker um einen Uhrzeitbereich

Schön sind die Ansagen von Alexa, wenn man sie auch hören kann – in der Nacht möchte man jedoch gerne schlafen und nicht durch eine Stimme geweckt werden, die einem die derzeit eingestellte Temperatur mitteilt.

// var Geraet aus HomeMatic
 var geraet_dp = "hm-rega.0.3118";
 
 // var Text aus HomeMatic
 var text_dp = "hm-rega.0.3119";
 
 // var Versand aus HomeMatic
 var versand_dp = "hm-rega.0.3120";
 
 on({id: versand_dp, change: "ne"}, function (obj) {
     // Prüfen, ob Versand auf "sprechen" steht
     if (obj.state.val==true) {
         
         // Hole Text aus Datenpunkt
         var text = getState(text_dp).val;
         
         // Hole Gerät aus Datenpunkt
         var echo = getState(geraet_dp).val;
         
         // Generiere Datum
         var d = new Date();
 
         // Hole Stunde
         var hour = d.getHours();
 
         // Ausgabe von Text zwischen 8 Uhr morgens und 22 Uhr abends;
         if (hour>8 && hour<22) {
             Alexa_sprechen(echo,text);
         } else {
             log ("Alexa darf nicht zwischen 22 Uhr und 8 Uhr sprechen!");
         }
            
         // Alle Werte zurücksetzen
         setState(geraet_dp,0);
         setState(text_dp,'');
         setState(versand_dp,false);
     }
 });

Mit dieser Änderung spricht Alexa die Texte, die aus HomeMatic kommen, nur in der Zeit von 8 bis 22 Uhr.
Durch meinen neuen Beitrag lässt sich das Zeitfenster auch anders anpassen, wenn man dieses Skript global verwendet.

// var Geraet aus HomeMatic
 var geraet_dp = "hm-rega.0.3118";
 
 // var Text aus HomeMatic
 var text_dp = "hm-rega.0.3119";
 
 // var Versand aus HomeMatic
 var versand_dp = "hm-rega.0.3120";
 
 on({id: versand_dp, change: "ne"}, function (obj) {
     // Prüfen, ob Versand auf "sprechen" steht
     if (obj.state.val==true) {
         
         // Hole Text aus Datenpunkt
         var text = getState(text_dp).val;
         
         // Hole Gerät aus Datenpunkt
         var echo = getState(geraet_dp).val;
         
         // Ausgabe von Text zwischen 8 Uhr morgens und 22 Uhr abends;
         if (Zeitbereich("08:00:00", "22:00:00")) {
             Alexa_sprechen(echo,text);
         } else {
             log ("Alexa darf nicht zwischen 22 Uhr und 8 Uhr sprechen!");
         }
            
         // Alle Werte zurücksetzen
         setState(geraet_dp,0);
         setState(text_dp,'');
         setState(versand_dp,false);
     }
 });
Katzenbrunnen

Katzenbrunnen mit ioBroker und Shelly Plug S überwachen

Für meine 2 Katzen habe ich einen Katzenbrunnen, um die Trinkgewohnheit anzuregen. Dieser Brunnen wird von einer kleinen Pumpe angetrieben, die je nach Zustand einen unterschiedlichen Vebrauch hat. Die Pumpe verbraucht z.B. mehr Leistung, wenn sie blockiert ist, im Gegenzug ist der Verbrauch im Betrieb aber konstant bei 4.2 Watt. Diese 2 Werte lassen sich so hervorragend benutzen, um den Status der Pumpe zu überwachen.

Ich übermittele so den Status der Pumpe an die HomeMatic und reagiere dort mit dem E-Mail Plugin darauf und lasse mir eine E-Mail senden, sobald die Pumpe blockiert.

Installation des Shelly Adapter

Installation des Shelly Adapter
Installation des Shelly Adapter

Nach kurzer Zeit stehen die Datenpunkte aller gefundenen Shellys unter shelly.0 zur Verfügung.

Systemvariable in HomeMatic anlegen

Systemvariable in HomeMatic
Systemvariable in HomeMatic

Ich habe zur Weiterverarbeitung eine Systemvariable in HomeMatic angelegt, die 3 Zustände in einer Werteliste annimmt. Diese werden dann von ioBroker entsprechend übermittelt und gesetzt.

Skript zur Überwachung der Pumpe

Datenpunkt des Shelly Plug S
Datenpunkt des Shelly Plug S
// Überwachung des Katzebrunnen
 var dp_brunnen = "hm-rega.0.11909"; //Systemvariable "Katzenbrunnen"
 var dp_verbrauch = "shelly.0.SHPLG-S#51D3XX#1.Relay0.Power";
 var status;
 on({id: dp_verbrauch, change: "any"}, function (obj) 
 {
     // hole aktuellen Status
     var status_current = getState(dp_brunnen).val;
     // Aktueller Verbrauch der Pumpe
     var verbrauch = getState(dp_verbrauch).val;
     if (verbrauch>1) {
         status = 0; //Katzenbrunnen ist eingesteckt
     }
     if (verbrauch>4) {
         status = 1; //Katzenbrunnen läuft
     }
     if (verbrauch>6) {
         status = 2; //Katzenbrunnen ist blockiert
     }
     if (status_current!=status) {
         setState(dp_brunnen, status);
     }
 });

Damit der Status des Brunnens nicht bei jeder Werte Änderung an die HomeMatic übermittelt wird, habe ich das Skript so angepasst, das es den Status nur übermittelt, wenn dieser sich vom aktuellen Status unterscheidet.

Smart-Home

Tablet als Visualisierungs-Front-End

Wer sein Smart – Home umfangreich eingerichtet hat, möchte auch gerne mit diesem an einer (oder mehr) zentralen Stelle(n) agieren und seine Geräte steuern oder Status – Mitteilungen einsehen können.

Dies kann mit einem (alten, nicht mehr benötigten) Tablet ermöglicht werden. Ich nutze hier ein Samsung – Tablet (Samsung Galaxy Tab S 10.5). Als OS bediene ich mich dem Lineage OS (https://wiki.lineageos.org/devices/chagallwifi). Zusätzlich sind die folgenden Programme installiert, deren Einrichtung ich hier erläutere.

ProgrammZweckDownload
BatteryChargeLimitLadekontrolle des Tablets (Root erforderlichLink
iobroker VISVisualisierungs – Anzeige von ioBrokerLink
MacroDroidAutomatisierung von AndroidLink
MotionDetectorBewegungserkennungLink
Benötigte Programme für ein Smart – Home Tablet

Konfiguration von MotionDetector

Die App Motion Detector dient dem Zweck, eine Bewegung der Frontkamera zu erfassen, um so das Display einzuschalten, wenn man sich nähert. Die App wird wie folgt eingestellt.

Zuerst startest Du die App und stellst den Schieber bei Notification/Send auf AN. Der Haken bei Receive wird aktiviert, damit andere Anwendungen das Signal (Intent) empfangen können, sobald Motion Detector eine Bewegung erkennt.

Notification Einstellungen in Motion Detector
Notification Einstellungen in Motion Detector

In den weiteren Einstellungen aktivierst Du noch den Autostart und kannst ggf. die Camera auf Front einstellen.

Camera - Einstellung & Autostart in Motion Detector
Camera – Einstellung & Autostart in Motion Detector

Im weiteren Verlauf solltest Du noch die Battery Optimization einstellen und die Empfindlichkeit unter Sensitivity an Deine Umgebung anpassen. Folgende Einstellungen habe ich bei mir aktiviert. Somit erkennt das Tablet auch in der Nacht Bewegungen und schaltet sich ein.

Battery Optimization & Sensity Einstellung
Battery Optimization & Sensity Einstellung
Sensitivity Einstellung
Sensitivity Einstellung

Bei Suspend kannst Du einstellen, wie lange die App keine erneute Bewegung nach einer erkannten Bewegung erfasst und somit auch keine Benachrichtigung (Intent) sendet.

Suspend Einstellung
Suspend Einstellung

Auf der Hauptseite des Motion Detector muss die Erkennung noch aktiviert werden. Dazu das blaue Kamera – Symbol anklicken und man sieht direkt, das die Kamera neue Events registriert. Um Dich zu versichern kannst Du auch ein paar Mal mit der Handfläche an der Kamera vorbei streichen und sehen, wie sich die Zahl der Events verändert.

Motion Detector gestartet und aktiv
Motion Detector gestartet und aktiv

Konfiguration von MacroDroid

Ich persönlich arbeite sehr gerne mit MacroDroid, da es im Gegensatz zu Tasker sehr zuverlässig läuft und schnell und einfach zu bedienen ist. Wer an dieser Stelle schon Tasker installiert hat, kann die ähnlichen Befehle auch dort einbinden – die Vorgehensweise ändert sich nur ein Wenig.

Du erstellst in MacroDroid ein neues Makro

Neues Makro in MacroDroid anlegen
Neues Makro in MacroDroid anlegen

Makroname:
Den Namen kannst Du frei wählen. Z.B. Bewegung – Display an

Auslöser:
Klicke auf das kleine Plus bei Auslöser Geräteereignisse -> Intent erhalten und trage dort folgendes ein:

org.motion.detector.ACTION_GLOBAL_BROADCAST
Auslöser hinzufügen -> Geräteereignisse -> Intent erhalten
Auslöser hinzufügen -> Geräteereignisse -> Intent erhalten

Aktionen:
Abermals über das Plus zwei Aktionen anlegen:
Geräteeinstellungen -> Bildschirmsperre -> Bildschirm entsperren -> OK
Bildschirm -> Bildschirm An/Aus -> Bildschirm an -> OK

Geräteeinstellungen -> Bildschirmsperre -> Bildschirm entsperren
Geräteeinstellungen -> Bildschirmsperre -> Bildschirm entsperren
Bildschirm -> Bildschirm An/Aus -> Bildschirm an
Bildschirm -> Bildschirm An/Aus -> Bildschirm an

Über die Taste =+ am unteren Bildschirmrand speicherst Du das Makro ab und aktivierst es gleichzeitig.

Konfiguration von ioBroker VIS

Die notwendigen Einstellungen kannst Du in der VIS App auf dem Tablet tätigen. Gib’ zuerst die Adresse und Zugangsdaten ein und wähle OK. Danach wird die Konfiguration neu geladen und das Projekt ist – sollten die Zugangsdaten stimmen – auswählbar.
Erscheint auch mit korrekten Zugangsdaten kein Projekt in der Auswahlliste, so scrolle einmal ganz nach unten und wähle dort Mobile Verbindung -> Erlaube selbstsignierte Zertifikate -> aktiv

SSID Name: Name des W-Lans (so weiss VIS, ob es im heimischen W-LAN ist)
Socket URL: Adresse des ioBroker VIS mit Port 8082 (https://192.168.2.105:8082)
Anwender: Unter diesem Benutzer ist das Projekt gespeichert (Standard: Admin)
Kennwort: Falls ioBroker mit einem Kennwort gesichert ist, dieses hier eintragen
Kennwort-Wiederholung: Das Kennwort des Benutzers nochmal eingeben
Projekt: Name des Projekt, welches VIS laden soll
Erlaube selbstsignierte Zertifikate: Unbedingt aktivieren, da sonst keine Verbindung zustande kommt

Sobald alle Einstellungen erfolgt sind und VIS als Oberfläche erscheint, lässt Du das Tablet einfach liegen und wartest, bis sich das Display abdunkelt oder ausschaltet. Dann kannst Du durch eine Bewegung testen, ob diese erfasst wird und sich das Display einschaltet.

BatteryChargeLimit einrichten

Da das Tablet non-stop mit dem Ladegerät verbunden ist, würde es sich jedes Mal direkt bei 99% Akkustand wieder aufladen. Dies schadet dem Akku sehr. Der beste Ladestand eines Akkus beträgt zwischen 60 – 80%. Um dies zu erreichen kannst Du entweder die Möglichkeit einer Smart – Home Steckdose nutzen, die Du per Macrodroid einschalten lässt, sobald ein gewisser Ladestand unterschritten ist oder Du nutzt die App BatteryChargeLimit, die dies völlig unabhängig auf einem gerooteten Tablet durchführt.

Folgende Einstellungen sind hier zu tätigen:

  • Aktiviere Battery Charge Limit
  • Laden bis max. 80%
  • Wiederaufladen unter 60%
  • Die App findet automatisch die passende Steuerdatei
Einstellungen für BatteryChargeLimit
Einstellungen für BatteryChargeLimit

Überwachung des Tablet Ladestand in der HomeMatic

Mit MacroDroid lässt sich natürlich auch noch der aktuelle Ladestand auf die HomeMatic bringen. Dazu habe ich ein eigenes Skript, welches alle 2 Minuten den aktuellen Ladestand in die CCU schreibt.

VariableTypMaßeinheit
Ladestand TabletZahl%
Ladestand des Tablets alle 2 Minuten an die CCU übermitteln

Dazu kannst Du ein neues Makro erstellen, welches folgenden Auslöser hat:
Tag/Zeit -> Intervall, regelmäßiges -> alle 2 Minuten

Als Aktion wählst Du:
Anwendungen -> Webseite öffnen / HTTP Get und wählst dort zusätzlich (HTTP GET (Ohne Web Browser) aus.
Als URL trägst Du dort folgendes ein:

http://IP-DEINER-CCU:8181/x.exe?Antwort=dom.GetObject("Ladestand Tablet").State([battery])
Ladestand des Tablets alle 2 Minuten an die CCU übermitteln
Ladestand des Tablets alle 2 Minuten an die CCU übermitteln

Jetzt wird alle 2 Minuten der Ladestand des Tablets automatisch in die Variable geschrieben. Auf der CCU kann man nun mit dem Wert weiter arbeiten und zugehörige Programme erstellen. Zum Beispiel -> Ladestand unter 50% -> sende eine E-Mail als Hinweis.

Geschafft!

Ein fertiges Tablet sieht in etwa so aus:

Beispiel für die Visualisierung
Systeminformationen anzeigen

Systeminformationen auf der Startseite der HomeMatic anzeigen

Damit Systemvariablen auf der Startseite der HomeMatic angezeigt werden können, sind ein paar Schritte notwendig.
Durch die Screenshots wird deutlich, welche Schritte durchzuführen sind.

Zuerst auf Einstellungen -> Benutzerverwaltung

Einstellungen -> Benutzerverwaltung
Einstellungen -> Benutzerverwaltung

Danach den Benutzer über Bearbeiten auswählen, aus wessen Startseite die Variablen angezeigt werden sollen.

Bearbeiten
Auf der rechten Seite auf “Bearbeiten”

Auf der rechten Seite Systemvariable hinzufügen auswählen

Systemvariable hinzufügen
Systemvariable hinzufügen

Die gewünschte Systemvariable über Auswahl auswählen. Bei mehreren Variablen den Schritt von vorher wiederholen und die nächste Variable erneut über Auswahl auswählen.

Systemvariable auswählen
Systemvariable auswählen

Die ausgewählten Variablen erscheinen in der Liste, welche auf der Startseite angezeigt werden.

Die ausgewählte Variable erscheint dann in der Liste
Die ausgewählte Variable erscheint dann in der Liste

Mit einem Klick auf Zurück schließt man die Maske und kann sich wieder auf die Startseite begeben. Dort erscheint dann die Systemvariable mit ihrem derzeitigen Wert. Alle Änderungen an der Systemvariable werden unmittelbar aktualisiert, sobald eine Änderung eintritt.

Startseite des Benutzers mit Variablen
Startseite des Benutzers mit Variablen
Systeminformationen

Systeminformationen zu HomeMatic sammeln

  • die Temperatur
  • die Laufzeit
  • die aktuelle RAM – Auslastung
  • die CPU – Nutzung

Vorbereitung

Für die Anzeige müssen insgesamt 4 Systemvariablen angelegt werden.
Zusätzlich wird hier wieder ein Kanal eines CuX Exec (28) Gerät benötigt.

Name:Typ:
CPU-AuslastungZeichenkette
LaufzeitZeichenkette
RAM-NutzungZeichenkette
Temperatur RaspberryZeichenkette
Folgende Systemvariablen müssen angelegt werden

Es lassen sich hier natürlich auch nur einzelne Variablen definieren, welche man in der Übersicht sehen möchte. Hierbei ist zu beachten, das bei einzelnen Anzeigen immer das CuX – Gerät eingefügt wird (markiert in Zeile 2). Verwendet man also 1 Skript, so ist einmalig in Zeile 2 das CuX – Gerät einzufügen.
Am Ende gibt es das komplette Skript.

Skript CPU-Auslastung

! CPU-Nutzung
string s_cuxd = "CUxD.CUX2801001:3.";
string s_cmd = "top -b -n 1 | egrep 'CPU' |  awk 'NR==1 {printf \"%d%s\", $2, \"%\"}'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("CPU-Auslastung").State (dom.GetObject (s_cuxd # "CMD_RETS").State());

Skript Laufzeit

! Laufzeit
string s_cuxd = "CUxD.CUX2801001:3.";
string s_cmd = "cat /proc/uptime | awk '// { printf \"%d Tag(e) - %02d:%02d Stunden\", $1/86400, $1/3600%24, $1/60%60 }'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("Laufzeit").State (dom.GetObject (s_cuxd # "CMD_RETS").State());

Skript RAM – Nutzung

! Ram-Nutzung
string s_cmd = "free -m | awk 'FNR == 2 { printf \"%d MiB/%d MiB (%d%)\",  ($3-$7)*-1, $2, ($3-$7)/$2*100*-1}'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("RAM-Nutzung").State (dom.GetObject (s_cuxd # "CMD_RETS").State());

Skript Temperatur Raspberry

! Temperatur
string s_cuxd = "CUxD.CUX2801001:3.";
string s_cmd = "/usr/bin/vcgencmd measure_temp | awk '// { printf substr($1, length($1) -5, 4)}'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("Temperatur Raspberry").State (dom.GetObject (s_cuxd # "CMD_RETS").State().ToString(2)#" °C");

Komplettes Skript mit allen Daten

! Servicedaten der HomeMatic sammeln ########################################
! Temperatur
string s_cuxd = "CUxD.CUX2801001:3.";
string s_cmd = "/usr/bin/vcgencmd measure_temp | awk '// { printf substr($1, length($1) -5, 4)}'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("Temperatur Raspberry").State (dom.GetObject (s_cuxd # "CMD_RETS").State().ToString(2)#" °C");

! Laufzeit
string s_cmd = "cat /proc/uptime | awk '// { printf \"%d Tag(e) - %02d:%02d Stunden\", $1/86400, $1/3600%24, $1/60%60 }'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("Laufzeit").State (dom.GetObject (s_cuxd # "CMD_RETS").State());

! Ram-Nutzung
string s_cmd = "free -m | awk 'FNR == 2 { printf \"%d MiB/%d MiB (%d%)\",  ($3-$7)*-1, $2, ($3-$7)/$2*100*-1}'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("RAM-Nutzung").State (dom.GetObject (s_cuxd # "CMD_RETS").State());

! CPU-Nutzung
string s_cmd = "top -b -n 1 | egrep 'CPU' |  awk 'NR==1 {printf \"%d%s\", $2, \"%\"}'";
dom.GetObject (s_cuxd # "CMD_SETS").State (s_cmd);
dom.GetObject (s_cuxd # "CMD_QUERY_RET").State (1);
dom.GetObject ("CPU-Auslastung").State (dom.GetObject (s_cuxd # "CMD_RETS").State());

Ich lasse diese Skript bei mir alle 10 Minuten ausführen.

Um Variablen auf der Startseite der HomeMatic anzeigen zu lassen, sind folgende Schritte notwendig.