Zum Inhalt

Python

Mit Python lässt sich der WattWächter TTL plattformübergreifend auslesen – am einfachsten direkt am Raspberry Pi über dessen GPIO-UART. Für Mac, Linux und Windows ohne GPIO-Pins ist der WattWächter USB die bessere Wahl, zum Testen geht auch ein USB-TTL-Adapter.

Die meisten modernen Zähler senden ihre Daten im SML-Format (Smart Message Language) mit 9600 Baud, 8N1. Wir verwenden dafür pyserial zum Einlesen der seriellen Schnittstelle und smllib zum Dekodieren der Telegramme.

So funktioniert die Kommunikation

Die meisten Zähler senden ihr Telegramm von sich aus zyklisch (Push) – bei ihnen genügt zum Auslesen die Empfangsleitung (grün / RXD). Die TX-Leitung (weiß, beim älteren TTL gelb) ist nur für die übrigen Zähler nötig, die erst per Befehl zum Senden aufgefordert werden müssen — in der Tabelle Unterstützte Zähler mit der Fußnote ⁴ markiert. Welche Ader wohin gehört, zeigt der Anschlussplan unter Anschluss → Verkabelung.

Welche Zähler müssen zum Senden aufgefordert werden?

Das zeigt die Tabelle Unterstützte Zähler: Zähler mit der Fußnote ⁴ senden erst nach einer Anfrage (IEC 62056-21, „D0“) — sie liest Beispiel-Skript 2 aus. Die meisten anderen senden SML von sich aus; für sie ist Beispiel-Skript 1 gedacht.

Einige Zähler senden D0 von selbst, ohne Anfrage (z. B. EasyMeter Q3D, Hager EHZ161/EHZ361). Für sie passt keines der beiden Skripte genau: Skript 1 erwartet SML, Skript 2 schickt immer erst eine Anfrage. Die Werte-Zeilen sind aber dieselben — mit den Schnittstellen-Einstellungen deines Zählers und ohne die Anfrage lässt sich Skript 2 leicht anpassen.

Voraussetzungen am Zähler

Damit der Zähler die vollständigen Momentanwerte (Leistung, Phasen) sendet, muss am Zähler meist die PIN deaktiviert und der erweiterte Infomodus (Inf → On) aktiviert sein. Die PIN erhältst du bei deinem Netzbetreiber. Wie das geht, steht unter Vorbereitung des Zählers.


Verkabelung

Am Raspberry Pi steckst du den WattWächter TTL direkt auf die Stiftleiste. Anschluss, Freigabe der seriellen Schnittstelle und einen ersten Test beschreibt die Seite Raspberry Pi. Zum Testen an Mac, Linux oder Windows geht auch ein handelsüblicher USB-TTL-Adapter (z. B. CP2102, FT232, CH340), mit 3,3 V versorgt.


Installation

pip install pyserial smllib

Raspberry Pi OS ab Bookworm

Dort lehnt pip die Installation ins System-Python ab („externally-managed-environment“). Lege einmalig eine virtuelle Umgebung an und starte die Skripte mit deren Python:

python3 -m venv ~/zaehler
~/zaehler/bin/pip install pyserial smllib
~/zaehler/bin/python skript.py

Beispiel-Skript 1: SML-Zähler

import serial
from smllib import SmlStreamReader
from smllib.errors import CrcError

# --- Serielle Schnittstelle -------------------------------------------------
# Raspberry Pi (GPIO-UART):  /dev/serial0
# USB-TTL-Adapter (Linux):   /dev/ttyUSB0
# macOS:                     /dev/tty.usbserial-XXXX
# Windows:                   COM3
PORT = "/dev/serial0"

# OBIS-Codes, die uns interessieren (Kurzform -> Bezeichnung)
OBIS = {
    "1.8.0":  "Bezug",        # Wh, aus dem Netz bezogen
    "2.8.0":  "Einspeisung",  # Wh, ins Netz eingespeist
    "16.7.0": "Leistung",     # W, aktuelle Wirkleistung (vorzeichenbehaftet)
}

ser = serial.Serial(PORT, baudrate=9600, bytesize=8,
                    parity="N", stopbits=1, timeout=2)
stream = SmlStreamReader()

print(f"Lese WattWächter TTL an {PORT} ...")
while True:
    data = ser.read(ser.in_waiting or 1)
    if not data:
        continue

    stream.add(data)
    try:
        frame = stream.get_frame()
    except CrcError:
        continue   # gestörtes Telegramm überspringen
    if frame is None:
        continue   # Telegramm noch nicht vollständig

    for entry in frame.get_obis():
        name = OBIS.get(entry.obis.obis_short)
        if name is None:
            continue
        value = entry.get_value()          # bereits skaliert (Wert × 10^Scaler)
        if entry.obis.obis_short in ("1.8.0", "2.8.0"):
            print(f"{name:12s}: {value / 1000:.3f} kWh")
        else:
            print(f"{name:12s}: {value:.0f} W")
    print("-" * 30)

Beispiel-Ausgabe:

Lese WattWächter TTL an /dev/serial0 ...
Bezug       : 12345.678 kWh
Einspeisung : 4321.000 kWh
Leistung    : 437 W
------------------------------

Weitere Werte auslesen

Ergänze das OBIS-Dictionary um weitere Codes (z. B. 36.7.0, 56.7.0, 76.7.0 für die Phasenleistungen oder 32.7.0, 52.7.0, 72.7.0 für die Phasenspannungen). entry.get_value() liefert den Wert bereits korrekt skaliert, entry.unit enthält den Einheiten-Code. Eine Übersicht gängiger OBIS-Codes findest du unter Weitere OBIS-Kennzahlen.


Beispiel-Skript 2: Zähler mit Anfrage (IEC 62056-21)

Ältere Zähler mit dem Protokoll IEC 62056-21 Modus C („D0“, siehe Tabelle oben) senden erst, wenn man sie fragt. Dafür muss zusätzlich die TX-Leitung angeschlossen sein (weiß, beim älteren TTL gelb). Das Skript läuft so ab, wie es auch die Zähler-Skripte des WattWächter Tasmota machen:

  1. Mit 300 Baud, 7E1 (7 Datenbits, gerade Parität, 1 Stoppbit) die Anfrage /?! senden.
  2. Der Zähler antwortet mit seiner Kennung, z. B. /LGZ5ZMD3104407.B32. Das fünfte Zeichen (5) nennt die Baudrate, mit der er seine Daten schicken kann (5 = 9600 Baud).
  3. Mit ACK 0 Z 0 bestätigen und auf diese Baudrate umschalten.
  4. Der Zähler schickt seine Werte als Textzeilen wie 1.8.0(012345.678*kWh), am Ende eine Zeile !.

Für dieses Skript genügt pyserial (pip install pyserial).

import re
import time
import serial

# --- Einstellungen ----------------------------------------------------------
PORT = "/dev/serial0"   # wie bei Skript 1: /dev/ttyUSB0, /dev/tty.usbserial-XXXX, COM3 ...
INTERVAL = 30           # Sekunden zwischen zwei Abfragen
KEEP_300 = False        # True: immer mit 300 Baud lesen (falls der Wechsel scheitert)

# Kennbuchstabe in der Zählerkennung -> Baudrate (IEC 62056-21, Modus C)
BAUD = {"0": 300, "1": 600, "2": 1200, "3": 2400, "4": 4800, "5": 9600, "6": 19200}

# Bekannte Kennzahlen bekommen einen Namen, alle anderen werden mit Code ausgegeben
NAMES = {
    "1.8.0":  "Bezug",
    "2.8.0":  "Einspeisung",
    "16.7.0": "Leistung",
    "C.1.0":  "Zählernummer",
}

# Datenzeilen wie  1.8.0(012345.678*kWh)  oder  1-0:1.8.0*255(012345.678*kWh)
LINE = re.compile(r"^(?:\d+-\d+:)?([0-9A-Z]+(?:\.[0-9A-Z]+)+)(?:\*\d+)?\(([^)*]*)(?:\*([^)]*))?\)")


def read_meter(ser):
    """Fragt den Zähler einmal ab und gibt Kennung und Werte zurück."""
    # 1. Anfrage mit 300 Baud senden
    ser.baudrate = 300
    ser.reset_input_buffer()
    ser.write(b"/?!\r\n")
    ser.flush()

    # 2. Kennung lesen, z. B. "/LGZ5ZMD3104407.B32" - das 5. Zeichen nennt die Baudrate
    ident = ser.readline().decode("ascii", "replace").strip()
    if ident == "/?!":                      # Echo der eigenen Anfrage überspringen
        ident = ser.readline().decode("ascii", "replace").strip()
    if not ident.startswith("/") or len(ident) < 5 or ident[4] not in BAUD:
        raise RuntimeError(f"Keine gültige Antwort vom Zähler: {ident!r}")
    z = "0" if KEEP_300 else ident[4]

    # 3. Bestätigen (ACK 0 Z 0) und auf die neue Baudrate umschalten
    ack = b"\x06" + b"0" + z.encode() + b"0\r\n"
    start = time.monotonic()
    ser.write(ack)
    ser.flush()
    # Umschalten, sobald das ACK draußen ist (6 Zeichen x 10 Bit bei 300 Baud = 200 ms).
    # Der Zähler darf schon 200 ms danach senden (ist der 3. Kennbuchstabe klein: 20 ms).
    time.sleep(max(0, start + len(ack) * 10 / 300 + 0.01 - time.monotonic()))
    ser.baudrate = BAUD[z]

    # 4. Datenblock lesen, bis die Endezeile "!" kommt
    values = {}
    block = None                            # Bytes nach STX, für die Prüfsumme (BCC)
    while True:
        line = ser.readline()
        if not line:
            raise RuntimeError("Zeitüberschreitung beim Lesen des Datenblocks")
        if block is None:                   # alles vor dem STX (0x02) ignorieren
            if b"\x02" not in line:
                continue
            line = line[line.index(b"\x02") + 1:]
            block = b""
        block += line
        text = line.decode("ascii", "replace").strip()
        if text.startswith("!"):
            tail = ser.read(2)              # ETX + BCC
            bcc = 0
            for b in block + tail[:1]:
                bcc ^= b
            if len(tail) < 2 or tail[0] != 0x03 or tail[1] != bcc:
                raise RuntimeError("Prüfsumme falsch - Datenblock unvollständig")
            return ident, values
        match = LINE.match(text)
        if match:
            code, value, unit = match.groups()
            values[code] = (value, unit or "")


# 7 Datenbits, gerade Parität, 1 Stoppbit - so sprechen IEC-62056-21-Zähler
ser = serial.Serial(PORT, baudrate=300, bytesize=serial.SEVENBITS,
                    parity=serial.PARITY_EVEN, stopbits=serial.STOPBITS_ONE, timeout=2)

print(f"Frage Zähler an {PORT} ab (IEC 62056-21) ...")
while True:
    try:
        ident, values = read_meter(ser)
        print(f"Zähler: {ident}")
        for code, (value, unit) in values.items():
            print(f"{NAMES.get(code, code):14s}: {value} {unit}")
    except RuntimeError as err:
        print(f"Fehler: {err}")
    print("-" * 30)
    time.sleep(INTERVAL)

Beispiel-Ausgabe:

Frage Zähler an /dev/serial0 ab (IEC 62056-21) ...
Zähler: /LGZ5ZMD3104407.B32
Zählernummer  : 12345678
Bezug         : 012345.678 kWh
Einspeisung   : 004321.000 kWh
Leistung      : 00.437 kW
------------------------------

Welche Kennzahlen kommen?

Das Skript gibt alle Werte aus, die der Zähler schickt — bekannte mit Namen, alle anderen mit ihrer Kennzahl. Die Schreibweise unterscheidet sich je nach Hersteller: Manche Zähler senden 16.7.0, andere 16.7. Ergänze NAMES um die Codes deines Zählers. Welche Kennzahl was bedeutet, steht unter Messwerte.


Fehlerbehebung

Problem Mögliche Ursache / Lösung
Permission denied auf /dev/... Benutzer zur Gruppe dialout hinzufügen: sudo usermod -aG dialout $USER, danach neu anmelden
Keine Daten / frame bleibt None Lesekopf nicht korrekt über der IR-Diode positioniert; grünes Kabel (RXD) nicht am RX des Raspberry Pi bzw. Adapters; falscher Port
Nur Energiezähler, keine Leistung/Phasen Am Zähler PIN deaktivieren und Inf → On setzen
Am Raspberry Pi kommt nichts an Serielle Login-Shell deaktiviert? Port /dev/serial0 statt /dev/ttyAMA0 verwenden
Werte um Faktor 10/100 falsch In seltenen Fällen get_obis() durch parse_frame() ersetzen (siehe smllib-Doku)
Skript 2: „Keine gültige Antwort vom Zähler“ TX-Leitung (weiß, beim älteren TTL gelb) nicht angeschlossen oder nicht am TX des Raspberry Pi bzw. Adapters; Lesekopf nicht richtig über der IR-Schnittstelle; der Zähler spricht SML — dann Skript 1 verwenden
Skript 2: Zeitüberschreitung beim Datenblock oder „Prüfsumme falsch“ Manche Zähler schaffen den Baudratenwechsel nicht zuverlässig — KEEP_300 = True setzen, dann bleibt die Verbindung bei 300 Baud