Exemplos
Percurso pelos sketches incluídos em examples/ e por cenários compostos. A maioria dos exemplos numerados abaixo tem código correspondente em examples/ — abra os sketches reais no Arduino IDE para o código-fonte completo.
| # | Título | Dificuldade | Ficheiro-fonte |
|---|---|---|---|
| 1 | Leitura rápida | mínimo | 01_QuickRead.ino |
| 2 | Contador de 60 segundos no OLED | baixo | 02_PeriodEnergyOLED.ino |
| 3 | Monitor multimódulo (3 dispositivos) | baixo | 03_MultiModuleBroadcast.ino |
| 4 | UI3 por aparelho + MQTT | médio | 04_UI3PerChannelMQTT.ino |
| 5 | Contabilidade bidirecional do lado do master | médio | 06_BidirectionalEnergy.ino |
| 6 | Balanço energético doméstico | alta | (composed) |
| 7 | Deteção de eventos (EMA) | médio | (composed) |
| 8 | Monitor de bancada autónomo de 12 horas | médio | (código neste capítulo) |
| 9 | Registador de deep sleep a bateria | médio | 07_DeepSleepLogger.ino |
| 10 | Alteração do endereço I2C | baixo | 05_AddressChange.ino |
| 11 | Um só sketch, ambas as linhas de módulos (BASIC + STD) | médio | 11_StdLine.ino |
Cenário 1 — Leitura rápida
Objetivo: imprimir U / I / P / PF / frequência uma vez por segundo. O «olá mundo» que acabou de escrever no Arranque rápido, mas usando dev.readAll(s) para uma leitura completa em bloco RT numa só vez, em vez de chamadas de propriedades individuais.
#include
#include
static RbAmp dev(Wire, 0x50);
void setup() {
Serial.begin(115200);
while (!Serial && millis() < 3000) {}
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) {
Serial.print(F("begin: ")); Serial.println(RbAmp::errorString(dev.lastError()));
delay(1000);
}
}
void loop() {
RbAmpSnapshot s;
if (!dev.readAll(s)) {
Serial.print(F("read fail: ")); Serial.println(RbAmp::errorString(dev.lastError()));
delay(1000); return;
}
Serial.print(F("U=")); Serial.print(s.voltage, 1); Serial.print(F("V "));
Serial.print(F("f=")); Serial.print(s.frequency, 1); Serial.print(F("Hz "));
for (uint8_t ch = 0; ch < s.channels; ++ch) {
Serial.print(F("I")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.current[ch], 2); Serial.print(F("A "));
Serial.print(F("P")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.power[ch], 1); Serial.print(F("W "));
Serial.print(F("PF")); Serial.print(ch); Serial.print(F("="));
Serial.print(s.power_factor[ch], 2); Serial.print(F(" "));
}
Serial.println();
delay(1000);
}
O que circula no fio: readAll() num UI3 emite 53 transações de um byte (13 floats × 4 bytes + 1 byte de frequência). A 100 kHz com margem de 3 tentativas, ~12–15 ms no total. Passe a leituras por chamada (dev.voltage, dev.current[ch]) se só precisar de um subconjunto.
Cenário 2 — Contador de 60 segundos no OLED
Contador Wh atualizado uma vez por minuto num OLED SSD1306 de 128×64 que partilha o barramento I2C (OLED em 0x3C). Mecanismo principal da biblioteca: readPeriodSnapshot() faz instantâneo + estabilização + verificação de validade + leitura + tick de Wh numa só chamada.
#include
#include
#include
#include
static Adafruit_SSD1306 oled(128, 64, &Wire, -1);
static RbAmp dev(Wire, 0x50);
static uint32_t next_latch_ms = 0;
static uint32_t snapshots_ok = 0, snapshots_bad = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
oled.begin(SSD1306_SWITCHCAPVCC, 0x3C);
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(1000); }
next_latch_ms = millis() + 60000;
}
void loop() {
if (millis() < next_latch_ms) { delay(50); return; }
next_latch_ms = millis() + 60000;
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) { snapshots_bad++; return; }
snapshots_ok++;
oled.clearDisplay();
oled.setTextColor(SSD1306_WHITE);
oled.setCursor(0, 0); oled.setTextSize(1); oled.println(F("rbAmp Energy Meter"));
oled.setCursor(0, 16); oled.setTextSize(2); oled.print(snap.avg_p[0], 1); oled.println(F(" W"));
oled.setTextSize(1);
oled.print(F("Wh:")); oled.println(dev.energy().wh(0), 4);
oled.print(F("ok=")); oled.print(snapshots_ok);
oled.print(F(" bad=")); oled.println(snapshots_bad);
oled.display();
}
Esboço completo em 02_PeriodEnergyOLED.ino.
Tratamento de instantâneo obsoleto: readPeriodSnapshot() devolve false com lastError() == RB_ERR_STALE se REG_V03_PERIOD_VALID == 0. A biblioteca continua a registar internamente o carimbo de tempo do relógio do mestre — isto impede que o próximo instantâneo bem-sucedido faça dupla contagem de Wh num intervalo de 2× período.
Cenário 3 — Monitor de vários módulos
Três módulos rbAmp no mesmo barramento em 0x50 / 0x51 / 0x52. Cada um tem de ter um endereço I2C único — use o cenário 10 para atribuir endereços durante a instalação.
todos os módulos que suportam o instantâneo por Chamada Geral e que optaram por ele (enableGc(true), persistido) capturam o mesmo período da rede numa só trama de chamada geral — RbAmp::broadcastLatchGroup(Wire, 0x00, tick). O desfasamento da frota é < 10 µs, pelo que as potências por módulo se somam de forma coerente. Cada módulo marca o seu instantâneo com o tick de difusão; leia-o de volta com readGcTick() para detetar um módulo que perdeu a trama. (No firmware v1.0/v1.1 o instantâneo por Chamada Geral não estava disponível e este esboço recorria a instantâneos sequenciais por dispositivo — mantidos no histórico de comentários do ficheiro para os módulos mais antigos.)
#include
#include
static RbAmp T0(Wire, 0x50);
static RbAmp T1(Wire, 0x51);
static RbAmp T2(Wire, 0x52);
static RbAmp* modules[] = { &T0, &T1, &T2 };
static const uint8_t N = sizeof(modules) / sizeof(modules[0]);
static uint16_t g_tick = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
Wire.setClock(50000); // 50 kHz on ESP32 / 100 kHz on non-ESP32 masters
for (uint8_t i = 0; i < N; ++i) {
modules[i]->begin();
modules[i]->enableGc(true); // opt into General-Call snapshot (persisted)
}
}
void loop() {
g_tick++;
RbAmp::broadcastLatchGroup(Wire, /*group=*/0x00, g_tick); // 0x00 = all-call
delay(50); // single shared settle for the whole bus
for (uint8_t i = 0; i < N; ++i) {
RbAmpPeriodSnapshot snap;
if (modules[i]->readPeriodSnapshot(snap, /*settle_ms=*/0, /*skip_latch=*/true)) {
uint16_t tick;
bool synced = modules[i]->readGcTick(tick) && tick == g_tick;
Serial.print(F("T")); Serial.print(i);
Serial.print(F(" P=")); Serial.print(snap.avg_p[0], 0);
Serial.print(F("W Wh=")); Serial.print(modules[i]->energy().wh(0), 3);
Serial.println(synced ? F(" [sync]") : F(" [MISSED FRAME]"));
}
}
delay(60000);
}
Sketch completo (com sondagem do barramento e relatório de erros) em 03_MultiModuleBroadcast.ino.
Cenário 4 — UI3 por eletrodoméstico + MQTT
Um módulo UI3 com três pinças de TC em três cargas. Contadores Wh independentes por canal, publicados em MQTT uma vez por minuto. Demonstra que dev.energy().wh(ch) funciona em cada canal de forma independente — sem necessidade de um array manual total_wh[3].
#include
#include
#include
#include
static RbAmp dev(Wire, 0x50);
static const char* CH_NAMES[3] = {"main", "heatpump", "lights"};
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void publish_channel(const char* name, float avg_p, double e_wh) {
char topic[64], payload[96];
snprintf(topic, sizeof(topic), "rbamp/%s/state", name);
snprintf(payload, sizeof(payload), "{\"power\":%.1f,\"energy\":%.4f}", avg_p, e_wh);
mqtt.publish(topic, payload, true);
}
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
mqtt.setServer("192.168.1.10", 1883);
mqtt.setKeepAlive(60);
mqtt.connect("rbamp-ui3");
Wire.begin();
Wire.setClock(50000); // reduced bus clock on ESP32
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
}
void loop() {
if (!mqtt.connected()) mqtt.connect("rbamp-ui3");
mqtt.loop();
static uint32_t last_period = 0;
if (last_period == 0) last_period = millis();
if (millis() - last_period < 60000) { delay(50); return; }
last_period = millis();
RbAmpPeriodSnapshot snap;
if (!dev.readPeriodSnapshot(snap)) return;
for (uint8_t ch = 0; ch < dev.channels(); ++ch) {
publish_channel(CH_NAMES[ch], snap.avg_p[ch], dev.energy().wh(ch));
}
}
Sketch completo em 04_UI3PerChannelMQTT.ino. Para a descoberta automática MQTT do HA sobre esta base, veja Integrações DIY.
Cenário 5 — Contabilidade bidirecional do lado do mestre
Divida a potência RT com sinal em baldes de consumo bruto / exportação bruta. Use em módulos de nível BASIC, onde o acumulador do período corta os valores negativos — amostre dev.readPower(0) a 10 Hz do lado do master.
#include
#include
static RbAmp dev(Wire, 0x50);
static double consume_wh = 0.0;
static double export_wh = 0.0;
static uint32_t last_sample_ms = 0;
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
last_sample_ms = millis();
}
void loop() {
if (millis() - last_sample_ms < 100) { delay(5); return; } // 10 Hz — matches RT cadence
const uint32_t now_ms = millis();
const uint32_t dt_ms = now_ms - last_sample_ms;
last_sample_ms = now_ms;
const float p_w = dev.readPower(0);
if (isnan(p_w)) return;
const double dwh = (double)p_w * dt_ms / 3600000.0;
if (p_w >= 0.0f) consume_wh += dwh;
else export_wh += -dwh;
static uint32_t next_print = 0;
if (millis() >= next_print) {
next_print = millis() + 200;
Serial.print(F("P=")); Serial.print(p_w, 1);
Serial.print(F("W cons=")); Serial.print(consume_wh, 4);
Serial.print(F("Wh exp=")); Serial.print(export_wh, 4);
Serial.print(F("Wh net=")); Serial.print(consume_wh - export_wh, 4);
Serial.println(F("Wh"));
}
}
Sketch completo em 06_BidirectionalEnergy.ino. Num módulo STANDARD (STD), dev.energy().wh(0) já lhe dá o saldo líquido com sinal — só precisa desta repartição do lado do mestre para relatar separadamente o consumo bruto e a exportação bruta.
Cenário 6 — Balanço energético doméstico
Três módulos: rede (bidir, STANDARD (STD)) + solar (apenas geração, BASIC OK)
- cargas (UI3 BASIC para cada eletrodoméstico). Painel doméstico combinado publicado a cada 60 s.
#include
#include
#include
#include
static RbAmp mains(Wire, 0x50); // bidirectional
static RbAmp solar(Wire, 0x51); // generation only
static RbAmp loads(Wire, 0x52); // UI3
static RbAmp* mods[] = { &mains, &solar, &loads };
static WiFiClient espClient;
static PubSubClient mqtt(espClient);
void setup() {
Serial.begin(115200);
WiFi.begin("ssid", "pass");
while (WiFi.status() != WL_CONNECTED) delay(500);
mqtt.setServer("192.168.1.10", 1883); mqtt.connect("home-balance");
Wire.begin();
Wire.setClock(50000); // 50 kHz on ESP32 (100 kHz on non-ESP32 masters)
for (auto m : mods) { while (!m->begin()) delay(500); m->enableGc(true); }
}
void loop() {
delay(60000);
static uint16_t g_tick = 0;
RbAmp::broadcastLatchGroup(Wire, /*group=*/0x00, ++g_tick); // coherent all-call snapshot
delay(50);
RbAmpPeriodSnapshot sm, ss, sl;
mains.readPeriodSnapshot(sm, 0, true);
solar.readPeriodSnapshot(ss, 0, true);
loads.readPeriodSnapshot(sl, 0, true);
char payload[512];
snprintf(payload, sizeof(payload),
"{\"mains\":%.3f,\"solar\":%.3f,\"hp\":%.3f,\"ac\":%.3f,\"ev\":%.3f}",
mains.energy().wh(0),
solar.energy().wh(0),
loads.energy().wh(0),
loads.energy().wh(1),
loads.energy().wh(2));
mqtt.publish("home/energy/balance", payload, true);
mqtt.loop();
}
Para a separação explícita consumo/exportação no módulo de rede, combine com o padrão do Cenário 5 (execute um ciclo separado a 10 Hz sobre mains.readPower(0)).
Cenário 7 — Deteção de eventos (EMA)
Em cada janela RT de 100 ms, compare P com uma média móvel exponencialmente ponderada. Registe os desvios significativos (micro-ondas / chaleira).
#include
#include
static RbAmp dev(Wire, 0x50);
static float p_ema = 0.0f;
static const float EMA_ALPHA = 0.05f;
static const float EVENT_THRESHOLD_W = 200.0f;
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
while (!dev.begin()) { delay(500); }
p_ema = dev.readPower(0); // seed EMA so first read isn't a spurious event
if (isnan(p_ema)) p_ema = 0.0f;
}
void loop() {
delay(200);
const float p = dev.readPower(0);
if (isnan(p)) return;
const float delta = p - p_ema;
p_ema = (1.0f - EMA_ALPHA) * p_ema + EMA_ALPHA * p;
if (fabsf(delta) > EVENT_THRESHOLD_W) {
Serial.print(millis()); Serial.print(F(" "));
Serial.print(delta > 0 ? F("TURN_ON ") : F("TURN_OFF "));
Serial.print(F("delta=")); Serial.print(delta, 0); Serial.print(F("W "));
Serial.print(F("P=")); Serial.print(p, 0); Serial.print(F("W "));
Serial.print(F("EMA=")); Serial.println(p_ema, 0);
}
}
Cenário composto — sem ficheiro de exemplo dedicado. Combine com a publicação MQTT do Cenário 4 para automatização de eventos no HA, ou registe no SD com Adafruit_SD para acompanhamento offline de eventos.
Cenário 8 — Monitor de bancada autónomo de 12 horas
Ensaio de resistência longa — executa a biblioteca contra um DUT real durante 12-15 horas sob uma carga densa por ciclo, emitindo uma linha CSV a cada 5 minutos com contadores de diagnóstico completos. É a receita de referência usada para qualificar o firmware v1.1 na referência do mestre da biblioteca Arduino.
Principais características:
-
Substituição de
RBAMP_NACK_RETRY_ATTEMPTS=5— defina ANTES do include para ajustar a repetição em cargas densas (≥10 leituras de um byte por ciclo). A predefinição de 3 chega para a consulta de 60 s do ESPHome; o SoakMonitor lê ~45 bytes por ciclo e precisa da margem extra. -
dev.rawTopology()— leitura direta do fio de REG_TOPOLOGY (0x24) para deteção da v1.1. Devolve 1/2/3 na v1.1,0x00na v1.0,0xFFem falha I2C. -
dev.retryExhaustionCount()+dev.sanityRejectCount()— ambos têm de se manter em 0 para uma execução de 12 h aprovada.
Esqueleto de cada ciclo:
#define RBAMP_NACK_RETRY_ATTEMPTS 5
#include
#include
RbAmp dev(Wire, 0x50);
void emitCycle() {
const float u = dev.readVoltage();
float i[3]={NAN,NAN,NAN}, p[3]={NAN,NAN,NAN}, pf[3]={NAN,NAN,NAN};
for (uint8_t c = 0; c < dev.channels(); c++) {
i[c] = dev.readCurrent(c);
p[c] = dev.readPower(c);
pf[c] = dev.readPowerFactor(c);
}
const float freq = dev.readFrequency();
RbAmpPeriodSnapshot snap;
const bool snap_ok = dev.readPeriodSnapshot(snap, 60);
/* CSV row (shortened) */
Serial.printf("%lu,%.3f,%.4f,%.3f,%.4f,%.1f,%.4f,%lu,%lu,%.6f,%lu,%lu,%u\n",
millis(), u, i[0], p[0], pf[0], freq,
snap.avg_p[0], snap.latch_ms, snap.master_dt_ms,
dev.energy().wh(0),
dev.retryExhaustionCount(),
dev.sanityRejectCount(),
snap_ok ? 1 : 0);
}
void setup() {
Serial.begin(115200);
Wire.begin(21, 22); Wire.setClock(50000);
while (!dev.begin()) delay(500);
dev.resetCounters();
emitCycle();
}
void loop() {
static uint32_t next_ms = 5UL * 60UL * 1000UL;
if (millis() >= next_ms) { emitCycle(); next_ms += 5UL * 60UL * 1000UL; }
delay(100);
}
O esboço é construído a partir dos excertos deste cenário. Execute com arduino-cli monitor -p COM3 -c baudrate=115200 > soak.csv e deixe a correr 12–15 h sem supervisão. Critérios de aceitação: retry_exhaust == 0, sanity_reject == 0, period_ok / period_total ≥ 99 %, Wh monótono.
Cenário 9 — Registador de deep sleep a bateria
O ESP32 acorda a cada 10 minutos, tira um instantâneo de período, publica por WiFi+MQTT e entra em deep-sleep. A energia persiste entre suspensões através da memória RTC. O acumulador da biblioteca fica desativado — o mestre é que assegura a persistência dos Wh.
Esqueleto relevante para a biblioteca:
#include
#include
#include "esp_sleep.h"
RTC_DATA_ATTR uint32_t rtc_magic = 0;
RTC_DATA_ATTR double rtc_total_wh = 0;
RTC_DATA_ATTR bool rtc_primer_done = false;
void setup() {
Serial.begin(115200);
Wire.begin();
RbAmp dev(Wire, 0x50);
if (rtc_magic != 0xCAFEFEED) {
rtc_magic = 0xCAFEFEED; rtc_total_wh = 0; rtc_primer_done = false;
}
dev.begin();
dev.energy().disable(); // master owns Wh
if (!rtc_primer_done) {
dev.latchPeriod();
rtc_primer_done = true;
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
esp_deep_sleep_start();
}
RbAmpPeriodSnapshot snap;
if (dev.readPeriodSnapshot(snap)) {
// master_dt_ms measures actual wake-to-wake interval
rtc_total_wh += (double)snap.avg_p[0] * snap.master_dt_ms / 3600000.0;
publish_via_wifi(snap.avg_p[0], rtc_total_wh, snap.master_dt_ms);
}
esp_sleep_enable_timer_wakeup(10ULL * 60ULL * 1000000ULL);
esp_deep_sleep_start();
}
void loop() {}
Sketch completo (com configuração do WiFi, publicação MQTT, proteções de marcador mágico RTC) em 07_DeepSleepLogger.ino.
Orçamento de energia (ESP32-WROOM, intervalo de despertar de 10 min):
- Duração do despertar: ~3 s (WiFi + MQTT + I2C)
- Corrente de despertar: ~80 mA média → ~0.07 mAh por despertar
- Corrente em repouso: ~10 µA (RTC + domínios retidos)
- ~10 mAh/dia no total → uma bateria Li-ion de 2000 mAh dura ~6 meses
Cenário 10 — Alteração do endereço I2C
Reatribui o endereço escravo de um rbAmp de 0x50 para 0x51. Usado uma vez por módulo ao construir uma instalação multimódulo. Desligue os outros módulos durante esta operação para evitar colisões no barramento.
No firmware atual (v1.3+), alterar o endereço I²C de um módulo não exige modo especial, jumper nem ferramentas de fábrica — prepara o novo endereço, arma a alteração e confirma-a (uma sequência de duas fases com armação mágica, para que um endereço não mude por acidente), e o módulo reinicia no novo endereço. A biblioteca impõe um protocolo de dois passos — prepareAddressChange() arma, commitAddressChange() escreve dentro de uma janela de 5 segundos.
#include
#include
static const uint8_t CURRENT_ADDR = 0x50;
static const uint8_t NEW_ADDR = 0x51;
static RbAmp dev(Wire, CURRENT_ADDR);
void setup() {
Serial.begin(115200);
Wire.begin();
dev.setLogStream(&Serial);
if (!dev.begin()) {
Serial.println(F("device not found")); return;
}
Serial.print(F("fw=0x")); Serial.println(dev.firmwareVersion(), HEX);
// Step 1: arm the change (no special mode needed on firmware v1.3+).
if (!dev.prepareAddressChange(NEW_ADDR)) {
Serial.print(F("prepare: ")); Serial.println(RbAmp::errorString(dev.lastError()));
if (dev.lastError() == rbamp::RB_ERR_MODE) {
Serial.println(F("Module firmware is older than v1.3 - update to v1.3+ for the no-mode two-phase path."));
}
return;
}
delay(1000);
// Step 2: commit — writes 0x30, CMD_SAVE_GAINS (700 ms), CMD_RESET (100 ms).
if (!dev.commitAddressChange()) {
Serial.print(F("commit: ")); Serial.println(RbAmp::errorString(dev.lastError()));
return;
}
Serial.print(F("device now at 0x")); Serial.println(dev.address(), HEX);
if (dev.probe()) Serial.println(F("verified"));
}
void loop() { delay(60000); }
Esboço completo em 05_AddressChange.ino. Se a janela de armação de 5 segundos expirar antes do commit, a biblioteca devolve false com lastError() == RB_ERR_TIMEOUT e repõe o flag de armação — tem de chamar prepareAddressChange() de novo. Isto evita erros de digitação que bloqueiam o dispositivo com uma única chamada má.
Cenário 11 — Um só sketch, ambas as linhas de módulos
O exemplo 11_StdLine mostra que um único esboço serve módulos BASIC e STANDARD (STD). O begin() deteta a linha; as chamadas de leitura comuns (readVoltage(), readCurrent(), readPower(), readPowerFactor(), readFrequency()) funcionam em ambos, e os extras apenas-STD — potência reativa e aparente, leituras em bloco por canal (stdReadChannel()), contadores de saúde (stdReadHealth()) e os bancos de instantâneos do período — ficam atrás de uma verificação line():
if (dev.line() == RbAmpLine::Std) {
RbAmpStdChannel c;
if (dev.stdReadChannel(0, c)) {
Serial.print(F("Q0=")); Serial.print(c.q, 1);
Serial.print(F(" var S0=")); Serial.println(c.s, 1);
}
} else {
// BASIC: reactive power is not exposed by this library
}
Num módulo BASIC as chamadas std* devolvem RB_ERR_NOT_IMPLEMENTED. A descrição chamada a chamada está em 09 · Referência da API § API da linha STD.
Tabela comparativa
| # | LOC | Barramento I2C | Período? | DRDY? | MQTT? | Persistência |
|---|---|---|---|---|---|---|
| 1 | ~30 | partilhado | não | não | não | nenhum |
| 2 | ~50 | partilhado com o OLED | sim | não | não | RAM |
| 3 | ~50 | partilhado com 3 módulos | sim | não | não | RAM |
| 4 | ~80 | dedicado | sim | não | sim | MQTT retained |
| 5 | ~50 | dedicado | não (RT) | não | não | RAM (propriedade do master) |
| 6 | ~70 | partilhado com 3 módulos | sim | não | sim | MQTT retained |
| 7 | ~40 | dedicado | não (RT) | não | não | RAM |
| 8 | ~250 | dedicado | sim | não | não | nenhum (fluxo CSV) |
| 9 | ~150 | dedicado | sim | não | sim | Memória RTC + MQTT |
| 10 | ~50 | dedicado | n/a | não | não | flash (lado do escravo) |
| 11 | ~130 | dedicado | sim | não | não | nenhum |
O que se segue
- Integrações DIY — ligar estes cenários ao Home Assistant / Node-RED / OpenHAB
- Integrações Cloud — pipelines AWS IoT / Azure / GCP / InfluxDB
- Referência da API — todos os métodos públicos documentados
- Resolução de problemas — quando os cenários se comportam mal na sua bancada
Relacionado — documentação principal da rbAmp
- Referência da API — especificação formal de registos I²C / comandos / erros que a biblioteca encapsula
- Exemplos Arduino (I²C em bruto) — os mesmos cenários sem a biblioteca, úteis para portar
- Medição por período — conceito de instantâneo de período atómico e fórmula de energia do lado do mestre
- Ligação de hardware — pinagem, ligação, instalação dos TC
- Resolução de problemas — problemas do lado do módulo (NACK, deriva de calibração, ruído no barramento)
Fonte e problemas: rb-amp/rbamp-arduino · esta página no repositório: docs/06_examples.md
Fonte e problemas: rb-amp/rbamp-arduino · esta página no repositório: docs/06_examples.md (v1.6.2)