rbAmp
IT
Negozio
Docs
Aggiornato il

08 · Esempi STD

Versioni minime delle librerie: Arduino 1.6.2 e ESP-IDF 1.7.3 su un modulo con banchi di istantanee e contatori di energia; Python 1.6.0; ESPHome 1.9.0. Le chiamate ai banchi di istantanee richiedono Python 1.6.1 ed ESPHome 1.9.1. Banchi di istantanee nelle librerie: Arduino, ESP-IDF, ESPHome (period_banks:); Python ha le chiamate std_arm_banks, std_latch, std_read_latch, std_latch_wh.

Le librerie client leggono i moduli STD e BASIC con le stesse chiamate; le grandezze esclusive di STD (potenza reattiva e apparente, contatori di salute, banchi di istantanee) sono disponibili previa verifica della linea.

Piattaforma Esempio Mostra
Arduino rbamp-arduino, examples/11_StdLine uno sketch per entrambe le linee: begin() rileva la linea; valori in tempo reale; contatori di salute; un periodo temporizzato dal master sul banco di snapshot 1
ESP-IDF rbamp-esp-idf, examples/std_meter Lettura del contatore STD con il componente ESP-IDF
Python (CPython) rbamp-python, gli esempi del pacchetto le stesse letture su Raspberry Pi e server

Arduino: il nucleo dello sketch

(Serial.printf come sul core Arduino ESP32; usare Serial.print su altre schede.)

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);
}

Un periodo temporizzato dal master: chiamare dev.stdLatch(bank) al confine, attendere alcune lunghezze di finestra, leggerlo con dev.stdReadLatch(bank, L) e convertirlo con RbAmp::stdLatchWh(...). La procedura a livello di registri è in Energia e periodi.

Modbus RTU con Python (pymodbus, STD-UI1)

Letture sulle linee UART del modulo tramite un adattatore seriale (con un ricetrasmettitore RS-485 esterno dove il collegamento lo richiede). Impostare il commutatore della modalità di interfaccia su Modbus default (9600 8N1, unit 1) oppure su Modbus RTU con le impostazioni salvate. Scritto per pymodbus 3.x (device_id=; le versioni 3.x più vecchie lo chiamano slave=). Tutti i valori multi-registro sono big-endian, prima la parola alta (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()

Il fattore di potenza ha significato solo con una corrente di carico; a vuoto può leggere qualsiasi valore.

Nel profilo float32 un modulo monofase pubblica il proprio canale come L1; L2 e L3 leggono 0.0, così come i punti S e PF e ogni indirizzo fuori dall'elenco del trasporto Modbus. I registri di configurazione (0x8000: id unità, codice baud, formato di trama, id virtuali) si leggono allo stesso modo con read_holding_registers.

Modbus RTU con mbpoll (STD-UI1)

mbpoll legge il modulo da riga di comando. Impostare lo switch della modalità d'interfaccia su Modbus predefinito (9600 8N1, unità 1) e sostituire con la propria porta seriale. Le opzioni usate: -0 (numerazione dei registri da 0, così coincidono con la mappa), -1 (un'interrogazione), -B (ordine delle parole big-endian, parola alta per prima, per valori a 32 bit), -o 2 (timeout di 2 s), -t 3 (registri di input) oppure -t 4 (registri holding). Il riferimento dopo -r è decimale.

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 

Com'è fatta una risposta:

  • Configurazione: dieci registri; su un modulo con impostazioni predefinite i primi tre leggono 1 (id unità), 2 (codice baud per 9600) e 0 (formato 8N1).
  • Identità: [24576] legge 0x5354 ('S','T'), [24577] la versione della mappa dei registri (0x0036), [24583] la variante (0x0011 per STD-UI1), [24585] lo stato, [24595] la frequenza in 0.01 Hz (0x1388 = 50.00 Hz).
  • Letture intere a 32 bit (:int -B) stampano un valore ogni due registri: [24832] la tensione in mV; [25088], [25090], [25092], [25094] la corrente in µA e la potenza, la potenza reattiva e la potenza apparente in mW, mvar e mVA.
  • Letture del profilo float32 stampano un valore ogni due registri; i punti sono elencati nel trasporto Modbus.
  • L'energia è un valore a 64 bit: mbpoll non ha un tipo a 64 bit, quindi leggere quattro parole a 16 bit e combinarle prima la parola alta.

ESPHome: I²C (STD-UI1)

Il componente esterno rbamp di rbamp-esphome legge il modulo tramite I²C (il componente va collocato in components/ accanto allo YAML). All'avvio segnala la versione della mappa dei registri, la variante, i canali e la fonte di energia. I sensori vengono pubblicati ogni 10 s.

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 e energy_exported_total contano l'energia vista da quando il componente è partito (vengono ripristinate dopo i riavvii dell'ESP). Non sono i contatori a vita del modulo; leggerli dal modulo (vedere Energia e periodi). La velocità di bus di 50 kHz è la raccomandazione per gli host ESP32.

ESPHome: Modbus RTU (STD-UI1)

Il controller modbus_controller di serie legge il modulo tramite le sue linee UART: impostare il commutatore della modalità di interfaccia su Modbus default (9600 8N1, unit 1). Collegare il TX del master al pin 3 (SDA, RX del modulo) e l'RX del master al pin 4 (SCL, TX del modulo) del connettore del modulo — il modulo riceve sul pin 3 e trasmette sul pin 4 — quindi tx_pin è il filo verso il pin 3 e rx_pin il filo verso il pin 4. L'id del controller non deve essere std: entra in conflitto con il namespace C++ e la build fallisce.

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

Il profilo punti float32 e l'energia di importazione nativa riportano la stessa energia. Se l'adattatore seriale è RS-485, inserire un ricetrasmettitore esterno tra l'UART del master e il modulo (vedere Hardware).

Senza libreria

Su Modbus qualsiasi stack Modbus può leggere la mappa nativa del modulo o i punti del profilo float32 (input 0x0000); vedere Come iniziare.