Optischer Schreib-Lesekopf · IEC 62056-21

IR-HEAD TTL

Liest die optische Datenschnittstelle elektronischer Stromzähler und kann auch senden. Ein Neodym-Ring hält den Kopf am Zähler. Die Daten kommen als UART/TTL-Signal, direkt passend für ein USB-TTL-Kabel, einen Raspberry Pi, einen ESP32 oder einen Arduino.

USB-VersionMikrocontroller

IR-HEAD TTL zusammengebaut: zwei schwarze runde Platinen mit Magnetring dazwischen, drei weiße Kabelbinder, Anschlusskabel
IEC 62056-21
Optische D0-Schnittstelle: SML und Mode A bis D
3,3–5 V TTL
UART direkt, Pegel entspricht der Versorgung
Ø 31 mm
Neodym-Ringmagnet mit 3,5 kg Haftkraft
Senden + Empfangen
940 nm, 300 bis 9600 Baud

Am Zähler

Der Ringmagnet zieht den Kopf an den Stahlring der optischen Schnittstelle. Die Frontplatte liegt plan auf, die beiden Fenster sitzen vor Sender und Empfänger des Zählers. Das Kabel hängt nach unten weg.

IR-HEAD TTL am Stahlring der optischen Schnittstelle eines Drehstromzählers, darüber das Display mit Zählerstand, Kabel hängt nach unten
Am Drehstromzähler (Darstellung mit neutralem Zähler)
Seitenansicht am Zähler: Stahlring der Schnittstelle, Frontplatte, silberner Magnetring, Elektronikplatine mit Kabelbindern und Kabel
Seitenansicht: Stahlring, Frontplatte, Magnetring, Elektronikplatine
  • Halt
    Magnet am StahlringDer NdFeB-Ring hat 3,5 kg Haftkraft und hält den Kopf ohne Werkzeug. Zum Abnehmen einfach abziehen.
  • Lage
    Kabel nach untenSo sitzt der Kopf üblicherweise. Bei einigen Zählern kommt es auf die Lage an, siehe Passende Zähler.
  • Ohne Ring
    Halter oder BlechFehlt der Stahlring am Zähler, hilft ein Halter oder ein aufgeklebtes Blech.

Zwei Scheiben, ein Magnetring, drei Kabelbinder

Der Kopf ist ein Sandwich aus der Elektronikplatine und einer gewendeten Frontplatte. Der 2 mm hohe Magnetring liegt dazwischen und dient zugleich als Abstandshalter. Beide Scheiben haben drei Schlitzpaare im 120°-Raster, die beim Stapeln genau übereinanderliegen.

Explosionsdarstellung: oben die Frontplatte mit zwei Fenstern, in der Mitte der silberne Magnetring, unten die Elektronikplatine mit Bauteilen und Anschlussadern
Frontplatte, Magnetring, Elektronikplatine (von oben nach unten)
  • Zählerseite
    FrontplatteDie zweite Scheibe aus dem Nutzen, gewendet aufgesetzt. Zwei Fenster mit 2 mm Durchmesser liegen genau über LED und Fototransistor (Abstand 6,5 mm).
  • Mitte
    MagnetringNdFeB N40, 25/20 × 2 mm, axial magnetisiert, vernickelt. Hält den Kopf am Stahlring des Zählers. Die Bauteile liegen im Innenraum des Rings.
  • Hinten
    ElektronikplatineBauteile zeigen zur Frontplatte. Auf der Rückseite liegen die Lötaugen GND, TX, RX und VCC.
  • Rand
    3 KabelbinderJe einer durch ein Schlitzpaar beider Scheiben, Verschluss hinten. Schlitze 2,55 × 1,4 mm, also Kabelbinder bis 2,5 mm Breite.
Zählerseite: runde schwarze Frontplatte mit zwei kleinen Fenstern und drei Kabelbinderbändern am Rand
Zählerseite: Fenster für Sender und Empfänger, Kabelbinder im 120°-Raster
Rückseite: Beschriftung IR-HEAD TTL, Lötaugen GND, TX, RX, VCC mit angelöteten Adern, Verschlüsse der Kabelbinder
Rückseite: Lötaugen und Kabelbinderverschlüsse
Platinenpaar, Oberseite: links die Frontplatte mit zwei Bohrungen, rechts die bestückte Elektronikplatine
Platinenpaar, Oberseite: Frontplatte und Elektronikplatine hängen an einem perforierten Steg
Platinenpaar, Unterseite: Beschriftung, CE- und WEEE-Zeichen, Lötaugen GND TX RX VCC
Platinenpaar, Unterseite

Montage

  1. Scheiben trennen. Elektronikplatine und Frontplatte am perforierten Steg auseinanderbrechen und den Grat glätten.
  2. Kabel anlöten. Adern von hinten in die Lötaugen der Elektronikplatine stecken und verlöten: VCC rot, RX weiß, TX grün, GND schwarz. Die Belegung steht auf der Rückseite.
  3. Empfindlichkeit einstellen. Trimmer RV1 („SENSIVITY“) jetzt einstellen, nach dem Zusammenbau liegt er unter der Frontplatte. Vorgehen siehe Schaltplan.
  4. Magnetring auflegen. Ring mittig auf die Kreismarkierung der Bauteilseite legen. Die Bauteile sind höchstens etwa 1,5 mm hoch und passen in den 2 mm hohen Ring.
  5. Frontplatte aufsetzen. Gewendet auflegen, sodass die Fenster über LED und Fototransistor liegen. Dann decken sich alle drei Schlitzpaare.
  6. Kabelbinder schließen. Durch jedes Schlitzpaar einen Kabelbinder führen, Verschluss auf die Rückseite, festziehen und bündig abschneiden. Auf der Zählerseite bleiben nur die flachen Bänder.

USB-Version: der Wandler steckt im Stecker

Am einfachsten läuft der Kopf an einem fertigen USB-TTL-Kabel, bei dem der Wandler im USB-A-Stecker sitzt (PL2303, CP2102, CH340 oder FT232). Die Dupont-Buchsen werden abgeschnitten und die vier Adern direkt an den Kopf gelötet. Am PC erscheint er als serielle Schnittstelle.

USB-Version: schwarzer USB-A-Stecker mit eingebautem Wandler, Kabel mit Knickschutz, am anderen Ende der Lesekopf
USB-TTL-Kabel direkt am Kopf angelötet

So wird daraus ein USB-Lesekopf

  1. Dupont-Buchsen abschneiden, Adern 3 bis 4 mm abisolieren und verzinnen. Die Farben vorher am Datenblatt des Kabels prüfen. Bei FTDI-Kabeln ist zum Beispiel orange TXD und gelb RXD.
  2. 1:1 anlöten: rot an VCC, weiß an RX, grün an TX, schwarz an GND. Nicht kreuzen, die Lötaugen sind aus Sicht des Hosts benannt.
  3. Trimmer bei 5 V einstellen. Das Kabel liefert 5 V. RV1 bei dieser Spannung einstellen und nicht auf Anschlag drehen, dann zusammenbauen.
  4. Einstecken. Linux: /dev/ttyUSB0, mit festem Namen unter /dev/serial/by-id/. Windows: ein COM-Port im Geräte-Manager.
LötaugeSignalRichtungKabeladerBedeutung
VCC+INEingangrot, 5 VVersorgung, über Schottky-Diode D1 (Verpolschutz)
RXRXDzum HostweißLow, solange Licht vom Zähler ankommt
TXTXvom HostgrünLow schaltet die IR-LED ein (Startbit = Licht an)
GNDGND–schwarzMasse

Kabel mit 5-V-Pegel bevorzugen

Am 5-V-Pin läuft der Kopf mit etwa 4,7 V. Ein Kabel mit 5-V-Logik liegt an TX sicher über der Schaltschwelle von U1. Ein 3,3-V-Kabel wie das PL2303HX funktioniert in der Praxis auch, das Datenblatt garantiert es aber nicht (Schwelle bis etwa 3,2 V). Für Zähler, die nur senden, spielt TX keine Rolle.

RX muss 5 V vertragen

RXD liefert als High etwa 4,7 V. Die RX-Leitung des PL2303HX-Kabels verträgt laut Händlern 5 V. Bei anderen 3,3-V-Kabeln vorher im Datenblatt nachsehen.

Treiber

FT232, CP2102 und CH340 laufen unter Linux ohne Zusatztreiber, unter Windows kommt der Treiber in der Regel automatisch. Ältere und nachgebaute PL2303HX-Chips werden laut Händlern unter Windows 10/11 nicht unterstützt, unter Linux und auf dem Raspberry Pi schon.

TX nicht offen lassen

Der TX-Eingang hat keinen Pull-up. Offen kann die LED unkontrolliert leuchten. Am USB-TTL-Kabel liegt TX im Ruhezustand auf High, das passt.

Software

Schnelltest unter Linux

Bei einem SML-Zähler erscheint alle ein bis vier Sekunden ein Telegramm, das mit 1b1b 1b1b 0101 0101 beginnt.

stty -F /dev/ttyUSB0 9600 raw cs8 -parenb -echo
xxd /dev/ttyUSB0

Für Mode D (Text, 7E1) stattdessen cs7 parenb -parodd setzen und mit cat lesen.

Fertige Programme

Home Assistant: Integration EDL21, liest SML von einer seriellen Schnittstelle.

Volkszähler: vzlogger mit den Protokollen sml und d0.

ioBroker: Adapter smartmeter, kann SML und D0 einschließlich Anfrage.

Als Port jeweils den Pfad unter /dev/serial/by-id/ eintragen.

Zählerstand und Leistung mit Python lesensml_lesen.py · USB-Kabel und Raspberry Pi · pip install pyserial
#!/usr/bin/env python3
"""Zaehlerstand (1.8.0) und Leistung (16.7.0) aus SML lesen. pip install pyserial"""
import sys, serial

PORT = sys.argv[1] if len(sys.argv) > 1 else "/dev/serial0"   # USB-Kabel: /dev/ttyUSB0
OBIS = {"Bezug kWh": bytes.fromhex("070100010800ff"),
        "Leistung W": bytes.fromhex("070100100700ff")}

def skip(b, i):
    """Ein SML-Feld ueberspringen (auch Listen und lange Strings)."""
    tl = b[i]
    if tl & 0x70 == 0x70:                       # Liste mit n Elementen
        i += 1
        for _ in range(tl & 0x0F):
            i = skip(b, i)
        return i
    n = tl & 0x0F
    if tl & 0x80:                               # zweiteilige Laengenangabe
        n = (n << 4) | (b[i + 1] & 0x0F)
    return i + max(n, 1)

def wert(b, obis):
    i = b.find(obis)
    if i < 0:
        return None
    i += len(obis)
    i = skip(b, i)                              # status
    i = skip(b, i)                              # valTime
    i = skip(b, i)                              # unit
    scaler = int.from_bytes(b[i + 1:i + 2], "big", signed=True) if b[i] == 0x52 else 0
    i = skip(b, i)
    n = (b[i] & 0x0F) - 1
    v = int.from_bytes(b[i + 1:i + 1 + n], "big", signed=(b[i] & 0x70) == 0x50)
    return v * 10 ** scaler                     # Wh bzw. W

START, ENDE = b"\x1b\x1b\x1b\x1b\x01\x01\x01\x01", b"\x1b\x1b\x1b\x1b\x1a"

def main():
    s = serial.Serial(PORT, 9600, timeout=2)    # SML: 9600 8N1
    buf = b""
    while True:
        buf += s.read(256)
        a = buf.find(START)
        e = buf.find(ENDE, a + 8) if a >= 0 else -1
        if e < 0:
            buf = buf[-2048:]
            continue
        tel, buf = buf[a:e + 8], buf[e + 8:]
        for name, obis in OBIS.items():
            v = wert(tel, obis)
            if v is not None:
                print(f"{name}: {v / 1000:.4f}" if "kWh" in name else f"{name}: {v:.0f}")

if __name__ == "__main__":
    main()

sml_lesen.py herunterladen

Zähler, die erst auf eine Anfrage antworten (Mode A/C)modus_c.py · 300 Bd 7E1
# Zähler nach IEC 62056-21 Mode A/C: erst fragen, dann lesen (300 Bd, 7E1)
import serial
s = serial.Serial("/dev/ttyUSB0", 300, bytesize=7, parity="E", timeout=60)
s.write(b"/?!\r\n")                       # Anfrage an jeden Zähler
print(s.readline())                       # Kennung, z. B. b'/ISk5MT174-0001\r\n'
s.write(b"\x06000\r\n")                   # ACK: normal, 300 Bd bleiben, Daten auslesen
print(s.read_until(b"!").decode("ascii", "replace"))   # Datensatz endet mit "!"

modus_c.py herunterladen

Direkt an Arduino, Raspberry Pi und ESP32

Ohne USB-Wandler hängt der Kopf direkt an einem UART. Die Versorgung bestimmt den Pegel an RXD. Deshalb bekommt der Kopf an 3,3-V-Boards 3,3 V und an 5-V-Boards 5 V. Die Lötaugen sind aus Sicht des Boards benannt: RX des Kopfs an RX des Boards, TX an TX.

KopfArduino Uno / Nano · 5 VRaspberry Pi · 3,3 VESP32 · 3,3 V
VCC5V3V3Pin 13V3
GNDGNDGNDPin 6GND
RX zum BoardD10SoftwareSerial RXGPIO15 · RXDPin 10GPIO16 · RX2
TX vom BoardD11SoftwareSerial TXGPIO14 · TXDPin 8GPIO17 · TX2nur lesen: an 3V3
Schnittstelle
UARTSoftwareSerial/dev/serial0Serial2 oder ESPHome uart

Raspberry Pi und ESP32 nie mit 5 V

An 5 V gibt RXD etwa 4,7 V aus. Die GPIOs von Raspberry Pi und ESP32 vertragen nur 3,3 V. Mit 3,3 V Versorgung liegt RXD-High bei etwa 3,0 V, das erkennen beide sicher.

Trimmer bei der Betriebsspannung einstellen

Die Empfindlichkeit hängt von der Versorgung ab. RV1 also an dem Board einstellen, an dem der Kopf später läuft. An 3,3 V ist der ganze Drehbereich nutzbar.

Arduino

Uno und Nano brauchen den Hardware-UART für USB, deshalb SoftwareSerial an D10/D11. Mega und Leonardo haben mit Serial1 einen zweiten Hardware-UART, der auch SERIAL_7E1 für Mode D kann. 3,3-V-Boards wie Nano 33 IoT, Nano ESP32 oder Due versorgen den Kopf mit 3,3 V.

7E1 mit SoftwareSerial

SoftwareSerial kennt nur 8N1. Ein 7E1-Zeichen ist genauso lang, also als 8N1 lesen und das oberste Bit mit c & 0x7F abschneiden. So lassen sich auch Mode-D-Zähler lesen.

Raspberry Pi einrichten

sudo raspi-config → Interface Options → Serial Port: Login-Shell nein, Hardware ja. Danach in /boot/firmware/config.txt:

enable_uart=1
dtoverlay=disable-bt   # Pi 3, 4, Zero W, Zero 2 W

Damit liegt der PL011-UART auf GPIO14/15. Der Mini-UART kann keine Parität und taugt nicht für 7E1. Beim Pi 5 stattdessen dtparam=uart0=on, Gerät /dev/ttyAMA0. Dann python3 sml_lesen.py /dev/serial0.

ESP32

Beim klassischen ESP32 sind GPIO16/17 die Standardpins von Serial2. Bei WROVER-Modulen belegt das PSRAM diese Pins, dann zwei andere GPIOs nehmen. Der ESP32-C3 hat nur Serial1, die Pins sind frei wählbar. GPIO6 bis 11 sind für den Flash reserviert.

Arduino-Sketch für Uno, Nano und ESP32ir_head_sml.ino · SML 9600 8N1 · serieller Monitor mit 115200 Bd
// IR-HEAD TTL: Zaehlerstand (1.8.0) und Leistung (16.7.0) aus SML lesen, 9600 8N1.
// Arduino Uno/Nano: RXD -> D10, TX <- D11, VCC 5 V.  ESP32: RXD -> GPIO16, TX <- GPIO17, VCC 3,3 V.
#if defined(ESP32)
  #define ZAEHLER Serial2
#else
  #include <SoftwareSerial.h>
  SoftwareSerial ZAEHLER(10, 11);              // RX, TX
#endif

const uint8_t START[8] = {0x1B, 0x1B, 0x1B, 0x1B, 0x01, 0x01, 0x01, 0x01};
const uint8_t BEZUG[7] = {0x07, 0x01, 0x00, 0x01, 0x08, 0x00, 0xFF};      // 1-0:1.8.0
const uint8_t LEISTUNG[7] = {0x07, 0x01, 0x00, 0x10, 0x07, 0x00, 0xFF};   // 1-0:16.7.0
uint8_t buf[512];
uint16_t len = 0;

uint16_t skip(uint16_t i) {                     // ein SML-Feld ueberspringen
  if (i >= len) return len;
  uint8_t tl = buf[i];
  if ((tl & 0x70) == 0x70) {                    // Liste
    i++;
    for (uint8_t k = 0; k < (tl & 0x0F); k++) i = skip(i);
    return i;
  }
  uint16_t n = tl & 0x0F;
  if ((tl & 0x80) && i + 1 < len) n = (n << 4) | (buf[i + 1] & 0x0F);
  return i + (n ? n : 1);
}

bool wert(const uint8_t *obis, float &out) {    // Ergebnis in Wh bzw. W
  for (uint16_t i = 0; i + 7 <= len; i++) {
    if (memcmp(buf + i, obis, 7) != 0) continue;
    uint16_t p = skip(skip(skip(i + 7)));       // status, valTime, unit
    if (p + 1 >= len) return false;
    int8_t scaler = (buf[p] == 0x52) ? (int8_t)buf[p + 1] : 0;
    p = skip(p);
    if (p >= len) return false;
    uint8_t tl = buf[p], n = (tl & 0x0F) - 1;
    if (n < 1 || n > 8 || p + n >= len) return false;
    uint64_t u = 0;
    for (uint8_t k = 1; k <= n; k++) u = (u << 8) | buf[p + k];
    if ((tl & 0x70) == 0x50 && (buf[p + 1] & 0x80) && n < 8) u |= ~0ULL << (8 * n);
    out = (float)(int64_t)u * pow(10, scaler);
    return true;
  }
  return false;
}

void setup() {
  Serial.begin(115200);
#if defined(ESP32)
  ZAEHLER.begin(9600, SERIAL_8N1, 16, 17);
#else
  ZAEHLER.begin(9600);
#endif
}

void loop() {
  while (ZAEHLER.available()) {
    buf[len++] = ZAEHLER.read();
    if (len == sizeof(buf)) len = 0;            // zu lang: verwerfen
    if (len >= 8 && memcmp(buf + len - 8, START, 8) == 0) {
      memcpy(buf, START, 8);                    // Telegrammanfang
      len = 8;
    } else if (len >= 16 && memcmp(buf + len - 8, START, 4) == 0 && buf[len - 4] == 0x1A) {
      float v;                                  // Telegrammende 1B 1B 1B 1B 1A xx yy zz
      if (wert(BEZUG, v)) { Serial.print("Bezug: "); Serial.print(v / 1000, 4); Serial.println(" kWh"); }
      if (wert(LEISTUNG, v)) { Serial.print("Leistung: "); Serial.print(v, 0); Serial.println(" W"); }
      len = 0;
    }
  }
}

ir_head_sml.ino herunterladen

ESPHome-Konfiguration für Home Assistantesphome_sml.yaml · nur lesen
# ESP32 + IR-HEAD TTL, nur lesen (SML). Kopf: VCC an 3V3, RX an GPIO16, TX an 3V3.
uart:
  id: uart_bus
  rx_pin: GPIO16
  baud_rate: 9600
  data_bits: 8
  parity: NONE
  stop_bits: 1

sml:
  id: mysml
  uart_id: uart_bus

sensor:
  - platform: sml
    name: "Zählerstand Bezug"
    sml_id: mysml
    obis_code: "1-0:1.8.0"
    unit_of_measurement: kWh
    accuracy_decimals: 3
    device_class: energy
    state_class: total_increasing
    filters:
      - multiply: 0.0001   # Rohwert in 0,1 Wh; bei Zählern mit Wh-Auflösung 0.001
  - platform: sml
    name: "Leistung"
    sml_id: mysml
    obis_code: "1-0:16.7.0"
    unit_of_measurement: W
    accuracy_decimals: 0
    device_class: power
    state_class: measurement

esphome_sml.yaml herunterladen

Sketch und Python-Skript suchen im Telegramm die OBIS-Kennzahlen 1.8.0 (Zählerstand Bezug) und 16.7.0 (Momentanleistung) und rechnen den Scaler des Zählers ein. Weitere Werte lassen sich mit derselben Funktion abfragen, zum Beispiel 2.8.0 für die Einspeisung.

Schaltplan

Empfänger, Sender und Versorgung mit den bestückten Werten. Der Empfangspfad ist türkis, der Sendepfad orange markiert.

Schaltplan IR-HEAD TTL v0.2 +UB GND VCC RX TX GND Lötaugen (Rückseite) +IN RXD TX D1 1N5819WS C11 µF C21 µF D2ESD5Z5.0 R4200k Q1PT17-21C RV115k R110k T1BC817-40 R210k U1 SN74LVC2G17 52 16 RXD TX 34 D3ESD5Z5.0 D4ESD5Z5.0 R3120R LED1940 nm
Empfangspfad: Licht vom Zähler → RXD Sendepfad: TX → IR-LED RXD und TX sind über ihre Namen mit den Lötaugen verbunden

Empfangen

Fällt Licht auf Q1, fließt Strom über RV1 und R1. Steigt die Spannung an der Basis von T1 über etwa 0,6 V, schaltet T1 durch und zieht den Eingang des Schmitt-Triggers U1 auf Low. RXD geht dann auf Low. R4 spannt die Basis leicht vor. Mit RV1 wird eingestellt, wie viel Licht dafür nötig ist.

Senden

TX Low schaltet den Ausgang 2Y von U1 auf Low, und die LED leuchtet über R3. Der Strom liegt bei etwa 25 mA an 5 V und etwa 12 mA an 3,3 V. D2 bis D4 schützen VCC, RXD und TX vor ESD, D1 schützt vor Verpolung.

Empfindlichkeit einstellen

Kopf abdunkeln und mit der späteren Spannung betreiben. RV1 in Richtung „+“ drehen, bis RXD dauerhaft Low wird. Dann ein deutliches Stück zurückdrehen, etwa ein Viertel des Wegs. Wird die Versorgungsspannung gewechselt, neu einstellen.

Bei 5 V nicht auf Anschlag

Ganz aufgedreht liegt die Basis von T1 an 5 V im Dunkeln schon bei etwa 0,52 V, also knapp unter der Schaltschwelle. Wärme oder Fremdlicht lassen RXD dann auf Low hängen. An 3,3 V ist der ganze Bereich nutzbar.

Stückliste

Bauteile pro Kopf, wie bestückt.

RefAnz.WertBauteilGehäuseLCSC
Elektronik
C1, C221 µF / 50 V, X5RSamsung CL10A105KB8NNNC0603C15849
D11Schottky 40 V / 1 AHottech 1N5819WSSOD-323C191023
D2–D43TVS, 5 V SperrspannungShikues ESD5Z5.0SOD-523C475685
LED11IR-LED 940 nmNEWOPTO XYC-IR26C-LX41206C2693592
Q11Fototransistor 940 nmEverlight PT17-21C/L41/TR80805C100090
R1, R2210 kΩ, 1 %UNI-ROYAL 0603WAF1002T5E0603C25804
R31120 Ω, 1 %UNI-ROYAL 0603WAF1200T5E0603C22787
R41200 kΩ, 1 %UNI-ROYAL 0603WAF2003T5E0603C25811
RV11Trimmer 15 kΩHDK VG039NCHXTB153SMD 3,8 × 3 mmC128547
T11NPN 45 V / 0,5 AHottech BC817-40SOT-23C181151
U112× Schmitt-PufferTI SN74LVC2G17DBVRSOT-23-6C10429
Mechanik und Zubehör
–1PlatinenpaarElektronikplatine und Frontplatte, Ø 31 mm, 1,6 mm, schwarzNutzen–
–1RingmagnetNdFeB N40, 25/20 × 2 mm, axial, vernickelt, 3,5 kg––
–3Kabelbinderbis 2,5 mm breit––
–1USB-TTL-Kabelfür die USB-Version, z. B. PL2303HX, Adern rot/weiß/grün/schwarz––

Passende Zähler

Jeder Zähler mit optischer D0-Schnittstelle. Der Kopf sendet und empfängt und deckt damit alle drei Betriebsarten ab, auch ältere Zähler, die erst auf eine Anfrage antworten. Die Beispiele stammen aus der ELV-Zählerliste und der Tasmota-Dokumentation.

BetriebsartFormatTX nötigBeispiele
SML, sendet von selbstmoderne Messeinrichtung, eHZ; heute der Normalfall9600 Bd 8N1neinEasyMeter Q3A, Q3M · EMH ED300L, eHZ-K, mMe4.0 · Iskra MT175, MT631, MT681, MT691 · Holley DTZ541 · Logarex LK13BE · DZG DWS74xx, DVS74xx · Itron 3.HZ · Landis+Gyr E220, E320 · Apator Norax 3D, Lepus · EFR SGM · Kaifa MB310 · Hager EHZ363
D0 Mode D, Text, sendet von selbst9600 Bd 7E1neinEasyMeter Q3D, Q1D · eBZ DD3 (OD) · Hager EHZ161, EHZ361 · Logarex LK13BE803039
IEC 62056-21 Mode A/C, antwortet auf Anfrageältere Zähler und IndustriezählerStart 300 Bd 7E1, /?!jaLandis+Gyr E350, ZMD, ZMF, ZMR, E550, E650 · Elster/Honeywell AS1440, AS3000, A1350 · Iskra MT174, MT171, MT37x · EMH LZQJ-XC, DMTZ · MetCom MCS301 · Siemens TD3511 · Itron ACE3000

PIN beim Messstellenbetreiber

Ohne PIN liefern viele SML-Zähler nur den Zählerstand, oft mit verringerter Auflösung. Momentanleistung und volle Auflösung gibt es nach der Freischaltung. Die PIN wird mit einer Taschenlampe an der optischen Taste eingegeben.

Halt für den Magneten

Der Ring hält nur an einer Stahlplatte um die Schnittstelle. Laut ELV fehlt sie bei EMH mMe4.0, am Info-Port des EasyMeter Q3B und beim Actaris EC310D. Dort hilft ein Halter oder ein aufgeklebtes Blech.

Lage des Kopfs

Bei einigen Zählern zählt die Ausrichtung: beim EMH mMe4.0 Kabel nach links, beim L+G ZMF120ACDA nach oben, beim Itron ACE3000 ist sie kritisch.

Gegenmagnet im Zähler

Im L+G ZMB120T413 steckt ein umgekehrt gepolter Magnet. Der axial magnetisierte Ring wird dort abgestoßen und muss beim Zusammenbau gewendet werden.

Nicht passend

Ferraris-Zähler mit Drehscheibe haben keine Datenschnittstelle. Zähler mit Kundenschnittstelle über Kabel (P1 oder RJ12, vor allem in den Niederlanden und Österreich) brauchen einen anderen Adapter.

Datenrate

300 bis 9600 Baud decken die optischen Schnittstellen ab. Zähler mit 115200 Baud nutzen eine Kabelschnittstelle.

Technische Daten

Schnittstelleoptisch nach IEC 62056-21 (D0), elektrisch UART/TTL
Versorgung3,3–5 V an VCC, Verpolschutz durch Schottky-Diode
Logikpegelentspricht der Versorgung; RXD-High ≈ VCC − 0,3 V
SignallogikLicht empfangen → RXD Low · TX Low → LED an
Stromaufnahmeberechnet: Ruhe < 0,1 mA · Empfang aktiv + 0,5 mA · LED an ≈ 12 mA (3,3 V) bzw. 25 mA (5 V)
Optik940 nm für Sender und Empfänger · Abstand 6,5 mm · Fenster Ø 2 mm
Empfindlichkeiteinstellbar mit Trimmer RV1 (15 kΩ)
SchutzTVS-Dioden 5 V an VCC, RXD und TX
AbmessungenØ 31 mm · 5,2 mm hoch ohne Kabelbinder
MagnetNdFeB N40, Ring 25/20 × 2 mm, axial, vernickelt, Haftkraft 3,5 kg
Befestigung3 Kabelbinder bis 2,5 mm Breite, Schlitze 2,55 × 1,4 mm im 120°-Raster
LötaugenRückseite, von links: GND · TX · RX · VCC