14 · Примеры STM32 HAL
Эта глава — аналог STM32 HAL для arduino-examples.md, micropython-examples.md и esp-idf-examples.md: те же десять сценариев, перенесённые на STM32 HAL (C, сгенерированный CubeMX) с необязательными FreeRTOS / CMSIS-OS2.
Эти примеры обращаются к rbAmp напрямую через API сырых регистров I²C. Они предназначены для промышленной встраиваемой прошивки на STM32: прямой контроль над HAL, предсказуемый объём RAM и флеша, интеграция с LwIP, FATFS, FreeRTOS и генерацией HAL из CubeMX.
Настройте периферию I²C в CubeMX на 50 кГц (рекомендуется, см. главу 11 §2.2) и оберните чтение регистров коротким повтором.
Поддерживаемые семейства и тулчейн
| Семейство | Проверено | Периферия I²C | Примечания |
|---|---|---|---|
| Семейство STM32F1 | ✓ | I2C1, I2C2 | Распространённая цель для самоделок |
| STM32F4 (Nucleo-F411, Discovery) | ✓ | I2C1..3 | Высокая тактовая частота, много RAM |
| STM32L4 / L4+ | ✓ | I2C1..4 | Низкое энергопотребление, резервные регистры RTC, STOP / STANDBY |
| STM32G0 / G4 | ✓ | I2C1..3 | Современная периферия |
| STM32H7 (Nucleo-H743) | ✓ | I2C1..4 | Встроенный PHY Ethernet → MQTT напрямую через LwIP |
Тулчейн: CubeMX 6.x и CubeIDE или проект на Makefile (arm-none-eabi-gcc). Примеры рассчитаны на версию HAL, соответствующую вашему проекту, сгенерированному CubeMX. Новая сигнатура HAL для I²C (HAL_I2C_Mem_Read/Write) поддерживается всеми современными семействами.
Примечание о сети
У большинства микросхем STM32 нет встроенного Wi-Fi. Примеры с MQTT (4, 6, 8, 9) предполагают один из следующих сетевых путей:
- Ethernet — платы STM32F4 / F7 / H7 со встроенным PHY (LAN8742, DP83848), работающие на LwIP и небольшой библиотеке MQTT (Paho Embedded C, MQTT-C или форк, дружественный к HAL). Это самый простой путь.
- W5500 SPI Ethernet: для STM32F1 / L4 / G4 (без встроенного MAC). Использует WIZnet ioLibrary.
- ESP32-AT через UART: модуль ESP-AT работает как мост Wi-Fi. AT-команды отправляются из основного цикла STM32.
Примеры ниже показывают логику rbAmp во всех подробностях. Настройка сети вынесена за две функции-заглушки, которые вы реализуете в своём проекте:
extern HAL_StatusTypeDef Net_Init(void); // bring up the chosen stack
extern HAL_StatusTypeDef Net_MqttPublish(const char *topic,
const uint8_t *payload, uint32_t len,
uint8_t qos, uint8_t retain);
Референсные реализации для каждого сетевого пути выходят за рамки этой главы: выберите подходящий для вашей аппаратуры и замените заглушки.
Структура проекта
Структура проекта, сгенерированная CubeMX:
example_NN/
├── example_NN.ioc ← CubeMX project (pins, peripherals, clock)
├── Makefile ← (or *.eww / *.uvprojx for IAR / STM32CubeIDE)
├── Core/
│ ├── Inc/main.h
│ ├── Inc/rbamp_io.h ← common helpers
│ ├── Src/main.c ← USER CODE inside CubeMX markers
│ ├── Src/rbamp_io.c
│ └── Src/stm32xxxx_it.c ← EXTI handlers (CubeMX-generated)
├── Drivers/
│ └── STM32xxxx_HAL_Driver/ ← HAL sources
└── Middlewares/ ← FreeRTOS, LwIP, FATFS (optional)
Назначение выводов CubeMX, используемое во всех примерах, если не указано иное:
- I2C1: SCL = PB6, SDA = PB7 (типовые значения по умолчанию для STM32F1 / Nucleo-F411)
- UART1: TX = PA9, RX = PA10 — для отладки через
printf - EXTI: PA0 = DRDY (спадающий фронт, подтяжка вверх)
- Скорость I²C: 100 кГц
Оглавление примеров
| # | Заголовок | Сложность | Выход | MQTT | DRDY | Несколько модулей | Двунаправленный | Сценарий использования |
|---|---|---|---|---|---|---|---|---|
| 1 | Быстрое чтение | минимальный | UART printf | — | — | — | — | Проверка работоспособности |
| 2 | Счётчик энергии за 60 секунд на OLED | низкий | SSD1306 | — | — | — | — | Счётчик Вт·ч в корпусе |
| 3 | Монитор нескольких модулей | низкий | UART printf | — | — | да (3) | — | Мониторинг всего дома |
| 4 | Учёт энергии по отдельным приборам (UI3) | средний | — | да | — | — | — | Субсчётчики в HA |
| 5 | Двунаправленный учёт на стороне мастера для модуля BASIC | средний | UART printf | — | да | — | да (мастер) | Солнечный дом на уровне BASIC |
| 6 | Баланс энергии дома | высокий | — | да | — | да (3) | да | Полный баланс дома |
| 7 | Обнаружение событий питания | средний | UART + SD | — | да | — | — | Журнал событий приборов |
| 8 | Публикатор MQTT с HA Auto-discovery | средний | — | да (+disco) | — | — | необязательно | Готовая интеграция с HA |
| 9 | Логгер на батарее с режимом STANDBY | средний | — | да | — | — | — | Счётчик для улицы / автономной установки |
| 10 | Тарификация по времени суток (TOU) с настенными часами через SNTP | средний | UART printf | да | — | — | необязательно | Учёт по пиковому и внепиковому тарифу |
Общие хелперы (rbamp_io.h / rbamp_io.c)
Поместите эти файлы в Core/Inc и Core/Src вашего проекта CubeMX. Чтобы сэкономить место, строка #include "rbamp_io.h" опущена в каждом примере ниже.
rbamp_io.h
/**
* @file rbamp_io.h
* @brief Raw I2C helpers for the rbAmp slave (STM32 HAL).
*/
#ifndef RBAMP_IO_H
#define RBAMP_IO_H
#include
#include
#include "main.h" /* CubeMX-generated, brings the HAL header */
#ifdef __cplusplus
extern "C" {
#endif
/* I2C transaction timeout in milliseconds (HAL_GetTick units). */
#define RBAMP_I2C_TIMEOUT_MS 50U
/**
* @brief Bind the helpers to a HAL I2C handle.
* @details Stores the pointer internally; call once at startup. The handle
* must have been initialised by HAL_I2C_Init() (typically by CubeMX).
*/
void RbAmpIO_Bind(I2C_HandleTypeDef *hi2c);
/**
* @brief Read one byte from a register of an rbAmp slave.
* @param addr 7-bit slave address (e.g. 0x50).
* @param reg Register address inside the slave.
* @param out Output byte.
* @return HAL_OK on success.
*/
HAL_StatusTypeDef RbAmpIO_ReadU8(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.
*/
HAL_StatusTypeDef RbAmpIO_ReadFloatLE(uint8_t addr, uint8_t reg, float *out);
/**
* @brief Read a little-endian uint32 from four consecutive registers.
*/
HAL_StatusTypeDef RbAmpIO_ReadU32LE(uint8_t addr, uint8_t reg, uint32_t *out);
/**
* @brief Write a single byte to a register.
*/
HAL_StatusTypeDef RbAmpIO_WriteU8(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 HAL_OK on ACK; HAL_ERROR on NACK — fall back to per-module snapshot.
*/
HAL_StatusTypeDef RbAmpIO_BroadcastLatch(uint16_t tick16, uint8_t group);
/**
* @brief Probe whether a slave responds at the given address (1-byte read).
* @return true if the slave acks, false otherwise.
*/
bool RbAmpIO_Probe(uint8_t addr);
/**
* @brief Block until DATA_VALID bit 0 of register 0xCE reads 1, or timeout.
* @return HAL_OK if ready in time, HAL_TIMEOUT otherwise.
*/
HAL_StatusTypeDef RbAmpIO_WaitReady(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
#endif /* RBAMP_IO_H */
rbamp_io.c
#include "rbamp_io.h"
#include
/* HAL I2C uses the 8-bit address format: left-shift the 7-bit address. */
#define ADDR8(addr7) ((uint16_t)((addr7) << 1))
static I2C_HandleTypeDef *s_hi2c = NULL;
void RbAmpIO_Bind(I2C_HandleTypeDef *hi2c) {
s_hi2c = hi2c;
}
HAL_StatusTypeDef RbAmpIO_ReadU8(uint8_t addr, uint8_t reg, uint8_t *out) {
return HAL_I2C_Mem_Read(s_hi2c, ADDR8(addr), reg,
I2C_MEMADD_SIZE_8BIT, out, 1,
RBAMP_I2C_TIMEOUT_MS);
}
HAL_StatusTypeDef RbAmpIO_ReadFloatLE(uint8_t addr, uint8_t reg, float *out) {
uint8_t buf[4];
for (int i = 0; i < 4; i++) {
HAL_StatusTypeDef st = HAL_I2C_Mem_Read(s_hi2c, ADDR8(addr), reg + i,
I2C_MEMADD_SIZE_8BIT,
&buf[i], 1,
RBAMP_I2C_TIMEOUT_MS);
if (st != HAL_OK) return st;
}
memcpy(out, buf, sizeof(float)); /* STM32 is little-endian — host order matches */
return HAL_OK;
}
HAL_StatusTypeDef RbAmpIO_ReadU32LE(uint8_t addr, uint8_t reg, uint32_t *out) {
uint8_t buf[4];
for (int i = 0; i < 4; i++) {
HAL_StatusTypeDef st = HAL_I2C_Mem_Read(s_hi2c, ADDR8(addr), reg + i,
I2C_MEMADD_SIZE_8BIT,
&buf[i], 1,
RBAMP_I2C_TIMEOUT_MS);
if (st != HAL_OK) return st;
}
*out = (uint32_t)buf[0] | (uint32_t)buf[1] << 8
| (uint32_t)buf[2] << 16 | (uint32_t)buf[3] << 24;
return HAL_OK;
}
HAL_StatusTypeDef RbAmpIO_WriteU8(uint8_t addr, uint8_t reg, uint8_t val) {
return HAL_I2C_Mem_Write(s_hi2c, ADDR8(addr), reg,
I2C_MEMADD_SIZE_8BIT, &val, 1,
RBAMP_I2C_TIMEOUT_MS);
}
HAL_StatusTypeDef RbAmpIO_BroadcastLatch(uint16_t tick16, uint8_t group) {
/* Canonical 5-byte general-call frame: A5 27 group tick_lo tick_hi.
* HAL_I2C_Master_Transmit accepts the 8-bit address; 0x00 << 1 = 0x00. */
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),
};
return HAL_I2C_Master_Transmit(s_hi2c, ADDR8(0x00), tx, sizeof tx,
RBAMP_I2C_TIMEOUT_MS);
}
bool RbAmpIO_Probe(uint8_t addr) {
/* HAL_I2C_IsDeviceReady performs an address-only NACK probe. */
return HAL_I2C_IsDeviceReady(s_hi2c, ADDR8(addr), /*trials=*/2,
RBAMP_I2C_TIMEOUT_MS) == HAL_OK;
}
HAL_StatusTypeDef RbAmpIO_WaitReady(uint8_t addr, uint32_t timeout_ms) {
uint32_t deadline = HAL_GetTick() + timeout_ms;
while (HAL_GetTick() < deadline) {
uint8_t v = 0;
if (RbAmpIO_ReadU8(addr, RB_REG_DATA_VALID, &v) == HAL_OK && (v & 0x01U)) {
return HAL_OK;
}
HAL_Delay(50);
}
return HAL_TIMEOUT;
}
Перенаправление printf
Все примеры вызывают printf() через UART. В вашем main.c добавьте канонический вспомогательный код перенаправления (работает с newlib-nano):
extern UART_HandleTypeDef huart1;
/**
* @brief Standard newlib `_write` retarget — sends bytes to UART1.
* @details A bounded timeout (100 ms) prevents a stuck/unplugged UART from
* starving the IWDG (which `HAL_MAX_DELAY` would do). On timeout the
* chunk is dropped — preferable to a reset.
*/
int _write(int file, char *ptr, int len) {
if (HAL_UART_Transmit(&huart1, (uint8_t*)ptr, len, 100) != HAL_OK) {
return -1; /* drop chunk, do NOT block */
}
return len;
}
Для проектов Cube IDE с отключённой семихостингой и выбранным newlib-nano printf("%.1f", ...) требует -u _printf_float во флагах линкера.
Пример 1 — быстрое чтение (минимальное)
Цель: выводить U, I, P, PF в UART раз в секунду. Аппаратура: любой STM32 + один rbAmp UI1 + USB-UART для консоли на хосте.
В CubeMX:
- включить
I2C1(стандартный режим, 100 кГц) на PB6/PB7 - включить
USART1(115200 8N1) на PA9/PA10 - всё остальное по умолчанию
Пользовательский код в main.c — блоки /* USER CODE BEGIN 2 */ и /* USER CODE BEGIN WHILE */, показанные ниже, находятся внутри функции main(), сгенерированной CubeMX, между вызовами инициализации и циклом while(1). Не вставляйте их на уровень файла — они должны находиться внутри main().
Эталонная форма (окружающая int main(void) { … } генерируется CubeMX и показана здесь только для контекста):
/* USER CODE BEGIN Includes */
#include
#include "rbamp_io.h"
/* USER CODE END Includes */
extern I2C_HandleTypeDef hi2c1;
extern UART_HandleTypeDef huart1;
int _write(int file, char *ptr, int len) {
if (HAL_UART_Transmit(&huart1, (uint8_t*)ptr, len, 100) != HAL_OK) return -1;
return len;
}
#define RB_ADDR 0x50U
int main(void) /* generated by CubeMX */
{
HAL_Init(); /* generated by CubeMX */
SystemClock_Config(); /* generated by CubeMX */
MX_GPIO_Init(); /* generated */
MX_I2C1_Init(); /* generated */
MX_USART1_UART_Init(); /* generated */
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
/* Wait until the first RT window has been computed. */
if (RbAmpIO_WaitReady(RB_ADDR, 2000) != HAL_OK) {
printf("ERROR: rbAmp not ready\r\n");
Error_Handler();
}
uint8_t ver = 0;
RbAmpIO_ReadU8(RB_ADDR, RB_REG_VERSION, &ver);
printf("rbAmp version: 0x%02X\r\n", ver);
/* USER CODE END 2 */
/* USER CODE BEGIN WHILE */
while (1) {
float u, i_, p, pf;
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_U_RMS, &u );
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_I0_RMS, &i_);
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_P0_REAL, &p );
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_PF0, &pf);
printf("U=%.1fV I=%.3fA P=%+.1fW PF=%+.3f\r\n", u, i_, p, pf);
HAL_Delay(1000);
/* USER CODE END WHILE */
}
}
Соглашение, принятое в этой главе: примеры 2–10 опускают окружающую функцию main(void) и вызовы инициализации CubeMX ради краткости, показывая только блоки /* USER CODE BEGIN 2 */ / /* USER CODE BEGIN WHILE */. Каждый фрагмент, начинающийся с RbAmpIO_Bind(&hi2c1);, является содержимым main(), а не кодом уровня файла.
Ожидаемый вывод в консоль:
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
...
Пример 2 — счётчик энергии за 60 секунд на OLED
Цель: счётчик Вт·ч, обновляемый раз в минуту, выводится на SSD1306 128×64, работающий на общей шине I²C с rbAmp. Аппаратура: STM32 + rbAmp + SSD1306 (0x3C) на той же шине. Учёт: однонаправленный (уровень BASIC). Библиотека: любой драйвер SSD1306 для STM32-HAL (например, afiskon/stm32-ssd1306).
#include
#include
#include "rbamp_io.h"
#include "ssd1306.h" /* your driver of choice */
#include "ssd1306_fonts.h"
extern I2C_HandleTypeDef hi2c1;
#define RB_ADDR 0x50U
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
ssd1306_Init();
RbAmpIO_WaitReady(RB_ADDR, 2000);
/* Primer snapshot — discard the snapshot it produces. */
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_prev_ms = HAL_GetTick();
double total_wh = 0.0;
/* USER CODE END 2 */
while (1) {
HAL_Delay(60UL * 1000UL);
/* 1) Final snapshot — closes the period [t_prev_ms .. now]. */
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = HAL_GetTick();
HAL_Delay(50); /* let firmware finalise snapshot */
/* 2) Check PERIOD_VALID. */
uint8_t valid = 0;
RbAmpIO_ReadU8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
printf("WARN: stale snapshot\r\n");
t_prev_ms = HAL_GetTick();
continue;
}
/* 3) Read time-averaged power, channel 0. */
float avg_p = 0.0f;
RbAmpIO_ReadFloatLE(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 on OLED. */
char line[24];
ssd1306_Fill(Black);
snprintf(line, sizeof(line), "P: %6.1f W", avg_p);
ssd1306_SetCursor(0, 0); ssd1306_WriteString(line, Font_7x10, White);
snprintf(line, sizeof(line), "dt: %6.1f s", dt_s);
ssd1306_SetCursor(0, 16); ssd1306_WriteString(line, Font_7x10, White);
snprintf(line, sizeof(line), "%.2f Wh", total_wh);
ssd1306_SetCursor(0, 32); ssd1306_WriteString(line, Font_11x18, White);
ssd1306_UpdateScreen();
printf("avg_P=%.1f E_period=%.3f total=%.3f\r\n", avg_p, e_wh, total_wh);
}
Драйвер SSD1306 и rbAmp используют hi2c1. Никогда не переинициализируйте периферию, просто используйте один и тот же дескриптор для обоих.
Пример 3 — Монитор нескольких модулей
Цель: опрашивать три модуля (основной ввод, водонагреватель, кондиционер) и выводить сумму. Аппаратура: STM32 + 3 × rbAmp UI1 по адресам 0x50, 0x51, 0x52.
#include
#include "rbamp_io.h"
extern I2C_HandleTypeDef hi2c1;
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]))
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
/* Bus probe — halt if any module is missing. */
for (size_t i = 0; i < N_MODULES; i++) {
if (!RbAmpIO_Probe(modules[i].addr)) {
printf("ERROR: %s at 0x%02X not found\r\n",
modules[i].label, modules[i].addr);
Error_Handler();
}
}
printf("All modules OK\r\n");
/* USER CODE END 2 */
while (1) {
float total_p = 0.0f;
printf("---\r\n");
/* Round-robin read. */
for (size_t i = 0; i < N_MODULES; i++) {
float u = 0.0f, p = 0.0f;
RbAmpIO_ReadFloatLE(modules[i].addr, RB_REG_U_RMS, &u);
RbAmpIO_ReadFloatLE(modules[i].addr, RB_REG_P0_REAL, &p);
printf("[%s] U=%.1f P=%+.1f W\r\n", modules[i].label, u, p);
total_p += p;
}
printf("TOTAL: %.1f W\r\n", total_p);
HAL_Delay(2000);
}
HAL_I2C_IsDeviceReady() (внутри RbAmpIO_Probe()) — аналог в STM32 пробы Wire.endTransmission() из Arduino.
Пример 4 — учёт энергии по отдельным приборам (UI3)
Цель: модуль UI3 с тремя токовыми клещами на трёх разных нагрузках одной фазы; независимые счётчики Вт·ч публикуются в MQTT каждую минуту. Аппаратура: STM32, 1 × rbAmp UI3 и Ethernet PHY (или мост W5500 / ESP32-AT). Заглушки сети: Net_Init() и Net_MqttPublish() (см. введение главы).
#include
#include "rbamp_io.h"
extern I2C_HandleTypeDef hi2c1;
extern HAL_StatusTypeDef Net_Init(void);
extern HAL_StatusTypeDef Net_MqttPublish(const char *topic,
const uint8_t *payload, uint32_t len,
uint8_t qos, uint8_t retain);
#define RB_ADDR 0x50U
static const char *CH_NAMES[3] = { "main", "heatpump", "lights" };
/**
* @brief Publish one channel's data to MQTT.
*/
static void mqtt_publish_channel(const char *ch_name, float avg_p, double e_wh) {
char topic[64], payload[64];
int t = snprintf(topic, sizeof(topic), "rbamp/%s/state", ch_name);
int n = snprintf(payload, sizeof(payload),
"{\"power\":%.1f,\"energy\":%.4f}", avg_p, e_wh);
(void)t;
Net_MqttPublish(topic, (const uint8_t*)payload, (uint32_t)n, /*qos*/ 0, /*retain*/ 0);
}
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
Net_Init();
RbAmpIO_WaitReady(RB_ADDR, 2000);
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD); /* primer */
uint32_t t_prev_ms = HAL_GetTick();
double total_wh[3] = { 0.0, 0.0, 0.0 };
/* USER CODE END 2 */
while (1) {
HAL_Delay(60UL * 1000UL);
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = HAL_GetTick();
HAL_Delay(50);
uint8_t valid = 0;
RbAmpIO_ReadU8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
t_prev_ms = HAL_GetTick();
continue;
}
/* PERIOD_AVG_P_W per channel: I0 at 0xDC, I1 at 0xC2, I2 at 0xC6. */
float avg_p[3];
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p[0]);
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_PERIOD_AVG_P1, &avg_p[1]);
RbAmpIO_ReadFloatLE(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\r\n",
CH_NAMES[ch], avg_p[ch], total_wh[ch]);
mqtt_publish_channel(CH_NAMES[ch], avg_p[ch], total_wh[ch]);
}
}
Пример 5 — двунаправленный учёт на стороне мастера для модуля BASIC
Цель: реализовать двунаправленный учёт на мастере, когда модуль работает с прошивкой BASIC. Спад DRDY вызывает прерывание EXTI; ISR выставляет флаг, основной цикл читает RT P_real и разделяет потребление и выдачу. Аппаратура: STM32 + rbAmp UI1; DRDY на PA0 (настроен как GPIO_EXTI0, спад, подтяжка вверх в CubeMX).
В CubeMX:
PA0→ режимGPIO_EXTI0, подтяжка вверх, триггер — спадающий фронтFalling edge- NVIC: включите
EXTI line 0 interrupt
stm32xxxx_it.c — генерируется CubeMX, только блок пользовательского кода:
extern volatile uint8_t g_data_ready; /* defined in main.c */
void EXTI0_IRQHandler(void) {
HAL_GPIO_EXTI_IRQHandler(GPIO_PIN_0);
}
void HAL_GPIO_EXTI_Callback(uint16_t GPIO_Pin) {
if (GPIO_Pin == GPIO_PIN_0) {
g_data_ready = 1; /* tiny ISR — set a flag and return */
}
}
Пользовательский код в main.c:
#include
#include
#include "rbamp_io.h"
extern I2C_HandleTypeDef hi2c1;
volatile uint8_t g_data_ready = 0;
#define RB_ADDR 0x50U
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
RbAmpIO_WaitReady(RB_ADDR, 2000);
double e_consumed_wh = 0.0;
double e_exported_wh = 0.0;
uint32_t t_last_sample_ms = HAL_GetTick();
uint32_t t_last_print_ms = t_last_sample_ms;
printf("Bidirectional accumulator started\r\n");
/* USER CODE END 2 */
while (1) {
if (!g_data_ready) {
continue; /* main loop also free to do other work */
}
__disable_irq();
g_data_ready = 0; /* clear flag atomically */
__enable_irq();
uint32_t t_now = HAL_GetTick();
/* Signed instantaneous P_real: + consume, − export. */
float p = 0.0f;
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_P0_REAL, &p);
float dt_s = (float)(t_now - t_last_sample_ms) / 1000.0f;
t_last_sample_ms = t_now;
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 - t_last_print_ms >= 5000) {
t_last_print_ms = t_now;
printf("P=%+8.1fW consumed=%.4f Wh exported=%.4f Wh net=%+.4f Wh\r\n",
p, e_consumed_wh, e_exported_wh,
e_consumed_wh - e_exported_wh);
}
}
Notes:
- Обработчик EXTI минимален — только выставляет
g_data_ready. Вся работа с I²C выполняется в основном цикле. - Квалификатор
volatileобязателен: компилятор должен перечитыватьg_data_readyиз RAM на каждой итерации цикла. - Короткое окно
__disable_irq() / __enable_irq()вокруг сброса предотвращает гонку с почти одновременным срабатыванием EXTI.
Пример 6 — баланс энергии дома
Цель: полная панель баланса энергии. Три модуля:
- rbAmp №1 на основном вводе (STD — двунаправленный)
- rbAmp #2 на выходе солнечного инвертора (BASIC подходит)
- rbAmp №3 UI3 на трёх мощных нагрузках (ТН, кондиционер, EV)
Мастер использует RbAmpIO_BroadcastLatch() для синхронных снимков и публикует сохраняемый баланс в MQTT каждую минуту.
#include
#include
#include "rbamp_io.h"
extern I2C_HandleTypeDef hi2c1;
extern HAL_StatusTypeDef Net_Init(void);
extern HAL_StatusTypeDef Net_MqttPublish(const char *topic,
const uint8_t *payload, uint32_t len,
uint8_t qos, uint8_t retain);
#define ADDR_MAINS 0x50U /* bidirectional (STD) */
#define ADDR_SOLAR 0x51U /* generation only */
#define ADDR_LOADS 0x52U /* UI3 */
/* PERIOD_AVG_P_NEG address for the mains module — see the SKU datasheet
* of the STD product. Set to 0xFF for BASIC modules. */
#define REG_PERIOD_AVG_P_NEG_MAINS 0xFFU
typedef struct {
double mains_in_wh;
double mains_out_wh;
double solar_total_wh;
double loads_wh[3];
} totals_t;
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
Net_Init();
RbAmpIO_WaitReady(ADDR_MAINS, 2000);
RbAmpIO_WaitReady(ADDR_SOLAR, 2000);
RbAmpIO_WaitReady(ADDR_LOADS, 2000);
static uint16_t gc_tick = 0;
if (RbAmpIO_BroadcastLatch(gc_tick++, 0) != HAL_OK) {
/* GC NACK — fall back to per-module sequential snapshot. */
RbAmpIO_WriteU8(ADDR_MAINS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
RbAmpIO_WriteU8(ADDR_SOLAR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
RbAmpIO_WriteU8(ADDR_LOADS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
}
uint32_t t_prev_ms = HAL_GetTick();
totals_t totals = {0};
printf("Home balance started\r\n");
/* USER CODE END 2 */
while (1) {
HAL_Delay(60UL * 1000UL);
/* Synchronous snapshot — all modules snapshot at the same instant. */
if (RbAmpIO_BroadcastLatch(gc_tick++, 0) != HAL_OK) {
/* GC NACK — fall back to per-module snapshot (skew ~1 ms/module). */
RbAmpIO_WriteU8(ADDR_MAINS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
RbAmpIO_WriteU8(ADDR_SOLAR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
RbAmpIO_WriteU8(ADDR_LOADS, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
}
uint32_t t_now_ms = HAL_GetTick();
HAL_Delay(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 (RbAmpIO_ReadU8(ADDR_MAINS, RB_REG_PERIOD_VALID, &valid) == HAL_OK
&& (valid & 0x01U)) {
float p_consume = 0.0f, p_export = 0.0f;
RbAmpIO_ReadFloatLE(ADDR_MAINS, RB_REG_PERIOD_AVG_P0, &p_consume);
if (REG_PERIOD_AVG_P_NEG_MAINS != 0xFFU) {
RbAmpIO_ReadFloatLE(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 (RbAmpIO_ReadU8(ADDR_SOLAR, RB_REG_PERIOD_VALID, &valid) == HAL_OK
&& (valid & 0x01U)) {
float p = 0.0f;
RbAmpIO_ReadFloatLE(ADDR_SOLAR, RB_REG_PERIOD_AVG_P0, &p);
totals.solar_total_wh += (double)p * dt_s / 3600.0;
}
/* ----- LOADS (UI3, three channels) ----- */
if (RbAmpIO_ReadU8(ADDR_LOADS, RB_REG_PERIOD_VALID, &valid) == HAL_OK
&& (valid & 0x01U)) {
float p[3] = {0};
RbAmpIO_ReadFloatLE(ADDR_LOADS, RB_REG_PERIOD_AVG_P0, &p[0]); /* I0 */
RbAmpIO_ReadFloatLE(ADDR_LOADS, RB_REG_PERIOD_AVG_P1, &p[1]); /* I1 */
RbAmpIO_ReadFloatLE(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\r\n", totals.mains_in_wh, totals.mains_out_wh);
printf("SOLAR gen=%.2f self-used=%.2f exported=%.2f\r\n",
totals.solar_total_wh, solar_self_used, totals.mains_out_wh);
printf("LOADS HP=%.2f AC=%.2f EV=%.2f\r\n",
totals.loads_wh[0], totals.loads_wh[1], totals.loads_wh[2]);
printf("TOTAL household consumed=%.2f Wh\r\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]);
Net_MqttPublish("home/energy/balance", (const uint8_t*)payload,
(uint32_t)n, /*qos*/ 1, /*retain*/ 1);
}
Пример 7 — обнаружение событий питания
Цель: по каждому фронту DRDY сравнивать мгновенную P с EMA и записывать значимые отклонения на SD-карту через SDIO + FATFS. Аппаратура: STM32F4 / L4 / H7 + rbAmp + SD-карта на интерфейсе SDIO (CubeMX: включить middleware FATFS и SDIO).
Настройка CubeMX:
- Режим
SDIO= широкая шина SD (4 бита) или SD (1 бит) [SD 4 bits Wide bus / SD 1 bit] - Включён промежуточный слой
FATFS, точка монтирования по умолчанию PA0=GPIO_EXTI0, спад, подтяжка вверх (DRDY)
#include
#include
#include
#include "rbamp_io.h"
#include "fatfs.h"
extern I2C_HandleTypeDef hi2c1;
extern FATFS SDFatFS;
extern char SDPath[4];
extern volatile uint8_t g_data_ready; /* set by EXTI0 callback */
#define RB_ADDR 0x50U
#define EMA_ALPHA 0.05f
#define EVENT_THRESHOLD_W 200.0f
static FIL s_logfile;
static bool s_log_open = false; /* guard — f_write on closed FIL is UB */
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
RbAmpIO_WaitReady(RB_ADDR, 2000);
/* Mount the SD card (CubeMX has already set up SDFatFS / SDPath).
* Both mount and open MUST succeed before we touch s_logfile in the loop. */
if (f_mount(&SDFatFS, SDPath, 1) == FR_OK) {
if (f_open(&s_logfile, "events.log",
FA_OPEN_APPEND | FA_WRITE) == FR_OK) {
s_log_open = true;
printf("SD mounted; logging to events.log\r\n");
} else {
printf("WARN: f_open(events.log) failed — file logging disabled\r\n");
}
} else {
printf("WARN: f_mount failed — file logging disabled\r\n");
}
/* Seed the EMA with current power so we do not log a spurious startup event. */
float p_ema = 0.0f;
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_P0_REAL, &p_ema);
printf("Event detector started\r\n");
/* USER CODE END 2 */
while (1) {
if (!g_data_ready) continue;
__disable_irq(); g_data_ready = 0; __enable_irq();
float p = 0.0f;
RbAmpIO_ReadFloatLE(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\r\n",
(unsigned long)HAL_GetTick(),
type, delta, p, p_ema);
printf("%s", line);
if (s_log_open) { /* never touch a closed FIL */
UINT bw;
f_write(&s_logfile, line, n, &bw);
f_sync(&s_logfile); /* flush to the card */
}
}
}
Пример 8 — Публикатор MQTT с автообнаружением Home Assistant
Цель: готовая интеграция с HA. STM32 публикует конфигурации автообнаружения HA (retained) и раз в минуту выдаёт состояние в JSON. Аппаратура: STM32 с Ethernet (H7 / F7 / F4 + LAN8742) или любой STM32 с мостом Ethernet.
#include
#include
#include "rbamp_io.h"
extern I2C_HandleTypeDef hi2c1;
extern HAL_StatusTypeDef Net_Init(void);
extern HAL_StatusTypeDef Net_MqttPublish(const char *topic,
const uint8_t *payload, uint32_t len,
uint8_t qos, uint8_t retain);
#define RB_ADDR 0x50U
#define DEVICE_ID "rbamp_main"
#define DEVICE_NAME "Mains rbAmp"
/**
* @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, "}");
Net_MqttPublish(topic, (const uint8_t*)payload, (uint32_t)n,
/*qos*/ 1, /*retain*/ 1);
}
/**
* @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");
}
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
Net_Init();
publish_discovery_all();
RbAmpIO_WaitReady(RB_ADDR, 2000);
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD); /* primer */
uint32_t t_prev_ms = HAL_GetTick();
double total_wh = 0.0;
/* USER CODE END 2 */
while (1) {
HAL_Delay(60UL * 1000UL);
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = HAL_GetTick();
HAL_Delay(50);
uint8_t valid = 0;
RbAmpIO_ReadU8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
t_prev_ms = HAL_GetTick();
continue;
}
float avg_p = 0.0f;
RbAmpIO_ReadFloatLE(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;
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_U_RMS, &u);
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_I0_RMS, &i_);
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_PF0, &pf);
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_Q0, &q);
RbAmpIO_ReadU8 (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);
char topic[64];
snprintf(topic, sizeof(topic), "rbamp/%s/state", DEVICE_ID);
Net_MqttPublish(topic, (const uint8_t*)payload, (uint32_t)n,
/*qos*/ 0, /*retain*/ 0);
printf("Published: %s\r\n", payload);
}
Пример 9 — Регистратор на батарее с режимом STANDBY
Цель: автономный логгер на улице или вне сети, который просыпается из STANDBY каждые 10 минут по будильнику RTC, делает снимок периода, публикует его через MQTT и снова уходит в STANDBY. Потребление определяется редкими пробуждениями: STANDBY у большинства семейств STM32 составляет единицы мкА. Аппаратура: STM32L4 / L5 (лучший вариант по энергопотреблению) или F4/F7 с урезанными возможностями. rbAmp можно питать через высокосторонний ключ на GPIO, чтобы он не потреблял ничего в STANDBY. Сохранение данных: регистры резервной области RTC RTC->BKP0R..BKPxR (зависят от семейства) переживают STANDBY и VBAT.
#include
#include
#include "rbamp_io.h"
/* CubeMX-generated: RTC + Wakeup timer + Backup registers in PWR */
extern I2C_HandleTypeDef hi2c1;
extern RTC_HandleTypeDef hrtc;
extern HAL_StatusTypeDef Net_Init(void);
extern HAL_StatusTypeDef Net_MqttPublish(const char *topic,
const uint8_t *payload, uint32_t len,
uint8_t qos, uint8_t retain);
#define RB_ADDR 0x50U
#define WAKE_SECONDS (10U * 60U) /* 10 minutes */
/* Backup-register layout (uint32 per slot). All survive STANDBY and VBAT.
* BKP0..1: total_wh (double, split into two uint32 halves)
* BKP2: wake_count
* BKP3: primer_done (0/1) + flags
* BKP4..5: t_prev_ms_ticks (uint64 split)
*/
#define BKP_TOTAL_WH_LO RTC_BKP_DR0
#define BKP_TOTAL_WH_HI RTC_BKP_DR1
#define BKP_WAKE_COUNT RTC_BKP_DR2
#define BKP_PRIMER RTC_BKP_DR3
#define BKP_T_PREV_LO RTC_BKP_DR4
#define BKP_T_PREV_HI RTC_BKP_DR5
static void bkp_load(double *total_wh, uint32_t *wakes,
uint8_t *primer, uint64_t *t_prev_ms) {
uint32_t lo = HAL_RTCEx_BKUPRead(&hrtc, BKP_TOTAL_WH_LO);
uint32_t hi = HAL_RTCEx_BKUPRead(&hrtc, BKP_TOTAL_WH_HI);
uint64_t bits = ((uint64_t)hi << 32) | lo;
memcpy(total_wh, &bits, sizeof(double));
*wakes = HAL_RTCEx_BKUPRead(&hrtc, BKP_WAKE_COUNT);
*primer = (uint8_t)HAL_RTCEx_BKUPRead(&hrtc, BKP_PRIMER);
uint32_t plo = HAL_RTCEx_BKUPRead(&hrtc, BKP_T_PREV_LO);
uint32_t phi = HAL_RTCEx_BKUPRead(&hrtc, BKP_T_PREV_HI);
*t_prev_ms = ((uint64_t)phi << 32) | plo;
}
static void bkp_save(double total_wh, uint32_t wakes,
uint8_t primer, uint64_t t_prev_ms) {
HAL_PWR_EnableBkUpAccess();
uint64_t bits;
memcpy(&bits, &total_wh, sizeof(double));
HAL_RTCEx_BKUPWrite(&hrtc, BKP_TOTAL_WH_LO, (uint32_t)(bits & 0xFFFFFFFFU));
HAL_RTCEx_BKUPWrite(&hrtc, BKP_TOTAL_WH_HI, (uint32_t)(bits >> 32));
HAL_RTCEx_BKUPWrite(&hrtc, BKP_WAKE_COUNT, wakes);
HAL_RTCEx_BKUPWrite(&hrtc, BKP_PRIMER, primer);
HAL_RTCEx_BKUPWrite(&hrtc, BKP_T_PREV_LO, (uint32_t)(t_prev_ms & 0xFFFFFFFFU));
HAL_RTCEx_BKUPWrite(&hrtc, BKP_T_PREV_HI, (uint32_t)(t_prev_ms >> 32));
}
/**
* @brief Arm the RTC wake-up timer and enter STANDBY.
* @details On the next wake (or RESET via NRST), execution restarts at the
* reset vector — exactly like a fresh boot.
*/
static void enter_standby(uint32_t seconds) {
HAL_RTCEx_SetWakeUpTimer_IT(&hrtc, seconds,
RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
HAL_PWR_EnterSTANDBYMode();
/* never returns */
}
/* USER CODE BEGIN 2 */
double total_wh;
uint32_t wake_count;
uint8_t primer_done;
uint64_t t_prev_unused; /* reserved BKP slot; see note below */
bkp_load(&total_wh, &wake_count, &primer_done, &t_prev_unused);
(void)t_prev_unused; /* HAL_GetTick() resets after STANDBY — */
/* the dt is approximated by WAKE_SECONDS */
/* instead. Slot kept for forward compat; */
/* upgrade to HAL_RTC_GetTime/Date if you */
/* need true wall-clock dt across sleeps. */
wake_count++;
RbAmpIO_Bind(&hi2c1);
if (RbAmpIO_WaitReady(RB_ADDR, 2000) != HAL_OK) {
bkp_save(total_wh, wake_count, primer_done, /*t_prev=*/0);
enter_standby(WAKE_SECONDS);
}
/* First wake-up after a cold boot: primer snapshot only. */
if (!primer_done) {
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
primer_done = 1;
bkp_save(total_wh, wake_count, primer_done, /*t_prev=*/0);
printf("Primer done — entering STANDBY\r\n");
enter_standby(WAKE_SECONDS);
}
/* Subsequent wake-ups: close the period and read its average power. */
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
HAL_Delay(50);
uint8_t valid = 0;
RbAmpIO_ReadU8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
bkp_save(total_wh, wake_count, primer_done, /*t_prev=*/0);
enter_standby(WAKE_SECONDS);
}
float avg_p = 0.0f;
RbAmpIO_ReadFloatLE(RB_ADDR, RB_REG_PERIOD_AVG_P0, &avg_p);
/* dt approximation: STANDBY resets HAL_GetTick(), and the WAKE_SECONDS-driven
* RTC wake-timer is the wall-clock interval to single-digit-% accuracy with
* an LSE crystal. For tighter accounting, read HAL_RTC_GetTime/Date before
* STANDBY and compute dt against the stored epoch. */
float dt_s = (float)WAKE_SECONDS;
total_wh += (double)avg_p * dt_s / 3600.0;
/* Publish via Wi-Fi / Ethernet (graceful fallback). */
if (Net_Init() == HAL_OK) {
char payload[256];
int n = snprintf(payload, sizeof(payload),
"{\"wake\":%lu,\"dt_s\":%.1f,\"avg_p\":%.1f,\"energy_wh\":%.3f}",
(unsigned long)wake_count, dt_s, avg_p, total_wh);
Net_MqttPublish("rbamp/remote/state",
(const uint8_t*)payload, (uint32_t)n,
/*qos*/ 1, /*retain*/ 1);
printf("Published: %s\r\n", payload);
}
bkp_save(total_wh, wake_count, primer_done, /*t_prev=*/0);
enter_standby(WAKE_SECONDS);
/* USER CODE END 2 */
Notes:
- Регистры резервного питания (
BKP_DR*) переживают STANDBY и VBAT, но не полное отключение питания без резервной батареи VBAT. Для абсолютной сохранности периодически дублируйте сумму во внутреннюю flash. HAL_GetTick()сбрасывается при каждом входе в STANDBY → если приложению нужен абсолютный интервал по реальному времени, используйте календарь RTC (HAL_RTC_GetTime/Date).- RTC в CubeMX должен работать от LSE (кварц 32.768 кГц) для точного долговременного отсчёта времени. Дрейф LSI при температуре может достигать 5–10 %.
- Для STM32F1 / F4 перечисление источника тактирования пробуждения может немного отличаться; значения
RTC_WAKEUPCLOCK_*смотрите в справочнике HAL для вашего семейства.
Пример 10 — Тарификация по времени суток (TOU) с настенными часами через SNTP
Цель: учёт энергии по тарифному расписанию с разделением по времени суток. STM32 поддерживает реальное время по SNTP (LwIP lwip/apps/sntp.h), относит каждый закрытый период к нужной тарифной группе, сбрасывает суточные итоги в полночь и публикует данные с метками времени ISO. Аппаратура: STM32 с Ethernet (STM32H7 / F7 / F4 + LAN8742) или любой STM32 с Ethernet-мостом.
#include
#include
#include
#include "rbamp_io.h"
#include "lwip/apps/sntp.h"
extern I2C_HandleTypeDef hi2c1;
extern RTC_HandleTypeDef hrtc;
extern HAL_StatusTypeDef Net_Init(void);
extern HAL_StatusTypeDef Net_MqttPublish(const char *topic,
const uint8_t *payload, uint32_t len,
uint8_t qos, uint8_t retain);
#define RB_ADDR 0x50U
#define TZ_OFFSET_HOURS 2 /* CEST = UTC+2; recompute on roll-over for DST */
#define PEAK_START_HOUR 8
#define PEAK_END_HOUR 22
/* IMPORTANT: LwIP's SNTP populates the system clock via the SNTP_SET_SYSTEM_TIME
* macro that you MUST define in lwipopts.h. Without it, time(NULL) stays at 0
* forever and sntp_sync() will always time out. Minimal hook:
*
* #include
* #define SNTP_SET_SYSTEM_TIME(sec) \
* do { struct timeval tv = { (time_t)(sec), 0 }; \
* settimeofday(&tv, NULL); } while (0)
*
* Also requires _gettimeofday() / time() to be retargeted to the same source
* (newlib's default works once settimeofday is wired). */
typedef struct {
double peak_wh;
double off_peak_wh;
int day_of_year; /* tm_yday */
} day_totals_t;
typedef struct {
double peak_wh;
double 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 system clock looks plausible (year > 2023).
*/
static HAL_StatusTypeDef 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();
uint32_t deadline = HAL_GetTick() + timeout_ms;
while (HAL_GetTick() < deadline) {
time_t now = time(NULL);
struct tm lt;
gmtime_r(&now, <);
if (lt.tm_year + 1900 >= 2023) {
printf("SNTP sync: %04d-%02d-%02d %02d:%02d:%02d UTC\r\n",
lt.tm_year + 1900, lt.tm_mon + 1, lt.tm_mday,
lt.tm_hour, lt.tm_min, lt.tm_sec);
return HAL_OK;
}
HAL_Delay(500);
}
return HAL_TIMEOUT;
}
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) {
/* For schedules that cross midnight, swap to
* return (hour >= PEAK_START_HOUR) || (hour < PEAK_END_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();
const char sign = (TZ_OFFSET_HOURS >= 0) ? '+' : '-';
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, (TZ_OFFSET_HOURS < 0) ? -TZ_OFFSET_HOURS : TZ_OFFSET_HOURS);
}
/**
* @brief Add one period's energy to the right tariff bucket and roll over 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);
Net_MqttPublish("rbamp/tou/day_close",
(const uint8_t*)payload, (uint32_t)n,
/*qos*/ 1, /*retain*/ 1);
printf("Day closed: %s\r\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;
}
}
/* USER CODE BEGIN 2 */
RbAmpIO_Bind(&hi2c1);
Net_Init();
sntp_sync(15000);
RbAmpIO_WaitReady(RB_ADDR, 2000);
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD); /* primer */
uint32_t t_prev_ms = HAL_GetTick();
printf("TOU started: peak %02d:00..%02d:00 local\r\n",
PEAK_START_HOUR, PEAK_END_HOUR);
/* USER CODE END 2 */
while (1) {
HAL_Delay(60UL * 1000UL);
RbAmpIO_WriteU8(RB_ADDR, RB_REG_COMMAND, RB_CMD_LATCH_PERIOD);
uint32_t t_now_ms = HAL_GetTick();
HAL_Delay(50);
uint8_t valid = 0;
RbAmpIO_ReadU8(RB_ADDR, RB_REG_PERIOD_VALID, &valid);
if ((valid & 0x01U) == 0) {
t_prev_ms = HAL_GetTick();
continue;
}
float avg_p = 0.0f;
RbAmpIO_ReadFloatLE(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;
/* Guard against fresh boot before SNTP succeeds. */
struct tm lt = local_time();
if (lt.tm_year + 1900 < 2023) {
printf("WARN: clock not yet synced, retrying SNTP\r\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);
Net_MqttPublish("rbamp/tou/state", (const uint8_t*)payload,
(uint32_t)n, /*qos*/ 0, /*retain*/ 0);
printf("%s\r\n", payload);
}
Notes:
- Клиент SNTP от LwIP заполняет источник
time(NULL)стандартной библиотеки C через хуки LwIPSYS_ARCH_RAND/sys_now; на портах STM32gmtime_r()затем возвращает корректные значения. - Для полной поддержки летнего времени храните смещение TZ в небольшой таблице и пересчитывайте его при ежедневном переходе либо передавайте время через
tzset()со строкой POSIX TZ, если ваша сборка newlib её поддерживает (большинство поддерживают). - Для двунаправленного учёта STD вызовите
accumulate()дважды: один раз для стороны потребления и один раз для стороны выдачи, и публикуйте пиковую и внепиковую корзины с обеих сторон.
Сравнение примеров
| # | Сложность | Выход | MQTT | DRDY | Несколько модулей | Двунаправленный | Сохранение | Сценарий использования |
|---|---|---|---|---|---|---|---|---|
| 1 | минимальный | UART printf | — | — | — | — | — | проверка работоспособности |
| 2 | низкий | OLED | — | — | — | — | RAM | счётчик в корпусе |
| 3 | низкий | UART printf | — | — | да (3) | — | — | домашний мониторинг |
| 4 | средний | — | да | — | — | — | RAM | по каждому прибору в HA |
| 5 | средний | UART printf | — | да | — | да (мастер) | RAM | солнечный дом на уровне BASIC |
| 6 | высокий | — | да | — | да (3) | да | RAM | полный баланс дома |
| 7 | средний | UART + SD (FATFS) | — | да | — | — | SD-карта | обнаружение событий |
| 8 | средний | — | да (+disco) | — | — | необязательно | RAM + MQTT | HA Auto-discovery |
| 9 | средний | — | да | — | — | — | Регистры резервного питания RTC (BKP) | регистратор для улицы / автономной установки |
| 10 | средний | UART printf | да | — | — | необязательно | RAM + MQTT | TOU: пиковый / внепиковый тариф с SNTP |
Рекомендации
- Всегда проверяйте коды возврата HAL. Транзакции I²C могут временно сбоить на длинных шинах, поэтому надёжный код должен повторять попытку, а не игнорировать сбой. При необходимости оборачивайте вызовы
RbAmpIO_*повторами. - Держите ISR минимальными. Обработчики EXTI / SysTick / завершения DMA должны выставлять флаг
volatile uint8_tи возвращаться. Вся работа с I²C / printf относится к основному циклу. - Один драйвер I2C HAL на периферию. И rbAmp, и OLED используют
hi2c1. Никогда не переинициализируйте периферию, просто используйте общий дескриптор. - Для главных часов используйте
HAL_GetTick(). Точность до миллисекунды, монотонно, сохраняется при большинстве операций HAL. PERIOD_VALID(0x07) нужно проверять после каждогоCMD_LATCH_PERIOD. Устаревшие снимки появляются, если мастер опрашивает быстрее, чем прошивка интегрирует данные.- Подождите ≥ 50 мс после снимка, прежде чем читать
0xDC..0xEF: прошивка завершает снимок в своём основном цикле. - Используйте
HAL_I2C_IsDeviceReady()для сканирования шины — аналог STM32 для проверкиendTransmission()в Arduino. - Для батарейных приложений входите в STOP или STANDBY между отсчётами и взводите таймер пробуждения RTC. STANDBY перезапускает выполнение с вектора сброса — для состояния, которое должно сохраниться, используйте регистры резервного питания.
- Сохраняйте суммы Вт·ч во внутреннюю flash, если они должны пережить полное отключение питания (извлечение батареи без VBAT). Регистры резервного питания RTC сохраняются только при наличии VBAT или VDD.
- Поддержка float в
printfтребует-u _printf_floatво флагах линкера CubeIDE (сборка newlib-nano).
Что дальше
После изучения этих десяти примеров:
- Для разработки ESP32 в стиле Arduino см. arduino-examples.md (исходный текст).
- Для MicroPython / CircuitPython см. micropython-examples.md (исходный текст).
- Для нативного ESP-IDF см. esp-idf-examples.md (исходный текст).
- Для Raspberry Pi Pico C SDK см. pico-sdk-examples.md.
- Для интеграции с ESPHome (декларативный YAML) см.
tools/esphome-rbamp/docs/en/. - Формальная спецификация регистров I²C, используемая здесь, находится в api-reference.md.