Subversion Repositories dashGPS

Rev

Go to most recent revision | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32f1xx_ll_rtc.c
  4.   * @author  MCD Application Team
  5.   * @brief   RTC LL module driver.
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * <h2><center>&copy; Copyright (c) 2016 STMicroelectronics.
  10.   * All rights reserved.</center></h2>
  11.   *
  12.   * This software component is licensed by ST under BSD 3-Clause license,
  13.   * the "License"; You may not use this file except in compliance with the
  14.   * License. You may obtain a copy of the License at:
  15.   *                        opensource.org/licenses/BSD-3-Clause
  16.   *
  17.   ******************************************************************************
  18.   */
  19.  
  20. #if defined(USE_FULL_LL_DRIVER)
  21.  
  22. /* Includes ------------------------------------------------------------------*/
  23. #include "stm32f1xx_ll_rtc.h"
  24. #include "stm32f1xx_ll_cortex.h"
  25. #ifdef  USE_FULL_ASSERT
  26. #include "stm32_assert.h"
  27. #else
  28. #define assert_param(expr) ((void)0U)
  29. #endif
  30.  
  31. /** @addtogroup STM32F1xx_LL_Driver
  32.   * @{
  33.   */
  34.  
  35. #if defined(RTC)
  36.  
  37. /** @addtogroup RTC_LL
  38.   * @{
  39.   */
  40.  
  41. /* Private types -------------------------------------------------------------*/
  42. /* Private variables ---------------------------------------------------------*/
  43. /* Private constants ---------------------------------------------------------*/
  44. /** @addtogroup RTC_LL_Private_Constants
  45.   * @{
  46.   */
  47. /* Default values used for prescaler */
  48. #define RTC_ASYNCH_PRESC_DEFAULT     0x00007FFFU
  49.  
  50. /* Values used for timeout */
  51. #define RTC_INITMODE_TIMEOUT         1000U /* 1s when tick set to 1ms */
  52. #define RTC_SYNCHRO_TIMEOUT          1000U /* 1s when tick set to 1ms */
  53. /**
  54.   * @}
  55.   */
  56.  
  57. /* Private macros ------------------------------------------------------------*/
  58. /** @addtogroup RTC_LL_Private_Macros
  59.   * @{
  60.   */
  61.  
  62. #define IS_LL_RTC_ASYNCH_PREDIV(__VALUE__)   ((__VALUE__) <= 0xFFFFFU)
  63.  
  64. #define IS_LL_RTC_FORMAT(__VALUE__) (((__VALUE__) == LL_RTC_FORMAT_BIN) \
  65.                                   || ((__VALUE__) == LL_RTC_FORMAT_BCD))
  66.  
  67. #define IS_LL_RTC_HOUR24(__HOUR__)            ((__HOUR__) <= 23U)
  68. #define IS_LL_RTC_MINUTES(__MINUTES__)        ((__MINUTES__) <= 59U)
  69. #define IS_LL_RTC_SECONDS(__SECONDS__)        ((__SECONDS__) <= 59U)
  70. #define IS_LL_RTC_CALIB_OUTPUT(__OUTPUT__) (((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_NONE) || \
  71.                                             ((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_RTCCLOCK) || \
  72.                                             ((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_ALARM) || \
  73.                                             ((__OUTPUT__) == LL_RTC_CALIB_OUTPUT_SECOND))
  74. /**
  75.   * @}
  76.   */
  77. /* Private function prototypes -----------------------------------------------*/
  78. /* Exported functions --------------------------------------------------------*/
  79. /** @addtogroup RTC_LL_Exported_Functions
  80.   * @{
  81.   */
  82.  
  83. /** @addtogroup RTC_LL_EF_Init
  84.   * @{
  85.   */
  86.  
  87. /**
  88.   * @brief  De-Initializes the RTC registers to their default reset values.
  89.   * @note   This function doesn't reset the RTC Clock source and RTC Backup Data
  90.   *         registers.
  91.   * @param  RTCx RTC Instance
  92.   * @retval An ErrorStatus enumeration value:
  93.   *          - SUCCESS: RTC registers are de-initialized
  94.   *          - ERROR: RTC registers are not de-initialized
  95.   */
  96. ErrorStatus LL_RTC_DeInit(RTC_TypeDef *RTCx)
  97. {
  98.   ErrorStatus status = ERROR;
  99.  
  100.   /* Check the parameter */
  101.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  102.  
  103.   /* Disable the write protection for RTC registers */
  104.   LL_RTC_DisableWriteProtection(RTCx);
  105.  
  106.   /* Set Initialization mode */
  107.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  108.   {
  109.     LL_RTC_WriteReg(RTCx, CNTL, 0x0000);
  110.     LL_RTC_WriteReg(RTCx, CNTH, 0x0000);
  111.     LL_RTC_WriteReg(RTCx, PRLH, 0x0000);
  112.     LL_RTC_WriteReg(RTCx, PRLL, 0x8000);
  113.     LL_RTC_WriteReg(RTCx, CRH,  0x0000);
  114.     LL_RTC_WriteReg(RTCx, CRL,  0x0020);
  115.  
  116.     /* Reset Tamper and alternate functions configuration register */
  117.     LL_RTC_WriteReg(BKP, RTCCR, 0x00000000U);
  118.     LL_RTC_WriteReg(BKP, CR,    0x00000000U);
  119.     LL_RTC_WriteReg(BKP, CSR,   0x00000000U);
  120.  
  121.     /* Exit Initialization Mode */
  122.     if (LL_RTC_ExitInitMode(RTCx) != ERROR)
  123.     {
  124.       /* Wait till the RTC RSF flag is set */
  125.       status = LL_RTC_WaitForSynchro(RTCx);
  126.  
  127.       /* Clear RSF Flag */
  128.       LL_RTC_ClearFlag_RS(RTCx);
  129.      
  130.       /* Enable the write protection for RTC registers */
  131.       LL_RTC_EnableWriteProtection(RTCx);
  132.     }
  133.   }
  134.   else
  135.   {
  136.     /* Enable the write protection for RTC registers */
  137.     LL_RTC_EnableWriteProtection(RTCx);
  138.   }
  139.  
  140.   return status;
  141. }
  142.  
  143. /**
  144.   * @brief  Initializes the RTC registers according to the specified parameters
  145.   *         in RTC_InitStruct.
  146.   * @param  RTCx RTC Instance
  147.   * @param  RTC_InitStruct pointer to a @ref LL_RTC_InitTypeDef structure that contains
  148.   *         the configuration information for the RTC peripheral.
  149.   * @note   The RTC Prescaler register is write protected and can be written in
  150.   *         initialization mode only.
  151.   * @note   the user should call LL_RTC_StructInit()  or the structure of Prescaler
  152.   *         need to be initialized  before RTC init()
  153.   * @retval An ErrorStatus enumeration value:
  154.   *          - SUCCESS: RTC registers are initialized
  155.   *          - ERROR: RTC registers are not initialized
  156.   */
  157. ErrorStatus LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_InitTypeDef *RTC_InitStruct)
  158. {
  159.   ErrorStatus status = ERROR;
  160.  
  161.   /* Check the parameters */
  162.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  163.   assert_param(IS_LL_RTC_ASYNCH_PREDIV(RTC_InitStruct->AsynchPrescaler));
  164.   assert_param(IS_LL_RTC_CALIB_OUTPUT(RTC_InitStruct->OutPutSource));
  165.   /* Waiting for synchro */
  166.   if (LL_RTC_WaitForSynchro(RTCx) != ERROR)
  167.   {
  168.     /* Set Initialization mode */
  169.     if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  170.     {
  171.       /* Clear Flag Bits */
  172.       LL_RTC_ClearFlag_ALR(RTCx);
  173.       LL_RTC_ClearFlag_OW(RTCx);
  174.       LL_RTC_ClearFlag_SEC(RTCx);
  175.  
  176.       if (RTC_InitStruct->OutPutSource != LL_RTC_CALIB_OUTPUT_NONE)
  177.       {
  178.         /* Disable the selected Tamper Pin */
  179.         LL_RTC_TAMPER_Disable(BKP);
  180.       }
  181.       /* Set the signal which will be routed to RTC Tamper Pin */
  182.       LL_RTC_SetOutputSource(BKP, RTC_InitStruct->OutPutSource);
  183.  
  184.       /* Configure Synchronous and Asynchronous prescaler factor */
  185.       LL_RTC_SetAsynchPrescaler(RTCx, RTC_InitStruct->AsynchPrescaler);
  186.  
  187.       /* Exit Initialization Mode */
  188.       LL_RTC_ExitInitMode(RTCx);
  189.  
  190.       status = SUCCESS;
  191.     }
  192.   }
  193.   return status;
  194. }
  195.  
  196. /**
  197.   * @brief  Set each @ref LL_RTC_InitTypeDef field to default value.
  198.   * @param  RTC_InitStruct pointer to a @ref LL_RTC_InitTypeDef structure which will be initialized.
  199.   * @retval None
  200.   */
  201. void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct)
  202. {
  203.   /* Set RTC_InitStruct fields to default values */
  204.   RTC_InitStruct->AsynchPrescaler = RTC_ASYNCH_PRESC_DEFAULT;
  205.   RTC_InitStruct->OutPutSource    = LL_RTC_CALIB_OUTPUT_NONE;
  206. }
  207.  
  208. /**
  209.   * @brief  Set the RTC current time.
  210.   * @param  RTCx RTC Instance
  211.   * @param  RTC_Format This parameter can be one of the following values:
  212.   *         @arg @ref LL_RTC_FORMAT_BIN
  213.   *         @arg @ref LL_RTC_FORMAT_BCD
  214.   * @param  RTC_TimeStruct pointer to a RTC_TimeTypeDef structure that contains
  215.   *                        the time configuration information for the RTC.
  216.   * @note  The user should call LL_RTC_TIME_StructInit() or the structure
  217.   *        of time need to be initialized  before time init()
  218.   * @retval An ErrorStatus enumeration value:
  219.   *          - SUCCESS: RTC Time register is configured
  220.   *          - ERROR: RTC Time register is not configured
  221.   */
  222. ErrorStatus LL_RTC_TIME_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_TimeTypeDef *RTC_TimeStruct)
  223. {
  224.   ErrorStatus status = ERROR;
  225.   uint32_t counter_time = 0U;
  226.  
  227.   /* Check the parameters */
  228.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  229.   assert_param(IS_LL_RTC_FORMAT(RTC_Format));
  230.  
  231.   if (RTC_Format == LL_RTC_FORMAT_BIN)
  232.   {
  233.     assert_param(IS_LL_RTC_HOUR24(RTC_TimeStruct->Hours));
  234.     assert_param(IS_LL_RTC_MINUTES(RTC_TimeStruct->Minutes));
  235.     assert_param(IS_LL_RTC_SECONDS(RTC_TimeStruct->Seconds));
  236.   }
  237.   else
  238.   {
  239.     assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
  240.     assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)));
  241.     assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds)));
  242.   }
  243.  
  244.   /* Enter Initialization mode */
  245.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  246.   {
  247.     /* Check the input parameters format */
  248.     if (RTC_Format != LL_RTC_FORMAT_BIN)
  249.     {
  250.       counter_time = (uint32_t)(((uint32_t)RTC_TimeStruct->Hours * 3600U) + \
  251.                                 ((uint32_t)RTC_TimeStruct->Minutes * 60U) + \
  252.                                 ((uint32_t)RTC_TimeStruct->Seconds));
  253.       LL_RTC_TIME_Set(RTCx, counter_time);
  254.     }
  255.     else
  256.     {
  257.       counter_time = (((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)) * 3600U) + \
  258.                       ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)) * 60U) + \
  259.                       ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds))));
  260.       LL_RTC_TIME_Set(RTCx, counter_time);
  261.     }
  262.     status = SUCCESS;
  263.   }
  264.   /* Exit Initialization mode */
  265.   LL_RTC_ExitInitMode(RTCx);
  266.  
  267.   return status;
  268. }
  269.  
  270. /**
  271.   * @brief  Set each @ref LL_RTC_TimeTypeDef field to default value (Time = 00h:00min:00sec).
  272.   * @param  RTC_TimeStruct pointer to a @ref LL_RTC_TimeTypeDef structure which will be initialized.
  273.   * @retval None
  274.   */
  275. void LL_RTC_TIME_StructInit(LL_RTC_TimeTypeDef *RTC_TimeStruct)
  276. {
  277.   /* Time = 00h:00min:00sec */
  278.   RTC_TimeStruct->Hours      = 0U;
  279.   RTC_TimeStruct->Minutes    = 0U;
  280.   RTC_TimeStruct->Seconds    = 0U;
  281. }
  282.  
  283. /**
  284.   * @brief  Set the RTC Alarm.
  285.   * @param  RTCx RTC Instance
  286.   * @param  RTC_Format This parameter can be one of the following values:
  287.   *         @arg @ref LL_RTC_FORMAT_BIN
  288.   *         @arg @ref LL_RTC_FORMAT_BCD
  289.   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure that
  290.   *                         contains the alarm configuration parameters.
  291.   * @note   the user should call LL_RTC_ALARM_StructInit()  or the structure
  292.   *         of Alarm need to be initialized  before Alarm init()
  293.   * @retval An ErrorStatus enumeration value:
  294.   *          - SUCCESS: ALARM registers are configured
  295.   *          - ERROR: ALARM registers are not configured
  296.   */
  297. ErrorStatus LL_RTC_ALARM_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
  298. {
  299.   ErrorStatus status = ERROR;
  300.   uint32_t counter_alarm = 0U;
  301.   /* Check the parameters */
  302.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  303.   assert_param(IS_LL_RTC_FORMAT(RTC_Format));
  304.  
  305.   if (RTC_Format == LL_RTC_FORMAT_BIN)
  306.   {
  307.     assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
  308.     assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
  309.     assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
  310.   }
  311.   else
  312.   {
  313.     assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
  314.     assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
  315.     assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
  316.   }
  317.  
  318.   /* Enter Initialization mode */
  319.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  320.   {
  321.     /* Check the input parameters format */
  322.     if (RTC_Format != LL_RTC_FORMAT_BIN)
  323.     {
  324.       counter_alarm = (uint32_t)(((uint32_t)RTC_AlarmStruct->AlarmTime.Hours * 3600U) + \
  325.                                  ((uint32_t)RTC_AlarmStruct->AlarmTime.Minutes * 60U) + \
  326.                                  ((uint32_t)RTC_AlarmStruct->AlarmTime.Seconds));
  327.       LL_RTC_ALARM_Set(RTCx, counter_alarm);
  328.     }
  329.     else
  330.     {
  331.       counter_alarm = (((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)) * 3600U) + \
  332.                        ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)) * 60U) + \
  333.                        ((uint32_t)(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds))));
  334.       LL_RTC_ALARM_Set(RTCx, counter_alarm);
  335.     }
  336.     status = SUCCESS;
  337.   }
  338.   /* Exit Initialization mode */
  339.   LL_RTC_ExitInitMode(RTCx);
  340.  
  341.   return status;
  342. }
  343.  
  344. /**
  345.   * @brief  Set each @ref LL_RTC_AlarmTypeDef of ALARM field to default value (Time = 00h:00mn:00sec /
  346.   *         Day = 1st day of the month/Mask = all fields are masked).
  347.   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure which will be initialized.
  348.   * @retval None
  349.   */
  350. void LL_RTC_ALARM_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
  351. {
  352.   /* Alarm Time Settings : Time = 00h:00mn:00sec */
  353.   RTC_AlarmStruct->AlarmTime.Hours      = 0U;
  354.   RTC_AlarmStruct->AlarmTime.Minutes    = 0U;
  355.   RTC_AlarmStruct->AlarmTime.Seconds    = 0U;
  356. }
  357.  
  358. /**
  359.   * @brief  Enters the RTC Initialization mode.
  360.   * @param  RTCx RTC Instance
  361.   * @retval An ErrorStatus enumeration value:
  362.   *          - SUCCESS: RTC is in Init mode
  363.   *          - ERROR: RTC is not in Init mode
  364.   */
  365. ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx)
  366. {
  367.   __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
  368.   ErrorStatus status = SUCCESS;
  369.   uint32_t tmp = 0U;
  370.  
  371.   /* Check the parameter */
  372.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  373.  
  374.   /* Wait till RTC is in INIT state and if Time out is reached exit */
  375.   tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
  376.   while ((timeout != 0U) && (tmp != 1U))
  377.   {
  378.     if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
  379.     {
  380.       timeout --;
  381.     }
  382.     tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
  383.     if (timeout == 0U)
  384.     {
  385.       status = ERROR;
  386.     }
  387.   }
  388.  
  389.   /* Disable the write protection for RTC registers */
  390.   LL_RTC_DisableWriteProtection(RTCx);
  391.  
  392.   return status;
  393. }
  394.  
  395. /**
  396.   * @brief  Exit the RTC Initialization mode.
  397.   * @note   When the initialization sequence is complete, the calendar restarts
  398.   *         counting after 4 RTCCLK cycles.
  399.   * @param  RTCx RTC Instance
  400.   * @retval An ErrorStatus enumeration value:
  401.   *          - SUCCESS: RTC exited from in Init mode
  402.   *          - ERROR: Not applicable
  403.   */
  404. ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
  405. {
  406.   __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
  407.   ErrorStatus status = SUCCESS;
  408.   uint32_t tmp = 0U;
  409.  
  410.   /* Check the parameter */
  411.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  412.  
  413.   /* Disable initialization mode */
  414.   LL_RTC_EnableWriteProtection(RTCx);
  415.  
  416.   /* Wait till RTC is in INIT state and if Time out is reached exit */
  417.   tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
  418.   while ((timeout != 0U) && (tmp != 1U))
  419.   {
  420.     if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
  421.     {
  422.       timeout --;
  423.     }
  424.     tmp = LL_RTC_IsActiveFlag_RTOF(RTCx);
  425.     if (timeout == 0U)
  426.     {
  427.       status = ERROR;
  428.     }
  429.   }
  430.   return status;
  431. }
  432.  
  433. /**
  434.   * @brief  Set the Time Counter
  435.   * @param  RTCx RTC Instance
  436.   * @param  TimeCounter this value can be from 0 to 0xFFFFFFFF
  437.   * @retval An ErrorStatus enumeration value:
  438.   *          - SUCCESS: RTC Counter register configured
  439.   *          - ERROR: Not applicable
  440.   */
  441. ErrorStatus LL_RTC_TIME_SetCounter(RTC_TypeDef *RTCx, uint32_t TimeCounter)
  442. {
  443.   ErrorStatus status = ERROR;
  444.   /* Check the parameter */
  445.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  446.  
  447.   /* Enter Initialization mode */
  448.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  449.   {
  450.     LL_RTC_TIME_Set(RTCx, TimeCounter);
  451.     status = SUCCESS;
  452.   }
  453.   /* Exit Initialization mode */
  454.   LL_RTC_ExitInitMode(RTCx);
  455.  
  456.   return status;
  457. }
  458.  
  459. /**
  460.   * @brief  Set Alarm Counter.
  461.   * @param  RTCx RTC Instance
  462.   * @param  AlarmCounter this value can be from 0 to 0xFFFFFFFF
  463.   * @retval An ErrorStatus enumeration value:
  464.   *          - SUCCESS: RTC exited from in Init mode
  465.   *          - ERROR: Not applicable
  466.   */
  467. ErrorStatus LL_RTC_ALARM_SetCounter(RTC_TypeDef *RTCx, uint32_t AlarmCounter)
  468. {
  469.   ErrorStatus status = ERROR;
  470.   /* Check the parameter */
  471.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  472.  
  473.   /* Enter Initialization mode */
  474.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  475.   {
  476.     LL_RTC_ALARM_Set(RTCx, AlarmCounter);
  477.     status = SUCCESS;
  478.   }
  479.   /* Exit Initialization mode */
  480.   LL_RTC_ExitInitMode(RTCx);
  481.  
  482.   return status;
  483. }
  484.  
  485. /**
  486.   * @brief  Waits until the RTC registers are synchronized with RTC APB clock.
  487.   * @note   The RTC Resynchronization mode is write protected, use the
  488.   *         @ref LL_RTC_DisableWriteProtection before calling this function.
  489.   * @param  RTCx RTC Instance
  490.   * @retval An ErrorStatus enumeration value:
  491.   *          - SUCCESS: RTC registers are synchronised
  492.   *          - ERROR: RTC registers are not synchronised
  493.   */
  494. ErrorStatus LL_RTC_WaitForSynchro(RTC_TypeDef *RTCx)
  495. {
  496.   __IO uint32_t timeout = RTC_SYNCHRO_TIMEOUT;
  497.   ErrorStatus status = SUCCESS;
  498.   uint32_t tmp = 0U;
  499.  
  500.   /* Check the parameter */
  501.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  502.  
  503.   /* Clear RSF flag */
  504.   LL_RTC_ClearFlag_RS(RTCx);
  505.  
  506.   /* Wait the registers to be synchronised */
  507.   tmp = LL_RTC_IsActiveFlag_RS(RTCx);
  508.   while ((timeout != 0U) && (tmp != 0U))
  509.   {
  510.     if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
  511.     {
  512.       timeout--;
  513.     }
  514.     tmp = LL_RTC_IsActiveFlag_RS(RTCx);
  515.     if (timeout == 0U)
  516.     {
  517.       status = ERROR;
  518.     }
  519.   }
  520.  
  521.   return (status);
  522. }
  523.  
  524. /**
  525.   * @}
  526.   */
  527.  
  528. /**
  529.   * @}
  530.   */
  531.  
  532. /**
  533.   * @}
  534.   */
  535.  
  536. #endif /* defined(RTC) */
  537.  
  538. /**
  539.   * @}
  540.   */
  541.  
  542. #endif /* USE_FULL_LL_DRIVER */
  543.  
  544. /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
  545.