Den Shelly Plus 1PM habe ich auf meinem Blog bereits in mehreren Beiträgen vorgestellt. In meinem Fall ist das Gerät an meinem Balkonkraftwerk (BKW) angeschlossen, sodass ich darüber jederzeit die aktuelle Leistung sowie den Energieverbrauch ablesen kann.
Über die App Shelly Smart Control oder die Cloudlösung von Shelly funktioniert das grundsätzlich sehr einfach. Sobald man jedoch mehrere Werte gleichzeitig auswerten oder übersichtlich darstellen möchte, stößt die App schnell an ihre Grenzen.
Shelly selbst bietet mit dem Shelly Wall Display zwar eine Lösung an, allerdings ist dieses mit aktuell über 130 € nicht gerade günstig.
In dieser Beitragsreihe zeige ich dir daher eine deutlich flexiblere und kostengünstigere Alternative. Mit Node-RED und der gut dokumentierten Shelly API bauen wir uns Schritt für Schritt ein eigenes Energie-Dashboard, über das sich Leistungsdaten speichern, auswerten und später auch grafisch darstellen lassen.
Im ersten Teil legen wir dafür die Grundlage:
Wir erstellen eine SQLite-Datenbank, importieren vorhandene Daten und lernen, wie sich diese anschließend wieder abrufen lassen.
Aufbau der Lösung
Damit wir ein eigenes Energie-Dashboard erstellen können, benötigen wir zunächst eine Möglichkeit, die Leistungsdaten des Shelly dauerhaft zu speichern.
Über die API lassen sich bei vielen Shelly-Geräten aktuelle Werte direkt abrufen. Eine Schnittstelle für historische Energiedaten ist jedoch nicht bei allen Modellen verfügbar.
Geräte wie der Shelly EM (Mini) oder Shelly Pro 3EM sind für Energie-Monitoring ausgelegt und bieten dafür deutlich mehr Möglichkeiten. Diese Modelle sind allerdings – je nach Ausführung – auch spürbar teurer. Beim Shelly Plus 1PM, den ich an meinem Balkonkraftwerk einsetze, lassen sich die bereits gesammelten historischen Daten nicht einfach per API abrufen.
Aus diesem Grund verfolgen wir in dieser Reihe folgenden Ansatz:
- Bereits vorhandene Daten werden zunächst einmalig als CSV-Datei exportiert.
- Diese Daten importieren wir anschließend in eine lokale SQLite-Datenbank.
- Über Node-RED können wir die gespeicherten Daten später wieder abrufen und für Auswertungen oder Diagramme verwenden.
Die Architektur unseres Projekts sieht daher wie folgt aus:
Der große Vorteil dieses Ansatzes ist, dass alle Daten lokal im eigenen Netzwerk gespeichert werden. Es ist keine Cloud-Anbindung notwendig und du behältst jederzeit die volle Kontrolle über deine Messwerte.
Im nächsten Schritt installieren wir die benötigten SQLite-Nodes für Node-RED und erstellen anschließend unsere erste Datenbank.
SQLite auf dem Raspberry Pi installieren
Damit Node-RED die Energiedaten speichern kann, benötigen wir zunächst eine lokale Datenbank. Für dieses Projekt verwende ich SQLite, da diese Datenbank besonders leichtgewichtig ist und ohne zusätzlichen Server direkt auf dem Raspberry Pi betrieben werden kann.
SQLite eignet sich hervorragend für kleinere Projekte oder Zeitreihen wie Energie- und Leistungsdaten, da die komplette Datenbank einfach in einer Datei gespeichert wird.
Zuerst aktualisieren wir das System:
sudo apt update
sudo apt upgradeAnschließend installieren wir SQLite:
sudo apt install sqlite3Nach der Installation können wir prüfen, ob SQLite korrekt installiert wurde:
sqlite3 --versionDie Ausgabe sollte ungefähr so aussehen:
Damit ist SQLite erfolgreich auf dem Raspberry Pi installiert und einsatzbereit.
SQLite Datenbank erstellen
Nun erstellen wir eine erste Datenbank für unsere Energiedaten.
Dazu wechseln wir zunächst in das Node-RED Verzeichnis:
cd ~/.node-redJetzt können wir eine neue Datenbank erstellen:
sqlite3 shelly-energy.dbSQLite erstellt die Datei automatisch, falls sie noch nicht existiert.
Wir befinden uns nun in der SQLite Konsole, in der wir SQL-Befehle ausführen können.
Die Eingabeaufforderung sieht dann so aus:
m nächsten Schritt legen wir eine Tabelle an, in der später die Leistungsdaten des Shelly gespeichert werden.
Tabelle für den CSV-Import anlegen
Da der CSV-Export des Shelly in meinem Fall einen Zeitstempel sowie den Energieverbrauch in Wh enthält, lege ich dafür zunächst eine eigene Tabelle in der SQLite-Datenbank an.
Innerhalb der SQLite-Konsole führe ich dazu folgenden SQL-Befehl aus:
CREATE TABLE shelly_energy_monthly (
id INTEGER PRIMARY KEY AUTOINCREMENT,
timestamp TEXT NOT NULL,
energy_wh REAL NOT NULL
);
Exportieren der historischen Daten aus der Shelly Cloud
Zunächst exportieren wir die historischen Energiedaten aus der Shelly Cloud. Diese Daten dienen als Grundlage für unsere Datenbank, damit wir nicht bei Null beginnen müssen. In meinem Beispiel exportiere ich die Daten der letzten 12 Monate im CSV-Format.
Mit etwas zusätzlichem Aufwand lassen sich auch Daten über einen längeren Zeitraum exportieren. Der grundlegende Ablauf bleibt jedoch identisch.
Schritt 1: Anmeldung in der Shelly Cloud
Melde dich zunächst in der Shelly Cloud unter folgendem Link an: https://control.shelly.cloud/
Nach der Anmeldung erscheint die Übersicht deiner Geräte. Wähle dort das entsprechende Gerät aus.
In meinem Fall ist der Shelly Plus 1PM, der an meinem Balkonkraftwerk angeschlossen ist und daher auch entsprechend als „Balkonkraftwerk“ bezeichnet wurde.
Schritt 2: Energieverbrauch öffnen
Auf der rechten Seite der Geräteübersicht findest du ein kleines Liniendiagramm, das den Energieverbrauch visualisiert.
Klicke auf dieses Diagramm, um die detaillierte Verbrauchsansicht zu öffnen.
Anschließend aus der Auswahlliste den Eintrag „Letzte 12 Monate“ auswählen.
Schritt 3: CSV-Export starten
Oben im Diagramm befindet sich neben der Beschriftung „Verbrauch“ ein Menü mit drei Punkten.
Öffnest du dieses Menü, findest du dort die Option:
„CSV exportieren“
Mit einem Klick darauf wird der Download der CSV-Datei gestartet.
Damit liegen dir nun die historischen Verbrauchsdaten vor, die wir im nächsten Schritt in unsere SQLite-Datenbank importieren werden.
CSV-Daten importieren
Nachdem wir die historischen Daten aus der Shelly Cloud exportiert haben, können wir diese nun in unsere SQLite-Datenbank importieren. Bevor wir den Import in Node-RED umsetzen, lohnt sich jedoch ein kurzer Blick in die CSV-Datei.
Öffnet man die Datei beispielsweise mit einem Editor wie Notepad++, fällt auf, dass diese zwei Datenblöcke enthält:
- Verbrauchsdaten
- Einspeisedaten
Diese beiden Abschnitte stehen untereinander in der CSV-Datei.
In meinem Fall ist der Shelly Plus 1PM an einem Balkonkraftwerk angeschlossen. Da der Shelly jedoch nicht erkennt, dass Energie in das Netz eingespeist wird, werden die relevanten Werte im Abschnitt „Verbrauch“ gespeichert. Der darunter liegende Block zur Einspeisung ist für unser Projekt daher nicht relevant.
Möglichkeit 1: CSV-Datei vorher bereinigen (empfohlen)
Der einfachste Weg besteht darin, die CSV-Datei mit einem Editor wie Notepad++ zu öffnen und den unteren Block mit den Einspeisedaten zu entfernen. Sowie entfernen wir noch die Leerzeichen um die Spaltenüberschriften Zeit und Wh sowie vor den Datenzeilen.
Die Datei enthält danach nur noch die benötigten Verbrauchsdaten.
Der Vorteil dieser Variante ist, dass der Node-RED Flow deutlich einfacher bleibt, da wir nur noch einen einheitlichen Datensatz importieren müssen.
Möglichkeit 2: Aufbereitung direkt in Node-RED
Alternativ könnte man die CSV-Datei auch komplett importieren und anschließend im Node-RED Flow nur die relevanten Datensätze herausfiltern.
Diese Variante funktioniert ebenfalls, erhöht jedoch die Komplexität des Flows, da zusätzliche Filter- oder Function-Nodes benötigt werden.
Da es sich in diesem Beitrag um einen einmaligen Import historischer Daten handelt, entscheide ich mich für die erste Variante und bereinige die CSV-Datei vor dem Import.
Node-RED Palette erweitern
Damit Node-RED Daten in unsere SQLite-Datenbank schreiben kann, benötigen wir zunächst eine passende Node. Standardmäßig bringt Node-RED keine direkte Unterstützung für SQLite mit, diese kann jedoch sehr einfach über den Palette Manager nachinstalliert werden.
Öffne dazu zunächst das Menü in der Node-RED Oberfläche. Dieses findest du oben rechts hinter dem Symbol mit den drei horizontalen Strichen.
In dem sich öffnenden Menü wählst du anschließend den Eintrag „Palette erweitern“ aus.
Über diesen Dialog lassen sich zusätzliche Nodes installieren, die den Funktionsumfang von Node-RED erweitern. In unserem Fall benötigen wir eine Node, mit der sich SQL-Abfragen an eine SQLite-Datenbank senden lassen.
Im neu geöffneten Dialog wählst du nun den Reiter „Installation“ aus. In diesem Bereich lassen sich zusätzliche Erweiterungen für Node-RED suchen und direkt installieren.
Im Reiter „Installation“ suchen wir nun nach dem Paket node-red-node-sqlite.
Sobald das Paket in der Liste erscheint, klicken wir auf „Installieren“, um die Erweiterung zu Node-RED hinzuzufügen.
Im nun erscheinenden Bestätigungsdialog klicken wir erneut auf „Installieren“, um die Installation des Pakets zu starten.
Sobald die Installation abgeschlossen ist, steht im Node-RED Editor eine neue Node mit der Bezeichnung „sqlite“ zur Verfügung. Diese findest du in der linken Node-Auswahl im Bereich „Speicher“.
Kommunikation mit der SQLite-Datenbank testen
Bevor wir die CSV-Daten importieren, prüfen wir zunächst, ob die Kommunikation zwischen Node-RED und der SQLite-Datenbank korrekt funktioniert.
Dazu erstellen wir einen kleinen Test-Flow. Wir verwenden eine Inject Node, um ein einfaches SQL-Statement an die SQLite-Node zu übergeben. Dieses Statement liefert den aktuellen Zeitstempel der Datenbank zurück.
In der Inject Node tragen wir dazu folgenden Wert für msg.topic ein:
SELECT datetime('now');
Die Inject Node wird anschließend mit der sqlite Node verbunden. Zusätzlich verbinden wir die sqlite Node mit einer Debug Node, um das Ergebnis anzeigen zu lassen.
SQLite-Node konfigurieren
Bevor wir das SQL-Statement ausführen können, muss die sqlite Node noch konfiguriert werden. Da SQLite-Datenbanken direkt in Dateien gespeichert werden, müssen wir der Node zunächst mitteilen, wo sich unsere Datenbank befindet.
Öffne dazu die sqlite Node per Doppelklick und trage im Feld Datenbank den Pfad zur Datenbankdatei ein.
In meinem Fall lautet der Pfad:
/root/.node-red/shelly-energy.db
Dieser Pfad zeigt auf die SQLite-Datenbank, die wir zuvor auf dem Raspberry Pi erstellt haben. Sobald der Pfad eingetragen ist, kann die sqlite Node SQL-Abfragen an diese Datenbank senden und die Ergebnisse wieder an den Flow zurückgeben.
Nach dem Speichern der Einstellungen ist die sqlite Node bereit, um das zuvor erstellte Test-Statement auszuführen.
Der Test-Flow sieht damit so aus:
Wenn wir nun die Inject Node auslösen, wird das SQL-Statement an die Datenbank gesendet. Bei erfolgreicher Ausführung erscheint im Debug-Tab ein Eintrag mit dem aktuellen Zeitstempel.
Damit ist sichergestellt, dass Node-RED erfolgreich mit der SQLite-Datenbank kommunizieren kann und wir im nächsten Schritt die CSV-Daten importieren können.
Flow zum speichern der exportierten Daten und Speichern in der SQLite-Datenbank
Nachdem die CSV-Datei nun auf dem Raspberry Pi abgelegt wurde, erstellen wir einen Node-RED Flow, der die Daten einliest und anschließend in unserer SQLite-Datenbank speichert.
Der Flow besteht aus mehreren Nodes, die nacheinander die einzelnen Verarbeitungsschritte übernehmen:
Am Ende wird ein großes INSERT Statement erstellt welches in die Datenbank geschrieben wird.
Schritt 1: laden der Daten aus der Datei export.csv
Im ersten Schritt lesen wir die zuvor kopierte CSV-Datei vom Raspberry Pi ein.
Dazu verwenden wir eine Read-File in Node, die den Inhalt der Datei lädt und an den Flow weitergibt.
In meinem Beispiel liegt die Datei im folgenden Verzeichnis:
/home/stefan/export.csvDie Read-File-Node liest die Datei als Text ein und übergibt den Inhalt anschließend an eine CSV Node.
Diese Node zerlegt die Datei in strukturierte Datensätze und stellt sie im msg.payload bereit.
Dazu geben wir die Spalten aus der CSV-Datei an und definieren das Trennzeichen.
Wichtig ist das wir hier den Haken bei „Erste Zeile enthält Spaltennamen“ setzen sowie die Ausgabe in ein Array umleiten.
Schritt 2: erstellen der SQL INSERT INTO Statements
Das INSERT INTO Statement für die Datenbank erstellen wir mit einer Function Node denn hier müssen wir die Werte aus dem zuvor erstellten Array umwandeln.
let rows = msg.payload;
let values = [];
for (let row of rows) {
let zeit = String(row["Zeit"]).trim();
let energy = String(row["Wh"]).trim();
if (!zeit || isNaN(energy)) {
continue;
}
let parts = zeit.split(" ");
let datePart = parts[0];
let d = datePart.split("/");
let formatted = `${d[2]}-${d[1]}-${d[0]}`;
values.push(`('${formatted}', ${energy})`);
}
msg.topic = `
INSERT INTO shelly_energy_monthly (timestamp, energy_wh)
VALUES
${values.join(",\n")};
`;
return msg;
Die Ausgabe ist dann ein großes SQL Statement mit allen Daten, dabei entfernen wir den Zeitstempel welcher bei allen auf „00:00“ steht.
Schritt 3: speichern in der Datenbank
Die sqlite-Node ist so konfiguriert das, das Statement aus dem Feld msg.topic verwendet wird.
Wenn der Flow erfolgreich ausgeführt wurde dann sind die Daten aus der CSV-Datei erfolgreich in die Datenbank überführt worden.
Im nächsten Schritt können wir nun ein Dashboard erzeugen um diese Daten zu visualisieren.
Fazit: Grundlage für dein Shelly Energie-Dashboard geschaffen
Das Laden der historischen Daten aus der Shelly Cloud und das anschließende Speichern in einer SQLite-Datenbank war rückblickend deutlich einfacher, als man zunächst vermuten könnte. Mit wenigen Schritten haben wir eine solide Grundlage geschaffen, um Energiedaten lokal zu speichern und unabhängig von der Cloud weiterzuverarbeiten.
Gerade in Kombination mit Node-RED zeigt sich hier die Stärke solcher IoT-Setups: Daten lassen sich flexibel erfassen, aufbereiten und für eigene Projekte nutzen – ganz ohne zusätzliche Kosten oder proprietäre Einschränkungen.
Ausblick: Vom Datenspeicher zum smarten Dashboard
Im nächsten Teil der Reihe gehen wir einen Schritt weiter und machen die gespeicherten Daten sichtbar. Dazu laden wir die Werte aus unserer SQLite-Datenbank und stellen sie in einem übersichtlichen Dashboard dar.
Zusätzlich greifen wir direkt auf die Shelly API zu und holen uns per RPC Call die aktuellen Messwerte wie Spannung, Strom und Leistung. Diese kombinieren wir mit den bereits gespeicherten Daten, sodass du sowohl historische als auch aktuelle Werte auf einen Blick sehen kannst.
👉 Ziel ist ein modernes, eigenes Energie-Dashboard, das dir jederzeit zeigt, was dein Balkonkraftwerk aktuell leistet – und was es über den Tag hinweg erzeugt hat.
Letzte Aktualisierung am: 18. März 2026
1 thought on “Shelly Energie-Dashboard mit Node-RED – Teil 1: SQLite & Datenimport”