594 lines
18 KiB
C
594 lines
18 KiB
C
/**
|
|
******************************************************************************
|
|
* @file stm32f1xx_hal_rtc_ex.c
|
|
* @author MCD Application Team
|
|
* @version V1.1.1
|
|
* @date 12-May-2017
|
|
* @brief Extended RTC HAL module driver.
|
|
* This file provides firmware functions to manage the following
|
|
* functionalities of the Real Time Clock (RTC) Extension peripheral:
|
|
* + RTC Tamper functions
|
|
* + Extension Control functions
|
|
* + Extension RTC features functions
|
|
*
|
|
******************************************************************************
|
|
* @attention
|
|
*
|
|
* <h2><center>© COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
|
|
*
|
|
* Redistribution and use in source and binary forms, with or without modification,
|
|
* are permitted provided that the following conditions are met:
|
|
* 1. Redistributions of source code must retain the above copyright notice,
|
|
* this list of conditions and the following disclaimer.
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
* and/or other materials provided with the distribution.
|
|
* 3. Neither the name of STMicroelectronics nor the names of its contributors
|
|
* may be used to endorse or promote products derived from this software
|
|
* without specific prior written permission.
|
|
*
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
*
|
|
******************************************************************************
|
|
*/
|
|
|
|
/* Includes ------------------------------------------------------------------*/
|
|
#include "stm32f1xx_hal.h"
|
|
|
|
/** @addtogroup STM32F1xx_HAL_Driver
|
|
* @{
|
|
*/
|
|
|
|
#ifdef HAL_RTC_MODULE_ENABLED
|
|
|
|
/** @defgroup RTCEx RTCEx
|
|
* @brief RTC Extended HAL module driver
|
|
* @{
|
|
*/
|
|
|
|
/* Private typedef -----------------------------------------------------------*/
|
|
/* Private define ------------------------------------------------------------*/
|
|
/* Private macro -------------------------------------------------------------*/
|
|
/** @defgroup RTCEx_Private_Macros RTCEx Private Macros
|
|
* @{
|
|
*/
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/* Private variables ---------------------------------------------------------*/
|
|
/* Private function prototypes -----------------------------------------------*/
|
|
/* Private functions ---------------------------------------------------------*/
|
|
|
|
/** @defgroup RTCEx_Exported_Functions RTCEx Exported Functions
|
|
* @{
|
|
*/
|
|
|
|
/** @defgroup RTCEx_Exported_Functions_Group1 RTC Tamper functions
|
|
* @brief RTC Tamper functions
|
|
*
|
|
@verbatim
|
|
===============================================================================
|
|
##### RTC Tamper functions #####
|
|
===============================================================================
|
|
|
|
[..] This section provides functions allowing to configure Tamper feature
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Sets Tamper
|
|
* @note By calling this API we disable the tamper interrupt for all tampers.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @param sTamper: Pointer to Tamper Structure.
|
|
* @note Tamper can be enabled only if ASOE and CCO bit are reset
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
|
|
{
|
|
/* Check input parameters */
|
|
if((hrtc == NULL) || (sTamper == NULL))
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_RTC_TAMPER(sTamper->Tamper));
|
|
assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
|
|
|
|
/* Process Locked */
|
|
__HAL_LOCK(hrtc);
|
|
|
|
hrtc->State = HAL_RTC_STATE_BUSY;
|
|
|
|
if (HAL_IS_BIT_SET(BKP->RTCCR,(BKP_RTCCR_CCO | BKP_RTCCR_ASOE)))
|
|
{
|
|
hrtc->State = HAL_RTC_STATE_ERROR;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
MODIFY_REG(BKP->CR, (BKP_CR_TPE | BKP_CR_TPAL), (sTamper->Tamper | (sTamper->Trigger)));
|
|
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Sets Tamper with interrupt.
|
|
* @note By calling this API we force the tamper interrupt for all tampers.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @param sTamper: Pointer to RTC Tamper.
|
|
* @note Tamper can be enabled only if ASOE and CCO bit are reset
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
|
|
{
|
|
/* Check input parameters */
|
|
if((hrtc == NULL) || (sTamper == NULL))
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_RTC_TAMPER(sTamper->Tamper));
|
|
assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
|
|
|
|
/* Process Locked */
|
|
__HAL_LOCK(hrtc);
|
|
|
|
hrtc->State = HAL_RTC_STATE_BUSY;
|
|
|
|
if (HAL_IS_BIT_SET(BKP->RTCCR,(BKP_RTCCR_CCO | BKP_RTCCR_ASOE)))
|
|
{
|
|
hrtc->State = HAL_RTC_STATE_ERROR;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
MODIFY_REG(BKP->CR, (BKP_CR_TPE | BKP_CR_TPAL), (sTamper->Tamper | (sTamper->Trigger)));
|
|
|
|
/* Configure the Tamper Interrupt in the BKP->CSR */
|
|
__HAL_RTC_TAMPER_ENABLE_IT(hrtc, RTC_IT_TAMP1);
|
|
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Deactivates Tamper.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @param Tamper: Selected tamper pin.
|
|
* This parameter can be a value of @ref RTCEx_Tamper_Pins_Definitions
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper)
|
|
{
|
|
/* Check input parameters */
|
|
if(hrtc == NULL)
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(Tamper);
|
|
|
|
assert_param(IS_RTC_TAMPER(Tamper));
|
|
|
|
/* Process Locked */
|
|
__HAL_LOCK(hrtc);
|
|
|
|
hrtc->State = HAL_RTC_STATE_BUSY;
|
|
|
|
/* Disable the selected Tamper pin */
|
|
CLEAR_BIT(BKP->CR, BKP_CR_TPE);
|
|
|
|
/* Disable the Tamper Interrupt in the BKP->CSR */
|
|
/* Configure the Tamper Interrupt in the BKP->CSR */
|
|
__HAL_RTC_TAMPER_DISABLE_IT(hrtc, RTC_IT_TAMP1);
|
|
|
|
/* Clear the Tamper interrupt pending bit */
|
|
__HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP1F);
|
|
SET_BIT(BKP->CSR, BKP_CSR_CTE);
|
|
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles Tamper interrupt request.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval None
|
|
*/
|
|
void HAL_RTCEx_TamperIRQHandler(RTC_HandleTypeDef *hrtc)
|
|
{
|
|
/* Get the status of the Interrupt */
|
|
if(__HAL_RTC_TAMPER_GET_IT_SOURCE(hrtc, RTC_IT_TAMP1))
|
|
{
|
|
/* Get the TAMPER Interrupt enable bit and pending bit */
|
|
if(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F) != (uint32_t)RESET)
|
|
{
|
|
/* Tamper callback */
|
|
HAL_RTCEx_Tamper1EventCallback(hrtc);
|
|
|
|
/* Clear the Tamper interrupt pending bit */
|
|
__HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
|
|
}
|
|
}
|
|
|
|
/* Change RTC state */
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
}
|
|
|
|
/**
|
|
* @brief Tamper 1 callback.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hrtc);
|
|
/* NOTE : This function Should not be modified, when the callback is needed,
|
|
the HAL_RTCEx_Tamper1EventCallback could be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles Tamper1 Polling.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @param Timeout: Timeout duration
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
|
|
{
|
|
uint32_t tickstart = HAL_GetTick();
|
|
|
|
/* Check input parameters */
|
|
if(hrtc == NULL)
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Get the status of the Interrupt */
|
|
while(__HAL_RTC_TAMPER_GET_FLAG(hrtc,RTC_FLAG_TAMP1F)== RESET)
|
|
{
|
|
if(Timeout != HAL_MAX_DELAY)
|
|
{
|
|
if((Timeout == 0U)||((HAL_GetTick() - tickstart ) > Timeout))
|
|
{
|
|
hrtc->State = HAL_RTC_STATE_TIMEOUT;
|
|
return HAL_TIMEOUT;
|
|
}
|
|
}
|
|
}
|
|
|
|
/* Clear the Tamper Flag */
|
|
__HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
|
|
|
|
/* Change RTC state */
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @defgroup RTCEx_Exported_Functions_Group2 RTC Second functions
|
|
* @brief RTC Second functions
|
|
*
|
|
@verbatim
|
|
===============================================================================
|
|
##### RTC Second functions #####
|
|
===============================================================================
|
|
|
|
[..] This section provides functions implementing second interupt handlers
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Sets Interrupt for second
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_SetSecond_IT(RTC_HandleTypeDef *hrtc)
|
|
{
|
|
/* Check input parameters */
|
|
if(hrtc == NULL)
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Process Locked */
|
|
__HAL_LOCK(hrtc);
|
|
|
|
hrtc->State = HAL_RTC_STATE_BUSY;
|
|
|
|
/* Enable Second interuption */
|
|
__HAL_RTC_SECOND_ENABLE_IT(hrtc, RTC_IT_SEC);
|
|
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief Deactivates Second.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_DeactivateSecond(RTC_HandleTypeDef *hrtc)
|
|
{
|
|
/* Check input parameters */
|
|
if(hrtc == NULL)
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
|
|
/* Process Locked */
|
|
__HAL_LOCK(hrtc);
|
|
|
|
hrtc->State = HAL_RTC_STATE_BUSY;
|
|
|
|
/* Deactivate Second interuption*/
|
|
__HAL_RTC_SECOND_DISABLE_IT(hrtc, RTC_IT_SEC);
|
|
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @brief This function handles second interrupt request.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval None
|
|
*/
|
|
void HAL_RTCEx_RTCIRQHandler(RTC_HandleTypeDef* hrtc)
|
|
{
|
|
if(__HAL_RTC_SECOND_GET_IT_SOURCE(hrtc, RTC_IT_SEC))
|
|
{
|
|
/* Get the status of the Interrupt */
|
|
if(__HAL_RTC_SECOND_GET_FLAG(hrtc, RTC_FLAG_SEC))
|
|
{
|
|
/* Check if Overrun occurred */
|
|
if (__HAL_RTC_SECOND_GET_FLAG(hrtc, RTC_FLAG_OW))
|
|
{
|
|
/* Second error callback */
|
|
HAL_RTCEx_RTCEventErrorCallback(hrtc);
|
|
|
|
/* Clear flag Second */
|
|
__HAL_RTC_OVERFLOW_CLEAR_FLAG(hrtc, RTC_FLAG_OW);
|
|
|
|
/* Change RTC state */
|
|
hrtc->State = HAL_RTC_STATE_ERROR;
|
|
}
|
|
else
|
|
{
|
|
/* Second callback */
|
|
HAL_RTCEx_RTCEventCallback(hrtc);
|
|
|
|
/* Change RTC state */
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
}
|
|
|
|
/* Clear flag Second */
|
|
__HAL_RTC_SECOND_CLEAR_FLAG(hrtc, RTC_FLAG_SEC);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* @brief Second event callback.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_RTCEx_RTCEventCallback(RTC_HandleTypeDef *hrtc)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hrtc);
|
|
/* NOTE : This function Should not be modified, when the callback is needed,
|
|
the HAL_RTCEx_RTCEventCallback could be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* @brief Second event error callback.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @retval None
|
|
*/
|
|
__weak void HAL_RTCEx_RTCEventErrorCallback(RTC_HandleTypeDef *hrtc)
|
|
{
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hrtc);
|
|
/* NOTE : This function Should not be modified, when the callback is needed,
|
|
the HAL_RTCEx_RTCEventErrorCallback could be implemented in the user file
|
|
*/
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/** @defgroup RTCEx_Exported_Functions_Group3 Extended Peripheral Control functions
|
|
* @brief Extended Peripheral Control functions
|
|
*
|
|
@verbatim
|
|
===============================================================================
|
|
##### Extension Peripheral Control functions #####
|
|
===============================================================================
|
|
[..]
|
|
This subsection provides functions allowing to
|
|
(+) Writes a data in a specified RTC Backup data register
|
|
(+) Read a data in a specified RTC Backup data register
|
|
(+) Sets the Smooth calibration parameters.
|
|
|
|
@endverbatim
|
|
* @{
|
|
*/
|
|
|
|
/**
|
|
* @brief Writes a data in a specified RTC Backup data register.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @param BackupRegister: RTC Backup data Register number.
|
|
* This parameter can be: RTC_BKP_DRx where x can be from 1 to 10 (or 42) to
|
|
* specify the register (depending devices).
|
|
* @param Data: Data to be written in the specified RTC Backup data register.
|
|
* @retval None
|
|
*/
|
|
void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
|
|
{
|
|
uint32_t tmp = 0U;
|
|
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hrtc);
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_RTC_BKP(BackupRegister));
|
|
|
|
tmp = (uint32_t)BKP_BASE;
|
|
tmp += (BackupRegister * 4U);
|
|
|
|
*(__IO uint32_t *) tmp = (Data & BKP_DR1_D);
|
|
}
|
|
|
|
/**
|
|
* @brief Reads data from the specified RTC Backup data Register.
|
|
* @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
|
|
* the configuration information for RTC.
|
|
* @param BackupRegister: RTC Backup data Register number.
|
|
* This parameter can be: RTC_BKP_DRx where x can be from 1 to 10 (or 42) to
|
|
* specify the register (depending devices).
|
|
* @retval Read value
|
|
*/
|
|
uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
|
|
{
|
|
uint32_t backupregister = 0U;
|
|
uint32_t pvalue = 0U;
|
|
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(hrtc);
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_RTC_BKP(BackupRegister));
|
|
|
|
backupregister = (uint32_t)BKP_BASE;
|
|
backupregister += (BackupRegister * 4U);
|
|
|
|
pvalue = (*(__IO uint32_t *)(backupregister)) & BKP_DR1_D;
|
|
|
|
/* Read the specified register */
|
|
return pvalue;
|
|
}
|
|
|
|
|
|
/**
|
|
* @brief Sets the Smooth calibration parameters.
|
|
* @param hrtc: RTC handle
|
|
* @param SmoothCalibPeriod: Not used (only present for compatibility with another families)
|
|
* @param SmoothCalibPlusPulses: Not used (only present for compatibility with another families)
|
|
* @param SmouthCalibMinusPulsesValue: specifies the RTC Clock Calibration value.
|
|
* This parameter must be a number between 0 and 0x7F.
|
|
* @retval HAL status
|
|
*/
|
|
HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmouthCalibMinusPulsesValue)
|
|
{
|
|
/* Check input parameters */
|
|
if(hrtc == NULL)
|
|
{
|
|
return HAL_ERROR;
|
|
}
|
|
/* Prevent unused argument(s) compilation warning */
|
|
UNUSED(SmoothCalibPeriod);
|
|
UNUSED(SmoothCalibPlusPulses);
|
|
|
|
/* Check the parameters */
|
|
assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmouthCalibMinusPulsesValue));
|
|
|
|
/* Process Locked */
|
|
__HAL_LOCK(hrtc);
|
|
|
|
hrtc->State = HAL_RTC_STATE_BUSY;
|
|
|
|
/* Sets RTC Clock Calibration value.*/
|
|
MODIFY_REG(BKP->RTCCR, BKP_RTCCR_CAL, SmouthCalibMinusPulsesValue);
|
|
|
|
/* Change RTC state */
|
|
hrtc->State = HAL_RTC_STATE_READY;
|
|
|
|
/* Process Unlocked */
|
|
__HAL_UNLOCK(hrtc);
|
|
|
|
return HAL_OK;
|
|
}
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
#endif /* HAL_RTC_MODULE_ENABLED */
|
|
|
|
/**
|
|
* @}
|
|
*/
|
|
|
|
/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
|
|
|