15 · Esempi Raspberry Pi Pico SDK
Questo capitolo è l'equivalente per Raspberry Pi Pico di arduino-examples.md, micropython-examples.md, esp-idf-examples.md e stm32-hal-examples.md: gli stessi dieci scenari, portati in C nativo con Pico SDK (pico-sdk 1.5+ / 2.x) e networking basato su LwIP.
Questi esempi comunicano con rbAmp direttamente tramite l'API grezza dei registri I²C. Sono pensati per firmware embedded di produzione su RP2040 / RP2350 — controllo diretto del Cortex-M0+ / M33 dual-core, integrazione con il client MQTT di LwIP, FATFS e le primitive di sospensione / persistenza dell'SDK.
Non è fornita nessuna libreria dedicata a Pico SDK — le librerie client coprono Arduino (incluso arduino-pico per RP2040 tramite l'API Wire), MicroPython (in esecuzione sul port RP2040), ESP-IDF e CPython su SBC Linux; vedere la tabella delle librerie client nel README. Per il firmware Pico SDK nativo in C, segua le ricette con API grezza qui sotto. Se desidera un'API di livello più alto su RP2040, la via più semplice è il core arduino-pico + la libreria Arduino di rbAmp.
Target supportati e toolchain
| Target | Verificato | Wi-Fi | Note |
|---|---|---|---|
| Raspberry Pi Pico (RP2040) | ✓ | no | Esempi solo I²C 1–3, 5, 7 |
| Raspberry Pi Pico W (RP2040 + CYW43) | ✓ | sì | Tutti gli esempi; usa pico-cyw43-arch + LwIP |
| Raspberry Pi Pico 2 (RP2350) | ✓ | no | Cortex-M33 |
| Raspberry Pi Pico 2 W (RP2350 + CYW43) | ✓ | sì | Tutti gli esempi |
Toolchain: pico-sdk 1.5.1+ (o 2.x per RP2350), CMake 3.13+, arm-none-eabi-gcc 12+; si consiglia l'estensione ufficiale VS Code «Raspberry Pi Pico».
Struttura del progetto
Ogni esempio usa la struttura standard di progetto pico-sdk:
example_NN/
├── CMakeLists.txt
├── pico_sdk_import.cmake
└── src/
├── example_NN.c
├── rbamp_io.h
├── rbamp_io.c
└── lwipopts.h (only for Wi-Fi examples)
CMakeLists.txt di primo livello:
cmake_minimum_required(VERSION 3.13)
# Pull in the SDK before project() — see pico-sdk template.
include(pico_sdk_import.cmake)
# For Pico W, set BOARD before project():
# set(PICO_BOARD pico_w)
project(example_NN C CXX ASM)
set(CMAKE_C_STANDARD 11)
pico_sdk_init()
add_executable(example_NN
src/example_NN.c
src/rbamp_io.c)
target_include_directories(example_NN PRIVATE src)
# Always-required libraries.
target_link_libraries(example_NN
pico_stdlib
hardware_i2c)
# Wi-Fi examples add CYW43 + LwIP + mqtt:
# target_link_libraries(example_NN
# pico_cyw43_arch_lwip_threadsafe_background
# pico_lwip_mqtt
# pico_lwip_sntp)
# target_compile_definitions(example_NN PRIVATE WIFI_SSID=\"...\" WIFI_PASSWORD=\"...\")
# Route stdio to USB CDC (for Pico's serial console).
pico_enable_stdio_usb(example_NN 1)
pico_enable_stdio_uart(example_NN 0)
pico_add_extra_outputs(example_NN)
Compilazione e flashing:
mkdir build && cd build
cmake ..
make -j
# Drag-and-drop the .uf2 onto the RPI-RP2 / RP2350 USB mass-storage device.
Indice degli esempi
| # | Titolo | Difficoltà | Uscita | MQTT | DRDY | Più moduli | Bidirezionale | Caso d'uso |
|---|---|---|---|---|---|---|---|---|
| 1 | Lettura rapida | minimo | USB stdio | — | — | — | — | Test di funzionamento |
| 2 | Misuratore di energia a 60 secondi su OLED | basso | SSD1306 | — | — | — | — | Contatore Wh in custodia |
| 3 | Monitor a più moduli | basso | USB stdio | — | — | sì (3) | — | Monitoraggio dell'intera abitazione |
| 4 | Monitoraggio energetico per singolo apparecchio (UI3) | medio | — | sì | — | — | — | Sotto-misura in HA |
| 5 | Bidirezionale lato master su un modulo BASIC | medio | USB stdio | — | sì | — | sì (master) | Casa solare su livello BASIC |
| 6 | Bilancio energetico domestico | alta | — | sì | — | sì (3) | sì | Bilancio domestico completo |
| 7 | Rilevazione di eventi di alimentazione | medio | USB + SD | — | sì | — | — | Registro eventi degli apparecchi |
| 8 | Publisher MQTT con HA Auto-discovery | medio | — | sì (+disco) | — | — | facoltativo | Integrazione HA pronta all'uso |
| 9 | Registratore alimentato a batteria con sleep dormiente | medio | — | sì | — | — | — | Misuratore fuori rete / per esterni |
| 10 | Tariffa a fasce orarie (TOU) con orologio da parete SNTP | medio | USB stdio | sì | — | — | facoltativo | Misura con tariffa di punta / fuori punta |
Gli esempi Wi-Fi (4, 6, 8, 9, 10) richiedono Pico W o Pico 2 W.
Helper comuni (rbamp_io.h / rbamp_io.c)
Collochi questi file nella directory src/ del progetto. Per risparmiare spazio, la riga #include "rbamp_io.h" è omessa in ogni esempio qui sotto.
rbamp_io.h
/**
* @file rbamp_io.h
* @brief Raw I2C helpers for the rbAmp slave (Raspberry Pi Pico SDK).
*/
#pragma once
#include
#include
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#ifdef __cplusplus
extern "C" {
#endif
#define RBAMP_I2C_TIMEOUT_US 50000U /* 50 ms */
/**
* @brief Initialise the I2C peripheral and pin functions.
* @param i2c_inst i2c0 or i2c1.
* @param sda_gpio SDA GPIO number (e.g. 4 for default i2c0).
* @param scl_gpio SCL GPIO number (e.g. 5 for default i2c0).
* @param baudrate Bus speed (use 50000 — the recommended 50 kHz; wrap reads in a short retry, see ch. 11 §2.2).
*/
void rbamp_io_init(i2c_inst_t *i2c_inst, uint sda_gpio, uint scl_gpio,
uint baudrate);
/**
* @brief Read one byte from a register of an rbAmp slave.
* @return PICO_OK on success, an error code otherwise.
*/
int rbamp_io_read_u8(uint8_t addr, uint8_t reg, uint8_t *out);
/**
* @brief Read a little-endian float32 from four consecutive registers.
* @details Reads four consecutive bytes. rbAmp supports READ auto-increment
* (a single burst-read is valid for atomicity). The per-byte form
* is shown for clarity. See chapter 11 for asymmetry rules.
*/
int rbamp_io_read_float_le(uint8_t addr, uint8_t reg, float *out);
/**
* @brief Read a little-endian uint32 from four consecutive registers.
*/
int rbamp_io_read_u32_le(uint8_t addr, uint8_t reg, uint32_t *out);
/**
* @brief Write a single byte to a register.
*/
int rbamp_io_write_u8(uint8_t addr, uint8_t reg, uint8_t val);
/**
* @brief Broadcast CMD_LATCH_PERIOD to every rbAmp with GC reception
* enabled (FLEET_CONFIG.bit0 = 1; opt-in, default OFF).
* @details Canonical 5-byte general-call frame: A5 27 group tick_lo tick_hi.
* Slaves reject any first byte != 0xA5. See chapter 11 §6.3.2.
* @param tick16 Caller's 16-bit window counter (mirrored at GC_TICK 0x59).
* @param group GROUP_ID filter (0 = all-call).
* @return PICO_OK on ACK; PICO_ERROR_GENERIC on NACK — fall back to per-module.
*/
int rbamp_io_broadcast_latch(uint16_t tick16, uint8_t group);
/**
* @brief Probe whether a slave responds at the given address.
* @return true if the slave acks, false otherwise.
*/
bool rbamp_io_probe(uint8_t addr);
/**
* @brief Block until DATA_VALID bit 0 of register 0xCE reads 1, or timeout.
* @return PICO_OK on success, PICO_ERROR_TIMEOUT otherwise.
*/
int rbamp_io_wait_ready(uint8_t addr, uint32_t timeout_ms);
/* ===== rbAmp register addresses (subset used in examples) ===== */
#define RB_REG_STATUS 0x00U
#define RB_REG_COMMAND 0x01U
#define RB_REG_VERSION 0x03U
#define RB_REG_AC_FREQ 0x20U
#define RB_REG_PERIOD_VALID 0x07U
#define RB_REG_U_RMS 0x86U
#define RB_REG_I0_RMS 0x8EU
#define RB_REG_I1_RMS 0x92U
#define RB_REG_I2_RMS 0x96U
#define RB_REG_P0_REAL 0xA6U
#define RB_REG_PF0 0xB2U
#define RB_REG_Q0 0xD0U
#define RB_REG_DATA_VALID 0xCEU
#define RB_REG_PERIOD_AVG_P0 0xDCU
#define RB_REG_PERIOD_AVG_P1 0xC2U
#define RB_REG_PERIOD_AVG_P2 0xC6U
#define RB_REG_PERIOD_MAX_P 0xE0U
#define RB_REG_PERIOD_LATCH_MS 0xECU
/* ===== Commands ===== */
#define RB_CMD_RESET 0x01U
#define RB_CMD_LATCH_PERIOD 0x27U
#ifdef __cplusplus
}
#endif
rbamp_io.c
#include "rbamp_io.h"
#include
#include "pico/error.h"
static i2c_inst_t *s_i2c = NULL;
void rbamp_io_init(i2c_inst_t *i2c_inst, uint sda_gpio, uint scl_gpio,
uint baudrate) {
s_i2c = i2c_inst;
i2c_init(s_i2c, baudrate);
gpio_set_function(sda_gpio, GPIO_FUNC_I2C);
gpio_set_function(scl_gpio, GPIO_FUNC_I2C);
/* The rbAmp board carries its own pull-ups; do NOT enable the internal
* pulls unless yours are physically removed. */
}
/**
* @brief Internal helper — one register read.
* @details Pattern: write reg-address (nostop=true) + read 1 byte.
*/
static int read_one(uint8_t addr, uint8_t reg, uint8_t *out) {
int n = i2c_write_timeout_us(s_i2c, addr, ®, 1,
/*nostop=*/true, RBAMP_I2C_TIMEOUT_US);
if (n != 1) return PICO_ERROR_GENERIC;
n = i2c_read_timeout_us(s_i2c, addr, out, 1,
/*nostop=*/false, RBAMP_I2C_TIMEOUT_US);
return (n == 1) ? PICO_OK : PICO_ERROR_GENERIC;
}
int rbamp_io_read_u8(uint8_t addr, uint8_t reg, uint8_t *out) {
return read_one(addr, reg, out);
}
int rbamp_io_read_float_le(uint8_t addr, uint8_t reg, float *out) {
uint8_t buf[4];
for (int i = 0; i < 4; i++) {
int rc = read_one(addr, (uint8_t)(reg + i), &buf[i]);
if (rc != PICO_OK) return rc;
}
memcpy(out, buf, sizeof(float)); /* RP2040 / RP2350 are little-endian */
return PICO_OK;
}
int rbamp_io_read_u32_le(uint8_t addr, uint8_t reg, uint32_t *out) {
uint8_t buf[4];
for (int i = 0; i < 4; i++) {
int rc = read_one(addr, (uint8_t)(reg + i), &buf[i]);
if (rc != PICO_OK) return rc;
}
*out = (uint32_t)buf[0] | (uint32_t)buf[1] << 8
| (uint32_t)buf[2] << 16 | (uint32_t)buf[3] << 24;
return PICO_OK;
}
int rbamp_io_write_u8(uint8_t addr, uint8_t reg, uint8_t val) {
uint8_t tx[2] = { reg, val };
int n = i2c_write_timeout_us(s_i2c, addr, tx, 2,
/*nostop=*/false, RBAMP_I2C_TIMEOUT_US);
return (n == 2) ? PICO_OK : PICO_ERROR_GENERIC;
}
int rbamp_io_broadcast_latch(uint16_t tick16, uint8_t group) {
/* Canonical 5-byte general-call frame: A5 27 group tick_lo tick_hi. */
uint8_t tx[5] = {
0xA5, /* frame magic */
RB_CMD_LATCH_PERIOD, /* opcode 0x27 */
group, /* group_id (0 = all-call) */
(uint8_t)(tick16 & 0xFF),
(uint8_t)((tick16 >> 8) & 0xFF),
};
int n = i2c_write_timeout_us(s_i2c, /*addr=*/0x00U, tx, sizeof tx,
/*nostop=*/false, RBAMP_I2C_TIMEOUT_US);
return (n == (int)sizeof tx) ? PICO_OK : PICO_ERROR_GENERIC;
}
bool rbamp_io_probe(uint8_t addr) {
uint8_t dummy;
/* A 1-byte read is the simplest ACK probe — read the STATUS register. */
return read_one(addr, RB_REG_STATUS, &dummy) == PICO_OK;
}
int rbamp_io_wait_ready(uint8_t addr, uint32_t timeout_ms) {
absolute_time_t deadline = make_timeout_time_ms(timeout_ms);
while (!time_reached(deadline)) {
uint8_t v = 0;
if (rbamp_io_read_u8(addr, RB_REG_DATA_VALID, &v) == PICO_OK
&& (v & 0x01U)) {
return PICO_OK;
}
sleep_ms(50);
}
return PICO_ERROR_TIMEOUT;
}
Esempio 1 — Lettura rapida (minima)
Obiettivo: stampare U, I, P, PF via USB CDC una volta al secondo. Hardware: Raspberry Pi Pico + un rbAmp UI1. I²C su GPIO 4 (SDA) / GPIO 5 (SCL) — pin predefiniti di i2c0.
src/example_01.c:
#include
#include "pico/stdlib.h"
#include "hardware/i2c.h"
#include "rbamp_io.h"
#define RB_ADDR 0x50U
int main(void) {
stdio_init_all(); /* USB CDC stdio */
sleep_ms(2000); /* let the USB host enumerate */
/* I2C0 on GPIO 4 / 5 at the recommended 50 kHz. */
rbamp_io_init(i2c0, 4, 5, 50000);
/* Wait until the first RT window has been computed. */
if (rbamp_io_wait_ready(RB_ADDR, 2000) != PICO_OK) {
printf("ERROR: rbAmp not ready\n");
while (1) tight_loop_contents();
}
uint8_t ver = 0;
rbamp_io_read_u8(RB_ADDR, RB_REG_VERSION, &ver);
printf("rbAmp version: 0x%02X\n", ver);
while (true) {
float u, i_, p, pf;
rbamp_io_read_float_le(RB_ADDR, RB_REG_U_RMS, &u );
rbamp_io_read_float_le(RB_ADDR, RB_REG_I0_RMS, &i_);
rbamp_io_read_float_le(RB_ADDR, RB_REG_P0_REAL, &p );
rbamp_io_read_float_le(RB_ADDR, RB_REG_PF0, &pf);
printf("U=%.1fV I=%.3fA P=%+.1fW PF=%+.3f\n", u, i_, p, pf);
sleep_ms(1000);
}
}
Output atteso sulla console seriale:
rbAmp version: 0x04
U=230.1V I=0.262A P=+60.2W PF=+0.998
U=229.9V I=0.262A P=+60.1W PF=+0.998
...
Si colleghi alla console seriale con minicom -D /dev/ttyACM0 -b 115200 (Linux), screen /dev/cu.usbmodem* (macOS) oppure PuTTY (Windows).
Esempio 2 — contatore energetico a 60 secondi su OLED
Obiettivo: contatore Wh aggiornato una volta al minuto, mostrato su un SSD1306 da 128×64 che condivide il bus I²C di rbAmp. Hardware: Pico + rbAmp + SSD1306 (0x3C) sullo stesso bus. Libreria: un driver SSD1306 standard per Pico-SDK (ad es. daschr/pico-ssd1306). L'API OLED qui sotto è simbolica — sostituisca con le chiamate del suo driver.
#include
#include
#include "pico/stdlib.h"
#include "rbamp_io.h"
#include "ssd1306.h"
#define RB_ADDR 0x50U
int main(void) {
stdio_init_all();
sleep_ms(2000);
rbamp_io_init(i2c0, 4, 5, 50000);
/* OLED shares the same i2c0. */
ssd1306_t oled;
ssd1306_init(&oled, 128, 64, 0x3C, i2c0);
rbamp_io_wait_ready(RB_ADDR, 2000);
/* Primer snapshot — discard its snapshot. */
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_prev_ms = to_ms_since_boot(get_absolute_time());
double total_wh = 0.0;
while (true) {
sleep_ms(60 * 1000);
/* 1) Final snapshot. */
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = to_ms_since_boot(get_absolute_time());
sleep_ms(50); /* let firmware finalise snapshot */
/* 2) Check PERIOD_VALID. */
uint8_t valid = 0;
rbamp_io_read_u8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
printf("WARN: stale snapshot\n");
t_prev_ms = to_ms_since_boot(get_absolute_time());
continue;
}
/* 3) Read time-averaged P. */
float avg_p = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p);
/* 4) Energy uses the MASTER clock. */
float dt_s = (float)(t_now_ms - t_prev_ms) / 1000.0f;
double e_wh = (double)avg_p * dt_s / 3600.0;
total_wh += e_wh;
t_prev_ms = t_now_ms;
/* 5) Render. */
char line[32];
ssd1306_clear(&oled);
snprintf(line, sizeof(line), "P: %6.1f W", avg_p);
ssd1306_draw_string(&oled, 0, 0, 1, line);
snprintf(line, sizeof(line), "dt: %6.1f s", dt_s);
ssd1306_draw_string(&oled, 0, 16, 1, line);
snprintf(line, sizeof(line), "%.2f Wh", total_wh);
ssd1306_draw_string(&oled, 0, 32, 2, line);
ssd1306_show(&oled);
printf("avg_P=%.1f E_period=%.3f total=%.3f\n", avg_p, e_wh, total_wh);
}
}
Il driver OLED e rbAmp condividono i2c0 — non chiami mai i2c_init() due volte; la funzione di supporto rbamp_io_init() lo fa già.
Esempio 3 — Monitor multi-modulo
Obiettivo: interrogare tre moduli (alimentazione principale, scaldabagno, condizionatore) e stampare il totale. Hardware: Pico + 3 × rbAmp UI1 a 0x50, 0x51, 0x52.
#include
#include
#include "pico/stdlib.h"
#include "rbamp_io.h"
typedef struct {
uint8_t addr;
const char *label;
} module_t;
static const module_t modules[] = {
{ 0x50, "Mains " },
{ 0x51, "Boiler" },
{ 0x52, "AC " },
};
#define N_MODULES (sizeof(modules) / sizeof(modules[0]))
int main(void) {
stdio_init_all();
sleep_ms(2000);
rbamp_io_init(i2c0, 4, 5, 50000);
/* Probe every module before entering the read loop. */
for (size_t i = 0; i < N_MODULES; i++) {
if (!rbamp_io_probe(modules[i].addr)) {
printf("ERROR: %s at 0x%02X not found\n",
modules[i].label, modules[i].addr);
while (1) tight_loop_contents();
}
}
printf("All modules OK\n");
while (true) {
float total_p = 0.0f;
printf("---\n");
/* Round-robin read. */
for (size_t i = 0; i < N_MODULES; i++) {
float u = 0.0f, p = 0.0f;
rbamp_io_read_float_le(modules[i].addr, RB_REG_U_RMS, &u);
rbamp_io_read_float_le(modules[i].addr, RB_REG_P0_REAL, &p);
printf("[%s] U=%.1f P=%+.1f W\n", modules[i].label, u, p);
total_p += p;
}
printf("TOTAL: %.1f W\n", total_p);
sleep_ms(2000);
}
}
Esempio 4 — Monitoraggio energetico per singolo apparecchio (UI3)
Obiettivo: un modulo UI3 con tre pinze amperometriche (CT) su tre carichi diversi sulla stessa fase; contatori Wh indipendenti pubblicati su MQTT ogni minuto. Hardware: Pico W (o Pico 2 W) + 1 × rbAmp UI3 + rete Wi-Fi con broker MQTT. Componenti SDK: pico_cyw43_arch_lwip_threadsafe_background, pico_lwip_mqtt.
Aggiunte a CMakeLists.txt:
set(PICO_BOARD pico_w)
target_link_libraries(example_04
pico_stdlib
hardware_i2c
pico_cyw43_arch_lwip_threadsafe_background
pico_lwip_mqtt)
target_compile_definitions(example_04 PRIVATE
WIFI_SSID=\"ssid\"
WIFI_PASSWORD=\"password\"
MQTT_BROKER_IP=\"192.168.1.10\")
src/lwipopts.h (minimo — estendere da pico-examples/pico_w/wifi/lwipopts_examples_common.h):
#pragma once
#include "lwip/apps/mqtt.h"
#define LWIP_MQTT 1
#define MEMP_NUM_SYS_TIMEOUT 8
/* Use the SDK's standard threadsafe-background opts. */
src/example_04.c:
#include
#include
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/mqtt.h"
#include "lwip/dns.h"
#include "rbamp_io.h"
#define RB_ADDR 0x50U
static const char *CH_NAMES[3] = { "main", "heatpump", "lights" };
static mqtt_client_t *s_mqtt;
static ip_addr_t s_broker_ip;
/**
* @brief MQTT connection-status callback (logs result; could trigger retry).
*/
static void mqtt_conn_cb(mqtt_client_t *client, void *arg,
mqtt_connection_status_t status) {
printf("MQTT connect status=%d\n", (int)status);
}
/**
* @brief Bring up Wi-Fi (CYW43) and connect to the MQTT broker.
*/
static void net_init(void) {
if (cyw43_arch_init()) {
printf("CYW43 init failed\n");
return;
}
cyw43_arch_enable_sta_mode();
if (cyw43_arch_wifi_connect_timeout_ms(WIFI_SSID, WIFI_PASSWORD,
CYW43_AUTH_WPA2_AES_PSK, 30000)) {
printf("Wi-Fi connect failed\n");
return;
}
printf("Wi-Fi up\n");
ipaddr_aton(MQTT_BROKER_IP, &s_broker_ip);
s_mqtt = mqtt_client_new();
struct mqtt_connect_client_info_t ci = { .client_id = "rbamp-ui3" };
mqtt_client_connect(s_mqtt, &s_broker_ip, 1883, mqtt_conn_cb, NULL, &ci);
}
/**
* @brief Publish one channel's state to MQTT.
*/
static void mqtt_publish_channel(const char *ch_name, float avg_p, double e_wh) {
char topic[64], payload[64];
snprintf(topic, sizeof(topic), "rbamp/%s/state", ch_name);
int n = snprintf(payload, sizeof(payload),
"{\"power\":%.1f,\"energy\":%.4f}", avg_p, e_wh);
mqtt_publish(s_mqtt, topic, payload, n, /*qos*/ 0, /*retain*/ 0,
NULL, NULL);
}
int main(void) {
stdio_init_all();
sleep_ms(2000);
net_init();
rbamp_io_init(i2c0, 4, 5, 50000);
rbamp_io_wait_ready(RB_ADDR, 2000);
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD); /* primer */
uint32_t t_prev_ms = to_ms_since_boot(get_absolute_time());
double total_wh[3] = { 0.0, 0.0, 0.0 };
while (true) {
sleep_ms(60 * 1000);
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = to_ms_since_boot(get_absolute_time());
sleep_ms(50);
uint8_t valid = 0;
rbamp_io_read_u8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
t_prev_ms = to_ms_since_boot(get_absolute_time());
continue;
}
/* PERIOD_AVG_P_W per channel: I0 at 0xDC, I1 at 0xC2, I2 at 0xC6. */
float avg_p[3];
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p[0]);
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P1, &avg_p[1]);
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P2, &avg_p[2]);
float dt_s = (float)(t_now_ms - t_prev_ms) / 1000.0f;
t_prev_ms = t_now_ms;
for (int ch = 0; ch < 3; ch++) {
double e = (double)avg_p[ch] * dt_s / 3600.0;
total_wh[ch] += e;
printf("[%s] avg_P=%+.1f W E_total=%.3f Wh\n",
CH_NAMES[ch], avg_p[ch], total_wh[ch]);
mqtt_publish_channel(CH_NAMES[ch], avg_p[ch], total_wh[ch]);
}
}
}
Esempio 5 — Bidirezionale lato master su un modulo BASIC
Obiettivo: implementare la contabilità bidirezionale sul master mentre il modulo ha firmware BASIC. Il Pico reagisce al fronte di discesa di DRDY tramite IRQ GPIO e separa consumo ed esportazione. Hardware: Pico + rbAmp UI1; DRDY collegato al GPIO 15.
#include
#include
#include "pico/stdlib.h"
#include "pico/critical_section.h"
#include "hardware/gpio.h"
#include "rbamp_io.h"
#define RB_ADDR 0x50U
#define PIN_DRDY 15
static volatile bool g_data_ready = false;
/**
* @brief Shared GPIO IRQ callback for the Pico SDK.
* @details The SDK uses a single callback for all GPIO IRQs — we filter by pin.
* Keep the callback short (no I2C, no printf inside an IRQ).
*/
static void gpio_callback(uint gpio, uint32_t events) {
if (gpio == PIN_DRDY && (events & GPIO_IRQ_EDGE_FALL)) {
g_data_ready = true;
}
}
int main(void) {
stdio_init_all();
sleep_ms(2000);
rbamp_io_init(i2c0, 4, 5, 50000);
rbamp_io_wait_ready(RB_ADDR, 2000);
/* DRDY input with internal pull-up; falling-edge IRQ. */
gpio_init(PIN_DRDY);
gpio_set_dir(PIN_DRDY, GPIO_IN);
gpio_pull_up(PIN_DRDY);
gpio_set_irq_enabled_with_callback(PIN_DRDY, GPIO_IRQ_EDGE_FALL,
true, &gpio_callback);
double e_consumed_wh = 0.0;
double e_exported_wh = 0.0;
// Use uint64_t for microsecond counters — to_us_since_boot() returns u64;
// truncating to u32 overflows every ~71.6 minutes and produces a multi-kWh
// dt_s spike on the wrap.
uint64_t t_last_us = to_us_since_boot(get_absolute_time());
uint64_t t_last_print_us = t_last_us;
printf("Bidirectional accumulator started\n");
while (true) {
if (!g_data_ready) {
tight_loop_contents();
continue;
}
g_data_ready = false;
uint32_t t_now_us = to_us_since_boot(get_absolute_time());
/* Signed instantaneous P_real: + consume, − export. */
float p = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_P0_REAL, &p);
float dt_s = (float)(t_now_us - t_last_us) / 1000000.0f;
t_last_us = t_now_us;
if (p > 0.0f) e_consumed_wh += (double)p * dt_s / 3600.0;
else e_exported_wh += (double)(-p) * dt_s / 3600.0;
/* Summary print every 5 s — not on every RT window. */
if (t_now_us - t_last_print_us >= 5000000UL) {
t_last_print_us = t_now_us;
printf("P=%+8.1fW consumed=%.4f Wh exported=%.4f Wh net=%+.4f Wh\n",
p, e_consumed_wh, e_exported_wh,
e_consumed_wh - e_exported_wh);
}
}
}
Notes:
- La funzione
gpio_set_irq_enabled_with_callback()di Pico SDK registra una callback condivisa per tutte le IRQ GPIO; le successive chiamate agpio_set_irq_enabled()la riutilizzano. volatile boolbasta per la sincronizzazione con un singolo flag — RP2040 è single-issue e il booleano viene letto in modo atomico.
Esempio 6 — Bilancio energetico domestico
Obiettivo: cruscotto completo del bilancio. Tre moduli:
- rbAmp #1 sulla linea principale (STD — bidirezionale)
- rbAmp #2 sull'uscita dell'inverter solare (BASIC compatibile)
- rbAmp #3 UI3 su tre grandi carichi (HP, AC, EV)
Il master usa rbamp_io_broadcast_latch() per le istantanee sincrone e pubblica un saldo retained su MQTT ogni minuto.
#include
#include
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/mqtt.h"
#include "rbamp_io.h"
#define ADDR_MAINS 0x50U
#define ADDR_SOLAR 0x51U
#define ADDR_LOADS 0x52U
#define REG_PERIOD_AVG_P_NEG_MAINS 0xFFU /* set per SKU datasheet on STD */
extern void net_init(void); /* same boilerplate as Ex. 4 */
extern mqtt_client_t *s_mqtt;
typedef struct {
double mains_in_wh;
double mains_out_wh;
double solar_total_wh;
double loads_wh[3];
} totals_t;
int main(void) {
stdio_init_all();
sleep_ms(2000);
net_init();
rbamp_io_init(i2c0, 4, 5, 50000);
rbamp_io_wait_ready(ADDR_MAINS, 2000);
rbamp_io_wait_ready(ADDR_SOLAR, 2000);
rbamp_io_wait_ready(ADDR_LOADS, 2000);
/* Primer snapshot on all modules (general call). GC is opt-in
* (FLEET_CONFIG.bit0, default OFF) — fall back to per-module on NACK. */
uint16_t gc_tick = 0;
if (rbamp_io_broadcast_latch(gc_tick++, 0) != PICO_OK) {
rbamp_io_write_u8(ADDR_MAINS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
rbamp_io_write_u8(ADDR_SOLAR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
rbamp_io_write_u8(ADDR_LOADS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
}
uint32_t t_prev_ms = to_ms_since_boot(get_absolute_time());
totals_t totals = {0};
printf("Home balance started\n");
while (true) {
sleep_ms(60 * 1000);
/* Synchronous snapshot on all modules. */
if (rbamp_io_broadcast_latch(gc_tick++, 0) != PICO_OK) {
rbamp_io_write_u8(ADDR_MAINS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
rbamp_io_write_u8(ADDR_SOLAR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
rbamp_io_write_u8(ADDR_LOADS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
}
uint32_t t_now_ms = to_ms_since_boot(get_absolute_time());
sleep_ms(50);
float dt_s = (float)(t_now_ms - t_prev_ms) / 1000.0f;
t_prev_ms = t_now_ms;
/* ----- MAINS (bidirectional, STD) ----- */
uint8_t valid;
if (rbamp_io_read_u8(ADDR_MAINS, RB_REG_PERIOD_VALID, &valid) == PICO_OK
&& (valid & 0x01U)) {
float p_consume = 0.0f, p_export = 0.0f;
rbamp_io_read_float_le(ADDR_MAINS, RB_REG_PERIOD_AVG_P0, &p_consume);
if (REG_PERIOD_AVG_P_NEG_MAINS != 0xFFU) {
rbamp_io_read_float_le(ADDR_MAINS, REG_PERIOD_AVG_P_NEG_MAINS,
&p_export);
}
totals.mains_in_wh += (double)p_consume * dt_s / 3600.0;
totals.mains_out_wh += (double)p_export * dt_s / 3600.0;
}
/* ----- SOLAR (generation only) ----- */
if (rbamp_io_read_u8(ADDR_SOLAR, RB_REG_PERIOD_VALID, &valid) == PICO_OK
&& (valid & 0x01U)) {
float p = 0.0f;
rbamp_io_read_float_le(ADDR_SOLAR, RB_REG_PERIOD_AVG_P0, &p);
totals.solar_total_wh += (double)p * dt_s / 3600.0;
}
/* ----- LOADS (UI3, three channels) ----- */
if (rbamp_io_read_u8(ADDR_LOADS, RB_REG_PERIOD_VALID, &valid) == PICO_OK
&& (valid & 0x01U)) {
float p[3] = {0};
rbamp_io_read_float_le(ADDR_LOADS, RB_REG_PERIOD_AVG_P0, &p[0]); /* I0 */
rbamp_io_read_float_le(ADDR_LOADS, RB_REG_PERIOD_AVG_P1, &p[1]); /* I1 */
rbamp_io_read_float_le(ADDR_LOADS, RB_REG_PERIOD_AVG_P2, &p[2]); /* I2 */
for (int i = 0; i < 3; i++) {
totals.loads_wh[i] += (double)p[i] * dt_s / 3600.0;
}
}
double total_consumed = totals.mains_in_wh + totals.solar_total_wh
- totals.mains_out_wh;
double solar_self_used = totals.solar_total_wh - totals.mains_out_wh;
if (solar_self_used < 0.0) solar_self_used = 0.0;
printf("MAINS in=%.2f out=%.2f\n", totals.mains_in_wh, totals.mains_out_wh);
printf("SOLAR gen=%.2f self-used=%.2f exported=%.2f\n",
totals.solar_total_wh, solar_self_used, totals.mains_out_wh);
printf("LOADS HP=%.2f AC=%.2f EV=%.2f\n",
totals.loads_wh[0], totals.loads_wh[1], totals.loads_wh[2]);
printf("TOTAL household consumed=%.2f Wh\n", total_consumed);
char payload[512];
int n = snprintf(payload, sizeof(payload),
"{\"mains_in\":%.3f,\"mains_out\":%.3f,\"solar\":%.3f,"
"\"self_used\":%.3f,\"total_consumed\":%.3f,"
"\"hp\":%.3f,\"ac\":%.3f,\"ev\":%.3f}",
totals.mains_in_wh, totals.mains_out_wh, totals.solar_total_wh,
solar_self_used, total_consumed,
totals.loads_wh[0], totals.loads_wh[1], totals.loads_wh[2]);
mqtt_publish(s_mqtt, "home/energy/balance", payload, n,
/*qos*/ 1, /*retain*/ 1, NULL, NULL);
}
}
Esempio 7 — Rilevazione di eventi di alimentazione
Obiettivo: a ogni fronte DRDY, confrontare la potenza istantanea P con una EMA e registrare su una scheda SD montata via SPI + FATFS gli scostamenti significativi. Hardware: Pico + rbAmp + modulo scheda SD SPI. Libreria: no-OS-FatFS-SD-SPI-RPi-Pico oppure un port FATFS analogo compatibile con l'SDK.
#include
#include
#include
#include "pico/stdlib.h"
#include "hardware/gpio.h"
#include "ff.h" /* FATFS API */
#include "rbamp_io.h"
#define RB_ADDR 0x50U
#define PIN_DRDY 15
#define EMA_ALPHA 0.05f
#define EVENT_THRESHOLD_W 200.0f
static volatile bool g_data_ready = false;
static FATFS s_fs;
static FIL s_logfile;
static void gpio_callback(uint gpio, uint32_t events) {
if (gpio == PIN_DRDY && (events & GPIO_IRQ_EDGE_FALL)) {
g_data_ready = true;
}
}
/**
* @brief Mount the SD card and open events.log in append mode.
*/
static bool sd_setup(void) {
if (f_mount(&s_fs, "", 1) != FR_OK) return false;
if (f_open(&s_logfile, "events.log",
FA_OPEN_APPEND | FA_WRITE) != FR_OK) return false;
return true;
}
int main(void) {
stdio_init_all();
sleep_ms(2000);
rbamp_io_init(i2c0, 4, 5, 50000);
rbamp_io_wait_ready(RB_ADDR, 2000);
if (sd_setup()) printf("SD mounted; logging to events.log\n");
else printf("WARN: SD card not available\n");
gpio_init(PIN_DRDY);
gpio_set_dir(PIN_DRDY, GPIO_IN);
gpio_pull_up(PIN_DRDY);
gpio_set_irq_enabled_with_callback(PIN_DRDY, GPIO_IRQ_EDGE_FALL,
true, &gpio_callback);
/* Seed the EMA with current power so we do not log a spurious startup event. */
float p_ema = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_P0_REAL, &p_ema);
printf("Event detector started\n");
while (true) {
if (!g_data_ready) { tight_loop_contents(); continue; }
g_data_ready = false;
float p = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_P0_REAL, &p);
float delta = p - p_ema;
p_ema = (1.0f - EMA_ALPHA) * p_ema + EMA_ALPHA * p;
if (fabsf(delta) > EVENT_THRESHOLD_W) {
const char *type = (delta > 0.0f) ? "TURN_ON" : "TURN_OFF";
char line[128];
int n = snprintf(line, sizeof(line),
"%lu %s delta=%+.1f W P=%.1f W EMA=%.1f W\n",
(unsigned long)to_ms_since_boot(get_absolute_time()),
type, delta, p, p_ema);
printf("%s", line);
UINT bw;
f_write(&s_logfile, line, n, &bw);
f_sync(&s_logfile); /* flush to the card */
}
}
}
Esempio 8 — Publisher MQTT con auto-discovery di Home Assistant
Obiettivo: un'integrazione HA pronta all'uso. Il Pico W si connette a Wi-Fi e a un broker MQTT, pubblica le configurazioni HA Auto-discovery (retained) ed emette uno stato JSON ogni minuto. Hardware: Pico W (o Pico 2 W) + un rbAmp UI1 + Wi-Fi + broker MQTT.
#include
#include
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/mqtt.h"
#include "rbamp_io.h"
#define RB_ADDR 0x50U
#define DEVICE_ID "rbamp_main"
#define DEVICE_NAME "Mains rbAmp"
extern void net_init(void); /* Wi-Fi + MQTT bring-up (Ex. 4) */
extern mqtt_client_t *s_mqtt;
/**
* @brief Publish one HA discovery config (retained).
*/
static void publish_discovery_sensor(const char *key, const char *friendly,
const char *unit, const char *dev_class,
const char *state_class) {
char topic[128], payload[512];
snprintf(topic, sizeof(topic),
"homeassistant/sensor/%s/%s/config", DEVICE_ID, key);
int n = snprintf(payload, sizeof(payload),
"{"
"\"name\":\"%s %s\","
"\"unique_id\":\"%s_%s\","
"\"state_topic\":\"rbamp/%s/state\","
"\"value_template\":\"{{ value_json.%s }}\","
"\"state_class\":\"%s\","
"\"device\":{"
"\"identifiers\":[\"%s\"],"
"\"name\":\"%s\","
"\"manufacturer\":\"rbAmp\","
"\"model\":\"rbAmp UI*\""
"}",
DEVICE_NAME, friendly, DEVICE_ID, key,
DEVICE_ID, key, state_class,
DEVICE_ID, DEVICE_NAME);
if (unit) n += snprintf(payload + n, sizeof(payload) - n,
",\"unit_of_measurement\":\"%s\"", unit);
if (dev_class) n += snprintf(payload + n, sizeof(payload) - n,
",\"device_class\":\"%s\"", dev_class);
n += snprintf(payload + n, sizeof(payload) - n, "}");
mqtt_publish(s_mqtt, topic, payload, n,
/*qos*/ 1, /*retain*/ 1, NULL, NULL);
}
/**
* @brief Publish the full set of HA discovery configs for one rbAmp.
*/
static void publish_discovery_all(void) {
publish_discovery_sensor("voltage", "Voltage", "V", "voltage", "measurement");
publish_discovery_sensor("current", "Current", "A", "current", "measurement");
publish_discovery_sensor("power", "Power", "W", "power", "measurement");
publish_discovery_sensor("energy", "Energy", "Wh", "energy", "total_increasing");
publish_discovery_sensor("frequency", "Frequency", "Hz", "frequency", "measurement");
publish_discovery_sensor("power_factor", "Power Factor", NULL, "power_factor", "measurement");
publish_discovery_sensor("apparent_power", "Apparent Power", "VA", "apparent_power", "measurement");
publish_discovery_sensor("reactive_power", "Reactive Power", "var", "reactive_power", "measurement");
}
/* Set to true by Ex.4's mqtt_conn_cb on MQTT_CONNECT_ACCEPTED.
* (Add `extern volatile bool s_mqtt_connected;` to the net_init translation unit.) */
extern volatile bool s_mqtt_connected;
int main(void) {
stdio_init_all();
sleep_ms(2000);
net_init();
/* MQTT connect is asynchronous — publishing discovery before the CONNECT
* callback fires causes mqtt_publish() to return ERR_CONN and the configs
* to silently disappear. Wait (bounded) for the connection. */
uint32_t mqtt_deadline = to_ms_since_boot(get_absolute_time()) + 15000;
while (!s_mqtt_connected) {
if (to_ms_since_boot(get_absolute_time()) > mqtt_deadline) {
printf("WARN: MQTT not connected after 15 s — discovery will be retried on reconnect\n");
break;
}
sleep_ms(100);
}
if (s_mqtt_connected) publish_discovery_all();
rbamp_io_init(i2c0, 4, 5, 50000);
rbamp_io_wait_ready(RB_ADDR, 2000);
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD); /* primer */
uint32_t t_prev_ms = to_ms_since_boot(get_absolute_time());
double total_wh = 0.0;
while (true) {
sleep_ms(60 * 1000);
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = to_ms_since_boot(get_absolute_time());
sleep_ms(50);
uint8_t valid = 0;
rbamp_io_read_u8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
t_prev_ms = to_ms_since_boot(get_absolute_time());
continue;
}
float avg_p = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p);
float dt_s = (float)(t_now_ms - t_prev_ms) / 1000.0f;
total_wh += (double)avg_p * dt_s / 3600.0;
t_prev_ms = t_now_ms;
/* Live RT values for the state payload. */
float u = 0, i_ = 0, pf = 0, q = 0;
uint8_t freq = 0;
rbamp_io_read_float_le(RB_ADDR, RB_REG_U_RMS, &u);
rbamp_io_read_float_le(RB_ADDR, RB_REG_I0_RMS, &i_);
rbamp_io_read_float_le(RB_ADDR, RB_REG_PF0, &pf);
rbamp_io_read_float_le(RB_ADDR, RB_REG_Q0, &q);
rbamp_io_read_u8 (RB_ADDR, RB_REG_AC_FREQ, &freq);
char payload[384];
int n = snprintf(payload, sizeof(payload),
"{"
"\"voltage\":%.1f,"
"\"current\":%.3f,"
"\"power\":%.1f,"
"\"energy\":%.3f,"
"\"frequency\":%u,"
"\"power_factor\":%.3f,"
"\"apparent_power\":%.1f,"
"\"reactive_power\":%.1f"
"}",
u, i_, avg_p, total_wh,
(unsigned)freq, pf, u * i_, q);
mqtt_publish(s_mqtt, "rbamp/" DEVICE_ID "/state", payload, n,
/*qos*/ 0, /*retain*/ 0, NULL, NULL);
printf("Published: %s\n", payload);
}
}
Esempio 9 — Registratore alimentato a batteria con sleep dormiente
Obiettivo: un registratore per esterni / fuori rete che si risveglia dalla modalità dormiente ogni 10 minuti tramite la sveglia RTC, acquisisce un periodo, pubblica via MQTT e torna in dormiente. Il Pico W scende a qualche centinaio di µA in sleep dormiente — sufficiente per molti mesi su una cella Li-ion. Hardware: Pico W + un rbAmp UI1 + Li-ion. L'rbAmp può essere alimentato in modo intermittente tramite un interruttore high-side su GPIO 16. Persistenza: pico/sleep.h + l'RTC on-chip + una piccola regione NOINIT (o NVM esterna) per lo stato che deve sopravvivere allo sleep.
#include
#include
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "pico/sleep.h"
#include "hardware/rtc.h"
#include "hardware/gpio.h"
#include "lwip/apps/mqtt.h"
#include "rbamp_io.h"
#define RB_ADDR 0x50U
#define PIN_RBAMP_POWER 16
#define WAKE_SECONDS (10 * 60)
extern void net_init(void);
extern mqtt_client_t *s_mqtt;
/* "NOINIT" region — variables that are not zeroed by the startup code.
* They survive dormant sleep on RP2040 because RAM stays powered. */
__attribute__((section(".uninitialized_data")))
static double s_total_wh;
__attribute__((section(".uninitialized_data")))
static uint32_t s_wake_count;
__attribute__((section(".uninitialized_data")))
static bool s_primer_done;
__attribute__((section(".uninitialized_data")))
static uint32_t s_magic; /* 0xCAFEFEED when state is initialised */
/**
* @brief Power-gate the rbAmp module.
*/
static void rbamp_power(bool on) {
gpio_init(PIN_RBAMP_POWER);
gpio_set_dir(PIN_RBAMP_POWER, GPIO_OUT);
gpio_put(PIN_RBAMP_POWER, on);
if (on) sleep_ms(300); /* let the LDO + MCU boot */
}
/**
* @brief Arm the RTC alarm `seconds` ahead (with day-wrap) and enter dormant sleep.
* @details Execution resumes at the reset vector via watchdog. On Pico W,
* deinit CYW43 BEFORE calling this — leaving the radio powered keeps
* the chip at ~10 mA instead of ~180 µA in dormant.
*/
static void enter_dormant(uint32_t seconds) {
datetime_t now;
if (!rtc_get_datetime(&now)) {
/* RTC not running — fall back to a brute reboot via watchdog. */
watchdog_reboot(0, 0, seconds * 1000U);
while (1) tight_loop_contents();
}
/* Convert "now" + `seconds` to absolute calendar time WITH day-wrap.
* Without this, alarms in the last 60 s of a day land at 00:0x today —
* a time in the past — and the RTC never matches until 24 h later. */
int total_sec = now.hour * 3600 + now.min * 60 + now.sec + (int)seconds;
int day_offset = total_sec / 86400;
total_sec %= 86400;
datetime_t alarm = now;
alarm.hour = total_sec / 3600;
alarm.min = (total_sec / 60) % 60;
alarm.sec = total_sec % 60;
if (day_offset > 0) {
/* Bump the day; for periods ≤ 24 h this is at most one day forward. */
alarm.day += day_offset;
/* NOTE: this does not handle month/year roll-over; for periods ≤ 24 h
* and well-set RTC the simplest fix is to step the day field; for a
* production logger use a proper time_t arithmetic via mktime. */
}
sleep_run_from_xosc();
sleep_goto_sleep_until(&alarm, NULL);
/* Force a clean reset so main() re-runs from the top (with NOINIT state). */
watchdog_reboot(0, 0, 1);
while (1) tight_loop_contents();
}
int main(void) {
stdio_init_all();
sleep_ms(1000);
/* Initialise persistent state on cold boot. Write `s_magic` LAST so a
* crash mid-init leaves the marker unset and forces re-initialisation. */
if (s_magic != 0xCAFEFEEDU) {
s_total_wh = 0.0;
s_wake_count = 0;
s_primer_done = false;
__dmb(); /* publish other fields before the marker */
s_magic = 0xCAFEFEEDU;
/* Seed the RTC with an arbitrary epoch so rtc_get_datetime() returns
* a valid struct from the first call. Without this, the alarm math in
* enter_dormant() reads garbage and sleep duration is undefined. */
rtc_init();
datetime_t epoch = { .year=2024, .month=1, .day=1,
.dotw=1, .hour=0, .min=0, .sec=0 };
rtc_set_datetime(&epoch);
sleep_us(64); /* RTC needs a few cycles to latch */
} else {
rtc_init();
}
s_wake_count++;
/* Power up rbAmp + I2C. */
rbamp_power(true);
rbamp_io_init(i2c0, 4, 5, 50000);
if (rbamp_io_wait_ready(RB_ADDR, 2000) != PICO_OK) {
printf("rbAmp not ready — sleeping\n");
rbamp_power(false);
enter_dormant(WAKE_SECONDS);
}
/* First wake-up after a cold boot: primer snapshot only. */
if (!s_primer_done) {
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
s_primer_done = true;
printf("Primer done — entering dormant\n");
rbamp_power(false);
enter_dormant(WAKE_SECONDS);
}
/* Subsequent wake-ups: close the period and read its average power. */
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
sleep_ms(50);
uint8_t valid = 0;
rbamp_io_read_u8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
printf("Stale snapshot — skipping cycle\n");
rbamp_power(false);
enter_dormant(WAKE_SECONDS);
}
float avg_p = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p);
/* dt approximation: dormant sleep + boot ≈ WAKE_SECONDS. For higher accuracy
* read the RTC calendar on entry and exit. */
float dt_s = (float)WAKE_SECONDS;
s_total_wh += (double)avg_p * dt_s / 3600.0;
/* Publish via Wi-Fi + MQTT (graceful fallback). */
net_init();
if (s_mqtt) {
char payload[256];
int n = snprintf(payload, sizeof(payload),
"{\"wake\":%lu,\"dt_s\":%.1f,\"avg_p\":%.1f,\"energy_wh\":%.3f}",
(unsigned long)s_wake_count, dt_s, avg_p, s_total_wh);
mqtt_publish(s_mqtt, "rbamp/remote/state", payload, n,
/*qos*/ 1, /*retain*/ 1, NULL, NULL);
printf("Published: %s\n", payload);
sleep_ms(200); /* let LwIP flush the publish */
} else {
printf("Wi-Fi/MQTT failed — value buffered in NOINIT RAM\n");
}
/* Power down the CYW43 radio BEFORE dormant — leaving it powered keeps
* the chip at ~10 mA instead of ~180 µA. Required for the headline
* "6 months on a 2000 mAh cell" power budget. */
#if PICO_CYW43_SUPPORTED
cyw43_arch_deinit();
#endif
rbamp_power(false);
enter_dormant(WAKE_SECONDS);
}
Notes:
- La sezione
.uninitialized_datanon viene azzerata all'avvio; sopravvive al breve reset che segue il risveglio dal dormiente. Un sentinella a numero magico (s_magic) permette di distinguere un avvio a freddo (RAM non inizializzata, magic casuale) da un risveglio. - Per una persistenza permanente anche alla rimozione della batteria, salvare periodicamente il totale nella flash interna con
flash_range_program(). Il Pico SDK ha buoni esempi inpico-examples/flash/. - Pico W in sospensione dormiente con CYW43 spento assorbe circa 1 mA. Il solo RP2040 (Pico) scende a circa 180 µA. Usi
cyw43_arch_deinit()prima della sospensione per spegnere il modulo radio.
Esempio 10 — Tariffa a fasce orarie (TOU) con orologio da parete SNTP
Obiettivo: fatturare l'energia con una pianificazione a fasce orarie. Il Pico W mantiene un orologio da parete reale via SNTP, assegna ogni periodo chiuso alla fascia tariffaria corretta, azzera i totali giornalieri a mezzanotte e pubblica payload con marche temporali ISO. Hardware: Pico W + un rbAmp UI1 + Wi-Fi.
Aggiunte a CMakeLists.txt:
target_link_libraries(example_10
pico_stdlib
hardware_i2c
pico_cyw43_arch_lwip_threadsafe_background
pico_lwip_mqtt
pico_lwip_sntp)
src/example_10.c:
#include
#include
#include
#include "pico/stdlib.h"
#include "pico/cyw43_arch.h"
#include "lwip/apps/mqtt.h"
#include "lwip/apps/sntp.h"
#include "rbamp_io.h"
#define RB_ADDR 0x50U
/* CEST = UTC+2. For full DST handling, recompute on roll-over. */
#define TZ_OFFSET_HOURS 2
#define PEAK_START_HOUR 8
#define PEAK_END_HOUR 22
extern void net_init(void);
extern mqtt_client_t *s_mqtt;
typedef struct {
double peak_wh, off_peak_wh;
int day_of_year;
} day_totals_t;
typedef struct {
double peak_wh, off_peak_wh;
} lifetime_totals_t;
static day_totals_t s_today = { .day_of_year = -1 };
static lifetime_totals_t s_lifetime = { 0 };
/**
* @brief Start SNTP and wait until the C library `time(NULL)` returns plausible UTC.
*/
static bool sntp_sync(uint32_t timeout_ms) {
sntp_setoperatingmode(SNTP_OPMODE_POLL);
sntp_setservername(0, "pool.ntp.org");
sntp_setservername(1, "time.google.com");
sntp_init();
absolute_time_t deadline = make_timeout_time_ms(timeout_ms);
while (!time_reached(deadline)) {
time_t now = time(NULL);
if (now > 1700000000) { /* ≥ year 2023 */
struct tm lt;
gmtime_r(&now, <);
printf("SNTP sync: %04d-%02d-%02d %02d:%02d:%02d UTC\n",
lt.tm_year + 1900, lt.tm_mon + 1, lt.tm_mday,
lt.tm_hour, lt.tm_min, lt.tm_sec);
return true;
}
sleep_ms(500);
}
return false;
}
static struct tm local_time(void) {
time_t now = time(NULL) + (TZ_OFFSET_HOURS * 3600);
struct tm lt;
gmtime_r(&now, <);
return lt;
}
static bool is_peak_hour(int hour) {
return (hour >= PEAK_START_HOUR) && (hour < PEAK_END_HOUR);
}
static void iso_now(char *out, size_t out_len) {
struct tm lt = local_time();
char sign = (TZ_OFFSET_HOURS >= 0) ? '+' : '-';
int off = (TZ_OFFSET_HOURS < 0) ? -TZ_OFFSET_HOURS : TZ_OFFSET_HOURS;
snprintf(out, out_len, "%04d-%02d-%02dT%02d:%02d:%02d%c%02d00",
lt.tm_year + 1900, lt.tm_mon + 1, lt.tm_mday,
lt.tm_hour, lt.tm_min, lt.tm_sec, sign, off);
}
/**
* @brief Add one period's energy to the right bucket; roll over the day at midnight.
*/
static void accumulate(double e_wh, const struct tm *tm_now) {
if (s_today.day_of_year != tm_now->tm_yday) {
if (s_today.day_of_year >= 0) {
char payload[192];
int n = snprintf(payload, sizeof(payload),
"{\"yday\":%d,\"peak_wh\":%.3f,\"off_peak_wh\":%.3f,"
"\"total_wh\":%.3f}",
s_today.day_of_year, s_today.peak_wh, s_today.off_peak_wh,
s_today.peak_wh + s_today.off_peak_wh);
mqtt_publish(s_mqtt, "rbamp/tou/day_close", payload, n,
/*qos*/ 1, /*retain*/ 1, NULL, NULL);
printf("Day closed: %s\n", payload);
}
s_today.peak_wh = 0.0;
s_today.off_peak_wh = 0.0;
s_today.day_of_year = tm_now->tm_yday;
}
if (is_peak_hour(tm_now->tm_hour)) {
s_today.peak_wh += e_wh;
s_lifetime.peak_wh += e_wh;
} else {
s_today.off_peak_wh += e_wh;
s_lifetime.off_peak_wh += e_wh;
}
}
int main(void) {
stdio_init_all();
sleep_ms(2000);
net_init();
sntp_sync(15000);
rbamp_io_init(i2c0, 4, 5, 50000);
rbamp_io_wait_ready(RB_ADDR, 2000);
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD); /* primer */
uint32_t t_prev_ms = to_ms_since_boot(get_absolute_time());
printf("TOU started: peak %02d:00..%02d:00 local\n",
PEAK_START_HOUR, PEAK_END_HOUR);
while (true) {
sleep_ms(60 * 1000);
rbamp_io_write_u8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = to_ms_since_boot(get_absolute_time());
sleep_ms(50);
uint8_t valid = 0;
rbamp_io_read_u8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
t_prev_ms = to_ms_since_boot(get_absolute_time());
continue;
}
float avg_p = 0.0f;
rbamp_io_read_float_le(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p);
float dt_s = (float)(t_now_ms - t_prev_ms) / 1000.0f;
double e_wh = (double)avg_p * dt_s / 3600.0;
t_prev_ms = t_now_ms;
struct tm lt = local_time();
if (lt.tm_year + 1900 < 2023) {
printf("WARN: clock not synced — retrying SNTP\n");
sntp_sync(15000);
continue;
}
accumulate(e_wh, <);
bool peak = is_peak_hour(lt.tm_hour);
char iso[40];
iso_now(iso, sizeof(iso));
char payload[384];
int n = snprintf(payload, sizeof(payload),
"{"
"\"ts\":\"%s\","
"\"tariff\":\"%s\","
"\"avg_p\":%.1f,"
"\"period_wh\":%.4f,"
"\"today_peak_wh\":%.3f,"
"\"today_off_peak_wh\":%.3f,"
"\"life_peak_wh\":%.3f,"
"\"life_off_peak_wh\":%.3f"
"}",
iso, peak ? "peak" : "off_peak",
avg_p, e_wh,
s_today.peak_wh, s_today.off_peak_wh,
s_lifetime.peak_wh, s_lifetime.off_peak_wh);
mqtt_publish(s_mqtt, "rbamp/tou/state", payload, n,
/*qos*/ 0, /*retain*/ 0, NULL, NULL);
printf("%s\n", payload);
}
}
Notes:
pico_lwip_sntpsi collega al client SNTP di LwIP; l'SDK lo collega alla libreria Ctime(NULL), cosìgmtime_r()funziona subito.- Per la gestione completa dell'ora legale, memorizzi l'offset TZ in una piccola tabella di ricerca, oppure integri una stringa POSIX TZ tramite il meccanismo
tzset()di newlib, se la sua build lo include. - Per la misura bidirezionale STD, chiami
accumulate()due volte — una per il consumo e una per l'esportazione — e pubblichi entrambe le fasce di punta / fuori punta.
Confronto degli esempi
| # | Complessità | Uscita | MQTT | DRDY | Più moduli | Bidirezionale | Persistenza | Caso d'uso |
|---|---|---|---|---|---|---|---|---|
| 1 | minimo | USB stdio | — | — | — | — | — | test di base (smoke test) |
| 2 | basso | OLED | — | — | — | — | RAM | contatore in custodia |
| 3 | basso | USB stdio | — | — | sì (3) | — | — | monitoraggio domestico |
| 4 | medio | — | sì | — | — | — | RAM | per singolo apparecchio in HA |
| 5 | medio | USB stdio | — | sì | — | sì (master) | RAM | casa solare su livello BASIC |
| 6 | alta | — | sì | — | sì (3) | sì | RAM | bilancio domestico completo |
| 7 | medio | USB + SD (FATFS) | — | sì | — | — | Scheda SD | rilevamento di eventi |
| 8 | medio | — | sì (+disco) | — | — | facoltativo | RAM + MQTT | HA Auto-discovery |
| 9 | medio | — | sì | — | — | — | RAM NOINIT | registratore fuori rete / per esterni |
| 10 | medio | USB stdio | sì | — | — | facoltativo | RAM + MQTT | Fasce di punta / fuori punta con SNTP |
Buone pratiche
- Controllare sempre i codici di ritorno delle chiamate
rbamp_io_*. Le transazioni I²C possono fallire su bus lunghi; il codice di produzione deve riprovare anziché ignorare l'errore. - Mantenere le callback IRQ GPIO minime. Il Pico SDK usa un'unica callback condivisa per tutte le IRQ GPIO — impostare un flag
volatile boole ritornare. Tutto il lavoro I²C / printf appartiene al loop principale. - Usare
i2c0ei2c1in modo indipendente. rbAmp sui2c0, OLED sui2c0, scheda SD su SPI — mantenere le periferiche sul bus per cui sono state inizializzate. - Usi
to_ms_since_boot(get_absolute_time())per il clock master. Precisione al microsecondo tramiteto_us_since_boot(). Monotono, sopravvive asleep_ms(). PERIOD_VALID(0x07) va verificato dopo ogniCMD_LATCH_PERIOD. Si hanno istantanee obsolete se il master interroga più rapidamente di quanto il firmware integri.- Attenda ≥ 50 ms dopo un'istantanea prima di leggere
0xDC..0xEF. - Per configurazioni multi-modulo,
rbamp_io_broadcast_latch(tick, group)via general call assicura una sincronizzazione precisa. La ricezione GC è opt-in per modulo (FLEET_CONFIG.bit0, predefinito OFF). In caso di NACK, ripiegare sull'acquisizione sequenziale per modulo. - Per applicazioni a batteria su Pico W, disattivare CYW43 (
cyw43_arch_deinit()) prima dello sleep per eliminare diversi mA. Il deep sleep dormiente dell'RP2040 è ~180 µA, quello dell'RP2350 ancora inferiore. - Salvare i totali Wh nella flash interna con
flash_range_program()se devono sopravvivere a una perdita di alimentazione completa. La RAM NOINIT sopravvive al dormiente ma non allo spegnimento. printffloat supportato è abilitato di default inpico_stdlib. Per RP2040 si usa l'implementazionepico_floatdell'SDK; per RP2350 il supporto FPU hardware è attivo di default.
Cosa segue
Dopo aver svolto questi dieci esempi:
- Per lo sviluppo ESP32 in stile Arduino, vedi arduino-examples.md (raw).
- Per MicroPython / CircuitPython (anche sul Pico stesso), vedi micropython-examples.md (raw).
- Per ESP-IDF nativo, vedere esp-idf-examples.md (raw).
- Per STM32 HAL, vedi stm32-hal-examples.md.
- Per l'integrazione ESPHome (YAML dichiarativo), vedere
tools/esphome-rbamp/docs/en/. - La specifica formale dei registri I²C usata qui si trova in api-reference.md.