SSRU management

README.md

@@ -179,6 +179,14 @@ by the RTC. Thus the getEpoch function is only to be called to get the subsecond
 (returned time_t is not valid). The setAlarmEpoch only uses the sub-second [0..0xFFFFFFFF]
 (time_t value is useless).
 
+_SubSeconds underflow_
+
+Only dor STM32WLxx. Manage interrupt (SSRU) when SubSeconds register
+underflow. Used by STM32LoRaWAN.
+
+* **`void attachSubSecondsUnderflowInterrupt(voidFuncPtr callback);`**
+* **`void detachSubSecondsUnderflowInterrupt(void);`**
+
 Refer to the Arduino RTC documentation for the other functions
 http://arduino.cc/en/Reference/RTC
 

keywords.txt

@@ -72,6 +72,8 @@ attachInterrupt	KEYWORD2
 detachInterrupt	KEYWORD2
 attachSecondsInterrupt	KEYWORD2
 detachSecondsInterrupt	KEYWORD2
+attachSubSecondsUnderflowInterrupt	KEYWORD2
+detachSubSecondsUnderflowInterrupt	KEYWORD2
 
 getClockSource	KEYWORD2
 setClockSource	KEYWORD2

src/STM32RTC.cpp

@@ -334,6 +334,31 @@ void STM32RTC::detachSecondsInterrupt(void)
 }
 
 #endif /* ONESECOND_IRQn */
+
+#ifdef STM32WLxx
+/**
+  * @brief attach a callback to the RTC SubSeconds underflow interrupt.
+  * @note  only for STM32WLxx
+  * @param callback: pointer to the callback
+  * @retval None
+  */
+void STM32RTC::attachSubSecondsUnderflowInterrupt(voidFuncPtr callback)
+{
+  attachSubSecondsUnderflowIrqCallback(callback);
+}
+
+/**
+  * @brief detach the RTC SubSeconds underflow callback.
+  * @retval None
+  */
+void STM32RTC::detachSubSecondsUnderflowInterrupt(void)
+{
+  detachSubSecondsUnderflowIrqCallback();
+}
+
+#endif /* STM32WLxx */
+
+
 // Kept for compatibility. Use STM32LowPower library.
 void STM32RTC::standbyMode(void)
 {
@@ -851,16 +876,7 @@ void STM32RTC::setAlarmSubSeconds(uint32_t subSeconds, Alarm name)
 #ifndef RTC_ALARM_B
   UNUSED(name);
 #endif
-  if (_mode == MODE_BIN) {
-#ifdef RTC_ALARM_B
-    if (name == ALARM_B) {
-      _alarmBSubSeconds = subSeconds;
-    } else
-#endif
-    {
-      _alarmSubSeconds = subSeconds;
-    }
-  } else if (subSeconds < 1000) {
+  if ((_mode == MODE_BIN) || (subSeconds < 1000)) {
 #ifdef RTC_ALARM_B
     if (name == ALARM_B) {
       _alarmBSubSeconds = subSeconds;

src/STM32RTC.h

@@ -159,6 +159,11 @@ class STM32RTC {
     void detachSecondsInterrupt(void);
 
 #endif /* ONESECOND_IRQn */
+#ifdef STM32WLxx
+    // STM32WLxx has a dedicated IRQ
+    void attachSubSecondsUnderflowInterrupt(voidFuncPtr callback);
+    void detachSubSecondsUnderflowInterrupt(void);
+#endif /* STM32WLxx */
     // Kept for compatibility: use STM32LowPower library.
     void standbyMode();
 

src/rtc.c

@@ -63,8 +63,12 @@ static void *callbackUserData = NULL;
 static voidCallbackPtr RTCUserCallbackB = NULL;
 static void *callbackUserDataB = NULL;
 #endif
+#ifdef ONESECOND_IRQn
 static voidCallbackPtr RTCSecondsIrqCallback = NULL;
-
+#endif
+#ifdef STM32WLxx
+static voidCallbackPtr RTCSubSecondsUnderflowIrqCallback = NULL;
+#endif
 static sourceClock_t clkSrc = LSI_CLOCK;
 static uint32_t clkVal = LSI_VALUE;
 static uint8_t HSEDiv = 0;
@@ -97,55 +101,6 @@ static inline int _log2(int x)
 }
 
 /* Exported functions --------------------------------------------------------*/
-
-/* HAL MSP function used for RTC_Init */
-void HAL_RTC_MspInit(RTC_HandleTypeDef *rtcHandle)
-{
-#if defined(RTC_SCR_CSSRUF)
-  if (rtcHandle->Instance == RTC) {
-    /* In BINARY mode (MIX or ONLY), set the SSR Underflow interrupt */
-    if (rtcHandle->Init.BinMode != RTC_BINARY_NONE) {
-#if defined(STM32WLxx)
-      /* Only the STM32WLxx series has a TAMP_STAMP_LSECSS_SSRU_IRQn */
-      if (HAL_RTCEx_SetSSRU_IT(rtcHandle) != HAL_OK) {
-        Error_Handler();
-      }
-      /* Give init value for the RtcFeatures enable */
-      rtcHandle->IsEnabled.RtcFeatures = 0;
-
-      /* RTC interrupt Init */
-      HAL_NVIC_SetPriority(TAMP_STAMP_LSECSS_SSRU_IRQn, 0, 0);
-      HAL_NVIC_EnableIRQ(TAMP_STAMP_LSECSS_SSRU_IRQn);
-#else
-      /* The STM32U5, STM32H5, STM32L4plus have common RTC interrupt and a SSRU flag */
-      __HAL_RTC_SSRU_ENABLE_IT(rtcHandle, RTC_IT_SSRU);
-#endif /* STM32WLxx */
-    }
-  }
-#else /* RTC_SCR_CSSRUF */
-  UNUSED(rtcHandle);
-#endif /* RTC_SCR_CSSRUF */
-  /* RTC_Alarm_IRQn is enabled when enabling Alarm */
-}
-
-void HAL_RTC_MspDeInit(RTC_HandleTypeDef *rtcHandle)
-{
-
-  if (rtcHandle->Instance == RTC) {
-    /* Peripheral clock disable */
-    __HAL_RCC_RTC_DISABLE();
-#ifdef __HAL_RCC_RTCAPB_CLK_DISABLE
-    __HAL_RCC_RTCAPB_CLK_DISABLE();
-#endif
-    /* RTC interrupt Deinit */
-#if defined(STM32WLxx)
-    /* Only the STM32WLxx series has a TAMP_STAMP_LSECSS_SSRU_IRQn */
-    HAL_NVIC_DisableIRQ(TAMP_STAMP_LSECSS_SSRU_IRQn);
-#endif /* STM32WLxx */
-    HAL_NVIC_DisableIRQ(RTC_Alarm_IRQn);
-  }
-}
-
 /**
   * @brief Get pointer to RTC_HandleTypeDef
   * @param None
@@ -635,14 +590,31 @@ bool RTC_init(hourFormat_t format, binaryMode_t mode, sourceClock_t source, bool
 void RTC_DeInit(bool reset_cb)
 {
   HAL_RTC_DeInit(&RtcHandle);
+  /* Peripheral clock disable */
+  __HAL_RCC_RTC_DISABLE();
+#ifdef __HAL_RCC_RTCAPB_CLK_DISABLE
+  __HAL_RCC_RTCAPB_CLK_DISABLE();
+#endif
+  HAL_NVIC_DisableIRQ(RTC_Alarm_IRQn);
+#ifdef ONESECOND_IRQn
+  HAL_NVIC_DisableIRQ(ONESECOND_IRQn);
+#endif
+#ifdef STM32WLxx
+  HAL_NVIC_DisableIRQ(TAMP_STAMP_LSECSS_SSRU_IRQn);
+#endif
   if (reset_cb) {
     RTCUserCallback = NULL;
     callbackUserData = NULL;
 #ifdef RTC_ALARM_B
     RTCUserCallbackB = NULL;
     callbackUserDataB = NULL;
 #endif
+#ifdef ONESECOND_IRQn
     RTCSecondsIrqCallback = NULL;
+#endif
+#ifdef STM32WLxx
+    RTCSubSecondsUnderflowIrqCallback = NULL;
+#endif
   }
 }
 
@@ -1260,6 +1232,48 @@ void RTC_WKUP_IRQHandler(void)
 #endif /* STM32F1xx */
 #endif /* ONESECOND_IRQn */
 
+#ifdef STM32WLxx
+/**
+  * @brief Attach SubSeconds underflow interrupt callback.
+  * @param func: pointer to the callback
+  * @retval None
+  */
+void attachSubSecondsUnderflowIrqCallback(voidCallbackPtr func)
+{
+  /* Callback called on SSRU interrupt */
+  RTCSubSecondsUnderflowIrqCallback = func;
+
+  /* Enable the IRQ that will trig the one-second interrupt */
+  if (HAL_RTCEx_SetSSRU_IT(&RtcHandle) != HAL_OK) {
+    Error_Handler();
+  }
+  HAL_NVIC_SetPriority(TAMP_STAMP_LSECSS_SSRU_IRQn, RTC_IRQ_SSRU_PRIO, RTC_IRQ_SSRU_SUBPRIO);
+  HAL_NVIC_EnableIRQ(TAMP_STAMP_LSECSS_SSRU_IRQn);
+}
+
+/**
+  * @brief Detach  SubSeconds underflow interrupt callback.
+  * @param None
+  * @retval None
+  */
+void detachSubSecondsUnderflowIrqCallback(void)
+{
+  RTCSubSecondsUnderflowIrqCallback = NULL;
+  if (HAL_RTCEx_DeactivateSSRU(&RtcHandle) != HAL_OK) {
+    Error_Handler();
+  }
+  HAL_NVIC_DisableIRQ(TAMP_STAMP_LSECSS_SSRU_IRQn);
+}
+
+void HAL_RTCEx_SSRUEventCallback(RTC_HandleTypeDef *hrtc)
+{
+  (void)hrtc;
+  if (RTCSubSecondsUnderflowIrqCallback != NULL) {
+    RTCSubSecondsUnderflowIrqCallback(NULL);
+  }
+}
+#endif /* STM32WLxx */
+
 #if defined(STM32F1xx)
 void RTC_StoreDate(void)
 {

src/rtc.h

@@ -108,8 +108,12 @@ typedef void(*voidCallbackPtr)(void *);
 #ifndef RTC_IRQ_SUBPRIO
 #define RTC_IRQ_SUBPRIO    0
 #endif
-
-
+#ifndef RTC_IRQ_SSRU_PRIO
+#define RTC_IRQ_SSRU_PRIO     0
+#endif
+#ifndef RTC_IRQ_SSRU_SUBPRIO
+#define RTC_IRQ_SSRU_SUBPRIO  0
+#endif
 #define HSE_RTC_MAX 1000000U
 
 #if !defined(STM32F1xx)
@@ -198,7 +202,10 @@ void detachAlarmCallback(alarm_t name);
 void attachSecondsIrqCallback(voidCallbackPtr func);
 void detachSecondsIrqCallback(void);
 #endif /* ONESECOND_IRQn */
-
+#ifdef STM32WLxx
+void attachSubSecondsUnderflowIrqCallback(voidCallbackPtr func);
+void detachSubSecondsUnderflowIrqCallback(void);
+#endif /* STM32WLxx */
 #if defined(STM32F1xx)
 void RTC_StoreDate(void);
 #endif