#shellyscripting

[draegerit]

Shelly Scripting – Shelly BLU Aktionen programmieren

Mit den Geräten der Shelly BLU Serie – vom BLU Button über den BLU Button Tough 1 bis hin zu BLU Motion oder dem BLU Door/Window Sensor – kannst du dein Smarthome per Bluetooth flexibel erweitern. Jeder Tastendruck oder Sensor-Event lässt sich in individuelle Aktionen übersetzen, die z. B. Relais schalten, Lampen aktivieren oder Abfragen an andere Geräte senden.

https://youtu.be/MCSYiK0NFRk

Für die meisten Anwendungsfälle reicht es, eine Szene mit dem Shelly Wizard zu erstellen – das geht schnell und ohne Programmierkenntnisse. Doch Szenen funktionieren in erster Linie innerhalb des Shelly-Ökosystems. Wenn du allerdings auch andere Geräte oder Dienste über REST-APIs ansteuern möchtest, die nicht Teil deines Shelly-Netzwerks sind, stößt du mit Szenen schnell an Grenzen.

Genau hier kommt Shelly Scripting ins Spiel: Mit einem eigenen Script kannst du die BLU Events flexibel auswerten und beliebige HTTP-Requests absetzen – egal ob an einen anderen Shelly, einen ESP32, ein Smarthome-Gateway oder einen Webservice.

Shelly BLU Button Tough 1

Shelly Blu Button 1

Shelly BLU Motion

Shelly BLU Door / Window

Shelly BLU H&T

In diesem Beitrag zeige ich dir, wie du am Beispiel des Shelly BLU Button ein Script erstellst, das Tastendrücke erkennt und daraufhin beliebige HTTP-Befehle ausführt. Das Script ist universell gehalten, sodass du es mit wenigen Anpassungen auch für andere Shelly BLU Geräte nutzen kannst.

Benötigte Hardware

Um die Aktionen mit Shelly Scripting umzusetzen, brauchen wir zunächst die passende Hardware:

- Shelly BLU Gerät Für dieses Beispiel nutze ich den bereits etwas älteren, aber immer noch sehr praktischen Shelly BLU Button 1. Er eignet sich hervorragend zum Testen, da er verschiedene Events wie Single, Double, Triple oder Long Press unterstützt. - Gateway für die BLU-Signale Damit die Signale des BLU Buttons im Netzwerk ankommen, benötigen wir ein Shelly BLU Gateway. Alternativ kann jedes andere Bluetooth-fähige Shelly Gerät der 2. Generation (oder neuer) als Gateway eingesetzt werden. Das bedeutet: auch ein Shelly Plus Plug S oder ein Shelly Pro Gerät mit aktiviertem BLE kann die Signale aufnehmen und im lokalen Netz verfügbar machen.

Damit haben wir die Grundausstattung, um die BLU-Events zu empfangen und anschließend mit unserem Script weiterzuverarbeiten.

Shelly BLU verbinden

Bevor wir mit dem eigentlichen Script starten, müssen wir den Shelly BLU Button (oder ein anderes BLU-Gerät) mit unserem Gateway koppeln. Dieser Schritt ist wichtig, damit die Signale zuverlässig erkannt und verarbeitet werden.

Eine ausführliche Schritt-für-Schritt-Anleitung zur Kopplung findest du in meinem YouTube Video:

https://youtu.be/2XsbCDfVOOM

Offizielle Vorlage von Shelly

Die Grundlage für dieses Projekt stammt aus der offiziellen Shelly Script Library. Dort findest du den ursprünglichen Blogbeitrag von Shelly mit einem Beispielscript für die Integration des Shelly BLU Button1:

🔗 Shelly Gen2 BLE Gateway Script for BLU Button1 Integration

In diesem Beitrag gehe ich einen Schritt weiter:

- Das Script ist vollständig kommentiert, - um einige praktische Funktionen erweitert (z. B. NONE-Konstante, flexible Logging-Funktion, HTTP-Queue mit Retry), - und lässt sich damit einfach für andere Shelly BLU Geräte (z. B. BLU Motion, BLU Door/Window Sensor oder BLU Button Tough 1) adaptieren.

So profitierst du von der offiziellen Basis, bekommst aber gleichzeitig eine auf Praxis ausgelegte Version, die sofort einsatzbereit ist.

Wie reagiert man auf Shelly BLU Aktoren wie Button, Button Tough, Door/Window und Motion?

In diesem Abschnitt zeige ich, wie du die wichtigsten Shelly BLU Aktoren mit dem Script nutzt. Die Basis ist immer gleich:

- BLU-Frames werden per BTHome v2 empfangen, - das Script dekodiert die Daten, - und löst je nach Event HTTP-Aktionen aus (CONFIG.actions).

Nachfolgend das gesamte Script welches alle drei Geräte behandelt, du musst hier lediglich deine MAC Adresse eintragen. Diese findest du in der Shelly Cloud oder der App Shelly Smart Control unter den Geräteinformationen.

ermitteln der MAC-Adresse eines Shelly BLU Gerätes Script für das reagieren auf Events von den BLU Button, Tough, Door/Window und Motion /* =========CHANGE HERE========= */ let CONFIG = { bluButtonAddress: "28:76:81:f9:69:6d", //the mac address of shelly blu button1 that will trigger the actions actions: { //urls to be called on a event //when adding urls you must separate them with commas and put them in quotation marks singlePush: , doublePush: , triplePush: , longPush: } }; /** =============================== STOP CHANGING HERE =============================== */ let urlsPerCall = 3; let urlsQueue = ; let callsCounter = 0; let ALLTERCO_MFD_ID_STR = "0ba9"; let BTHOME_SVC_ID_STR = "fcd2"; let uint8 = 0; let int8 = 1; let uint16 = 2; let int16 = 3; let uint24 = 4; let int24 = 5; let BTH = {}; BTH = { n: "pid", t: uint8 }; BTH = { n: "Battery", t: uint8, u: "%" }; BTH = { n: "Illuminance", t: uint24, f: 0.01 }; BTH = { n: "Door", t: uint8 }; BTH = { n: "Moisture", t: uint8 }; BTH = { n: "Window", t: uint8 }; BTH = { n: "Button", t: uint8 }; function getByteSize(type) { if (type === uint8 || type === int8) return 1; if (type === uint16 || type === int16) return 2; if (type === uint24 || type === int24) return 3; //impossible as advertisements are much smaller; return 255; } let BTHomeDecoder = { utoi: function (num, bitsz) { let mask = 1 5; if (ver!==2) return null; if (enc) return { encryption:true }; var buf = sd.slice(1); var out = { encryption:false, version:2 }; while (buf.length>0){ var id = buf.at(0), spec = BTH; if (!spec) break; // unbekannt → abbrechen (minimal) buf = buf.slice(1); var need = (spec.t===T.u8||spec.t===T.i8)?SZ.u8:(spec.t===T.u16||spec.t===T.i16)?SZ.u16:SZ.u24; var raw = readTyped(spec.t, buf); if (raw===null) break; var val = (typeof spec.f==="number") ? raw*spec.f : raw; out = val; buf = buf.slice(need); } return out; } /******************************************************/ /************* STATES *************/ var lastPid = -1; var lastTemp = null, lastHum = null; var tempState = "unknown"; // "low" | "normal" | "high" var humState = "unknown"; /**********************************/ /************* OPTIONAL: Werte pushen *************/ function pushValues(t, h, bat){ if (!CONFIG.push || !CONFIG.push.enabled) return; var url = CONFIG.push.urlBase + "?temp=" + t + "&hum=" + h + "&bat=" + bat; Shelly.call("HTTP.GET", { url:url, timeout: (CONFIG.push.timeoutSec||5) }, function(res, code, msg, ctx){ if (code===0) log("debug","PUSH OK", ctx.url); else log("warn","PUSH FAIL", ctx.url, msg); }, { url:url } ); } /**************************************************/ /************* GRENZWERTE + HYSTERESE *************/ function evalTemp(t){ var cfg = CONFIG.sensors && CONFIG.sensors.ht ? CONFIG.sensors.ht.temp : null; if (!cfg) return; var lowOn = cfg.low, lowOff = cfg.low + cfg.hyst; var highOn = cfg.high, highOff = cfg.high - cfg.hyst; if (tempState==="unknown"){ tempState = (t=highOn) ?

[draegerit]

Shelly Scripting – JavaScript-Grundlagen für Einsteiger: Arrays verstehen und anwenden

Arrays sind eine der einfachsten Möglichkeiten, mehrere Werte wie Zahlen oder Zeichenketten in einer Art Liste zu speichern. Jeder Eintrag hat dabei eine feste Position und kann über einen sogenannten Index angesprochen werden. Besonders praktisch ist das Zusammenspiel mit Schleifen: Damit lassen sich alle Elemente eines Arrays effizient durchlaufen – zum Beispiel, um sie auszugeben oder zu bearbeiten. In diesem Beitrag zeige ich dir, wie Arrays aufgebaut sind und wie du sie sinnvoll nutzen kannst. https://youtu.be/TRULc___5ps 📌 Tipp: Eine ausführliche Einführung in JavaScript-Grundlagen wie Variablen, Bedingungen und die verschiedenen Schleifenarten findest du in meinem Blogbeitrag:👉 Shelly Scripting – JavaScript-Grundlagen für Einsteiger: Variablen, Bedingungen & Logik verstehen 🎥 Zusätzlich gibt’s auf meinem YouTube-Kanal eine eigene Playlist, in der ich alle Themen Schritt für Schritt in einzelnen Videos erkläre. Was ist ein Array? Ein Array ist eine geordnete Sammlung von Werten, die unter einem gemeinsamen Namen gespeichert werden. Man kann sich ein Array wie eine Liste oder ein Regal mit nummerierten Fächern vorstellen – in jedem Fach liegt ein Wert. Diese Werte können zum Beispiel Zahlen oder Zeichenketten sein. Wichtig:Die Zählung (der sogenannte Index) beginnt bei 0, nicht bei 1! Das bedeutet: - Das erste Element eines Arrays hat den Index 0 - Das zweite Element den Index 1 - Und so weiter … Beispiel: Gemüse-Array let gemuese = ; In diesem Array haben wir vier Gemüsesorten gespeichert. Die Zuordnung sieht so aus: IndexWert0"Tomate"1"Gurke"2"Paprika"3"Karotte" Wenn du z. B. auf das erste Element zugreifen möchtest, schreibst du: print(gemuese); // Ausgabe: Tomate Und so greifst du auf das letzte Element zu: print(gemuese); // Ausgabe: Karotte Shelly Scripting - Arrays - Ausgabe von Werten aus dem Array Zugriff auf nicht vorhandene Elemente Wenn du in einem Array einen Index auswählst, für den kein Wert existiert, bekommst du als Ergebnis den speziellen Wert undefined. Das bedeutet, dass an dieser Stelle nichts gespeichert ist. Schauen wir uns das am Beispiel an: // IDX 0 IDX 1 IDX 2 IDX 3 let gemuese = ; print(gemuese); // Ausgabe: undefined In unserem Array sind nur vier Elemente enthalten, mit den Indizes 0 bis 3. Wenn du versuchst, auf gemuese zuzugreifen, also auf den fünften Platz, bekommst du undefined, weil dort kein Wert hinterlegt ist. 🔎 Tipp:Vor dem Zugriff kannst du mit einer Bedingung prüfen, ob der Index gültig ist: if (gemuese !== undefined) { print(gemuese); } else { print("An dieser Stelle gibt es kein Gemüse!"); } Shelly Scripting - Arrays - Zugriff auf nicht vorhandenen Index Die Länge eines Arrays mit length ermitteln Mit der Eigenschaft length kannst du herausfinden, wie viele Elemente sich aktuell in einem Array befinden. let gemuese = ; print("Anzahl der Elemente im Array: "+ gemuese.length); Shelly Scripting - Arrays - ermitteln der Anzahl der Elemente Das bedeutet: Unser gemuese-Array enthält vier Elemente.Aber Achtung: Der letzte gültige Index ist nicht 4, sondern 3, denn die Zählung beginnt wie immer bei 0. 👉 Merke:Die length-Eigenschaft gibt dir die Anzahl der Elemente, nicht den höchsten Index. Der höchste Index ist also immer length - 1. Beispiel für Zugriff mit length let gemuese = ; let letztesGemuese = gemuese; print(letztesGemuese); // Ausgabe: Karotte So kannst du dynamisch auf das letzte Element zugreifen, egal wie viele Werte im Array gespeichert sind. Array mit einer for-Schleife durchlaufen Eine der häufigsten Methoden, um alle Werte eines Arrays zu verarbeiten oder auszugeben, ist die for-Schleife. Sie ermöglicht es dir, nacheinander auf jeden Index des Arrays zuzugreifen. Hier ein Beispiel mit unserem Gemüse-Array: let gemuese = ; for (let index = 0; index < gemuese.length; index++) { print(gemuese); } Shelly Scripting - Arrays - Ausgabe der Elemente mit einer ForSchleife 🔍 Was passiert hier? - Die Schleife beginnt bei index = 0 (also dem ersten Element). - Sie läuft so lange, wie der Index kleiner als gemuese.length ist. - Mit gemuese greifen wir auf das jeweilige Element zu. - Die Funktion print() gibt das Element aus (alternativ in der Konsole: console.log()). 💡 Wichtig:Wir verwenden index < gemuese.length – nicht - Die Methode - Sie übergibt jedes Element nacheinander an die anonyme Funktion - Die Funktion wird print(element)); Wann forEach() verwenden? ✅ Vorteile: - Weniger Fehleranfällig (kein manuelles Zählen oder Indexvergleich) - Lesbarer und kürzerer Code - Perfekt für einfache Ausgaben oder Operationen auf jedem Element ⚠️ Beachte:forEach() ist nicht abbrechbar – ein break oder return beendet nicht die gesamte Schleife wie bei for. Für Fälle mit Abbruchbedingung bleibt for oft die bessere Wahl. Mehrdimensionale Arrays – Strukturen im Array Mit einem mehrdimensionalen Array kannst du komplexere Datenstrukturen abbilden. Statt nur einer Liste mit Werten speicherst du darin Arrays innerhalb von Arrays – ähnlich wie bei einer Tabelle oder Matrix. Das eignet sich besonders gut, wenn du Daten gruppieren möchtest – z. B. mehrere Räume in einer Wohnung, jeweils mit verschiedenen smarten Geräten. let wohnung = , , ], , , ] ]; for (let i = 0; i < wohnung.length; i++) { print("Raum: " + wohnung); for (let j = 1; j < wohnung.length; j++) { let gruppe = wohnung; print(" Gruppe: " + gruppe); for (let k = 1; k < gruppe.length; k++) { print(" Gerät: " + gruppe); } } } Hinweis: Da die Console lediglich die letzten 10 Einträge anzeigt, habe ich hier zu jsfiddle.net gewechselt. Zusätzlich habe ich für die kompatibilität die Funktion print implementiert, somit kann man den Code 1:1 übernehmen. Shelly Scripting - Arrays - Mehrdimensionale Arrays - Ausgabe Werte in einem Array ersetzen Ein Array ist veränderbar – du kannst also einzelne Werte gezielt austauschen, indem du einen neuen Wert an einer bestimmten Stelle (Index) zuweist. Beispiel: let gemuese = ; gemuese = "Kohlrabi"; ➡️ Was passiert hier?Das Element mit dem Index 2 (also der dritte Eintrag: "Paprika") wird durch "Kohlrabi" ersetzt. Shelly Scripting - Arrays - Ersetzen von Elementen 💡 So kannst du gezielt Werte anpassen – etwa, wenn sich ein Sensorwert ändert oder ein Gerät ausgetauscht wurde. Werte per Index hinzufügen Wie gezeigt, kannst du mit gemuese = "Kohlrabi" einen bestehenden Eintrag ersetzen.Doch was passiert, wenn du einen Index verwendest, der noch nicht existiert? Beispiel: let gemuese = ; gemuese = "Brokkoli"; ➡️ Ergebnis:Der Eintrag "Brokkoli" wird an Position 4 eingefügt – das Array wächst automatisch. Shelly Scripting - Arrays - Hinzufügen von Elementen ⚠️ Achtung:Wenn du z. B. gemuese = "Spinat" schreibst, aber Index 5 leer lässt, wird dieser automatisch mit undefined gefüllt: gemuese = "Spinat"; print(gemuese); Shelly Scripting - Arrays - Hinzufügen von Elementen Index übersprungen 💡 Daher sollte man bei nicht fortlaufender Indexvergabe aufpassen, um unerwartete Lücken im Array zu vermeiden. Ausblick: So geht’s weiter In diesem Beitrag hast du gelernt, wie Arrays aufgebaut sind, wie du auf ihre Elemente zugreifst und wie du sie mit Schleifen durchläufst. Damit hast du die wichtigsten Grundlagen in der Hand, um mit Arrays in Shelly Scripting oder JavaScript allgemein zu arbeiten. Im nächsten Teil zeige ich dir, wie du Arrays aktiv bearbeitest:🔹 Elemente hinzufügen (push, unshift)🔹 Werte entfernen (pop, shift)🔹 Inhalte gezielt ändern oder löschen mit splice() So kannst du deine Daten nicht nur lesen, sondern auch flexibel anpassen – perfekt für dynamische Smarthome-Szenarien. Bleib dran! Read the full article

[draegerit]

Shelly Scripting #6: EventHandler und StatusHandler für sofortige Reaktionen nutzen

Mit Shelly Scripting, EventHandler und StatusHandler lassen sich smarte Automatisierungen besonders effizient umsetzen. In diesem Beitrag zeige ich dir, wie du mit einem Shelly 2PM zwei Lampen so steuerst, dass sie wechselseitig mit einem Serienschalter ein- und ausgeschaltet werden. Zwar könnte man diese Logik auch über eine Szene in der Shelly App realisieren, doch mit einem kleinen Shelly Script benötigen wir dafür nur wenige Zeilen Code. Der große Vorteil: Da wir direkt auf Statusänderungen mit dem EventHandler reagieren, erfolgt die Schaltung ohne Verzögerung und ganz ohne Timer – die Lampen wechseln sofort ihren Zustand, sobald der Schalter betätigt wird. https://youtu.be/CcOWr91YTxI Im letzten Beitrag Shelly 2PM Gen2: Smarte Steuerung und Verbrauchsmessung für wenig Geld habe ich den Shelly 2PM Gen2 bereits ausführlich vorgestellt. Falls du mehr über seine Funktionen, Einrichtung und Einsatzmöglichkeiten erfahren möchtest, schau gerne dort vorbei!

Unterschied zwischen einem EventHandler und einem StatusHandler in Shelly Scripting

Beim Shelly Scripting gibt es zwei zentrale Mechanismen, um auf Änderungen zu reagieren: - EventHandler (Shelly.addEventHandler) - StatusHandler (Shelly.addStatusHandler) Obwohl sie auf den ersten Blick ähnlich erscheinen, gibt es wesentliche Unterschiede in ihrer Funktionsweise und Anwendung.

EventHandler – Reaktion auf spezifische Ereignisse

Ein EventHandler (Shelly.addEventHandler) wird ausgelöst, wenn ein bestimmtes Ereignis am Shelly-Gerät auftritt. Merkmale: - Wird nur bei einer Aktion oder einem Event ausgelöst (z. B. Taster gedrückt, MQTT-Nachricht empfangen). - Reagiert nur auf relevante Events und verarbeitet keine allgemeinen Statusänderungen. - Besonders nützlich für Schalter-/Taster-Steuerungen, MQTT-Kommunikation oder externe Trigger. Beispiel: Ein EventHandler erkennt, wenn ein Schalter getoggelt wird (event.info.event === "toggle") und schaltet dann ein anderes Relais aus. Shelly.addEventHandler(function (event) { print(event); // Gibt das komplette Event-Objekt aus (nützlich fürs Debugging) if (event.id === 0 && event.info.component === "switch:0" && event.info.event === "toggle") { print("Schalter links wurde betätigt!"); } if (event.id === 1 && event.info.component === "switch:1" && event.info.event === "toggle") { print("Schalter rechts wurde betätigt!"); } }); Dieser Code erkennt, wenn ein Schalter (Switch 0 oder Switch 1) umgelegt wurde und gibt eine Debug-Nachricht aus.

StatusHandler – Reaktion auf Statusänderungen

Ein StatusHandler (Shelly.addStatusHandler) wird immer dann ausgelöst, wenn sich ein Statuswert eines Geräts ändert – unabhängig davon, was die Änderung verursacht hat. Merkmale: - Wird bei jeder Statusänderung aufgerufen (z. B. Relais AN/AUS, Temperaturwerte, WLAN-Signalstärke). - Kann ausgelöst werden durch Benutzeraktionen, Skripte oder externe Steuerungen (z. B. MQTT oder REST-API). - Ideal für Überwachung, Logging oder automatisches Reagieren auf Zustandsänderungen. Beispiel: Ein StatusHandler erkennt, wenn ein Relais ein- oder ausgeschaltet wurde und gibt den neuen Zustand aus. Shelly.addStatusHandler(function (status) { if (status.name === "switch" && status.id === 0 && status.delta.output) { print("Relais 0 wurde geschaltet! Neuer Zustand: " + status.delta.output); } }); Dieser Code erkennt, wenn Relais 0 geschaltet wurde (egal ob durch ein Skript, eine Szene oder manuell) und gibt den neuen Zustand aus.

Vergleich: Wann nutzt man welchen Handler?

EigenschaftEventHandler (Shelly.addEventHandler)StatusHandler (Shelly.addStatusHandler)Wann wird er ausgelöst?Nur bei spezifischen Ereignissen (z. B. Tasterdruck, MQTT-Nachricht)Bei jeder Statusänderung (z. B. Relais AN/AUS, Temperaturänderung)Reaktion auf...Benutzeraktionen, externe Trigger, MQTTJede Statusänderung, egal wodurch verursachtTypische AnwendungSchalter-Toggles, Bewegungssensoren, EreignissteuerungÜberwachung von Relais, Sensorwerten, WLAN-VerbindungWird ausgelöst durch...Aktionen wie Tastendruck, MQTT-Nachrichten, API-BefehleJede Änderung eines Statuswerts, auch durch andere Skripte oder BenutzerBeispielReagieren, wenn ein Taster gedrückt wurdePrüfen, ob das Relais geschaltet wurde

Wann solltest du welchen Handler verwenden?

Verwende den EventHandler (Shelly.addEventHandler), wenn du - eine spezifische Aktion oder einen Trigger auswerten möchtest (z. B. Schalter, MQTT) - nur auf bestimmte Benutzeraktionen reagieren möchtest - ein Skript für schnelle, einmalige Reaktionen auf Events brauchst Verwende den StatusHandler (Shelly.addStatusHandler), wenn du - jede Statusänderung mitverfolgen willst, egal wodurch sie ausgelöst wurde - Logik abhängig vom Gerätestatus implementieren möchtest - eine kontinuierliche Überwachung (z. B. Temperatur, WLAN-Status) brauchst

EventHandler / StatusHandler am Shelly 2PM mit Lampen

Um den Shelly 2PM noch flexibler zu steuern, kannst du EventHandler und StatusHandler nutzen, um direkt auf Schalterbetätigungen oder Statusänderungen zu reagieren. Anstatt regelmäßig mit einem Timer den Zustand abzufragen, ermöglichen diese Methoden eine sofortige Reaktion in Echtzeit.

Schaltung - Shelly 2PM Gen2 mit Schalter und Lampen In diesem Abschnitt zeige ich dir, wie du mit einem EventHandler direkt auf das Umschalten eines Schalters reagieren kannst und wie du mit einem StatusHandler überwachst, ob ein Relais geschaltet wurde – ideal für eine intelligente Lampensteuerung mit Shelly Scripting. Script zum wechselseitigen Schalten mit StatusHandler // Fügt einen Status-Handler hinzu, der auf Änderungen im Shelly-Gerät reagiert. // Dieser Handler wird immer dann ausgelöst, wenn sich der Status eines Geräts verändert. Shelly.addStatusHandler(function (status) { // Überprüfen, ob das Ereignis vom Switch-Modul stammt und ob es sich um das Relais mit der ID 0 handelt. // Zudem wird geprüft, ob sich der `output`-Status (An/Aus) verändert hat. if (status.name === "switch" && status.id === 0 && status.delta.output) { // Definieren der Parameter für den Schaltbefehl: // - `id:1` -> Steuert das Relais mit der ID 1 // - `on:false` -> Das Relais 1 wird ausgeschaltet let params = {id:1, on:false}; // Senden des Befehls an das Shelly-Gerät, um Relais 1 auszuschalten. Shelly.call("Switch.Set", params); } // Falls das Ereignis vom Relais mit der ID 1 stammt und sich der `output`-Status verändert hat: else if (status.name === "switch" && status.id === 1 && status.delta.output) { // Definieren der Parameter für den Schaltbefehl: // - `id:0` -> Steuert das Relais mit der ID 0 // - `on:false` -> Das Relais 0 wird ausgeschaltet let params = {id:0, on:false}; // Senden des Befehls an das Shelly-Gerät, um Relais 0 auszuschalten. Shelly.call("Switch.Set", params); } }); Script zum wechselseitigen Schalten zweier Lampen mit EventHandler // Fügt einen Event-Handler hinzu, der auf Ereignisse am Shelly reagiert. // Diese Funktion wird aufgerufen, sobald eine Aktion (z. B. Schalterbetätigung) erkannt wird. Shelly.addEventHandler(function (event) { // Gibt das gesamte Event-Objekt im Debug-Log aus. // Dies hilft beim Debugging, um zu sehen, welche Daten das Event enthält. print(event); // Prüfen, ob das Ereignis vom Schalter 0 kommt und ob es sich um eine "toggle"-Aktion handelt. if (event.id === 0 && event.info.component === "switch:0" && event.info.event === "toggle") { // Definiert die Parameter für den Schaltbefehl: // - `id:1` -> Steuert das Relais mit der ID 1 (zweites Relais). // - `on:false` -> Das Relais 1 wird ausgeschaltet. let params = {id:1, on:false}; // Senden des Befehls an das Shelly-Gerät, um Relais 1 auszuschalten. Shelly.call("Switch.Set", params); } // Prüfen, ob das Ereignis vom Schalter 1 kommt und ob es sich um eine "toggle"-Aktion handelt. if (event.id === 1 && event.info.component === "switch:1" && event.info.event === "toggle") { // Definiert die Parameter für den Schaltbefehl: // - `id:0` -> Steuert das Relais mit der ID 0 (erstes Relais). // - `on:false` -> Das Relais 0 wird ausgeschaltet. let params = {id:0, on:false}; // Senden des Befehls an das Shelly-Gerät, um Relais 0 auszuschalten. Shelly.call("Switch.Set", params); } });

Reagieren auf Sensoren mit dem StatusHandler am Shelly AddOn & Shelly 2PM

Mit dem StatusHandler kannst du nicht nur Relais überwachen, sondern auch auf Sensordaten in Echtzeit reagieren. In diesem Abschnitt zeige ich dir, wie du einen LDR (Lichtsensor) mit dem Shelly AddOn nutzt, um eine Lampe abhängig von der Umgebungshelligkeit automatisch ein- oder auszuschalten.

Schaltung - Shelly 2PM Gen2 + AddOn + LDR + Schalter + Lampen Das Prinzip funktioniert nicht nur mit einem LDR, sondern auch mit anderen Sensoren wie PIR-Bewegungssensoren, Abstandssensoren oder Temperatursensoren. Durch den StatusHandler erkennt das Shelly Script sofort Änderungen der Sensordaten und kann entsprechend reagieren – ohne Verzögerung und ohne ständige Abfragen durch einen Timer.

Shelly AddOn mit analogen & digitalen Sensoren Wenn sich der LDR (Lichtsensor) am Shelly AddOn ändert, sendet der Shelly eine Statusänderung in JSON-Format, die folgendermaßen aufgebaut ist: { "component": "input:100", 12:06:58 "name": "input", 12:06:58 "id": 100, 12:06:58 "delta": { "id": 100, "percent": 20.31 } 12:06:58 } Erklärung der JSON-Daten: - "component": "input:100" → Statusänderung kommt vom Eingangssensor (LDR an Port 100). - "delta.percent": 20.31 → Neuer Helligkeitswert in Prozent (hier 20,31 %). - "id": 100 → Die ID des Sensors, über die er angesprochen wird. Daraus können wir folgendes kleines Script ableiten mit welchem wir bei Änderung der Helligkeit eine Lampe schalten können. // Definiere Konstanten für die Schwellwerte des Ein- und Ausschaltens const VAL_AUS = 15; // Schwellenwert, oberhalb dessen das Licht ausgeschaltet wird const VAL_AN = 20; // Schwellenwert, unterhalb dessen das Licht eingeschaltet wird // Initialisiere Objekte zur Steuerung der Lampen let paramsLampeLinks = {id: 0, on: false}; // Lampe Links mit ID 0 let paramsLampeRechts = {id: 1, on: false}; // Lampe Rechts mit ID 1 // Füge einen Status-Handler für Ereignisse des Shelly-Geräts hinzu Shelly.addStatusHandler(function (status) { print(status); // Debugging: Gibt den Status im Log aus // Prüfe, ob das Ereignis von "input:100" stammt und die ID 100 ist if (status.component === "input:100" && status.id === 100) { // Überprüfe den Helligkeitswert und steuere die Lampen entsprechend if (status.delta.percent // Wenn der Wert unter den Einschalt-Schwellenwert fällt, schalte beide Lampen ein paramsLampeLinks.on = true; paramsLampeRechts.on = true; print("Lampen AN"); } else if (status.delta.percent > VAL_AUS) { // Wenn der Wert über den Ausschalt-Schwellenwert steigt, schalte beide Lampen aus paramsLampeLinks.on = false; paramsLampeRechts.on = false; print("Lampen AUS"); } // Sende den neuen Status an das Shelly-Gerät, um die Lampen zu steuern Shelly.call("Switch.Set", paramsLampeLinks); Shelly.call("Switch.Set", paramsLampeRechts); } }); Fazit: Effiziente Automatisierung mit EventHandler und StatusHandler Mit dem EventHandler kannst du schnell und zuverlässig auf Ereignisse am Shelly reagieren, ohne dabei einen Timer im Hintergrund laufen zu lassen. Das spart nicht nur Ressourcen, sondern macht den Code auch einfacher und übersichtlicher. Dank dieser Methode erfolgt die Reaktion in Echtzeit, was besonders bei Schalterbetätigungen oder anderen direkten Eingaben von Vorteil ist. Auch der StatusHandler hat enormes Potenzial, insbesondere für Automatisierungen mit Sensoren am Shelly. In zukünftigen Projekten lassen sich damit noch viele spannende Anwendungen umsetzen. 🔜 Im nächsten Beitrag widme ich mich dem Shelly i4 DC in Kombination mit Reed-Kontakten – sei gespannt! 🚀 Read the full article

[draegerit]

Shelly Scripting #5: Intelligente Relaissteuerung bei Netzwerkausfall

Ein stabiles WLAN ist essenziell für viele smarte Automatisierungen, doch was passiert, wenn das Signal abreißt? In diesem Beitrag zeige ich dir, wie du mit Shelly Scripting die Signalstärke deines WLANs überwachen und bei einem Verbindungsverlust automatisch ein Relais deaktivieren kannst. https://youtu.be/TztC-NnrAZU Diese Funktion ist besonders nützlich für sicherheitskritische Anwendungen oder Geräte, die nicht unbeaufsichtigt weiterlaufen sollen, wenn die Netzwerkverbindung unterbrochen wird. Mit einem einfachen Script kannst du sicherstellen, dass dein Shelly eigenständig auf WLAN-Ausfälle reagiert und sich entsprechend verhält – ganz ohne zusätzliche Hardware oder manuelles Eingreifen.

Einsatzmöglichkeiten für die intelligente Relaissteuerung bei Netzwerkausfall

Ein Shelly Script zur automatischen Deaktivierung eines Relais bei WLAN-Verlust kann in verschiedenen Szenarien sinnvoll sein. Hier sind vier praxisnahe Beispiele: - Sicherheitsabschaltung für smarte Heizgeräte - Falls ein WLAN-gesteuertes Heizgerät oder eine elektrische Heizung über Shelly geschaltet wird, könnte ein Verbindungsverlust bedeuten, dass die Steuerung nicht mehr erreichbar ist. Das Script kann dafür sorgen, dass sich das Relais bei einem WLAN-Ausfall automatisch abschaltet, um eine unkontrollierte Erwärmung zu verhindern. - Pumpensteuerung in der Hausautomation - Viele smarte Garten- oder Heizkreispumpen werden über WLAN gesteuert. Falls das Netzwerk ausfällt, könnte eine Pumpe dauerhaft weiterlaufen, was unnötige Energieverschwendung oder sogar Schäden verursachen kann. Das Script stellt sicher, dass die Pumpe nur dann aktiv bleibt, wenn eine stabile Verbindung besteht. - Notabschaltung für 3D-Drucker oder Maschinen - Ein über Shelly gesteuerter 3D-Drucker oder eine CNC-Maschine könnte im Falle eines Netzwerkausfalls unbeaufsichtigt weiterlaufen. Das Script kann in solchen Fällen eine Sicherheitsabschaltung einleiten, um Fehlproduktionen oder sogar Brände zu vermeiden. - Licht- oder Alarmsteuerung bei Netzwerkausfällen - Smarte Lichter oder Alarmsysteme, die auf Netzwerkinformationen oder Steuerbefehle angewiesen sind, könnten im Falle eines WLAN-Abbruchs in einem falschen Zustand bleiben (z. B. Alarm dauerhaft aktiv). Mit dem Shelly Script kann eine definierte Abschaltlogik umgesetzt werden, um Fehlalarme oder unnötigen Stromverbrauch zu vermeiden. Diese Beispiele zeigen, wie wichtig eine intelligente Reaktion auf Netzwerkausfälle sein kann, um sowohl Sicherheit als auch Energieeffizienz in einem Smart Home zu gewährleisten.

Wenn das WLAN ausfällt: Der Heizlüfter bleibt unkontrolliert an

Ein kleiner Heizlüfter, der über einen Shelly Plug S gesteuert wird, kann effizient für eine temperaturabhängige Regelung genutzt werden. Die eigentliche Temperaturmessung erfolgt dabei nicht am Plug selbst, sondern über einen DS18B20-Sensor, der an einem Shelly Plus 1 mit AddOn angeschlossen ist. Basierend auf den Sensordaten wird der Heizlüfter automatisch ein- oder ausgeschaltet. Doch was passiert, wenn das WLAN-Signal abbricht? Da der Shelly Plug S seine Steuerbefehle über das Netzwerk erhält, könnte der Heizlüfter eingeschaltet bleiben, selbst wenn die gewünschte Temperatur längst erreicht wurde. Dies führt zu unnötigem Stromverbrauch und kann im schlimmsten Fall ein Überhitzungsrisiko darstellen. Um dieses Problem zu verhindern, setzen wir ein Shelly Script ein, das regelmäßig die WLAN-Signalstärke überprüft. Sobald die Verbindung verloren geht oder das Signal zu schwach wird, schaltet das Script das Relais automatisch aus, sodass der Heizlüfter nicht unkontrolliert weiterläuft.

Schaltungsaufbau: Shelly Plug S & Shelly Plus 1 mit Temperatursensor

Nun werfen wir einen Blick auf den Aufbau der Schaltung. Der Shelly Plug S dient als Schaltaktor für den Heizlüfter, während der Shelly Plus 1 mit AddOn die Temperaturmessung übernimmt. Der Temperatursensor DS18B20 ist am AddOn des Shelly Plus 1 angeschlossen und misst die Umgebungstemperatur. Basierend auf diesen Daten wird der Heizlüfter gesteuert.

Diese Kombination ermöglicht eine flexible und präzise Temperaturregelung, ist jedoch von einer stabilen WLAN-Verbindung abhängig. Im nächsten Schritt zeige ich, wie wir sicherstellen, dass der Heizlüfter bei einem Netzwerkausfall automatisch deaktiviert wird. Benötigte Ressourcen für dieses Projekt Für den Aufbau der Schaltung habe ich nachfolgende Komponenten verwendet: - einen Shelly Plus 1 Gen2*, - ein Shelly AddOn*, - einen Temperatursensor DS18B20*, - ein Shelly Plug S Gen3*

Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Shelly Script – Plug S temperaturgesteuert mit DS18B20

Der Shelly Plus 1 mit AddOn und angeschlossenem DS18B20-Temperatursensor übernimmt die Temperaturmessung und steuert den Shelly Plug S entsprechend der erfassten Werte. Sinkt die Temperatur unter einen definierten Grenzwert, wird der Plug S eingeschaltet, um beispielsweise einen Heizlüfter zu aktivieren. Sobald die Temperatur den oberen Grenzwert überschreitet, schaltet der Shelly Plus 1 den Plug S wieder aus, um Energie zu sparen und eine Überhitzung zu vermeiden. // Basis-URL für den Shelly Plug S, der den Heizlüfter steuert. // Die IP-Adresse muss dem Shelly Plug S in deinem Netzwerk entsprechen. // Der Parameter "turn=" wird später mit "on" oder "off" ergänzt. let urlHeater = "http://192.168.178.91/relay/0?turn="; // Temperaturgrenzen für das Ein- und Ausschalten des Heizlüfters. // Sobald die Temperatur unter HEATER_ON_TEMP fällt, wird der Heizlüfter eingeschaltet. // Sobald die Temperatur über HEATER_OFF_TEMP steigt, wird der Heizlüfter ausgeschaltet. const let HEATER_ON_TEMP = 17; // Heizlüfter einschalten bei weniger als 17°C. const let HEATER_OFF_TEMP = 20; // Heizlüfter ausschalten bei mehr als 20°C. // Variable zur Speicherung des aktuellen Heizlüfter-Zustands. // Sie verhindert unnötige HTTP-Anfragen, wenn der Status unverändert bleibt. let heaterON = false; // HTTP-Parameter für die Anfrage an den Shelly Plug S. let parameter = { method: "GET", // HTTP-Methode: GET wird genutzt, um den Schaltbefehl zu senden. url: "", // Die URL wird dynamisch gesetzt, abhängig davon, ob der Heizlüfter an- oder ausgeschaltet wird. headers: { "Content-Type": "application/json" } // Optionaler Header für den Request. }; /** * Funktion zur Überprüfung der Raumtemperatur und Steuerung des Heizlüfters. */ function handleHeater() { // Abrufen der aktuellen Temperatur vom DS18B20-Sensor am Shelly Plus 1 mit AddOn. let temperaturJson = Shelly.getComponentStatus("temperature:100"); print("Raumtemperatur ist: " + temperaturJson.tC + "°C"); // Prüfen, ob die Temperatur unterhalb der Einschaltschwelle liegt. if (temperaturJson.tC print("Temperatur kleiner als " + HEATER_ON_TEMP + "°C. Heizlüfter wird aktiviert!"); heaterON = true; // Heizlüfter als eingeschaltet markieren. callUrl(); // HTTP-Anfrage zum Einschalten senden. } // Prüfen, ob die Temperatur oberhalb der Ausschaltschwelle liegt. else if (temperaturJson.tC > HEATER_OFF_TEMP) { print("Temperatur größer als " + HEATER_OFF_TEMP + "°C. Heizlüfter wird deaktiviert!"); heaterON = false; // Heizlüfter als ausgeschaltet markieren. callUrl(); // HTTP-Anfrage zum Ausschalten senden. } } /** * Funktion zum Senden des HTTP-Requests an den Shelly Plug S, um das Relais zu schalten. */ function callUrl() { // Dynamisches Setzen der URL je nach aktuellem Status des Heizlüfters. parameter.url = urlHeater + (heaterON ? "on" : "off"); print(parameter.url); // Debugging: Die generierte URL ausgeben. // HTTP-Request an den Shelly Plug S senden. Shelly.call( "HTTP.Request", parameter, function(result, error_code, error_message) { if (error_code != 0) { print("Fehler beim Senden der Daten: " + error_message); // Fehlerbehandlung. } else { print("Daten erfolgreich gesendet."); // Erfolgreiche Anfrage bestätigen. } } ); } // Einrichten eines Timers, der alle 2500 Millisekunden (2,5 Sekunden) die Temperatur prüft. // Falls eine Änderung festgestellt wird, wird der Heizlüfter entsprechend ein- oder ausgeschaltet. Timer.set(2500, true, handleHeater);

Shelly Script – Plug S abschalten, wenn das WLAN ausfällt

Es gibt mehrere Möglichkeiten, um festzustellen, ob die WLAN-Verbindung unterbrochen wurde. Zwei der wichtigsten Indikatoren sind: 1️⃣ Der RSSI-Wert – Dieser gibt die Signalstärke der Verbindung in dBm an. Ein stark negativer Wert (z. B. unter -85 dBm) kann auf eine instabile Verbindung oder einen bevorstehenden Abbruch hindeuten. 2️⃣ Die IP-Adresse – Ein Shelly erhält normalerweise eine dynamische IP-Adresse vom Router per DHCP. Ist keine IP-Adresse zugewiesen, bedeutet dies, dass das Gerät nicht mehr mit dem Netzwerk verbunden ist. ➡ Der einfachste Weg, um einen WLAN-Ausfall zu erkennen, ist zu überprüfen, ob dem Shelly aktuell eine IP-Adresse zugewiesen wurde. Dies funktioniert jedoch nur, wenn der Shelly seine IP dynamisch vom Router erhält. Falls eine statische IP-Adresse konfiguriert wurde, bleibt diese auch bei einem WLAN-Abbruch bestehen, was zu einer falschen Erkennung führen kann. // Ein Timer wird gesetzt, der alle 2000 Millisekunden (2 Sekunden) ausgeführt wird. Timer.set(2000, true, function() { // Abrufen des aktuellen WLAN-Status vom Shelly-Gerät. let wifiStatus = Shelly.getComponentStatus("wifi"); // Überprüfen, ob der Shelly noch eine gültige IP-Adresse im WLAN besitzt. // Falls `sta_ip` nicht vorhanden oder leer ist, bedeutet das, dass der Shelly keine Verbindung mehr zum WLAN hat. if (!wifiStatus.sta_ip) { // Definieren der Parameter zum Ausschalten des Relais. let shellyParameter = { id: 0, // Das Relais mit der ID 0 wird angesprochen. on: false // Das Relais wird ausgeschaltet. }; // Senden des Befehls an den Shelly, um das Relais zu deaktivieren. Shelly.call("Switch.Set", shellyParameter); } });

Fazit: Mehr Sicherheit und Effizienz mit Shelly Scripting für die Relaissteuerung Mit Shelly Scripting lässt sich die Relaissteuerung intelligent erweitern, um auf Netzwerkausfälle zu reagieren. In diesem Beitrag habe ich gezeigt, wie du mithilfe eines einfachen Scripts dein Shelly Plug S automatisch abschalten kannst, wenn das WLAN ausfällt. So verhinderst du, dass Verbraucher wie ein Heizlüfter unnötig weiterlaufen, falls keine Verbindung mehr besteht. Diese Methode verbessert nicht nur die Sicherheit, sondern hilft auch, Energie zu sparen. Shelly Scripting bietet damit eine leistungsstarke Möglichkeit, individuelle Automatisierungen zu erstellen, die weit über die Standardfunktionen hinausgehen. 🔜 Im nächsten Beitrag zeige ich dir weitere spannende Automatisierungen mit Shelly – bleib dran! 🚀 Read the full article

[draegerit]

Shelly Scripting #3: Stromverbrauch und Sensordaten in der Cloud visualisieren

Shelly Scripting Stromverbrauch visualisieren – genau darum geht es in diesem Beitrag. Ich zeige dir, wie du mithilfe von Shelly Scripting die Daten deines Shelly 1PM Gen3, ergänzt durch das Addon und einen DHT22-Sensor, flexibel erfassen, verarbeiten und in die Cloud übertragen kannst, um sie dort übersichtlich zu visualisieren. https://youtu.be/SXejhvuD2zQ Mit Shelly Scripting kannst du dein Gerät so programmieren, dass es die Messwerte automatisch und regelmäßig an den Cloud-Service ThingSpeak sendet. Dies geschieht im Hintergrund mithilfe von Timern, sodass keine manuelle Interaktion erforderlich ist. Im letzten Beitrag habe ich bereits gezeigt, wie du die Daten als JSON speichern kannst. Hier machen wir den nächsten Schritt und zeigen, wie du mit Shelly Scripting und ThingSpeak die Daten in einem übersichtlichen Dashboard visualisierst. So kannst du sowohl aktuelle Werte überwachen als auch historische Daten analysieren.

Shelly 1PM mit Addon und Sensor zum Erfassen von Stromverbrauch und Umweltdaten

Um den Stromverbrauch zu messen, hast du die Wahl zwischen dem Shelly 1PM und dem Shelly 2PM. Der Shelly 1PM Mini ist besonders kompakt und eignet sich hervorragend für kleine Bauräume.

Shelly 1PM Gen3

Shelly 1PM Mini Gen3

Shelly 1 Plus

Shelly i4 Gen3 Wenn du jedoch – wie in diesem Beitrag gezeigt – zusätzlich Umweltdaten wie Temperatur und Luftfeuchtigkeit erfassen möchtest, benötigst du die größere Version des Shelly 1PM. Nur diese bietet die Möglichkeit, das Addon für Sensoren wie den DHT22 aufzustecken. Du kannst aber auch den "normalen" Shelly 1 Plus oder den Shelly i4 Gen3 verwenden wenn du auch das Feature zum messen des Stromverbrauchs verzichen kannst.

Benötigten Ressourcen für diesen Beitrag

Wenn du diesen Beitrag nachstellen möchtest, dann benötigst du: - einen Shelly 1PM* oder Shelly 2PM* - ein Shelly AddOn* - ein DHT22 Sensor* mit 3-Adriger Zuleitung Wenn du nur die Umweltdaten auslesen und ein Gerät schalten möchtest, also auf den Stromverbrauch verzichten kannst, dann empfehle ich dir den Shelly 1 Plus*.

Shelly, AddOn & DHT22 Sensor inkl. Zuleitung Hinweis von mir: Die mit einem Sternchen (*) markierten Links sind Affiliate-Links. Wenn du über diese Links einkaufst, erhalte ich eine kleine Provision, die dazu beiträgt, diesen Blog zu unterstützen. Der Preis für dich bleibt dabei unverändert. Vielen Dank für deine Unterstützung!

Anschluss des DHT22 via AddOn an den Shelly

Im Beitrag Shelly Plus #2: Shelly Plus AddOn habe ich dir bereits das kleine Modul welches du auf den Shelly Stecken kannst vorgestellt. Hier möchte ich kurz auf die Features eingehen und aufzeigen wie du dieses mit dem Shelly 1PM verbindest und einen DHT22 Sensor einrichtest.

Shelly Plus Addon

Rückseite Shelly AddOn Du kannst an den Shelly AddOn bis zu 3 DS18B20 Sensoren oder einen DHT22 Sensor (über die Pins VCC, DATA und GND) anschließen.

Shelly AddOn mit DHT22 Sensor

Shelly AddOn mit DS18B20 Sensor Einrichten des Sensors in der Shelly Smart Control App Sobald der Sensor mit dem AddOn angeschlossen wurde, müssen wir diesen in der App "Shelly Smart Control" einrichten. Wie du dieses machst, habe ich dir bereits im Beitrag Shelly Plus #2: Shelly Plus AddOn erläutert. https://youtu.be/-6hS4BTGP_0

Anschluss eines Verbrauchers an den Shelly 1PM

Damit wir einen Stromverbrauch messen können, benötigen wir auch einen Stromverbraucher. In meinem Fall schließe ich wieder eine Lampe nach folgendem Schema an. Der Shelly und die Lampe wird wiefolgt angeschlossen: - Shelly 1PM - N - Neutralleiter (blau) - L - Leiter (braun) - O - Ausgang "L" zur Lampe - Lampe - Fassung "außen" - Neutralleiter (blau) - Fassung "unten" - Leiter (braun)

Schaltung - Shelly 1PM mit Lampe Im nachfolgenden Video erläutere ich dir, wie du eine Lampe am Shelly Plus 1 Mini anschließt und in der App einrichtest. https://youtu.be/r3-TEb3K_xM

Auslesen der Sensordaten via Shelly Script

m ersten Schritt lesen wir die Sensordaten in ein JSON-Objekt ein. Das JSON-Format bietet den Vorteil, dass es unsere Daten strukturiert und organisiert speichert. Dadurch können wir über einen Key gezielt auf die entsprechenden Werte zugreifen, ohne für jede Messgröße eine separate Variable anlegen zu müssen. let data = { voltage: 0, //Spannung in Volt current: 0, //Stromaufnahme in Ampere apower: 0, //Leistungsaufnahme in Watt temperature: 0, //Temperatur in °C humidity: 0 //rel. Luftfeuchtigkeit in % }; (Selbstverständlich wäre es auch möglich, die Werte in einzelne Variablen zu speichern. Allerdings sorgt das JSON-Format für eine übersichtlichere und flexiblere Handhabung, besonders wenn die Anzahl der Datenpunkte wächst.) Diese Struktur hilft uns, die Daten effizient weiterzuverarbeiten und später in einem Cloud-Service wie ThingSpeak zu speichern oder zu visualisieren. let powerResult = Shelly.getComponentStatus("Switch:0"); data.voltage = powerResult.voltage; data.current = powerResult.current; data.apower = powerResult.apower; let temperaturResult = Shelly.getComponentStatus("temperature:100"); data.temperature = temperaturResult.tC; let humidityResult = Shelly.getComponentStatus("humidity:100"); data.humidity = humidityResult.rh;

Einrichten eines Accounts bei Thinkspeak

Nachdem wir die Daten ermittelt haben, richten wir ein Account bei Thinkspeak ein. Für diesen Account benötigst du eine gültige Mail, Land, sowie Vorname und Nachname. Solltest du nach einer MathLab Lizenz gefragt werden so öffne die nachfolgende Adresse um direkt auf Thinkspeak zugreifen zu können. https://thingspeak.mathworks.com

Zugrifssbeschränkungen des kostenfreien Accounts Der kostenfreie Account kann pro Tag nur 8219 Requests empfangen.

Wenn du dich bei Thinkspeak angemeldet und noch keinen Channel eingerichtet hast sollte dein Dashboard wiefolgt aussehen.

Mit einem klick auf "New Channel" erstellst du ein neuen Kanal bzw. Dashboard an welchen du deine Daten senden kannst. Einrichten eines Channels für den Stromverbrauch & die Umweltdaten Zunächst vergeben wir dem Channel einen Namen und benennen die Felder 1 bis 5 mit den Typen unserer ermittelten Daten. Damit wir weitere Felder verwenden können, müssen wir jeweils die Checkbox markieren. Wenn du nach unten Scrollst dann findest du dort die grüne Schaltfläche "Save" mit welcher du die Einstellungen übernimmst.

API Key für den schreibzugriff auf den Channel via HTTP Request Wenn du den neuen Channel angelegt hast, dann siehst du bereits einige leere Diagramme und Reiter. Im Reiter "API Keys" findest du deinen API Key zum schreiben und lesen von Daten. Zunächst interessiert uns hier nur der "Write API Key". Diesen Key kannst du über die Schaltfläche "Generate New Write API Key" jederzeit neu erstellen!

Absenden eines HTTP Request via Postman Mit dem kostenfreien Tool Postman kannst du sehr einfach REST-Schnittstellen wie der von Thinkspeak ansprechen und ermitteln wie dieser Request aufgebaut werden muss ohne das du eine Zeile Code schreiben musst. Dieses Tool habe ich bereits im letzten Beitrag eingesetzt um die Schnittstelle zu jsonbin.io zu bedienen.

Der Link ist dann wiefolgt : https://api.thingspeak.com/update?api_key=Q1930CQB0EBK2FRF&field1=231&field2=8.5&field3=2.8&field4=25&field5=35 Wenn du oben rechts auf die Schaltfläche "Send" klickst, wird die Adresse aufgerufen und du erhälst bei erfolg ein "200 OK". Diesen Request müssen wir nun im Shelly Script nachbauen. Wie du einen HTTP Request aus einem Shelly Script aufbaust und absendest hatte ich dir im letzten Beitrag Shelly Scripting #2: Sensordaten in der Cloud speichern und abrufen wie erwähnt mit jsonbin.io erläutert, dieses ist hier ähnlich einfach und du kannst die Funktion recyceln.

Absenden der ermittelten Daten via HTTP Request vom Shelly mit Script

In diesem Abschnitt zeige ich dir, wie du mit Shelly Scripting den Stromverbrauch und die eines angeschlossenen DHT22-Sensors regelmäßig an ThingSpeak sendest und dort visualisieren kannst. Dazu wird der Code in einzelne Blöcke zerlegt, um die Funktionsweise besser zu verstehen.

Stromverbrauch & Sensordaten eines Shelly auf dem Dashboard von ThingSpeak Basis-Setup und Datenstruktur Im ersten Schritt definieren wir die Basis-URL für den HTTP-Request an ThingSpeak und erstellen ein JSON-Objekt (data), das die gemessenen Werte wie Spannung, Strom, Leistung, Temperatur und Luftfeuchtigkeit speichert. // Basis-URL der ThingSpeak-API mit API-Schlüssel. const baseUrl = "https://api.thingspeak.com/update?api_key=Q1930CQB0EBK2FRF"; // JSON-Objekt zur Organisation der Sensordaten. let data = { voltage: 0, // Spannung in Volt. current: 0, // Stromstärke in Ampere. apower: 0, // Leistung in Watt. temperature: 0, // Temperatur in °C. humidity: 0 // Luftfeuchtigkeit in %. }; Konfiguration des HTTP-Requests Hier erstellen wir die grundlegenden Parameter für den HTTP-Request. Die URL wird später dynamisch mit den Messwerten ergänzt. // Parameter für den HTTP-Request. let parameter = { method: "GET", // HTTP-Methode GET für ThingSpeak. url: baseUrl, // URL wird später mit Daten ergänzt. headers: { "Content-Type": "application/json" } // Optionaler Header für JSON. }; Regelmäßige Datenerfassung und Verarbeitung Ein Timer wird eingerichtet, der alle 2 Sekunden die Sensordaten vom Shelly und dem angeschlossenen Sensor abruft. Die erfassten Daten werden im JSON-Objekt data gespeichert. // Timer: Alle 2 Sekunden Sensordaten abrufen. Timer.set(2000, true, function() { // Erfassen der Stromverbrauchsdaten (Spannung, Stromstärke, Leistung). let powerResult = Shelly.getComponentStatus("Switch:0"); data.voltage = powerResult.voltage; data.current = powerResult.current; data.apower = powerResult.apower; // Erfassen der Temperatur vom DHT22-Sensor. let temperaturResult = Shelly.getComponentStatus("temperature:100"); data.temperature = temperaturResult.tC; // Erfassen der Luftfeuchtigkeit vom DHT22-Sensor. let humidityResult = Shelly.getComponentStatus("humidity:100"); data.humidity = humidityResult.rh; // Debugging: Ausgabe der aktuellen Messwerte in der Konsole. print(data); URL mit Sensordaten ergänzen Die erfassten Messwerte werden dynamisch an die Basis-URL angehängt. ThingSpeak erwartet die Daten in Form von field1, field2, etc. // Ergänzen der URL mit den Sensordaten. var url = baseUrl; url += "&field1=" + data.voltage; // Feld 1: Spannung. url += "&field2=" + data.current; // Feld 2: Stromstärke. url += "&field3=" + data.apower; // Feld 3: Leistung. url += "&field4=" + data.temperature; // Feld 4: Temperatur. url += "&field5=" + data.humidity; // Feld 5: Luftfeuchtigkeit. // URL in die HTTP-Parameter übernehmen. parameter.url = url; HTTP-Request absenden Zum Abschluss wird ein HTTP-Request an ThingSpeak gesendet, um die Daten zu übertragen. Die Antwort des Servers wird im Debug-Log angezeigt, und etwaige Fehler werden ausgegeben. // Senden des HTTP-Requests an ThingSpeak. Shelly.call( "HTTP.Request", parameter, function(result, error_code, error_message) { if (error_code != 0) { // Fehler: Ausgabe der Fehlermeldung. print("Fehler beim Senden der Daten: " + error_message); } else { // Erfolgreicher Request: Ausgabe der Serverantwort. print("Daten erfolgreich gesendet: "); print(result); } } ); }); Gesamter Code Hier ist der vollständige Code, der die einzelnen Schritte zusammenführt, um mithilfe von Shelly Scripting Stromverbrauch visualisieren zu können. In regelmäßigen Intervallen werden die Stromverbrauchs- und Sensordaten deines Shelly erfasst und automatisch auf einem Dashboard dargestellt: /* Der Code dient zum Ermitteln der Sensordaten eines DHT22-Sensors am Shelly 1PM Gen3. Zusätzlich wird der Stromverbrauch einer LED-Lampe (Spannung, Stromstärke und Leistung) erfasst. Die Daten werden anschließend mithilfe eines HTTP-GET-Requests an ThingSpeak gesendet. */ const baseUrl = "https://api.thingspeak.com/update?api_key=Q1930CQB0EBK2FRF"; // Basis-URL für die ThingSpeak API. Der API-Schlüssel authentifiziert den Zugriff auf den Kanal. let data = { voltage: 0, // Spannung der LED-Lampe in Volt. current: 0, // Stromstärke der LED-Lampe in Ampere. apower: 0, // Momentane Leistungsaufnahme der LED-Lampe in Watt. temperature: 0, // Temperaturwert des DHT22-Sensors in °C. humidity: 0 // Luftfeuchtigkeit des DHT22-Sensors in Prozent. }; let parameter = { method: "GET", // Die HTTP-Methode ist GET, um Daten an ThingSpeak zu senden. url: baseUrl, // URL wird dynamisch mit Sensordaten ergänzt. headers: { "Content-Type": "application/json" } // Header, der den Inhaltstyp angibt. }; // Timer, der alle 2000 ms (2 Sekunden) ausgeführt wird. Timer.set(2000, true, function() { // Abrufen der Stromverbrauchsdaten vom Shelly (Spannung, Strom, Leistung). let powerResult = Shelly.getComponentStatus("Switch:0"); data.voltage = powerResult.voltage; // Spannung in Volt. data.current = powerResult.current; // Stromstärke in Ampere. data.apower = powerResult.apower; // Leistungsaufnahme in Watt. // Abrufen der Temperaturdaten vom DHT22-Sensor. let temperaturResult = Shelly.getComponentStatus("temperature:100"); data.temperature = temperaturResult.tC; // Temperatur in °C. // Abrufen der Luftfeuchtigkeitsdaten vom DHT22-Sensor. let humidityResult = Shelly.getComponentStatus("humidity:100"); data.humidity = humidityResult.rh; // Luftfeuchtigkeit in %. // Debugging: Ausgabe der erfassten Daten im Konsolen-Log. print(data); // Ergänzen der URL mit den Sensordaten (ThingSpeak-Felder 1 bis 5). var url = baseUrl; url += "&field1=" + data.voltage; // Feld 1: Spannung. url += "&field2=" + data.current; // Feld 2: Stromstärke. url += "&field3=" + data.apower; // Feld 3: Leistung. url += "&field4=" + data.temperature; // Feld 4: Temperatur. url += "&field5=" + data.humidity; // Feld 5: Luftfeuchtigkeit. // URL wird in den Request-Parameter übernommen. parameter.url = url; // HTTP-GET-Request an ThingSpeak senden. Shelly.call( "HTTP.Request", parameter, function(result, error_code, error_message) { // Fehlerbehandlung: Fehlermeldung wird im Debug-Log ausgegeben. if (error_code != 0) { print(error_message); } else { // Erfolgsfall: Die Antwort von ThingSpeak wird ausgegeben. print(result); } } ); });

Fazit und Ausblick zu Shelly Scripting Stromverbrauch visualisieren

In diesem Beitrag habe ich dir gezeigt, wie du mit Shelly Scripting die Messdaten deines Shelly 1PM Gen3 und eines angeschlossenen DHT22-Sensors erfassen und regelmäßig an ThingSpeak sendest. Read the full article

[draegerit]

Shelly Scripting #2: Sensordaten in der Cloud speichern und abrufen

In diesem Beitrag zeige ich dir, wie du Sensordaten deiner Shelly-Geräte mit Shelly Scripting erfassen und in der Cloud speichern kannst. Dazu nutzen wir JSONBin.io – eine einfache und kostenlose Plattform, um JSON-basierte Daten zu speichern und zu verwalten. https://youtu.be/wU5eKLY0lyg Ich werde dir in diesem Beitrag zeigen, wie du die Messdaten deines Shelly 1PM Mini erfassen und in die Cloud senden kannst. Dabei lernst du, wie Spannung, Stromverbrauch und Leistungsaufnahme erfasst, strukturiert und gespeichert werden. Zusätzlich erkläre ich dir, wie du die gespeicherten Daten aus der Cloud abrufen kannst – sei es, um sie anzuzeigen, weiterzuverarbeiten oder in Automatisierungen einzusetzen. Mit diesen Schritten kannst du die Sensordaten deines Shelly-Geräts nicht nur lokal nutzen, sondern auch für Langzeitanalysen oder die Integration in externe Systeme verfügbar machen. So erschließt du das volle Potenzial von Shelly Scripting und Cloud-Diensten!

Shellys der Generation 2 & 3

Wie ist meine Herangehensweise?

In diesem Beitrag zeige ich dir, wie du Sensordaten von einem Shelly-Gerät erfassen und in der Cloud speichern kannst. Mein Ansatz ist dabei einfach und effizient: - Daten erfassen: Die Messdaten werden direkt vom Shelly ausgelesen. - JSON-Format verwenden: Die Daten werden in einem strukturierten JSON-Objekt organisiert. - Cloud-Speicherung: Dieses JSON wird in der Cloud gespeichert und kann dort auch gelesen, aktualisiert oder gelöscht werden. Um die Daten in der Cloud abzulegen, verwende ich den Dienst jsonbin.io, der sich durch eine einfache Handhabung und gute API-Unterstützung auszeichnet. Besonders praktisch ist, dass der kostenfreie Plan von jsonbin.io bereits für viele Anwendungsfälle ausreicht. Für dieses Beispiel werde ich die Sensordaten pro Minute aktualisieren, was problemlos innerhalb der 10.000 Zugriffe pro Tag liegt, die der kostenfreie Plan erlaubt. Im nächsten Abschnitt erläutere ich, wie jsonbin.io funktioniert und wie du es einrichtest, um deine Sensordaten einfach und sicher zu verwalten.

Einen Account bei JSONBin.io anlegen

Bevor wir Sensordaten in der Cloud speichern können, benötigen wir einen Account bei JSONBin.io. Dieser Dienst ermöglicht es uns, JSON-basierte Daten sicher und einfach zu speichern.

Login - jsonbin.io Registrierungsoptionen JSONBin.io bietet dir zwei Möglichkeiten, ein Konto anzulegen: - Klassische Registrierung mit Benutzername und Passwort: - Du gibst eine gültige E-Mail-Adresse ein und erstellst ein sicheres Passwort. - Nach der Registrierung erhältst du eine Bestätigungs-E-Mail, die du bestätigen musst, um den Account zu aktivieren. - Schnelle Registrierung über Drittanbieter-Konten: - Du kannst dich direkt mit einem bestehenden Konto bei Google, GitHub, Facebook oder X (ehemals Twitter) anmelden. - Diese Methode ist besonders einfach, da keine weiteren Passworteingaben erforderlich sind. Mein Vorgehen Ich habe mich für die Registrierung über mein Google-Konto entschieden, da diese Methode schnell und unkompliziert ist: - Gehe auf die Startseite von JSONBin.io und klicke auf "Login". - Wähle das Logo von Google. - Melde dich mit deinem Google-Konto an und autorisiere die Verbindung. - Nach der Anmeldung wirst du direkt zu deinem JSONBin.io-Dashboard weitergeleitet. Warum JSONBin.io? JSONBin.io ist ideal für Shelly Scripting, da es: - Eine einfache API für das Speichern und Abrufen von Daten bietet. - Kostenlos für grundlegende Anwendungen genutzt werden kann. - Keine komplexen Server-Konfigurationen erfordert. Im nächsten Schritt zeige ich, wie wir API-Zugriff auf JSONBin.io einrichten und vorbereiten, um Messdaten deiner Shelly-Geräte speichern zu können. JSONBin.io: Preiskategorien und der kostenlose Plan "FREE" JSONBin.io bietet drei verschiedene Preiskategorien, die sich in ihren Funktionen und Limits unterscheiden:

Übersicht - Pläne & Preise von jsonbin.io FREE Kostenloser Plan, der 10000 Anfragen pro Tag erlaubt. Perfekt für kleinere Anwendungen oder Experimente wie in diesem Beitrag. Pro Plan Für Nutzer mit höheren Anforderungen, die mehr Anfragen (100 tausend pro Tag) und zusätzliche Funktionen benötigen. Additional Requests Zusatzoptionen, um mehr Anfragen (bis zu 2 Millionen Anfragen pro Tag) als im gewählten Plan erlaubt zu nutzen. API-Zugriff mit dem X-Master-KEY einrichten Um JSONBin.io für das Speichern und Abrufen von Daten zu nutzen, benötigt jede Anfrage einen speziellen X-Master-KEY. Dieser Schlüssel authentifiziert dich gegenüber dem Service und stellt sicher, dass nur autorisierte Benutzer Zugriff auf die Daten haben. X-Master-KEY abrufen - Melde dich in deinem JSONBin.io-Konto an. - Navigiere im Dashboard zum Menüpunkt "API KEYS". - Dort findest du deinen aktuellen X-Master-KEY, der für die Authentifizierung verwendet wird. - Falls notwendig, kannst du über denselben Bereich jederzeit einen neuen Schlüssel generieren. Wichtig: - Behandle deinen X-Master-KEY wie ein Passwort: Gib ihn niemals weiter und teile ihn nicht öffentlich (z. B. in öffentlichen Repositories). - Ändere den Schlüssel regelmäßig, insbesondere wenn du vermutest, dass er kompromittiert wurde. Im nächsten Schritt erläutere ich dir, wie du via Postman einen Request an jsonbin.io absendest und dort Daten speicherst und abrufst. Dadurch wird erstmal ohne Code möglich zu ermitteln, welche Daten wir benötigen und wie die Anfrage aufgebaut werden muss.

JSONBin.io mit Postman nutzen: Daten einfügen und abrufen

Mit Postman kannst du einfach testen, wie Daten an JSONBin.io gesendet und wieder abgerufen werden. Hier erkläre ich Schritt für Schritt, wie du einen neuen Eintrag in einer JSONBin-Collection erstellst und diesen später abrufst. Neuen Eintrag erstellen - Öffne Postman und erstelle einen neuen Request. - Stelle die Methode auf POST und gib die URL https://api.jsonbin.io/v3/b ein. - Navigiere zum Tab "Headers" und füge folgende Einträge hinzu: - Content-Type → application/json - X-Master-Key → Kopiere deinen API-Schlüssel (im Beispiel: $2a$10$PVlU/LH4NVxYVAJl0aAqa.Bz8bdkkYQfQ5bXI.MgU8VeETzw4ZyCW). - Wechsle zum Tab "Body", wähle den Typ raw und setze JSON als Format. - Füge folgenden JSON-Inhalt ein: { "greeting": "Hello World" } - Klicke auf die Schaltfläche Send, um den Request abzuschicken.

Antwort von JSONBin.io: Bei Erfolg erhältst du eine JSON-Antwort mit Details zur neu erstellten Bin, darunter die record-ID. Diese ID benötigst du später, um die Daten abzurufen. { "record": { "greeting": "Hello World" }, "metadata": { "id": "677d13b7e41b4d34e4713a85", "createdAt": "2025-01-05T11:44:55.965Z", "private": true } } Verwendung der ID aus der JSONBin.io-Antwort Nach dem Absenden eines POST-Requests an JSONBin.io erhältst du als Antwort ein JSON-Dokument, das wichtige Informationen zur gerade erstellten Bin enthält. Eine zentrale Rolle spielt dabei die ID, die in der Antwort enthalten ist. Diese ID identifiziert die erstellte Bin eindeutig und wird für alle weiteren Anfragen (wie Updates oder Abrufe) benötigt.

Warum ist die ID wichtig? Die ID fungiert als eindeutiger Schlüssel, um die Daten, die du gespeichert hast, jederzeit wieder aufzurufen oder zu ergänzen. Bei weiteren Datenaktualisierungen (z. B. täglichen Messwerten) wird die ID in den Requests ergänzt, um die bestehende Bin zu adressieren. Datenlimits im kostenfreien Account Im kostenfreien Plan von JSONBin.io kannst du pro Request maximal 100 KB an Daten absenden. Dieses Limit ist mehr als ausreichend, um tägliche Messdaten wie Spannung, Stromverbrauch oder Temperatur zu speichern und zu erweitern. Gespeicherte Datensätze aus JSONBin.io laden Um einen zuvor gespeicherten Datensatz aus JSONBin.io zu laden, benötigst du die spezifische Bin ID, die du bei der Erstellung des Eintrags erhalten hast. Diese ID wird in der URL verwendet, um die entsprechenden Daten abzurufen. Hier sind die erforderlichen Details für den Request: - Erstelle einen neuen GET-Request in Postman. - Gib die URL mit der entsprechenden ID ein (z. B. https://api.jsonbin.io/v3/b/63abc123ef4567890). - Füge die Header hinzu: - Content-Type: application/json - X-Master-Key: - Sende den Request, um die Daten abzurufen.

Bin ID finden Falls du die ID eines zuvor gespeicherten Eintrags nicht mehr weißt, kannst du sie im Dashboard von JSONBin.io abrufen: - Melde dich bei JSONBin.io an. - Gehe zum Menüpunkt Bins (https://jsonbin.io/app/bins). - Hier findest du eine Übersicht aller erstellten Bins und die zugehörigen IDs. Antwort von JSONBin.io Wenn der Request erfolgreich ist, erhältst du die gespeicherten Daten im JSON-Format: { "record": { "greeting": "Hello World" }, "metadata": { "id": "677d170fad19ca34f8e6f3c6", "private": true, "createdAt": "2025-01-05T11:59:11.047Z" } } Einträge bei JSONBin.io aktualisieren: Daten mit PUT ersetzen Wenn du einen bestehenden Eintrag bei JSONBin.io aktualisieren möchtest, verwendest du die HTTP-Methode PUT. Dabei übergibst du im Body ein valides JSON, das den aktuellen Inhalt vollständig ersetzt. - Erstelle einen neuen PUT-Request in Postman. - Gib die URL mit der entsprechenden ID ein (z. B. https://api.jsonbin.io/v3/b/63abc123ef4567890). - Füge die Header hinzu: - Content-Type: application/json - X-Master-Key: - Wechsle zum Body-Tab, wähle den Typ raw, setze das Format auf JSON, und gib die neuen Daten ein:jsonCode kopieren{ "greeting": "Hello Updated World", "timestamp": "2025-01-04T12:00:00.000Z" } - Sende den Request, um die Bin zu aktualisieren.

Wichtige Hinweise bei Updates im FREE-Plan - Beim kostenfreien Plan wird die bestehende Bin durch die neuen Daten überschrieben, ohne dass eine Versionskontrolle erfolgt. - Das bedeutet: Die alten Daten sind unwiderruflich verloren, sobald sie überschrieben wurden. - In den kostenpflichtigen Plänen (Pro Plan oder Additional Requests) steht eine Versionskontrolle zur Verfügung, die es ermöglicht, auf ältere Versionen zurückzugreifen. Antwort von JSONBin.io Bei Erfolg erhältst du eine JSON-Antwort, die bestätigt, dass die Daten erfolgreich ersetzt wurden: { "record": { "greeting": "Ein anderer Eintrag!" }, "metadata": { "parentId": "677d170fad19ca34f8e6f3c6", "private": true } }

Sensordaten am Shelly via Scripting ermitteln und speichern

Nachdem ich dir nun den Service jsonbin.io ausführlich erläutert habe, möchte ich einsteigen und dir aufzeigen wie du die ermittelten Sensordaten am Shelly via Script speichern kannst. Abfragen des aktuellen Status via Browser Mit der Adresse http:///rpc/Shelly.GetStatus können wir den Status (als JSON-Response) des Gerätes auslesen. Aus diesem Block interessiert mich nachfolgend nur der Abschnitt "switch:0". Da es sich in dem Fall um den Shelly 1PM Mini Gen3 handelt, können wir nachfolgende Daten vom Verbraucher ablesen: - Spannung in Volt (voltage), - Stromaufnahme in Ampere (current), - Leistungsaufname (momentan & Gesamt) in W (apower)

Ermitteln der Sensordaten am Shelly via Scripting Zunächst möchte ich die Leistungsaufnahme einer LED Lampe am Shelly 1PM Mini Gen3 messen. Dazu können wir wie im letzten Beitrag erwähnt mit der Funktion Shelly.getComponentStatus auf diese Eigenschaften zugreifen und die aktuellen Daten als JSON auslesen. // Abrufen des aktuellen Status von Switch:0 (Relais oder Schalter). // Das Ergebnis enthält Messwerte wie Spannung, Leistung und Energiedaten. let result = Shelly.getComponentStatus("Switch:0"); // Ausgabe der aktuell gemessenen Spannung in Volt. // Der Wert result.voltage gibt die Spannung an, die vom Shelly gemessen wurde. print("Spannung: " + result.voltage + " Volt"); // Ausgabe der aktuell gemessenen Leistungsaufnahme in Watt. // Der Wert result.apower gibt die momentane Leistung an, die das Gerät verbraucht. print("Leistungsaufnahme: " + result.apower + " Watt"); // Abrufen des Zeitstempels der letzten Minute aus den Energiedaten. // result.aenergy.minute_ts liefert einen UNIX-Zeitstempel in Sekunden. let timestamp = result.aenergy.minute_ts; // Umwandeln des UNIX-Zeitstempels in ein JavaScript-Date-Objekt. // Der Zeitstempel wird mit 1000 multipliziert, da JavaScript Millisekunden erwartet. var date = new Date(timestamp * 1000); // Ausgabe des Datums und der Uhrzeit in lesbarer Form. // Das Date-Objekt wird mit toString() formatiert und in der Konsole angezeigt. print("Zeit: " + date.toString()); Der Code lädt die Daten des Shelly als JSON und aus diesem können wir recht einfach über den entsprechenden Schlüssel auf die Werte zugreifen. In diesem kleinen Script lasse ich die Daten zunächst in der Console mit dem Befehl print ausgeben.

Speichern der Daten vom Shelly in ein JSON Die ermittelten Daten speichern wir in einem JSON welches wir zunächst definieren müssen. In meinem Fall benenne ich die Schlüssel genauso wie diese im JSON-Response vom Shelly kommen. // Initialisieren eines Datenobjekts, um Messwerte zu speichern. // Die Felder repräsentieren Spannung (voltage), Strom (current), Leistung (apower) und Zeitstempel (timestamp). let data = { voltage: 0, // Spannung in Volt (Initialwert: 0) current: 0, // Stromstärke in Ampere (Initialwert: 0) apower: 0, // Momentane Leistungsaufnahme in Watt (Initialwert: 0) timestamp: 0 // Zeitstempel der Messung in UNIX-Sekunden (Initialwert: 0) }; // Abrufen des aktuellen Status des Shelly-Geräts für Switch:0. // Das result-Objekt enthält Messdaten wie Spannung, Strom, Leistung und Energiedaten. let result = Shelly.getComponentStatus("Switch:0"); // Aktualisieren des voltage-Felds im data-Objekt mit der gemessenen Spannung. data.voltage = result.voltage; // Aktualisieren des current-Felds im data-Objekt mit der gemessenen Stromstärke. data.current = result.current; // Aktualisieren des apower-Felds im data-Objekt mit der gemessenen Leistungsaufnahme. data.apower = result.apower; // Aktualisieren des timestamp-Felds im data-Objekt mit dem Zeitstempel der letzten Minute. // Der Zeitstempel wird in UNIX-Sekunden geliefert. data.timestamp = result.aenergy.minute_ts; // Ausgabe des gesamten data-Objekts in der Konsole. // Alle Messwerte und der Zeitstempel werden im JSON-Format angezeigt. print(data); Die Ausgabe ist wie zu erwarten ein JSON mit den aktuellen Daten vom Shelly.

Ausgabe der ermittelten Sensordaten am Shelly im JSON-Format Speichern des JSON auf JSONBin.io Die zuvor ermittelten Daten können wir nun via HTTP.Request an jsonbin.io senden. Dazu müssen wir den Request wie folgt aufbauen: let parameter = { method: "POST", // Die HTTP-Methode ist POST, um neue Daten zu erstellen. url: baseUrl, // Ziel-URL für den API-Endpunkt. headers: { // Header-Informationen für den Request. "Content-Type": "application/json", // Gibt an, dass der Body JSON-Daten enthält. "X-Master-key": jsonbin_API_KEY // API-Key zur Authentifizierung. }, body: data // Das zu sendende JSON-Objekt mit den Messdaten. }; Shelly.call( "HTTP.Request", parameter, function(result, error_code, error_message) { // Callback-Funktion zur Verarbeitung der Antwort. if (error_code != 0) { // Ausgabe einer Fehlermeldung, falls die Anfrage fehlschlägt. } else { // Abrufen der Bin-ID aus der erfolgreichen Antwort und Ausgabe in der Konsole. } } ); Nachfolgend das komplette Script zum speichern der Sensordaten eines Shelly in jsonbin.io. // Definieren des API-Schlüssels für JSONBin.io. Dieser Schlüssel authentifiziert die Anfragen. // Hinweis: Sensible Daten wie API-Keys sollten niemals öffentlich zugänglich sein. const jsonbin_API_KEY = "geheim"; // Basis-URL für JSONBin.io-API-Endpunkte. const baseUrl = "https://api.jsonbin.io/v3/b/"; // Initialisieren eines Objekts, um die Messwerte des Shelly-Geräts zu speichern. let data = { voltage: 0, // Spannung in Volt current: 0, // Stromstärke in Ampere apower: 0, // Momentane Leistungsaufnahme in Watt timestamp: 0 // Zeitstempel der letzten Messung }; // Abrufen der aktuellen Messwerte vom Shelly-Gerät für Switch:0. let result = Shelly.getComponentStatus("Switch:0"); data.voltage = result.voltage; // Spannung wird aktualisiert. data.current = result.current; // Stromstärke wird aktualisiert. data.apower = result.apower; // Momentane Leistungsaufnahme wird aktualisiert. data.timestamp = result.aenergy.minute_ts; // Zeitstempel wird aktualisiert. // Erstellen der Parameter für den HTTP-Request, um die Daten an JSONBin.io zu senden. let parameter = { method: "POST", // Die HTTP-Methode ist POST, um neue Daten zu erstellen. Read the full article