rbAmp
FR
Boutique
Docs
Mis à jour le

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

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

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

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

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.

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 

À 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) et 0 (trame 8N1).
  • Identité : [24576] affiche 0x5354 ('S','T'), [24577] la version de la table de registres (0x0036), [24583] la variante (0x0011 pour 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 : mbpoll n'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.

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

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

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.