08 · STD-Beispiele
Mindestversionen der Bibliotheken: Arduino 1.6.2 und ESP-IDF 1.7.3 bei einem Modul mit Snapshot-Bänken und Energiezählern; Python 1.6.0; ESPHome 1.9.0. Snapshot-Bank-Aufrufe benötigen Python 1.6.1 und ESPHome 1.9.1. Snapshot-Bänke in den Bibliotheken: Arduino, ESP-IDF, ESPHome (period_banks:); Python hat die Aufrufe std_arm_banks, std_latch, std_read_latch, std_latch_wh.
Die Client-Bibliotheken lesen STD- und BASIC-Module mit denselben Aufrufen; die nur bei STD vorhandenen Größen (Blind- und Scheinleistung, Gesundheitszähler, Snapshot-Bänke) sind hinter einer Linienprüfung verfügbar.
| Plattform | Beispiel | Zeigt |
|---|---|---|
| Arduino | rbamp-arduino, examples/11_StdLine |
ein Sketch für beide Linien: begin() erkennt die Linie; Echtzeitwerte; Gesundheitszähler; eine vom Master getaktete Periode auf Snapshot-Bank 1 |
| ESP-IDF | rbamp-esp-idf, examples/std_meter |
STD-Zählerauslesung mit der ESP-IDF-Komponente |
| Python (CPython) | rbamp-python, die Paketbeispiele | dieselben Lesevorgänge auf Raspberry Pi und Servern |
Arduino: der Kern des Sketches
(Serial.printf wie im ESP32-Arduino-Core; auf anderen Boards Serial.print verwenden.)
#include
#include
static RbAmp dev(Wire, 0x50);
void setup() {
Serial.begin(115200);
Wire.begin();
while (!dev.begin()) delay(1000); // detects BASIC or STD
if (dev.line() == RbAmpLine::Std) {
dev.stdArmBanks((1u << 0) | (1u << 1)); // arm banks 0 and 1
dev.stdLatch(1); // start the first period of bank 1
}
}
void loop() {
RbAmpSnapshot s;
if (dev.readAll(s)) {
Serial.printf("U=%.1f V I=%.2f A P=%.1f W\n", s.voltage, s.current[0], s.power[0]);
if (dev.line() == RbAmpLine::Std)
Serial.printf("Q=%.1f var S=%.1f VA\n", dev.readReactivePower(0), dev.readApparentPower(0));
}
delay(1000);
}
Eine vom Master getaktete Periode: dev.stdLatch(bank) an der Grenze aufrufen, einige Fensterlängen warten, mit dev.stdReadLatch(bank, L) lesen und mit RbAmp::stdLatchWh(...) umrechnen. Das Verfahren auf Registerebene steht unter Energie und Perioden.
Modbus RTU mit Python (pymodbus, STD-UI1)
Lesevorgänge über die UART-Leitungen des Moduls durch einen seriellen Adapter (mit externem RS-485-Transceiver, wo die Verbindung ihn benötigt). Stellen Sie den Umschalter für den Schnittstellenmodus auf Modbus default (9600 8N1, Unit 1) oder auf Modbus RTU mit Ihren gespeicherten Einstellungen. Geschrieben für pymodbus 3.x (device_id=; ältere 3.x-Versionen nennen es slave=). Alle Mehrregister-Werte sind Big-Endian, höheres Wort zuerst (ABCD).
import struct
from pymodbus.client import ModbusSerialClient
def i32(r, i):
v = (r[i] << 16) | r[i + 1]
return v - (1 << 32) if v & 0x80000000 else v
def i64(r, i):
v = 0
for w in r[i:i + 4]:
v = (v << 16) | w
return v - (1 << 64) if v & (1 << 63) else v
def f32(r, i):
return struct.unpack(">f", struct.pack(">HH", r[i], r[i + 1]))[0]
client = ModbusSerialClient(port="/dev/ttyUSB0", baudrate=9600, parity="N", stopbits=1, bytesize=8)
client.connect()
UNIT = 1
# 1. Identity (input 0x6000): 'ST', map version, variant, status, frequency, window counter
r = client.read_input_registers(0x6000, count=33, device_id=UNIT).registers
assert r[0] == 0x5354 # 'S','T'
print("map", hex(r[1]), "variant", hex(r[7]), "status", hex(r[9]), "f =", r[0x13] / 100, "Hz")
# 2. Voltage (input 0x6100): U_RMS, i32 mV
u = client.read_input_registers(0x6100, count=6, device_id=UNIT).registers
print("U =", i32(u, 0) / 1000, "V")
# 3. Current channel 0 (input 0x6200): I (µA), P (mW), Q (mvar), S (mVA), PF (Q10, signed)
c = client.read_input_registers(0x6200, count=9, device_id=UNIT).registers
pf = c[8] - 65536 if c[8] & 0x8000 else c[8]
print("I =", i32(c, 0) / 1e6, "A P =", i32(c, 2) / 1000, "W Q =", i32(c, 4) / 1000, "var S =", i32(c, 6) / 1000, "VA PF =", pf / 1024)
# 4. Energy (input 0x6B00): import / export / net in Wh (i64), then mWh at +0x14
e = client.read_input_registers(0x6B00, count=32, device_id=UNIT).registers
print("import", i64(e, 0), "Wh export", i64(e, 4), "Wh net", i64(e, 8), "Wh")
# 5. The same quantities as float32 profile values (input 0x0000)
flt = client.read_input_registers(0x0000, count=76, device_id=UNIT).registers
print("float32: V L1", f32(flt, 0x00), "I L1", f32(flt, 0x06), "P total", f32(flt, 0x34),
"f", f32(flt, 0x46), "import kWh", f32(flt, 0x48), "export kWh", f32(flt, 0x4A))
client.close()
Der Leistungsfaktor ist nur bei anliegendem Laststrom aussagekräftig; ohne Last kann er einen beliebigen Wert zeigen.
Im Float32-Profil veröffentlicht ein einphasiges Modul seinen Kanal als L1; L2 und L3 liefern 0.0, ebenso die Punkte S und PF und jede Adresse außerhalb der Liste im Modbus-Transport. Die Konfigurationsregister (0x8000: Unit-ID, Baud-Code, Rahmenformat, virtuelle IDs) werden ebenso gelesen, mit read_holding_registers.
Modbus RTU mit mbpoll (STD-UI1)
mbpoll liest das Modul über die Kommandozeile. Stellen Sie den Schalter für den Schnittstellenmodus auf Modbus default (9600 8N1, Unit 1) und ersetzen Sie durch Ihren seriellen Port. Verwendete Optionen: -0 (0-basierte Registernummern, damit sie zur Registerübersicht passen), -1 (eine Abfrage), -B (Big-Endian-Wortreihenfolge, oberes Wort zuerst, für 32-Bit-Werte), -o 2 (2 s Timeout), -t 3 (Eingangsregister) oder -t 4 (Halteregister). Die Referenz nach -r ist dezimal.
# configuration, holding 0x8000: unit id, baud code, frame format, ...
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 4 -r 32768 -c 10
# identity, input 0x6000: 'ST', map version, variant, status, frequency, ...
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:hex -r 24576 -c 33
# U_RMS, input 0x6100: one 32-bit value, mV
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:int -B -r 24832 -c 1
# current channel 0, input 0x6200: I (µA), P (mW), Q (mvar), S (mVA) as four 32-bit values
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:int -B -r 25088 -c 4
# float32 profile: V L1, V L2, V L3 (single-phase modules read 0 for L2/L3), I L1 (float)
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:float -B -r 0 -c 4
# float32 profile: total P (float)
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:float -B -r 52 -c 1
# float32 profile: frequency, import kWh, export kWh (float)
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:float -B -r 70 -c 3
# energy in Wh, input 0x6B00: 64-bit values as 4 words each (import, export, ...)
mbpoll -m rtu -b 9600 -P none -a 1 -0 -1 -o 2 -t 3:hex -r 27392 -c 8
So sehen die Antworten aus:
- Konfiguration: zehn Register; bei einem Modul mit Standardeinstellungen zeigen die ersten drei
1(Unit-ID),2(Baud-Code für 9600) und0(Rahmen 8N1). - Identität:
[24576]liefert0x5354('S','T'),[24577]die Version der Registerübersicht (0x0036),[24583]die Variante (0x0011für STD-UI1),[24585]den Status,[24595]die Frequenz in 0.01 Hz (0x1388= 50.00 Hz). - 32-Bit-Ganzzahl-Lesevorgänge (
:int -B) geben einen Wert je zwei Register aus:[24832]die Spannung in mV;[25088],[25090],[25092],[25094]den Strom in µA sowie die Leistung, Blindleistung und Scheinleistung in mW, mvar und mVA. - Float32-Profil-Lesevorgänge liefern je zwei Register einen Wert; die Punkte sind im Modbus-Transport aufgeführt.
- Energie ist ein 64-Bit-Wert:
mbpollhat keinen 64-Bit-Typ, daher vier 16-Bit-Wörter lesen und höheres Wort zuerst zusammensetzen.
ESPHome: I²C (STD-UI1)
Die externe Komponente rbamp von rbamp-esphome liest das Modul über I²C (die Komponente wird neben dem YAML in components/ abgelegt). Beim Start meldet sie die Version der Registerübersicht, die Variante, die Kanäle und die Energiequelle. Die Sensoren werden alle 10 s veröffentlicht.
esphome:
name: std-ui1-i2c
esp32:
board: esp32dev
framework:
type: arduino
logger:
i2c:
sda: GPIO25
scl: GPIO26
frequency: 50kHz
external_components:
- source:
type: local
path: components
components: [rbamp]
rbamp:
id: meter1
address: 0x50
update_interval: 10s
sensor:
- platform: rbamp
rbamp_id: meter1
voltage:
name: "Voltage"
current:
name: "Current"
power:
name: "Power"
energy_total:
name: "Energy import"
energy_exported_total:
name: "Energy export"
energy_total und energy_exported_total zählen die Energie seit dem Start der Komponente (sie werden über Neustarts des ESP wiederhergestellt). Sie sind nicht die Lebensdauerzähler des Moduls; diese lesen Sie aus dem Modul (siehe Energie und Perioden). Die Busgeschwindigkeit von 50 kHz wird für ESP32-Hosts empfohlen.
ESPHome: Modbus RTU (STD-UI1)
Die Standard-modbus_controller liest das Modul über seine UART-Leitungen: Stellen Sie den Umschalter für den Schnittstellenmodus auf Modbus default (9600 8N1, Unit 1). Verbinden Sie die TX des Masters mit Pin 3 (SDA, RX des Moduls) und die RX des Masters mit Pin 4 (SCL, TX des Moduls) am Modulstecker — das Modul empfängt auf Pin 3 und sendet auf Pin 4 — daher ist tx_pin die Leitung zu Pin 3 und rx_pin die Leitung zu Pin 4. Die Controller-ID darf nicht std sein: Sie kollidiert mit dem C++-Namensraum, und der Build schlägt fehl.
esphome:
name: std-ui1-modbus
esp32:
board: esp32dev
framework:
type: arduino
logger:
uart:
id: mod_bus
tx_pin: GPIO25 # to the module's pin 3 (SDA, module RX)
rx_pin: GPIO26 # from the module's pin 4 (SCL, module TX)
baud_rate: 9600
parity: NONE
stop_bits: 1
modbus:
id: modbus1
uart_id: mod_bus
modbus_controller:
- id: std_meter
address: 1
modbus_id: modbus1
update_interval: 10s
sensor:
# float32 profile points (input registers, ABCD)
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Voltage L1"
register_type: read
address: 0x0000
value_type: FP32
unit_of_measurement: V
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Current L1"
register_type: read
address: 0x0006
value_type: FP32
unit_of_measurement: A
accuracy_decimals: 3
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Power total"
register_type: read
address: 0x0034
value_type: FP32
unit_of_measurement: W
accuracy_decimals: 1
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Frequency"
register_type: read
address: 0x0046
value_type: FP32
unit_of_measurement: Hz
accuracy_decimals: 2
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Energy import (float profile)"
register_type: read
address: 0x0048
value_type: FP32
unit_of_measurement: kWh
accuracy_decimals: 3
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Energy export (float profile)"
register_type: read
address: 0x004A
value_type: FP32
unit_of_measurement: kWh
accuracy_decimals: 3
# Native map: import energy in Wh, i64 big-endian (input 0x6B00)
- platform: modbus_controller
modbus_controller_id: std_meter
name: "Energy import (native)"
register_type: read
address: 0x6B00
value_type: S_QWORD
unit_of_measurement: Wh
accuracy_decimals: 0
Das float32-Profil und der native Import-Energiewert melden dieselbe Energie. Wenn Ihr serieller Adapter RS-485 ist, setzen Sie einen externen Transceiver zwischen den UART des Masters und das Modul (siehe Hardware).
Ohne Bibliothek
Über Modbus kann jeder Modbus-Stack die native Karte des Moduls oder die Float32-Profilpunkte lesen (Eingang 0x0000); siehe Einstieg.