git.sur5r.net Git - freertos/blob - FreeRTOS/Demo/CORTEX_M7_STM32F7_STM32756G-EVAL_IAR_Keil/ST_Library/stm32f7xx_hal_rtc_ex.c

   1 /**\r
   2   ******************************************************************************\r
   3   * @file    stm32f7xx_hal_rtc_ex.c\r
   4   * @author  MCD Application Team\r
   5   * @version V1.0.0RC1\r
   6   * @date    24-March-2015\r
   7   * @brief   RTC HAL module driver.\r
   8   *          This file provides firmware functions to manage the following \r
   9   *          functionalities of the Real Time Clock (RTC) Extension peripheral:\r
  10   *           + RTC Time Stamp functions\r
  11   *           + RTC Tamper functions \r
  12   *           + RTC Wake-up functions\r
  13   *           + Extension Control functions\r
  14   *           + Extension RTC features functions    \r
  15   *         \r
  16   @verbatim\r
  17   ==============================================================================\r
  18                   ##### How to use this driver #####\r
  19   ==============================================================================\r
  20   [..] \r
  21     (+) Enable the RTC domain access.\r
  22     (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour \r
  23         format using the HAL_RTC_Init() function.\r
  24   \r
  25   *** RTC Wakeup configuration ***\r
  26   ================================\r
  27   [..] \r
  28     (+) To configure the RTC Wakeup Clock source and Counter use the HAL_RTC_SetWakeUpTimer()\r
  29         function. You can also configure the RTC Wakeup timer in interrupt mode \r
  30         using the HAL_RTC_SetWakeUpTimer_IT() function.\r
  31     (+) To read the RTC WakeUp Counter register, use the HAL_RTC_GetWakeUpTimer() \r
  32         function.\r
  33   \r
  34   *** TimeStamp configuration ***\r
  35   ===============================\r
  36   [..]\r
  37     (+) Enables the RTC TimeStamp using the HAL_RTC_SetTimeStamp() function.\r
  38         You can also configure the RTC TimeStamp with interrupt mode using the\r
  39         HAL_RTC_SetTimeStamp_IT() function.\r
  40     (+) To read the RTC TimeStamp Time and Date register, use the HAL_RTC_GetTimeStamp()\r
  41         function.\r
  42 \r
  43   *** Internal TimeStamp configuration ***\r
  44   ===============================\r
  45   [..]\r
  46     (+) Enables the RTC internal TimeStamp using the HAL_RTC_SetInternalTimeStamp() function.\r
  47     (+) To read the RTC TimeStamp Time and Date register, use the HAL_RTC_GetTimeStamp()\r
  48         function.\r
  49   \r
  50   *** Tamper configuration ***\r
  51   ============================\r
  52   [..]\r
  53     (+) Enable the RTC Tamper and Configure the Tamper filter count, trigger Edge \r
  54         or Level according to the Tamper filter (if equal to 0 Edge else Level) \r
  55         value, sampling frequency, NoErase, MaskFlag,  precharge or discharge and\r
  56         Pull-UP using the HAL_RTC_SetTamper() function. You can configure RTC Tamper\r
  57         with interrupt mode using HAL_RTC_SetTamper_IT() function.\r
  58     (+) The default configuration of the Tamper erases the backup registers. To avoid\r
  59         erase, enable the NoErase field on the RTC_TAMPCR register.\r
  60   \r
  61   *** Backup Data Registers configuration ***\r
  62   ===========================================\r
  63   [..]\r
  64     (+) To write to the RTC Backup Data registers, use the HAL_RTC_BKUPWrite()\r
  65         function.  \r
  66     (+) To read the RTC Backup Data registers, use the HAL_RTC_BKUPRead()\r
  67         function.\r
  68      \r
  69    @endverbatim\r
  70   ******************************************************************************\r
  71   * @attention\r
  72   *\r
  73   * <h2><center>&copy; COPYRIGHT(c) 2015 STMicroelectronics</center></h2>\r
  74   *\r
  75   * Redistribution and use in source and binary forms, with or without modification,\r
  76   * are permitted provided that the following conditions are met:\r
  77   *   1. Redistributions of source code must retain the above copyright notice,\r
  78   *      this list of conditions and the following disclaimer.\r
  79   *   2. Redistributions in binary form must reproduce the above copyright notice,\r
  80   *      this list of conditions and the following disclaimer in the documentation\r
  81   *      and/or other materials provided with the distribution.\r
  82   *   3. Neither the name of STMicroelectronics nor the names of its contributors\r
  83   *      may be used to endorse or promote products derived from this software\r
  84   *      without specific prior written permission.\r
  85   *\r
  86   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"\r
  87   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE\r
  88   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE\r
  89   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE\r
  90   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL\r
  91   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR\r
  92   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER\r
  93   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,\r
  94   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE\r
  95   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.\r
  96   *\r
  97   ******************************************************************************\r
  98   */ \r
  99 \r
 100 /* Includes ------------------------------------------------------------------*/\r
 101 #include "stm32f7xx_hal.h"\r
 102 \r
 103 /** @addtogroup STM32F7xx_HAL_Driver\r
 104   * @{\r
 105   */\r
 106 \r
 107 /** @defgroup RTCEx RTCEx \r
 108   * @brief RTC Extended HAL module driver\r
 109   * @{\r
 110   */\r
 111 \r
 112 #ifdef HAL_RTC_MODULE_ENABLED\r
 113 \r
 114 /* Private typedef -----------------------------------------------------------*/\r
 115 /* Private define ------------------------------------------------------------*/\r
 116 /* Private macro -------------------------------------------------------------*/\r
 117 /* Private variables ---------------------------------------------------------*/\r
 118 /* Private function prototypes -----------------------------------------------*/\r
 119 /* Private functions ---------------------------------------------------------*/\r
 120 \r
 121 /** @defgroup RTCEx_Exported_Functions RTC Extended Exported Functions\r
 122   * @{\r
 123   */\r
 124   \r
 125 \r
 126 /** @defgroup RTCEx_Group1 RTC TimeStamp and Tamper functions\r
 127  *  @brief   RTC TimeStamp and Tamper functions\r
 128  *\r
 129 @verbatim   \r
 130  ===============================================================================\r
 131                  ##### RTC TimeStamp and Tamper functions #####\r
 132  ===============================================================================  \r
 133  \r
 134  [..] This section provides functions allowing to configure TimeStamp feature\r
 135 \r
 136 @endverbatim\r
 137   * @{\r
 138   */\r
 139 \r
 140 /**\r
 141   * @brief  Sets TimeStamp.\r
 142   * @note   This API must be called before enabling the TimeStamp feature. \r
 143   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 144   *                the configuration information for RTC.\r
 145   * @param  TimeStampEdge: Specifies the pin edge on which the TimeStamp is \r
 146   *         activated.\r
 147   *          This parameter can be one of the following values:\r
 148   *             @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the  \r
 149   *                                        rising edge of the related pin.\r
 150   *             @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the \r
 151   *                                         falling edge of the related pin.\r
 152   * @param  RTC_TimeStampPin: specifies the RTC TimeStamp Pin.\r
 153   *          This parameter can be one of the following values:\r
 154   *             @arg RTC_TIMESTAMPPIN_PC13: PC13 is selected as RTC TimeStamp Pin.\r
 155   *             @arg RTC_TIMESTAMPPIN_PI8: PI8 is selected as RTC TimeStamp Pin.  \r
 156   *             @arg RTC_TIMESTAMPPIN_PC1: PC1 is selected as RTC TimeStamp Pin.   \r
 157   * @retval HAL status\r
 158   */\r
 159 HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge, uint32_t RTC_TimeStampPin)\r
 160 {\r
 161   uint32_t tmpreg = 0;\r
 162   \r
 163   /* Check the parameters */\r
 164   assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge));\r
 165   assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin));\r
 166   \r
 167   /* Process Locked */ \r
 168   __HAL_LOCK(hrtc);\r
 169   \r
 170   hrtc->State = HAL_RTC_STATE_BUSY;\r
 171   \r
 172   /* Get the RTC_CR register and clear the bits to be configured */\r
 173   tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));\r
 174     \r
 175   tmpreg|= TimeStampEdge;\r
 176   \r
 177   /* Disable the write protection for RTC registers */\r
 178   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
 179   \r
 180   hrtc->Instance->OR &= (uint32_t)~RTC_OR_TSINSEL;\r
 181   hrtc->Instance->OR |= (uint32_t)(RTC_TimeStampPin); \r
 182   \r
 183   /* Configure the Time Stamp TSEDGE and Enable bits */\r
 184   hrtc->Instance->CR = (uint32_t)tmpreg;\r
 185   \r
 186   __HAL_RTC_TIMESTAMP_ENABLE(hrtc);\r
 187   \r
 188   /* Enable the write protection for RTC registers */\r
 189   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);    \r
 190   \r
 191   /* Change RTC state */\r
 192   hrtc->State = HAL_RTC_STATE_READY; \r
 193   \r
 194   /* Process Unlocked */ \r
 195   __HAL_UNLOCK(hrtc);\r
 196   \r
 197   return HAL_OK;\r
 198 }\r
 199 \r
 200 /**\r
 201   * @brief  Sets TimeStamp with Interrupt. \r
 202   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 203   *                the configuration information for RTC.\r
 204   * @note   This API must be called before enabling the TimeStamp feature.\r
 205   * @param  TimeStampEdge: Specifies the pin edge on which the TimeStamp is \r
 206   *         activated.\r
 207   *          This parameter can be one of the following values:\r
 208   *             @arg RTC_TIMESTAMPEDGE_RISING: the Time stamp event occurs on the  \r
 209   *                                        rising edge of the related pin.\r
 210   *             @arg RTC_TIMESTAMPEDGE_FALLING: the Time stamp event occurs on the \r
 211   *                                         falling edge of the related pin.\r
 212   * @param  RTC_TimeStampPin: Specifies the RTC TimeStamp Pin.\r
 213   *          This parameter can be one of the following values:\r
 214   *             @arg RTC_TIMESTAMPPIN_PC13: PC13 is selected as RTC TimeStamp Pin.\r
 215   *             @arg RTC_TIMESTAMPPIN_PI8: PI8 is selected as RTC TimeStamp Pin.  \r
 216   *             @arg RTC_TIMESTAMPPIN_PC1: PC1 is selected as RTC TimeStamp Pin.   \r
 217   * @retval HAL status\r
 218   */\r
 219 HAL_StatusTypeDef HAL_RTCEx_SetTimeStamp_IT(RTC_HandleTypeDef *hrtc, uint32_t TimeStampEdge, uint32_t RTC_TimeStampPin)\r
 220 {\r
 221   uint32_t tmpreg = 0;\r
 222   \r
 223   /* Check the parameters */\r
 224   assert_param(IS_TIMESTAMP_EDGE(TimeStampEdge));\r
 225   assert_param(IS_RTC_TIMESTAMP_PIN(RTC_TimeStampPin));\r
 226   \r
 227   /* Process Locked */ \r
 228   __HAL_LOCK(hrtc);\r
 229   \r
 230   hrtc->State = HAL_RTC_STATE_BUSY;\r
 231   \r
 232   /* Get the RTC_CR register and clear the bits to be configured */\r
 233   tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));\r
 234   \r
 235   tmpreg |= TimeStampEdge;\r
 236   \r
 237   /* Disable the write protection for RTC registers */\r
 238   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
 239   \r
 240   /* Configure the Time Stamp TSEDGE and Enable bits */\r
 241   hrtc->Instance->CR = (uint32_t)tmpreg;\r
 242   \r
 243   hrtc->Instance->OR &= (uint32_t)~RTC_OR_TSINSEL;\r
 244   hrtc->Instance->OR |= (uint32_t)(RTC_TimeStampPin); \r
 245   \r
 246   __HAL_RTC_TIMESTAMP_ENABLE(hrtc);\r
 247   \r
 248   /* Enable IT timestamp */ \r
 249   __HAL_RTC_TIMESTAMP_ENABLE_IT(hrtc,RTC_IT_TS);\r
 250   \r
 251   /* RTC timestamp Interrupt Configuration: EXTI configuration */\r
 252   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT();\r
 253   \r
 254   EXTI->RTSR |= RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT;\r
 255   \r
 256   /* Enable the write protection for RTC registers */\r
 257   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);  \r
 258   \r
 259   hrtc->State = HAL_RTC_STATE_READY;  \r
 260   \r
 261   /* Process Unlocked */ \r
 262   __HAL_UNLOCK(hrtc);\r
 263   \r
 264   return HAL_OK;\r
 265 }\r
 266 \r
 267 /**\r
 268   * @brief  Deactivates TimeStamp. \r
 269   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 270   *                the configuration information for RTC.\r
 271   * @retval HAL status\r
 272   */\r
 273 HAL_StatusTypeDef HAL_RTCEx_DeactivateTimeStamp(RTC_HandleTypeDef *hrtc)\r
 274 {\r
 275   uint32_t tmpreg = 0;\r
 276   \r
 277   /* Process Locked */ \r
 278   __HAL_LOCK(hrtc);\r
 279   \r
 280   hrtc->State = HAL_RTC_STATE_BUSY;\r
 281   \r
 282   /* Disable the write protection for RTC registers */\r
 283   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
 284   \r
 285   /* In case of interrupt mode is used, the interrupt source must disabled */ \r
 286   __HAL_RTC_TIMESTAMP_DISABLE_IT(hrtc, RTC_IT_TS);\r
 287   \r
 288   /* Get the RTC_CR register and clear the bits to be configured */\r
 289   tmpreg = (uint32_t)(hrtc->Instance->CR & (uint32_t)~(RTC_CR_TSEDGE | RTC_CR_TSE));\r
 290   \r
 291   /* Configure the Time Stamp TSEDGE and Enable bits */\r
 292   hrtc->Instance->CR = (uint32_t)tmpreg;\r
 293   \r
 294   /* Enable the write protection for RTC registers */\r
 295   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
 296  \r
 297   hrtc->State = HAL_RTC_STATE_READY;  \r
 298   \r
 299   /* Process Unlocked */ \r
 300   __HAL_UNLOCK(hrtc);\r
 301   \r
 302   return HAL_OK;\r
 303 }\r
 304 \r
 305 /**\r
 306   * @brief  Sets Internal TimeStamp.\r
 307   * @note   This API must be called before enabling the internal TimeStamp feature.\r
 308   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 309   *                the configuration information for RTC.\r
 310   * @retval HAL status\r
 311   */\r
 312 HAL_StatusTypeDef HAL_RTCEx_SetInternalTimeStamp(RTC_HandleTypeDef *hrtc)\r
 313 {\r
 314   /* Process Locked */\r
 315   __HAL_LOCK(hrtc);\r
 316 \r
 317   hrtc->State = HAL_RTC_STATE_BUSY;\r
 318 \r
 319   /* Disable the write protection for RTC registers */\r
 320   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
 321 \r
 322   /* Configure the internal Time Stamp Enable bits */\r
 323   __HAL_RTC_INTERNAL_TIMESTAMP_ENABLE(hrtc);\r
 324 \r
 325   /* Enable the write protection for RTC registers */\r
 326   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
 327 \r
 328   /* Change RTC state */\r
 329   hrtc->State = HAL_RTC_STATE_READY;\r
 330 \r
 331   /* Process Unlocked */ \r
 332   __HAL_UNLOCK(hrtc);\r
 333 \r
 334   return HAL_OK;\r
 335 }\r
 336 \r
 337 /**\r
 338   * @brief  Deactivates internal TimeStamp.\r
 339   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 340   *                the configuration information for RTC.\r
 341   * @retval HAL status\r
 342   */\r
 343 HAL_StatusTypeDef HAL_RTCEx_DeactivateInternalTimeStamp(RTC_HandleTypeDef *hrtc)\r
 344 {\r
 345   /* Process Locked */\r
 346   __HAL_LOCK(hrtc);\r
 347 \r
 348   hrtc->State = HAL_RTC_STATE_BUSY;\r
 349 \r
 350   /* Disable the write protection for RTC registers */\r
 351   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
 352 \r
 353   /* Configure the internal Time Stamp Enable bits */\r
 354   __HAL_RTC_INTERNAL_TIMESTAMP_DISABLE(hrtc);\r
 355 \r
 356   /* Enable the write protection for RTC registers */\r
 357   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
 358 \r
 359   hrtc->State = HAL_RTC_STATE_READY;\r
 360 \r
 361   /* Process Unlocked */\r
 362   __HAL_UNLOCK(hrtc);\r
 363 \r
 364   return HAL_OK;\r
 365 }\r
 366 \r
 367 /**\r
 368   * @brief  Gets the RTC TimeStamp value.\r
 369   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 370   *                the configuration information for RTC.\r
 371   * @param  sTimeStamp: Pointer to Time structure\r
 372   * @param  sTimeStampDate: Pointer to Date structure  \r
 373   * @param  Format: specifies the format of the entered parameters.\r
 374   *          This parameter can be one of the following values:\r
 375   *             FORMAT_BIN: Binary data format \r
 376   *             FORMAT_BCD: BCD data format\r
 377   * @retval HAL status\r
 378   */\r
 379 HAL_StatusTypeDef HAL_RTCEx_GetTimeStamp(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef* sTimeStamp, RTC_DateTypeDef* sTimeStampDate, uint32_t Format)\r
 380 {\r
 381   uint32_t tmptime = 0, tmpdate = 0;\r
 382 \r
 383   /* Check the parameters */\r
 384   assert_param(IS_RTC_FORMAT(Format));\r
 385 \r
 386   /* Get the TimeStamp time and date registers values */\r
 387   tmptime = (uint32_t)(hrtc->Instance->TSTR & RTC_TR_RESERVED_MASK);\r
 388   tmpdate = (uint32_t)(hrtc->Instance->TSDR & RTC_DR_RESERVED_MASK);\r
 389 \r
 390   /* Fill the Time structure fields with the read parameters */\r
 391   sTimeStamp->Hours = (uint8_t)((tmptime & (RTC_TR_HT | RTC_TR_HU)) >> 16);\r
 392   sTimeStamp->Minutes = (uint8_t)((tmptime & (RTC_TR_MNT | RTC_TR_MNU)) >> 8);\r
 393   sTimeStamp->Seconds = (uint8_t)(tmptime & (RTC_TR_ST | RTC_TR_SU));\r
 394   sTimeStamp->TimeFormat = (uint8_t)((tmptime & (RTC_TR_PM)) >> 16);  \r
 395   sTimeStamp->SubSeconds = (uint32_t) hrtc->Instance->TSSSR;\r
 396   \r
 397   /* Fill the Date structure fields with the read parameters */\r
 398   sTimeStampDate->Year = 0;\r
 399   sTimeStampDate->Month = (uint8_t)((tmpdate & (RTC_DR_MT | RTC_DR_MU)) >> 8);\r
 400   sTimeStampDate->Date = (uint8_t)(tmpdate & (RTC_DR_DT | RTC_DR_DU));\r
 401   sTimeStampDate->WeekDay = (uint8_t)((tmpdate & (RTC_DR_WDU)) >> 13);\r
 402 \r
 403   /* Check the input parameters format */\r
 404   if(Format == RTC_FORMAT_BIN)\r
 405   {\r
 406     /* Convert the TimeStamp structure parameters to Binary format */\r
 407     sTimeStamp->Hours = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Hours);\r
 408     sTimeStamp->Minutes = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Minutes);\r
 409     sTimeStamp->Seconds = (uint8_t)RTC_Bcd2ToByte(sTimeStamp->Seconds);\r
 410     \r
 411     /* Convert the DateTimeStamp structure parameters to Binary format */\r
 412     sTimeStampDate->Month = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Month);\r
 413     sTimeStampDate->Date = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->Date);\r
 414     sTimeStampDate->WeekDay = (uint8_t)RTC_Bcd2ToByte(sTimeStampDate->WeekDay);\r
 415   }\r
 416   \r
 417   /* Clear the TIMESTAMP Flag */\r
 418   __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSF);\r
 419     \r
 420   return HAL_OK;\r
 421 }\r
 422 \r
 423 /**\r
 424   * @brief  Sets Tamper\r
 425   * @note   By calling this API we disable the tamper interrupt for all tampers. \r
 426   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 427   *                the configuration information for RTC.\r
 428   * @param  sTamper: Pointer to Tamper Structure.\r
 429   * @retval HAL status\r
 430   */\r
 431 HAL_StatusTypeDef HAL_RTCEx_SetTamper(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)\r
 432 {\r
 433   uint32_t tmpreg = 0;\r
 434   \r
 435   /* Check the parameters */\r
 436   assert_param(IS_RTC_TAMPER(sTamper->Tamper)); \r
 437   assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));\r
 438   assert_param(IS_RTC_TAMPER_ERASE_MODE(sTamper->NoErase));\r
 439   assert_param(IS_RTC_TAMPER_MASKFLAG_STATE(sTamper->MaskFlag));\r
 440   assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter));\r
 441   assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency));         \r
 442   assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration));\r
 443   assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp));\r
 444   assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection));\r
 445  \r
 446   /* Process Locked */ \r
 447   __HAL_LOCK(hrtc);\r
 448     \r
 449   hrtc->State = HAL_RTC_STATE_BUSY;\r
 450 \r
 451   if(sTamper->Trigger != RTC_TAMPERTRIGGER_RISINGEDGE)\r
 452   { \r
 453     sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1); \r
 454   } \r
 455   \r
 456   if(sTamper->NoErase != RTC_TAMPER_ERASE_BACKUP_ENABLE)\r
 457   { \r
 458     sTamper->NoErase = 0;\r
 459     if((sTamper->Tamper & RTC_TAMPER_1) != 0)\r
 460     {\r
 461       sTamper->NoErase |= RTC_TAMPCR_TAMP1NOERASE;\r
 462     }\r
 463     if((sTamper->Tamper & RTC_TAMPER_2) != 0)\r
 464     {\r
 465       sTamper->NoErase |= RTC_TAMPCR_TAMP2NOERASE;\r
 466     }\r
 467     if((sTamper->Tamper & RTC_TAMPER_3) != 0)\r
 468     {\r
 469       sTamper->NoErase |= RTC_TAMPCR_TAMP3NOERASE;\r
 470     }\r
 471   }\r
 472 \r
 473   if(sTamper->MaskFlag != RTC_TAMPERMASK_FLAG_DISABLE)\r
 474   {\r
 475     sTamper->MaskFlag = 0;\r
 476     if((sTamper->Tamper & RTC_TAMPER_1) != 0)\r
 477     {\r
 478       sTamper->MaskFlag |= RTC_TAMPCR_TAMP1MF;\r
 479     }\r
 480     if((sTamper->Tamper & RTC_TAMPER_2) != 0)\r
 481     {\r
 482       sTamper->MaskFlag |= RTC_TAMPCR_TAMP2MF;\r
 483     }\r
 484     if((sTamper->Tamper & RTC_TAMPER_3) != 0)\r
 485     {\r
 486       sTamper->MaskFlag |= RTC_TAMPCR_TAMP3MF;\r
 487     }\r
 488   }\r
 489   \r
 490   tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Trigger  | (uint32_t)sTamper->NoErase |\\r
 491             (uint32_t)sTamper->MaskFlag | (uint32_t)sTamper->Filter | (uint32_t)sTamper->SamplingFrequency |\\r
 492             (uint32_t)sTamper->PrechargeDuration | (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection);\r
 493 \r
 494   hrtc->Instance->TAMPCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (uint32_t)RTC_TAMPCR_TAMPTS |\\r
 495                                        (uint32_t)RTC_TAMPCR_TAMPFREQ | (uint32_t)RTC_TAMPCR_TAMPFLT | (uint32_t)RTC_TAMPCR_TAMPPRCH |\\r
 496                                        (uint32_t)RTC_TAMPCR_TAMPPUDIS | (uint32_t)RTC_TAMPCR_TAMPIE | (uint32_t)RTC_TAMPCR_TAMP1IE |\\r
 497                                        (uint32_t)RTC_TAMPCR_TAMP2IE | (uint32_t)RTC_TAMPCR_TAMP3IE | (uint32_t)RTC_TAMPCR_TAMP1NOERASE |\\r
 498                                        (uint32_t)RTC_TAMPCR_TAMP2NOERASE | (uint32_t)RTC_TAMPCR_TAMP3NOERASE | (uint32_t)RTC_TAMPCR_TAMP1MF |\\r
 499                                        (uint32_t)RTC_TAMPCR_TAMP2MF | (uint32_t)RTC_TAMPCR_TAMP3MF);\r
 500 \r
 501   hrtc->Instance->TAMPCR |= tmpreg;      \r
 502       \r
 503   hrtc->State = HAL_RTC_STATE_READY; \r
 504 \r
 505   /* Process Unlocked */ \r
 506   __HAL_UNLOCK(hrtc);\r
 507     \r
 508   return HAL_OK;\r
 509 }\r
 510 \r
 511 /**\r
 512   * @brief  Sets Tamper with interrupt.\r
 513   * @note   By calling this API we force the tamper interrupt for all tampers.\r
 514   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 515   *                the configuration information for RTC.\r
 516   * @param  sTamper: Pointer to RTC Tamper.\r
 517   * @retval HAL status\r
 518   */\r
 519 HAL_StatusTypeDef HAL_RTCEx_SetTamper_IT(RTC_HandleTypeDef *hrtc, RTC_TamperTypeDef* sTamper)\r
 520 {\r
 521   uint32_t tmpreg = 0;\r
 522   \r
 523   /* Check the parameters */\r
 524   assert_param(IS_RTC_TAMPER(sTamper->Tamper)); \r
 525   assert_param(IS_RTC_TAMPER_INTERRUPT(sTamper->Interrupt));\r
 526   assert_param(IS_RTC_TAMPER_TRIGGER(sTamper->Trigger));\r
 527   assert_param(IS_RTC_TAMPER_ERASE_MODE(sTamper->NoErase));\r
 528   assert_param(IS_RTC_TAMPER_MASKFLAG_STATE(sTamper->MaskFlag));\r
 529   assert_param(IS_RTC_TAMPER_FILTER(sTamper->Filter));\r
 530   assert_param(IS_RTC_TAMPER_SAMPLING_FREQ(sTamper->SamplingFrequency));         \r
 531   assert_param(IS_RTC_TAMPER_PRECHARGE_DURATION(sTamper->PrechargeDuration));\r
 532   assert_param(IS_RTC_TAMPER_PULLUP_STATE(sTamper->TamperPullUp));\r
 533   assert_param(IS_RTC_TAMPER_TIMESTAMPONTAMPER_DETECTION(sTamper->TimeStampOnTamperDetection));\r
 534  \r
 535   /* Process Locked */ \r
 536   __HAL_LOCK(hrtc);\r
 537       \r
 538   hrtc->State = HAL_RTC_STATE_BUSY;\r
 539   \r
 540   /* Configure the tamper trigger */\r
 541   if(sTamper->Trigger != RTC_TAMPERTRIGGER_RISINGEDGE)\r
 542   { \r
 543     sTamper->Trigger = (uint32_t)(sTamper->Tamper << 1); \r
 544   } \r
 545   \r
 546   if(sTamper->NoErase != RTC_TAMPER_ERASE_BACKUP_ENABLE)\r
 547   { \r
 548     sTamper->NoErase = 0;\r
 549     if((sTamper->Tamper & RTC_TAMPER_1) != 0)\r
 550     {\r
 551       sTamper->NoErase |= RTC_TAMPCR_TAMP1NOERASE;\r
 552     }\r
 553     if((sTamper->Tamper & RTC_TAMPER_2) != 0)\r
 554     {\r
 555       sTamper->NoErase |= RTC_TAMPCR_TAMP2NOERASE;\r
 556     }\r
 557     if((sTamper->Tamper & RTC_TAMPER_3) != 0)\r
 558     {\r
 559       sTamper->NoErase |= RTC_TAMPCR_TAMP3NOERASE;\r
 560     }\r
 561   }\r
 562 \r
 563   if(sTamper->MaskFlag != RTC_TAMPERMASK_FLAG_DISABLE)\r
 564   {\r
 565     sTamper->MaskFlag = 0;\r
 566     if((sTamper->Tamper & RTC_TAMPER_1) != 0)\r
 567     {\r
 568       sTamper->MaskFlag |= RTC_TAMPCR_TAMP1MF;\r
 569     }\r
 570     if((sTamper->Tamper & RTC_TAMPER_2) != 0)\r
 571     {\r
 572       sTamper->MaskFlag |= RTC_TAMPCR_TAMP2MF;\r
 573     }\r
 574     if((sTamper->Tamper & RTC_TAMPER_3) != 0)\r
 575     {\r
 576       sTamper->MaskFlag |= RTC_TAMPCR_TAMP3MF;\r
 577     }\r
 578   }\r
 579   \r
 580   tmpreg = ((uint32_t)sTamper->Tamper | (uint32_t)sTamper->Interrupt | (uint32_t)sTamper->Trigger  | (uint32_t)sTamper->NoErase |\\r
 581             (uint32_t)sTamper->MaskFlag | (uint32_t)sTamper->Filter | (uint32_t)sTamper->SamplingFrequency |\\r
 582             (uint32_t)sTamper->PrechargeDuration | (uint32_t)sTamper->TamperPullUp | sTamper->TimeStampOnTamperDetection);\r
 583   \r
 584   hrtc->Instance->TAMPCR &= (uint32_t)~((uint32_t)sTamper->Tamper | (uint32_t)(sTamper->Tamper << 1) | (uint32_t)RTC_TAMPCR_TAMPTS |\\r
 585                                        (uint32_t)RTC_TAMPCR_TAMPFREQ | (uint32_t)RTC_TAMPCR_TAMPFLT | (uint32_t)RTC_TAMPCR_TAMPPRCH |\\r
 586                                        (uint32_t)RTC_TAMPCR_TAMPPUDIS | (uint32_t)RTC_TAMPCR_TAMPIE | (uint32_t)RTC_TAMPCR_TAMP1IE |\\r
 587                                        (uint32_t)RTC_TAMPCR_TAMP2IE | (uint32_t)RTC_TAMPCR_TAMP3IE | (uint32_t)RTC_TAMPCR_TAMP1NOERASE |\\r
 588                                        (uint32_t)RTC_TAMPCR_TAMP2NOERASE | (uint32_t)RTC_TAMPCR_TAMP3NOERASE | (uint32_t)RTC_TAMPCR_TAMP1MF |\\r
 589                                        (uint32_t)RTC_TAMPCR_TAMP2MF | (uint32_t)RTC_TAMPCR_TAMP3MF);\r
 590 \r
 591   hrtc->Instance->TAMPCR |= tmpreg;\r
 592 \r
 593   /* RTC Tamper Interrupt Configuration: EXTI configuration */\r
 594   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_ENABLE_IT();\r
 595 \r
 596   EXTI->RTSR |= RTC_EXTI_LINE_TAMPER_TIMESTAMP_EVENT;\r
 597   \r
 598   hrtc->State = HAL_RTC_STATE_READY;   \r
 599   \r
 600   /* Process Unlocked */ \r
 601   __HAL_UNLOCK(hrtc);\r
 602   \r
 603   return HAL_OK;\r
 604 }\r
 605 \r
 606 /**\r
 607   * @brief  Deactivates Tamper.\r
 608   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 609   *                the configuration information for RTC.\r
 610   * @param  Tamper: Selected tamper pin.\r
 611   *          This parameter can be RTC_Tamper_1 and/or RTC_TAMPER_2.\r
 612   * @retval HAL status\r
 613   */\r
 614 HAL_StatusTypeDef HAL_RTCEx_DeactivateTamper(RTC_HandleTypeDef *hrtc, uint32_t Tamper)\r
 615 {\r
 616   assert_param(IS_RTC_TAMPER(Tamper)); \r
 617   \r
 618   /* Process Locked */ \r
 619   __HAL_LOCK(hrtc);\r
 620       \r
 621   hrtc->State = HAL_RTC_STATE_BUSY;\r
 622   \r
 623 /* Disable the selected Tamper pin */\r
 624   hrtc->Instance->TAMPCR &= (uint32_t)~Tamper;\r
 625 \r
 626   if ((Tamper & RTC_TAMPER_1) != 0)\r
 627   {\r
 628     /* Disable the Tamper1 interrupt */\r
 629     hrtc->Instance->TAMPCR &= (uint32_t)~(RTC_IT_TAMP | RTC_IT_TAMP1);\r
 630   }\r
 631   if ((Tamper & RTC_TAMPER_2) != 0)\r
 632   {\r
 633     /* Disable the Tamper2 interrupt */\r
 634     hrtc->Instance->TAMPCR &= (uint32_t)~(RTC_IT_TAMP | RTC_IT_TAMP2);\r
 635   }\r
 636   if ((Tamper & RTC_TAMPER_3) != 0)\r
 637   {\r
 638     /* Disable the Tamper2 interrupt */\r
 639     hrtc->Instance->TAMPCR &= (uint32_t)~(RTC_IT_TAMP | RTC_IT_TAMP3);\r
 640   } \r
 641   \r
 642   hrtc->State = HAL_RTC_STATE_READY;   \r
 643   \r
 644   /* Process Unlocked */  \r
 645   __HAL_UNLOCK(hrtc);\r
 646   \r
 647   return HAL_OK; \r
 648 }\r
 649 \r
 650 /**\r
 651   * @brief  This function handles TimeStamp interrupt request.\r
 652   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 653   *                the configuration information for RTC.\r
 654   * @retval None\r
 655   */\r
 656 void HAL_RTCEx_TamperTimeStampIRQHandler(RTC_HandleTypeDef *hrtc)\r
 657 {  \r
 658   if(__HAL_RTC_TIMESTAMP_GET_IT(hrtc, RTC_IT_TS))\r
 659   {\r
 660     /* Get the status of the Interrupt */\r
 661     if((uint32_t)(hrtc->Instance->CR & RTC_IT_TS) != (uint32_t)RESET)\r
 662     {\r
 663        /* TIMESTAMP callback */ \r
 664         HAL_RTCEx_TimeStampEventCallback(hrtc);\r
 665 \r
 666       /* Clear the TIMESTAMP interrupt pending bit */\r
 667       __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc,RTC_FLAG_TSF);\r
 668     }\r
 669   }\r
 670 \r
 671   /* Get the status of the Interrupt */\r
 672   if(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F)== SET)\r
 673   {\r
 674     /* Get the TAMPER Interrupt enable bit and pending bit */\r
 675     if((((hrtc->Instance->TAMPCR & RTC_TAMPCR_TAMPIE)) != (uint32_t)RESET) || \\r
 676        (((hrtc->Instance->TAMPCR & RTC_TAMPCR_TAMP1IE)) != (uint32_t)RESET))\r
 677     {\r
 678       /* Tamper callback */\r
 679       HAL_RTCEx_Tamper1EventCallback(hrtc);\r
 680 \r
 681       /* Clear the Tamper interrupt pending bit */\r
 682       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);\r
 683     }\r
 684   }\r
 685 \r
 686   /* Get the status of the Interrupt */\r
 687   if(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP2F)== SET)\r
 688   {\r
 689     /* Get the TAMPER Interrupt enable bit and pending bit */\r
 690     if((((hrtc->Instance->TAMPCR & RTC_TAMPCR_TAMPIE)) != (uint32_t)RESET) || \\r
 691        (((hrtc->Instance->TAMPCR & RTC_TAMPCR_TAMP2IE)) != (uint32_t)RESET))\r
 692     {\r
 693       /* Tamper callback */\r
 694       HAL_RTCEx_Tamper2EventCallback(hrtc);\r
 695 \r
 696       /* Clear the Tamper interrupt pending bit */\r
 697       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP2F);\r
 698     }\r
 699   }\r
 700 \r
 701   /* Get the status of the Interrupt */\r
 702   if(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP3F)== SET)\r
 703   {\r
 704     /* Get the TAMPER Interrupt enable bit and pending bit */\r
 705     if((((hrtc->Instance->TAMPCR & RTC_TAMPCR_TAMPIE)) != (uint32_t)RESET) || \\r
 706        (((hrtc->Instance->TAMPCR & RTC_TAMPCR_TAMP3IE)) != (uint32_t)RESET))\r
 707     {\r
 708       /* Tamper callback */\r
 709       HAL_RTCEx_Tamper3EventCallback(hrtc);\r
 710 \r
 711       /* Clear the Tamper interrupt pending bit */\r
 712       __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc, RTC_FLAG_TAMP3F);\r
 713     }\r
 714   }\r
 715   \r
 716   /* Clear the EXTI's Flag for RTC TimeStamp and Tamper */\r
 717   __HAL_RTC_TAMPER_TIMESTAMP_EXTI_CLEAR_FLAG();\r
 718 \r
 719   /* Change RTC state */\r
 720   hrtc->State = HAL_RTC_STATE_READY;\r
 721 }\r
 722 \r
 723 /**\r
 724   * @brief  TimeStamp callback. \r
 725   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 726   *                the configuration information for RTC.\r
 727   * @retval None\r
 728   */\r
 729 __weak void HAL_RTCEx_TimeStampEventCallback(RTC_HandleTypeDef *hrtc)\r
 730 {\r
 731   /* NOTE : This function Should not be modified, when the callback is needed,\r
 732             the HAL_RTC_TimeStampEventCallback could be implemented in the user file\r
 733   */\r
 734 }\r
 735 \r
 736 /**\r
 737   * @brief  Tamper 1 callback. \r
 738   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 739   *                the configuration information for RTC.\r
 740   * @retval None\r
 741   */\r
 742 __weak void HAL_RTCEx_Tamper1EventCallback(RTC_HandleTypeDef *hrtc)\r
 743 {\r
 744   /* NOTE : This function Should not be modified, when the callback is needed,\r
 745             the HAL_RTC_Tamper1EventCallback could be implemented in the user file\r
 746    */\r
 747 }\r
 748 \r
 749 /**\r
 750   * @brief  Tamper 2 callback. \r
 751   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 752   *                the configuration information for RTC.\r
 753   * @retval None\r
 754   */\r
 755 __weak void HAL_RTCEx_Tamper2EventCallback(RTC_HandleTypeDef *hrtc)\r
 756 {\r
 757   /* NOTE : This function Should not be modified, when the callback is needed,\r
 758             the HAL_RTC_Tamper2EventCallback could be implemented in the user file\r
 759    */\r
 760 }\r
 761 \r
 762 /**\r
 763   * @brief  Tamper 3 callback. \r
 764   * @param  hrtc: RTC handle\r
 765   * @retval None\r
 766   */\r
 767 __weak void HAL_RTCEx_Tamper3EventCallback(RTC_HandleTypeDef *hrtc)\r
 768 {\r
 769   /* NOTE : This function Should not be modified, when the callback is needed,\r
 770             the HAL_RTCEx_Tamper3EventCallback could be implemented in the user file\r
 771    */\r
 772 }\r
 773 \r
 774 /**\r
 775   * @brief  This function handles TimeStamp polling request.\r
 776   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 777   *                the configuration information for RTC.\r
 778   * @param  Timeout: Timeout duration\r
 779   * @retval HAL status\r
 780   */\r
 781 HAL_StatusTypeDef HAL_RTCEx_PollForTimeStampEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)\r
 782 { \r
 783   uint32_t tickstart = 0; \r
 784 \r
 785   /* Get tick */\r
 786   tickstart = HAL_GetTick();\r
 787 \r
 788   while(__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSF) == RESET)\r
 789   {             \r
 790     if(Timeout != HAL_MAX_DELAY)\r
 791     {\r
 792       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 793       {\r
 794         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
 795         return HAL_TIMEOUT;\r
 796       }\r
 797     }\r
 798   }\r
 799         \r
 800   if(__HAL_RTC_TIMESTAMP_GET_FLAG(hrtc, RTC_FLAG_TSOVF) != RESET)\r
 801   {\r
 802     /* Clear the TIMESTAMP OverRun Flag */\r
 803     __HAL_RTC_TIMESTAMP_CLEAR_FLAG(hrtc, RTC_FLAG_TSOVF);\r
 804       \r
 805     /* Change TIMESTAMP state */\r
 806     hrtc->State = HAL_RTC_STATE_ERROR; \r
 807       \r
 808     return HAL_ERROR; \r
 809    }\r
 810         \r
 811   /* Change RTC state */\r
 812   hrtc->State = HAL_RTC_STATE_READY; \r
 813   \r
 814   return HAL_OK; \r
 815 }\r
 816   \r
 817 /**\r
 818   * @brief  This function handles Tamper1 Polling.\r
 819   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 820   *                the configuration information for RTC.\r
 821   * @param  Timeout: Timeout duration\r
 822   * @retval HAL status\r
 823   */\r
 824 HAL_StatusTypeDef HAL_RTCEx_PollForTamper1Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)\r
 825 {  \r
 826   uint32_t tickstart = 0; \r
 827 \r
 828   /* Get tick */\r
 829   tickstart = HAL_GetTick();\r
 830   \r
 831   /* Get the status of the Interrupt */\r
 832   while(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP1F)== RESET)\r
 833   {\r
 834     if(Timeout != HAL_MAX_DELAY)\r
 835     {\r
 836       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 837       {\r
 838         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
 839         return HAL_TIMEOUT;\r
 840       }\r
 841     }\r
 842   }\r
 843   \r
 844   /* Clear the Tamper Flag */\r
 845   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP1F);\r
 846   \r
 847   /* Change RTC state */\r
 848   hrtc->State = HAL_RTC_STATE_READY;\r
 849   \r
 850   return HAL_OK; \r
 851 }\r
 852 \r
 853 /**\r
 854   * @brief  This function handles Tamper2 Polling.\r
 855   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 856   *                the configuration information for RTC.\r
 857   * @param  Timeout: Timeout duration\r
 858   * @retval HAL status\r
 859   */\r
 860 HAL_StatusTypeDef HAL_RTCEx_PollForTamper2Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)\r
 861 {  \r
 862   uint32_t tickstart = 0; \r
 863 \r
 864   /* Get tick */\r
 865   tickstart = HAL_GetTick();\r
 866   \r
 867   /* Get the status of the Interrupt */\r
 868   while(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP2F) == RESET)\r
 869   {\r
 870     if(Timeout != HAL_MAX_DELAY)\r
 871     {\r
 872       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 873       {\r
 874         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
 875         return HAL_TIMEOUT;\r
 876       }\r
 877     }\r
 878   }\r
 879   \r
 880   /* Clear the Tamper Flag */\r
 881   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP2F);\r
 882   \r
 883   /* Change RTC state */\r
 884   hrtc->State = HAL_RTC_STATE_READY;\r
 885   \r
 886   return HAL_OK;\r
 887 }\r
 888 \r
 889 /**\r
 890   * @brief  This function handles Tamper3 Polling.\r
 891   * @param  hrtc: RTC handle\r
 892   * @param  Timeout: Timeout duration\r
 893   * @retval HAL status\r
 894   */\r
 895 HAL_StatusTypeDef HAL_RTCEx_PollForTamper3Event(RTC_HandleTypeDef *hrtc, uint32_t Timeout)\r
 896 {\r
 897   uint32_t tickstart = HAL_GetTick();\r
 898 \r
 899   /* Get the status of the Interrupt */\r
 900   while(__HAL_RTC_TAMPER_GET_FLAG(hrtc, RTC_FLAG_TAMP3F) == RESET)\r
 901   {\r
 902     if(Timeout != HAL_MAX_DELAY)\r
 903     {\r
 904       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
 905       {\r
 906         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
 907         return HAL_TIMEOUT;\r
 908       }\r
 909     }\r
 910   }\r
 911 \r
 912   /* Clear the Tamper Flag */\r
 913   __HAL_RTC_TAMPER_CLEAR_FLAG(hrtc,RTC_FLAG_TAMP3F);\r
 914 \r
 915   /* Change RTC state */\r
 916   hrtc->State = HAL_RTC_STATE_READY;\r
 917 \r
 918   return HAL_OK;\r
 919 }\r
 920 \r
 921 /**\r
 922   * @}\r
 923   */\r
 924   \r
 925 /** @defgroup RTCEx_Group2 RTC Wake-up functions\r
 926  *  @brief   RTC Wake-up functions\r
 927  *\r
 928 @verbatim   \r
 929  ===============================================================================\r
 930                         ##### RTC Wake-up functions #####\r
 931  ===============================================================================  \r
 932  \r
 933  [..] This section provides functions allowing to configure Wake-up feature\r
 934 \r
 935 @endverbatim\r
 936   * @{\r
 937   */\r
 938 \r
 939 /**\r
 940   * @brief  Sets wake up timer. \r
 941   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
 942   *                the configuration information for RTC.\r
 943   * @param  WakeUpCounter: Wake up counter\r
 944   * @param  WakeUpClock: Wake up clock  \r
 945   * @retval HAL status\r
 946   */\r
 947 HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock)\r
 948 {\r
 949   uint32_t tickstart = 0;\r
 950 \r
 951   /* Check the parameters */\r
 952   assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock));\r
 953   assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter));\r
 954  \r
 955   /* Process Locked */ \r
 956   __HAL_LOCK(hrtc);\r
 957     \r
 958   hrtc->State = HAL_RTC_STATE_BUSY;\r
 959   \r
 960   /* Disable the write protection for RTC registers */\r
 961   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
 962   \r
 963   __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);\r
 964 \r
 965   /* Get tick */\r
 966   tickstart = HAL_GetTick();\r
 967 \r
 968   /* Wait till RTC WUTWF flag is set and if Time out is reached exit */\r
 969   while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)\r
 970   {\r
 971     if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)\r
 972     {\r
 973       /* Enable the write protection for RTC registers */\r
 974       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
 975       \r
 976       hrtc->State = HAL_RTC_STATE_TIMEOUT; \r
 977       \r
 978       /* Process Unlocked */ \r
 979       __HAL_UNLOCK(hrtc);\r
 980       \r
 981       return HAL_TIMEOUT;\r
 982     }  \r
 983   }\r
 984   \r
 985   /* Clear the Wakeup Timer clock source bits in CR register */\r
 986   hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;\r
 987   \r
 988   /* Configure the clock source */\r
 989   hrtc->Instance->CR |= (uint32_t)WakeUpClock;\r
 990   \r
 991   /* Configure the Wakeup Timer counter */\r
 992   hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;\r
 993   \r
 994    /* Enable the Wakeup Timer */\r
 995   __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);   \r
 996   \r
 997   /* Enable the write protection for RTC registers */\r
 998   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); \r
 999   \r
1000   hrtc->State = HAL_RTC_STATE_READY;   \r
1001   \r
1002   /* Process Unlocked */ \r
1003   __HAL_UNLOCK(hrtc);\r
1004   \r
1005   return HAL_OK;\r
1006 }\r
1007 \r
1008 /**\r
1009   * @brief  Sets wake up timer with interrupt\r
1010   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1011   *                the configuration information for RTC.\r
1012   * @param  WakeUpCounter: Wake up counter\r
1013   * @param  WakeUpClock: Wake up clock  \r
1014   * @retval HAL status\r
1015   */\r
1016 HAL_StatusTypeDef HAL_RTCEx_SetWakeUpTimer_IT(RTC_HandleTypeDef *hrtc, uint32_t WakeUpCounter, uint32_t WakeUpClock)\r
1017 {\r
1018   uint32_t tickstart = 0;\r
1019   \r
1020   /* Check the parameters */\r
1021   assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock));\r
1022   assert_param(IS_RTC_WAKEUP_COUNTER(WakeUpCounter));\r
1023   \r
1024   /* Process Locked */ \r
1025   __HAL_LOCK(hrtc);\r
1026   \r
1027   hrtc->State = HAL_RTC_STATE_BUSY;\r
1028   \r
1029   /* Disable the write protection for RTC registers */\r
1030   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1031   \r
1032   __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);\r
1033 \r
1034   /* Get tick */\r
1035   tickstart = HAL_GetTick();\r
1036 \r
1037   /* Wait till RTC WUTWF flag is set and if Time out is reached exit */\r
1038   while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)\r
1039   {\r
1040     if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)\r
1041     {\r
1042       /* Enable the write protection for RTC registers */\r
1043       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1044       \r
1045       hrtc->State = HAL_RTC_STATE_TIMEOUT; \r
1046       \r
1047       /* Process Unlocked */ \r
1048       __HAL_UNLOCK(hrtc);\r
1049       \r
1050       return HAL_TIMEOUT;\r
1051     }  \r
1052   }\r
1053   \r
1054   /* Configure the Wakeup Timer counter */\r
1055   hrtc->Instance->WUTR = (uint32_t)WakeUpCounter;\r
1056 \r
1057   /* Clear the Wakeup Timer clock source bits in CR register */\r
1058   hrtc->Instance->CR &= (uint32_t)~RTC_CR_WUCKSEL;\r
1059 \r
1060   /* Configure the clock source */\r
1061   hrtc->Instance->CR |= (uint32_t)WakeUpClock;\r
1062   \r
1063   /* RTC WakeUpTimer Interrupt Configuration: EXTI configuration */\r
1064   __HAL_RTC_WAKEUPTIMER_EXTI_ENABLE_IT();\r
1065   \r
1066   EXTI->RTSR |= RTC_EXTI_LINE_WAKEUPTIMER_EVENT;\r
1067   \r
1068   /* Configure the Interrupt in the RTC_CR register */\r
1069   __HAL_RTC_WAKEUPTIMER_ENABLE_IT(hrtc,RTC_IT_WUT);\r
1070   \r
1071   /* Enable the Wakeup Timer */\r
1072   __HAL_RTC_WAKEUPTIMER_ENABLE(hrtc);\r
1073     \r
1074   /* Enable the write protection for RTC registers */\r
1075   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); \r
1076   \r
1077   hrtc->State = HAL_RTC_STATE_READY;   \r
1078   \r
1079   /* Process Unlocked */ \r
1080   __HAL_UNLOCK(hrtc);\r
1081  \r
1082   return HAL_OK;\r
1083 }\r
1084 \r
1085 /**\r
1086   * @brief  Deactivates wake up timer counter.\r
1087   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1088   *                the configuration information for RTC. \r
1089   * @retval HAL status\r
1090   */\r
1091 uint32_t HAL_RTCEx_DeactivateWakeUpTimer(RTC_HandleTypeDef *hrtc)\r
1092 {\r
1093   uint32_t tickstart = 0;\r
1094   \r
1095   /* Process Locked */ \r
1096   __HAL_LOCK(hrtc);\r
1097   \r
1098   hrtc->State = HAL_RTC_STATE_BUSY;\r
1099   \r
1100   /* Disable the write protection for RTC registers */\r
1101   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1102   \r
1103   /* Disable the Wakeup Timer */\r
1104   __HAL_RTC_WAKEUPTIMER_DISABLE(hrtc);\r
1105   \r
1106   /* In case of interrupt mode is used, the interrupt source must disabled */ \r
1107   __HAL_RTC_WAKEUPTIMER_DISABLE_IT(hrtc,RTC_IT_WUT);\r
1108 \r
1109   /* Get tick */\r
1110   tickstart = HAL_GetTick();\r
1111 \r
1112   /* Wait till RTC WUTWF flag is set and if Time out is reached exit */\r
1113   while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTWF) == RESET)\r
1114   {\r
1115     if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)\r
1116     {\r
1117       /* Enable the write protection for RTC registers */\r
1118       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1119       \r
1120       hrtc->State = HAL_RTC_STATE_TIMEOUT; \r
1121       \r
1122       /* Process Unlocked */ \r
1123       __HAL_UNLOCK(hrtc);\r
1124       \r
1125       return HAL_TIMEOUT;\r
1126     }   \r
1127   }\r
1128   \r
1129   /* Enable the write protection for RTC registers */\r
1130   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1131   \r
1132   hrtc->State = HAL_RTC_STATE_READY;   \r
1133   \r
1134   /* Process Unlocked */ \r
1135   __HAL_UNLOCK(hrtc);\r
1136   \r
1137   return HAL_OK;\r
1138 }\r
1139 \r
1140 /**\r
1141   * @brief  Gets wake up timer counter.\r
1142   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1143   *                the configuration information for RTC. \r
1144   * @retval Counter value\r
1145   */\r
1146 uint32_t HAL_RTCEx_GetWakeUpTimer(RTC_HandleTypeDef *hrtc)\r
1147 {\r
1148   /* Get the counter value */\r
1149   return ((uint32_t)(hrtc->Instance->WUTR & RTC_WUTR_WUT)); \r
1150 }\r
1151 \r
1152 /**\r
1153   * @brief  This function handles Wake Up Timer interrupt request.\r
1154   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1155   *                the configuration information for RTC.\r
1156   * @retval None\r
1157   */\r
1158 void HAL_RTCEx_WakeUpTimerIRQHandler(RTC_HandleTypeDef *hrtc)\r
1159 {  \r
1160   if(__HAL_RTC_WAKEUPTIMER_GET_IT(hrtc, RTC_IT_WUT))\r
1161   {\r
1162     /* Get the status of the Interrupt */\r
1163     if((uint32_t)(hrtc->Instance->CR & RTC_IT_WUT) != (uint32_t)RESET)\r
1164     {\r
1165       /* WAKEUPTIMER callback */ \r
1166       HAL_RTCEx_WakeUpTimerEventCallback(hrtc);\r
1167       \r
1168       /* Clear the WAKEUPTIMER interrupt pending bit */\r
1169       __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);\r
1170     }\r
1171   }\r
1172   \r
1173   /* Clear the EXTI's line Flag for RTC WakeUpTimer */\r
1174   __HAL_RTC_WAKEUPTIMER_EXTI_CLEAR_FLAG();\r
1175   \r
1176   /* Change RTC state */\r
1177   hrtc->State = HAL_RTC_STATE_READY;\r
1178 }\r
1179 \r
1180 /**\r
1181   * @brief  Wake Up Timer callback.\r
1182   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1183   *                the configuration information for RTC.\r
1184   * @retval None\r
1185   */\r
1186 __weak void HAL_RTCEx_WakeUpTimerEventCallback(RTC_HandleTypeDef *hrtc)\r
1187 {\r
1188   /* NOTE : This function Should not be modified, when the callback is needed,\r
1189             the HAL_RTC_WakeUpTimerEventCallback could be implemented in the user file\r
1190    */\r
1191 }\r
1192 \r
1193 /**\r
1194   * @brief  This function handles Wake Up Timer Polling.\r
1195   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1196   *                the configuration information for RTC.\r
1197   * @param  Timeout: Timeout duration\r
1198   * @retval HAL status\r
1199   */\r
1200 HAL_StatusTypeDef HAL_RTCEx_PollForWakeUpTimerEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)\r
1201 {  \r
1202   uint32_t tickstart = 0; \r
1203 \r
1204   /* Get tick */\r
1205   tickstart = HAL_GetTick();\r
1206 \r
1207   while(__HAL_RTC_WAKEUPTIMER_GET_FLAG(hrtc, RTC_FLAG_WUTF) == RESET)\r
1208   {\r
1209     if(Timeout != HAL_MAX_DELAY)\r
1210     {\r
1211       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
1212       {\r
1213         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
1214       \r
1215         return HAL_TIMEOUT;\r
1216       }\r
1217     }\r
1218   }\r
1219   \r
1220   /* Clear the WAKEUPTIMER Flag */\r
1221   __HAL_RTC_WAKEUPTIMER_CLEAR_FLAG(hrtc, RTC_FLAG_WUTF);\r
1222   \r
1223   /* Change RTC state */\r
1224   hrtc->State = HAL_RTC_STATE_READY;\r
1225   \r
1226   return HAL_OK; \r
1227 }\r
1228 \r
1229 /**\r
1230   * @}\r
1231   */\r
1232 \r
1233 \r
1234 /** @defgroup RTCEx_Group3 Extension Peripheral Control functions \r
1235  *  @brief   Extension Peripheral Control functions \r
1236  *\r
1237 @verbatim   \r
1238  ===============================================================================\r
1239               ##### Extension Peripheral Control functions #####\r
1240  ===============================================================================  \r
1241     [..]\r
1242     This subsection provides functions allowing to\r
1243       (+) Write a data in a specified RTC Backup data register\r
1244       (+) Read a data in a specified RTC Backup data register\r
1245       (+) Set the Coarse calibration parameters.\r
1246       (+) Deactivate the Coarse calibration parameters\r
1247       (+) Set the Smooth calibration parameters.\r
1248       (+) Configure the Synchronization Shift Control Settings.\r
1249       (+) Configure the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).\r
1250       (+) Deactivate the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).\r
1251       (+) Enable the RTC reference clock detection.\r
1252       (+) Disable the RTC reference clock detection.\r
1253       (+) Enable the Bypass Shadow feature.\r
1254       (+) Disable the Bypass Shadow feature.\r
1255 \r
1256 @endverbatim\r
1257   * @{\r
1258   */\r
1259 \r
1260 /**\r
1261   * @brief  Writes a data in a specified RTC Backup data register.\r
1262   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1263   *                the configuration information for RTC. \r
1264   * @param  BackupRegister: RTC Backup data Register number.\r
1265   *          This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to \r
1266   *                                 specify the register.\r
1267   * @param  Data: Data to be written in the specified RTC Backup data register.                     \r
1268   * @retval None\r
1269   */\r
1270 void HAL_RTCEx_BKUPWrite(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister, uint32_t Data)\r
1271 {\r
1272   uint32_t tmp = 0;\r
1273   \r
1274   /* Check the parameters */\r
1275   assert_param(IS_RTC_BKP(BackupRegister));\r
1276   \r
1277   tmp = (uint32_t)&(hrtc->Instance->BKP0R);\r
1278   tmp += (BackupRegister * 4);\r
1279   \r
1280   /* Write the specified register */\r
1281   *(__IO uint32_t *)tmp = (uint32_t)Data;\r
1282 }\r
1283 \r
1284 /**\r
1285   * @brief  Reads data from the specified RTC Backup data Register.\r
1286   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1287   *                the configuration information for RTC. \r
1288   * @param  BackupRegister: RTC Backup data Register number.\r
1289   *          This parameter can be: RTC_BKP_DRx where x can be from 0 to 19 to \r
1290   *                                 specify the register.                   \r
1291   * @retval Read value\r
1292   */\r
1293 uint32_t HAL_RTCEx_BKUPRead(RTC_HandleTypeDef *hrtc, uint32_t BackupRegister)\r
1294 {\r
1295   uint32_t tmp = 0;\r
1296   \r
1297   /* Check the parameters */\r
1298   assert_param(IS_RTC_BKP(BackupRegister));\r
1299 \r
1300   tmp = (uint32_t)&(hrtc->Instance->BKP0R);\r
1301   tmp += (BackupRegister * 4);\r
1302   \r
1303   /* Read the specified register */\r
1304   return (*(__IO uint32_t *)tmp);\r
1305 }\r
1306 \r
1307 /**\r
1308   * @brief  Sets the Smooth calibration parameters.\r
1309   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1310   *                the configuration information for RTC.  \r
1311   * @param  SmoothCalibPeriod: Select the Smooth Calibration Period.\r
1312   *          This parameter can be can be one of the following values :\r
1313   *             @arg RTC_SMOOTHCALIB_PERIOD_32SEC: The smooth calibration period is 32s.\r
1314   *             @arg RTC_SMOOTHCALIB_PERIOD_16SEC: The smooth calibration period is 16s.\r
1315   *             @arg RTC_SMOOTHCALIB_PERIOD_8SEC: The smooth calibration period is 8s.\r
1316   * @param  SmoothCalibPlusPulses: Select to Set or reset the CALP bit.\r
1317   *          This parameter can be one of the following values:\r
1318   *             @arg RTC_SMOOTHCALIB_PLUSPULSES_SET: Add one RTCCLK pulses every 2*11 pulses.\r
1319   *             @arg RTC_SMOOTHCALIB_PLUSPULSES_RESET: No RTCCLK pulses are added.\r
1320   * @param  SmouthCalibMinusPulsesValue: Select the value of CALM[8:0] bits.\r
1321   *          This parameter can be one any value from 0 to 0x000001FF.\r
1322   * @note   To deactivate the smooth calibration, the field SmoothCalibPlusPulses \r
1323   *         must be equal to SMOOTHCALIB_PLUSPULSES_RESET and the field \r
1324   *         SmouthCalibMinusPulsesValue must be equal to 0.  \r
1325   * @retval HAL status\r
1326   */\r
1327 HAL_StatusTypeDef HAL_RTCEx_SetSmoothCalib(RTC_HandleTypeDef* hrtc, uint32_t SmoothCalibPeriod, uint32_t SmoothCalibPlusPulses, uint32_t SmouthCalibMinusPulsesValue)\r
1328 {\r
1329   uint32_t tickstart = 0;\r
1330   \r
1331   /* Check the parameters */\r
1332   assert_param(IS_RTC_SMOOTH_CALIB_PERIOD(SmoothCalibPeriod));\r
1333   assert_param(IS_RTC_SMOOTH_CALIB_PLUS(SmoothCalibPlusPulses));\r
1334   assert_param(IS_RTC_SMOOTH_CALIB_MINUS(SmouthCalibMinusPulsesValue));\r
1335   \r
1336   /* Process Locked */ \r
1337   __HAL_LOCK(hrtc);\r
1338   \r
1339   hrtc->State = HAL_RTC_STATE_BUSY;\r
1340   \r
1341   /* Disable the write protection for RTC registers */\r
1342   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1343   \r
1344   /* check if a calibration is pending*/\r
1345   if((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)\r
1346   {\r
1347   /* Get tick */\r
1348   tickstart = HAL_GetTick();\r
1349 \r
1350     /* check if a calibration is pending*/\r
1351     while((hrtc->Instance->ISR & RTC_ISR_RECALPF) != RESET)\r
1352     {\r
1353       if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)\r
1354       {\r
1355         /* Enable the write protection for RTC registers */\r
1356         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1357         \r
1358         /* Change RTC state */\r
1359         hrtc->State = HAL_RTC_STATE_TIMEOUT; \r
1360         \r
1361         /* Process Unlocked */ \r
1362         __HAL_UNLOCK(hrtc);\r
1363         \r
1364         return HAL_TIMEOUT;\r
1365       }\r
1366     }\r
1367   }\r
1368   \r
1369   /* Configure the Smooth calibration settings */\r
1370   hrtc->Instance->CALR = (uint32_t)((uint32_t)SmoothCalibPeriod | (uint32_t)SmoothCalibPlusPulses | (uint32_t)SmouthCalibMinusPulsesValue);\r
1371   \r
1372   /* Enable the write protection for RTC registers */\r
1373   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1374   \r
1375   /* Change RTC state */\r
1376   hrtc->State = HAL_RTC_STATE_READY; \r
1377   \r
1378   /* Process Unlocked */ \r
1379   __HAL_UNLOCK(hrtc);\r
1380   \r
1381   return HAL_OK;\r
1382 }\r
1383 \r
1384 /**\r
1385   * @brief  Configures the Synchronization Shift Control Settings.\r
1386   * @note   When REFCKON is set, firmware must not write to Shift control register. \r
1387   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1388   *                the configuration information for RTC.    \r
1389   * @param  ShiftAdd1S: Select to add or not 1 second to the time calendar.\r
1390   *          This parameter can be one of the following values :\r
1391   *             @arg RTC_SHIFTADD1S_SET: Add one second to the clock calendar. \r
1392   *             @arg RTC_SHIFTADD1S_RESET: No effect.\r
1393   * @param  ShiftSubFS: Select the number of Second Fractions to substitute.\r
1394   *          This parameter can be one any value from 0 to 0x7FFF.\r
1395   * @retval HAL status\r
1396   */\r
1397 HAL_StatusTypeDef HAL_RTCEx_SetSynchroShift(RTC_HandleTypeDef* hrtc, uint32_t ShiftAdd1S, uint32_t ShiftSubFS)\r
1398 {\r
1399   uint32_t tickstart = 0;\r
1400 \r
1401   /* Check the parameters */\r
1402   assert_param(IS_RTC_SHIFT_ADD1S(ShiftAdd1S));\r
1403   assert_param(IS_RTC_SHIFT_SUBFS(ShiftSubFS));\r
1404 \r
1405   /* Process Locked */ \r
1406   __HAL_LOCK(hrtc);\r
1407   \r
1408   hrtc->State = HAL_RTC_STATE_BUSY;\r
1409 \r
1410   /* Disable the write protection for RTC registers */\r
1411   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1412 \r
1413   /* Get tick */\r
1414   tickstart = HAL_GetTick();\r
1415 \r
1416     /* Wait until the shift is completed*/\r
1417     while((hrtc->Instance->ISR & RTC_ISR_SHPF) != RESET)\r
1418     {\r
1419       if((HAL_GetTick() - tickstart ) > RTC_TIMEOUT_VALUE)\r
1420       {  \r
1421         /* Enable the write protection for RTC registers */\r
1422         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);  \r
1423         \r
1424         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
1425         \r
1426         /* Process Unlocked */ \r
1427         __HAL_UNLOCK(hrtc);\r
1428         \r
1429         return HAL_TIMEOUT;\r
1430       }\r
1431     }\r
1432   \r
1433     /* Check if the reference clock detection is disabled */\r
1434     if((hrtc->Instance->CR & RTC_CR_REFCKON) == RESET)\r
1435     {\r
1436       /* Configure the Shift settings */\r
1437       hrtc->Instance->SHIFTR = (uint32_t)(uint32_t)(ShiftSubFS) | (uint32_t)(ShiftAdd1S);\r
1438       \r
1439       /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */\r
1440       if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)\r
1441       {\r
1442         if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)\r
1443         {\r
1444           /* Enable the write protection for RTC registers */\r
1445           __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);  \r
1446           \r
1447           hrtc->State = HAL_RTC_STATE_ERROR;\r
1448           \r
1449           /* Process Unlocked */ \r
1450           __HAL_UNLOCK(hrtc);\r
1451           \r
1452           return HAL_ERROR;\r
1453         }\r
1454       }\r
1455     }\r
1456     else\r
1457     {\r
1458       /* Enable the write protection for RTC registers */\r
1459       __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1460       \r
1461       /* Change RTC state */\r
1462       hrtc->State = HAL_RTC_STATE_ERROR; \r
1463       \r
1464       /* Process Unlocked */ \r
1465       __HAL_UNLOCK(hrtc);\r
1466       \r
1467       return HAL_ERROR;\r
1468     }\r
1469   \r
1470   /* Enable the write protection for RTC registers */\r
1471   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1472   \r
1473   /* Change RTC state */\r
1474   hrtc->State = HAL_RTC_STATE_READY; \r
1475   \r
1476   /* Process Unlocked */ \r
1477   __HAL_UNLOCK(hrtc);\r
1478   \r
1479   return HAL_OK;\r
1480 }\r
1481 \r
1482 /**\r
1483   * @brief  Configures the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).\r
1484   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1485   *                the configuration information for RTC.    \r
1486   * @param  CalibOutput: Select the Calibration output Selection .\r
1487   *          This parameter can be one of the following values:\r
1488   *             @arg RTC_CALIBOUTPUT_512HZ: A signal has a regular waveform at 512Hz. \r
1489   *             @arg RTC_CALIBOUTPUT_1HZ: A signal has a regular waveform at 1Hz.\r
1490   * @retval HAL status\r
1491   */\r
1492 HAL_StatusTypeDef HAL_RTCEx_SetCalibrationOutPut(RTC_HandleTypeDef* hrtc, uint32_t CalibOutput)\r
1493 {\r
1494   /* Check the parameters */\r
1495   assert_param(IS_RTC_CALIB_OUTPUT(CalibOutput));\r
1496   \r
1497   /* Process Locked */ \r
1498   __HAL_LOCK(hrtc);\r
1499   \r
1500   hrtc->State = HAL_RTC_STATE_BUSY;\r
1501 \r
1502   /* Disable the write protection for RTC registers */\r
1503   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1504   \r
1505   /* Clear flags before config */\r
1506   hrtc->Instance->CR &= (uint32_t)~RTC_CR_COSEL;\r
1507   \r
1508   /* Configure the RTC_CR register */\r
1509   hrtc->Instance->CR |= (uint32_t)CalibOutput;\r
1510   \r
1511   __HAL_RTC_CALIBRATION_OUTPUT_ENABLE(hrtc);\r
1512   \r
1513   /* Enable the write protection for RTC registers */\r
1514   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1515   \r
1516   /* Change RTC state */\r
1517   hrtc->State = HAL_RTC_STATE_READY; \r
1518   \r
1519   /* Process Unlocked */ \r
1520   __HAL_UNLOCK(hrtc);\r
1521   \r
1522   return HAL_OK;\r
1523 }\r
1524 \r
1525 /**\r
1526   * @brief  Deactivates the Calibration Pinout (RTC_CALIB) Selection (1Hz or 512Hz).\r
1527   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1528   *                the configuration information for RTC.    \r
1529   * @retval HAL status\r
1530   */\r
1531 HAL_StatusTypeDef HAL_RTCEx_DeactivateCalibrationOutPut(RTC_HandleTypeDef* hrtc)\r
1532 {\r
1533   /* Process Locked */ \r
1534   __HAL_LOCK(hrtc);\r
1535   \r
1536   hrtc->State = HAL_RTC_STATE_BUSY;\r
1537   \r
1538   /* Disable the write protection for RTC registers */\r
1539   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1540   \r
1541   __HAL_RTC_CALIBRATION_OUTPUT_DISABLE(hrtc);\r
1542     \r
1543   /* Enable the write protection for RTC registers */\r
1544   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1545   \r
1546   /* Change RTC state */\r
1547   hrtc->State = HAL_RTC_STATE_READY; \r
1548   \r
1549   /* Process Unlocked */ \r
1550   __HAL_UNLOCK(hrtc);\r
1551   \r
1552   return HAL_OK;\r
1553 }\r
1554 \r
1555 /**\r
1556   * @brief  Enables the RTC reference clock detection.\r
1557   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1558   *                the configuration information for RTC.    \r
1559   * @retval HAL status\r
1560   */\r
1561 HAL_StatusTypeDef HAL_RTCEx_SetRefClock(RTC_HandleTypeDef* hrtc)\r
1562 {\r
1563   /* Process Locked */ \r
1564   __HAL_LOCK(hrtc);\r
1565   \r
1566   hrtc->State = HAL_RTC_STATE_BUSY;\r
1567   \r
1568   /* Disable the write protection for RTC registers */\r
1569   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1570   \r
1571   /* Set Initialization mode */\r
1572   if(RTC_EnterInitMode(hrtc) != HAL_OK)\r
1573   {\r
1574     /* Enable the write protection for RTC registers */\r
1575     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); \r
1576     \r
1577     /* Set RTC state*/\r
1578     hrtc->State = HAL_RTC_STATE_ERROR;\r
1579     \r
1580     /* Process Unlocked */ \r
1581     __HAL_UNLOCK(hrtc);\r
1582     \r
1583     return HAL_ERROR;\r
1584   } \r
1585   else\r
1586   {\r
1587     __HAL_RTC_CLOCKREF_DETECTION_ENABLE(hrtc);\r
1588 \r
1589     /* Exit Initialization mode */\r
1590     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; \r
1591   }\r
1592   \r
1593   /* Enable the write protection for RTC registers */\r
1594   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1595   \r
1596    /* Change RTC state */\r
1597   hrtc->State = HAL_RTC_STATE_READY; \r
1598   \r
1599   /* Process Unlocked */ \r
1600   __HAL_UNLOCK(hrtc);\r
1601   \r
1602   return HAL_OK;\r
1603 }\r
1604 \r
1605 /**\r
1606   * @brief  Disable the RTC reference clock detection.\r
1607   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1608   *                the configuration information for RTC.    \r
1609   * @retval HAL status\r
1610   */\r
1611 HAL_StatusTypeDef HAL_RTCEx_DeactivateRefClock(RTC_HandleTypeDef* hrtc)\r
1612 { \r
1613   /* Process Locked */ \r
1614   __HAL_LOCK(hrtc);\r
1615   \r
1616   hrtc->State = HAL_RTC_STATE_BUSY;\r
1617   \r
1618   /* Disable the write protection for RTC registers */\r
1619   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1620   \r
1621   /* Set Initialization mode */\r
1622   if(RTC_EnterInitMode(hrtc) != HAL_OK)\r
1623   {\r
1624     /* Enable the write protection for RTC registers */\r
1625     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc); \r
1626     \r
1627     /* Set RTC state*/\r
1628     hrtc->State = HAL_RTC_STATE_ERROR;\r
1629     \r
1630     /* Process Unlocked */ \r
1631     __HAL_UNLOCK(hrtc);\r
1632     \r
1633     return HAL_ERROR;\r
1634   } \r
1635   else\r
1636   {\r
1637     __HAL_RTC_CLOCKREF_DETECTION_DISABLE(hrtc);\r
1638     \r
1639     /* Exit Initialization mode */\r
1640     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT; \r
1641   }\r
1642   \r
1643   /* Enable the write protection for RTC registers */\r
1644   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1645   \r
1646   /* Change RTC state */\r
1647   hrtc->State = HAL_RTC_STATE_READY; \r
1648   \r
1649   /* Process Unlocked */ \r
1650   __HAL_UNLOCK(hrtc);\r
1651   \r
1652   return HAL_OK;\r
1653 }\r
1654 \r
1655 /**\r
1656   * @brief  Enables the Bypass Shadow feature.\r
1657   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1658   *                the configuration information for RTC.  \r
1659   * @note   When the Bypass Shadow is enabled the calendar value are taken \r
1660   *         directly from the Calendar counter.\r
1661   * @retval HAL status\r
1662   */\r
1663 HAL_StatusTypeDef HAL_RTCEx_EnableBypassShadow(RTC_HandleTypeDef* hrtc)\r
1664 {\r
1665   /* Process Locked */ \r
1666   __HAL_LOCK(hrtc);\r
1667   \r
1668   hrtc->State = HAL_RTC_STATE_BUSY;\r
1669   \r
1670   /* Disable the write protection for RTC registers */\r
1671   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1672   \r
1673   /* Set the BYPSHAD bit */\r
1674   hrtc->Instance->CR |= (uint8_t)RTC_CR_BYPSHAD;\r
1675   \r
1676   /* Enable the write protection for RTC registers */\r
1677   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1678   \r
1679   /* Change RTC state */\r
1680   hrtc->State = HAL_RTC_STATE_READY; \r
1681   \r
1682   /* Process Unlocked */ \r
1683   __HAL_UNLOCK(hrtc);\r
1684   \r
1685   return HAL_OK;\r
1686 }\r
1687 \r
1688 /**\r
1689   * @brief  Disables the Bypass Shadow feature.\r
1690   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1691   *                the configuration information for RTC.  \r
1692   * @note   When the Bypass Shadow is enabled the calendar value are taken \r
1693   *         directly from the Calendar counter.\r
1694   * @retval HAL status\r
1695   */\r
1696 HAL_StatusTypeDef HAL_RTCEx_DisableBypassShadow(RTC_HandleTypeDef* hrtc)\r
1697 {\r
1698   /* Process Locked */ \r
1699   __HAL_LOCK(hrtc);\r
1700   \r
1701   hrtc->State = HAL_RTC_STATE_BUSY;\r
1702   \r
1703   /* Disable the write protection for RTC registers */\r
1704   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);\r
1705   \r
1706   /* Reset the BYPSHAD bit */\r
1707   hrtc->Instance->CR &= (uint8_t)~RTC_CR_BYPSHAD;\r
1708   \r
1709   /* Enable the write protection for RTC registers */\r
1710   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);\r
1711   \r
1712   /* Change RTC state */\r
1713   hrtc->State = HAL_RTC_STATE_READY; \r
1714   \r
1715   /* Process Unlocked */ \r
1716   __HAL_UNLOCK(hrtc);\r
1717   \r
1718   return HAL_OK;\r
1719 }\r
1720 \r
1721 /**\r
1722   * @}\r
1723   */\r
1724 \r
1725   /** @defgroup RTCEx_Group4 Extended features functions \r
1726  *  @brief    Extended features functions  \r
1727  *\r
1728 @verbatim   \r
1729  ===============================================================================\r
1730                  ##### Extended features functions #####\r
1731  ===============================================================================  \r
1732     [..]  This section provides functions allowing to:\r
1733       (+) RTC Alram B callback\r
1734       (+) RTC Poll for Alarm B request\r
1735                \r
1736 @endverbatim\r
1737   * @{\r
1738   */\r
1739 \r
1740 /**\r
1741   * @brief  Alarm B callback.\r
1742   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1743   *                the configuration information for RTC.\r
1744   * @retval None\r
1745   */\r
1746 __weak void HAL_RTCEx_AlarmBEventCallback(RTC_HandleTypeDef *hrtc)\r
1747 {\r
1748   /* NOTE : This function Should not be modified, when the callback is needed,\r
1749             the HAL_RTC_AlarmBEventCallback could be implemented in the user file\r
1750    */\r
1751 }\r
1752 \r
1753 /**\r
1754   * @brief  This function handles AlarmB Polling request.\r
1755   * @param  hrtc: pointer to a RTC_HandleTypeDef structure that contains\r
1756   *                the configuration information for RTC.\r
1757   * @param  Timeout: Timeout duration\r
1758   * @retval HAL status\r
1759   */\r
1760 HAL_StatusTypeDef HAL_RTCEx_PollForAlarmBEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)\r
1761 {  \r
1762   uint32_t tickstart = 0; \r
1763 \r
1764   /* Get tick */\r
1765   tickstart = HAL_GetTick();\r
1766 \r
1767   while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBF) == RESET)\r
1768   {\r
1769     if(Timeout != HAL_MAX_DELAY)\r
1770     {\r
1771       if((Timeout == 0)||((HAL_GetTick() - tickstart ) > Timeout))\r
1772       {\r
1773         hrtc->State = HAL_RTC_STATE_TIMEOUT;\r
1774         return HAL_TIMEOUT;\r
1775       }\r
1776     }\r
1777   }\r
1778   \r
1779   /* Clear the Alarm Flag */\r
1780   __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF);\r
1781   \r
1782   /* Change RTC state */\r
1783   hrtc->State = HAL_RTC_STATE_READY; \r
1784   \r
1785   return HAL_OK; \r
1786 }\r
1787 \r
1788 /**\r
1789   * @}\r
1790   */\r
1791 \r
1792 /**\r
1793   * @}\r
1794   */\r
1795 \r
1796 #endif /* HAL_RTC_MODULE_ENABLED */\r
1797 /**\r
1798   * @}\r
1799   */\r
1800 \r
1801 /**\r
1802   * @}\r
1803   */\r
1804 \r
1805 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/\r