Schlagwort-Archive: Adapter

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

Update

ioBroker Adapter aktualisieren

ioBroker wird ständig weiterentwickelt und so kommt es vor, das auch die Adapter neue Versionen zur Verfügung stellen. Diese bieten meist Fehlerbehebungen, als auch neue Funktionen an, die implementiert wurden.

Adapter auf der Weboberfläche aktualisieren

Über den Adapter Bereich in ioBroker lässt sich der Filter für die Adapter setzen, die aktualisiert werden können.

Aktualisierbare Adapter in ioBroker
Aktualisierbare Adapter in ioBroker

Danach kannst Du über den Pfeil vor der neuen Versionsnummer den Adapter auf die neue Version aktualisieren. Beachte bitte, das der Adapter danach automatisch neu gestartet wird. Wenn mehrere Adapter zu aktualisieren sind, so kannst auf die Flagge klicken und es werden alle Adapter nacheinander aktualisiert.

Alle Adapter aktualisieren
Alle Adapter aktualisieren
Code

ioBroker Skript zur Anzeige der Node Version

Mit diesem Skript lässt sich ein Datenpunkt erstellen, der die aktuell installierte Node Version anzeigt. Ich lasse es nachts um 3:01 Uhr einmalig ausführen. Somit wird der Stand aktualisiert, sollte man tagsüber die Node aktualisiert haben.

Man erstellt das Skript unter einem beliebigen Namen im “common” – Bereich des Skript-Editors.

var pfad = "Systeminfos.ioBroker" + ".";
var abfrage = "node -v";
var DataPoint = pfad + 'node_Version';
createState(DataPoint, "", {
    name: 'node Version',
    desc: 'node Version (abgefragt mit node -v)',
    type: 'string',
    unit: '',
    role: 'value'
});
function node() {
    exec(abfrage,
        function (error, stdout, stderr) {
            setState(DataPoint, stdout);
        });
}
// Abfrage nachts um 03:01 Uhr
schedule('1 3 * * *',node);

Nachdem das Skript aktiviert ist, steht die Version im Datenpunkt:

// javascript 0 bei nur einer installierten Skript - Instanz
javascript.0.Systeminfos.ioBroker.node_Version

Hierbei ist zu beachten, dass die Version nachts um 3:01 Uhr eingetragen wird.

Solltest Du eine vorherige Anzeige benötigen, so kannst Du das Skript erweitern und einmal den Funktionsaufruf mit einfügen.

var pfad = "Systeminfos.ioBroker" + ".";
var abfrage = "node -v";
var DataPoint = pfad + 'node_Version';
createState(DataPoint, "", {
    name: 'node Version',
    desc: 'node Version (abgefragt mit node -v)',
    type: 'string',
    unit: '',
    role: 'value'
});
function node() {
    exec(abfrage,
        function (error, stdout, stderr) {
            setState(DataPoint, stdout);
        });
}
node(); //Hier findet der Funktionsaufruf einmalig statt und füllt den Datenpunkt
// Abfrage nachts um 03:01 Uhr
schedule('1 3 * * *',node);
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);
     }
 });
Alexa

Dynamische Alexa-Ausgabe auf verschiedene Echos mit ioBroker und JavaScript

Wenn Du wie ich mehrere Alexa – Geräte dein Eigen nennst, dann wirst Du sie wahrscheinlich entsprechend – je nach Raum – oder Standort benannt haben. So ist ja eine eindeutige Identifikation möglich. Wenn Du nun aber im Alexa Adapter für ioBroker schaust, sind die Namen mehr als nicht identifizierbar.

Alexa Adapter installieren

Installation des Alexa 2 Adapter
Installation des Alexa 2 Adapter

Alexa Geräte in der Alexa App

Alexa Geräte in der Alexa App (hier Android)
Alexa Geräte in der Alexa App (hier Android)

Alexa Geräte in ioBroker identifizieren

Alexa Geräte im Alexa Adapter
Alexa Geräte im Alexa Adapter

Wie im oberen Bild ersichtlich, habe ich meine Echo’s entsprechend ihrer Räumlichkeiten benannt. So kann ich mir leichter merken, welcher Echo, wo steht. Da aber der Zugriff auf den jeweiligen Echo via dem Datenpunkt, der ziemlich kryptisch ist, erfolgt, lässt sich dies in einem Skript zwar “vormerken”, kann sich aber auch ändern, wenn Amazon einmal seine Datenstruktur ändern würde. Dein festgelegter Name des Echo’s bleibt immer gleich.

Dynamisches Skript für die Ausgabe erstellen

In dem nachfolgenden Skript habe ich meine Echo’s in ein Array gelegt, da ich diese so auch aus HomeMatic ansprechen kann. Dazu aber später mehr. Das Skript muss zwingend im Bereich global abgelegt werden, da sonst andere Skripts nicht auf die Funktion zugreifen können. In dem Array gibt es den Wert Überall dieser wird von Amazon automatisch angelegt und bedeutet, das jeder Echo, der in Deinem Konto verbunden ist, zu dieser Gruppe gehört.

function Alexa_sprechen(geraet,text) {
     // Echo Array
     var echos = ['kein Gerät','Fire TV Cube','Echo Dot Küche',
     'Echo Dot Schlafzimmer','Echo Dot Flur','Wohnung','Überall'];
     // Finde das passende Gerät im Array
     var echo = echos[geraet];
     // Echo für Ausgabe gefunden, suche Datenpunkt ID
     var Echo_Ausgabe = getIdByName(echo,true);
     // Da das Gerät auch in der Histoy erscheinen kann, liefert das Skript
     // manchmal ein Array zurück.
     // Wir erzwingen die Ausgabe als Array mit dem Wert 'true'.
     // Somit lesen wir den 1. Wert aus dem Array, welcher immer das richtige Gerät ist.
     Echo_Ausgabe = Echo_Ausgabe[0];
     // Datenpunkt nicht gefunden. Abbruch.
     if (!Echo_Ausgabe) {
         log("Alexa-Ausgabe: Es liegt ein Fehler vor. Das Gerät wurde nicht gefunden!");
     } else {
         if (text!="") {
             setState(Echo_Ausgabe + '.Commands.speak', text);
             log ("Ausgabe auf: " + echo + " | Text: " + text);  
         } else {
             log ("Alexa-Ausgabe: Alexa sollte einen leeren Text sprechen!");
         }
     }
 }

Da das Skript im Ordner global liegt, können andere Skripte nun die Funktion
Alexa_sprechen(geraet,text); verwenden.
Die Ausgabe auf dem Echo Dot Küche wäre nun:

Alexa_sprechen(2, "Viel Spaß beim Kochen!");

Das Gerät ist 2, da in der Programmierungen Indizes immer bei 0 starten. Da 2 eine Zahl ist, muss diese ohne “-Zeichen angegeben werden, weil sie sonst als Text (String) erkannt wird. Der Text dahinter muss in “-Zeichen, da er als Text (String) verarbeitet werden soll.

Eine Ausgabe auf allen Echos wäre demzufolge:

Alexa_sprechen(6, "Das Essen ist fertig!");

Hier verwenden wir das 6. Gerät, da es das 7. in der Array Liste ist.

Im nächsten Schritt geht es um die Ausgabe von Information (Werte aus Geräten und Variablen) aus HomeMatic.
Dazu habe ich Dir diesen Beitrag erstellt.

Zeitsteuerung

Zeitgesteuerte Schaltungen, Zeitsteuerungen & Intervallschaltungen mit JavaScript in ioBroker

In einem vergangenen Beitrag hast Du bereits die Ereignissteuerungen kennengelernt. Hier geht es nun um die zeitgesteuerten Ereignisse in JavaScript. Zeitgesteuerte Ereignisse sind die, die nicht von einem Gerät, sondern von einem Zeitpunkt oder Zeitintervall ausgelöst werden.

Zeitgesteuerte Schaltung

Damit nun auch, wie eingangs erwähnt, der Zeitpunkt der Auslöser ist kann man natürlich eine Zeitsteuerung in HomeMatic nutzen. Was aber, wenn das Gerät nicht zu HomeMatic gehört oder vielleicht keine eigene Zeitsteuerung hat? Hier lässt sich mit wenig Aufwand eine Zeitsteuerung in JavaScript realisieren.

schedule({hour: 20, minute: 00}, TV_taeglich_an );
  
 function TV_taeglich_an() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }

Über den Parameter schedule wurde nun die Zeitsteuerung für hour und minute aktiviert. Hier wird zeitgesteuert das TV täglich um 20 Uhr eingeschaltet.

Zeitgesteuerte Schaltung nur an einem bestimmten Tag

Möchte man nun, dass das Skript nur an einem bestimmten Tag ausgeführt wird, so bedient man sich dem Parameter dayOfWeek. Dieser erwartet eine oder mehrere Zahlen.

schedule({hour: 20, minute: 00, dayOfWeek: 0}, TV_nur_Sonntag_an );
  
 function TV_nur_Sonntag_an() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }

In der Programmierung fangen die Zahlen oder Indizes mit 0 an – somit ist auch hier die erste Zahl eine 0 – aber ein Sonntag.

ZahlWochentag
0Sonntag
1Montag
2Dienstag
3Mittwoch
4Donnerstag
5Freitag
6Samstag
Belegung der Wochentage

Zeitgesteuerte Schaltung an bestimmten Tagen

Mit diesem leicht modifizierten Skript, lässt sich die Schaltung auf die Tage 1-5 (Montag bis Freitag) eingrenzen. Dazu wird jeder Tag durch Komma getrennt in eckige Klammern eingegeben.

schedule({hour: 20, minute: 00, dayOfWeek: [1,2,3,4,5]}, TV_nur_Mo_Fr_an );
  
 function TV_nur_Mo_Fr_an() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }

Intervallschaltungen

Minütliche Intervallschaltungen

In diesem Skript lassen wir ein Skript jede Minute ausführen. Dazu benutzen wir den Parameter second und geben ihm den Wert 00.

schedule({second: [00]}, Jede_Minute );
  
 function Jede_Minute() {
   log("Skript wird jede Minute ausgeführt!");
 }

Zeitsteuerung alle 30 Minuten

Hier bedienen wir uns des Parameters minute und geben ihm die Werte 00 und 30. Dies wäre dann jede halbe Stunde. 15:00 und 15:30.

schedule({minute: [00,30]}, Alle_30_Minuten );
  
 function Alle_30_Minuten() {
   log("Skript wird alle 30 Minuten ausgeführt!");
 }

Zeisteuerung jede Stunde

Um ein Skript jede Stunde ausführen zu lassen, kann man dies auch wieder über den minute Parameter einrichten. Man gibt ihm den Wert 00.

schedule({minute: [00]}, Jede_Stunde );
  
 function Jede_Stunde() {
   log("Skript wird jede Stunde ausgeführt!");
 }

Schaltung mit Sonnenaufgang und -untergang

Normale Schaltung

Es lassen sich mit JavaScript auch Schaltungen zu astronomischen Ereignissen ausführen. Diese Schaltung schaltet täglich das TV zum astronomischen Sonnenaufgang ein.

schedule({astro: "sunrise"}, TV_bei_Sonnenaufgang_ein );
  
 function TV_bei_Sonnenaufgang_ein() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }

… und dieses schaltet das TV zum astronomischen Sonnenuntergang wieder aus.

schedule({astro: "sunset"}, TV_bei_Sonnenuntergang_aus );
  
 function TV_bei_Sonnenuntergang_aus() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", false);
 }

Für astro stehen folgende Werte zur Verfügung:

WertBeschreibung
sunriseSonnenaufgang (Oberkante der Sonne erscheint am Horizont)
sunriseEndSonnenaufgang endet (unterer Rand der Sonne berührt den Horizont)
goldenHourEndDie goldene Morgenstunde (weiches Licht, beste Zeit für Fotografie) endet
solarNoonSonnenmittag (Sonne steht am höchsten)
goldenHourDie goldene Abendstunde beginnt
sunsetStartSonnenuntergang beginnt (unterer Sonnenrand berührt den Horizont)
sunsetSonnenuntergang (Sonne verschwindet unter dem Horizont, abendliche zivile Dämmerung beginnt)
duskAbenddämmerung (abendliche nautische Dämmerung beginnt)
nauticalDusknautische Dämmerung (abendliche astronomische Dämmerung beginnt)
nightNacht beginnt (dunkel genug für astronomische Beobachtungen)
nightEndDie Nacht endet (die astronomische Dämmerung am Morgen beginnt)
nauticalDawnnautische Morgendämmerung (morgendliche nautische Dämmerung beginnt)
dawnMorgendämmerung (die nautische Dämmerung am Morgen endet, die zivile Dämmerung am Morgen beginnt)
nadirdunkelster Moment der Nacht, Sonne steht am niedrigsten
Werte der Variable astro

Schaltung mit Verzögerung/vorzeitigem Eintritt bei Sonnenaufgang und -untergang

Wenn der genaue Zeitpunkt für Sonnenaufgang oder -untergang zu früh oder zu spät eintritt, so lässt sich mit dieser Modifikation eine Verzögerung oder ein vorzeitiger Eintritt der Ausführung einrichten.

Dieses Skript schaltet das TV 10 Minuten nach dem Sonnenaufgang ein.

schedule({astro: "sunrise", shift: 10}, TV_bei_Sonnenaufgang_ein );
  
 function TV_bei_Sonnenaufgang_ein() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }

… und dieses schaltet das TV 10 Minuten vor dem Sonnenuntergang aus.

schedule({astro: "sunset", shift: -10}, TV_bei_Sonnenaufgang_ein );
  
 function TV_bei_Sonnenaufgang_ein() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", false);
 }

Schaltung mit Verzögerung an einem bestimmten Tag

Schaltungen mit der Astrofunktion lassen sich auch nur an bestimmten Wochentagen ausführen. Hier wird das Licht 10 Minuten nach Sonnenaufgang an einem Samstag eingeschaltet.

schedule({astro: "sunrise", shift: 10, dayOfWeek:6}, TV_bei_Sonnenaufgang_ein_nur_Samstag );
  
 function TV_bei_Sonnenaufgang_ein_nur_Samstag() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }

Schaltung mit Verzögerung an bestimmten Tagen

Schaltungen mit der Astrofunktion lassen sich auch nur an mehreren Wochentagen ausführen. Hier wird das Licht an Samstag und Sonntag 10 Minuten nach dem Sonnenaufgang eingeschaltet.

schedule({astro: "sunrise", shift: 10, dayOfWeek:[0,6]}, TV_bei_Sonnenaufgang_ein_nur_Wochenende );
  
 function TV_bei_Sonnenaufgang_ein_nur_Wochenende() {
   setState("hm-rpc.2.00085A499BF6D2.4.STATE", true);
 }
Events

ioBroker Ereignisse (Events) mit JavaScript überwachen

Eine Haus-Automatisierung ist im groben Prinzip eine Verkettung von “wenn -> dann” Abfolgen. Z.B. Wenn Schalter betätigt, dann Licht an; Wenn 20 Uhr abends jeden Tag, dann TV an. Viele dieser Funktionen lassen sich mit direkten Verknüpfungen innerhalb einer Gerätefamilie einrichten. Andere hingegen lassen sich über einen kleinen Umweg auch geräteübergreifend realisieren.

HomeMatic Aktor mit HomeMatic Schalter/Taster schalten

Eine schöne Art und Weise zum Schalten ist die direkte Verknüpfung zwischen einem HomeMatic Schalter und einem Aktor. Dieser lässt sich in der HomeMatic konfigurieren.

Direkte Verknüpfung in HomeMatic
Direkte Verknüpfung in HomeMatic

ioBroker Gerät/Datenpunkt mit HomeMatic Schalter/Taster schalten

Möchtest Du nun aber ein anderes Gerät mit einem HomeMatic Schalter/Taster schalten, so ist dies mit der HomeMatic nicht so einfach möglich. Klar, für manche Geräte gibt es Workarounds o.ä. Eine elegantere Lösung stellt hier das JavaScript in ioBroker dar, denn dieses kann plattformunabhängig reagieren. Als Beispiel möchte ich jetzt mit einem HomeMatic Schalter meinen Onkyo Receiver (über Onkyo Adapter verbunden) mit dem Taster einschalten.

on({id: 'hm-rpc.0.OEQ0613813.1.PRESS_SHORT', change: 'any'}, function(obj) {
    setState("onkyo.0.Zone1.Power", true);
 });

Über den Parameter on in der ersten Zeile lassen sich Datenpunkte “abonnieren”. Mit dem nächsten Parameter change lässt sich JavaScript anweisen, wie es auf Änderungen reagieren soll. Dazu ist in der nächsten Tabelle ersichtlich, welche Werte verwendet werden können.

WertBeschreibung
anyTrigger wird immer ausgeführt
eqDer neue Wert muss gleich dem Alten sein
geNeuer Wert muss größer oder gleich groß sein
gtNeuer Wert muss größer als der alte Wert sein
leNeuer Wert muss kleiner oder gleich groß sein
ltNeuer Wert muss kleiner als der alte sein
neDer neue Wert muss nicht gleich dem Alten sein (Standard)
Übersicht der change Parameter

Sollten Dich zeitgesteuerte Schaltungen auch interessieren, so findest du hier meinem Beitrag zu dem Thema.

RGB

Shelly RGBW2 synchronisieren

Wenn du z.B. mehrere Shelly RGBW2 Dein Eigen nennst, ist es in manchen Situationen toll, wenn diese die RGB-Streifen synchron schalten würden. Hast Du z.B. in Deinem Wintergarten mehrere RGB-Streifen installiert und sie alle mit einem Shelly RGBW2 ausgestattet, so macht es dort natürlich Sinn, wenn alle Farben gleich sind.

Somit kannst Du einen Shelly RGBW2 als “Master” festlegen, der seine Farbwerte an die anderen RGBW2 weitergibt und zusätzlich die “Slave” Shelly aus- und einschaltet.

Als Raffinesse, wird noch die Helligkeit am Ende des Skriptes in alle Shelly synchronisiert.

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 zur Synchronisation

Datenpunkt des Master & der Slave Shelly
Datenpunkt des Master & der Slave Shelly
//Skript zum Synchronisieren des Shelly RGBW2
 var master = "shelly.0.SHRGBW2#6F65EB#1.color";
 
 //Hier den Datenpunkt des 1. Slave Shelly eingeben
 var slave_1 = "shelly.0.SHRGBW2#6F65AB#1.color";
 
 //Hier den Datenpunkt des 2. Slave Shelly eingeben
 var slave_2 = "shelly.0.SHRGBW2#6F65BB#1.color";
 
 //Hier den Datenpunkt des 3. Slave Shelly eingeben
 var slave_3 = "shelly.0.SHRGBW2#6F65CB#1.color";
 
 //Reagiere auf die Farbe des Master Shelly bei jedem Wechsel
 on({id: master+".rgbw", change: "any"}, function (obj) 
 {
     //Farbe des 1. Slave Shelly setzen
     setState(slave_1+".rgbw", obj.state.val);
     
     //Farbe des 2. Slave Shelly setzen
     setState(slave_2+".rgbw", obj.state.val); 
     
     //Farbe des 3. Slave Shelly setzen
     setState(slave_3+".rgbw", obj.state.val);
 });
 
 //Reagiere auf ein- und ausschalten des Master
 on({id: master+".Switch", change: "any"}, function (obj) 
 {
     //Zustand des 1. Slave Shelly setzen
     setState(slave_1+".Switch", obj.state.val);
     
     //Zustand des 2. Slave Shelly setzen
     setState(slave_2+".Switch", obj.state.val); 
     
     //Zustand des 3. Slave Shelly setzen
     setState(slave_3+".Switch", obj.state.val);
 });
 
 //Reagiere auf die Helligkeit des Master
 on({id: master+".gain", change: "any"}, function (obj) 
 {
     //Helligkeit des 1. Slave Shelly setzen
     setState(slave_1+".gain", obj.state.val);
     
     //Helligkeit des 2. Slave Shelly setzen
     setState(slave_2+".gain", obj.state.val); 
     
     //Helligkeit des 3. Slave Shelly setzen
     setState(slave_3+".gain", obj.state.val);
 });
 

Nicht benötigte Datenpunkte im Skript kannst Du mit // vor der jeweiligen Zeile auskommentieren oder einfach löschen.

Update

ioBroker Skript zur Anzeige der benötigten System Updates des Raspberry Pi

Mit diesem Skript lässt sich ein Datenpunkt erstellen, der die Anzahl der aktuell verfügbaren System Updates des Raspberry Pi anzeigt. Ich lasse es nachts um 00:01 Uhr einmalig ausführen. Somit wird der Stand aktualisiert, sollten tagsüber neue System Updates heraus gekommen sein.

Man erstellt das Skript unter einem beliebigen Namen im “common” – Bereich des Skript-Editors.

// Skript, um SystemUpdates des HostSystems anzuzeigen
var pfad = "Systeminfos.ioBroker" + ".";
var apt_update = "sudo apt update";
var abfrage = "apt list --upgradable 2>/dev/null | wc -l | awk '{print $S1-1}'";
var DataPoint = pfad + 'raspi_updates';
createState(DataPoint, "", {
    name: 'Raspi Updates',
    desc: 'Systemupdates für den Raspi',
    type: 'string',
    unit: '',
    role: 'value'
});
function check_for_updates() {
    exec(apt_update);
    exec(abfrage,
        function (error, stdout, stderr) {
            var value = stdout;
            if (value == '') {
                value = '0';
            } else {
                value = stdout;
            }
            setState(DataPoint, value);
        });
}
// Abfrage nachts um 00:01 Uhr
schedule('1 0 * * *',check_for_updates);

Nachdem das Skript aktiviert ist, steht die Version im Datenpunkt:

// javascript 0 bei nur einer installierten Skript - Instanz
javascript.0.Systeminfos.ioBroker.raspi_updates

Hierbei ist zu beachten, dass die Anzahl der verfügbaren Updates nachts um 00:01 Uhr eingetragen wird.

Sollte man eine vorherige Anzeige benötigen, so kann man das Skript erweitern und einmal den Funktionsaufruf mit einfügen.

// Skript, um SystemUpdates des HostSystems anzuzeigen
var pfad = "Systeminfos.ioBroker" + ".";
var apt_update = "sudo apt update";
var abfrage = "apt list --upgradable 2>/dev/null | wc -l | awk '{print $S1-1}'";
var DataPoint = pfad + 'raspi_updates';
createState(DataPoint, "", {
    name: 'Raspi Updates',
    desc: 'Systemupdates für den Raspi',
    type: 'string',
    unit: '',
    role: 'value'
});
function check_for_updates() {
    exec(apt_update);
    exec(abfrage,
        function (error, stdout, stderr) {
            var value = stdout;
            if (value == '') {
                value = '0';
            } else {
                value = stdout;
            }
            setState(DataPoint, value);
        });
}
check_for_updates(); //Hier findet der Funktionsaufruf einmalig statt und füllt den Datenpunkt
// Abfrage nachts um 00:01 Uhr
schedule('1 0 * * *',check_for_updates);
Farbwechsel

Shelly RGBW2 in ioBroker VIS: Farbwechsel

Wer einen Shelly RGBW2 sein eigen nennt, steuert diesen wohl mehr oder weniger mit der App oder gar mit Alexa, um seine Farbe einzustellen. Damit man jedoch auch die Farbe auf einer Tablet Visualisierung einstellen kann, kann man VIS nutzen.

Shelly Adapter in ioBroker installieren

Hierzu installiert man den Adapter Shelly in ioBroker

Shelly in ioBroker installieren
Shelly in ioBroker installieren
Konfiguration des Shelly Adapters
Konfiguration des Shelly Adapters

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

Colorpicker Widget in ioBroker installieren

Hierzu installiert man einfach den Adapter color picker style Widgets in ioBroker.

Colorpicker in ioBroker installieren
Colorpicker in ioBroker installieren

Colorpicker in VIS auswählen

Nachdem die Widgets nun installiert wurden, gibt es einen neuen Bereich in VIS, hinter dem sich die 5 verschiedenen Colorpicker verbergen. Da der Shelly RGBW2 eher für hellere Farben konzipiert wurde, wähle ich das color RGBColor Widget aus und ziehe es auf meine View.

color RGBColor Widget auf die View ziehen
color RGBColor Widget auf die View ziehen

color RGB Spectrum ist fast ähnlich, zeigt aber auch die sehr dunklen Farben an. Hier ein Vergleich:

Es ist natürlich Geschmackssache, welches Widget Du verwenden möchtest. Von der Einstellung her sind sie beide gleich. Ich verwende im weiteren Verlauf das color RGBColor Widget.

Datenpunkte des Shelly RGBW2 dem Widget zuweisen

Die jeweiligen Datenpunkte des Shelly findest Du hier:
Rot: shelly.0.SHRGBW2#ID_DES_SHELLY#1.color.red
Grün: shelly.0.SHRGBW2#ID_DES_SHELLY#1.color.green
Blau: shelly.0.SHRGBW2#ID_DES_SHELLY#1.color.blue

Shelly Datenpunkte dem Widget zuweisen
Shelly Datenpunkte dem Widget zuweisen

Nun kannst Du dem Shelly seine Farben per VIS zuweisen

Widget-Ansicht in VIS

Farbzuweisung des Shelly über die VIS Oberfläche
Farbzuweisung des Shelly über die VIS Oberfläche
Diagramm

ioBroker VIS Bar Widget – farbige Visualisierung

In VIS gibt es standardmäßig ein Bar Widget, mit dem sich ein Füllbalken in einer Farbe darstellen lässt. Eine Farbe ist vielleicht nützlich, um den Fortschritt anzeigen zu lassen. Möchte man aber z.B. eine Auslastung anzeigen, die den Status “normal”, “erhöht” und “kritisch” visuell darstellen soll, stößt man mit einer Farbe schnell an seine Grenzen. Es sei denn, man legt den Balken 3 Mal mit verschiedenen Farben an und blendet ihn je nach Wert aus. Das geht auch einfacher!

Einfache Bar

Dazu legt man sich das Bar Widget auf die VIS und passt die entsprechenden Werte an.
Ich benutze hier den Datenpunkt von ioBroker, der den freien RAM in % anzeigt. Als Farbe habe ich rot gewählt und die Ausrichtung ist horizontal.

Einfache Bar mit Datenpunkt
Einfache Bar mit Datenpunkt

Bar mit dynamischer Farbe

Wie oben schon erwähnt, könnte man das Bar Widget nun 3 Mal an der gleichen Stelle positionieren und die Farben grün, gelb und rot für die Zustände normal, erhöht und kritisch nutzen und sie jeweils ausblenden. Das wäre natürlich machbar aber unsinnig, da VIS dies per JavaScript erledigen kann. Damit man nun auf einen Blick sehen kann, wie hoch die Auslastung ist und ob sich der Wert im Bereich normal, erhöht und kritisch befindet, kann man für sich selbst überlegen, welche Werte sinnvoll sind.

Ich würde hier empfehlen, das jeder Wert unter 50 als normal gilt, Werte bis 66 als erhöht und alles über 66 gilt als kritisch. Dies kann aber individuell angepasst werden. Um nun die Farbe dynamisch anpassen zu lassen, kopierst Du bitte folgendes in den Bereich Skripte in der View. Sollten Dir die Werte nicht zusagen, so kannst Du diese in den “Highlight”-Zeilen angegebenen Werte anpassen.

function colorBarHex(i)
 {
     var hex = "#3D993F";
 
     if ( i < 50 ) 
     {
         hex = "#3D993F"; // Grün
     }
     else
     {
         if ( i < 66 ) 
         {
             hex = "#FFCC00"; // Gelb
         }
         else
         {
             hex = "#D91616"; // Rot
         }
     }
     
     return hex; 
 }

Damit das Skript nun auch die richtige Farbe an das Bar Widget zurück gibt, muss dieses an den Farbwert gebunden werden. Als Farbwert setzen wir also folgenden Code:

{i:system.host.ioBroker.mem;colorBarHex(i)}

Die gschweiften Klammern sagen VIS, das es sich hier um eine Funktion handelt.
i ist hier eine temporäre Variable, der der Wert des Datenpunktes system.host.ioBroker.mem zugewiesen wird. colorBarHex() ist die JavaScript Funktion, die wir oben in den Bereich Skripte kopiert haben. Ihr wird der Parameter i übergeben.

Dynamische Bar mit Farbwechsel
Dynamische Bar mit Farbwechsel

Ansicht der Balken in VIS

So sehen die Balken dann in Aktion aus.

Dynamische Bar in Funktion
Dynamische Bar in Funktion