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.)
#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).
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.
# 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) e0(formato 8N1). - Identità:
[24576]legge0x5354('S','T'),[24577]la versione della mappa dei registri (0x0036),[24583]la variante (0x0011per 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:
mbpollnon 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.
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.
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.