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.
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.
Inhaltsverzeichnis
- Shelly 1PM mit Addon und Sensor zum Erfassen von Stromverbrauch und Umweltdaten
- Benötigten Ressourcen für diesen Beitrag
- Anschluss des DHT22 via AddOn an den Shelly
- Anschluss eines Verbrauchers an den Shelly 1PM
- Auslesen der Sensordaten via Shelly Script
- Einrichten eines Accounts bei Thinkspeak
- Absenden der ermittelten Daten via HTTP Request vom Shelly mit Script
- Fazit und Ausblick zu Shelly Scripting Stromverbrauch visualisieren
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.
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*.
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.
Du kannst an den Shelly AddOn bis zu 3 DS18B20 Sensoren oder einen DHT22 Sensor (über die Pins VCC, DATA und GND) anschließen.
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.
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)
Im nachfolgenden Video erläutere ich dir, wie du eine Lampe am Shelly Plus 1 Mini anschließt und in der App einrichtest.
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.
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=35Wenn 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.
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. Durch die automatische Datenübertragung mithilfe eines Timers kannst du deine Stromverbrauchs- und Umweltdaten einfach in der Cloud speichern und visualisieren. Das Zusammenspiel von Shelly Scripting und ThingSpeak bietet dir nicht nur eine praktische Möglichkeit, deine Daten zu überwachen, sondern schafft auch die Grundlage für weitere Automatisierungen in deinem Smart Home.
Im nächsten Beitrag werden wir uns einem spannenden Feature widmen, das viele von der kostenpflichtigen Version der Shelly Smart Control App kennen: die Steuerung einer Lampe basierend auf den Sonnenaufgangs- und Sonnenuntergangszeiten.
Mit einem kostenlosen Service und einem kleinen Shelly Script zeige ich dir, wie du diese Funktion ganz einfach nachbauen kannst – ohne zusätzliche Kosten. Freu dich darauf, wie du dein Smart Home noch smarter gestalten kannst!