STM32LowPower + RTC Woes. Help greatly appreciated.

[Alan01252]

I've been scratching my head for a couple of days as to why I can't get the STM32LowPower/RTC library to work reliably on our hardware.

Taking this slightly modified version of the examples

#include <Arduino.h>
#include "STM32LowPower.h"
#include <ArduinoLog.h>
#include "CustomPins.h"
#include "STM32RTC.h"

Logging logger;
// HardwareSerial stlinkSerial(PIN_VCP_RX, PIN_VCP_TX);
HardwareSerial stlinkSerial(rx_pin2debug, tx_pin2debug);

STM32LowPower lowPower;

static const char *mydate = __DATE__;
static const char *mytime = __TIME__;
static byte seconds = 0;
static byte minutes = 0;
static byte hours = 0;

static byte weekDay = 1;
static byte day = 0;
static byte month = 0;
static byte year = 0;

static STM32RTC::Hour_Format hourFormat = STM32RTC::HOUR_24;
static STM32RTC::AM_PM period = STM32RTC::AM;

STM32RTC &rtc = STM32RTC::getInstance();

volatile int alarmMatch_counter = 0;

static uint8_t conv2d(const char *p)
{
    uint8_t v = 0;
    if ('0' <= *p && *p <= '9')
        v = *p - '0';
    return 10 * v + *++p - '0';
}

void print2digits(int number)
{
    if (number < 10)
    {
        stlinkSerial.print("0"); // print a 0 before if the number is < than 10
    }
    stlinkSerial.print(number);
}

void alarmMatch(void *data)
{
    // This function will be called once on device wakeup
    // You can do some little operations here (like changing variables which will be used in the loop)
    // Remember to avoid calling delay() and long running functions since this functions executes in interrupt context
    uint32_t epoc;
    uint32_t epoc_ms;
    uint32_t sec = 0;
    uint32_t _millis = 1000;

    if (data != NULL)
    {
        _millis = *(uint32_t *)data;
    }

    sec = _millis / 1000;
#ifdef STM32F1xx
    // Minimum is 1 second
    if (sec == 0)
    {
        sec = 1;
    }
    epoc = rtc.getEpoch(&epoc_ms);
#else
    _millis = _millis % 1000;
    epoc = rtc.getEpoch(&epoc_ms);

    // Update epoch_ms - might need to add a second to epoch
    epoc_ms += _millis;
    if (epoc_ms >= 1000)
    {
        sec++;
        epoc_ms -= 1000;
    }
#endif
    alarmMatch_counter++;
    rtc.setAlarmEpoch(epoc + sec, STM32RTC::MATCH_SS, epoc_ms);
}

// sample input: date = "Dec 26 2009", time = "12:34:56"
void initDateTime(const char *date, const char *time)
{
    year = conv2d(date + 9);
    // Jan Feb Mar Apr May Jun Jul Aug Sep Oct Nov Dec
    switch (date[0])
    {
    case 'J':
        month = (date[1] == 'a') ? 1 : ((date[2] == 'n') ? 6 : 7);
        break;
    case 'F':
        month = 2;
        break;
    case 'A':
        month = date[2] == 'r' ? 4 : 8;
        break;
    case 'M':
        month = date[2] == 'r' ? 3 : 5;
        break;
    case 'S':
        month = 9;
        break;
    case 'O':
        month = 10;
        break;
    case 'N':
        month = 11;
        break;
    case 'D':
        month = 12;
        break;
    }
    day = conv2d(date + 4);
    hours = conv2d(time);
    if (hourFormat == rtc.HOUR_12)
    {
        period = hours >= 12 ? rtc.PM : rtc.AM;
        hours = hours >= 13 ? hours - 12 : (hours < 1 ? hours + 12 : hours);
    }
    minutes = conv2d(time + 3);
    seconds = conv2d(time + 6);
}

// t: number of print
// d: delay between each print
// a: display alarm
void printDateTime(uint32_t t, uint32_t d, bool a)
{
    for (uint32_t i = 0; i < t; i++)
    {
        // Print date...
        print2digits(rtc.getMonth());
        stlinkSerial.print("/");
        print2digits(rtc.getDay());
        stlinkSerial.print("/");
        print2digits(rtc.getYear());
        stlinkSerial.print("\t");

        // ...and time
        print2digits(rtc.getHours(&period));
        stlinkSerial.print(":");
        print2digits(rtc.getMinutes());
        stlinkSerial.print(":");
        print2digits(rtc.getSeconds());
        if (hourFormat == rtc.HOUR_12)
        {
            stlinkSerial.print(period == rtc.AM ? " AM" : " PM");
        }
        if (a)
        {
            // Print day...
            stlinkSerial.print("\t");
            print2digits(rtc.getAlarmDay());
            stlinkSerial.print("\t");

            // ...and time
            print2digits(rtc.getAlarmHours(&period));
            stlinkSerial.print(":");
            print2digits(rtc.getAlarmMinutes());
            stlinkSerial.print(":");
            print2digits(rtc.getAlarmSeconds());
            if (hourFormat == rtc.HOUR_12)
            {
                stlinkSerial.print(period == rtc.AM ? " AM" : " PM");
            }
        }
        stlinkSerial.println();
        delay(d);
    }
}

void setup()
{
    // put your setup code here, to run once:
    stlinkSerial.begin(115200);
    while (!stlinkSerial)
    {
        ;
    }
    stlinkSerial.println("*******************************************");
    stlinkSerial.println("Started");
    stlinkSerial.flush();

    LowPower.begin();
    rtc.setClockSource(STM32RTC::LSE_CLOCK);
    rtc.begin();
    rtc.setAlarmEpoch(rtc.getEpoch() + 10);
}

void loop()
{
    stlinkSerial.println("Waking up!");
    printDateTime(1, 0, false);

    if (!rtc.isTimeSet())
    {
        stlinkSerial.println("Time did not persist.");

        initDateTime(mydate, mytime);
        rtc.setTime(hours, minutes, seconds);
        rtc.setDate(weekDay, day, month, year);
        printDateTime(1, 0, false);
    }
    else
    {
        stlinkSerial.println("Time persisted!");
        printDateTime(1, 0, false);
    }
    stlinkSerial.print("Alarm match: ");
    stlinkSerial.println(alarmMatch_counter);
    stlinkSerial.flush();
    stlinkSerial.println("Sleeping!");
    delay(100);
    LowPower.deepSleep();
    stlinkSerial.begin(115200);
    while (!stlinkSerial)
    {
    }
}

In my logs I see

12:13:49:729 -> *******************************************
12:13:49:750 -> Started
12:13:49:750 -> Waking up!
12:13:49:750 -> 12/18/24        12:13:43
12:13:49:750 -> Time persisted!
12:13:49:750 -> 12/18/24        12:13:43
12:13:49:750 -> Alarm match: 0
12:13:49:750 -> Sleeping!
12:13:58:977 -> Waking up!
12:13:58:977 -> 12/18/24        12:13:53
12:13:58:977 -> Time persisted!
12:13:58:977 -> 12/18/24        12:13:53
12:13:58:977 -> Alarm match: 0
12:13:58:977 -> Sleeping!

Which is so weird, as obviously the code is waking up, but the callback isn't being fired at all. So then I tried going low level and just writing almost exactly the same HAL code as the libraries

#include <Arduino.h>
#include "Version.h"
#include "CustomPins.h"
#include <Notecard.h>

RTC_HandleTypeDef hrtc;

HardwareSerial stlinkSerial(rx_pin2debug, tx_pin2debug);
HardwareSerial notecardSerial(rx_pin2note, tx_pin2note);

volatile bool alarmTriggered = false;

void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
{
    // stlinkSerial.println("[INFO] Alarm A Interrupt Triggered!");
    alarmTriggered = true; // Set the flag to indicate alarm fired
}

extern "C" void RTC_IRQHandler(void)
{
    HAL_RTC_AlarmIRQHandler(&hrtc);
}

void LowPower_stop()
{
    __disable_irq();
    HAL_PWR_EnterSTOPMode(PWR_LOWPOWERREGULATOR_ON, PWR_STOPENTRY_WFI);
    configIPClock();
    SystemClock_Config();
    __enable_irq();
    HAL_Delay(10);
}

void resetRTCToZero()
{
    __HAL_RCC_PWR_CLK_ENABLE();
    HAL_PWR_EnableBkUpAccess();

    // Initialize RTC peripheral
    hrtc.Instance = RTC;
    hrtc.Init.HourFormat = RTC_HOURFORMAT_24;
    hrtc.Init.AsynchPrediv = 127;
    hrtc.Init.SynchPrediv = 255;
    hrtc.Init.OutPut = RTC_OUTPUT_DISABLE;
    hrtc.Init.OutPutPolarity = RTC_OUTPUT_POLARITY_HIGH;
    hrtc.Init.OutPutType = RTC_OUTPUT_TYPE_OPENDRAIN;

    RTC_TimeTypeDef sTime;
    sTime.Hours = 0;
    sTime.Minutes = 0;
    sTime.Seconds = 0;
    sTime.TimeFormat = RTC_HOURFORMAT_24; // Default to 24-hour mode
    sTime.SubSeconds = 0;
    sTime.SecondFraction = 0;
    sTime.DayLightSaving = RTC_DAYLIGHTSAVING_NONE;
    sTime.StoreOperation = RTC_STOREOPERATION_RESET;

    RTC_DateTypeDef sDate;
    sDate.WeekDay = RTC_WEEKDAY_SATURDAY; // Default to Saturday
    sDate.Month = 1;                      // January
    sDate.Date = 1;                       // 1st day
    sDate.Year = 0;                       // Year 2000

    // Unlock RTC write protection
    __HAL_RTC_WRITEPROTECTION_DISABLE(&hrtc);

    __HAL_RCC_LSE_CONFIG(RCC_LSE_ON);
    while (__HAL_RCC_GET_FLAG(RCC_FLAG_LSERDY) == RESET)
    {
        stlinkSerial.println("[DEBUG] Waiting for LSE to stabilize...");
        delay(100);
    }
    stlinkSerial.println("[INFO] LSE Clock Stable");

    __HAL_RCC_RTC_CONFIG(RCC_RTCCLKSOURCE_LSE);
    __HAL_RCC_RTC_ENABLE();

    if (HAL_RTC_Init(&hrtc) != HAL_OK)
    {
        stlinkSerial.println("[ERROR] RTC Initialization Failed!");
        while (1)
            ;
    }

    // Set the time and date to zero
    if (HAL_RTC_SetTime(&hrtc, &sTime, RTC_FORMAT_BIN) != HAL_OK)
    {
        stlinkSerial.println("[ERROR] Failed to reset RTC time!");
    }
    if (HAL_RTC_SetDate(&hrtc, &sDate, RTC_FORMAT_BIN) != HAL_OK)
    {
        stlinkSerial.println("[ERROR] Failed to reset RTC date!");
    }

    // Lock RTC write protection
    __HAL_RTC_WRITEPROTECTION_ENABLE(&hrtc);

    stlinkSerial.println("[INFO] RTC Reset to 0 (1970-01-01 00:00:00).");
}

void setupRTCAlarm()
{
    // Clear Alarm A flag and interrupt
    __HAL_RTC_ALARM_CLEAR_FLAG(&hrtc, RTC_FLAG_ALRAF);
    HAL_NVIC_SetPriority(RTC_IRQn, 0, 0);
    HAL_NVIC_EnableIRQ(RTC_IRQn);

    __HAL_RTC_ALARMA_DISABLE(&hrtc);
    __HAL_RTC_ALARMA_ENABLE(&hrtc);

    // Get current time
    RTC_TimeTypeDef currentTime;
    if (HAL_RTC_GetTime(&hrtc, &currentTime, RTC_FORMAT_BIN) == HAL_OK)
    {
        stlinkSerial.print("[INFO] Current Time: ");
        if (currentTime.Hours < 10)
            stlinkSerial.print("0");
        stlinkSerial.print(currentTime.Hours);
        stlinkSerial.print(":");
        if (currentTime.Minutes < 10)
            stlinkSerial.print("0");
        stlinkSerial.print(currentTime.Minutes);
        stlinkSerial.print(":");
        if (currentTime.Seconds < 10)
            stlinkSerial.print("0");
        stlinkSerial.println(currentTime.Seconds);

        RTC_AlarmTypeDef sAlarm;
        sAlarm.Alarm = RTC_ALARM_A;
        sAlarm.AlarmMask = RTC_ALARMMASK_NONE;
        sAlarm.AlarmSubSecondMask = RTC_ALARMSUBSECONDMASK_NONE;

        uint8_t newSeconds = currentTime.Seconds + 10;
        uint8_t carryMinutes = newSeconds / 60;
        newSeconds %= 60;
        uint8_t newMinutes = currentTime.Minutes + carryMinutes;
        uint8_t carryHours = newMinutes / 60;
        newMinutes %= 60;
        uint8_t newHours = 0;
        newHours = (currentTime.Hours + carryHours) % 24;

        // WTF THIS IS WEIRD NEEDED ELSE ALL BREAKS
        auto newNewHours = 0;
        if (newHours == currentTime.Hours)
        {
            delay(1);
            newNewHours = newHours;
        }

        sAlarm.AlarmTime.Seconds = newSeconds;
        sAlarm.AlarmTime.Minutes = newMinutes;
        sAlarm.AlarmTime.Hours = newNewHours;
        sAlarm.AlarmDateWeekDaySel = RTC_ALARMDATEWEEKDAYSEL_DATE;
        sAlarm.AlarmDateWeekDay = 1;

        // Set Alarm A with interrupt
        if (HAL_RTC_SetAlarm_IT(&hrtc, &sAlarm, RTC_FORMAT_BIN) != HAL_OK)
        {
            stlinkSerial.println("[ERROR] RTC Alarm A Setup Failed!");
            while (1)
                ;
        }

        stlinkSerial.print("[INFO] Configured an alarm at time: ");
        if (sAlarm.AlarmTime.Hours < 10)
            stlinkSerial.print("0");
        stlinkSerial.print(sAlarm.AlarmTime.Hours);
        stlinkSerial.print(":");
        if (sAlarm.AlarmTime.Minutes < 10)
            stlinkSerial.print("0");
        stlinkSerial.print(sAlarm.AlarmTime.Minutes);
        stlinkSerial.print(":");
        if (sAlarm.AlarmTime.Seconds < 10)
            stlinkSerial.print("0");
        stlinkSerial.println(sAlarm.AlarmTime.Seconds);
    }
    else
    {
        stlinkSerial.println("[ERROR] Failed to get current time!");
        while (1)
            ;
    }
}

bool attnISRTriggered = false;     // Default to true for first interrupt
bool ignoreFutureRequests = false; // Default to true for first interrupt

void attnISR()
{
    stlinkSerial.println("Got interrupt");
    attnISRTriggered = true;
}

Notecard notecard;

void setup()
{
    stlinkSerial.begin(115200);
    while (!stlinkSerial)
    {
        ;
    }

    stlinkSerial.println("***********************************************************");
    stlinkSerial.println("[INFO] Program Starting...");

    notecardSerial.begin(9600);
    notecard.begin(notecardSerial);
    notecard.setDebugOutputStream(stlinkSerial);

    pinMode(ATTN_INPUT_PIN, INPUT);
    attachInterrupt(digitalPinToInterrupt(ATTN_INPUT_PIN), attnISR, RISING);

    // Configure RTC and Alarm A
    resetRTCToZero();
    setupRTCAlarm();
    attnISRTriggered = false;
}

bool forceTimeout = false;

void loop()
{
    stlinkSerial.println("[INFO] Entering Main Loop...");
    // Check if the alarm was triggered
    if (alarmTriggered)
    {
        stlinkSerial.println("[DEBUG] Alarm Trigger Flag Detected via RTC!");
        alarmTriggered = false; // Clear the flag

        // In real life this would probably die
        stlinkSerial.println("[DEBUG] Disarming all the attn requests notecard");
        ignoreFutureRequests = true;
        setupRTCAlarm();
    }


    stlinkSerial.println("[INFO] Going to sleep...");
    delay(100);
    LowPower_stop(); // Should wake up via notecard
    stlinkSerial.begin(115200);
    while (!stlinkSerial)
    {
    }
}

Which gives me

12:32:09:755 -> [INFO] Program Starting...
12:32:10:669 -> [INFO] LSE Clock Stable
12:32:10:669 -> [INFO] RTC Reset to 0 (1970-01-01 00:00:00).
12:32:10:669 -> [INFO] Current Time: 00:00:00
12:32:10:669 -> [INFO] Configured an alarm at time: 00:00:10
12:32:10:669 -> [INFO] Entering Main Loop...
12:32:10:669 -> [INFO] Going to sleep...
12:32:21:506 -> [INFO] Entering Main Loop...
12:32:21:506 -> [DEBUG] Alarm Trigger Flag Detected via RTC!
12:32:21:506 -> [DEBUG] Disarming all the attn requests notecard
12:32:21:506 -> [INFO] Current Time: 00:00:10
12:32:21:506 -> [INFO] Configured an alarm at time: 00:00:20
12:32:21:506 -> [INFO] Going to sleep...
12:32:31:651 -> [INFO] Entering Main Loop...
12:32:31:651 -> [DEBUG] Alarm Trigger Flag Detected via RTC!
12:32:31:651 -> [DEBUG] Disarming all the attn requests notecard
12:32:31:651 -> [INFO] Current Time: 00:00:20
12:32:31:651 -> [INFO] Configured an alarm at time: 00:00:30
12:32:31:651 -> [INFO] Going to sleep...
12:32:41:651 -> [INFO] Entering Main Loop...
12:32:41:651 -> [DEBUG] Alarm Trigger Flag Detected via RTC!
12:32:41:651 -> [DEBUG] Disarming all the attn requests notecard
12:32:41:651 -> [INFO] Current Time: 00:00:30
12:32:41:651 -> [INFO] Configured an alarm at time: 00:00:40
12:32:41:651 -> [INFO] Going to sleep...
12:32:51:650 -> [INFO] Entering Main Loop...

So my questions:

1. Is there something i'm doing fundamentally stupid in the first example?
2. The second example also weirdly seems to have a "works on my machine" issue whereas for a collegue it doesn't even if I send over the exact same binary... Is there something more fundamental I might be missing there too?

At this point any help would be incredibly appreciated, even if it's "if I was you I would do x,y,z next" because I'm not entirely sure what x,y,z could be now :)

[fpistm]

Hi @Alan01252
Could you be more precise, what is your hardware? Environment and version? options selected? ....
Moreover it seems you used some libraries and/or headers... and not the same btw both example?
Did you try the default example first.

[Alan01252]

Hi @fpistm

Sorry for not being clear!

We have a custom board with a STM32F030xC as the stm32 in use.

https://github.com/stm32duino/STM32LowPower.git with tags/1.2.5
https://github.com/stm32duino/STM32RTC.git with tags/1.4.0"

In terms of the "default" example, I tried that. It seems to work, sort of, in that it sleeps, but the callback never fires, which is why I then attempted to use the timed example above.

Here's the hal from the generated config

WEAK void SystemClock_Config(void)
{
 RCC_OscInitTypeDef RCC_OscInitStruct = {0};
 RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};
 RCC_PeriphCLKInitTypeDef PeriphClkInit = {0};

 /** Configure LSE Drive Capability
 */
 HAL_PWR_EnableBkUpAccess();
 __HAL_RCC_LSEDRIVE_CONFIG(RCC_LSEDRIVE_HIGH);

 /** Initializes the RCC Oscillators according to the specified parameters
 * in the RCC_OscInitTypeDef structure.
 */
 RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSI14|RCC_OSCILLATORTYPE_HSE
                             |RCC_OSCILLATORTYPE_LSE;
 RCC_OscInitStruct.HSEState = RCC_HSE_ON;
 RCC_OscInitStruct.LSEState = RCC_LSE_ON;
 RCC_OscInitStruct.HSI14State = RCC_HSI14_ON;
 RCC_OscInitStruct.HSI14CalibrationValue = 16;
 RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
 RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
 RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL6;
 RCC_OscInitStruct.PLL.PREDIV = RCC_PREDIV_DIV1;
 if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
 {
   Error_Handler();
 }

 /** Initializes the CPU, AHB and APB buses clocks
 */
 RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                             |RCC_CLOCKTYPE_PCLK1;
 RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
 RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
 RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV1;

 if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_1) != HAL_OK)
 {
   Error_Handler();
 }
 PeriphClkInit.PeriphClockSelection = RCC_PERIPHCLK_USART1|RCC_PERIPHCLK_I2C1
                             |RCC_PERIPHCLK_RTC;
 PeriphClkInit.Usart1ClockSelection = RCC_USART1CLKSOURCE_SYSCLK;
 PeriphClkInit.I2c1ClockSelection = RCC_I2C1CLKSOURCE_SYSCLK;
 PeriphClkInit.RTCClockSelection = RCC_RTCCLKSOURCE_LSE;
 if (HAL_RCCEx_PeriphCLKConfig(&PeriphClkInit) != HAL_OK)
 {
   Error_Handler();
 }
}

I'll get my collegue to post here too :) You just helped him re-instate his account so thank you for that too!

[Alan01252]

He's just provided me this image.

[fpistm]

Try with Arduino IDE 2. Sloeber is not supported here and knows to not build the same way.

[Alan01252]

Hi @fpistm.

Sorry I think I provided the wrong screen shot when providing the options.

My builds/output above are from cmake pipeline.

That being said, I've got my colleague to try again with Arduino ide.

[MangyDogUK]

Hi fpistm
I agree slober is a pita, but its the only half decent ide I've been able to get working for a while...
I've built the example code above that Alan posted in Aduino IDE 2.
And the it still isnt working.

[Alan01252]

Gosh this was stupid sorry for the time waste, if you notice in the first code the interrupt isn't actually set...

[fpistm]

Guess it is rtc.attachInterrupt missing.

[Alan01252]

Yes.... :(