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