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.
- 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.


- HaltMagnet am StahlringDer NdFeB-Ring hat 3,5 kg Haftkraft und hält den Kopf ohne Werkzeug. Zum Abnehmen einfach abziehen.
- LageKabel nach untenSo sitzt der Kopf üblicherweise. Bei einigen Zählern kommt es auf die Lage an, siehe Passende Zähler.
- Ohne RingHalter 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.

- ZählerseiteFrontplatteDie zweite Scheibe aus dem Nutzen, gewendet aufgesetzt. Zwei Fenster mit 2 mm Durchmesser liegen genau über LED und Fototransistor (Abstand 6,5 mm).
- MitteMagnetringNdFeB N40, 25/20 × 2 mm, axial magnetisiert, vernickelt. Hält den Kopf am Stahlring des Zählers. Die Bauteile liegen im Innenraum des Rings.
- HintenElektronikplatineBauteile zeigen zur Frontplatte. Auf der Rückseite liegen die Lötaugen GND, TX, RX und VCC.
- Rand3 KabelbinderJe einer durch ein Schlitzpaar beider Scheiben, Verschluss hinten. Schlitze 2,55 × 1,4 mm, also Kabelbinder bis 2,5 mm Breite.




Montage
- Scheiben trennen. Elektronikplatine und Frontplatte am perforierten Steg auseinanderbrechen und den Grat glätten.
- 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.
- Empfindlichkeit einstellen. Trimmer RV1 („SENSIVITY“) jetzt einstellen, nach dem Zusammenbau liegt er unter der Frontplatte. Vorgehen siehe Schaltplan.
- 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.
- Frontplatte aufsetzen. Gewendet auflegen, sodass die Fenster über LED und Fototransistor liegen. Dann decken sich alle drei Schlitzpaare.
- 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.

So wird daraus ein USB-Lesekopf
- 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.
- 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.
- Trimmer bei 5 V einstellen. Das Kabel liefert 5 V. RV1 bei dieser Spannung einstellen und nicht auf Anschlag drehen, dann zusammenbauen.
- Einstecken. Linux:
/dev/ttyUSB0, mit festem Namen unter/dev/serial/by-id/. Windows: ein COM-Port im Geräte-Manager.
| Lötauge | Signal | Richtung | Kabelader | Bedeutung |
|---|---|---|---|---|
| VCC | +IN | Eingang | rot, 5 V | Versorgung, über Schottky-Diode D1 (Verpolschutz) |
| RX | RXD | zum Host | weiß | Low, solange Licht vom Zähler ankommt |
| TX | TX | vom Host | grün | Low schaltet die IR-LED ein (Startbit = Licht an) |
| GND | GND | – | schwarz | Masse |
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()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 "!"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.
| Kopf | Arduino Uno / Nano · 5 V | Raspberry Pi · 3,3 V | ESP32 · 3,3 V |
|---|---|---|---|
| VCC | 5V | 3V3Pin 1 | 3V3 |
| GND | GND | GNDPin 6 | GND |
| RX zum Board | D10SoftwareSerial RX | GPIO15 · RXDPin 10 | GPIO16 · RX2 |
| TX vom Board | D11SoftwareSerial TX | GPIO14 · TXDPin 8 | GPIO17 · TX2nur lesen: an 3V3 |
| Schnittstelle | |||
| UART | SoftwareSerial | /dev/serial0 | Serial2 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;
}
}
}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: measurementSketch 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.
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.
| Ref | Anz. | Wert | Bauteil | Gehäuse | LCSC |
|---|---|---|---|---|---|
| Elektronik | |||||
| C1, C2 | 2 | 1 µF / 50 V, X5R | Samsung CL10A105KB8NNNC | 0603 | C15849 |
| D1 | 1 | Schottky 40 V / 1 A | Hottech 1N5819WS | SOD-323 | C191023 |
| D2–D4 | 3 | TVS, 5 V Sperrspannung | Shikues ESD5Z5.0 | SOD-523 | C475685 |
| LED1 | 1 | IR-LED 940 nm | NEWOPTO XYC-IR26C-LX4 | 1206 | C2693592 |
| Q1 | 1 | Fototransistor 940 nm | Everlight PT17-21C/L41/TR8 | 0805 | C100090 |
| R1, R2 | 2 | 10 kΩ, 1 % | UNI-ROYAL 0603WAF1002T5E | 0603 | C25804 |
| R3 | 1 | 120 Ω, 1 % | UNI-ROYAL 0603WAF1200T5E | 0603 | C22787 |
| R4 | 1 | 200 kΩ, 1 % | UNI-ROYAL 0603WAF2003T5E | 0603 | C25811 |
| RV1 | 1 | Trimmer 15 kΩ | HDK VG039NCHXTB153 | SMD 3,8 × 3 mm | C128547 |
| T1 | 1 | NPN 45 V / 0,5 A | Hottech BC817-40 | SOT-23 | C181151 |
| U1 | 1 | 2× Schmitt-Puffer | TI SN74LVC2G17DBVR | SOT-23-6 | C10429 |
| Mechanik und Zubehör | |||||
| – | 1 | Platinenpaar | Elektronikplatine und Frontplatte, Ø 31 mm, 1,6 mm, schwarz | Nutzen | – |
| – | 1 | Ringmagnet | NdFeB N40, 25/20 × 2 mm, axial, vernickelt, 3,5 kg | – | – |
| – | 3 | Kabelbinder | bis 2,5 mm breit | – | – |
| – | 1 | USB-TTL-Kabel | fü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.
| Betriebsart | Format | TX nötig | Beispiele |
|---|---|---|---|
| SML, sendet von selbstmoderne Messeinrichtung, eHZ; heute der Normalfall | 9600 Bd 8N1 | nein | EasyMeter 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 selbst | 9600 Bd 7E1 | nein | EasyMeter Q3D, Q1D · eBZ DD3 (OD) · Hager EHZ161, EHZ361 · Logarex LK13BE803039 |
| IEC 62056-21 Mode A/C, antwortet auf Anfrageältere Zähler und Industriezähler | Start 300 Bd 7E1, /?! | ja | Landis+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
| Schnittstelle | optisch nach IEC 62056-21 (D0), elektrisch UART/TTL |
|---|---|
| Versorgung | 3,3–5 V an VCC, Verpolschutz durch Schottky-Diode |
| Logikpegel | entspricht der Versorgung; RXD-High ≈ VCC − 0,3 V |
| Signallogik | Licht empfangen → RXD Low · TX Low → LED an |
| Stromaufnahme | berechnet: Ruhe < 0,1 mA · Empfang aktiv + 0,5 mA · LED an ≈ 12 mA (3,3 V) bzw. 25 mA (5 V) |
| Optik | 940 nm für Sender und Empfänger · Abstand 6,5 mm · Fenster Ø 2 mm |
| Empfindlichkeit | einstellbar mit Trimmer RV1 (15 kΩ) |
| Schutz | TVS-Dioden 5 V an VCC, RXD und TX |
| Abmessungen | Ø 31 mm · 5,2 mm hoch ohne Kabelbinder |
| Magnet | NdFeB N40, Ring 25/20 × 2 mm, axial, vernickelt, Haftkraft 3,5 kg |
| Befestigung | 3 Kabelbinder bis 2,5 mm Breite, Schlitze 2,55 × 1,4 mm im 120°-Raster |
| Lötaugen | Rückseite, von links: GND · TX · RX · VCC |