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.
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!
Inhaltsverzeichnis
- Wie ist meine Herangehensweise?
- Einen Account bei JSONBin.io anlegen
- JSONBin.io mit Postman nutzen: Daten einfügen und abrufen
- Sensordaten am Shelly via Scripting ermitteln und speichern
- Abfragen des aktuellen Status via Browser
- Ermitteln der Sensordaten am Shelly via Scripting
- Speichern der Daten vom Shelly in ein JSON
- Speichern des JSON auf JSONBin.io
- Timer für das fortlaufende auslesen und aktualisieren der Daten in der Cloud
- Abschluss und Fazit zu Sensordaten via Shelly Scripting in der Cloud speichern
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.
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:
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" }
- Füge folgenden JSON-Inhalt ein:
- 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: <Dein-API-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: <Dein-API-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://<IP-Adresse>/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.
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. 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. }; // Funktion zum Auslesen der Bin-ID aus der JSONBin.io-API-Antwort. // Die Antwort wird als JSON-Objekt geparst und die Bin-ID aus der "metadata" extrahiert. function readBinIDFromResult(result) { let json = JSON.parse(result); // Umwandeln der API-Antwort in ein JavaScript-Objekt. return json.metadata.id; // Rückgabe der Bin-ID aus den Metadaten. } // Senden der Daten an JSONBin.io mittels Shelly-HTTP-Aufruf. Shelly.call( "HTTP.Request", parameter, // HTTP-Anfrage mit den zuvor definierten Parametern. function(result, error_code, error_message) { // Callback-Funktion zur Verarbeitung der Antwort. if (error_code != 0) { // Ausgabe einer Fehlermeldung, falls die Anfrage fehlschlägt. print(error_message); } else { // Abrufen der Bin-ID aus der erfolgreichen Antwort und Ausgabe in der Konsole. let bin = readBinIDFromResult(result.body); print("Daten wurden unter der BIN-ID gespeichert: " + bin); } } );
Wenn die Daten erfolgreich abgesendet und verarbeitet wurden, dann erhalten wir als Antwort ein JSON mit einer BIN-ID über welche wir diesen Container mit neuen Daten aktualisieren können.
Die angezeigte BIN-ID finden wir auf der Platform jsonbin.io unter dem Menüpunkt BINS. Dort können wir die gesendeten Daten mit einem klick auf die ID ablesen.
Timer für das fortlaufende auslesen und aktualisieren der Daten in der Cloud
Mit einem Timer können wir nun die Daten fortlaufend auslesen und die Daten immer aktualisieren.
// Definieren des API-Schlüssels für JSONBin.io. Dieser wird für die Authentifizierung verwendet. // Hinweis: Der Schlüssel sollte vertraulich behandelt und nicht öffentlich gemacht werden. const jsonbin_API_KEY = "geheim"; // Basis-URL für JSONBin.io-API-Endpunkte. const baseUrl = "https://api.jsonbin.io/v3/b/"; // Initialisieren eines Datenobjekts, um Messwerte und die Bin-ID zu speichern. // Die `bin_id` wird verwendet, um zu entscheiden, ob ein neuer Datensatz erstellt (POST) oder aktualisiert (PUT) werden soll. let data = { bin_id: 0, // ID der JSONBin (0 bedeutet, dass noch keine Bin erstellt wurde). 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; // Leistungsaufnahme wird aktualisiert. data.timestamp = result.aenergy.minute_ts; // Zeitstempel der letzten Minute. // Parameter für den HTTP-Request erstellen. Standardmäßig wird ein POST-Request vorbereitet. let parameter = { method: "POST", // HTTP-Methode: POST für das Erstellen eines neuen Eintrags. url: baseUrl, // Ziel-URL für den API-Endpunkt. headers: { // Header-Informationen für den Request. "Content-Type": "application/json", // Der Body enthält JSON-Daten. "X-Master-key": jsonbin_API_KEY // API-Key zur Authentifizierung. }, body: data // Zu sendende Daten als JSON. }; // Funktion zum Extrahieren der Bin-ID aus der API-Antwort. // Die Antwort wird geparst und die `metadata.id` zurückgegeben. function readBinIDFromResult(result) { let json = JSON.parse(result); // Umwandeln der API-Antwort in ein JavaScript-Objekt. return json.metadata.id; // Rückgabe der Bin-ID aus den Metadaten. } // Funktion zum Senden von HTTP-Requests an JSONBin.io. // Der Parameter `updateBinID` gibt an, ob die Bin-ID aus der Antwort extrahiert werden soll. function callHttpRequest(updateBinID) { Shelly.call( "HTTP.Request", parameter, // HTTP-Anfrage mit den definierten Parametern. function(result, error_code, error_message) { // Callback-Funktion zur Verarbeitung der API-Antwort. if (error_code != 0) { // Bei einem Fehler wird die Fehlermeldung ausgegeben. print(error_message); } else { if (updateBinID) { // Wenn eine neue Bin erstellt wurde (POST), wird die Bin-ID extrahiert und im Datenobjekt gespeichert. let bin = readBinIDFromResult(result.body); data.bin_id = bin; // Speichern der Bin-ID im `data`-Objekt. print("Daten wurden unter der BIN-ID gespeichert: " + bin); } // Ausgabe der API-Antwort und der aktuellen Daten in der Konsole. print(data); print(result); } } ); } // Einrichten eines Timers, der alle 10 Sekunden die Messwerte aktualisiert und an JSONBin.io sendet. Timer.set(10000, true, function() { // Abrufen der aktuellen Messwerte vom Shelly-Gerät. 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; // Leistungsaufnahme wird aktualisiert. data.timestamp = result.aenergy.minute_ts; // Zeitstempel wird aktualisiert. if (data.bin_id === 0) { // Wenn noch keine Bin-ID existiert, wird ein POST-Request ausgeführt, um eine neue Bin zu erstellen. callHttpRequest(true); } else { // Wenn bereits eine Bin-ID existiert, wird ein PUT-Request ausgeführt, um die vorhandenen Daten zu aktualisieren. parameter.url = baseUrl + data.bin_id; // URL wird mit der Bin-ID ergänzt. parameter.method = "PUT"; // Methode wird auf PUT geändert. callHttpRequest(false); // Bin-ID muss nicht erneut extrahiert werden. } });
In jsonbin.io werden die Daten nun fortlaufend alle 10 Sekunden aktualisiert, ggf. müssen wir die Seite immer aktualisieren. Auf der Startseite siehst du bei einem kostenfreien Account einen Counter welcher mit jedem Request nach unten gezählt wird.
Abschluss und Fazit zu Sensordaten via Shelly Scripting in der Cloud speichern
In diesem Beitrag hast du gelernt, wie du Sensordaten deines Shelly-Geräts erfassen, strukturieren und mithilfe von JSONBin.io in der Cloud speichern kannst. Wir haben uns mit den grundlegenden Funktionen von JSONBin.io beschäftigt, darunter das Anlegen neuer Daten (POST), das Aktualisieren bestehender Einträge (PUT) und das Laden gespeicherter Informationen (GET).
Mit diesem Wissen bist du in der Lage, deine Shelly-Messwerte sicher und übersichtlich in der Cloud abzulegen und diese bei Bedarf abzurufen oder zu aktualisieren. Dieser Ansatz ist besonders hilfreich, wenn du Sensordaten langfristig speichern oder sie für weitere Analysen nutzen möchtest.
Im nächsten Beitrag werde ich dir zeigen, wie du die Sensordaten deines Shelly mithilfe von HTTP Requests an ThingSpeak sendest. Dort lernst du, wie du die Daten visualisierst und in Echtzeit überwachen kannst – ein weiterer Schritt, um das volle Potenzial deiner Shelly-Geräte auszuschöpfen. Bleib dran!
1 thought on “Shelly Scripting #2: Sensordaten in der Cloud speichern und abrufen”