mbed official / mbed-dev

mbed library sources. Supersedes mbed-src.

Dependents:   Nucleo_Hello_Encoder BLE_iBeaconScan AM1805_DEMO DISCO-F429ZI_ExportTemplate1 ... more

targets/TARGET_STM/TARGET_STM32F1/device/stm32f1xx_hal_rtc_ex.c@189:f392fc9709a3, 2019-02-20 (annotated)

Committer:
AnnaBridge
Date:
Wed Feb 20 22:31:08 2019 +0000
Revision:
189:f392fc9709a3
Parent:
187:0387e8f68319 
mbed library release version 165

Who changed what in which revision?

UserRevisionLine numberNew contents of line
<> 144:ef7eb2e8f9f7 1 /**
<> 144:ef7eb2e8f9f7 2 ******************************************************************************
<> 144:ef7eb2e8f9f7 3 * @file stm32f1xx_hal_rtc_ex.c
<> 144:ef7eb2e8f9f7 4 * @author MCD Application Team
<> 144:ef7eb2e8f9f7 5 * @brief Extended RTC HAL module driver.
<> 144:ef7eb2e8f9f7 6 * This file provides firmware functions to manage the following
<> 144:ef7eb2e8f9f7 7 * functionalities of the Real Time Clock (RTC) Extension peripheral:
<> 144:ef7eb2e8f9f7 8 * + RTC Tamper functions
<> 144:ef7eb2e8f9f7 9 * + Extension Control functions
<> 144:ef7eb2e8f9f7 10 * + Extension RTC features functions
<> 144:ef7eb2e8f9f7 11 *
<> 144:ef7eb2e8f9f7 12 ******************************************************************************
<> 144:ef7eb2e8f9f7 13 * @attention
<> 144:ef7eb2e8f9f7 14 *
<> 144:ef7eb2e8f9f7 15 * <h2><center>&copy; COPYRIGHT(c) 2016 STMicroelectronics</center></h2>
<> 144:ef7eb2e8f9f7 16 *
<> 144:ef7eb2e8f9f7 17 * Redistribution and use in source and binary forms, with or without modification,
<> 144:ef7eb2e8f9f7 18 * are permitted provided that the following conditions are met:
<> 144:ef7eb2e8f9f7 19 * 1. Redistributions of source code must retain the above copyright notice,
<> 144:ef7eb2e8f9f7 20 * this list of conditions and the following disclaimer.
<> 144:ef7eb2e8f9f7 21 * 2. Redistributions in binary form must reproduce the above copyright notice,
<> 144:ef7eb2e8f9f7 22 * this list of conditions and the following disclaimer in the documentation
<> 144:ef7eb2e8f9f7 23 * and/or other materials provided with the distribution.
<> 144:ef7eb2e8f9f7 24 * 3. Neither the name of STMicroelectronics nor the names of its contributors
<> 144:ef7eb2e8f9f7 25 * may be used to endorse or promote products derived from this software
<> 144:ef7eb2e8f9f7 26 * without specific prior written permission.
<> 144:ef7eb2e8f9f7 27 *
<> 144:ef7eb2e8f9f7 28 * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
<> 144:ef7eb2e8f9f7 29 * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
<> 144:ef7eb2e8f9f7 30 * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
<> 144:ef7eb2e8f9f7 31 * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
<> 144:ef7eb2e8f9f7 32 * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
<> 144:ef7eb2e8f9f7 33 * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
<> 144:ef7eb2e8f9f7 34 * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
<> 144:ef7eb2e8f9f7 35 * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
<> 144:ef7eb2e8f9f7 36 * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
<> 144:ef7eb2e8f9f7 37 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
<> 144:ef7eb2e8f9f7 38 *
<> 144:ef7eb2e8f9f7 39 ******************************************************************************
<> 144:ef7eb2e8f9f7 40 */
<> 144:ef7eb2e8f9f7 41
<> 144:ef7eb2e8f9f7 42 /* Includes ------------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 43 #include "stm32f1xx_hal.h"
<> 144:ef7eb2e8f9f7 44
<> 144:ef7eb2e8f9f7 45 /** @addtogroup STM32F1xx_HAL_Driver
<> 144:ef7eb2e8f9f7 46 * @{
<> 144:ef7eb2e8f9f7 47 */
<> 144:ef7eb2e8f9f7 48
<> 144:ef7eb2e8f9f7 49 #ifdef HAL_RTC_MODULE_ENABLED
<> 144:ef7eb2e8f9f7 50
<> 144:ef7eb2e8f9f7 51 /** @defgroup RTCEx RTCEx
<> 144:ef7eb2e8f9f7 52 * @brief RTC Extended HAL module driver
<> 144:ef7eb2e8f9f7 53 * @{
<> 144:ef7eb2e8f9f7 54 */
<> 144:ef7eb2e8f9f7 55
<> 144:ef7eb2e8f9f7 56 /* Private typedef -----------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 57 /* Private define ------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 58 /* Private macro -------------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 59 /** @defgroup RTCEx_Private_Macros RTCEx Private Macros
<> 144:ef7eb2e8f9f7 60 * @{
<> 144:ef7eb2e8f9f7 61 */
<> 144:ef7eb2e8f9f7 62 /**
<> 144:ef7eb2e8f9f7 63 * @}
<> 144:ef7eb2e8f9f7 64 */
<> 144:ef7eb2e8f9f7 65
<> 144:ef7eb2e8f9f7 66 /* Private variables ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 67 /* Private function prototypes -----------------------------------------------*/
<> 144:ef7eb2e8f9f7 68 /* Private functions ---------------------------------------------------------*/
<> 144:ef7eb2e8f9f7 69
<> 144:ef7eb2e8f9f7 70 /** @defgroup RTCEx_Exported_Functions RTCEx Exported Functions
<> 144:ef7eb2e8f9f7 71 * @{
<> 144:ef7eb2e8f9f7 72 */
<> 144:ef7eb2e8f9f7 73
<> 144:ef7eb2e8f9f7 74 /** @defgroup RTCEx_Exported_Functions_Group1 RTC Tamper functions
<> 144:ef7eb2e8f9f7 75 * @brief RTC Tamper functions
<> 144:ef7eb2e8f9f7 76 *
<> 144:ef7eb2e8f9f7 77 @verbatim
<> 144:ef7eb2e8f9f7 78 ===============================================================================
<> 144:ef7eb2e8f9f7 79 ##### RTC Tamper functions #####
<> 144:ef7eb2e8f9f7 80 ===============================================================================
<> 144:ef7eb2e8f9f7 81
<> 144:ef7eb2e8f9f7 82 [..] This section provides functions allowing to configure Tamper feature
<> 144:ef7eb2e8f9f7 83
<> 144:ef7eb2e8f9f7 84 @endverbatim
<> 144:ef7eb2e8f9f7 85 * @{
<> 144:ef7eb2e8f9f7 86 */
<> 144:ef7eb2e8f9f7 87
<> 144:ef7eb2e8f9f7 88 /**
<> 144:ef7eb2e8f9f7 89 * @brief Sets Tamper
<> 144:ef7eb2e8f9f7 90 * @note By calling this API we disable the tamper interrupt for all tampers.
<> 144:ef7eb2e8f9f7 91 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 92 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 93 * @param sTamper: Pointer to Tamper Structure.
<> 144:ef7eb2e8f9f7 94 * @note Tamper can be enabled only if ASOE and CCO bit are reset
<> 144:ef7eb2e8f9f7 95 * @retval HAL status
<> 144:ef7eb2e8f9f7 96 */
<> 144:ef7eb2e8f9f7 97 HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
<> 144:ef7eb2e8f9f7 98 {
<> 144:ef7eb2e8f9f7 99 /* Check input parameters */
<> 144:ef7eb2e8f9f7 100 if((hrtc == NULL) || (sTamper == NULL))
<> 144:ef7eb2e8f9f7 101 {
<> 144:ef7eb2e8f9f7 102 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 103 }
<> 144:ef7eb2e8f9f7 104
<> 144:ef7eb2e8f9f7 105 /* Check the parameters */
<> 144:ef7eb2e8f9f7 106 assert_param(IS_RTC_TAMPER(sTamper->Tamper));
<> 144:ef7eb2e8f9f7 107 assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
<> 144:ef7eb2e8f9f7 108
<> 144:ef7eb2e8f9f7 109 /* Process Locked */
<> 144:ef7eb2e8f9f7 110 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 111
<> 144:ef7eb2e8f9f7 112 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 113
<> 144:ef7eb2e8f9f7 114 if (HAL_IS_BIT_SET(BKP->RTCCR,(BKP_RTCCR_CCO | BKP_RTCCR_ASOE)))
<> 144:ef7eb2e8f9f7 115 {
<> 144:ef7eb2e8f9f7 116 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 117
<> 144:ef7eb2e8f9f7 118 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 119 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 120
<> 144:ef7eb2e8f9f7 121 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 122 }
<> 144:ef7eb2e8f9f7 123
<> 144:ef7eb2e8f9f7 124 MODIFY_REG(BKP->CR, (BKP_CR_TPE | BKP_CR_TPAL), (sTamper->Tamper | (sTamper->Trigger)));
<> 144:ef7eb2e8f9f7 125
<> 144:ef7eb2e8f9f7 126 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 127
<> 144:ef7eb2e8f9f7 128 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 129 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 130
<> 144:ef7eb2e8f9f7 131 return HAL_OK;
<> 144:ef7eb2e8f9f7 132 }
<> 144:ef7eb2e8f9f7 133
<> 144:ef7eb2e8f9f7 134 /**
<> 144:ef7eb2e8f9f7 135 * @brief Sets Tamper with interrupt.
<> 144:ef7eb2e8f9f7 136 * @note By calling this API we force the tamper interrupt for all tampers.
<> 144:ef7eb2e8f9f7 137 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 138 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 139 * @param sTamper: Pointer to RTC Tamper.
<> 144:ef7eb2e8f9f7 140 * @note Tamper can be enabled only if ASOE and CCO bit are reset
<> 144:ef7eb2e8f9f7 141 * @retval HAL status
<> 144:ef7eb2e8f9f7 142 */
<> 144:ef7eb2e8f9f7 143 HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)
<> 144:ef7eb2e8f9f7 144 {
<> 144:ef7eb2e8f9f7 145 /* Check input parameters */
<> 144:ef7eb2e8f9f7 146 if((hrtc == NULL) || (sTamper == NULL))
<> 144:ef7eb2e8f9f7 147 {
<> 144:ef7eb2e8f9f7 148 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 149 }
<> 144:ef7eb2e8f9f7 150
<> 144:ef7eb2e8f9f7 151 /* Check the parameters */
<> 144:ef7eb2e8f9f7 152 assert_param(IS_RTC_TAMPER(sTamper->Tamper));
<> 144:ef7eb2e8f9f7 153 assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));
<> 144:ef7eb2e8f9f7 154
<> 144:ef7eb2e8f9f7 155 /* Process Locked */
<> 144:ef7eb2e8f9f7 156 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 157
<> 144:ef7eb2e8f9f7 158 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 159
<> 144:ef7eb2e8f9f7 160 if (HAL_IS_BIT_SET(BKP->RTCCR,(BKP_RTCCR_CCO | BKP_RTCCR_ASOE)))
<> 144:ef7eb2e8f9f7 161 {
<> 144:ef7eb2e8f9f7 162 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 163
<> 144:ef7eb2e8f9f7 164 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 165 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 166
<> 144:ef7eb2e8f9f7 167 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 168 }
<> 144:ef7eb2e8f9f7 169
<> 144:ef7eb2e8f9f7 170 MODIFY_REG(BKP->CR, (BKP_CR_TPE | BKP_CR_TPAL), (sTamper->Tamper | (sTamper->Trigger)));
<> 144:ef7eb2e8f9f7 171
<> 144:ef7eb2e8f9f7 172 /* Configure the Tamper Interrupt in the BKP->CSR */
<> 144:ef7eb2e8f9f7 173 __HAL_RTC_TAMPER_ENABLE_IT(hrtc, RTC_IT_TAMP1);
<> 144:ef7eb2e8f9f7 174
<> 144:ef7eb2e8f9f7 175 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 176
<> 144:ef7eb2e8f9f7 177 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 178 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 179
<> 144:ef7eb2e8f9f7 180 return HAL_OK;
<> 144:ef7eb2e8f9f7 181 }
<> 144:ef7eb2e8f9f7 182
<> 144:ef7eb2e8f9f7 183 /**
<> 144:ef7eb2e8f9f7 184 * @brief Deactivates Tamper.
<> 144:ef7eb2e8f9f7 185 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 186 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 187 * @param Tamper: Selected tamper pin.
<> 144:ef7eb2e8f9f7 188 * This parameter can be a value of @ref RTCEx_Tamper_Pins_Definitions
<> 144:ef7eb2e8f9f7 189 * @retval HAL status
<> 144:ef7eb2e8f9f7 190 */
<> 144:ef7eb2e8f9f7 191 HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper)
<> 144:ef7eb2e8f9f7 192 {
<> 144:ef7eb2e8f9f7 193 /* Check input parameters */
<> 144:ef7eb2e8f9f7 194 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 195 {
<> 144:ef7eb2e8f9f7 196 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 197 }
AnnaBridge 165:e614a9f1c9e2 198 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 199 UNUSED(Tamper);
AnnaBridge 165:e614a9f1c9e2 200
<> 144:ef7eb2e8f9f7 201 assert_param(IS_RTC_TAMPER(Tamper));
<> 144:ef7eb2e8f9f7 202
<> 144:ef7eb2e8f9f7 203 /* Process Locked */
<> 144:ef7eb2e8f9f7 204 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 205
<> 144:ef7eb2e8f9f7 206 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 207
<> 144:ef7eb2e8f9f7 208 /* Disable the selected Tamper pin */
<> 144:ef7eb2e8f9f7 209 CLEAR_BIT(BKP->CR, BKP_CR_TPE);
<> 144:ef7eb2e8f9f7 210
<> 144:ef7eb2e8f9f7 211 /* Disable the Tamper Interrupt in the BKP->CSR */
<> 144:ef7eb2e8f9f7 212 /* Configure the Tamper Interrupt in the BKP->CSR */
<> 144:ef7eb2e8f9f7 213 __HAL_RTC_TAMPER_DISABLE_IT(hrtc, RTC_IT_TAMP1);
<> 144:ef7eb2e8f9f7 214
<> 144:ef7eb2e8f9f7 215 /* Clear the Tamper interrupt pending bit */
<> 144:ef7eb2e8f9f7 216 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP1F);
<> 144:ef7eb2e8f9f7 217 SET_BIT(BKP->CSR, BKP_CSR_CTE);
<> 144:ef7eb2e8f9f7 218
<> 144:ef7eb2e8f9f7 219 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 220
<> 144:ef7eb2e8f9f7 221 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 222 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 223
<> 144:ef7eb2e8f9f7 224 return HAL_OK;
<> 144:ef7eb2e8f9f7 225 }
<> 144:ef7eb2e8f9f7 226
<> 144:ef7eb2e8f9f7 227 /**
<> 144:ef7eb2e8f9f7 228 * @brief This function handles Tamper interrupt request.
<> 144:ef7eb2e8f9f7 229 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 230 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 231 * @retval None
<> 144:ef7eb2e8f9f7 232 */
<> 144:ef7eb2e8f9f7 233 void HAL_RTCEx_TamperIRQHandler(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 234 {
<> 144:ef7eb2e8f9f7 235 /* Get the status of the Interrupt */
<> 144:ef7eb2e8f9f7 236 if(__HAL_RTC_TAMPER_GET_IT_SOURCE(hrtc, RTC_IT_TAMP1))
<> 144:ef7eb2e8f9f7 237 {
<> 144:ef7eb2e8f9f7 238 /* Get the TAMPER Interrupt enable bit and pending bit */
<> 144:ef7eb2e8f9f7 239 if(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F) != (uint32_t)RESET)
<> 144:ef7eb2e8f9f7 240 {
<> 144:ef7eb2e8f9f7 241 /* Tamper callback */
<> 144:ef7eb2e8f9f7 242 HAL_RTCEx_Tamper1EventCallback(hrtc);
<> 144:ef7eb2e8f9f7 243
<> 144:ef7eb2e8f9f7 244 /* Clear the Tamper interrupt pending bit */
<> 144:ef7eb2e8f9f7 245 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
<> 144:ef7eb2e8f9f7 246 }
<> 144:ef7eb2e8f9f7 247 }
<> 144:ef7eb2e8f9f7 248
<> 144:ef7eb2e8f9f7 249 /* Change RTC state */
<> 144:ef7eb2e8f9f7 250 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 251 }
<> 144:ef7eb2e8f9f7 252
<> 144:ef7eb2e8f9f7 253 /**
<> 144:ef7eb2e8f9f7 254 * @brief Tamper 1 callback.
<> 144:ef7eb2e8f9f7 255 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 256 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 257 * @retval None
<> 144:ef7eb2e8f9f7 258 */
<> 144:ef7eb2e8f9f7 259 __weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 260 {
<> 144:ef7eb2e8f9f7 261 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 262 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 263 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 264 the HAL_RTCEx_Tamper1EventCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 265 */
<> 144:ef7eb2e8f9f7 266 }
<> 144:ef7eb2e8f9f7 267
<> 144:ef7eb2e8f9f7 268 /**
<> 144:ef7eb2e8f9f7 269 * @brief This function handles Tamper1 Polling.
<> 144:ef7eb2e8f9f7 270 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 271 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 272 * @param Timeout: Timeout duration
<> 144:ef7eb2e8f9f7 273 * @retval HAL status
<> 144:ef7eb2e8f9f7 274 */
<> 144:ef7eb2e8f9f7 275 HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
<> 144:ef7eb2e8f9f7 276 {
<> 144:ef7eb2e8f9f7 277 uint32_t tickstart = HAL_GetTick();
<> 144:ef7eb2e8f9f7 278
<> 144:ef7eb2e8f9f7 279 /* Check input parameters */
<> 144:ef7eb2e8f9f7 280 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 281 {
<> 144:ef7eb2e8f9f7 282 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 283 }
<> 144:ef7eb2e8f9f7 284
<> 144:ef7eb2e8f9f7 285 /* Get the status of the Interrupt */
<> 144:ef7eb2e8f9f7 286 while(__HAL_RTC_TAMPER_GET_FLAG(hrtc,RTC_FLAG_TAMP1F)== RESET)
<> 144:ef7eb2e8f9f7 287 {
<> 144:ef7eb2e8f9f7 288 if(Timeout != HAL_MAX_DELAY)
<> 144:ef7eb2e8f9f7 289 {
AnnaBridge 165:e614a9f1c9e2 290 if((Timeout == 0U)||((HAL_GetTick() - tickstart ) > Timeout))
<> 144:ef7eb2e8f9f7 291 {
<> 144:ef7eb2e8f9f7 292 hrtc->State = HAL_RTC_STATE_TIMEOUT;
<> 144:ef7eb2e8f9f7 293 return HAL_TIMEOUT;
<> 144:ef7eb2e8f9f7 294 }
<> 144:ef7eb2e8f9f7 295 }
<> 144:ef7eb2e8f9f7 296 }
<> 144:ef7eb2e8f9f7 297
<> 144:ef7eb2e8f9f7 298 /* Clear the Tamper Flag */
<> 144:ef7eb2e8f9f7 299 __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);
<> 144:ef7eb2e8f9f7 300
<> 144:ef7eb2e8f9f7 301 /* Change RTC state */
<> 144:ef7eb2e8f9f7 302 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 303
<> 144:ef7eb2e8f9f7 304 return HAL_OK;
<> 144:ef7eb2e8f9f7 305 }
<> 144:ef7eb2e8f9f7 306
<> 144:ef7eb2e8f9f7 307 /**
<> 144:ef7eb2e8f9f7 308 * @}
<> 144:ef7eb2e8f9f7 309 */
<> 144:ef7eb2e8f9f7 310
<> 144:ef7eb2e8f9f7 311 /** @defgroup RTCEx_Exported_Functions_Group2 RTC Second functions
<> 144:ef7eb2e8f9f7 312 * @brief RTC Second functions
<> 144:ef7eb2e8f9f7 313 *
<> 144:ef7eb2e8f9f7 314 @verbatim
<> 144:ef7eb2e8f9f7 315 ===============================================================================
<> 144:ef7eb2e8f9f7 316 ##### RTC Second functions #####
<> 144:ef7eb2e8f9f7 317 ===============================================================================
<> 144:ef7eb2e8f9f7 318
<> 144:ef7eb2e8f9f7 319 [..] This section provides functions implementing second interupt handlers
<> 144:ef7eb2e8f9f7 320
<> 144:ef7eb2e8f9f7 321 @endverbatim
<> 144:ef7eb2e8f9f7 322 * @{
<> 144:ef7eb2e8f9f7 323 */
<> 144:ef7eb2e8f9f7 324
<> 144:ef7eb2e8f9f7 325 /**
<> 144:ef7eb2e8f9f7 326 * @brief Sets Interrupt for second
<> 144:ef7eb2e8f9f7 327 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 328 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 329 * @retval HAL status
<> 144:ef7eb2e8f9f7 330 */
<> 144:ef7eb2e8f9f7 331 HAL_StatusTypeDef HAL_RTCEx_SetSecond_IT(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 332 {
<> 144:ef7eb2e8f9f7 333 /* Check input parameters */
<> 144:ef7eb2e8f9f7 334 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 335 {
<> 144:ef7eb2e8f9f7 336 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 337 }
<> 144:ef7eb2e8f9f7 338
<> 144:ef7eb2e8f9f7 339 /* Process Locked */
<> 144:ef7eb2e8f9f7 340 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 341
<> 144:ef7eb2e8f9f7 342 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 343
<> 144:ef7eb2e8f9f7 344 /* Enable Second interuption */
<> 144:ef7eb2e8f9f7 345 __HAL_RTC_SECOND_ENABLE_IT(hrtc, RTC_IT_SEC);
<> 144:ef7eb2e8f9f7 346
<> 144:ef7eb2e8f9f7 347 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 348
<> 144:ef7eb2e8f9f7 349 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 350 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 351
<> 144:ef7eb2e8f9f7 352 return HAL_OK;
<> 144:ef7eb2e8f9f7 353 }
<> 144:ef7eb2e8f9f7 354
<> 144:ef7eb2e8f9f7 355 /**
<> 144:ef7eb2e8f9f7 356 * @brief Deactivates Second.
<> 144:ef7eb2e8f9f7 357 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 358 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 359 * @retval HAL status
<> 144:ef7eb2e8f9f7 360 */
<> 144:ef7eb2e8f9f7 361 HAL_StatusTypeDef HAL_RTCEx_DeactivateSecond(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 362 {
<> 144:ef7eb2e8f9f7 363 /* Check input parameters */
<> 144:ef7eb2e8f9f7 364 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 365 {
<> 144:ef7eb2e8f9f7 366 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 367 }
<> 144:ef7eb2e8f9f7 368
<> 144:ef7eb2e8f9f7 369 /* Process Locked */
<> 144:ef7eb2e8f9f7 370 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 371
<> 144:ef7eb2e8f9f7 372 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 373
<> 144:ef7eb2e8f9f7 374 /* Deactivate Second interuption*/
<> 144:ef7eb2e8f9f7 375 __HAL_RTC_SECOND_DISABLE_IT(hrtc, RTC_IT_SEC);
<> 144:ef7eb2e8f9f7 376
<> 144:ef7eb2e8f9f7 377 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 378
<> 144:ef7eb2e8f9f7 379 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 380 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 381
<> 144:ef7eb2e8f9f7 382 return HAL_OK;
<> 144:ef7eb2e8f9f7 383 }
<> 144:ef7eb2e8f9f7 384
<> 144:ef7eb2e8f9f7 385 /**
<> 144:ef7eb2e8f9f7 386 * @brief This function handles second interrupt request.
<> 144:ef7eb2e8f9f7 387 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 388 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 389 * @retval None
<> 144:ef7eb2e8f9f7 390 */
<> 144:ef7eb2e8f9f7 391 void HAL_RTCEx_RTCIRQHandler(RTC_HandleTypeDef* hrtc)
<> 144:ef7eb2e8f9f7 392 {
<> 144:ef7eb2e8f9f7 393 if(__HAL_RTC_SECOND_GET_IT_SOURCE(hrtc, RTC_IT_SEC))
<> 144:ef7eb2e8f9f7 394 {
<> 144:ef7eb2e8f9f7 395 /* Get the status of the Interrupt */
<> 144:ef7eb2e8f9f7 396 if(__HAL_RTC_SECOND_GET_FLAG(hrtc, RTC_FLAG_SEC))
<> 144:ef7eb2e8f9f7 397 {
<> 144:ef7eb2e8f9f7 398 /* Check if Overrun occurred */
<> 144:ef7eb2e8f9f7 399 if (__HAL_RTC_SECOND_GET_FLAG(hrtc, RTC_FLAG_OW))
<> 144:ef7eb2e8f9f7 400 {
<> 144:ef7eb2e8f9f7 401 /* Second error callback */
<> 144:ef7eb2e8f9f7 402 HAL_RTCEx_RTCEventErrorCallback(hrtc);
<> 144:ef7eb2e8f9f7 403
<> 144:ef7eb2e8f9f7 404 /* Clear flag Second */
<> 144:ef7eb2e8f9f7 405 __HAL_RTC_OVERFLOW_CLEAR_FLAG(hrtc, RTC_FLAG_OW);
<> 144:ef7eb2e8f9f7 406
<> 144:ef7eb2e8f9f7 407 /* Change RTC state */
<> 144:ef7eb2e8f9f7 408 hrtc->State = HAL_RTC_STATE_ERROR;
<> 144:ef7eb2e8f9f7 409 }
<> 144:ef7eb2e8f9f7 410 else
<> 144:ef7eb2e8f9f7 411 {
<> 144:ef7eb2e8f9f7 412 /* Second callback */
<> 144:ef7eb2e8f9f7 413 HAL_RTCEx_RTCEventCallback(hrtc);
<> 144:ef7eb2e8f9f7 414
<> 144:ef7eb2e8f9f7 415 /* Change RTC state */
<> 144:ef7eb2e8f9f7 416 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 417 }
<> 144:ef7eb2e8f9f7 418
<> 144:ef7eb2e8f9f7 419 /* Clear flag Second */
<> 144:ef7eb2e8f9f7 420 __HAL_RTC_SECOND_CLEAR_FLAG(hrtc, RTC_FLAG_SEC);
<> 144:ef7eb2e8f9f7 421 }
<> 144:ef7eb2e8f9f7 422 }
<> 144:ef7eb2e8f9f7 423 }
<> 144:ef7eb2e8f9f7 424
<> 144:ef7eb2e8f9f7 425 /**
<> 144:ef7eb2e8f9f7 426 * @brief Second event callback.
<> 144:ef7eb2e8f9f7 427 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 428 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 429 * @retval None
<> 144:ef7eb2e8f9f7 430 */
<> 144:ef7eb2e8f9f7 431 __weak void HAL_RTCEx_RTCEventCallback(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 432 {
<> 144:ef7eb2e8f9f7 433 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 434 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 435 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 436 the HAL_RTCEx_RTCEventCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 437 */
<> 144:ef7eb2e8f9f7 438 }
<> 144:ef7eb2e8f9f7 439
<> 144:ef7eb2e8f9f7 440 /**
<> 144:ef7eb2e8f9f7 441 * @brief Second event error callback.
<> 144:ef7eb2e8f9f7 442 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 443 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 444 * @retval None
<> 144:ef7eb2e8f9f7 445 */
<> 144:ef7eb2e8f9f7 446 __weak void HAL_RTCEx_RTCEventErrorCallback(RTC_HandleTypeDef *hrtc)
<> 144:ef7eb2e8f9f7 447 {
<> 144:ef7eb2e8f9f7 448 /* Prevent unused argument(s) compilation warning */
<> 144:ef7eb2e8f9f7 449 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 450 /* NOTE : This function Should not be modified, when the callback is needed,
<> 144:ef7eb2e8f9f7 451 the HAL_RTCEx_RTCEventErrorCallback could be implemented in the user file
<> 144:ef7eb2e8f9f7 452 */
<> 144:ef7eb2e8f9f7 453 }
<> 144:ef7eb2e8f9f7 454
<> 144:ef7eb2e8f9f7 455 /**
<> 144:ef7eb2e8f9f7 456 * @}
<> 144:ef7eb2e8f9f7 457 */
<> 144:ef7eb2e8f9f7 458
<> 144:ef7eb2e8f9f7 459 /** @defgroup RTCEx_Exported_Functions_Group3 Extended Peripheral Control functions
<> 144:ef7eb2e8f9f7 460 * @brief Extended Peripheral Control functions
<> 144:ef7eb2e8f9f7 461 *
<> 144:ef7eb2e8f9f7 462 @verbatim
<> 144:ef7eb2e8f9f7 463 ===============================================================================
<> 144:ef7eb2e8f9f7 464 ##### Extension Peripheral Control functions #####
<> 144:ef7eb2e8f9f7 465 ===============================================================================
<> 144:ef7eb2e8f9f7 466 [..]
<> 144:ef7eb2e8f9f7 467 This subsection provides functions allowing to
<> 144:ef7eb2e8f9f7 468 (+) Writes a data in a specified RTC Backup data register
<> 144:ef7eb2e8f9f7 469 (+) Read a data in a specified RTC Backup data register
<> 144:ef7eb2e8f9f7 470 (+) Sets the Smooth calibration parameters.
<> 144:ef7eb2e8f9f7 471
<> 144:ef7eb2e8f9f7 472 @endverbatim
<> 144:ef7eb2e8f9f7 473 * @{
<> 144:ef7eb2e8f9f7 474 */
<> 144:ef7eb2e8f9f7 475
<> 144:ef7eb2e8f9f7 476 /**
<> 144:ef7eb2e8f9f7 477 * @brief Writes a data in a specified RTC Backup data register.
<> 144:ef7eb2e8f9f7 478 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 479 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 480 * @param BackupRegister: RTC Backup data Register number.
<> 144:ef7eb2e8f9f7 481 * This parameter can be: RTC_BKP_DRx where x can be from 1 to 10 (or 42) to
<> 144:ef7eb2e8f9f7 482 * specify the register (depending devices).
<> 144:ef7eb2e8f9f7 483 * @param Data: Data to be written in the specified RTC Backup data register.
<> 144:ef7eb2e8f9f7 484 * @retval None
<> 144:ef7eb2e8f9f7 485 */
<> 144:ef7eb2e8f9f7 486 void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)
<> 144:ef7eb2e8f9f7 487 {
AnnaBridge 165:e614a9f1c9e2 488 uint32_t tmp = 0U;
AnnaBridge 165:e614a9f1c9e2 489
AnnaBridge 165:e614a9f1c9e2 490 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 491 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 492
<> 144:ef7eb2e8f9f7 493 /* Check the parameters */
<> 144:ef7eb2e8f9f7 494 assert_param(IS_RTC_BKP(BackupRegister));
<> 144:ef7eb2e8f9f7 495
<> 144:ef7eb2e8f9f7 496 tmp = (uint32_t)BKP_BASE;
AnnaBridge 165:e614a9f1c9e2 497 tmp += (BackupRegister * 4U);
<> 144:ef7eb2e8f9f7 498
<> 144:ef7eb2e8f9f7 499 *(__IO uint32_t *) tmp = (Data & BKP_DR1_D);
<> 144:ef7eb2e8f9f7 500 }
<> 144:ef7eb2e8f9f7 501
<> 144:ef7eb2e8f9f7 502 /**
<> 144:ef7eb2e8f9f7 503 * @brief Reads data from the specified RTC Backup data Register.
<> 144:ef7eb2e8f9f7 504 * @param hrtc: pointer to a RTC_HandleTypeDef structure that contains
<> 144:ef7eb2e8f9f7 505 * the configuration information for RTC.
<> 144:ef7eb2e8f9f7 506 * @param BackupRegister: RTC Backup data Register number.
<> 144:ef7eb2e8f9f7 507 * This parameter can be: RTC_BKP_DRx where x can be from 1 to 10 (or 42) to
<> 144:ef7eb2e8f9f7 508 * specify the register (depending devices).
<> 144:ef7eb2e8f9f7 509 * @retval Read value
<> 144:ef7eb2e8f9f7 510 */
<> 144:ef7eb2e8f9f7 511 uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)
<> 144:ef7eb2e8f9f7 512 {
AnnaBridge 165:e614a9f1c9e2 513 uint32_t backupregister = 0U;
AnnaBridge 165:e614a9f1c9e2 514 uint32_t pvalue = 0U;
AnnaBridge 165:e614a9f1c9e2 515
AnnaBridge 165:e614a9f1c9e2 516 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 517 UNUSED(hrtc);
<> 144:ef7eb2e8f9f7 518
<> 144:ef7eb2e8f9f7 519 /* Check the parameters */
<> 144:ef7eb2e8f9f7 520 assert_param(IS_RTC_BKP(BackupRegister));
<> 144:ef7eb2e8f9f7 521
<> 144:ef7eb2e8f9f7 522 backupregister = (uint32_t)BKP_BASE;
AnnaBridge 165:e614a9f1c9e2 523 backupregister += (BackupRegister * 4U);
<> 144:ef7eb2e8f9f7 524
<> 144:ef7eb2e8f9f7 525 pvalue = (*(__IO uint32_t *)(backupregister)) & BKP_DR1_D;
<> 144:ef7eb2e8f9f7 526
<> 144:ef7eb2e8f9f7 527 /* Read the specified register */
<> 144:ef7eb2e8f9f7 528 return pvalue;
<> 144:ef7eb2e8f9f7 529 }
<> 144:ef7eb2e8f9f7 530
<> 144:ef7eb2e8f9f7 531
<> 144:ef7eb2e8f9f7 532 /**
<> 144:ef7eb2e8f9f7 533 * @brief Sets the Smooth calibration parameters.
<> 144:ef7eb2e8f9f7 534 * @param hrtc: RTC handle
<> 144:ef7eb2e8f9f7 535 * @param SmoothCalibPeriod: Not used (only present for compatibility with another families)
<> 144:ef7eb2e8f9f7 536 * @param SmoothCalibPlusPulses: Not used (only present for compatibility with another families)
<> 144:ef7eb2e8f9f7 537 * @param SmouthCalibMinusPulsesValue: specifies the RTC Clock Calibration value.
<> 144:ef7eb2e8f9f7 538 * This parameter must be a number between 0 and 0x7F.
<> 144:ef7eb2e8f9f7 539 * @retval HAL status
<> 144:ef7eb2e8f9f7 540 */
<> 144:ef7eb2e8f9f7 541 HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmouthCalibMinusPulsesValue)
<> 144:ef7eb2e8f9f7 542 {
<> 144:ef7eb2e8f9f7 543 /* Check input parameters */
<> 144:ef7eb2e8f9f7 544 if(hrtc == NULL)
<> 144:ef7eb2e8f9f7 545 {
<> 144:ef7eb2e8f9f7 546 return HAL_ERROR;
<> 144:ef7eb2e8f9f7 547 }
AnnaBridge 165:e614a9f1c9e2 548 /* Prevent unused argument(s) compilation warning */
AnnaBridge 165:e614a9f1c9e2 549 UNUSED(SmoothCalibPeriod);
AnnaBridge 165:e614a9f1c9e2 550 UNUSED(SmoothCalibPlusPulses);
AnnaBridge 165:e614a9f1c9e2 551
<> 144:ef7eb2e8f9f7 552 /* Check the parameters */
<> 144:ef7eb2e8f9f7 553 assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmouthCalibMinusPulsesValue));
<> 144:ef7eb2e8f9f7 554
<> 144:ef7eb2e8f9f7 555 /* Process Locked */
<> 144:ef7eb2e8f9f7 556 __HAL_LOCK(hrtc);
<> 144:ef7eb2e8f9f7 557
<> 144:ef7eb2e8f9f7 558 hrtc->State = HAL_RTC_STATE_BUSY;
<> 144:ef7eb2e8f9f7 559
<> 144:ef7eb2e8f9f7 560 /* Sets RTC Clock Calibration value.*/
<> 144:ef7eb2e8f9f7 561 MODIFY_REG(BKP->RTCCR, BKP_RTCCR_CAL, SmouthCalibMinusPulsesValue);
<> 144:ef7eb2e8f9f7 562
<> 144:ef7eb2e8f9f7 563 /* Change RTC state */
<> 144:ef7eb2e8f9f7 564 hrtc->State = HAL_RTC_STATE_READY;
<> 144:ef7eb2e8f9f7 565
<> 144:ef7eb2e8f9f7 566 /* Process Unlocked */
<> 144:ef7eb2e8f9f7 567 __HAL_UNLOCK(hrtc);
<> 144:ef7eb2e8f9f7 568
<> 144:ef7eb2e8f9f7 569 return HAL_OK;
<> 144:ef7eb2e8f9f7 570 }
<> 144:ef7eb2e8f9f7 571
<> 144:ef7eb2e8f9f7 572 /**
<> 144:ef7eb2e8f9f7 573 * @}
<> 144:ef7eb2e8f9f7 574 */
<> 144:ef7eb2e8f9f7 575
<> 144:ef7eb2e8f9f7 576 /**
<> 144:ef7eb2e8f9f7 577 * @}
<> 144:ef7eb2e8f9f7 578 */
<> 144:ef7eb2e8f9f7 579
<> 144:ef7eb2e8f9f7 580 /**
<> 144:ef7eb2e8f9f7 581 * @}
<> 144:ef7eb2e8f9f7 582 */
<> 144:ef7eb2e8f9f7 583
<> 144:ef7eb2e8f9f7 584 #endif /* HAL_RTC_MODULE_ENABLED */
<> 144:ef7eb2e8f9f7 585
<> 144:ef7eb2e8f9f7 586 /**
<> 144:ef7eb2e8f9f7 587 * @}
<> 144:ef7eb2e8f9f7 588 */
<> 144:ef7eb2e8f9f7 589
<> 144:ef7eb2e8f9f7 590 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
<> 144:ef7eb2e8f9f7 591