08 · Exemples STD
Versions minimales des bibliothèques : Arduino 1.6.2 et ESP-IDF 1.7.3 sur un module disposant de banques d'instantanés et de compteurs d'énergie ; Python 1.6.0 ; ESPHome 1.9.0. Les appels aux banques d'instantanés nécessitent Python 1.6.1 et ESPHome 1.9.1. Banques d'instantanés dans les bibliothèques : Arduino, ESP-IDF, ESPHome (period_banks:) ; Python dispose des appels std_arm_banks, std_latch, std_read_latch, std_latch_wh.
Les bibliothèques clientes lisent les modules STD et BASIC avec les mêmes appels ; les grandeurs propres au STD (puissance réactive et apparente, compteurs de santé, banques d'instantanés) sont accessibles derrière une vérification de gamme.
| Plateforme | Exemple | Affiche |
|---|---|---|
| Arduino | rbamp-arduino, examples/11_StdLine |
un seul croquis pour les deux lignes : begin() détecte la ligne ; valeurs en direct ; compteurs de santé ; une période cadencée par le maître sur la banque d'instantanés 1 |
| ESP-IDF | rbamp-esp-idf, examples/std_meter |
Lecture d'un compteur STD avec le composant ESP-IDF |
| Python (CPython) | rbamp-python, les exemples du paquet | les mêmes lectures sur Raspberry Pi et serveurs |
Arduino : le cœur du sketch
(Serial.printf comme sur le cœur Arduino ESP32 ; utilisez Serial.print sur les autres cartes.)
#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);
}
Une période cadencée par le maître : appelez dev.stdLatch(bank) à la frontière, attendez quelques durées de fenêtre, lisez avec dev.stdReadLatch(bank, L) et convertissez avec RbAmp::stdLatchWh(...). La procédure au niveau des registres est décrite dans Énergie et périodes.
Modbus RTU avec Python (pymodbus, STD-UI1)
Lectures sur les lignes UART du module via un adaptateur série (avec un émetteur-récepteur RS-485 externe lorsque la liaison en a besoin). Réglez le commutateur de mode d'interface sur Modbus par défaut (9600 8N1, unité 1) ou sur Modbus RTU avec vos réglages sauvegardés. Écrit pour pymodbus 3.x (device_id= ; les versions 3.x plus anciennes l'appellent slave=). Toutes les valeurs multi-registres sont gros-boutistes, mot de poids fort en premier (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()
Le facteur de puissance n'a de sens qu'avec un courant de charge ; à vide, il peut afficher n'importe quelle valeur.
Dans le profil float32, un module monophasé publie son canal comme L1 ; L2 et L3 affichent 0.0, de même que les points S et PF et toute adresse hors de la liste du transport Modbus. Les registres de configuration (0x8000 : identifiant d'unité, code de débit, format de trame, identifiants virtuels) se lisent de la même façon avec read_holding_registers.
Modbus RTU avec mbpoll (STD-UI1)
mbpoll lit le module depuis une ligne de commande. Réglez le commutateur de mode d'interface sur Modbus par défaut (9600 8N1, unité 1) et remplacez par votre port série. Options utilisées : -0 (numéros de registres à partir de 0, pour correspondre à la table), -1 (une seule interrogation), -B (ordre des mots gros-boutiste, mot de poids fort en premier, pour les valeurs 32 bits), -o 2 (délai de 2 s), -t 3 (registres d'entrée) ou -t 4 (registres de maintien). La référence qui suit -r est en décimal.
# 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
À quoi ressemblent les réponses :
- Configuration : dix registres ; sur un module aux réglages par défaut, les trois premiers affichent
1(identifiant d'unité),2(code de débit pour 9600) et0(trame 8N1). - Identité :
[24576]affiche0x5354('S','T'),[24577]la version de la table de registres (0x0036),[24583]la variante (0x0011pour STD-UI1),[24585]l'état,[24595]la fréquence en 0.01 Hz (0x1388= 50.00 Hz). - Lectures d'entiers sur 32 bits (
:int -B) : une valeur par deux registres ;[24832]la tension en mV ;[25088],[25090],[25092],[25094]le courant en µA et les puissances active, réactive et apparente en mW, mvar et mVA. - Les lectures du profil float32 affichent une valeur par deux registres ; les points sont listés dans le transport Modbus.
- L'énergie est une valeur sur 64 bits :
mbpolln'a pas de type 64 bits, lisez donc quatre mots de 16 bits et combinez-les, mot de poids fort en premier.
ESPHome : I²C (STD-UI1)
Le composant externe rbamp de rbamp-esphome lit le module via I²C (le composant est placé dans components/ à côté du YAML). Au démarrage, il signale la version de la table de registres, la variante, les canaux et la source d'énergie. Les capteurs sont publiés toutes les 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 et energy_exported_total comptent l'énergie vue depuis le démarrage du composant (ils sont restaurés après les redémarrages de l'ESP). Ce ne sont pas les compteurs à vie du module ; lisez ceux-ci depuis le module (voir Énergie et périodes). La vitesse de bus de 50 kHz est la recommandation pour les hôtes ESP32.
ESPHome : Modbus RTU (STD-UI1)
Le contrôleur modbus_controller standard lit le module par ses lignes UART : réglez le commutateur de mode d'interface sur Modbus par défaut (9600 8N1, unité 1). Reliez le TX du maître à la broche 3 (SDA, RX du module) et le RX du maître à la broche 4 (SCL, TX du module) du connecteur — le module reçoit sur la broche 3 et émet sur la broche 4 — donc tx_pin est le fil vers la broche 3 et rx_pin le fil vers la broche 4. L'identifiant du contrôleur ne doit pas être std : il entre en collision avec l'espace de noms C++ et la compilation échoue.
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
Le profil float32 et l'énergie d'import native rapportent la même énergie. Si votre adaptateur série est en RS-485, placez un émetteur-récepteur externe entre l'UART du maître et le module (voir Matériel).
Sans bibliothèque
Sur Modbus, toute pile Modbus peut lire la table native du module ou les points du profil float32 (entrée 0x0000) ; voir Premiers pas.