rbAmp
DE
Shop
Docs
Aktualisiert

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

C++
#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).

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

Shell
# 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) und 0 (Rahmen 8N1).
  • Identität: [24576] liefert 0x5354 ('S','T'), [24577] die Version der Registerübersicht (0x0036), [24583] die Variante (0x0011 fü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: mbpoll hat 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.

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

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