support a seconds interrupt based on the RTC feature

The stm32F1 device has specific one-second interrupt.
For stm32 devices that do not have a seconds interrupt
the RTC WakeUp is programmed to interrupt the system
on a one-second period.
The HAL_RTCEx_WakeUpTimerEventCallback is called instead
keeping the same naming RTCSecondsIrqCallback.
Some stm32F0 mcus do not support the wakeUp feature.

Signed-off-by: Francois Ramu <[email protected]>

Author: FRASTM

src/rtc.c

@@ -58,6 +58,7 @@ extern "C" {
 static RTC_HandleTypeDef RtcHandle = {0};
 static voidCallbackPtr RTCUserCallback = NULL;
 static void *callbackUserData = NULL;
+static voidCallbackPtr RTCSecondsIrqCallback = NULL;
 
 static sourceClock_t clkSrc = LSI_CLOCK;
 static uint8_t HSEDiv = 0;
@@ -388,6 +389,7 @@ void RTC_DeInit(void)
   HAL_RTC_DeInit(&RtcHandle);
   RTCUserCallback = NULL;
   callbackUserData = NULL;
+  RTCSecondsIrqCallback = NULL;
 }
 
 /**
@@ -731,6 +733,107 @@ void RTC_Alarm_IRQHandler(void)
   HAL_RTC_AlarmIRQHandler(&RtcHandle);
 }
 
+#ifdef ONESECOND_IRQn
+/**
+  * @brief Attach Seconds interrupt callback.
+  * @note  stm32F1 has a second interrupt capability
+  *        other MCUs map this on their WakeUp feature
+  * @param func: pointer to the callback
+  * @retval None
+  */
+void attachSecondsIrqCallback(voidCallbackPtr func)
+{
+#if defined(STM32F1xx)
+  /* callback called on Seconds interrupt */
+  RTCSecondsIrqCallback = func;
+
+  HAL_RTCEx_SetSecond_IT(&RtcHandle);
+  __HAL_RTC_SECOND_CLEAR_FLAG(&RtcHandle, RTC_FLAG_SEC);
+#else
+  /* callback called on wakeUp interrupt for One-Second purpose*/
+  RTCSecondsIrqCallback = func;
+
+  /* for MCUs using the wakeup feature : irq each second */
+#if defined(RTC_WUTR_WUTOCLR)
+  HAL_RTCEx_SetWakeUpTimer_IT(&RtcHandle, 0, RTC_WAKEUPCLOCK_CK_SPRE_16BITS, 0);
+#else
+  HAL_RTCEx_SetWakeUpTimer_IT(&RtcHandle, 0, RTC_WAKEUPCLOCK_CK_SPRE_16BITS);
+#endif /* RTC_WUTR_WUTOCLR */
+
+#endif /* STM32F1xx */
+  /* enable the IRQ that will trig the one-second interrupt */
+  HAL_NVIC_EnableIRQ(ONESECOND_IRQn);
+}
+
+/**
+  * @brief Detach Seconds interrupt callback.
+  * @param None
+  * @retval None
+  */
+void detachSecondsIrqCallback(void)
+{
+#if defined(STM32F1xx)
+  HAL_RTCEx_DeactivateSecond(&RtcHandle);
+#else
+  /* for MCUs using the wakeup feature : do not deactivate the WakeUp
+     as it might be used for another reason than the One-Second purpose */
+  // HAL_RTCEx_DeactivateWakeUpTimer(&RtcHandle);
+#endif /* STM32F1xx */
+  RTCSecondsIrqCallback = NULL;
+}
+
+#if defined(STM32F1xx)
+/**
+  * @brief  Seconds interrupt callback.
+  * @param  hrtc RTC handle
+  * @retval None
+  */
+void HAL_RTCEx_RTCEventCallback(RTC_HandleTypeDef *hrtc)
+{
+  UNUSED(hrtc);
+
+  if (RTCSecondsIrqCallback != NULL) {
+    RTCSecondsIrqCallback(NULL);
+  }
+}
+
+/**
+  * @brief  This function handles RTC Seconds interrupt request.
+  * @param  None
+  * @retval None
+  */
+void RTC_IRQHandler(void)
+{
+  HAL_RTCEx_RTCIRQHandler(&RtcHandle);
+}
+
+#else
+/**
+  * @brief  WakeUp event mapping the Seconds interrupt callback.
+  * @param  hrtc RTC handle
+  * @retval None
+  */
+void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)
+{
+  UNUSED(hrtc);
+
+  if (RTCSecondsIrqCallback != NULL) {
+    RTCSecondsIrqCallback(NULL);
+  }
+}
+
+/**
+  * @brief  This function handles RTC Seconds through wakeup interrupt request.
+  * @param  None
+  * @retval None
+  */
+void RTC_WKUP_IRQHandler(void)
+{
+  HAL_RTCEx_WakeUpTimerIRQHandler(&RtcHandle);
+}
+#endif /* STM32F1xx */
+#endif /* ONESECOND_IRQn */
+
 #ifdef __cplusplus
 }
 #endif

src/rtc.h

@@ -109,6 +109,28 @@ typedef void(*voidCallbackPtr)(void *);
 #define RTC_Alarm_IRQHandler RTC_TAMP_IRQHandler
 #endif
 
+/* mapping the IRQn for the one-second interrupt depending on the soc */
+#if defined(STM32F1xx) || (defined(STM32F0xx) && defined(RTC_CR_WUTE)) || \
+    defined(STM32L0xx) || defined(STM32L5xx) || defined(STM32U5xx) || \
+    defined(STM32WLE4xx)
+// specific WakeUp interrupt
+#define ONESECOND_IRQn RTC_IRQn
+#elif defined(STM32MP1xx)
+// global RTC interrupt
+#define ONESECOND_IRQn RTC_WKUP_ALARM_IRQn
+#elif defined(STM32G0xx)
+// global RTC/TAMP interrupt
+#define ONESECOND_IRQn RTC_TAMP_IRQn
+#elif defined(STM32WL54xx)|| defined(STM32WL55xx)
+// global RTC/LSS interrupt
+#define ONESECOND_IRQn RTC_LSECSS_IRQn
+#elif defined(RTC_CR_WUTE)
+// specific WakeUp interrupt (including M4 cpu of the STM32WLE5xx)
+#define ONESECOND_IRQn RTC_WKUP_IRQn
+#else
+// no One-Second IRQ available for the series
+#endif /* STM32F1xx || etc */
+
 #if defined(STM32F1xx) && !defined(IS_RTC_WEEKDAY)
 /* Compensate missing HAL definition */
 #define IS_RTC_WEEKDAY(WEEKDAY) (((WEEKDAY) == RTC_WEEKDAY_MONDAY)    || \
@@ -161,6 +183,10 @@ void RTC_StopAlarm(void);
 void RTC_GetAlarm(uint8_t *day, uint8_t *hours, uint8_t *minutes, uint8_t *seconds, uint32_t *subSeconds, hourAM_PM_t *period, uint8_t *mask);
 void attachAlarmCallback(voidCallbackPtr func, void *data);
 void detachAlarmCallback(void);
+#ifdef ONESECOND_IRQn
+void attachSecondsIrqCallback(voidCallbackPtr func);
+void detachSecondsIrqCallback(void);
+#endif /* ONESECOND_IRQn */
 
 #ifdef __cplusplus
 }