Subversion Repositories dashGPS

Rev

Blame | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_hal_rtc.c
  4.   * @author  MCD Application Team
  5.   * @brief   RTC HAL module driver.
  6.   *          This file provides firmware functions to manage the following
  7.   *          functionalities of the Real Time Clock (RTC) peripheral:
  8.   *           + Initialization and de-initialization functions
  9.   *           + RTC Time and Date functions
  10.   *           + RTC Alarm functions
  11.   *           + Peripheral Control functions
  12.   *           + Peripheral State functions
  13.   *
  14.   @verbatim
  15.   ==============================================================================
  16.                   ##### How to use this driver #####
  17.   ==================================================================
  18.   [..]
  19.     (+) Enable the RTC domain access (see description in the section above).
  20.     (+) Configure the RTC Prescaler (Asynchronous prescaler to generate RTC 1Hz time base)
  21.         using the HAL_RTC_Init() function.
  22.  
  23.   *** Time and Date configuration ***
  24.   ===================================
  25.   [..]
  26.     (+) To configure the RTC Calendar (Time and Date) use the HAL_RTC_SetTime()
  27.         and HAL_RTC_SetDate() functions.
  28.     (+) To read the RTC Calendar, use the HAL_RTC_GetTime() and HAL_RTC_GetDate() functions.
  29.  
  30.   *** Alarm configuration ***
  31.   ===========================
  32.   [..]
  33.     (+) To configure the RTC Alarm use the HAL_RTC_SetAlarm() function.
  34.         You can also configure the RTC Alarm with interrupt mode using the HAL_RTC_SetAlarm_IT() function.
  35.     (+) To read the RTC Alarm, use the HAL_RTC_GetAlarm() function.
  36.  
  37.   *** Tamper configuration ***
  38.   ============================
  39.   [..]
  40.     (+) Enable the RTC Tamper and configure the Tamper Level using the
  41.         HAL_RTCEx_SetTamper() function. You can configure RTC Tamper with interrupt
  42.         mode using HAL_RTCEx_SetTamper_IT() function.
  43.     (+) The TAMPER1 alternate function can be mapped to PC13
  44.  
  45.   *** Backup Data Registers configuration ***
  46.   ===========================================
  47.   [..]
  48.     (+) To write to the RTC Backup Data registers, use the HAL_RTCEx_BKUPWrite()
  49.         function.
  50.     (+) To read the RTC Backup Data registers, use the HAL_RTCEx_BKUPRead()
  51.         function.
  52.  
  53.                   ##### WARNING: Drivers Restrictions  #####
  54.   ==================================================================
  55.   [..] RTC version used on STM32F1 families is version V1. All the features supported by V2
  56.        (other families) will be not supported on F1.
  57.   [..] As on V2, main RTC features are managed by HW. But on F1, date feature is completely
  58.        managed by SW.
  59.   [..] Then, there are some restrictions compared to other families:
  60.     (+) Only format 24 hours supported in HAL (format 12 hours not supported)
  61.     (+) Date is saved in SRAM. Then, when MCU is in STOP or STANDBY mode, date will be lost.
  62.         User should implement a way to save date before entering in low power mode (an
  63.         example is provided with firmware package based on backup registers)
  64.     (+) Date is automatically updated each time a HAL_RTC_GetTime or HAL_RTC_GetDate is called.
  65.     (+) Alarm detection is limited to 1 day. It will expire only 1 time (no alarm repetition, need
  66.         to program a new alarm)
  67.  
  68.               ##### Backup Domain Operating Condition #####
  69.   ==============================================================================
  70.   [..] The real-time clock (RTC) and the RTC backup registers can be powered
  71.        from the VBAT voltage when the main VDD supply is powered off.
  72.        To retain the content of the RTC backup registers and supply the RTC
  73.        when VDD is turned off, VBAT pin can be connected to an optional
  74.        standby voltage supplied by a battery or by another source.
  75.  
  76.   [..] To allow the RTC operating even when the main digital supply (VDD) is turned
  77.        off, the VBAT pin powers the following blocks:
  78.     (#) The RTC
  79.     (#) The LSE oscillator
  80.     (#) The backup SRAM when the low power backup regulator is enabled
  81.     (#) PC13 to PC15 I/Os, plus PI8 I/O (when available)
  82.  
  83.   [..] When the backup domain is supplied by VDD (analog switch connected to VDD),
  84.        the following pins are available:
  85.     (+) PC13 can be used as a Tamper pin
  86.  
  87.   [..] When the backup domain is supplied by VBAT (analog switch connected to VBAT
  88.        because VDD is not present), the following pins are available:
  89.     (+) PC13 can be used as the Tamper pin
  90.  
  91.                    ##### Backup Domain Reset #####
  92.   ==================================================================
  93.   [..] The backup domain reset sets all RTC registers and the RCC_BDCR register
  94.        to their reset values.
  95.   [..] A backup domain reset is generated when one of the following events occurs:
  96.     (#) Software reset, triggered by setting the BDRST bit in the
  97.         RCC Backup domain control register (RCC_BDCR).
  98.     (#) VDD or VBAT power on, if both supplies have previously been powered off.
  99.     (#) Tamper detection event resets all data backup registers.
  100.  
  101.                    ##### Backup Domain Access #####
  102.   ==================================================================
  103.   [..] After reset, the backup domain (RTC registers, RTC backup data
  104.        registers and backup SRAM) is protected against possible unwanted write
  105.        accesses.
  106.   [..] To enable access to the RTC Domain and RTC registers, proceed as follows:
  107.     (+) Call the function HAL_RCCEx_PeriphCLKConfig in using RCC_PERIPHCLK_RTC for
  108.         PeriphClockSelection and select RTCClockSelection (LSE, LSI or HSE)
  109.     (+) Enable the BKP clock in using __HAL_RCC_BKP_CLK_ENABLE()
  110.  
  111.                   ##### RTC and low power modes #####
  112.   ==================================================================
  113.   [..] The MCU can be woken up from a low power mode by an RTC alternate
  114.        function.
  115.   [..] The RTC alternate functions are the RTC alarms (Alarm A),
  116.        and RTC tamper event detection.
  117.        These RTC alternate functions can wake up the system from the Stop and
  118.        Standby low power modes.
  119.   [..] The system can also wake up from low power modes without depending
  120.        on an external interrupt (Auto-wakeup mode), by using the RTC alarm.
  121.  
  122.   *** Callback registration ***
  123.   =============================================
  124.   [..]
  125.   The compilation define  USE_HAL_RTC_REGISTER_CALLBACKS when set to 1
  126.   allows the user to configure dynamically the driver callbacks.
  127.   Use Function @ref HAL_RTC_RegisterCallback() to register an interrupt callback.
  128.  
  129.   [..]
  130.   Function @ref HAL_RTC_RegisterCallback() allows to register following callbacks:
  131.     (+) AlarmAEventCallback          : RTC Alarm A Event callback.
  132.     (+) Tamper1EventCallback         : RTC Tamper 1 Event callback.
  133.     (+) MspInitCallback              : RTC MspInit callback.
  134.     (+) MspDeInitCallback            : RTC MspDeInit callback.
  135.   [..]   
  136.   This function takes as parameters the HAL peripheral handle, the Callback ID
  137.   and a pointer to the user callback function.
  138.  
  139.   [..]
  140.   Use function @ref HAL_RTC_UnRegisterCallback() to reset a callback to the default
  141.   weak function.
  142.   @ref HAL_RTC_UnRegisterCallback() takes as parameters the HAL peripheral handle,
  143.   and the Callback ID.
  144.   This function allows to reset following callbacks:
  145.     (+) AlarmAEventCallback          : RTC Alarm A Event callback.
  146.     (+) Tamper1EventCallback         : RTC Tamper 1 Event callback.
  147.     (+) MspInitCallback              : RTC MspInit callback.
  148.     (+) MspDeInitCallback            : RTC MspDeInit callback.
  149.   [..]
  150.   By default, after the @ref HAL_RTC_Init() and when the state is HAL_RTC_STATE_RESET,
  151.   all callbacks are set to the corresponding weak functions :
  152.   example @ref AlarmAEventCallback().
  153.   Exception done for MspInit and MspDeInit callbacks that are reset to the legacy weak function
  154.   in the @ref HAL_RTC_Init()/@ref HAL_RTC_DeInit() only when these callbacks are null
  155.   (not registered beforehand).
  156.   If not, MspInit or MspDeInit are not null, @ref HAL_RTC_Init()/@ref HAL_RTC_DeInit()
  157.   keep and use the user MspInit/MspDeInit callbacks (registered beforehand)
  158.   [..]
  159.   Callbacks can be registered/unregistered in HAL_RTC_STATE_READY state only.
  160.   Exception done MspInit/MspDeInit that can be registered/unregistered
  161.   in HAL_RTC_STATE_READY or HAL_RTC_STATE_RESET state,
  162.   thus registered (user) MspInit/DeInit callbacks can be used during the Init/DeInit.
  163.   In that case first register the MspInit/MspDeInit user callbacks
  164.   using @ref HAL_RTC_RegisterCallback() before calling @ref HAL_RTC_DeInit()
  165.   or @ref HAL_RTC_Init() function.
  166.   [..]
  167.   When The compilation define USE_HAL_RTC_REGISTER_CALLBACKS is set to 0 or
  168.   not defined, the callback registration feature is not available and all callbacks
  169.   are set to the corresponding weak functions.
  170.    @endverbatim
  171.   ******************************************************************************
  172.   * @attention
  173.   *
  174.   * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
  175.   * All rights reserved.</center></h2>
  176.   *
  177.   * This software component is licensed by ST under BSD 3-Clause license,
  178.   * the "License"; You may not use this file except in compliance with the
  179.   * License. You may obtain a copy of the License at:
  180.   *                        opensource.org/licenses/BSD-3-Clause
  181.   *
  182.   ******************************************************************************
  183.   */
  184.  
  185. /* Includes ------------------------------------------------------------------*/
  186. #include "stm32f1xx_hal.h"
  187.  
  188. /** @addtogroup STM32F1xx_HAL_Driver
  189.   * @{
  190.   */
  191.  
  192. /** @defgroup RTC RTC
  193.   * @brief RTC HAL module driver
  194.   * @{
  195.   */
  196.  
  197. #ifdef HAL_RTC_MODULE_ENABLED
  198.  
  199. /* Private typedef -----------------------------------------------------------*/
  200. /* Private define ------------------------------------------------------------*/
  201. /** @defgroup RTC_Private_Constants RTC Private Constants
  202.   * @{
  203.   */
  204. #define RTC_ALARM_RESETVALUE_REGISTER    (uint16_t)0xFFFF
  205. #define RTC_ALARM_RESETVALUE             0xFFFFFFFFU
  206.  
  207. /**
  208.   * @}
  209.   */
  210.  
  211. /* Private macro -------------------------------------------------------------*/
  212. /** @defgroup RTC_Private_Macros RTC Private Macros
  213.   * @{
  214.   */
  215. /**
  216.   * @}
  217.   */
  218.  
  219. /* Private variables ---------------------------------------------------------*/
  220. /* Private function prototypes -----------------------------------------------*/
  221. /** @defgroup RTC_Private_Functions RTC Private Functions
  222.   * @{
  223.   */
  224. static uint32_t           RTC_ReadTimeCounter(RTC_HandleTypeDef *hrtc);
  225. static HAL_StatusTypeDef  RTC_WriteTimeCounter(RTC_HandleTypeDef *hrtc, uint32_t TimeCounter);
  226. static uint32_t           RTC_ReadAlarmCounter(RTC_HandleTypeDef *hrtc);
  227. static HAL_StatusTypeDef  RTC_WriteAlarmCounter(RTC_HandleTypeDef *hrtc, uint32_t AlarmCounter);
  228. static HAL_StatusTypeDef  RTC_EnterInitMode(RTC_HandleTypeDef *hrtc);
  229. static HAL_StatusTypeDef  RTC_ExitInitMode(RTC_HandleTypeDef *hrtc);
  230. static uint8_t            RTC_ByteToBcd2(uint8_t Value);
  231. static uint8_t            RTC_Bcd2ToByte(uint8_t Value);
  232. static uint8_t            RTC_IsLeapYear(uint16_t nYear);
  233. static void               RTC_DateUpdate(RTC_HandleTypeDef *hrtc, uint32_t DayElapsed);
  234. static uint8_t            RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay);
  235.  
  236. /**
  237.   * @}
  238.   */
  239.  
  240. /* Private functions ---------------------------------------------------------*/
  241. /** @defgroup RTC_Exported_Functions RTC Exported Functions
  242.   * @{
  243.   */
  244.  
  245. /** @defgroup RTC_Exported_Functions_Group1 Initialization and de-initialization functions
  246.  *  @brief    Initialization and Configuration functions
  247.  *
  248. @verbatim
  249.  ===============================================================================
  250.               ##### Initialization and de-initialization functions #####
  251.  ===============================================================================
  252.    [..] This section provides functions allowing to initialize and configure the
  253.          RTC Prescaler (Asynchronous), disable RTC registers Write protection,
  254.          enter and exit the RTC initialization mode,
  255.          RTC registers synchronization check and reference clock detection enable.
  256.          (#) The RTC Prescaler should be programmed to generate the RTC 1Hz time base.
  257.          (#) All RTC registers are Write protected. Writing to the RTC registers
  258.              is enabled by setting the CNF bit in the RTC_CRL register.
  259.          (#) To read the calendar after wakeup from low power modes (Standby or Stop)
  260.              the software must first wait for the RSF bit (Register Synchronized Flag)
  261.              in the RTC_CRL register to be set by hardware.
  262.              The HAL_RTC_WaitForSynchro() function implements the above software
  263.              sequence (RSF clear and RSF check).
  264.  
  265. @endverbatim
  266.   * @{
  267.   */
  268.  
  269. /**
  270.   * @brief  Initializes the RTC peripheral
  271.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  272.   *                the configuration information for RTC.
  273.   * @retval HAL status
  274.   */
  275. HAL_StatusTypeDef HAL_RTC_Init(RTC_HandleTypeDef *hrtc)
  276. {
  277.   uint32_t prescaler = 0U;
  278.   /* Check input parameters */
  279.   if (hrtc == NULL)
  280.   {
  281.     return HAL_ERROR;
  282.   }
  283.  
  284.   /* Check the parameters */
  285.   assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
  286.   assert_param(IS_RTC_CALIB_OUTPUT(hrtc->Init.OutPut));
  287.   assert_param(IS_RTC_ASYNCH_PREDIV(hrtc->Init.AsynchPrediv));
  288.  
  289. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  290.   if (hrtc->State == HAL_RTC_STATE_RESET)
  291.   {
  292.     /* Allocate lock resource and initialize it */
  293.     hrtc->Lock = HAL_UNLOCKED;
  294.  
  295.     hrtc->AlarmAEventCallback          =  HAL_RTC_AlarmAEventCallback;        /* Legacy weak AlarmAEventCallback      */
  296.     hrtc->Tamper1EventCallback         =  HAL_RTCEx_Tamper1EventCallback;     /* Legacy weak Tamper1EventCallback     */
  297.  
  298.     if (hrtc->MspInitCallback == NULL)
  299.     {
  300.       hrtc->MspInitCallback = HAL_RTC_MspInit;
  301.     }
  302.     /* Init the low level hardware */
  303.     hrtc->MspInitCallback(hrtc);
  304.  
  305.     if (hrtc->MspDeInitCallback == NULL)
  306.     {
  307.       hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
  308.     }
  309.   }
  310. #else
  311.   if (hrtc->State == HAL_RTC_STATE_RESET)
  312.   {
  313.     /* Allocate lock resource and initialize it */
  314.     hrtc->Lock = HAL_UNLOCKED;
  315.  
  316.     /* Initialize RTC MSP */
  317.     HAL_RTC_MspInit(hrtc);
  318.   }
  319. #endif /* (USE_HAL_RTC_REGISTER_CALLBACKS) */
  320.  
  321.   /* Set RTC state */
  322.   hrtc->State = HAL_RTC_STATE_BUSY;
  323.  
  324.   /* Waiting for synchro */
  325.   if (HAL_RTC_WaitForSynchro(hrtc) != HAL_OK)
  326.   {
  327.     /* Set RTC state */
  328.     hrtc->State = HAL_RTC_STATE_ERROR;
  329.  
  330.     return HAL_ERROR;
  331.   }
  332.  
  333.   /* Set Initialization mode */
  334.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  335.   {
  336.     /* Set RTC state */
  337.     hrtc->State = HAL_RTC_STATE_ERROR;
  338.  
  339.     return HAL_ERROR;
  340.   }
  341.   else
  342.   {
  343.     /* Clear Flags Bits */
  344.     CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_OW | RTC_FLAG_ALRAF | RTC_FLAG_SEC));
  345.  
  346.     if (hrtc->Init.OutPut != RTC_OUTPUTSOURCE_NONE)
  347.     {
  348.       /* Disable the selected Tamper pin */
  349.       CLEAR_BIT(BKP->CR, BKP_CR_TPE);
  350.     }
  351.  
  352.     /* Set the signal which will be routed to RTC Tamper pin*/
  353.     MODIFY_REG(BKP->RTCCR, (BKP_RTCCR_CCO | BKP_RTCCR_ASOE | BKP_RTCCR_ASOS), hrtc->Init.OutPut);
  354.  
  355.     if (hrtc->Init.AsynchPrediv != RTC_AUTO_1_SECOND)
  356.     {
  357.       /* RTC Prescaler provided directly by end-user*/
  358.       prescaler = hrtc->Init.AsynchPrediv;
  359.     }
  360.     else
  361.     {
  362.       /* RTC Prescaler will be automatically calculated to get 1 second timebase */
  363.       /* Get the RTCCLK frequency */
  364.       prescaler = HAL_RCCEx_GetPeriphCLKFreq(RCC_PERIPHCLK_RTC);
  365.  
  366.       /* Check that RTC clock is enabled*/
  367.       if (prescaler == 0U)
  368.       {
  369.         /* Should not happen. Frequency is not available*/
  370.         hrtc->State = HAL_RTC_STATE_ERROR;
  371.         return HAL_ERROR;
  372.       }
  373.       else
  374.       {
  375.         /* RTC period = RTCCLK/(RTC_PR + 1) */
  376.         prescaler = prescaler - 1U;
  377.       }
  378.     }
  379.  
  380.     /* Configure the RTC_PRLH / RTC_PRLL */
  381.     MODIFY_REG(hrtc->Instance->PRLH, RTC_PRLH_PRL, (prescaler >> 16U));
  382.     MODIFY_REG(hrtc->Instance->PRLL, RTC_PRLL_PRL, (prescaler & RTC_PRLL_PRL));
  383.  
  384.     /* Wait for synchro */
  385.     if (RTC_ExitInitMode(hrtc) != HAL_OK)
  386.     {
  387.       hrtc->State = HAL_RTC_STATE_ERROR;
  388.  
  389.       return HAL_ERROR;
  390.     }
  391.  
  392.     /* Initialize date to 1st of January 2000 */
  393.     hrtc->DateToUpdate.Year = 0x00U;
  394.     hrtc->DateToUpdate.Month = RTC_MONTH_JANUARY;
  395.     hrtc->DateToUpdate.Date = 0x01U;
  396.  
  397.     /* Set RTC state */
  398.     hrtc->State = HAL_RTC_STATE_READY;
  399.  
  400.     return HAL_OK;
  401.   }
  402. }
  403.  
  404. /**
  405.   * @brief  DeInitializes the RTC peripheral
  406.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  407.   *                the configuration information for RTC.
  408.   * @note   This function does not reset the RTC Backup Data registers.
  409.   * @retval HAL status
  410.   */
  411. HAL_StatusTypeDef HAL_RTC_DeInit(RTC_HandleTypeDef *hrtc)
  412. {
  413.   /* Check input parameters */
  414.   if (hrtc == NULL)
  415.   {
  416.     return HAL_ERROR;
  417.   }
  418.  
  419.   /* Check the parameters */
  420.   assert_param(IS_RTC_ALL_INSTANCE(hrtc->Instance));
  421.  
  422.   /* Set RTC state */
  423.   hrtc->State = HAL_RTC_STATE_BUSY;
  424.  
  425.   /* Set Initialization mode */
  426.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  427.   {
  428.     /* Set RTC state */
  429.     hrtc->State = HAL_RTC_STATE_ERROR;
  430.  
  431.     /* Release Lock */
  432.     __HAL_UNLOCK(hrtc);
  433.  
  434.     return HAL_ERROR;
  435.   }
  436.   else
  437.   {
  438.     CLEAR_REG(hrtc->Instance->CNTL);
  439.     CLEAR_REG(hrtc->Instance->CNTH);
  440.     WRITE_REG(hrtc->Instance->PRLL, 0x00008000U);
  441.     CLEAR_REG(hrtc->Instance->PRLH);
  442.  
  443.     /* Reset All CRH/CRL bits */
  444.     CLEAR_REG(hrtc->Instance->CRH);
  445.     CLEAR_REG(hrtc->Instance->CRL);
  446.  
  447.     if (RTC_ExitInitMode(hrtc) != HAL_OK)
  448.     {
  449.       hrtc->State = HAL_RTC_STATE_ERROR;
  450.  
  451.       /* Process Unlocked */
  452.       __HAL_UNLOCK(hrtc);
  453.  
  454.       return HAL_ERROR;
  455.     }
  456.   }
  457.  
  458.   /* Wait for synchro*/
  459.   HAL_RTC_WaitForSynchro(hrtc);
  460.  
  461.   /* Clear RSF flag */
  462.   CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);
  463.  
  464. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  465.   if (hrtc->MspDeInitCallback == NULL)
  466.   {
  467.     hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
  468.   }
  469.  
  470.   /* DeInit the low level hardware: CLOCK, NVIC.*/
  471.   hrtc->MspDeInitCallback(hrtc);
  472.  
  473. #else
  474.   /* De-Initialize RTC MSP */
  475.   HAL_RTC_MspDeInit(hrtc);
  476. #endif /* (USE_HAL_RTC_REGISTER_CALLBACKS) */
  477.  
  478.   hrtc->State = HAL_RTC_STATE_RESET;
  479.  
  480.   /* Release Lock */
  481.   __HAL_UNLOCK(hrtc);
  482.  
  483.   return HAL_OK;
  484. }
  485.  
  486. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  487. /**
  488.   * @brief  Register a User RTC Callback
  489.   *         To be used instead of the weak predefined callback
  490.   * @param  hrtc RTC handle
  491.   * @param  CallbackID ID of the callback to be registered
  492.   *         This parameter can be one of the following values:
  493.   *          @arg @ref HAL_RTC_ALARM_A_EVENT_CB_ID          Alarm A Event Callback ID
  494.   *          @arg @ref HAL_RTC_TAMPER1_EVENT_CB_ID          Tamper 1 Callback ID
  495.   *          @arg @ref HAL_RTC_MSPINIT_CB_ID                Msp Init callback ID
  496.   *          @arg @ref HAL_RTC_MSPDEINIT_CB_ID              Msp DeInit callback ID
  497.   * @param  pCallback pointer to the Callback function
  498.   * @retval HAL status
  499.   */
  500. HAL_StatusTypeDef HAL_RTC_RegisterCallback(RTC_HandleTypeDef *hrtc, HAL_RTC_CallbackIDTypeDef CallbackID, pRTC_CallbackTypeDef pCallback)
  501. {
  502.   HAL_StatusTypeDef status = HAL_OK;
  503.  
  504.   if (pCallback == NULL)
  505.   {
  506.     return HAL_ERROR;
  507.   }
  508.  
  509.   /* Process locked */
  510.   __HAL_LOCK(hrtc);
  511.  
  512.   if (HAL_RTC_STATE_READY == hrtc->State)
  513.   {
  514.     switch (CallbackID)
  515.     {
  516.       case HAL_RTC_ALARM_A_EVENT_CB_ID :
  517.         hrtc->AlarmAEventCallback = pCallback;
  518.         break;
  519.  
  520.       case HAL_RTC_TAMPER1_EVENT_CB_ID :
  521.         hrtc->Tamper1EventCallback = pCallback;
  522.         break;
  523.  
  524.       case HAL_RTC_MSPINIT_CB_ID :
  525.         hrtc->MspInitCallback = pCallback;
  526.         break;
  527.  
  528.       case HAL_RTC_MSPDEINIT_CB_ID :
  529.         hrtc->MspDeInitCallback = pCallback;
  530.         break;
  531.  
  532.       default :
  533.         /* Return error status */
  534.         status =  HAL_ERROR;
  535.         break;
  536.     }
  537.   }
  538.   else if (HAL_RTC_STATE_RESET == hrtc->State)
  539.   {
  540.     switch (CallbackID)
  541.     {
  542.       case HAL_RTC_MSPINIT_CB_ID :
  543.         hrtc->MspInitCallback = pCallback;
  544.         break;
  545.  
  546.       case HAL_RTC_MSPDEINIT_CB_ID :
  547.         hrtc->MspDeInitCallback = pCallback;
  548.         break;
  549.  
  550.       default :
  551.         /* Return error status */
  552.         status =  HAL_ERROR;
  553.         break;
  554.     }
  555.   }
  556.   else
  557.   {
  558.     /* Return error status */
  559.     status =  HAL_ERROR;
  560.   }
  561.  
  562.   /* Release Lock */
  563.   __HAL_UNLOCK(hrtc);
  564.  
  565.   return status;
  566. }
  567.  
  568. /**
  569.   * @brief  Unregister an RTC Callback
  570.   *         RTC callabck is redirected to the weak predefined callback
  571.   * @param  hrtc RTC handle
  572.   * @param  CallbackID ID of the callback to be unregistered
  573.   *         This parameter can be one of the following values:
  574.   *          @arg @ref HAL_RTC_ALARM_A_EVENT_CB_ID          Alarm A Event Callback ID
  575.   *          @arg @ref HAL_RTC_TAMPER1_EVENT_CB_ID          Tamper 1 Callback ID
  576.   *          @arg @ref HAL_RTC_MSPINIT_CB_ID Msp Init callback ID
  577.   *          @arg @ref HAL_RTC_MSPDEINIT_CB_ID Msp DeInit callback ID
  578.   * @retval HAL status
  579.   */
  580. HAL_StatusTypeDef HAL_RTC_UnRegisterCallback(RTC_HandleTypeDef *hrtc, HAL_RTC_CallbackIDTypeDef CallbackID)
  581. {
  582.   HAL_StatusTypeDef status = HAL_OK;
  583.  
  584.   /* Process locked */
  585.   __HAL_LOCK(hrtc);
  586.  
  587.   if (HAL_RTC_STATE_READY == hrtc->State)
  588.   {
  589.     switch (CallbackID)
  590.     {
  591.       case HAL_RTC_ALARM_A_EVENT_CB_ID :
  592.         hrtc->AlarmAEventCallback = HAL_RTC_AlarmAEventCallback;         /* Legacy weak AlarmAEventCallback    */
  593.         break;
  594.  
  595.       case HAL_RTC_TAMPER1_EVENT_CB_ID :
  596.         hrtc->Tamper1EventCallback = HAL_RTCEx_Tamper1EventCallback;         /* Legacy weak Tamper1EventCallback   */
  597.         break;
  598.  
  599.       case HAL_RTC_MSPINIT_CB_ID :
  600.         hrtc->MspInitCallback = HAL_RTC_MspInit;
  601.         break;
  602.  
  603.       case HAL_RTC_MSPDEINIT_CB_ID :
  604.         hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
  605.         break;
  606.  
  607.       default :
  608.         /* Return error status */
  609.         status =  HAL_ERROR;
  610.         break;
  611.     }
  612.   }
  613.   else if (HAL_RTC_STATE_RESET == hrtc->State)
  614.   {
  615.     switch (CallbackID)
  616.     {
  617.       case HAL_RTC_MSPINIT_CB_ID :
  618.         hrtc->MspInitCallback = HAL_RTC_MspInit;
  619.         break;
  620.  
  621.       case HAL_RTC_MSPDEINIT_CB_ID :
  622.         hrtc->MspDeInitCallback = HAL_RTC_MspDeInit;
  623.         break;
  624.  
  625.       default :
  626.         /* Return error status */
  627.         status =  HAL_ERROR;
  628.         break;
  629.     }
  630.   }
  631.   else
  632.   {
  633.     /* Return error status */
  634.     status =  HAL_ERROR;
  635.   }
  636.  
  637.   /* Release Lock */
  638.   __HAL_UNLOCK(hrtc);
  639.  
  640.   return status;
  641. }
  642. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  643.  
  644. /**
  645.   * @brief  Initializes the RTC MSP.
  646.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  647.   *                the configuration information for RTC.
  648.   * @retval None
  649.   */
  650. __weak void HAL_RTC_MspInit(RTC_HandleTypeDef *hrtc)
  651. {
  652.   /* Prevent unused argument(s) compilation warning */
  653.   UNUSED(hrtc);
  654.   /* NOTE : This function Should not be modified, when the callback is needed,
  655.             the HAL_RTC_MspInit could be implemented in the user file
  656.    */
  657. }
  658.  
  659. /**
  660.   * @brief  DeInitializes the RTC MSP.
  661.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  662.   *                the configuration information for RTC.
  663.   * @retval None
  664.   */
  665. __weak void HAL_RTC_MspDeInit(RTC_HandleTypeDef *hrtc)
  666. {
  667.   /* Prevent unused argument(s) compilation warning */
  668.   UNUSED(hrtc);
  669.   /* NOTE : This function Should not be modified, when the callback is needed,
  670.             the HAL_RTC_MspDeInit could be implemented in the user file
  671.    */
  672. }
  673.  
  674. /**
  675.   * @}
  676.   */
  677.  
  678. /** @defgroup RTC_Exported_Functions_Group2 Time and Date functions
  679.  *  @brief   RTC Time and Date functions
  680.  *
  681. @verbatim
  682.  ===============================================================================
  683.                  ##### RTC Time and Date functions #####
  684.  ===============================================================================
  685.  
  686.  [..] This section provides functions allowing to configure Time and Date features
  687.  
  688. @endverbatim
  689.   * @{
  690.   */
  691.  
  692. /**
  693.   * @brief  Sets RTC current time.
  694.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  695.   *                the configuration information for RTC.
  696.   * @param  sTime: Pointer to Time structure
  697.   * @param  Format: Specifies the format of the entered parameters.
  698.   *          This parameter can be one of the following values:
  699.   *            @arg RTC_FORMAT_BIN: Binary data format
  700.   *            @arg RTC_FORMAT_BCD: BCD data format
  701.   * @retval HAL status
  702.   */
  703. HAL_StatusTypeDef HAL_RTC_SetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
  704. {
  705.   uint32_t counter_time = 0U, counter_alarm = 0U;
  706.  
  707.   /* Check input parameters */
  708.   if ((hrtc == NULL) || (sTime == NULL))
  709.   {
  710.     return HAL_ERROR;
  711.   }
  712.  
  713.   /* Check the parameters */
  714.   assert_param(IS_RTC_FORMAT(Format));
  715.  
  716.   /* Process Locked */
  717.   __HAL_LOCK(hrtc);
  718.  
  719.   hrtc->State = HAL_RTC_STATE_BUSY;
  720.  
  721.   if (Format == RTC_FORMAT_BIN)
  722.   {
  723.     assert_param(IS_RTC_HOUR24(sTime->Hours));
  724.     assert_param(IS_RTC_MINUTES(sTime->Minutes));
  725.     assert_param(IS_RTC_SECONDS(sTime->Seconds));
  726.  
  727.     counter_time = (uint32_t)(((uint32_t)sTime->Hours * 3600U) + \
  728.                               ((uint32_t)sTime->Minutes * 60U) + \
  729.                               ((uint32_t)sTime->Seconds));
  730.   }
  731.   else
  732.   {
  733.     assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sTime->Hours)));
  734.     assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sTime->Minutes)));
  735.     assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sTime->Seconds)));
  736.  
  737.     counter_time = (((uint32_t)(RTC_Bcd2ToByte(sTime->Hours)) * 3600U) + \
  738.                     ((uint32_t)(RTC_Bcd2ToByte(sTime->Minutes)) * 60U) + \
  739.                     ((uint32_t)(RTC_Bcd2ToByte(sTime->Seconds))));
  740.   }
  741.  
  742.   /* Write time counter in RTC registers */
  743.   if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
  744.   {
  745.     /* Set RTC state */
  746.     hrtc->State = HAL_RTC_STATE_ERROR;
  747.  
  748.     /* Process Unlocked */
  749.     __HAL_UNLOCK(hrtc);
  750.  
  751.     return HAL_ERROR;
  752.   }
  753.   else
  754.   {
  755.     /* Clear Second and overflow flags */
  756.     CLEAR_BIT(hrtc->Instance->CRL, (RTC_FLAG_SEC | RTC_FLAG_OW));
  757.  
  758.     /* Read current Alarm counter in RTC registers */
  759.     counter_alarm = RTC_ReadAlarmCounter(hrtc);
  760.  
  761.     /* Set again alarm to match with new time if enabled */
  762.     if (counter_alarm != RTC_ALARM_RESETVALUE)
  763.     {
  764.       if (counter_alarm < counter_time)
  765.       {
  766.         /* Add 1 day to alarm counter*/
  767.         counter_alarm += (uint32_t)(24U * 3600U);
  768.  
  769.         /* Write new Alarm counter in RTC registers */
  770.         if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
  771.         {
  772.           /* Set RTC state */
  773.           hrtc->State = HAL_RTC_STATE_ERROR;
  774.  
  775.           /* Process Unlocked */
  776.           __HAL_UNLOCK(hrtc);
  777.  
  778.           return HAL_ERROR;
  779.         }
  780.       }
  781.     }
  782.  
  783.     hrtc->State = HAL_RTC_STATE_READY;
  784.  
  785.     __HAL_UNLOCK(hrtc);
  786.  
  787.     return HAL_OK;
  788.   }
  789. }
  790.  
  791. /**
  792.   * @brief  Gets RTC current time.
  793.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  794.   *                the configuration information for RTC.
  795.   * @param  sTime: Pointer to Time structure
  796.   * @param  Format: Specifies the format of the entered parameters.
  797.   *          This parameter can be one of the following values:
  798.   *            @arg RTC_FORMAT_BIN: Binary data format
  799.   *            @arg RTC_FORMAT_BCD: BCD data format
  800.   * @retval HAL status
  801.   */
  802. HAL_StatusTypeDef HAL_RTC_GetTime(RTC_HandleTypeDef *hrtc, RTC_TimeTypeDef *sTime, uint32_t Format)
  803. {
  804.   uint32_t counter_time = 0U, counter_alarm = 0U, days_elapsed = 0U, hours = 0U;
  805.  
  806.   /* Check input parameters */
  807.   if ((hrtc == NULL) || (sTime == NULL))
  808.   {
  809.     return HAL_ERROR;
  810.   }
  811.  
  812.   /* Check the parameters */
  813.   assert_param(IS_RTC_FORMAT(Format));
  814.  
  815.   /* Check if counter overflow occurred */
  816.   if (__HAL_RTC_OVERFLOW_GET_FLAG(hrtc, RTC_FLAG_OW))
  817.   {
  818.     return HAL_ERROR;
  819.   }
  820.  
  821.   /* Read the time counter*/
  822.   counter_time = RTC_ReadTimeCounter(hrtc);
  823.  
  824.   /* Fill the structure fields with the read parameters */
  825.   hours = counter_time / 3600U;
  826.   sTime->Minutes  = (uint8_t)((counter_time % 3600U) / 60U);
  827.   sTime->Seconds  = (uint8_t)((counter_time % 3600U) % 60U);
  828.  
  829.   if (hours >= 24U)
  830.   {
  831.     /* Get number of days elapsed from last calculation */
  832.     days_elapsed = (hours / 24U);
  833.  
  834.     /* Set Hours in RTC_TimeTypeDef structure*/
  835.     sTime->Hours = (hours % 24U);
  836.  
  837.     /* Read Alarm counter in RTC registers */
  838.     counter_alarm = RTC_ReadAlarmCounter(hrtc);
  839.  
  840.     /* Calculate remaining time to reach alarm (only if set and not yet expired)*/
  841.     if ((counter_alarm != RTC_ALARM_RESETVALUE) && (counter_alarm > counter_time))
  842.     {
  843.       counter_alarm -= counter_time;
  844.     }
  845.     else
  846.     {
  847.       /* In case of counter_alarm < counter_time */
  848.       /* Alarm expiration already occurred but alarm not deactivated */
  849.       counter_alarm = RTC_ALARM_RESETVALUE;
  850.     }
  851.  
  852.     /* Set updated time in decreasing counter by number of days elapsed */
  853.     counter_time -= (days_elapsed * 24U * 3600U);
  854.  
  855.     /* Write time counter in RTC registers */
  856.     if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
  857.     {
  858.       return HAL_ERROR;
  859.     }
  860.  
  861.     /* Set updated alarm to be set */
  862.     if (counter_alarm != RTC_ALARM_RESETVALUE)
  863.     {
  864.       counter_alarm += counter_time;
  865.  
  866.       /* Write time counter in RTC registers */
  867.       if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
  868.       {
  869.         return HAL_ERROR;
  870.       }
  871.     }
  872.     else
  873.     {
  874.       /* Alarm already occurred. Set it to reset values to avoid unexpected expiration */
  875.       if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
  876.       {
  877.         return HAL_ERROR;
  878.       }
  879.     }
  880.  
  881.     /* Update date */
  882.     RTC_DateUpdate(hrtc, days_elapsed);
  883.   }
  884.   else
  885.   {
  886.     sTime->Hours = hours;
  887.   }
  888.  
  889.   /* Check the input parameters format */
  890.   if (Format != RTC_FORMAT_BIN)
  891.   {
  892.     /* Convert the time structure parameters to BCD format */
  893.     sTime->Hours    = (uint8_t)RTC_ByteToBcd2(sTime->Hours);
  894.     sTime->Minutes  = (uint8_t)RTC_ByteToBcd2(sTime->Minutes);
  895.     sTime->Seconds  = (uint8_t)RTC_ByteToBcd2(sTime->Seconds);
  896.   }
  897.  
  898.   return HAL_OK;
  899. }
  900.  
  901.  
  902. /**
  903.   * @brief  Sets RTC current date.
  904.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  905.   *                the configuration information for RTC.
  906.   * @param  sDate: Pointer to date structure
  907.   * @param  Format: specifies the format of the entered parameters.
  908.   *          This parameter can be one of the following values:
  909.   *            @arg RTC_FORMAT_BIN: Binary data format
  910.   *            @arg RTC_FORMAT_BCD: BCD data format
  911.   * @retval HAL status
  912.   */
  913. HAL_StatusTypeDef HAL_RTC_SetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
  914. {
  915.   uint32_t counter_time = 0U, counter_alarm = 0U, hours = 0U;
  916.  
  917.   /* Check input parameters */
  918.   if ((hrtc == NULL) || (sDate == NULL))
  919.   {
  920.     return HAL_ERROR;
  921.   }
  922.  
  923.   /* Check the parameters */
  924.   assert_param(IS_RTC_FORMAT(Format));
  925.  
  926.   /* Process Locked */
  927.   __HAL_LOCK(hrtc);
  928.  
  929.   hrtc->State = HAL_RTC_STATE_BUSY;
  930.  
  931.   if (Format == RTC_FORMAT_BIN)
  932.   {
  933.     assert_param(IS_RTC_YEAR(sDate->Year));
  934.     assert_param(IS_RTC_MONTH(sDate->Month));
  935.     assert_param(IS_RTC_DATE(sDate->Date));
  936.  
  937.     /* Change the current date */
  938.     hrtc->DateToUpdate.Year  = sDate->Year;
  939.     hrtc->DateToUpdate.Month = sDate->Month;
  940.     hrtc->DateToUpdate.Date  = sDate->Date;
  941.   }
  942.   else
  943.   {
  944.     assert_param(IS_RTC_YEAR(RTC_Bcd2ToByte(sDate->Year)));
  945.     assert_param(IS_RTC_MONTH(RTC_Bcd2ToByte(sDate->Month)));
  946.     assert_param(IS_RTC_DATE(RTC_Bcd2ToByte(sDate->Date)));
  947.  
  948.     /* Change the current date */
  949.     hrtc->DateToUpdate.Year  = RTC_Bcd2ToByte(sDate->Year);
  950.     hrtc->DateToUpdate.Month = RTC_Bcd2ToByte(sDate->Month);
  951.     hrtc->DateToUpdate.Date  = RTC_Bcd2ToByte(sDate->Date);
  952.   }
  953.  
  954.   /* WeekDay set by user can be ignored because automatically calculated */
  955.   hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(hrtc->DateToUpdate.Year, hrtc->DateToUpdate.Month, hrtc->DateToUpdate.Date);
  956.   sDate->WeekDay = hrtc->DateToUpdate.WeekDay;
  957.  
  958.   /* Reset time to be aligned on the same day */
  959.   /* Read the time counter*/
  960.   counter_time = RTC_ReadTimeCounter(hrtc);
  961.  
  962.   /* Fill the structure fields with the read parameters */
  963.   hours = counter_time / 3600U;
  964.   if (hours > 24U)
  965.   {
  966.     /* Set updated time in decreasing counter by number of days elapsed */
  967.     counter_time -= ((hours / 24U) * 24U * 3600U);
  968.     /* Write time counter in RTC registers */
  969.     if (RTC_WriteTimeCounter(hrtc, counter_time) != HAL_OK)
  970.     {
  971.       /* Set RTC state */
  972.       hrtc->State = HAL_RTC_STATE_ERROR;
  973.  
  974.       /* Process Unlocked */
  975.       __HAL_UNLOCK(hrtc);
  976.  
  977.       return HAL_ERROR;
  978.     }
  979.  
  980.     /* Read current Alarm counter in RTC registers */
  981.     counter_alarm = RTC_ReadAlarmCounter(hrtc);
  982.  
  983.     /* Set again alarm to match with new time if enabled */
  984.     if (counter_alarm != RTC_ALARM_RESETVALUE)
  985.     {
  986.       if (counter_alarm < counter_time)
  987.       {
  988.         /* Add 1 day to alarm counter*/
  989.         counter_alarm += (uint32_t)(24U * 3600U);
  990.  
  991.         /* Write new Alarm counter in RTC registers */
  992.         if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
  993.         {
  994.           /* Set RTC state */
  995.           hrtc->State = HAL_RTC_STATE_ERROR;
  996.  
  997.           /* Process Unlocked */
  998.           __HAL_UNLOCK(hrtc);
  999.  
  1000.           return HAL_ERROR;
  1001.         }
  1002.       }
  1003.     }
  1004.  
  1005.  
  1006.   }
  1007.  
  1008.   hrtc->State = HAL_RTC_STATE_READY ;
  1009.  
  1010.   /* Process Unlocked */
  1011.   __HAL_UNLOCK(hrtc);
  1012.  
  1013.   return HAL_OK;
  1014. }
  1015.  
  1016. /**
  1017.   * @brief  Gets RTC current date.
  1018.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1019.   *                the configuration information for RTC.
  1020.   * @param  sDate: Pointer to Date structure
  1021.   * @param  Format: Specifies the format of the entered parameters.
  1022.   *          This parameter can be one of the following values:
  1023.   *            @arg RTC_FORMAT_BIN:  Binary data format
  1024.   *            @arg RTC_FORMAT_BCD:  BCD data format
  1025.   * @retval HAL status
  1026.   */
  1027. HAL_StatusTypeDef HAL_RTC_GetDate(RTC_HandleTypeDef *hrtc, RTC_DateTypeDef *sDate, uint32_t Format)
  1028. {
  1029.   RTC_TimeTypeDef stime = {0U};
  1030.  
  1031.   /* Check input parameters */
  1032.   if ((hrtc == NULL) || (sDate == NULL))
  1033.   {
  1034.     return HAL_ERROR;
  1035.   }
  1036.  
  1037.   /* Check the parameters */
  1038.   assert_param(IS_RTC_FORMAT(Format));
  1039.  
  1040.   /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
  1041.   if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
  1042.   {
  1043.     return HAL_ERROR;
  1044.   }
  1045.  
  1046.   /* Fill the structure fields with the read parameters */
  1047.   sDate->WeekDay  = hrtc->DateToUpdate.WeekDay;
  1048.   sDate->Year     = hrtc->DateToUpdate.Year;
  1049.   sDate->Month    = hrtc->DateToUpdate.Month;
  1050.   sDate->Date     = hrtc->DateToUpdate.Date;
  1051.  
  1052.   /* Check the input parameters format */
  1053.   if (Format != RTC_FORMAT_BIN)
  1054.   {
  1055.     /* Convert the date structure parameters to BCD format */
  1056.     sDate->Year   = (uint8_t)RTC_ByteToBcd2(sDate->Year);
  1057.     sDate->Month  = (uint8_t)RTC_ByteToBcd2(sDate->Month);
  1058.     sDate->Date   = (uint8_t)RTC_ByteToBcd2(sDate->Date);
  1059.   }
  1060.   return HAL_OK;
  1061. }
  1062.  
  1063. /**
  1064.   * @}
  1065.   */
  1066.  
  1067. /** @defgroup RTC_Exported_Functions_Group3 Alarm functions
  1068.  *  @brief   RTC Alarm functions
  1069.  *
  1070. @verbatim
  1071.  ===============================================================================
  1072.                  ##### RTC Alarm functions #####
  1073.  ===============================================================================
  1074.  
  1075.  [..] This section provides functions allowing to configure Alarm feature
  1076.  
  1077. @endverbatim
  1078.   * @{
  1079.   */
  1080.  
  1081. /**
  1082.   * @brief  Sets the specified RTC Alarm.
  1083.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1084.   *                the configuration information for RTC.
  1085.   * @param  sAlarm: Pointer to Alarm structure
  1086.   * @param  Format: Specifies the format of the entered parameters.
  1087.   *          This parameter can be one of the following values:
  1088.   *             @arg RTC_FORMAT_BIN: Binary data format
  1089.   *             @arg RTC_FORMAT_BCD: BCD data format
  1090.   * @retval HAL status
  1091.   */
  1092. HAL_StatusTypeDef HAL_RTC_SetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
  1093. {
  1094.   uint32_t counter_alarm = 0U, counter_time;
  1095.   RTC_TimeTypeDef stime = {0U};
  1096.  
  1097.   /* Check input parameters */
  1098.   if ((hrtc == NULL) || (sAlarm == NULL))
  1099.   {
  1100.     return HAL_ERROR;
  1101.   }
  1102.  
  1103.   /* Check the parameters */
  1104.   assert_param(IS_RTC_FORMAT(Format));
  1105.   assert_param(IS_RTC_ALARM(sAlarm->Alarm));
  1106.  
  1107.   /* Process Locked */
  1108.   __HAL_LOCK(hrtc);
  1109.  
  1110.   hrtc->State = HAL_RTC_STATE_BUSY;
  1111.  
  1112.   /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
  1113.   if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
  1114.   {
  1115.     return HAL_ERROR;
  1116.   }
  1117.  
  1118.   /* Convert time in seconds */
  1119.   counter_time = (uint32_t)(((uint32_t)stime.Hours * 3600U) + \
  1120.                             ((uint32_t)stime.Minutes * 60U) + \
  1121.                             ((uint32_t)stime.Seconds));
  1122.  
  1123.   if (Format == RTC_FORMAT_BIN)
  1124.   {
  1125.     assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
  1126.     assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
  1127.     assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
  1128.  
  1129.     counter_alarm = (uint32_t)(((uint32_t)sAlarm->AlarmTime.Hours * 3600U) + \
  1130.                                ((uint32_t)sAlarm->AlarmTime.Minutes * 60U) + \
  1131.                                ((uint32_t)sAlarm->AlarmTime.Seconds));
  1132.   }
  1133.   else
  1134.   {
  1135.     assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
  1136.     assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
  1137.     assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
  1138.  
  1139.     counter_alarm = (((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)) * 3600U) + \
  1140.                      ((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)) * 60U) + \
  1141.                      ((uint32_t)RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
  1142.   }
  1143.  
  1144.   /* Check that requested alarm should expire in the same day (otherwise add 1 day) */
  1145.   if (counter_alarm < counter_time)
  1146.   {
  1147.     /* Add 1 day to alarm counter*/
  1148.     counter_alarm += (uint32_t)(24U * 3600U);
  1149.   }
  1150.  
  1151.   /* Write Alarm counter in RTC registers */
  1152.   if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
  1153.   {
  1154.     /* Set RTC state */
  1155.     hrtc->State = HAL_RTC_STATE_ERROR;
  1156.  
  1157.     /* Process Unlocked */
  1158.     __HAL_UNLOCK(hrtc);
  1159.  
  1160.     return HAL_ERROR;
  1161.   }
  1162.   else
  1163.   {
  1164.     hrtc->State = HAL_RTC_STATE_READY;
  1165.  
  1166.     __HAL_UNLOCK(hrtc);
  1167.  
  1168.     return HAL_OK;
  1169.   }
  1170. }
  1171.  
  1172. /**
  1173.   * @brief  Sets the specified RTC Alarm with Interrupt
  1174.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1175.   *                the configuration information for RTC.
  1176.   * @param  sAlarm: Pointer to Alarm structure
  1177.   * @param  Format: Specifies the format of the entered parameters.
  1178.   *          This parameter can be one of the following values:
  1179.   *             @arg RTC_FORMAT_BIN: Binary data format
  1180.   *             @arg RTC_FORMAT_BCD: BCD data format
  1181.   * @note   The HAL_RTC_SetTime() must be called before enabling the Alarm feature.
  1182.   * @retval HAL status
  1183.   */
  1184. HAL_StatusTypeDef HAL_RTC_SetAlarm_IT(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Format)
  1185. {
  1186.   uint32_t counter_alarm = 0U, counter_time;
  1187.   RTC_TimeTypeDef stime = {0U};
  1188.  
  1189.   /* Check input parameters */
  1190.   if ((hrtc == NULL) || (sAlarm == NULL))
  1191.   {
  1192.     return HAL_ERROR;
  1193.   }
  1194.  
  1195.   /* Check the parameters */
  1196.   assert_param(IS_RTC_FORMAT(Format));
  1197.   assert_param(IS_RTC_ALARM(sAlarm->Alarm));
  1198.  
  1199.   /* Process Locked */
  1200.   __HAL_LOCK(hrtc);
  1201.  
  1202.   hrtc->State = HAL_RTC_STATE_BUSY;
  1203.  
  1204.   /* Call HAL_RTC_GetTime function to update date if counter higher than 24 hours */
  1205.   if (HAL_RTC_GetTime(hrtc, &stime, RTC_FORMAT_BIN) != HAL_OK)
  1206.   {
  1207.     return HAL_ERROR;
  1208.   }
  1209.  
  1210.   /* Convert time in seconds */
  1211.   counter_time = (uint32_t)(((uint32_t)stime.Hours * 3600U) + \
  1212.                             ((uint32_t)stime.Minutes * 60U) + \
  1213.                             ((uint32_t)stime.Seconds));
  1214.  
  1215.   if (Format == RTC_FORMAT_BIN)
  1216.   {
  1217.     assert_param(IS_RTC_HOUR24(sAlarm->AlarmTime.Hours));
  1218.     assert_param(IS_RTC_MINUTES(sAlarm->AlarmTime.Minutes));
  1219.     assert_param(IS_RTC_SECONDS(sAlarm->AlarmTime.Seconds));
  1220.  
  1221.     counter_alarm = (uint32_t)(((uint32_t)sAlarm->AlarmTime.Hours * 3600U) + \
  1222.                                ((uint32_t)sAlarm->AlarmTime.Minutes * 60U) + \
  1223.                                ((uint32_t)sAlarm->AlarmTime.Seconds));
  1224.   }
  1225.   else
  1226.   {
  1227.     assert_param(IS_RTC_HOUR24(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)));
  1228.     assert_param(IS_RTC_MINUTES(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)));
  1229.     assert_param(IS_RTC_SECONDS(RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
  1230.  
  1231.     counter_alarm = (((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Hours)) * 3600U) + \
  1232.                      ((uint32_t)(RTC_Bcd2ToByte(sAlarm->AlarmTime.Minutes)) * 60U) + \
  1233.                      ((uint32_t)RTC_Bcd2ToByte(sAlarm->AlarmTime.Seconds)));
  1234.   }
  1235.  
  1236.   /* Check that requested alarm should expire in the same day (otherwise add 1 day) */
  1237.   if (counter_alarm < counter_time)
  1238.   {
  1239.     /* Add 1 day to alarm counter*/
  1240.     counter_alarm += (uint32_t)(24U * 3600U);
  1241.   }
  1242.  
  1243.   /* Write alarm counter in RTC registers */
  1244.   if (RTC_WriteAlarmCounter(hrtc, counter_alarm) != HAL_OK)
  1245.   {
  1246.     /* Set RTC state */
  1247.     hrtc->State = HAL_RTC_STATE_ERROR;
  1248.  
  1249.     /* Process Unlocked */
  1250.     __HAL_UNLOCK(hrtc);
  1251.  
  1252.     return HAL_ERROR;
  1253.   }
  1254.   else
  1255.   {
  1256.     /* Clear flag alarm A */
  1257.     __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
  1258.  
  1259.     /* Configure the Alarm interrupt */
  1260.     __HAL_RTC_ALARM_ENABLE_IT(hrtc, RTC_IT_ALRA);
  1261.  
  1262.     /* RTC Alarm Interrupt Configuration: EXTI configuration */
  1263.     __HAL_RTC_ALARM_EXTI_ENABLE_IT();
  1264.  
  1265.     __HAL_RTC_ALARM_EXTI_ENABLE_RISING_EDGE();
  1266.  
  1267.     hrtc->State = HAL_RTC_STATE_READY;
  1268.  
  1269.     __HAL_UNLOCK(hrtc);
  1270.  
  1271.     return HAL_OK;
  1272.   }
  1273. }
  1274.  
  1275. /**
  1276.   * @brief  Gets the RTC Alarm value and masks.
  1277.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1278.   *                the configuration information for RTC.
  1279.   * @param  sAlarm: Pointer to Date structure
  1280.   * @param  Alarm: Specifies the Alarm.
  1281.   *          This parameter can be one of the following values:
  1282.   *             @arg RTC_ALARM_A: Alarm
  1283.   * @param  Format: Specifies the format of the entered parameters.
  1284.   *          This parameter can be one of the following values:
  1285.   *             @arg RTC_FORMAT_BIN: Binary data format
  1286.   *             @arg RTC_FORMAT_BCD: BCD data format
  1287.   * @retval HAL status
  1288.   */
  1289. HAL_StatusTypeDef HAL_RTC_GetAlarm(RTC_HandleTypeDef *hrtc, RTC_AlarmTypeDef *sAlarm, uint32_t Alarm, uint32_t Format)
  1290. {
  1291.   uint32_t counter_alarm = 0U;
  1292.  
  1293.   /* Prevent unused argument(s) compilation warning */
  1294.   UNUSED(Alarm);
  1295.  
  1296.   /* Check input parameters */
  1297.   if ((hrtc == NULL) || (sAlarm == NULL))
  1298.   {
  1299.     return HAL_ERROR;
  1300.   }
  1301.  
  1302.   /* Check the parameters */
  1303.   assert_param(IS_RTC_FORMAT(Format));
  1304.   assert_param(IS_RTC_ALARM(Alarm));
  1305.  
  1306.   /* Read Alarm counter in RTC registers */
  1307.   counter_alarm = RTC_ReadAlarmCounter(hrtc);
  1308.  
  1309.   /* Fill the structure with the read parameters */
  1310.   /* Set hours in a day range (between 0 to 24)*/
  1311.   sAlarm->AlarmTime.Hours   = (uint32_t)((counter_alarm / 3600U) % 24U);
  1312.   sAlarm->AlarmTime.Minutes = (uint32_t)((counter_alarm % 3600U) / 60U);
  1313.   sAlarm->AlarmTime.Seconds = (uint32_t)((counter_alarm % 3600U) % 60U);
  1314.  
  1315.   if (Format != RTC_FORMAT_BIN)
  1316.   {
  1317.     sAlarm->AlarmTime.Hours   = RTC_ByteToBcd2(sAlarm->AlarmTime.Hours);
  1318.     sAlarm->AlarmTime.Minutes = RTC_ByteToBcd2(sAlarm->AlarmTime.Minutes);
  1319.     sAlarm->AlarmTime.Seconds = RTC_ByteToBcd2(sAlarm->AlarmTime.Seconds);
  1320.   }
  1321.  
  1322.   return HAL_OK;
  1323. }
  1324.  
  1325. /**
  1326.   * @brief  Deactive the specified RTC Alarm
  1327.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1328.   *                the configuration information for RTC.
  1329.   * @param  Alarm: Specifies the Alarm.
  1330.   *          This parameter can be one of the following values:
  1331.   *            @arg RTC_ALARM_A:  AlarmA
  1332.   * @retval HAL status
  1333.   */
  1334. HAL_StatusTypeDef HAL_RTC_DeactivateAlarm(RTC_HandleTypeDef *hrtc, uint32_t Alarm)
  1335. {
  1336.   /* Prevent unused argument(s) compilation warning */
  1337.   UNUSED(Alarm);
  1338.  
  1339.   /* Check the parameters */
  1340.   assert_param(IS_RTC_ALARM(Alarm));
  1341.  
  1342.   /* Check input parameters */
  1343.   if (hrtc == NULL)
  1344.   {
  1345.     return HAL_ERROR;
  1346.   }
  1347.  
  1348.   /* Process Locked */
  1349.   __HAL_LOCK(hrtc);
  1350.  
  1351.   hrtc->State = HAL_RTC_STATE_BUSY;
  1352.  
  1353.   /* In case of interrupt mode is used, the interrupt source must disabled */
  1354.   __HAL_RTC_ALARM_DISABLE_IT(hrtc, RTC_IT_ALRA);
  1355.  
  1356.   /* Set Initialization mode */
  1357.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  1358.   {
  1359.     /* Set RTC state */
  1360.     hrtc->State = HAL_RTC_STATE_ERROR;
  1361.  
  1362.     /* Process Unlocked */
  1363.     __HAL_UNLOCK(hrtc);
  1364.  
  1365.     return HAL_ERROR;
  1366.   }
  1367.   else
  1368.   {
  1369.     /* Clear flag alarm A */
  1370.     __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
  1371.  
  1372.     /* Set to default values ALRH & ALRL registers */
  1373.     WRITE_REG(hrtc->Instance->ALRH, RTC_ALARM_RESETVALUE_REGISTER);
  1374.     WRITE_REG(hrtc->Instance->ALRL, RTC_ALARM_RESETVALUE_REGISTER);
  1375.  
  1376.     /* RTC Alarm Interrupt Configuration: Disable EXTI configuration */
  1377.     __HAL_RTC_ALARM_EXTI_DISABLE_IT();
  1378.  
  1379.     /* Wait for synchro */
  1380.     if (RTC_ExitInitMode(hrtc) != HAL_OK)
  1381.     {
  1382.       hrtc->State = HAL_RTC_STATE_ERROR;
  1383.  
  1384.       /* Process Unlocked */
  1385.       __HAL_UNLOCK(hrtc);
  1386.  
  1387.       return HAL_ERROR;
  1388.     }
  1389.   }
  1390.   hrtc->State = HAL_RTC_STATE_READY;
  1391.  
  1392.   /* Process Unlocked */
  1393.   __HAL_UNLOCK(hrtc);
  1394.  
  1395.   return HAL_OK;
  1396. }
  1397.  
  1398. /**
  1399.   * @brief  This function handles Alarm interrupt request.
  1400.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1401.   *                the configuration information for RTC.
  1402.   * @retval None
  1403.   */
  1404. void HAL_RTC_AlarmIRQHandler(RTC_HandleTypeDef *hrtc)
  1405. {
  1406.   if (__HAL_RTC_ALARM_GET_IT_SOURCE(hrtc, RTC_IT_ALRA))
  1407.   {
  1408.     /* Get the status of the Interrupt */
  1409.     if (__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) != (uint32_t)RESET)
  1410.     {
  1411.       /* AlarmA callback */
  1412. #if (USE_HAL_RTC_REGISTER_CALLBACKS == 1)
  1413.       hrtc->AlarmAEventCallback(hrtc);
  1414. #else
  1415.       HAL_RTC_AlarmAEventCallback(hrtc);
  1416. #endif /* USE_HAL_RTC_REGISTER_CALLBACKS */
  1417.  
  1418.       /* Clear the Alarm interrupt pending bit */
  1419.       __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
  1420.     }
  1421.   }
  1422.  
  1423.   /* Clear the EXTI's line Flag for RTC Alarm */
  1424.   __HAL_RTC_ALARM_EXTI_CLEAR_FLAG();
  1425.  
  1426.   /* Change RTC state */
  1427.   hrtc->State = HAL_RTC_STATE_READY;
  1428. }
  1429.  
  1430. /**
  1431.   * @brief  Alarm A callback.
  1432.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1433.   *                the configuration information for RTC.
  1434.   * @retval None
  1435.   */
  1436. __weak void HAL_RTC_AlarmAEventCallback(RTC_HandleTypeDef *hrtc)
  1437. {
  1438.   /* Prevent unused argument(s) compilation warning */
  1439.   UNUSED(hrtc);
  1440.   /* NOTE : This function Should not be modified, when the callback is needed,
  1441.             the HAL_RTC_AlarmAEventCallback could be implemented in the user file
  1442.    */
  1443. }
  1444.  
  1445. /**
  1446.   * @brief  This function handles AlarmA Polling request.
  1447.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1448.   *                the configuration information for RTC.
  1449.   * @param  Timeout: Timeout duration
  1450.   * @retval HAL status
  1451.   */
  1452. HAL_StatusTypeDef HAL_RTC_PollForAlarmAEvent(RTC_HandleTypeDef *hrtc, uint32_t Timeout)
  1453. {
  1454.   uint32_t tickstart = HAL_GetTick();
  1455.  
  1456.   /* Check input parameters */
  1457.   if (hrtc == NULL)
  1458.   {
  1459.     return HAL_ERROR;
  1460.   }
  1461.  
  1462.   while (__HAL_RTC_ALARM_GET_FLAG(hrtc, RTC_FLAG_ALRAF) == RESET)
  1463.   {
  1464.     if (Timeout != HAL_MAX_DELAY)
  1465.     {
  1466.       if ((Timeout == 0) || ((HAL_GetTick() - tickstart) > Timeout))
  1467.       {
  1468.         hrtc->State = HAL_RTC_STATE_TIMEOUT;
  1469.         return HAL_TIMEOUT;
  1470.       }
  1471.     }
  1472.   }
  1473.  
  1474.   /* Clear the Alarm interrupt pending bit */
  1475.   __HAL_RTC_ALARM_CLEAR_FLAG(hrtc, RTC_FLAG_ALRAF);
  1476.  
  1477.   /* Change RTC state */
  1478.   hrtc->State = HAL_RTC_STATE_READY;
  1479.  
  1480.   return HAL_OK;
  1481. }
  1482.  
  1483. /**
  1484.   * @}
  1485.   */
  1486.  
  1487. /** @defgroup RTC_Exported_Functions_Group4 Peripheral State functions
  1488.  *  @brief   Peripheral State functions
  1489.  *
  1490. @verbatim
  1491.  ===============================================================================
  1492.                      ##### Peripheral State functions #####
  1493.  ===============================================================================
  1494.     [..]
  1495.     This subsection provides functions allowing to
  1496.       (+) Get RTC state
  1497.  
  1498. @endverbatim
  1499.   * @{
  1500.   */
  1501. /**
  1502.   * @brief  Returns the RTC state.
  1503.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1504.   *                the configuration information for RTC.
  1505.   * @retval HAL state
  1506.   */
  1507. HAL_RTCStateTypeDef HAL_RTC_GetState(RTC_HandleTypeDef *hrtc)
  1508. {
  1509.   return hrtc->State;
  1510. }
  1511.  
  1512. /**
  1513.   * @}
  1514.   */
  1515.  
  1516. /** @defgroup RTC_Exported_Functions_Group5 Peripheral Control functions
  1517.  *  @brief   Peripheral Control functions
  1518.  *
  1519. @verbatim
  1520.  ===============================================================================
  1521.                      ##### Peripheral Control functions #####
  1522.  ===============================================================================
  1523.     [..]
  1524.     This subsection provides functions allowing to
  1525.       (+) Wait for RTC Time and Date Synchronization
  1526.  
  1527. @endverbatim
  1528.   * @{
  1529.   */
  1530.  
  1531. /**
  1532.   * @brief  Waits until the RTC registers (RTC_CNT, RTC_ALR and RTC_PRL)
  1533.   *   are synchronized with RTC APB clock.
  1534.   * @note   This function must be called before any read operation after an APB reset
  1535.   *   or an APB clock stop.
  1536.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1537.   *                the configuration information for RTC.
  1538.   * @retval HAL status
  1539.   */
  1540. HAL_StatusTypeDef HAL_RTC_WaitForSynchro(RTC_HandleTypeDef *hrtc)
  1541. {
  1542.   uint32_t tickstart = 0U;
  1543.  
  1544.   /* Check input parameters */
  1545.   if (hrtc == NULL)
  1546.   {
  1547.     return HAL_ERROR;
  1548.   }
  1549.  
  1550.   /* Clear RSF flag */
  1551.   CLEAR_BIT(hrtc->Instance->CRL, RTC_FLAG_RSF);
  1552.  
  1553.   tickstart = HAL_GetTick();
  1554.  
  1555.   /* Wait the registers to be synchronised */
  1556.   while ((hrtc->Instance->CRL & RTC_FLAG_RSF) == (uint32_t)RESET)
  1557.   {
  1558.     if ((HAL_GetTick() - tickstart) >  RTC_TIMEOUT_VALUE)
  1559.     {
  1560.       return HAL_TIMEOUT;
  1561.     }
  1562.   }
  1563.  
  1564.   return HAL_OK;
  1565. }
  1566.  
  1567. /**
  1568.   * @}
  1569.   */
  1570.  
  1571.  
  1572. /**
  1573.   * @}
  1574.   */
  1575.  
  1576. /** @addtogroup RTC_Private_Functions
  1577.   * @{
  1578.   */
  1579.  
  1580.  
  1581. /**
  1582.   * @brief  Read the time counter available in RTC_CNT registers.
  1583.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1584.   *                the configuration information for RTC.
  1585.   * @retval Time counter
  1586.   */
  1587. static uint32_t RTC_ReadTimeCounter(RTC_HandleTypeDef *hrtc)
  1588. {
  1589.   uint16_t high1 = 0U, high2 = 0U, low = 0U;
  1590.   uint32_t timecounter = 0U;
  1591.  
  1592.   high1 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
  1593.   low   = READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT);
  1594.   high2 = READ_REG(hrtc->Instance->CNTH & RTC_CNTH_RTC_CNT);
  1595.  
  1596.   if (high1 != high2)
  1597.   {
  1598.     /* In this case the counter roll over during reading of CNTL and CNTH registers,
  1599.        read again CNTL register then return the counter value */
  1600.     timecounter = (((uint32_t) high2 << 16U) | READ_REG(hrtc->Instance->CNTL & RTC_CNTL_RTC_CNT));
  1601.   }
  1602.   else
  1603.   {
  1604.     /* No counter roll over during reading of CNTL and CNTH registers, counter
  1605.        value is equal to first value of CNTL and CNTH */
  1606.     timecounter = (((uint32_t) high1 << 16U) | low);
  1607.   }
  1608.  
  1609.   return timecounter;
  1610. }
  1611.  
  1612. /**
  1613.   * @brief  Write the time counter in RTC_CNT registers.
  1614.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1615.   *                the configuration information for RTC.
  1616.   * @param  TimeCounter: Counter to write in RTC_CNT registers
  1617.   * @retval HAL status
  1618.   */
  1619. static HAL_StatusTypeDef RTC_WriteTimeCounter(RTC_HandleTypeDef *hrtc, uint32_t TimeCounter)
  1620. {
  1621.   HAL_StatusTypeDef status = HAL_OK;
  1622.  
  1623.   /* Set Initialization mode */
  1624.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  1625.   {
  1626.     status = HAL_ERROR;
  1627.   }
  1628.   else
  1629.   {
  1630.     /* Set RTC COUNTER MSB word */
  1631.     WRITE_REG(hrtc->Instance->CNTH, (TimeCounter >> 16U));
  1632.     /* Set RTC COUNTER LSB word */
  1633.     WRITE_REG(hrtc->Instance->CNTL, (TimeCounter & RTC_CNTL_RTC_CNT));
  1634.  
  1635.     /* Wait for synchro */
  1636.     if (RTC_ExitInitMode(hrtc) != HAL_OK)
  1637.     {
  1638.       status = HAL_ERROR;
  1639.     }
  1640.   }
  1641.  
  1642.   return status;
  1643. }
  1644.  
  1645. /**
  1646.   * @brief  Read the time counter available in RTC_ALR registers.
  1647.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1648.   *                the configuration information for RTC.
  1649.   * @retval Time counter
  1650.   */
  1651. static uint32_t RTC_ReadAlarmCounter(RTC_HandleTypeDef *hrtc)
  1652. {
  1653.   uint16_t high1 = 0U, low = 0U;
  1654.  
  1655.   high1 = READ_REG(hrtc->Instance->ALRH & RTC_CNTH_RTC_CNT);
  1656.   low   = READ_REG(hrtc->Instance->ALRL & RTC_CNTL_RTC_CNT);
  1657.  
  1658.   return (((uint32_t) high1 << 16U) | low);
  1659. }
  1660.  
  1661. /**
  1662.   * @brief  Write the time counter in RTC_ALR registers.
  1663.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1664.   *                the configuration information for RTC.
  1665.   * @param  AlarmCounter: Counter to write in RTC_ALR registers
  1666.   * @retval HAL status
  1667.   */
  1668. static HAL_StatusTypeDef RTC_WriteAlarmCounter(RTC_HandleTypeDef *hrtc, uint32_t AlarmCounter)
  1669. {
  1670.   HAL_StatusTypeDef status = HAL_OK;
  1671.  
  1672.   /* Set Initialization mode */
  1673.   if (RTC_EnterInitMode(hrtc) != HAL_OK)
  1674.   {
  1675.     status = HAL_ERROR;
  1676.   }
  1677.   else
  1678.   {
  1679.     /* Set RTC COUNTER MSB word */
  1680.     WRITE_REG(hrtc->Instance->ALRH, (AlarmCounter >> 16U));
  1681.     /* Set RTC COUNTER LSB word */
  1682.     WRITE_REG(hrtc->Instance->ALRL, (AlarmCounter & RTC_ALRL_RTC_ALR));
  1683.  
  1684.     /* Wait for synchro */
  1685.     if (RTC_ExitInitMode(hrtc) != HAL_OK)
  1686.     {
  1687.       status = HAL_ERROR;
  1688.     }
  1689.   }
  1690.  
  1691.   return status;
  1692. }
  1693.  
  1694. /**
  1695.   * @brief  Enters the RTC Initialization mode.
  1696.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1697.   *                the configuration information for RTC.
  1698.   * @retval HAL status
  1699.   */
  1700. static HAL_StatusTypeDef RTC_EnterInitMode(RTC_HandleTypeDef *hrtc)
  1701. {
  1702.   uint32_t tickstart = 0U;
  1703.  
  1704.   tickstart = HAL_GetTick();
  1705.   /* Wait till RTC is in INIT state and if Time out is reached exit */
  1706.   while ((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
  1707.   {
  1708.     if ((HAL_GetTick() - tickstart) >  RTC_TIMEOUT_VALUE)
  1709.     {
  1710.       return HAL_TIMEOUT;
  1711.     }
  1712.   }
  1713.  
  1714.   /* Disable the write protection for RTC registers */
  1715.   __HAL_RTC_WRITEPROTECTION_DISABLE(hrtc);
  1716.  
  1717.  
  1718.   return HAL_OK;
  1719. }
  1720.  
  1721. /**
  1722.   * @brief  Exit the RTC Initialization mode.
  1723.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1724.   *                the configuration information for RTC.
  1725.   * @retval HAL status
  1726.   */
  1727. static HAL_StatusTypeDef RTC_ExitInitMode(RTC_HandleTypeDef *hrtc)
  1728. {
  1729.   uint32_t tickstart = 0U;
  1730.  
  1731.   /* Disable the write protection for RTC registers */
  1732.   __HAL_RTC_WRITEPROTECTION_ENABLE(hrtc);
  1733.  
  1734.   tickstart = HAL_GetTick();
  1735.   /* Wait till RTC is in INIT state and if Time out is reached exit */
  1736.   while ((hrtc->Instance->CRL & RTC_CRL_RTOFF) == (uint32_t)RESET)
  1737.   {
  1738.     if ((HAL_GetTick() - tickstart) >  RTC_TIMEOUT_VALUE)
  1739.     {
  1740.       return HAL_TIMEOUT;
  1741.     }
  1742.   }
  1743.  
  1744.   return HAL_OK;
  1745. }
  1746.  
  1747. /**
  1748.   * @brief  Converts a 2 digit decimal to BCD format.
  1749.   * @param  Value: Byte to be converted
  1750.   * @retval Converted byte
  1751.   */
  1752. static uint8_t RTC_ByteToBcd2(uint8_t Value)
  1753. {
  1754.   uint32_t bcdhigh = 0U;
  1755.  
  1756.   while (Value >= 10U)
  1757.   {
  1758.     bcdhigh++;
  1759.     Value -= 10U;
  1760.   }
  1761.  
  1762.   return ((uint8_t)(bcdhigh << 4U) | Value);
  1763. }
  1764.  
  1765. /**
  1766.   * @brief  Converts from 2 digit BCD to Binary.
  1767.   * @param  Value: BCD value to be converted
  1768.   * @retval Converted word
  1769.   */
  1770. static uint8_t RTC_Bcd2ToByte(uint8_t Value)
  1771. {
  1772.   uint32_t tmp = 0U;
  1773.   tmp = ((uint8_t)(Value & (uint8_t)0xF0) >> (uint8_t)0x4) * 10U;
  1774.   return (tmp + (Value & (uint8_t)0x0F));
  1775. }
  1776.  
  1777. /**
  1778.   * @brief  Updates date when time is 23:59:59.
  1779.   * @param  hrtc   pointer to a RTC_HandleTypeDef structure that contains
  1780.   *                the configuration information for RTC.
  1781.   * @param  DayElapsed: Number of days elapsed from last date update
  1782.   * @retval None
  1783.   */
  1784. static void RTC_DateUpdate(RTC_HandleTypeDef *hrtc, uint32_t DayElapsed)
  1785. {
  1786.   uint32_t year = 0U, month = 0U, day = 0U;
  1787.   uint32_t loop = 0U;
  1788.  
  1789.   /* Get the current year*/
  1790.   year = hrtc->DateToUpdate.Year;
  1791.  
  1792.   /* Get the current month and day */
  1793.   month = hrtc->DateToUpdate.Month;
  1794.   day = hrtc->DateToUpdate.Date;
  1795.  
  1796.   for (loop = 0U; loop < DayElapsed; loop++)
  1797.   {
  1798.     if ((month == 1U) || (month == 3U) || (month == 5U) || (month == 7U) || \
  1799.         (month == 8U) || (month == 10U) || (month == 12U))
  1800.     {
  1801.       if (day < 31U)
  1802.       {
  1803.         day++;
  1804.       }
  1805.       /* Date structure member: day = 31 */
  1806.       else
  1807.       {
  1808.         if (month != 12U)
  1809.         {
  1810.           month++;
  1811.           day = 1U;
  1812.         }
  1813.         /* Date structure member: day = 31 & month =12 */
  1814.         else
  1815.         {
  1816.           month = 1U;
  1817.           day = 1U;
  1818.           year++;
  1819.         }
  1820.       }
  1821.     }
  1822.     else if ((month == 4U) || (month == 6U) || (month == 9U) || (month == 11U))
  1823.     {
  1824.       if (day < 30U)
  1825.       {
  1826.         day++;
  1827.       }
  1828.       /* Date structure member: day = 30 */
  1829.       else
  1830.       {
  1831.         month++;
  1832.         day = 1U;
  1833.       }
  1834.     }
  1835.     else if (month == 2U)
  1836.     {
  1837.       if (day < 28U)
  1838.       {
  1839.         day++;
  1840.       }
  1841.       else if (day == 28U)
  1842.       {
  1843.         /* Leap year */
  1844.         if (RTC_IsLeapYear(year))
  1845.         {
  1846.           day++;
  1847.         }
  1848.         else
  1849.         {
  1850.           month++;
  1851.           day = 1U;
  1852.         }
  1853.       }
  1854.       else if (day == 29U)
  1855.       {
  1856.         month++;
  1857.         day = 1U;
  1858.       }
  1859.     }
  1860.   }
  1861.  
  1862.   /* Update year */
  1863.   hrtc->DateToUpdate.Year = year;
  1864.  
  1865.   /* Update day and month */
  1866.   hrtc->DateToUpdate.Month = month;
  1867.   hrtc->DateToUpdate.Date = day;
  1868.  
  1869.   /* Update day of the week */
  1870.   hrtc->DateToUpdate.WeekDay = RTC_WeekDayNum(year, month, day);
  1871. }
  1872.  
  1873. /**
  1874.   * @brief  Check whether the passed year is Leap or not.
  1875.   * @param  nYear  year to check
  1876.   * @retval 1: leap year
  1877.   *         0: not leap year
  1878.   */
  1879. static uint8_t RTC_IsLeapYear(uint16_t nYear)
  1880. {
  1881.   if ((nYear % 4U) != 0U)
  1882.   {
  1883.     return 0U;
  1884.   }
  1885.  
  1886.   if ((nYear % 100U) != 0U)
  1887.   {
  1888.     return 1U;
  1889.   }
  1890.  
  1891.   if ((nYear % 400U) == 0U)
  1892.   {
  1893.     return 1U;
  1894.   }
  1895.   else
  1896.   {
  1897.     return 0U;
  1898.   }
  1899. }
  1900.  
  1901. /**
  1902.   * @brief  Determines the week number, the day number and the week day number.
  1903.   * @param  nYear   year to check
  1904.   * @param  nMonth  Month to check
  1905.   * @param  nDay    Day to check
  1906.   * @note   Day is calculated with hypothesis that year > 2000
  1907.   * @retval Value which can take one of the following parameters:
  1908.   *         @arg RTC_WEEKDAY_MONDAY
  1909.   *         @arg RTC_WEEKDAY_TUESDAY
  1910.   *         @arg RTC_WEEKDAY_WEDNESDAY
  1911.   *         @arg RTC_WEEKDAY_THURSDAY
  1912.   *         @arg RTC_WEEKDAY_FRIDAY
  1913.   *         @arg RTC_WEEKDAY_SATURDAY
  1914.   *         @arg RTC_WEEKDAY_SUNDAY
  1915.   */
  1916. static uint8_t RTC_WeekDayNum(uint32_t nYear, uint8_t nMonth, uint8_t nDay)
  1917. {
  1918.   uint32_t year = 0U, weekday = 0U;
  1919.  
  1920.   year = 2000U + nYear;
  1921.  
  1922.   if (nMonth < 3U)
  1923.   {
  1924.     /*D = { [(23 x month)/9] + day + 4 + year + [(year-1)/4] - [(year-1)/100] + [(year-1)/400] } mod 7*/
  1925.     weekday = (((23U * nMonth) / 9U) + nDay + 4U + year + ((year - 1U) / 4U) - ((year - 1U) / 100U) + ((year - 1U) / 400U)) % 7U;
  1926.   }
  1927.   else
  1928.   {
  1929.     /*D = { [(23 x month)/9] + day + 4 + year + [year/4] - [year/100] + [year/400] - 2 } mod 7*/
  1930.     weekday = (((23U * nMonth) / 9U) + nDay + 4U + year + (year / 4U) - (year / 100U) + (year / 400U) - 2U) % 7U;
  1931.   }
  1932.  
  1933.   return (uint8_t)weekday;
  1934. }
  1935.  
  1936. /**
  1937.   * @}
  1938.   */
  1939.  
  1940. #endif /* HAL_RTC_MODULE_ENABLED */
  1941. /**
  1942.   * @}
  1943.   */
  1944.  
  1945. /**
  1946.   * @}
  1947.   */
  1948.  
  1949. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  1950.