08 · Ejemplos de STD
Versiones mínimas de las bibliotecas: Arduino 1.6.2 y ESP-IDF 1.7.3 en un módulo con bancos de instantáneas y contadores de energía; Python 1.6.0; ESPHome 1.9.0. Las llamadas a bancos de instantáneas requieren Python 1.6.1 y ESPHome 1.9.1. Bancos de instantáneas en las bibliotecas: Arduino, ESP-IDF, ESPHome (period_banks:); Python dispone de las llamadas std_arm_banks, std_latch, std_read_latch, std_latch_wh.
Las bibliotecas cliente leen los módulos STD y BASIC con las mismas llamadas; las magnitudes exclusivas del STD (potencia reactiva y aparente, contadores de estado y bancos de instantáneas) están disponibles tras una comprobación de línea.
| Plataforma | Ejemplo | Muestra |
|---|---|---|
| Arduino | rbamp-arduino, examples/11_StdLine |
un solo boceto para ambas líneas: begin() detecta la línea; valores en tiempo real; contadores de salud; un período temporizado por el maestro en el banco de instantáneas 1 |
| ESP-IDF | rbamp-esp-idf, examples/std_meter |
Lectura de medidor STD con el componente ESP-IDF |
| Python (CPython) | rbamp-python, los ejemplos del paquete | las mismas lecturas en Raspberry Pi y servidores |
Arduino: el núcleo del sketch
(Serial.printf como en el núcleo Arduino de ESP32; use Serial.print en otras placas.)
#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 período temporizado por el maestro: llame a dev.stdLatch(bank) en el límite, espere unas cuantas longitudes de ventana, léalo con dev.stdReadLatch(bank, L) y conviértalo con RbAmp::stdLatchWh(...). El procedimiento a nivel de registro está en Energía y períodos.
Modbus RTU con Python (pymodbus, STD-UI1)
Lecturas por las líneas UART del módulo a través de un adaptador serie (con un transceptor RS-485 externo donde el enlace lo necesite). Ponga el conmutador de modo de interfaz en Modbus por defecto (9600 8N1, unidad 1) o en Modbus RTU con sus ajustes guardados. Escrito para pymodbus 3.x (device_id=; las versiones 3.x anteriores lo llaman slave=). Todos los valores de varios registros son big-endian, primero la palabra 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()
El factor de potencia solo tiene sentido con corriente de carga; en vacío puede leer cualquier valor.
En el perfil float32, un módulo monofásico publica su canal como L1; L2 y L3 leen 0.0, igual que los puntos S y PF y cualquier dirección fuera de la lista del transporte Modbus. Los registros de configuración (0x8000: id de unidad, código de velocidad, formato de trama, ids virtuales) se leen igual con read_holding_registers.
Modbus RTU con mbpoll (STD-UI1)
mbpoll lee el módulo desde la línea de comandos. Ponga el conmutador de modo de interfaz en Modbus predeterminado (9600 8N1, unidad 1) y sustituya por su puerto serie. Las opciones usadas: -0 (números de registro desde 0, para que coincidan con el mapa de registros), -1 (una sola lectura), -B (orden de palabras big-endian, palabra alta primero, para valores de 32 bits), -o 2 (tiempo límite de 2 s), -t 3 (registros de entrada) o -t 4 (registros retenidos). La referencia tras -r es decimal.
# 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
Qué aspecto tienen las respuestas:
- Configuración: diez registros; en un módulo con valores de fábrica, los tres primeros leen
1(id de unidad),2(código de velocidad para 9600) y0(trama 8N1). - Identidad:
[24576]lee0x5354('S','T'),[24577]la versión del mapa de registros (0x0036),[24583]la variante (0x0011para STD-UI1),[24585]el estado,[24595]la frecuencia en 0.01 Hz (0x1388= 50.00 Hz). - Lecturas de enteros de 32 bits (
:int -B) imprimen un valor por cada dos registros:[24832]la tensión en mV;[25088],[25090],[25092],[25094]la corriente en µA y la potencia, la potencia reactiva y la potencia aparente en mW, mvar y mVA. - Las lecturas del perfil float32 muestran un valor por cada dos registros; los puntos se enumeran en el transporte Modbus.
- La energía es un valor de 64 bits:
mbpollno tiene tipo de 64 bits, así que lea cuatro palabras de 16 bits y combínelas, primero la palabra alta.
ESPHome: I²C (STD-UI1)
El componente externo rbamp de rbamp-esphome lee el módulo por I²C (el componente se coloca en components/ junto al YAML). Al arrancar informa de la versión del mapa de registros, la variante, los canales y la fuente de energía. Los sensores se publican cada 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 y energy_exported_total cuentan la energía vista desde que arrancó el componente (se restauran tras los reinicios del ESP). No son los contadores de vida del módulo; léalos del módulo (véase Energía y periodos). La velocidad de bus de 50 kHz es la recomendada para hosts ESP32.
ESPHome: Modbus RTU (STD-UI1)
El controlador modbus_controller de serie lee el módulo por sus líneas UART: ponga el conmutador de modo de interfaz en Modbus por defecto (9600 8N1, unidad 1). Conecte el TX del maestro al pin 3 (SDA, RX del módulo) y el RX del maestro al pin 4 (SCL, TX del módulo) del conector del módulo — el módulo recibe por el pin 3 y transmite por el pin 4 — de modo que tx_pin es el cable al pin 3 y rx_pin el cable al pin 4. El id del controlador no debe ser std: colisiona con el espacio de nombres de C++ y la compilación falla.
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
El perfil float32 de puntos y la energía de importación nativa informan la misma energía. Si su adaptador serie es RS-485, coloque un transceptor externo entre la UART del maestro y el módulo (véase Hardware).
Sin biblioteca
Por Modbus, cualquier pila Modbus puede leer el mapa nativo del módulo o los puntos del perfil float32 (entrada 0x0000); véase Primeros pasos.