Energie sichtbar machen
Der bewusste Umgang mit Energie beginnt bei der Transparenz über den eigenen Verbrauch. Smartmeter – also digitale Stromzähler – liefern diese Daten, meist über eine optische Schnittstelle nach IEC 62056-21, die im SML-Format (Smart Message Language) sendet.
Doch die Daten allein reichen nicht – entscheidend ist, sie sichtbar, auswertbar und verknüpfbar zu machen. Ein Blick auf ein Energiedashboard kann schnell überraschende Erkenntnisse bringen:
- Ein Elektroherd, der im Standby 7 W zieht
- Zwei Garagentorantriebe, die dauerhaft je 10 W verbrauchen
- Ein alter Router, der 24 W Grundlast verursacht
Solche scheinbar kleinen Verbraucher summieren sich – und sind oft leichter zu optimieren als große Lasten.
Smartmeter, Energiewende und Digitale Souveränität
Smartmeter werden häufig im Kontext der Energiewende diskutiert. Unabhängig von ideologischen Debatten gilt: Daten schaffen Entscheidungsgrundlagen. Wer seinen Energiefluss kennt, kann Verbräuche zeitlich verschieben, Spitzen kappen oder Standby-Verluste vermeiden.
Ein zentrales Monitoring hilft, Verbrauchsmuster zu verstehen, nicht um Kontrolle auszuüben, sondern um sinnvolle Entscheidungen treffen zu können – im Kleinen wie im Großen.
Ich wollte die Stromzählerdaten aus meinem Haushalt direkt in mein zentrales Monitoring integrieren – ohne Cloud-Anbindung, ohne Blackbox-Appliance und ohne Abhängigkeit von externen Diensten. Das Ziel war eine Lösung, die digital souverän arbeitet: lokal, transparent, nachvollziehbar und unter voller Kontrolle der eigenen Daten.
Hardwareauswahl
Die Hardwareanforderungen sind minimal:
- ein Raspberry Pi 2 Model B (oder vergleichbar)
- zwei USB-IR-Leseköpfe nach IEC 62056-21, z. B. ELV Energiesensor ES-IEC
- Stromversorgung und Netzwerk
Die Auswahl war vor allem pragmatisch motiviert: Der Raspberry Pi 2 lag noch in der Schublade – robust, sparsam und für einen dauerhaften Betrieb mehr als ausreichend. Die IR-Leseköpfe von ELV sind als Bausatz erhältlich, was nicht nur den Preis niedrig hält, sondern auch ein gutes Verständnis über die Funktionsweise der optischen Schnittstelle vermittelt.
Gerade dieser Do-it-yourself-Charakter passt gut zum Projekt: einfache, nachvollziehbare Komponenten, die sich mit überschaubarem Aufwand zu einem vollwertigen Smartmeter-Gateway kombinieren lassen – ohne Spezialhardware, ohne Cloud, ohne Abhängigkeiten.
Architektur
┌──────────────────────────────────────────────────────────────────────────┐
│ NetBSD dom0 │
│ (Xen Hypervisor Host) │
│ │
│ ┌──────────────────────────────────────────────────────────────────┐ │
│ │ Xen domU │ │
│ │ (Monitoring Virtual Machine) │ │
│ │ │ │
│ │ ┌────────────────────┐ ┌────────────────────┐ │ │
│ │ │ Prometheus │ <──── │ Grafana │ │ │
│ │ │ (scrapes metrics) │ │ (visualizes data) │ │ │
│ │ └────────┬───────────┘ └────────────────────┘ │ │
│ │ │ │ │
│ └────────────┼─────────────────────────────────────────────────────┘ │
│ │ HTTP pull (/metrics) │
└───────────────┼──────────────────────────────────────────────────────────┘
│
│
┌───────┴──────────────────────────────────────────────────────────┐
│ Raspberry Pi │
│ Smartmeter-Gateway (Flask App) │
│ http://pi:8080/metrics │
│ │
└──────────────────────────────────────────────────────────────────┘
│ │
USB(ttyUSB0) USB(ttyUSB1)
│ │
▼ ▼
┌────────────────────────┐ ┌────────────────────────┐
│ USB-IR-Lesekopf #1 │ │ USB-IR-Lesekopf #2 │
│ (IEC 62056-21, SML) │ │ (IEC 62056-21, SML) │
└────────────────────────┘ └────────────────────────┘
Softwarebasis: Buildroot
Für die Softwareseite fiel die Wahl auf Buildroot – ein Framework, das minimalistische, maßgeschneiderte Linux-Systeme generiert. Der Fokus liegt auf kleinen Images, klarer Struktur und stabiler Reproduzierbarkeit – ideal für embedded Systeme.
Build-Vorbereitung
$ wget https://buildroot.org/downloads/buildroot-2024.02.10.tar.gz
$ tar xvfz buildroot-2024.02.10.tar.gz
$ cd buildroot-2024.02.10/
$ make list-defconfigs | grep rasp
raspberrypi0_defconfig
raspberrypi2_defconfig
raspberrypi3_defconfig
raspberrypi4_defconfig
$ make raspberrypi2_defconfig
$ make menuconfig
Wichtige Einstellungen
Filesystem Images
- Exact size: 256M
Toolchain
- C library: musl
System Configuration
- System hostname: gateway
- System banner: Welcome to Smartmeter Gateway
- /dev Management: Dynamic using devtmpfs + eudev
- Root password: **********
Target Packages
-
Interpreter Languages and scripting
- python3
- Core Python Modules: ssl, sqlite, xml, zlib
- External Python Modules:
- python-flask
- python-flask-login
- python-flask-sqlalchemy
- python-pyzmq
- python-requests
- python-serial
- python-serial-asyncio
- python-paho-mqtt
- python-pip
- python3
-
Networking Applications
- rsync
- avahi (mDNS/DNS-SD daemon)
- dropbear
- chrony
- shellinabox
-
Shell and utilities
- tmux
Build starten
$ make all
Ergebnis: Ein vollständiges, minimales Linux-Image mit Python und Netzwerk-Support. Nach dem Build lässt es sich per dd auf eine SD-Karte übertragen und bootet anschließend unmittelbar auf dem Raspberry Pi.
Nach der Installation
Nach dem ersten Boot wird das System (mit angeschlossenem Display) grundlegend konfiguriert. Nach Abschluss dieses Schrittes kann über die Netzwerkschnittstelle mit dem angelegten user per SSH zugegriffen werden.
Chrony (Zeitdienst)
# nano /etc/chrony.conf
pool pool.ntp.org iburst
initstepslew 10 pool.ntp.org
driftfile /var/lib/chrony/chrony.drift
rtcsync
cmdport 0
Benutzer einrichten
# mkdir /home
# adduser user
# vi /etc/group
dialout:x:18:user
Python Virtual Environment
$ cd /home/user
$ python -m venv --system-site-packages .venv
$ . .venv/bin/activate
(.venv) $ pip install smllib flask
Der Prometheus-Exporter
Das folgende Python-Skript liest die SML-Daten beider Zähler, extrahiert die relevanten Werte und stellt sie als Prometheus-kompatible Metriken auf Port 8080 bereit.
#!/usr/bin/env python
import serial
import threading
import queue
from smllib import SmlStreamReader
from flask import Flask, Response
app = Flask(__name__)
data_store = {}
data_queue = queue.Queue()
@app.route("/metrics")
def metrics():
body = ""
for key in data_store.keys():
body += key + " " + str(data_store[key]) + "\n"
return Response(body, mimetype='text/plain')
def read_from_serial(port, baudrate, key):
try:
ser = serial.Serial(port, baudrate, timeout=True)
stream = SmlStreamReader()
while True:
data = ser.readline()
stream.add(data)
sml_frame = stream.get_frame()
if sml_frame is None:
continue
parsed_msgs = sml_frame.parse_frame()
obis_values = parsed_msgs[1].message_body.val_list
data_queue.put((f"total_power_consumption_watt_hours{{meter=\"{key}\"}}", obis_values[2].value / 10))
data_queue.put((f"current_power_consumption_watts{{meter=\"{key}\"}}", obis_values[4].value))
except serial.SerialException as e:
print(f"Fehler beim Öffnen der seriellen Schnittstelle {port}: {e}")
def update_data_store():
while True:
key, value = data_queue.get()
data_store[key] = value
data_queue.task_done()
if __name__ == '__main__':
threading.Thread(target=read_from_serial, daemon=True, args=('/dev/ttyUSB0', 9600, 'Heizung')).start()
threading.Thread(target=read_from_serial, daemon=True, args=('/dev/ttyUSB1', 9600, 'Allgemein')).start()
threading.Thread(target=update_data_store, daemon=True).start()
app.run(debug=False, host='0.0.0.0', port=8080)
Ergebnis: Prometheus-Endpunkt
Nach dem Start des Skripts liefert der Aufruf von
http://<raspberrypi>:8080/metrics z. B. folgende Ausgabe:
total_power_consumption_watt_hours{meter="Heizung"} 182456.7
current_power_consumption_watts{meter="Heizung"} 64.3
total_power_consumption_watt_hours{meter="Allgemein"} 521109.1
current_power_consumption_watts{meter="Allgemein"} 243.6
Diese Daten können von Prometheus regelmäßig abgefragt werden und lassen sich direkt in Grafana visualisieren.
Integration in Grafana
Ein einfaches Energiedashboard zeigt:
- aktuelle Leistung pro Zähler
- Tages-, Wochen- und Monatsverbräuche
- Verlaufskurven der Grundlast
Damit erkennt man Lastspitzen und stille Verbraucher sofort – und kann daraus konkrete Optimierungen ableiten.
Fazit
Fazit: Mit wenig Aufwand lässt sich ein Smartmeter-Gateway aufbauen, das Messdaten in Echtzeit bereitstellt und sich nahtlos in bestehende Monitoring-Lösungen integrieren lässt.
Das Projekt zeigt: Energieeffizienz beginnt mit Transparenz. Man erkennt Lastprofile, entdeckt Standby-Verbraucher und kann gezielt Maßnahmen ableiten. Selbst ein paar Watt hier und dort summieren sich – und wer die Daten kennt, kann sie nutzen. Ein kleines Gateway, das hilft, Energie sichtbar zu machen.
Bildnachweis: Das Prometheus-Logo ist eine eingetragene Marke der Cloud Native Computing Foundation (CNCF). Verwendung im Rahmen redaktioneller Berichterstattung.