Advice on using RTC and WUTR on STM32F446 as a versatile timer and how to reset RTC->SSR?

[arnold_w]

I am working with the STM32F446 microcontroller and I would like to create a versatile timer function using the RTC:

typedef void (*timerCallback_t)();

void scheduleOneTimerEvent(uint32_t timeoutMs, timerCallback_t timerCallback);

I am considering using one WUTR interrupt for this and I would let ck_spre provide clock for the WUTR. Since I only care about WUTR (I won't use the RTC as a regular calendar clock at all) I will have varying frequencies on ck_spre, depending on what timeoutMs is set to (and for large timeoutMs I will need several "hidden" interrupts that don't call the timerCallback). Does anybody foresee any problems with this or have any general suggestions for improvement? Also, to keep things simple, I was planning to reset time to default whenever scheduleOneTimerEvent is called, but I read in the reference manual that the subsecond register (RTC->SSR) is read only, so how would I go about to reset it?

[arnold_w]

I guess I can use a Backup Domain Reset (bit BDRST in the RCC->BDCR register) to reset the subsecond register (RTC->SSR), right?

[arnold_w]

I did like this instead:

typedef enum {
 _0_ms = 256,
 _11_7_ms = 253,
 _15_6_ms = 252,
 .
 .
 .
 _984_4_ms = 4,
 _988_3_ms = 3,
 _992_2_ms = 2,
 _996_1_ms = 1,
} subSeconds_e;
 
#define DISABLE_ALL_INTS_IF_NECESSARY() uint32_t old_primask; \
 old_primask = __get_PRIMASK(); \
 __disable_irq()
 
/// Enable all interrupts if they were enable
#define ENABLE_ALL_INTS_IF_THEY_WERE_ENABLED() if (!old_primask) \
 { \
 __enable_irq(); \
 }
 
#define HAL_RTC_WRITEPROTECTION_ENABLE() do { \
 RTC->WPR = 0xFF; \
 } while(0)
 
#define HAL_RTC_WRITEPROTECTION_DISABLE() do { \
 RTC->WPR = 0xCA; \
 RTC->WPR = 0x53; \
 } while(0)
 
#define HAL_RTC_ALARM_GET_IT(__INTERRUPT__) ((((RTC->ISR) & ((__INTERRUPT__) >> 4)) != 0) ? 1 : 0)
 
#define HAL_RTC_ALARM_CLEAR_FLAG(__FLAG__) do { \
 RTC->ISR = (~((__FLAG__) | RTC_ISR_INIT) | (RTC->ISR & RTC_ISR_INIT)); \
 } while(0)
 
static EventCallback_t RTCinterruptCallback_ = (EventCallback_t)NULL;
static uint32_t arg1_, arg2_;
static volatile Bool_t isRTCintScheduled_ = FALSE;
 
static HAL_StatusTypeDef RTC_EnterInitMode_() {
 if ((RTC->ISR & RTC_ISR_INITF) == 0) { // Check if the Initialization mode is set
 RTC->ISR = (uint32_t)RTC_INIT_MASK; // Set the Initialization mode
 uint32_t startTime = GET_TIMESTAMP_IN_CLK_CYCLES(); // Get tick
 
 // Wait until RTC is in INIT state and if Time out is reached exit
 while ((RTC->ISR & RTC_ISR_INITF) == 0) {
 if (RTC_TIMEOUT_VALUE < (clkCyclesToMilliseconds(getClkCyclesElapsed(startTime)))) {
 return HAL_TIMEOUT;
 }
 }
 }
 return HAL_OK;
}
 
Bool_t isRTCintScheduled() {
 return isRTCintScheduled_;
}
 
HAL_StatusTypeDef scheduleRTCinterrupt(uint8_t delaySecondsMax59, subSeconds_e delaySubSeconds, EventCallback_t RTCinterruptCallback, uint32_t arg1, uint32_t arg2) {
 DISABLE_ALL_INTS_IF_NECESSARY();
 if ((delaySecondsMax59 == 0) && (delaySubSeconds == _0_ms)) {
 issueDummyInt(RTCinterruptCallback, arg1, arg2);
 ENABLE_ALL_INTS_IF_THEY_WERE_ENABLED();
 return HAL_OK;
 }
 isRTCintScheduled_ = TRUE;
 uint32_t RCC_BDCR = RCC->BDCR; // Make a copy of RCC->BDCR register
 RCC->BDCR |= ((uint32_t)RCC_BDCR_BDRST); // Hold Backup Domain in reset (will reset all RTC registers)
 RCC->BDCR &= ~((uint32_t)RCC_BDCR_BDRST); // Release Backup Domain from reset
 RCC->BDCR = RCC_BDCR; // Restore RCC->BDCR register values that were lost during the reset
 __HAL_RCC_RTC_ENABLE();
 HAL_RTC_WRITEPROTECTION_DISABLE(); // Disable the write protection for RTC registers
 if (RTC_EnterInitMode_() != HAL_OK) { // Set Initialization mode
 HAL_RTC_WRITEPROTECTION_ENABLE(); // Enable the write protection for RTC registers
 return HAL_ERROR;
 }
 
 RTC->CR = RTC_CR_BYPSHAD; // Set RTC_CR register
 RTC->PRER = 255; // Configure the RTC PRER, lower bits (7-bit asynchronous prescalar)
 RTC->PRER |= (((uint32_t)127) << 16); // Configure the RTC PRER, upper bits (16-bit synchronous prescalar)
 
#define ALARM_TIME_HOURS (0)
#define ALARM_TIME_MINUTES (0)
#define ALARM_DATE_WEEKDAY (0x1)
 
 RTC->ALRMAR = ((((uint32_t)ALARM_TIME_HOURS ) << 16) |
 (((uint32_t)ALARM_TIME_MINUTES ) << 8 ) |
 (((uint32_t)delaySecondsMax59 ) ) |
 (((uint32_t)RTC_HOURFORMAT12_AM) << 16 ) |
 (((uint32_t)ALARM_DATE_WEEKDAY ) << 24) |
 (((uint32_t)RTC_ALARMDATEWEEKDAYSEL_DATE) ) |
 (((uint32_t)RTC_ALARMMASK_NONE )));
 RTC->ALRMASSR = ((uint32_t)delaySubSeconds) | RTC_ALARMSUBSECONDMASK_NONE; // Configure the Alarm A Sub Second register
 RTC->ISR &= ~((uint32_t)RTC_ISR_INIT); // Exit Initialization mode
 
 uint32_t startTime = GET_TIMESTAMP_IN_CLK_CYCLES();
 while ((RTC->ISR & RTC_FLAG_ALRAWF) == 0) { // Wait until RTC ALRAWF flag is set and if Time out is reached exit
 if (RTC_TIMEOUT_VALUE < (clkCyclesToMilliseconds(getClkCyclesElapsed(startTime)))) {
 HAL_RTC_WRITEPROTECTION_ENABLE(); // Enable the write protection for RTC registers
 return HAL_TIMEOUT;
 }
 }
 
 RTC->CR |= RTC_IT_ALRA | RTC_CR_ALRAE; // Configure the Alarm interrupt and the Alarm state: Enable Alarm
 HAL_RTC_WRITEPROTECTION_ENABLE(); // Enable the write protection for RTC registers
 RTCinterruptCallback_ = RTCinterruptCallback;
 arg1_ = arg1;
 arg2_ = arg2;
 EXTI->RTSR |= RTC_EXTI_LINE_ALARM_EVENT; // Configure rising edge on alarm EXTI interrupt
 EXTI->IMR |= RTC_EXTI_LINE_ALARM_EVENT; // RTC Alarm Interrupt Configuration: EXTI configuration
 HAL_NVIC_EnableIRQ(RTC_Alarm_IRQn); // Enable RTC alarm interrupt in NVIC
 ENABLE_ALL_INTS_IF_THEY_WERE_ENABLED();
 return HAL_OK;
}
 
void cancelRTCandStopRTC() {
 DISABLE_ALL_INTS_IF_NECESSARY();
 RTCinterruptCallback_ = NULL;
 HAL_NVIC_DisableIRQ(RTC_Alarm_IRQn); // Enable RTC alarm interrupt in NVIC
 RTC->CR &= ~((uint32_t)(RTC_IT_ALRA | RTC_CR_ALRAE)); // Configure the Alarm interrupt and the Alarm state: Disable Alarm
 EXTI->RTSR &= ~RTC_EXTI_LINE_ALARM_EVENT; // Configure rising edge on alarm EXTI interrupt
 EXTI->IMR &= ~RTC_EXTI_LINE_ALARM_EVENT; // RTC Alarm Interrupt Configuration: EXTI configuration
 HAL_RTC_ALARM_CLEAR_FLAG(RTC_FLAG_ALRAF); // Clear the Alarm interrupt pending bit
 isRTCintScheduled_ = FALSE;
 ENABLE_ALL_INTS_IF_THEY_WERE_ENABLED();
}
 
void RTC_Alarm_IRQHandler(void) {
 EXTI->PR = RTC_EXTI_LINE_ALARM_EVENT; // Clear the EXTI's line Flag for RTC Alarm
 if (HAL_RTC_ALARM_GET_IT(RTC_IT_ALRA)) {
 if (RTC->CR & RTC_IT_ALRA) { // Get the status of the Interrupt
 HAL_RTC_ALARM_CLEAR_FLAG(RTC_FLAG_ALRAF); // Clear the Alarm interrupt pending bit
 EventCallback_t RTCinterruptCallbackCopy = RTCinterruptCallback_;
 RTCinterruptCallback_ = NULL;
 isRTCintScheduled_ = FALSE;
 if (RTCinterruptCallbackCopy != NULL) {
 (void)RTCinterruptCallbackCopy(arg1_, arg2_);
 }
 }
 }
}