tmk_core/tool/mbed/mbed-sdk/libraries/mbed/targets/cmsis/TARGET_STM/TARGET_STM32F3/stm32f3xx_hal_rtc.c

   1 /**
   2   ******************************************************************************
   3   * @file    stm32f3xx_hal_rtc.c
   4   * @author  MCD Application Team
   5   * @version V1.1.0
   6   * @date    12-Sept-2014
   7   * @brief   RTC HAL module driver.
   8   *
   9   *          This file provides firmware functions to manage the following
  10   *          functionalities of the Real-Time Clock (RTC) peripheral:
  11   *           - Initialization
  12   *           - Calendar (Time and Date) configuration
  13   *           - Alarms (Alarm A and Alarm B) configuration
  14   *           - WakeUp Timer configuration
  15   *           - TimeStamp configuration
  16   *           - Tampers configuration
  17   *           - Backup Data Registers configuration
  18   *           - RTC Tamper and TimeStamp Pins Selection
  19   *           - Interrupts and flags management
  20   *
  21   @verbatim
  22
  23  ===============================================================================
  24                           ##### RTC Operating Condition #####
  25  ===============================================================================
  26     [..] The real-time clock (RTC) and the RTC backup registers can be powered
  27          from the VBAT voltage when the main VDD supply is powered off.
  28          To retain the content of the RTC backup registers and supply the RTC
  29          when VDD is turned off, VBAT pin can be connected to an optional
  30          standby voltage supplied by a battery or by another source.
  31
  32     [..] To allow the RTC to operate even when the main digital supply (VDD)
  33          is turned off, the VBAT pin powers the following blocks:
  34            (#) The RTC
  35            (#) The LSE oscillator
  36            (#) PC13 to PC15 I/Os (when available)
  37
  38     [..] When the backup domain is supplied by VDD (analog switch connected
  39          to VDD), the following functions are available:
  40            (#) PC14 and PC15 can be used as either GPIO or LSE pins
  41            (#) PC13 can be used as a GPIO or as the RTC_AF pin
  42
  43     [..] When the backup domain is supplied by VBAT (analog switch connected
  44          to VBAT because VDD is not present), the following functions are available:
  45            (#) PC14 and PC15 can be used as LSE pins only
  46            (#) PC13 can be used as the RTC_AF pin
  47
  48                         ##### Backup Domain Reset #####
  49  ===============================================================================
  50     [..] The backup domain reset sets all RTC registers and the RCC_BDCR
  51          register to their reset values.
  52          A backup domain reset is generated when one of the following events
  53          occurs:
  54            (#) Software reset, triggered by setting the BDRST bit in the
  55                RCC Backup domain control register (RCC_BDCR).
  56            (#) VDD or VBAT power on, if both supplies have previously been
  57                powered off.
  58
  59                    ##### Backup Domain Access #####
  60  ===================================================================
  61     [..] After reset, the backup domain (RTC registers, RTC backup data
  62          registers and backup SRAM) is protected against possible unwanted write
  63          accesses.
  64
  65     [..] To enable access to the RTC Domain and RTC registers, proceed as follows:
  66            (#) Enable the Power Controller (PWR) APB1 interface clock using the
  67                __PWR_CLK_ENABLE() function.
  68            (#) Enable access to RTC domain using the HAL_PWR_EnableBkUpAccess() function.
  69            (#) Select the RTC clock source using the __HAL_RCC_RTC_CONFIG() function.
  70            (#) Enable RTC Clock using the __HAL_RCC_RTC_ENABLE() function.
  71
  72
  73                   ##### How to use RTC Driver #####
  74  ===================================================================
  75     [..]
  76         (+) Enable the RTC domain access (see description in the section above).
  77         (+) Configure the RTC Prescaler (Asynchronous and Synchronous) and RTC hour
  78             format using the HAL_RTC_Init() function.
  79
  80     *** Time and Date configuration ***
  81     ===================================
  82     [..]
  83         (+) To configure the RTC Calendar (Time and Date) use the HAL_RTC_SetTime()
  84             and HAL_RTC_SetDate() functions.
  85         (+) To read the RTC Calendar, use the HAL_RTC_GetTime() and HAL_RTC_GetDate() functions.
  86
  87     *** Alarm configuration ***
  88     ===========================
  89     [..]
  90         (+) To configure the RTC Alarm use the HAL_RTC_SetAlarm() function.
  91             You can also configure the RTC Alarm with interrupt mode using the
  92             HAL_RTC_SetAlarm_IT() function.
  93         (+) To read the RTC Alarm, use the HAL_RTC_GetAlarm() function.
  94
  95     *** RTC Wakeup configuration ***
  96     ================================
  97     [..]
  98         (+) To configure the RTC Wakeup Clock source and Counter use the HAL_RTC_SetWakeUpTimer()
  99             function. You can also configure the RTC Wakeup timer with interrupt mode
 100             using the HAL_RTC_SetWakeUpTimer_IT() function.
 101         (+) To read the RTC WakeUp Counter register, use the HAL_RTC_GetWakeUpTimer()
 102             function.
 103
 104     *** TimeStamp configuration ***
 105     ===============================
 106     [..]
 107         (+) Configure the RTC_AF trigger and enables the RTC TimeStamp using the
 108             HAL_RTC_SetTimeStamp() function. You can also configure the RTC TimeStamp with
 109             interrupt mode using the HAL_RTC_SetTimeStamp_IT() function.
 110         (+) To read the RTC TimeStamp Time and Date register, use the HAL_RTC_GetTimeStamp()
 111             function.
 112
 113     *** Tamper configuration ***
 114     ============================
 115     [..]
 116         (+) Enable the RTC Tamper and Configure the Tamper filter count, trigger Edge
 117             or Level according to the Tamper filter (if equal to 0 Edge else Level)
 118             value, sampling frequency, precharge or discharge and Pull-UP using the
 119             HAL_RTC_SetTamper() function. You can configure RTC Tamper with interrupt
 120             mode using HAL_RTC_SetTamper_IT() function.
 121
 122     *** Backup Data Registers configuration ***
 123     ===========================================
 124     [..]
 125         (+) To write to the RTC Backup Data registers, use the HAL_RTC_BKUPWrite()
 126             function.
 127         (+) To read the RTC Backup Data registers, use the HAL_RTC_BKUPRead()
 128             function.
 129
 130
 131                   ##### RTC and low power modes #####
 132  ===================================================================
 133     [..] The MCU can be woken up from a low power mode by an RTC alternate
 134          function.
 135     [..] The RTC alternate functions are the RTC alarms (Alarm A and Alarm B),
 136          RTC wakeup, RTC tamper event detection and RTC time stamp event detection.
 137          These RTC alternate functions can wake up the system from the Stop and
 138          Standby low power modes.
 139     [..] The system can also wake up from low power modes without depending
 140          on an external interrupt (Auto-wakeup mode), by using the RTC alarm
 141          or the RTC wakeup events.
 142     [..] The RTC provides a programmable time base for waking up from the
 143          Stop or Standby mode at regular intervals.
 144          Wakeup from STOP and Standby modes is possible only when the RTC clock source
 145          is LSE or LSI.
 146
 147   @endverbatim
 148
 149   ******************************************************************************
 150   * @attention
 151   *
 152   * <h2><center>&copy; COPYRIGHT(c) 2014 STMicroelectronics</center></h2>
 153   *
 154   * Redistribution and use in source and binary forms, with or without modification,
 155   * are permitted provided that the following conditions are met:
 156   *   1. Redistributions of source code must retain the above copyright notice,
 157   *      this list of conditions and the following disclaimer.
 158   *   2. Redistributions in binary form must reproduce the above copyright notice,
 159   *      this list of conditions and the following disclaimer in the documentation
 160   *      and/or other materials provided with the distribution.
 161   *   3. Neither the name of STMicroelectronics nor the names of its contributors
 162   *      may be used to endorse or promote products derived from this software
 163   *      without specific prior written permission.
 164   *
 165   * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
 166   * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
 167   * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 168   * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
 169   * FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
 170   * DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
 171   * SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
 172   * CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
 173   * OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
 174   * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 175   *
 176   ******************************************************************************
 177   */
 178
 179 /* Includes ------------------------------------------------------------------*/
 180 #include "stm32f3xx_hal.h"
 181
 182 /** @addtogroup STM32F3xx_HAL_Driver
 183   * @{
 184   */
 185
 186 /** @defgroup RTC RTC HAL module driver
 187   * @brief RTC HAL module driver
 188   * @{
 189   */
 190
 191 #ifdef HAL_RTC_MODULE_ENABLED
 192
 193 /* Private typedef -----------------------------------------------------------*/
 194 /* Private define ------------------------------------------------------------*/
 195 /* Private macro -------------------------------------------------------------*/
 196 /* Private variables ---------------------------------------------------------*/
 197 /* Private function prototypes -----------------------------------------------*/
 198 /* Exported functions ---------------------------------------------------------*/
 199
 200 /** @defgroup RTC_Exported_Functions RTC Exported Functions
 201   * @{
 202   */
 203
 204 /** @defgroup RTC_Exported_Functions_Group1 Initialization and de-initialization functions
 205  *  @brief    Initialization and Configuration functions
 206  *
 207 @verbatim
 208  ===============================================================================
 209               ##### Initialization and de-initialization functions #####
 210  ===============================================================================
 211    [..] This section provide functions allowing to initialize and configure the
 212          RTC Prescaler (Synchronous and Asynchronous), RTC Hour format, disable
 213          RTC registers Write protection, enter and exit the RTC initialization mode,
 214          RTC registers synchronization check and reference clock detection enable.
 215          (#) The RTC Prescaler is programmed to generate the RTC 1Hz time base.
 216              It is split into 2 programmable prescalers to minimize power consumption.
 217              (++) A 7-bit asynchronous prescaler and A 13-bit synchronous prescaler.
 218              (++) When both prescalers are used, it is recommended to configure the
 219                  asynchronous prescaler to a high value to minimize consumption.
 220          (#) All RTC registers are Write protected. Writing to the RTC registers
 221              is enabled by writing a key into the Write Protection register, RTC_WPR.
 222          (#) To Configure the RTC Calendar, user application should enter
 223              initialization mode. In this mode, the calendar counter is stopped
 224              and its value can be updated. When the initialization sequence is
 225              complete, the calendar restarts counting after 4 RTCCLK cycles.
 226          (#) To read the calendar through the shadow registers after Calendar
 227              initialization, calendar update or after wakeup from low power modes
 228              the software must first clear the RSF flag. The software must then
 229              wait until it is set again before reading the calendar, which means
 230              that the calendar registers have been correctly copied into the
 231              RTC_TR and RTC_DR shadow registers.The HAL_RTC_WaitForSynchro() function
 232              implements the above software sequence (RSF clear and RSF check).
 233
 234 @endverbatim
 235   * @{
 236   */
 237
 238 /**
 239   * @brief  Initializes the RTC peripheral
 240   * @param  hrtc: RTC handle
 241   * @retval HAL status
 242   */
 243 HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc)
 244 {
 245   /* Check the RTC peripheral state */
 246   if(hrtc == HAL_NULL)
 247   {
 248      return HAL_ERROR;
 249   }
 250
 251   /* Check the parameters */
 252   assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
 253   assert_param(IS_RTC_HOUR_FORMAT(hrtc->Init.HourFormat));
 254   assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv));
 255   assert_param(IS_RTC_SYNCH_PREDIV(hrtc->Init.SynchPrediv));
 256   assert_param(IS_RTC_OUTPUT(hrtc->Init.OutPut));
 257   assert_param(IS_RTC_OUTPUT_POL(hrtc->Init.OutPutPolarity));
 258   assert_param(IS_RTC_OUTPUT_TYPE(hrtc->Init.OutPutType));
 259
 260   if(hrtc->State == HAL_RTC_STATE_RESET)
 261   {
 262     /* Initialize RTC MSP */
 263     HAL_RTC_MspInit(hrtc);
 264   }
 265
 266   /* Set RTC state */
 267   hrtc->State = HAL_RTC_STATE_BUSY;
 268
 269   /* Disable the write protection for RTC registers */
 270   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
 271
 272   /* Set Initialization mode */
 273   if(RTC_EnterInitMode(hrtc) != HAL_OK)
 274   {
 275     /* Enable the write protection for RTC registers */
 276     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 277
 278     /* Set RTC state */
 279     hrtc->State = HAL_RTC_STATE_ERROR;
 280
 281     return HAL_ERROR;
 282   }
 283   else
 284   {
 285     /* Clear RTC_CR FMT, OSEL and POL Bits */
 286     hrtc->Instance->CR &= ((uint32_t)~(RTC_CR_FMT | RTC_CR_OSEL | RTC_CR_POL));
 287     /* Set RTC_CR register */
 288     hrtc->Instance->CR |= (uint32_t)(hrtc->Init.HourFormat | hrtc->Init.OutPut | hrtc->Init.OutPutPolarity);
 289
 290     /* Configure the RTC PRER */
 291     hrtc->Instance->PRER = (uint32_t)(hrtc->Init.SynchPrediv);
 292     hrtc->Instance->PRER |= (uint32_t)(hrtc->Init.AsynchPrediv << 16);
 293
 294     /* Exit Initialization mode */
 295     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
 296
 297     hrtc->Instance->TAFCR &= (uint32_t)~RTC_TAFCR_ALARMOUTTYPE;
 298     hrtc->Instance->TAFCR |= (uint32_t)(hrtc->Init.OutPutType);
 299
 300     /* Enable the write protection for RTC registers */
 301     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 302
 303     /* Set RTC state */
 304     hrtc->State = HAL_RTC_STATE_READY;
 305
 306     return HAL_OK;
 307   }
 308 }
 309
 310 /**
 311   * @brief  DeInitializes the RTC peripheral
 312   * @param  hrtc: RTC handle
 313   * @note   This function doesn't reset the RTC Backup Data registers.
 314   * @retval HAL status
 315   */
 316 HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
 317 {
 318   uint32_t tickstart = 0;
 319
 320   /* Check the parameters */
 321   assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
 322
 323   /* Set RTC state */
 324   hrtc->State = HAL_RTC_STATE_BUSY;
 325
 326   /* Disable the write protection for RTC registers */
 327   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
 328
 329   /* Set Initialization mode */
 330   if(RTC_EnterInitMode(hrtc) != HAL_OK)
 331   {
 332     /* Enable the write protection for RTC registers */
 333     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 334
 335     /* Set RTC state */
 336     hrtc->State = HAL_RTC_STATE_ERROR;
 337
 338     return HAL_ERROR;
 339   }
 340   else
 341   {
 342     /* Reset TR, DR and CR registers */
 343     hrtc->Instance->TR = (uint32_t)0x00000000;
 344     hrtc->Instance->DR = (uint32_t)0x00002101;
 345     /* Reset All CR bits except CR[2:0] */
 346     hrtc->Instance->CR &= (uint32_t)0x00000007;
 347
 348     tickstart = HAL_GetTick();
 349
 350     /* Wait till WUTWF flag is set and if Time out is reached exit */
 351     while(((hrtc->Instance->ISR) & RTC_ISR_WUTWF) == (uint32_t)RESET)
 352     {
 353       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
 354       {
 355         /* Enable the write protection for RTC registers */
 356         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 357
 358         /* Set RTC state */
 359         hrtc->State = HAL_RTC_STATE_TIMEOUT;
 360
 361         return HAL_TIMEOUT;
 362       }
 363     }
 364
 365     /* Reset all RTC CR register bits */
 366     hrtc->Instance->CR &= (uint32_t)0x00000000;
 367     hrtc->Instance->WUTR = (uint32_t)0x0000FFFF;
 368     hrtc->Instance->PRER = (uint32_t)0x007F00FF;
 369     hrtc->Instance->ALRMAR = (uint32_t)0x00000000;
 370     hrtc->Instance->ALRMBR = (uint32_t)0x00000000;
 371     hrtc->Instance->SHIFTR = (uint32_t)0x00000000;
 372     hrtc->Instance->CALR = (uint32_t)0x00000000;
 373     hrtc->Instance->ALRMASSR = (uint32_t)0x00000000;
 374     hrtc->Instance->ALRMBSSR = (uint32_t)0x00000000;
 375
 376     /* Reset ISR register and exit initialization mode */
 377     hrtc->Instance->ISR = (uint32_t)0x00000000;
 378
 379     /* Reset Tamper and alternate functions configuration register */
 380     hrtc->Instance->TAFCR = 0x00000000;
 381
 382     /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
 383     if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
 384     {
 385       if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
 386       {
 387         /* Enable the write protection for RTC registers */
 388         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 389
 390         hrtc->State = HAL_RTC_STATE_ERROR;
 391
 392         return HAL_ERROR;
 393       }
 394     }
 395   }
 396
 397   /* Enable the write protection for RTC registers */
 398   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 399
 400   /* De-Initialize RTC MSP */
 401   HAL_RTC_MspDeInit(hrtc);
 402
 403   hrtc->State = HAL_RTC_STATE_RESET;
 404
 405   /* Release Lock */
 406   __HAL_UNLOCK(hrtc);
 407
 408   return HAL_OK;
 409 }
 410
 411 /**
 412   * @brief  Initializes the RTC MSP.
 413   * @param  hrtc: RTC handle
 414   * @retval None
 415   */
 416 __weak void HAL_RTC_MspInit(RTC_HandleTypeDef* hrtc)
 417 {
 418   /* NOTE : This function Should not be modified, when the callback is needed,
 419             the HAL_RTC_MspInit could be implenetd in the user file
 420    */
 421 }
 422
 423 /**
 424   * @brief  DeInitializes the RTC MSP.
 425   * @param  hrtc: RTC handle
 426   * @retval None
 427   */
 428 __weak void HAL_RTC_MspDeInit(RTC_HandleTypeDef* hrtc)
 429 {
 430   /* NOTE : This function Should not be modified, when the callback is needed,
 431             the HAL_RTC_MspDeInit could be implenetd in the user file
 432    */
 433 }
 434
 435 /**
 436   * @}
 437   */
 438
 439 /** @defgroup RTC_Exported_Functions_Group2 RTC Time and Date functions
 440  *  @brief   RTC Time and Date functions
 441  *
 442 @verbatim
 443  ===============================================================================
 444                  ##### RTC Time and Date functions #####
 445  ===============================================================================
 446
 447  [..] This section provide functions allowing to configure Time and Date features
 448
 449 @endverbatim
 450   * @{
 451   */
 452
 453 /**
 454   * @brief  Sets RTC current time.
 455   * @param  hrtc: RTC handle
 456   * @param  sTime: Pointer to Time structure
 457   * @param  Format: Specifies the format of the entered parameters.
 458   *          This parameter can be one of the following values:
 459   *            @arg Format_BIN: Binary data format
 460   *            @arg Format_BCD: BCD data format
 461   * @retval HAL status
 462   */
 463 HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
 464 {
 465   uint32_t tmpreg = 0;
 466
 467  /* Check the parameters */
 468   assert_param(IS_RTC_FORMAT(Format));
 469   assert_param(IS_RTC_DAYLIGHT_SAVING(sTime->DayLightSaving));
 470   assert_param(IS_RTC_STORE_OPERATION(sTime->StoreOperation));
 471
 472   /* Process Locked */
 473   __HAL_LOCK(hrtc);
 474
 475   hrtc->State = HAL_RTC_STATE_BUSY;
 476
 477   if(Format == FORMAT_BIN)
 478   {
 479     if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
 480     {
 481       assert_param(IS_RTC_HOUR12(sTime->Hours));
 482       assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat));
 483     }
 484     else
 485     {
 486       sTime->TimeFormat = 0x00;
 487       assert_param(IS_RTC_HOUR24(sTime->Hours));
 488     }
 489     assert_param(IS_RTC_MINUTES(sTime->Minutes));
 490     assert_param(IS_RTC_SECONDS(sTime->Seconds));
 491
 492     tmpreg = (uint32_t)(((uint32_t)RTC_ByteToBcd2(sTime->Hours) << 16) | \
 493                         ((uint32_t)RTC_ByteToBcd2(sTime->Minutes) << 8) | \
 494                         ((uint32_t)RTC_ByteToBcd2(sTime->Seconds)) | \
 495                         (((uint32_t)sTime->TimeFormat) << 16));
 496   }
 497   else
 498   {
 499     if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
 500     {
 501       tmpreg = RTC_Bcd2ToByte(sTime->Hours);
 502       assert_param(IS_RTC_HOUR12(tmpreg));
 503       assert_param(IS_RTC_HOURFORMAT12(sTime->TimeFormat));
 504     }
 505     else
 506     {
 507       sTime->TimeFormat = 0x00;
 508       assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours)));
 509     }
 510     assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes)));
 511     assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds)));
 512     tmpreg = (((uint32_t)(sTime->Hours) << 16) | \
 513               ((uint32_t)(sTime->Minutes) << 8) | \
 514               ((uint32_t)sTime->Seconds) | \
 515               ((uint32_t)(sTime->TimeFormat) << 16));
 516   }
 517
 518   /* Disable the write protection for RTC registers */
 519   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
 520
 521   /* Set Initialization mode */
 522   if(RTC_EnterInitMode(hrtc) != HAL_OK)
 523   {
 524     /* Enable the write protection for RTC registers */
 525     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 526
 527     /* Set RTC state */
 528     hrtc->State = HAL_RTC_STATE_ERROR;
 529
 530     /* Process Unlocked */
 531     __HAL_UNLOCK(hrtc);
 532
 533     return HAL_ERROR;
 534   }
 535   else
 536   {
 537     /* Set the RTC_TR register */
 538     hrtc->Instance->TR = (uint32_t)(tmpreg & RTC_TR_RESERVED_MASK);
 539
 540     /* Clear the bits to be configured */
 541     hrtc->Instance->CR &= (uint32_t)~RTC_CR_BCK;
 542
 543     /* Configure the RTC_CR register */
 544     hrtc->Instance->CR |= (uint32_t)(sTime->DayLightSaving | sTime->StoreOperation);
 545
 546     /* Exit Initialization mode */
 547     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
 548
 549     /* If  CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
 550     if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
 551     {
 552       if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
 553       {
 554         /* Enable the write protection for RTC registers */
 555         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 556
 557         hrtc->State = HAL_RTC_STATE_ERROR;
 558
 559         /* Process Unlocked */
 560         __HAL_UNLOCK(hrtc);
 561
 562         return HAL_ERROR;
 563       }
 564     }
 565
 566     /* Enable the write protection for RTC registers */
 567     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 568
 569    hrtc->State = HAL_RTC_STATE_READY;
 570
 571    __HAL_UNLOCK(hrtc);
 572
 573    return HAL_OK;
 574   }
 575 }
 576
 577 /**
 578   * @brief  Gets RTC current time.
 579   * @param  hrtc: RTC handle
 580   * @param  sTime: Pointer to Time structure
 581   * @param  Format: Specifies the format of the entered parameters.
 582   *          This parameter can be one of the following values:
 583   *            @arg Format_BIN: Binary data format
 584   *            @arg Format_BCD: BCD data format
 585   * @note   Call HAL_RTC_GetDate() after HAL_RTC_GetTime() to unlock the values
 586   *         in the higher-order calendar shadow registers.
 587   * @retval HAL status
 588   */
 589 HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
 590 {
 591   uint32_t tmpreg = 0;
 592
 593   /* Check the parameters */
 594   assert_param(IS_RTC_FORMAT(Format));
 595
 596   /* Get subseconds values from the correspondent registers*/
 597   sTime->SubSeconds = (uint32_t)(hrtc->Instance->SSR);
 598
 599   /* Get the TR register */
 600   tmpreg = (uint32_t)(hrtc->Instance->TR & RTC_TR_RESERVED_MASK);
 601
 602   /* Fill the structure fields with the read parameters */
 603   sTime->Hours = (uint8_t)((tmpreg & (RTC_TR_HT | RTC_TR_HU)) >> 16);
 604   sTime->Minutes = (uint8_t)((tmpreg & (RTC_TR_MNT | RTC_TR_MNU)) >>8);
 605   sTime->Seconds = (uint8_t)(tmpreg & (RTC_TR_ST | RTC_TR_SU));
 606   sTime->TimeFormat = (uint8_t)((tmpreg & (RTC_TR_PM)) >> 16);
 607
 608   /* Check the input parameters format */
 609   if(Format == FORMAT_BIN)
 610   {
 611     /* Convert the time structure parameters to Binary format */
 612     sTime->Hours = (uint8_t)RTC_Bcd2ToByte(sTime->Hours);
 613     sTime->Minutes = (uint8_t)RTC_Bcd2ToByte(sTime->Minutes);
 614     sTime->Seconds = (uint8_t)RTC_Bcd2ToByte(sTime->Seconds);
 615   }
 616
 617   return HAL_OK;
 618 }
 619
 620 /**
 621   * @brief  Sets RTC current date.
 622   * @param  hrtc: RTC handle
 623   * @param  sDate: Pointer to date structure
 624   * @param  Format: specifies the format of the entered parameters.
 625   *          This parameter can be one of the following values:
 626   *            @arg Format_BIN: Binary data format
 627   *            @arg Format_BCD: BCD data format
 628   * @retval HAL status
 629   */
 630 HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
 631 {
 632   uint32_t datetmpreg = 0;
 633
 634  /* Check the parameters */
 635   assert_param(IS_RTC_FORMAT(Format));
 636
 637  /* Process Locked */
 638  __HAL_LOCK(hrtc);
 639
 640   hrtc->State = HAL_RTC_STATE_BUSY;
 641
 642   if((Format == FORMAT_BIN) && ((sDate->Month & 0x10) == 0x10))
 643   {
 644     sDate->Month = (uint8_t)((sDate->Month & (uint8_t)~(0x10)) + (uint8_t)0x0A);
 645   }
 646
 647   assert_param(IS_RTC_WEEKDAY(sDate->WeekDay));
 648
 649   if(Format == FORMAT_BIN)
 650   {
 651     assert_param(IS_RTC_YEAR(sDate->Year));
 652     assert_param(IS_RTC_MONTH(sDate->Month));
 653     assert_param(IS_RTC_DATE(sDate->Date));
 654
 655    datetmpreg = (((uint32_t)RTC_ByteToBcd2(sDate->Year) << 16) | \
 656                  ((uint32_t)RTC_ByteToBcd2(sDate->Month) << 8) | \
 657                  ((uint32_t)RTC_ByteToBcd2(sDate->Date)) | \
 658                  ((uint32_t)sDate->WeekDay << 13));
 659   }
 660   else
 661   {
 662     assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
 663     datetmpreg = RTC_Bcd2ToByte(sDate->Month);
 664     assert_param(IS_RTC_MONTH(datetmpreg));
 665     datetmpreg = RTC_Bcd2ToByte(sDate->Date);
 666     assert_param(IS_RTC_DATE(datetmpreg));
 667
 668     datetmpreg = ((((uint32_t)sDate->Year) << 16) | \
 669                   (((uint32_t)sDate->Month) << 8) | \
 670                   ((uint32_t)sDate->Date) | \
 671                   (((uint32_t)sDate->WeekDay) << 13));
 672   }
 673
 674   /* Disable the write protection for RTC registers */
 675   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
 676
 677   /* Set Initialization mode */
 678   if(RTC_EnterInitMode(hrtc) != HAL_OK)
 679   {
 680     /* Enable the write protection for RTC registers */
 681     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 682
 683     /* Set RTC state*/
 684     hrtc->State = HAL_RTC_STATE_ERROR;
 685
 686     /* Process Unlocked */
 687     __HAL_UNLOCK(hrtc);
 688
 689     return HAL_ERROR;
 690   }
 691   else
 692   {
 693     /* Set the RTC_DR register */
 694     hrtc->Instance->DR = (uint32_t)(datetmpreg & RTC_DR_RESERVED_MASK);
 695
 696     /* Exit Initialization mode */
 697     hrtc->Instance->ISR &= (uint32_t)~RTC_ISR_INIT;
 698
 699     /* If  CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
 700     if((hrtc->Instance->CR & RTC_CR_BYPSHAD) == RESET)
 701     {
 702       if(HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
 703       {
 704         /* Enable the write protection for RTC registers */
 705         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 706
 707         hrtc->State = HAL_RTC_STATE_ERROR;
 708
 709         /* Process Unlocked */
 710         __HAL_UNLOCK(hrtc);
 711
 712         return HAL_ERROR;
 713       }
 714     }
 715
 716     /* Enable the write protection for RTC registers */
 717     __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 718
 719     hrtc->State = HAL_RTC_STATE_READY ;
 720
 721     /* Process Unlocked */
 722     __HAL_UNLOCK(hrtc);
 723
 724     return HAL_OK;
 725   }
 726 }
 727
 728 /**
 729   * @brief  Gets RTC current date.
 730   * @param  hrtc: RTC handle
 731   * @param  sDate: Pointer to Date structure
 732   * @param  Format: Specifies the format of the entered parameters.
 733   *          This parameter can be one of the following values:
 734   *            @arg Format_BIN :  Binary data format
 735   *            @arg Format_BCD :  BCD data format
 736   * @retval HAL status
 737   */
 738 HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
 739 {
 740   uint32_t datetmpreg = 0;
 741
 742   /* Check the parameters */
 743   assert_param(IS_RTC_FORMAT(Format));
 744
 745   /* Get the DR register */
 746   datetmpreg = (uint32_t)(hrtc->Instance->DR & RTC_DR_RESERVED_MASK);
 747
 748   /* Fill the structure fields with the read parameters */
 749   sDate->Year = (uint8_t)((datetmpreg & (RTC_DR_YT | RTC_DR_YU)) >> 16);
 750   sDate->Month = (uint8_t)((datetmpreg & (RTC_DR_MT | RTC_DR_MU)) >> 8);
 751   sDate->Date = (uint8_t)(datetmpreg & (RTC_DR_DT | RTC_DR_DU));
 752   sDate->WeekDay = (uint8_t)((datetmpreg & (RTC_DR_WDU)) >> 13);
 753
 754   /* Check the input parameters format */
 755   if(Format == FORMAT_BIN)
 756   {
 757     /* Convert the date structure parameters to Binary format */
 758     sDate->Year = (uint8_t)RTC_Bcd2ToByte(sDate->Year);
 759     sDate->Month = (uint8_t)RTC_Bcd2ToByte(sDate->Month);
 760     sDate->Date = (uint8_t)RTC_Bcd2ToByte(sDate->Date);
 761   }
 762   return HAL_OK;
 763 }
 764
 765 /**
 766   * @}
 767   */
 768
 769 /** @defgroup RTC_Exported_Functions_Group3 RTC Alarm functions
 770  *  @brief   RTC Alarm functions
 771  *
 772 @verbatim
 773  ===============================================================================
 774                  ##### RTC Alarm functions #####
 775  ===============================================================================
 776
 777  [..] This section provide functions allowing to configure Alarm feature
 778
 779 @endverbatim
 780   * @{
 781   */
 782 /**
 783   * @brief  Sets the specified RTC Alarm.
 784   * @param  hrtc: RTC handle
 785   * @param  sAlarm: Pointer to Alarm structure
 786   * @param  Format: Specifies the format of the entered parameters.
 787   *          This parameter can be one of the following values:
 788   *             @arg Format_BIN: Binary data format
 789   *             @arg Format_BCD: BCD data format
 790   * @retval HAL status
 791   */
 792 HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
 793 {
 794   uint32_t tickstart = 0;
 795   uint32_t tmpreg = 0, subsecondtmpreg = 0;
 796
 797   /* Check the parameters */
 798   assert_param(IS_RTC_FORMAT(Format));
 799   assert_param(IS_ALARM(sAlarm->Alarm));
 800   assert_param(IS_ALARM_MASK(sAlarm->AlarmMask));
 801   assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
 802   assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
 803   assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
 804
 805   /* Process Locked */
 806   __HAL_LOCK(hrtc);
 807
 808   hrtc->State = HAL_RTC_STATE_BUSY;
 809
 810   if(Format == FORMAT_BIN)
 811   {
 812     if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
 813     {
 814       assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
 815       assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
 816     }
 817     else
 818     {
 819       sAlarm->AlarmTime.TimeFormat = 0x00;
 820       assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
 821     }
 822     assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
 823     assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
 824
 825     if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
 826     {
 827       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
 828     }
 829     else
 830     {
 831       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
 832     }
 833
 834     tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
 835               ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
 836               ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
 837               ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
 838               ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
 839               ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
 840               ((uint32_t)sAlarm->AlarmMask));
 841   }
 842   else
 843   {
 844     if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
 845     {
 846       tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
 847       assert_param(IS_RTC_HOUR12(tmpreg));
 848       assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
 849     }
 850     else
 851     {
 852       sAlarm->AlarmTime.TimeFormat = 0x00;
 853       assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
 854     }
 855
 856     assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
 857     assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
 858
 859     if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
 860     {
 861       tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
 862       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
 863     }
 864     else
 865     {
 866       tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
 867       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
 868     }
 869
 870     tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
 871               ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
 872               ((uint32_t) sAlarm->AlarmTime.Seconds) | \
 873               ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
 874               ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
 875               ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
 876               ((uint32_t)sAlarm->AlarmMask));
 877   }
 878
 879   /* Configure the Alarm A or Alarm B Sub Second registers */
 880   subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
 881
 882   /* Disable the write protection for RTC registers */
 883   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
 884
 885   /* Configure the Alarm register */
 886   if(sAlarm->Alarm == RTC_ALARM_A)
 887   {
 888     /* Disable the Alarm A interrupt */
 889     __HAL_RTC_ALARMA_DISABLE(hrtc);
 890
 891     /* In case of interrupt mode is used, the interrupt source must disabled */
 892     __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
 893
 894     tickstart = HAL_GetTick();
 895     /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
 896     while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
 897     {
 898       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
 899       {
 900         /* Enable the write protection for RTC registers */
 901         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 902
 903         hrtc->State = HAL_RTC_STATE_TIMEOUT;
 904
 905         /* Process Unlocked */
 906         __HAL_UNLOCK(hrtc);
 907
 908         return HAL_TIMEOUT;
 909       }
 910     }
 911
 912     hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
 913     /* Configure the Alarm A Sub Second register */
 914     hrtc->Instance->ALRMASSR = subsecondtmpreg;
 915     /* Configure the Alarm state: Enable Alarm */
 916     __HAL_RTC_ALARMA_ENABLE(hrtc);
 917   }
 918   else
 919   {
 920     /* Disable the Alarm B interrupt */
 921     __HAL_RTC_ALARMB_DISABLE(hrtc);
 922
 923     /* In case of interrupt mode is used, the interrupt source must disabled */
 924     __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRB);
 925
 926     tickstart = HAL_GetTick();
 927     /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
 928     while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
 929     {
 930       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
 931       {
 932         /* Enable the write protection for RTC registers */
 933         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 934
 935         hrtc->State = HAL_RTC_STATE_TIMEOUT;
 936
 937         /* Process Unlocked */
 938         __HAL_UNLOCK(hrtc);
 939
 940         return HAL_TIMEOUT;
 941       }
 942     }
 943
 944     hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
 945     /* Configure the Alarm B Sub Second register */
 946     hrtc->Instance->ALRMBSSR = subsecondtmpreg;
 947     /* Configure the Alarm state: Enable Alarm */
 948     __HAL_RTC_ALARMB_ENABLE(hrtc);
 949   }
 950
 951   /* Enable the write protection for RTC registers */
 952   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
 953
 954   /* Change RTC state */
 955   hrtc->State = HAL_RTC_STATE_READY;
 956
 957   /* Process Unlocked */
 958   __HAL_UNLOCK(hrtc);
 959
 960   return HAL_OK;
 961 }
 962
 963 /**
 964   * @brief  Sets the specified RTC Alarm with Interrupt
 965   * @param  hrtc: RTC handle
 966   * @param  sAlarm: Pointer to Alarm structure
 967   * @param  Format: Specifies the format of the entered parameters.
 968   *          This parameter can be one of the following values:
 969   *             @arg Format_BIN: Binary data format
 970   *             @arg Format_BCD: BCD data format
 971   * @note   The Alarm register can only be written when the corresponding Alarm
 972   *         is disabled (Use the HAL_RTC_DeactivateAlarm()).
 973   * @note   The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
 974   * @retval HAL status
 975   */
 976 HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
 977 {
 978   uint32_t tickstart = 0;
 979   uint32_t tmpreg = 0, subsecondtmpreg = 0;
 980
 981   /* Check the parameters */
 982   assert_param(IS_RTC_FORMAT(Format));
 983   assert_param(IS_ALARM(sAlarm->Alarm));
 984   assert_param(IS_ALARM_MASK(sAlarm->AlarmMask));
 985   assert_param(IS_RTC_ALARM_DATE_WEEKDAY_SEL(sAlarm->AlarmDateWeekDaySel));
 986   assert_param(IS_RTC_ALARM_SUB_SECOND_VALUE(sAlarm->AlarmTime.SubSeconds));
 987   assert_param(IS_RTC_ALARM_SUB_SECOND_MASK(sAlarm->AlarmSubSecondMask));
 988
 989   /* Process Locked */
 990   __HAL_LOCK(hrtc);
 991
 992   hrtc->State = HAL_RTC_STATE_BUSY;
 993
 994   if(Format == FORMAT_BIN)
 995   {
 996     if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
 997     {
 998       assert_param(IS_RTC_HOUR12(sAlarm->AlarmTime.Hours));
 999       assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
1000     }
1001     else
1002     {
1003       sAlarm->AlarmTime.TimeFormat = 0x00;
1004       assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
1005     }
1006     assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
1007     assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
1008
1009     if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
1010     {
1011       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(sAlarm->AlarmDateWeekDay));
1012     }
1013     else
1014     {
1015       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(sAlarm->AlarmDateWeekDay));
1016     }
1017     tmpreg = (((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Hours) << 16) | \
1018               ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes) << 8) | \
1019               ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds)) | \
1020               ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
1021               ((uint32_t)RTC_ByteToBcd2(sAlarm->AlarmDateWeekDay) << 24) | \
1022               ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
1023               ((uint32_t)sAlarm->AlarmMask));
1024   }
1025   else
1026   {
1027     if((hrtc->Instance->CR & RTC_CR_FMT) != (uint32_t)RESET)
1028     {
1029       tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
1030       assert_param(IS_RTC_HOUR12(tmpreg));
1031       assert_param(IS_RTC_HOURFORMAT12(sAlarm->AlarmTime.TimeFormat));
1032     }
1033     else
1034     {
1035       sAlarm->AlarmTime.TimeFormat = 0x00;
1036       assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
1037     }
1038
1039     assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
1040     assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
1041
1042     if(sAlarm->AlarmDateWeekDaySel == RTC_ALARMDATEWEEKDAYSEL_DATE)
1043     {
1044       tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
1045       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_DATE(tmpreg));
1046     }
1047     else
1048     {
1049       tmpreg = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
1050       assert_param(IS_RTC_ALARM_DATE_WEEKDAY_WEEKDAY(tmpreg));
1051     }
1052     tmpreg = (((uint32_t)(sAlarm->AlarmTime.Hours) << 16) | \
1053               ((uint32_t)(sAlarm->AlarmTime.Minutes) << 8) | \
1054               ((uint32_t) sAlarm->AlarmTime.Seconds) | \
1055               ((uint32_t)(sAlarm->AlarmTime.TimeFormat) << 16) | \
1056               ((uint32_t)(sAlarm->AlarmDateWeekDay) << 24) | \
1057               ((uint32_t)sAlarm->AlarmDateWeekDaySel) | \
1058               ((uint32_t)sAlarm->AlarmMask));
1059   }
1060   /* Configure the Alarm A or Alarm B Sub Second registers */
1061   subsecondtmpreg = (uint32_t)((uint32_t)(sAlarm->AlarmTime.SubSeconds) | (uint32_t)(sAlarm->AlarmSubSecondMask));
1062
1063   /* Disable the write protection for RTC registers */
1064   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
1065
1066   /* Configure the Alarm register */
1067   if(sAlarm->Alarm == RTC_ALARM_A)
1068   {
1069     /* Disable the Alarm A interrupt */
1070     __HAL_RTC_ALARMA_DISABLE(hrtc);
1071
1072     /* Clear flag alarm A */
1073     __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
1074
1075     tickstart = HAL_GetTick();
1076     /* Wait till RTC ALRAWF flag is set and if Time out is reached exit */
1077     while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
1078     {
1079       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
1080       {
1081         /* Enable the write protection for RTC registers */
1082         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
1083
1084         hrtc->State = HAL_RTC_STATE_TIMEOUT;
1085
1086         /* Process Unlocked */
1087         __HAL_UNLOCK(hrtc);
1088
1089         return HAL_TIMEOUT;
1090       }
1091     }
1092
1093     hrtc->Instance->ALRMAR = (uint32_t)tmpreg;
1094     /* Configure the Alarm A Sub Second register */
1095     hrtc->Instance->ALRMASSR = subsecondtmpreg;
1096     /* Configure the Alarm state: Enable Alarm */
1097     __HAL_RTC_ALARMA_ENABLE(hrtc);
1098     /* Configure the Alarm interrupt */
1099     __HAL_RTC_ALARM_ENABLE_IT(hrtc,RTC_IT_ALRA);
1100   }
1101   else
1102   {
1103     /* Disable the Alarm B interrupt */
1104     __HAL_RTC_ALARMB_DISABLE(hrtc);
1105
1106     /* Clear flag alarm B */
1107     __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRBF);
1108
1109     tickstart = HAL_GetTick();
1110     /* Wait till RTC ALRBWF flag is set and if Time out is reached exit */
1111     while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
1112     {
1113       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
1114       {
1115         /* Enable the write protection for RTC registers */
1116         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
1117
1118         hrtc->State = HAL_RTC_STATE_TIMEOUT;
1119
1120         /* Process Unlocked */
1121         __HAL_UNLOCK(hrtc);
1122
1123         return HAL_TIMEOUT;
1124       }
1125     }
1126
1127     hrtc->Instance->ALRMBR = (uint32_t)tmpreg;
1128     /* Configure the Alarm B Sub Second register */
1129     hrtc->Instance->ALRMBSSR = subsecondtmpreg;
1130     /* Configure the Alarm state: Enable Alarm */
1131     __HAL_RTC_ALARMB_ENABLE(hrtc);
1132     /* Configure the Alarm interrupt */
1133     __HAL_RTC_ALARM_ENABLE_IT(hrtc, RTC_IT_ALRB);
1134   }
1135
1136   /* RTC Alarm Interrupt Configuration: EXTI configuration */
1137   __HAL_RTC_ENABLE_IT(RTC_EXTI_LINE_ALARM_EVENT);
1138
1139   EXTI->RTSR |= RTC_EXTI_LINE_ALARM_EVENT;
1140
1141   /* Enable the write protection for RTC registers */
1142   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
1143
1144   hrtc->State = HAL_RTC_STATE_READY;
1145
1146   /* Process Unlocked */
1147   __HAL_UNLOCK(hrtc);
1148
1149   return HAL_OK;
1150 }
1151
1152 /**
1153   * @brief  Deactive the specified RTC Alarm
1154   * @param  hrtc: RTC handle
1155   * @param  Alarm: Specifies the Alarm.
1156   *          This parameter can be one of the following values:
1157   *            @arg ALARM_A :  AlarmA
1158   *            @arg ALARM_B :  AlarmB
1159   * @retval HAL status
1160   */
1161 HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm)
1162 {
1163   uint32_t tickstart = 0;
1164
1165   /* Check the parameters */
1166   assert_param(IS_ALARM(Alarm));
1167
1168   /* Process Locked */
1169   __HAL_LOCK(hrtc);
1170
1171   hrtc->State = HAL_RTC_STATE_BUSY;
1172
1173   /* Disable the write protection for RTC registers */
1174   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
1175
1176   if(Alarm == RTC_ALARM_A)
1177   {
1178     /* AlarmA */
1179     __HAL_RTC_ALARMA_DISABLE(hrtc);
1180
1181     /* In case of interrupt mode is used, the interrupt source must disabled */
1182     __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
1183
1184     tickstart = HAL_GetTick();
1185
1186     /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
1187     while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAWF) == RESET)
1188     {
1189       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
1190       {
1191         /* Enable the write protection for RTC registers */
1192         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
1193
1194         hrtc->State = HAL_RTC_STATE_TIMEOUT;
1195
1196         /* Process Unlocked */
1197         __HAL_UNLOCK(hrtc);
1198
1199         return HAL_TIMEOUT;
1200       }
1201     }
1202   }
1203   else
1204   {
1205     /* AlarmB */
1206     __HAL_RTC_ALARMB_DISABLE(hrtc);
1207
1208     /* In case of interrupt mode is used, the interrupt source must disabled */
1209     __HAL_RTC_ALARM_DISABLE_IT(hrtc,RTC_IT_ALRB);
1210
1211     tickstart = HAL_GetTick();
1212
1213     /* Wait till RTC ALRxWF flag is set and if Time out is reached exit */
1214     while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRBWF) == RESET)
1215     {
1216       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
1217       {
1218         /* Enable the write protection for RTC registers */
1219         __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
1220
1221         hrtc->State = HAL_RTC_STATE_TIMEOUT;
1222
1223         /* Process Unlocked */
1224         __HAL_UNLOCK(hrtc);
1225
1226         return HAL_TIMEOUT;
1227       }
1228     }
1229   }
1230   /* Enable the write protection for RTC registers */
1231   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
1232
1233   hrtc->State = HAL_RTC_STATE_READY;
1234
1235   /* Process Unlocked */
1236   __HAL_UNLOCK(hrtc);
1237
1238   return HAL_OK;
1239 }
1240
1241 /**
1242   * @brief  Gets the RTC Alarm value and masks.
1243   * @param  hrtc: RTC handle
1244   * @param  sAlarm: Pointer to Date structure
1245   * @param  Alarm: Specifies the Alarm
1246   *          This parameter can be one of the following values:
1247   *             @arg ALARM_A: AlarmA
1248   *             @arg ALARM_B: AlarmB
1249   * @param  Format: Specifies the format of the entered parameters.
1250   *          This parameter can be one of the following values:
1251   *             @arg Format_BIN: Binary data format
1252   *             @arg Format_BCD: BCD data format
1253   * @retval HAL status
1254   */
1255 HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Alarm, uint32_t Format)
1256 {
1257   uint32_t tmpreg = 0, subsecondtmpreg = 0;
1258
1259   /* Check the parameters */
1260   assert_param(IS_RTC_FORMAT(Format));
1261   assert_param(IS_ALARM(Alarm));
1262
1263   if(Alarm == RTC_ALARM_A)
1264   {
1265     /* AlarmA */
1266     sAlarm->Alarm = RTC_ALARM_A;
1267
1268     tmpreg = (uint32_t)(hrtc->Instance->ALRMAR);
1269     subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMASSR ) & RTC_ALRMASSR_SS);
1270   }
1271   else
1272   {
1273     sAlarm->Alarm = RTC_ALARM_B;
1274
1275     tmpreg = (uint32_t)(hrtc->Instance->ALRMBR);
1276     subsecondtmpreg = (uint32_t)((hrtc->Instance->ALRMBSSR) & RTC_ALRMBSSR_SS);
1277   }
1278
1279   /* Fill the structure with the read parameters */
1280   sAlarm->AlarmTime.Hours = (uint32_t)((tmpreg & (RTC_ALRMAR_HT | RTC_ALRMAR_HU)) >> 16);
1281   sAlarm->AlarmTime.Minutes = (uint32_t)((tmpreg & (RTC_ALRMAR_MNT | RTC_ALRMAR_MNU)) >> 8);
1282   sAlarm->AlarmTime.Seconds = (uint32_t)(tmpreg & (RTC_ALRMAR_ST | RTC_ALRMAR_SU));
1283   sAlarm->AlarmTime.TimeFormat = (uint32_t)((tmpreg & RTC_ALRMAR_PM) >> 16);
1284   sAlarm->AlarmTime.SubSeconds = (uint32_t) subsecondtmpreg;
1285   sAlarm->AlarmDateWeekDay = (uint32_t)((tmpreg & (RTC_ALRMAR_DT | RTC_ALRMAR_DU)) >> 24);
1286   sAlarm->AlarmDateWeekDaySel = (uint32_t)(tmpreg & RTC_ALRMAR_WDSEL);
1287   sAlarm->AlarmMask = (uint32_t)(tmpreg & RTC_ALARMMASK_ALL);
1288
1289   if(Format == FORMAT_BIN)
1290   {
1291     sAlarm->AlarmTime.Hours = RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours);
1292     sAlarm->AlarmTime.Minutes = RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes);
1293     sAlarm->AlarmTime.Seconds = RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds);
1294     sAlarm->AlarmDateWeekDay = RTC_Bcd2ToByte(sAlarm->AlarmDateWeekDay);
1295   }
1296
1297   return HAL_OK;
1298 }
1299
1300 /**
1301   * @brief  This function handles Alarm interrupt request.
1302   * @param  hrtc: RTC handle
1303   * @retval None
1304   */
1305 void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef* hrtc)
1306 {
1307   if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRA))
1308   {
1309     /* Get the status of the Interrupt */
1310     if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRA) != (uint32_t)RESET)
1311     {
1312       /* AlarmA callback */
1313       HAL_RTC_AlarmAEventCallback(hrtc);
1314
1315       /* Clear the Alarm interrupt pending bit */
1316       __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRAF);
1317     }
1318   }
1319
1320   if(__HAL_RTC_ALARM_GET_IT(hrtc, RTC_IT_ALRB))
1321   {
1322     /* Get the status of the Interrupt */
1323     if((uint32_t)(hrtc->Instance->CR & RTC_IT_ALRB) != (uint32_t)RESET)
1324     {
1325       /* AlarmB callback */
1326       HAL_RTCEx_AlarmBEventCallback(hrtc);
1327
1328       /* Clear the Alarm interrupt pending bit */
1329       __HAL_RTC_ALARM_CLEAR_FLAG(hrtc,RTC_FLAG_ALRBF);
1330     }
1331   }
1332
1333   /* Clear the EXTI's line Flag for RTC Alarm */
1334   __HAL_RTC_CLEAR_FLAG(RTC_EXTI_LINE_ALARM_EVENT);
1335
1336   /* Change RTC state */
1337   hrtc->State = HAL_RTC_STATE_READY;
1338 }
1339
1340 /**
1341   * @brief  Alarm A callback.
1342   * @param  hrtc: RTC handle
1343   * @retval None
1344   */
1345 __weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
1346 {
1347   /* NOTE : This function Should not be modified, when the callback is needed,
1348             the HAL_RTC_AlarmAEventCallback could be implemented in the user file
1349    */
1350 }
1351
1352 /**
1353   * @brief  This function handles AlarmA Polling request.
1354   * @param  hrtc: RTC handle
1355   * @param  Timeout: Timeout duration
1356   * @retval HAL status
1357   */
1358 HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
1359 {
1360
1361   uint32_t tickstart = HAL_GetTick();
1362
1363   while(__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET)
1364   {
1365     if(Timeout != HAL_MAX_DELAY)
1366     {
1367       if((Timeout == 0) || ((HAL_GetTick()-tickstart) > Timeout))
1368       {
1369         hrtc->State = HAL_RTC_STATE_TIMEOUT;
1370         return HAL_TIMEOUT;
1371       }
1372     }
1373   }
1374
1375   /* Clear the Alarm interrupt pending bit */
1376   __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
1377
1378   /* Change RTC state */
1379   hrtc->State = HAL_RTC_STATE_READY;
1380
1381   return HAL_OK;
1382 }
1383
1384 /**
1385   * @}
1386   */
1387
1388 /** @defgroup RTC_Exported_Functions_Group4 Peripheral Control functions
1389  *  @brief   Peripheral Control functions
1390  *
1391 @verbatim
1392  ===============================================================================
1393                      ##### Peripheral Control functions #####
1394  ===============================================================================
1395     [..]
1396     This subsection provides functions allowing to
1397       (+) Wait for RTC Time and Date Synchronization
1398
1399 @endverbatim
1400   * @{
1401   */
1402
1403 /**
1404   * @brief  Waits until the RTC Time and Date registers (RTC_TR and RTC_DR) are
1405   *         synchronized with RTC APB clock.
1406   * @note   The RTC Resynchronization mode is write protected, use the
1407   *         __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
1408   * @note   To read the calendar through the shadow registers after Calendar
1409   *         initialization, calendar update or after wakeup from low power modes
1410   *         the software must first clear the RSF flag.
1411   *         The software must then wait until it is set again before reading
1412   *         the calendar, which means that the calendar registers have been
1413   *         correctly copied into the RTC_TR and RTC_DR shadow registers.
1414   * @param  hrtc: RTC handle
1415   * @retval HAL status
1416   */
1417 HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef* hrtc)
1418 {
1419   uint32_t tickstart = 0;
1420
1421   /* Clear RSF flag */
1422   hrtc->Instance->ISR &= (uint32_t)RTC_RSF_MASK;
1423
1424   tickstart = HAL_GetTick();
1425
1426   /* Wait the registers to be synchronised */
1427   while((hrtc->Instance->ISR & RTC_ISR_RSF) == (uint32_t)RESET)
1428   {
1429     if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
1430     {
1431       return HAL_TIMEOUT;
1432     }
1433   }
1434
1435   return HAL_OK;
1436 }
1437
1438 /**
1439   * @}
1440   */
1441
1442 /** @defgroup RTC_Exported_Functions_Group5 Peripheral State functions
1443  *  @brief   Peripheral State functions
1444  *
1445 @verbatim
1446  ===============================================================================
1447                      ##### Peripheral State functions #####
1448  ===============================================================================
1449     [..]
1450     This subsection provides functions allowing to
1451       (+) Get RTC state
1452
1453 @endverbatim
1454   * @{
1455   */
1456 /**
1457   * @brief  Returns the Alarm state.
1458   * @param  hrtc: RTC handle
1459   * @retval HAL state
1460   */
1461 HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef* hrtc)
1462 {
1463   return hrtc->State;
1464 }
1465
1466 /**
1467   * @}
1468   */
1469
1470 /**
1471   * @}
1472   */
1473
1474 /** @defgroup RTC_Private_Functions RTC Private Functions
1475   * @{
1476   */
1477
1478 /**
1479   * @brief  Enters the RTC Initialization mode.
1480   * @note   The RTC Initialization mode is write protected, use the
1481   *         __HAL_RTC_WRITEPROTECTION_DISABLE() before calling this function.
1482   * @param  hrtc: RTC handle
1483   * @retval An ErrorStatus enumeration value:
1484   *          - HAL_OK : RTC is in Init mode
1485   *          - HAL_TIMEOUT : RTC is not in Init mode and in Timeout
1486   */
1487 HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef* hrtc)
1488 {
1489   uint32_t tickstart = 0;
1490
1491   /* Check if the Initialization mode is set */
1492   if((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
1493   {
1494     /* Set the Initialization mode */
1495     hrtc->Instance->ISR = (uint32_t)RTC_INIT_MASK;
1496
1497     tickstart = HAL_GetTick();
1498     /* Wait till RTC is in INIT state and if Time out is reached exit */
1499     while((hrtc->Instance->ISR & RTC_ISR_INITF) == (uint32_t)RESET)
1500     {
1501       if((HAL_GetTick()-tickstart) > RTC_TIMEOUT_VALUE)
1502       {
1503         return HAL_TIMEOUT;
1504       }
1505     }
1506   }
1507
1508   return HAL_OK;
1509 }
1510
1511
1512 /**
1513   * @brief  Converts a 2 digit decimal to BCD format.
1514   * @param  Value: Byte to be converted
1515   * @retval Converted byte
1516   */
1517 uint8_t RTC_ByteToBcd2(uint8_t Value)
1518 {
1519   uint32_t bcdhigh = 0;
1520
1521   while(Value >= 10)
1522   {
1523     bcdhigh++;
1524     Value -= 10;
1525   }
1526
1527   return  ((uint8_t)(bcdhigh << 4) | Value);
1528 }
1529
1530 /**
1531   * @brief  Converts from 2 digit BCD to Binary.
1532   * @param  Value: BCD value to be converted
1533   * @retval Converted word
1534   */
1535 uint8_t RTC_Bcd2ToByte(uint8_t Value)
1536 {
1537   uint32_t tmp = 0;
1538   tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10;
1539   return (tmp + (Value & (uint8_t)0x0F));
1540 }
1541
1542 /**
1543   * @}
1544   */
1545
1546 #endif /* HAL_RTC_MODULE_ENABLED */
1547
1548 /**
1549   * @}
1550   */
1551
1552 /**
1553   * @}
1554   */
1555
1556 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/