Перейти к содержимому

Your meter gives one number. See which circuit makes the bill.

Start with one rbAmp module on your own controller, and grow to a whole-panel system without replacing what you bought. Each module measures voltage, current, power and energy on individual circuits.

A three-phase rbAmp installation on a DIN rail inside a consumer unit, with clamp sensors on the outgoing circuits.

What do you want to know?

Per-circuit monitoring

See what each circuit and appliance uses, not just the whole house.

"One number from the meter is not enough."

Solar and battery

Separate grid import, self-consumption and export.

"Export breaks my charts; the counter jumps after a reboot."

Standby consumption

Find the baseline that never switches off.

"Everything is off and the meter still turns."

Sub-metering

One meter per room, load or tenant on one device.

"A meter per tenant, not a cabinet of meters."

Industrial integration

Hand readings to an inverter, PLC or SCADA over Modbus RTU (external RS-485 transceiver).

"My inverter expects a meter on RS-485."

Whole-panel synchronized

Every channel measured at the same instant.

"All meters of the site at one instant."

RBgrid: see your electricity as money

Put an ESP32 hub next to your rbAmp modules and RBgrid shows what every measured circuit costs — right now, today and this month — on your own tariff zones. It runs on the hub: no account, no cloud, no subscription. If you run Home Assistant, it stays as it is: the hub plugs into it over MQTT.

The hub firmware is source-available, free for personal and non-commercial use.

Open the live demo · How it works · rbgrid.io

RBgrid Overview in the live demo: cost per hour, today and month to date, and where the money goes by circuit.

STD: data you can trust

Metering lives on the device, not in your software: the counters are kept and saved on the module, so a restart of your controller loses nothing.

An STD-U3I3 three-phase meter on a DIN rail with its 60 A clamp sensors.

STD: data you can trust

Metering lives on the device, not in your software. Source: Docs › STD › Energy and periods

Counters on the device

Counters on the device, saved every second.

Import and export

Import and export: two counters, not a balance.

Small loads don't hide

Current in microamperes, energy in microwatt-hours.

Updates that roll back

Signed image; metering continues during the update.

Safe by design, stated per model. The side you connect to your controller is low-voltage and isolated from the mains measurement inputs; current is measured through a clamp; the exact wording per line is on the safety page.

Factory calibrated. Every module ships calibrated; accuracy is stated per sensor rating in the documentation — as system accuracy, module plus sensor, not as one number. Sensor ratings

Your first project

BASIC SCT-UI3 — your first measured circuit. What else you need:

  • an SCT-013 clamp sensor
  • an ESP32 board
  • a 5 V supply
  • four bus wires (I²C)
  • the library for your stack

Works with the tools you already use

ESPHome · ESP-IDF · Arduino · Python · Modbus RTU. Quick starts: ESPHome · ESP-IDF · Arduino · Python · STD over Modbus RTU

ESPHome — BASIC SCT-UI1 + SCT-013 · ESP32 · I²C

YAML
rbamp:
  id: meter1
  address: 0x50
  ct_model: SCT_013_030

sensor:
  - platform: rbamp
    rbamp_id: meter1
    voltage:
      name: "Mains Voltage"
    current:
      name: "Mains Current"
    power:
      name: "Mains Power"
    energy:
      name: "Mains Energy"

Source: rbamp-esphome README · Quick start · Full example →

ESP-IDF — BASIC SCT-UI1 + SCT-013 · ESP32 · I²C

C
rbamp_handle_t dev;
ESP_ERROR_CHECK(rbamp_new(bus, 0x50, &dev));
ESP_ERROR_CHECK(rbamp_begin(dev));
ESP_ERROR_CHECK(rbamp_set_sensor_class(dev,
                RBAMP_SENSOR_SCT013));
ESP_ERROR_CHECK(rbamp_set_ct_model(dev, 3));

rbamp_snapshot_t s;
if (rbamp_read_all(dev, &s) == ESP_OK) {
    ESP_LOGI("app", "P=%.1f W", (double)s.power[0]);
}

Source: rbamp-esp-idf README · Quick start · Full example →

Arduino — BASIC SCT-UI1 + SCT-013 · ESP32 · I²C

C++
#include <Wire.h>
#include <RbAmp.h>

RbAmp dev(Wire, 0x50);

dev.setSensorClass(RbAmpSensorClass::Sct013);
dev.setCTModel(RbAmpCTModel::Sct013_030);

RbAmpPeriodSnapshot snap;
if (dev.readPeriodSnapshot(snap)) {
    Serial.println(snap.avg_p[0]);
}

Source: rbamp-arduino README · Quick start · Full example →

Python — BASIC SCT-UI1 + SCT-013 · Raspberry Pi · I²C

Python
from smbus2 import SMBus
from rbamp import RbAmp, RbAmpSensorClass

with SMBus(1) as bus:
    with RbAmp(bus, 0x50) as dev:
        dev.set_sensor_class(RbAmpSensorClass.SCT_013)
        dev.set_ct_model(3)
        print(f"P[0] = {dev.power[0]:.2f} W")

Source: rbamp-python README · Quick start · Full example →

STD over Modbus RTU — switch: Modbus default (9600 8N1, unit 1) · UART TTL, RS-485 through an external transceiver

Shell
# 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 <port>

# 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 <port>

Source: STD docs · Examples · Full example →

What stays the same as you grow

Whatever you add — a module, a meter, a hub — the bus, the library, the contract and the moment of measurement stay the same.

One bus

Two wires from one circuit to a whole panel; up to about 16 modules per bus, limited by bus capacitance.

One library

begin() detects the line and the channel count.

One contract

Published, versioned register maps.

One snapshot

The whole site frozen at one instant over the bus.

Several rbAmp modules wired to one I²C bus - SDA, SCL, 3V3 and GND daisy-chained from the controller to each module.
One bus, whatever you add: SDA, SCL, 3V3 and GND chained from your controller through every module.

One installation that grows

Every step adds; nothing is replaced.

1 · Modules and your master

BASIC or STD on your own controller.

2 · BASIC and STD on one bus

STD also standalone over Modbus RTU.

Platform releases

New modules, libraries and firmware — only when something ships, at most once a month.

Thanks for registering!

We use your address for nothing else.