| /** |
| ****************************************************************************** |
| * @file stm32f1xx_hal_rtc_ex.c |
| * @author MCD Application Team |
| * @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. |
| * All rights reserved.</center></h2> |
| * |
| * This software component is licensed by ST under BSD 3-Clause license, |
| * the "License"; You may not use this file except in compliance with the |
| * License. You may obtain a copy of the License at: |
| * opensource.org/licenses/BSD-3-Clause |
| * |
| ****************************************************************************** |
| */ |
| |
| /* 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 */ |
| #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1) |
| hrtc->Tamper1EventCallback(hrtc); |
| #else |
| HAL_RTCEx_Tamper1EventCallback(hrtc); |
| #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */ |
| |
| /* 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****/ |
| |