rbAmp
DE
Shop
Docs
Aktualisiert

14 · STM32-HAL-Beispiele

Dieses Kapitel ist das STM32-Gegenstück zu arduino-examples.md, micropython-examples.md und esp-idf-examples.md: dieselben zehn Szenarien, portiert auf STM32 HAL (von CubeMX generiertes C) mit optionalem FreeRTOS / CMSIS-OS2.

Hinweis

Diese Beispiele sprechen rbAmp direkt über die rohe I²C-Registerschnittstelle an. Sie sind für produktive Embedded-Firmware auf dem STM32 gedacht — direkte Kontrolle über das HAL, vorhersagbarer RAM- und Flash-Bedarf, Integration mit LwIP, FATFS, FreeRTOS und der CubeMX-HAL-Generierung.

Konfigurieren Sie die I²C-Peripherie in CubeMX auf 50 kHz (empfohlen — siehe Kapitel 11 §2.2) und umschließen Sie Registerlesevorgänge mit einem kurzen Wiederholungsversuch.

Unterstützte Familien und Toolchain

Familie Validiert I²C-Peripherie Hinweise
STM32F1-Familie ✓ I2C1, I2C2 Verbreitetes DIY-Ziel
STM32F4 (Nucleo-F411, Discovery) ✓ I2C1..3 Hoher Takt, viel RAM
STM32L4 / L4+ ✓ I2C1..4 Stromsparend, RTC-Backup-Register, STOP / STANDBY
STM32G0 / G4 ✓ I2C1..3 Moderne Peripherie
STM32H7 (Nucleo-H743) ✓ I2C1..4 Integrierter Ethernet-PHY → MQTT direkt über LwIP

Toolchain: CubeMX 6.x + CubeIDE oder ein Makefile-Projekt (arm-none-eabi-gcc). Die Beispiele setzen eine HAL-Version voraus, die zu Ihrem CubeMX-generierten Projekt passt. Die neue I²C-HAL-Signatur (HAL_I2C_Mem_Read/Write) wird von jeder aktuellen Familie unterstützt.

Hinweis zur Vernetzung

Die meisten STM32-Chips haben kein integriertes WLAN. Die MQTT-abhängigen Beispiele (4, 6, 8, 9) setzen einen der folgenden Netzwerkwege voraus:

  • Ethernet — STM32F4 / F7 / H7-Boards mit integriertem PHY (LAN8742, DP83848), die LwIP und eine kleine MQTT-Bibliothek ausführen (Paho Embedded C, MQTT-C oder ein HAL-freundlicher Fork). Das ist der unkomplizierteste Weg.
  • W5500-SPI-Ethernet — für STM32F1 / L4 / G4 (ohne integrierte MAC). Verwendet die WIZnet-ioLibrary.
  • ESP32-AT über UART — ein ESP-AT-Modul dient als WLAN-Bridge. AT-Befehle werden aus der Hauptschleife des STM32 gesendet.

Die Beispiele zeigen die rbAmp-Logik im vollen Detail; die Netzwerkinitialisierung ist hinter zwei Stub-Funktionen abstrahiert, die Sie in Ihrem Projekt implementieren:

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

Referenzimplementierungen für jeden Netzwerkweg liegen außerhalb des Umfangs dieses Kapitels; wählen Sie den, der zu Ihrer Hardware passt, und ersetzen Sie die Stubs.

Projektaufbau

Struktur des CubeMX-generierten Projekts:

Text
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-Pinbelegung, die in allen Beispielen verwendet wird, sofern nicht anders angegeben:

  • I2C1: SCL = PB6, SDA = PB7 (typische Standardwerte für STM32F1 / Nucleo-F411)
  • UART1: TX = PA9, RX = PA10 — für printf-Debugging
  • EXTI: PA0 = DRDY (fallende Flanke, Pull-up)
  • I²C-Takt: 100 kHz

Inhaltsverzeichnis der Beispiele

# Titel Schwierigkeit Ausgang MQTT DRDY Mehrere Module Bidirektional Anwendungsfall
1 Schnelles Lesen minimal UART-printf — — — — Schnelltest
2 60-Sekunden-Energiezähler auf OLED niedrig SSD1306 — — — — Gekapselter Wh-Zähler
3 Monitor für mehrere Module niedrig UART-printf — — ja (3) — Gesamthausüberwachung
4 Energiemonitor pro Gerät (UI3) mittel — ja — — — Unterzählung in HA
5 Bidirektional auf dem Master für ein BASIC-Modul mittel UART-printf — ja — ja (Master) Solar-Haushalt auf BASIC-Stufe
6 Gesamte Hausbilanz hoch — ja — ja (3) ja Gesamte Hausbilanz
7 Erkennung von Netzereignissen mittel UART + SD — ja — — Ereignisprotokoll der Geräte
8 MQTT-Publisher mit HA-Auto-Discovery mittel — ja (+disco) — — optional Sofort einsatzbereite HA-Integration
9 Batteriebetriebener Logger mit STANDBY-Modus mittel — ja — — — Messung für den Außen- bzw. Inselbetrieb
10 Zeitabhängiger Tarif (TOU) mit SNTP-Wanduhr mittel UART-printf ja — — optional Energiemessung mit Spitzen- / Nebenzeit-Tarif

Gemeinsame Hilfsfunktionen (rbamp_io.h / rbamp_io.c)

Legen Sie diese Dateien in Core/Inc und Core/Src Ihres CubeMX-Projekts ab. Um Platz zu sparen, wird die Zeile #include "rbamp_io.h" in jedem Beispiel unten weggelassen.

rbamp_io.h

C
/**
 * @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

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

Alle Beispiele geben über printf() per UART aus. Fügen Sie in Ihre main.c den üblichen Umleitungshelfer hinzu (funktioniert mit newlib-nano):

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

Bei CubeIDE-Projekten mit deaktiviertem Semihosting und ausgewähltem newlib-nano benötigt printf("%.1f", ...) -u _printf_float in den Linker-Flags.


Beispiel 1 — Schnelles Lesen (minimal)

Ziel: U, I, P, PF einmal pro Sekunde über UART ausgeben. Hardware: beliebiger STM32 + ein rbAmp UI1 + USB-UART für die Konsole am Host.

In CubeMX:

  • I2C1 aktivieren (Standard, 100 kHz) an PB6/PB7
  • USART1 aktivieren (115200 8N1) an PA9/PA10
  • alles andere Standard

Benutzercode in main.c — die unten gezeigten Blöcke /* USER CODE BEGIN 2 */ und /* USER CODE BEGIN WHILE */ stehen innerhalb der von CubeMX generierten Funktion main(), zwischen deren Initialisierungsaufrufen und der while(1)-Schleife. Fügen Sie sie nicht auf Dateiebene ein — sie müssen innerhalb von main() stehen.

Referenzform (das umgebende int main(void) { … } wird von CubeMX generiert und hier nur zur Orientierung gezeigt):

C
/* 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 */
    }
}
Hinweis

Konvention in diesem Kapitel: Die Beispiele 2–10 lassen das umgebende main(void) und die CubeMX-Initialisierungsaufrufe der Kürze halber weg und zeigen nur die Blöcke /* USER CODE BEGIN 2 */ / /* USER CODE BEGIN WHILE */. Jeder Ausschnitt, der mit RbAmpIO_Bind(&hi2c1); beginnt, ist der Inhalt von main(), nicht Code auf Dateiebene.

Erwartete Konsolenausgabe:

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

Beispiel 2 — 60-Sekunden-Energiezähler auf OLED

Ziel: Wh-Zähler einmal pro Minute aktualisiert, angezeigt auf einem 128×64-SSD1306, der den I²C-Bus des rbAmp teilt. Hardware: STM32 + rbAmp + SSD1306 (0x3C) am selben Bus. Bilanzierung: unidirektional (BASIC-Stufe). Bibliothek: beliebiger SSD1306-Treiber für STM32-HAL (z. B. afiskon/stm32-ssd1306).

C
#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);
}
Hinweis

Der SSD1306-Treiber und rbAmp teilen sich hi2c1 — initialisieren Sie die Peripherie nicht neu, sondern verwenden Sie für beide dasselbe Handle.


Beispiel 3 — Überwachung mehrerer Module

Ziel: drei Module abfragen (Hauptzuleitung, Warmwasserbereiter, Klimaanlage) und die Summe ausgeben. Hardware: STM32 + 3 × rbAmp UI1 bei 0x50, 0x51, 0x52.

C
#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() (innerhalb von RbAmpIO_Probe()) ist das STM32-Gegenstück zur Arduino-Prüfung über Wire.endTransmission().


Beispiel 4 — Energiemonitor pro Gerät (UI3)

Ziel: ein UI3-Modul mit drei Stromzangen an drei verschiedenen Lasten auf derselben Phase; unabhängige Wh-Zähler, die jede Minute an MQTT gesendet werden. Hardware: STM32 + 1 × rbAmp UI3 + Ethernet-PHY (oder W5500- bzw. ESP32-AT-Bridge). Netzwerk-Stubs: Net_Init() und Net_MqttPublish() (siehe Kapiteleinleitung).

C
#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]);
    }
}

Beispiel 5 — Bidirektional auf dem Master für ein BASIC-Modul

Ziel: bidirektionale Bilanzierung auf dem Master, während das Modul BASIC-Firmware hat. Die fallende DRDY-Flanke löst einen EXTI-Interrupt aus; die ISR setzt ein Flag, und die Hauptschleife liest das RT-P_real und trennt Verbrauch und Einspeisung. Hardware: STM32 + rbAmp UI1; DRDY an PA0 angeschlossen (in CubeMX als GPIO_EXTI0, fallend, Pull-up konfiguriert).

In CubeMX:

  • PA0 → Modus GPIO_EXTI0, Pull-up, Auslöser: fallende Flanke [Falling edge]
  • NVIC: EXTI line 0 interrupt aktivieren

stm32xxxx_it.c — von CubeMX generiert, nur der Benutzercode-Block:

C
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 */
    }
}

Benutzercode in main.c:

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:

  • Die EXTI-ISR ist minimal – sie setzt nur g_data_ready. Die gesamte I²C-Arbeit läuft in der Hauptschleife.
  • Das Attribut volatile ist unverzichtbar: Der Compiler muss g_data_ready bei jedem Schleifendurchlauf aus dem RAM neu laden.
  • Ein kurzes Fenster __disable_irq() / __enable_irq() um das Löschen verhindert ein Wettrennen mit einem nahezu gleichzeitigen EXTI-Auslösen.

Beispiel 6 — Energiebilanz des Hauses

Ziel: vollständiges Bilanz-Dashboard. Drei Module:

  • rbAmp #1 am Hauptnetz (STD — bidirektional)
  • rbAmp #2 am Ausgang des Solarwechselrichters (BASIC ok)
  • rbAmp #3 UI3 an drei großen Lasten (Wärmepumpe, Klimaanlage, E-Auto)

Der Master verwendet RbAmpIO_BroadcastLatch() für synchrone Snapshots und veröffentlicht jede Minute einen beibehaltenen Saldo an MQTT.

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

Beispiel 7 — Erkennung von Netzereignissen

Ziel: bei jeder DRDY-Flanke die momentane Leistung P mit einem EMA vergleichen und signifikante Abweichungen über SDIO + FATFS auf eine SD-Karte schreiben. Hardware: STM32F4 / L4 / H7 + rbAmp + SD-Karte an der SDIO-Schnittstelle (CubeMX: Middleware FATFS + SDIO aktivieren).

CubeMX-Einrichtung:

  • Modus SDIO: „4-Bit-Breitbus“ [SD 4 bits Wide bus] oder „1 Bit“ [SD 1 bit]
  • FATFS-Middleware aktiviert, Mount-Punkt Standard
  • PA0 = GPIO_EXTI0, fallend, Pull-up (DRDY)
C
#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 */
        }
    }
}

Beispiel 8 — MQTT-Publisher mit Home-Assistant-Auto-Discovery

Ziel: sofort einsatzbereite HA-Integration. Der STM32 veröffentlicht HA-Auto-Discovery-Konfigurationen (retained) und sendet jede Minute einen JSON-Status. Hardware: STM32 mit Ethernet (H7 / F7 / F4 + LAN8742) oder beliebiger STM32 + Ethernet-Brücke.

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

Beispiel 9 — Batteriebetriebener Logger mit STANDBY-Modus

Ziel: ein Logger im Außen- oder Inselbetrieb, der per RTC-Alarm alle 10 Minuten aus STANDBY aufwacht, eine Periode aufnimmt, sie über MQTT veröffentlicht und dann wieder in STANDBY geht. Der Stromverbrauch wird vom seltenen Aufwachen bestimmt — STANDBY liegt bei den meisten STM32-Familien im einstelligen µA-Bereich. Hardware: STM32L4 / L5 (beste Energieeffizienz) oder F4/F7 mit reduziertem Funktionsumfang. rbAmp kann über einen High-Side-Schalter an einem GPIO versorgt werden, sodass es im STANDBY nichts verbraucht. Persistenz: RTC-Backup-Register RTC->BKP0R..BKPxR (je nach Familie unterschiedlich) überstehen STANDBY und VBAT.

C
#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:

  • Backup-Register (BKP_DR*) überstehen STANDBY und VBAT, aber nicht einen vollständigen Stromausfall ohne Backup-Batterie an VBAT. Für absolute Persistenz spiegeln Sie die Summe regelmäßig in den internen Flash.
  • HAL_GetTick() wird bei jedem STANDBY zurückgesetzt → verwenden Sie für eine absolute Wanduhr-Zeitdifferenz (dt) den RTC-Kalender (HAL_RTC_GetTime/Date), falls Ihre Anwendung das benötigt.
  • Die CubeMX-RTC muss mit LSE (32.768-kHz-Quarz) konfiguriert werden, um eine genaue Langzeitzeitmessung zu erhalten; der LSI-Drift kann temperaturabhängig 5–10 % betragen.
  • Bei STM32F1 / F4 kann die Aufzählung der Weckquelle der Uhr leicht abweichen; prüfen Sie für die Werte RTC_WAKEUPCLOCK_* die HAL-Referenz Ihrer Familie.

Beispiel 10 — Zeitabhängiger Tarif (TOU) mit SNTP-Wanduhr

Ziel: Energie nach einem Zeittarif abrechnen. Der STM32 führt über SNTP eine echte Uhrzeit (LwIP lwip/apps/sntp.h), ordnet jeden abgeschlossenen Zeitraum dem passenden Tarifblock zu, setzt die Tagessummen um Mitternacht zurück und veröffentlicht Payloads mit ISO-Zeitstempeln. Hardware: STM32 mit Ethernet (STM32H7 / F7 / F4 + LAN8742) oder ein beliebiger STM32 mit Ethernet-Bridge.

C
#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:

  • Der SNTP-Client von LwIP füllt die Quelle für time(NULL) der C-Bibliothek über die LwIP-Hooks SYS_ARCH_RAND / sys_now; auf STM32-Portierungen liefert gmtime_r() danach sinnvolle Werte.
  • Für die volle Sommerzeitbehandlung speichern Sie den TZ-Offset in einer kleinen Tabelle und berechnen ihn beim täglichen Tageswechsel neu, oder leiten die Zeit über tzset() mit einem POSIX-TZ-String weiter, falls Ihr newlib-Build dies unterstützt (die meisten tun es).
  • Für bidirektionale STD-Messung rufen Sie accumulate() zweimal auf — einmal für den Verbrauch und einmal für die Einspeisung — und veröffentlichen Sie beide Tarifblöcke, Spitzen- und Nebenzeit.

Vergleich der Beispiele

# Komplexität Ausgang MQTT DRDY Mehrere Module Bidirektional Persistenz Anwendungsfall
1 minimal UART-printf — — — — — Rauchtest
2 niedrig OLED — — — — RAM Zählerkasten
3 niedrig UART-printf — — ja (3) — — Heimüberwachung
4 mittel — ja — — — RAM pro Gerät in HA
5 mittel UART-printf — ja — ja (Master) RAM Solar-Haushalt auf BASIC-Stufe
6 hoch — ja — ja (3) ja RAM gesamte Hausbilanz
7 mittel UART + SD (FATFS) — ja — — SD-Karte Ereigniserkennung
8 mittel — ja (+disco) — — optional RAM + MQTT HA-Auto-Discovery
9 mittel — ja — — — RTC-BKP-Register Logger für den Außen- bzw. Inselbetrieb
10 mittel UART-printf ja — — optional RAM + MQTT TOU Spitzen-/Nebenzeit mit SNTP

Bewährte Verfahren

  • Prüfen Sie immer die HAL-Rückgabecodes. I²C-Transaktionen können auf langen Bussen vorübergehend fehlschlagen; produktiver Code sollte sie wiederholen, statt sie zu ignorieren. Umschließen Sie RbAmpIO_*-Aufrufe bei Bedarf mit Wiederholungen.
  • Halten Sie ISRs klein. EXTI-, SysTick- und DMA-Complete-Callbacks sollten ein volatile uint8_t-Flag setzen und zurückkehren. Alle I²C- und printf-Arbeiten gehören in die Hauptschleife.
  • Ein HAL-I2C-Treiber pro Peripherie. rbAmp und OLED teilen sich hi2c1 — initialisieren Sie die Peripherie nicht neu, sondern verwenden Sie nur das gemeinsame Handle.
  • Verwenden Sie HAL_GetTick() für den Master-Takt. Millisekunden-Genauigkeit, monoton, übersteht die meisten HAL-Operationen.
  • PERIOD_VALID (0x07) muss nach jedem CMD_LATCH_PERIOD geprüft werden. Veraltete Snapshots entstehen, wenn der Master schneller abfragt, als die Firmware integriert.
  • Warten Sie ≥ 50 ms nach einem Snapshot, bevor Sie 0xDC..0xEF lesen — die Firmware schließt den Snapshot in ihrer Hauptschleife ab.
  • Verwenden Sie HAL_I2C_IsDeviceReady() für Bus-Scans — das STM32-Gegenstück zum Arduino-Ping über endTransmission().
  • Für Akkubetrieb wechseln Sie zwischen den Messungen in STOP oder STANDBY und aktivieren den RTC-Weckzeitgeber. STANDBY startet die Ausführung am Reset-Vektor neu — verwenden Sie Backup-Register für Zustände, die erhalten bleiben müssen.
  • Wh-Summen im internen Flash speichern, wenn sie einen vollständigen Stromausfall überstehen sollen (Akku-Entnahme ohne VBAT). RTC-Backup-Register überleben nur, solange VBAT oder VDD anliegt.
  • Unterstützung für printf-Fließkommazahlen erfordert -u _printf_float in den CubeIDE-Linker-Flags (newlib-nano-Build).

Wie geht es weiter

Nachdem Sie diese zehn Beispiele durchgearbeitet haben: