Schlagwort-Archive: Shelly

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

Radiowelle

Shelly mit Hilfe eines NFC Tag schalten

Du hast für Dein Schlafzimmer einen Shelly 1 oder gar Shelly 2.5 (für Decken- und Stehleuchte) eingebaut? Dann stellt sich beim Schlafen gehen meistens die Frage: “Licht aus? Handy-Taschenlampe an!”, damit Du nicht über Dinge, die am Boden liegen, stolperst? Oder gar: Nachttischlampe an, wieder zurück zum Schalter, diesen ausschalten und erneut den Weg Richtung Bett antreten.

Das geht auch einfacher!

Benötigt werden:

Einrichtung des Makros in MacroDroid

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 “Licht Schlafzimmer” 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.

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

http://IP-DEINES-SHELLY/relay/0?turn=toggle

Die Variable “turn” steht hier auf toggle. Das heißt, das bei jedem Aufruf der Status geändert wird: An -> Aus, Aus -> An. Diese kannst Du auch verwenden, um das Licht immer nur aus oder nur an zuschalten.

Für an:
http://IP-DEINES-SHELLY/relay/0?turn=on

Für aus:
http://IP-DEINES-SHELLY/relay/0?turn=off

Nach dem Speichern des Makros kannst Du den NFC Tag direkt testen.

Schalter

Shelly Fensterkontakt schaltet Plug-S, Shelly 1 oder Shelly 2.5

Ist Dir schon mal aufgefallen, das die Schaltvorgänge über die Szenen mit der Shelly App ziemlich lange (>3 Sekunden) dauern? Dies resultiert aus der Cloud-Verbindung. Die Szene wird in der Cloud gespeichert und so muss der Auslöser seinen Status in die Cloud senden, die Cloud verarbeitet das Skript und aktiviert dann den jeweiligen Aktor.
Das geht auch schneller!

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.

Mit diesem Skript kannst Du einen Shelly Fensterkontakt als Auslöser nutzen und z.B. einen Shelly Plug S, Shelly 1 oder Shelly 2.5 schalten.

Skripte für ioBroker

Shelly Plug-S

on({id: "shelly.0.SHWND-S#XXXXXX5#1.open", change: "ne"}, function (obj) {
    setState("shelly.0.SHPLG-S#DE69XX#1.Relay0.Switch",obj.state.val);
});

Shelly 1

on({id: "shelly.0.SHWND-S#XXXXXX5#1.open", change: "ne"}, function (obj) {
    setState("shelly.0.SHSW-PM#765BXX#1.Relay0.Switch",obj.state.val);
});

Shelly 2.5

on({id: "shelly.0.SHWND-S#XXXXXX5#1.open", change: "ne"}, function (obj) {
    setState("shelly.0.SHSW-25#F3FXXB#1.Relay0.Switch",obj.state.val);
});

In Zeile 2 bitte darauf achten, den richtigen Schaltpunkt auszuwählen.

Nun werden die Shelly Geräte durch den Status des Fensterkontaktes geschaltet.

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);
    }  
});
Fernbedienung

Shelly RGBW mit Shelly Plug-S synchronisieren

Ich steuere bei mir hinter dem TV eine LED Lichtleiste mit einem Shelly RGBW2 an. Damit nun auch die Vitrinenbeleuchtung im Schrank nebenan mit eingeschaltet wird, habe ich diese noch über einen Shelly Plug-S angeschlossen.

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.

Per Javascript abonniere ich nun den Schaltzustand der LED Beleuchtung hinter dem TV und übertrage sie auf den Shelly Plug-S.

//Skript zum Synchronisieren des Shelly Plug-S im Wohnzimmer
var master = "shelly.0.SHRGBW2#6F65XX#1.color";
var slave_1 = "shelly.0.SHPLG-S#51D5XX#1.Relay0";

on({id: master+".Switch", change: "any"}, function (obj) 
{
    //Zustand des 1. Slave Shelly setzen
    setState(slave_1+".Switch", obj.state.val);
});
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.

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.

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
Puzzle

Shelly Schalter in HomeMatic integrieren

Um einen Shelly per HomeMatic schalten zu können, benötigt man CUxD (40) 16-Kanal Universalsteuerung als Schalter.

Vorbereitung

CuX Gerät erstellen
CuX Gerät erstellen

Pro Shelly Kanal (Shelly 1(PM) -> 1 Kanal, Shelly 2.5PM -> 2 Kanäle) wird ein Kanal der Universalfernbedienung benötigt.
Die einzelnen Kanäle können in der Geräte Übersicht verschieden benannt werden und auch den einzelnen Räumen zugeordnet werden.

Geräte Einstellung

Als nächstes in die Geräte-Übersicht und das Gerät einstellen.

CuX Gerät bennen und Raum zuordnen
CuX Gerät bennen und Raum zuordnen

Per Klick auf Einstellen erreicht man die Einstellungen des Gerätes.

Parameter für den CuX Schalter anpassen
Parameter für den CuX Schalter anpassen

Einstellung für SWITCH|CMD_SHORT:

wget -q -O - 'http://192.168.2.31/relay/0?turn~3doff'

Einstellung für SWITCH|CMD_LONG:

wget -q -O - 'http://192.168.2.31/relay/0?turn~3don'

Hierbei ist zu beachten, das die IP-Adresse des Shelly’s angepasst wird.

Da das CuX Gerät als Schalter definiert ist, bleibt der Ein- und Aus Zustand hinterlegt. Da aber der Shelly auch am physischen Schalter/Taster oder per App geschaltet werden kann, bekommt die HomeMatic dies natürlich nicht mit. Dazu verhelfen wir uns einer Funktion, die in der Shelly Web-Oberfläche integriert ist: Actions.

Der Shelly übermittelt so beim Betätigen des physischen Schalters, als auch beim Schalten per App den richtigen Status an die HomeMatic.

Shelly Action Konfiguration

Dazu rufen wir die Web-Oberfläche des Shelly mit seiner IP Adresse im Browser auf.

Einstellungen des Shelly auf der Weboberfläche
Einstellungen des Shelly auf der Weboberfläche

Url to be hit when the button is switched ON:

http://192.168.2.20:8181/x.exe?Antwort=dom.GetObject("CUxD.CUX4000001:1.SET_STATE").State(1)

Hier bitte auch wieder die Adresse der HomeMatic anpassen.
Die ID (CUX4000001) des CuX ist die, die oben angelegt wurde.
State(1) besagt, das der Status auf wahr (true) gesetzt wird.

Url to be hit when the button is switched OFF:

http://192.168.2.20:8181/x.exe?Antwort=dom.GetObject("CUxD.CUX4000001:1.SET_STATE").State(0)

Hier auch wieder die Adresse der HomeMatic anpassen. Das State(0) am Ende besagt, das der Status auf falsch (false) gsetzt wird.

Mit diesen Daten können wir den Schalter nun von allen Stellen (HomeMatic, Shelly App/Cloud und physischer Schalter) aus- und einschalten.

Es kann vorkommen, dass der Shelly den Status in der HomeMatic manchmal nicht aktualisiert. Dies kann der Fall sein, wenn der Shelly seine Mitteilung senden möchte, die HomeMatic aber gerade “blockiert” ist und die Anfrage nicht bearbeitet.
Hier habe ich mir eines kleinen Programms beholfen, welches alle 30 Sekunden ausgeführt wird und so den Status aller Shelly’s abholt und den jeweiligen CuX Geräten zuweist. Es ist nicht notwendig, für jeden Shelly ein eigenes Programm ausführen zu lassen.

Hilfsprogramm zur Aktualisierung des Shelly in der HomeMatic

Damit dieses Programm funktioniert, benötigt man ein CuX Exec (28) Gerät.

CuX Exec Gerät erstellen
CuX Exec Gerät erstellen
Shelly Status Aktualisierung in der HomeMatic
Shelly Status Aktualisierung in der HomeMatic
! Statusaktualisierung von Shelly-Aktoren ###################
! Statusaktualisierung von Shelly-Aktor Schlafzimmer Schrankbeleuchtung
var url = "http://192.168.2.31/relay/0/status";
var cux_device = "CUxD.CUX4000001:1";
var cux_exec = "CUxD.CUX2801001:2";

dom.GetObject(""#cux_exec#".CMD_SETS").State("wget -q -O - '"#url#"'");
dom.GetObject(""#cux_exec#".CMD_QUERY_RET").State(1);
string Status = dom.GetObject(""#cux_exec#".CMD_RETS").State();
dom.GetObject(""#cux_exec#".CMD_SETS").State("0");  
if (Status.Contains("\"ison\":false")) {
  dom.GetObject(""#cux_device#".SET_STATE").State(0);
}
if (Status.Contains("\"ison\":true")) {
  dom.GetObject(""#cux_device#".SET_STATE").State(1);
}

Als Zeitsteuerung verwende ich die der HomeMatic.
Ausführung ganztägig/alle 30 Sekunden.

Hier bitte folgende Daten anpassen:

var url = "http://192.168.2.31/relay/0/status"; <- Adresse des Shelly
var cux_device = "CUxD.CUX4000001:1"; <- ID und Kanal des CuX Gerätes für den Shelly
var cux_exec = "CUxD.CUX2801001:2"; <- Das System-Exec Gerät.

Darauf achten, das hier der Kanal angepasst wird, wenn man mehrere Exec Geräte in anderen Skripten ausführen lässt.
Zum Beispiel:
Kanal 2: Aktualisierung der Shellys

Das Skript kann man nun mehrmals in das Programm kopieren und somit den Status von allen Shellys abholen lassen. Der Kanal des System Exec kann für alle Shellys verwendet werden. Da der Kanal nach jeder Abarbeitung wieder freigegeben wird, besteht hier auch keine Gefahr, das der Kanal “besetzt” ist und mit anderen Ausführungen kollidiert.