Subversion Repositories DashDisplay

Rev

Rev 61 | Blame | Compare with Previous | Last modification | View Log | Download | RSS feed

  1. /**
  2.   ******************************************************************************
  3.   * @file    stm32l1xx_ll_rtc.c
  4.   * @author  MCD Application Team
  5.   * @brief   RTC LL module driver.
  6.   ******************************************************************************
  7.   * @attention
  8.   *
  9.   * Copyright (c) 2016 STMicroelectronics.
  10.   * All rights reserved.
  11.   *
  12.   * This software is licensed under terms that can be found in the LICENSE file
  13.   * in the root directory of this software component.
  14.   * If no LICENSE file comes with this software, it is provided AS-IS.
  15.   *
  16.   ******************************************************************************
  17.   */
  18. #if defined(USE_FULL_LL_DRIVER)
  19.  
  20. /* Includes ------------------------------------------------------------------*/
  21. #include "stm32l1xx_ll_rtc.h"
  22. #include "stm32l1xx_ll_cortex.h"
  23. #ifdef  USE_FULL_ASSERT
  24. #include "stm32_assert.h"
  25. #else
  26. #define assert_param(expr) ((void)0U)
  27. #endif
  28.  
  29. /** @addtogroup STM32L1xx_LL_Driver
  30.   * @{
  31.   */
  32.  
  33. #if defined(RTC)
  34.  
  35. /** @addtogroup RTC_LL
  36.   * @{
  37.   */
  38.  
  39. /* Private types -------------------------------------------------------------*/
  40. /* Private variables ---------------------------------------------------------*/
  41. /* Private constants ---------------------------------------------------------*/
  42. /** @addtogroup RTC_LL_Private_Constants
  43.   * @{
  44.   */
  45. /* Default values used for prescaler */
  46. #define RTC_ASYNCH_PRESC_DEFAULT     0x0000007FU
  47. #define RTC_SYNCH_PRESC_DEFAULT      0x000000FFU
  48.  
  49. /* Values used for timeout */
  50. #define RTC_INITMODE_TIMEOUT         1000U /* 1s when tick set to 1ms */
  51. #define RTC_SYNCHRO_TIMEOUT          1000U /* 1s when tick set to 1ms */
  52. /**
  53.   * @}
  54.   */
  55.  
  56. /* Private macros ------------------------------------------------------------*/
  57. /** @addtogroup RTC_LL_Private_Macros
  58.   * @{
  59.   */
  60.  
  61. #define IS_LL_RTC_HOURFORMAT(__VALUE__) (((__VALUE__) == LL_RTC_HOURFORMAT_24HOUR) \
  62.                                       || ((__VALUE__) == LL_RTC_HOURFORMAT_AMPM))
  63.  
  64. #define IS_LL_RTC_ASYNCH_PREDIV(__VALUE__)   ((__VALUE__) <= 0x7FU)
  65.  
  66. #define IS_LL_RTC_SYNCH_PREDIV(__VALUE__)    ((__VALUE__) <= 0x7FFFU)
  67.  
  68. #define IS_LL_RTC_FORMAT(__VALUE__) (((__VALUE__) == LL_RTC_FORMAT_BIN) \
  69.                                   || ((__VALUE__) == LL_RTC_FORMAT_BCD))
  70.  
  71. #define IS_LL_RTC_TIME_FORMAT(__VALUE__) (((__VALUE__) == LL_RTC_TIME_FORMAT_AM_OR_24) \
  72.                                        || ((__VALUE__) == LL_RTC_TIME_FORMAT_PM))
  73.  
  74. #define IS_LL_RTC_HOUR12(__HOUR__)            (((__HOUR__) > 0U) && ((__HOUR__) <= 12U))
  75. #define IS_LL_RTC_HOUR24(__HOUR__)            ((__HOUR__) <= 23U)
  76. #define IS_LL_RTC_MINUTES(__MINUTES__)        ((__MINUTES__) <= 59U)
  77. #define IS_LL_RTC_SECONDS(__SECONDS__)        ((__SECONDS__) <= 59U)
  78.  
  79. #define IS_LL_RTC_WEEKDAY(__VALUE__) (((__VALUE__) == LL_RTC_WEEKDAY_MONDAY) \
  80.                                    || ((__VALUE__) == LL_RTC_WEEKDAY_TUESDAY) \
  81.                                    || ((__VALUE__) == LL_RTC_WEEKDAY_WEDNESDAY) \
  82.                                    || ((__VALUE__) == LL_RTC_WEEKDAY_THURSDAY) \
  83.                                    || ((__VALUE__) == LL_RTC_WEEKDAY_FRIDAY) \
  84.                                    || ((__VALUE__) == LL_RTC_WEEKDAY_SATURDAY) \
  85.                                    || ((__VALUE__) == LL_RTC_WEEKDAY_SUNDAY))
  86.  
  87. #define IS_LL_RTC_DAY(__DAY__)     (((__DAY__) >= 1U) && ((__DAY__) <= 31U))
  88.  
  89. #define IS_LL_RTC_MONTH(__MONTH__) (((__MONTH__) >= 1U) && ((__MONTH__) <= 12U))
  90.  
  91. #define IS_LL_RTC_YEAR(__YEAR__)   ((__YEAR__) <= 99U)
  92.  
  93. #define IS_LL_RTC_ALMA_MASK(__VALUE__) (((__VALUE__) == LL_RTC_ALMA_MASK_NONE) \
  94.                                      || ((__VALUE__) == LL_RTC_ALMA_MASK_DATEWEEKDAY) \
  95.                                      || ((__VALUE__) == LL_RTC_ALMA_MASK_HOURS) \
  96.                                      || ((__VALUE__) == LL_RTC_ALMA_MASK_MINUTES) \
  97.                                      || ((__VALUE__) == LL_RTC_ALMA_MASK_SECONDS) \
  98.                                      || ((__VALUE__) == LL_RTC_ALMA_MASK_ALL))
  99.  
  100. #define IS_LL_RTC_ALMB_MASK(__VALUE__) (((__VALUE__) == LL_RTC_ALMB_MASK_NONE) \
  101.                                      || ((__VALUE__) == LL_RTC_ALMB_MASK_DATEWEEKDAY) \
  102.                                      || ((__VALUE__) == LL_RTC_ALMB_MASK_HOURS) \
  103.                                      || ((__VALUE__) == LL_RTC_ALMB_MASK_MINUTES) \
  104.                                      || ((__VALUE__) == LL_RTC_ALMB_MASK_SECONDS) \
  105.                                      || ((__VALUE__) == LL_RTC_ALMB_MASK_ALL))
  106.  
  107. #define IS_LL_RTC_ALMA_DATE_WEEKDAY_SEL(__SEL__) (((__SEL__) == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE) || \
  108.                                                   ((__SEL__) == LL_RTC_ALMA_DATEWEEKDAYSEL_WEEKDAY))
  109.  
  110. #define IS_LL_RTC_ALMB_DATE_WEEKDAY_SEL(__SEL__) (((__SEL__) == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE) || \
  111.                                                   ((__SEL__) == LL_RTC_ALMB_DATEWEEKDAYSEL_WEEKDAY))
  112.  
  113. /**
  114.   * @}
  115.   */
  116. /* Private function prototypes -----------------------------------------------*/
  117. /* Exported functions --------------------------------------------------------*/
  118. /** @addtogroup RTC_LL_Exported_Functions
  119.   * @{
  120.   */
  121.  
  122. /** @addtogroup RTC_LL_EF_Init
  123.   * @{
  124.   */
  125.  
  126. /**
  127.   * @brief  De-Initializes the RTC registers to their default reset values.
  128.   * @note   This function does not reset the RTC Clock source and RTC Backup Data
  129.   *         registers.
  130.   * @param  RTCx RTC Instance
  131.   * @retval An ErrorStatus enumeration value:
  132.   *          - SUCCESS: RTC registers are de-initialized
  133.   *          - ERROR: RTC registers are not de-initialized
  134.   */
  135. ErrorStatus LL_RTC_DeInit(RTC_TypeDef *RTCx)
  136. {
  137.   ErrorStatus status = ERROR;
  138.  
  139.   /* Check the parameter */
  140.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  141.  
  142.   /* Disable the write protection for RTC registers */
  143.   LL_RTC_DisableWriteProtection(RTCx);
  144.  
  145.   /* Set Initialization mode */
  146.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  147.   {
  148.     /* Reset TR, DR and CR registers */
  149.     LL_RTC_WriteReg(RTCx, TR,       0x00000000U);
  150.     LL_RTC_WriteReg(RTCx, WUTR,     RTC_WUTR_WUT);
  151.     LL_RTC_WriteReg(RTCx, DR,      (RTC_DR_WDU_0 | RTC_DR_MU_0 | RTC_DR_DU_0));
  152.  
  153.     /* Reset All CR bits except CR[2:0] */
  154.     LL_RTC_WriteReg(RTCx, CR, (LL_RTC_ReadReg(RTCx, CR) & RTC_CR_WUCKSEL));
  155.  
  156.     LL_RTC_WriteReg(RTCx, PRER,    (RTC_PRER_PREDIV_A | RTC_SYNCH_PRESC_DEFAULT));
  157.     LL_RTC_WriteReg(RTCx, ALRMAR,   0x00000000U);
  158.     LL_RTC_WriteReg(RTCx, ALRMBR,   0x00000000U);
  159. #if defined(RTC_SMOOTHCALIB_SUPPORT)
  160.     LL_RTC_WriteReg(RTCx, CALR,     0x00000000U);
  161. #endif /* RTC_SMOOTHCALIB_SUPPORT */
  162. #if defined(RTC_SUBSECOND_SUPPORT)
  163.     LL_RTC_WriteReg(RTCx, SHIFTR,   0x00000000U);
  164.     LL_RTC_WriteReg(RTCx, ALRMASSR, 0x00000000U);
  165.     LL_RTC_WriteReg(RTCx, ALRMBSSR, 0x00000000U);
  166. #endif /* RTC_SUBSECOND_SUPPORT */
  167.  
  168.     /* Reset ISR register and exit initialization mode */
  169.     LL_RTC_WriteReg(RTCx, ISR,      0x00000000U);
  170.  
  171.     /* Reset Tamper and alternate functions configuration register */
  172.     LL_RTC_WriteReg(RTCx, TAFCR, 0x00000000U);
  173.  
  174.     /* Wait till the RTC RSF flag is set */
  175.     status = LL_RTC_WaitForSynchro(RTCx);
  176.   }
  177.  
  178.   /* Enable the write protection for RTC registers */
  179.   LL_RTC_EnableWriteProtection(RTCx);
  180.  
  181.   return status;
  182. }
  183.  
  184. /**
  185.   * @brief  Initializes the RTC registers according to the specified parameters
  186.   *         in RTC_InitStruct.
  187.   * @param  RTCx RTC Instance
  188.   * @param  RTC_InitStruct pointer to a @ref LL_RTC_InitTypeDef structure that contains
  189.   *         the configuration information for the RTC peripheral.
  190.   * @note   The RTC Prescaler register is write protected and can be written in
  191.   *         initialization mode only.
  192.   * @retval An ErrorStatus enumeration value:
  193.   *          - SUCCESS: RTC registers are initialized
  194.   *          - ERROR: RTC registers are not initialized
  195.   */
  196. ErrorStatus LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_InitTypeDef *RTC_InitStruct)
  197. {
  198.   ErrorStatus status = ERROR;
  199.  
  200.   /* Check the parameters */
  201.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  202.   assert_param(IS_LL_RTC_HOURFORMAT(RTC_InitStruct->HourFormat));
  203.   assert_param(IS_LL_RTC_ASYNCH_PREDIV(RTC_InitStruct->AsynchPrescaler));
  204.   assert_param(IS_LL_RTC_SYNCH_PREDIV(RTC_InitStruct->SynchPrescaler));
  205.  
  206.   /* Disable the write protection for RTC registers */
  207.   LL_RTC_DisableWriteProtection(RTCx);
  208.  
  209.   /* Set Initialization mode */
  210.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  211.   {
  212.     /* Set Hour Format */
  213.     LL_RTC_SetHourFormat(RTCx, RTC_InitStruct->HourFormat);
  214.  
  215.     /* Configure Synchronous and Asynchronous prescaler factor */
  216.     LL_RTC_SetSynchPrescaler(RTCx, RTC_InitStruct->SynchPrescaler);
  217.     LL_RTC_SetAsynchPrescaler(RTCx, RTC_InitStruct->AsynchPrescaler);
  218.  
  219.     /* Exit Initialization mode */
  220.     LL_RTC_DisableInitMode(RTCx);
  221.  
  222.     status = SUCCESS;
  223.   }
  224.   /* Enable the write protection for RTC registers */
  225.   LL_RTC_EnableWriteProtection(RTCx);
  226.  
  227.   return status;
  228. }
  229.  
  230. /**
  231.   * @brief  Set each @ref LL_RTC_InitTypeDef field to default value.
  232.   * @param  RTC_InitStruct pointer to a @ref LL_RTC_InitTypeDef structure which will be initialized.
  233.   * @retval None
  234.   */
  235. void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct)
  236. {
  237.   /* Set RTC_InitStruct fields to default values */
  238.   RTC_InitStruct->HourFormat      = LL_RTC_HOURFORMAT_24HOUR;
  239.   RTC_InitStruct->AsynchPrescaler = RTC_ASYNCH_PRESC_DEFAULT;
  240.   RTC_InitStruct->SynchPrescaler  = RTC_SYNCH_PRESC_DEFAULT;
  241. }
  242.  
  243. /**
  244.   * @brief  Set the RTC current time.
  245.   * @param  RTCx RTC Instance
  246.   * @param  RTC_Format This parameter can be one of the following values:
  247.   *         @arg @ref LL_RTC_FORMAT_BIN
  248.   *         @arg @ref LL_RTC_FORMAT_BCD
  249.   * @param  RTC_TimeStruct pointer to a RTC_TimeTypeDef structure that contains
  250.   *                        the time configuration information for the RTC.
  251.   * @retval An ErrorStatus enumeration value:
  252.   *          - SUCCESS: RTC Time register is configured
  253.   *          - ERROR: RTC Time register is not configured
  254.   */
  255. ErrorStatus LL_RTC_TIME_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_TimeTypeDef *RTC_TimeStruct)
  256. {
  257.   ErrorStatus status = ERROR;
  258.  
  259.   /* Check the parameters */
  260.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  261.   assert_param(IS_LL_RTC_FORMAT(RTC_Format));
  262.  
  263.   if (RTC_Format == LL_RTC_FORMAT_BIN)
  264.   {
  265.     if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
  266.     {
  267.       assert_param(IS_LL_RTC_HOUR12(RTC_TimeStruct->Hours));
  268.       assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat));
  269.     }
  270.     else
  271.     {
  272.       RTC_TimeStruct->TimeFormat = 0x00U;
  273.       assert_param(IS_LL_RTC_HOUR24(RTC_TimeStruct->Hours));
  274.     }
  275.     assert_param(IS_LL_RTC_MINUTES(RTC_TimeStruct->Minutes));
  276.     assert_param(IS_LL_RTC_SECONDS(RTC_TimeStruct->Seconds));
  277.   }
  278.   else
  279.   {
  280.     if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
  281.     {
  282.       assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
  283.       assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat));
  284.     }
  285.     else
  286.     {
  287.       RTC_TimeStruct->TimeFormat = 0x00U;
  288.       assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
  289.     }
  290.     assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)));
  291.     assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds)));
  292.   }
  293.  
  294.   /* Disable the write protection for RTC registers */
  295.   LL_RTC_DisableWriteProtection(RTCx);
  296.  
  297.   /* Set Initialization mode */
  298.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  299.   {
  300.     /* Check the input parameters format */
  301.     if (RTC_Format != LL_RTC_FORMAT_BIN)
  302.     {
  303.       LL_RTC_TIME_Config(RTCx, RTC_TimeStruct->TimeFormat, RTC_TimeStruct->Hours,
  304.                          RTC_TimeStruct->Minutes, RTC_TimeStruct->Seconds);
  305.     }
  306.     else
  307.     {
  308.       LL_RTC_TIME_Config(RTCx, RTC_TimeStruct->TimeFormat, __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Hours),
  309.                          __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Minutes),
  310.                          __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Seconds));
  311.     }
  312.  
  313.     /* Exit Initialization mode */
  314.     LL_RTC_DisableInitMode(RTCx);
  315.  
  316. #if defined(RTC_CR_BYPSHAD)
  317.     /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
  318.     if (LL_RTC_IsShadowRegBypassEnabled(RTCx) == 0U)
  319.     {
  320.       status = LL_RTC_WaitForSynchro(RTCx);
  321.     }
  322.     else
  323.     {
  324.       status = SUCCESS;
  325.     }
  326. #else /* RTC_CR_BYPSHAD */
  327.     status = SUCCESS;
  328. #endif /* RTC_CR_BYPSHAD */
  329.   }
  330.   /* Enable the write protection for RTC registers */
  331.   LL_RTC_EnableWriteProtection(RTCx);
  332.  
  333.   return status;
  334. }
  335.  
  336. /**
  337.   * @brief  Set each @ref LL_RTC_TimeTypeDef field to default value (Time = 00h:00min:00sec).
  338.   * @param  RTC_TimeStruct pointer to a @ref LL_RTC_TimeTypeDef structure which will be initialized.
  339.   * @retval None
  340.   */
  341. void LL_RTC_TIME_StructInit(LL_RTC_TimeTypeDef *RTC_TimeStruct)
  342. {
  343.   /* Time = 00h:00min:00sec */
  344.   RTC_TimeStruct->TimeFormat = LL_RTC_TIME_FORMAT_AM_OR_24;
  345.   RTC_TimeStruct->Hours      = 0U;
  346.   RTC_TimeStruct->Minutes    = 0U;
  347.   RTC_TimeStruct->Seconds    = 0U;
  348. }
  349.  
  350. /**
  351.   * @brief  Set the RTC current date.
  352.   * @param  RTCx RTC Instance
  353.   * @param  RTC_Format This parameter can be one of the following values:
  354.   *         @arg @ref LL_RTC_FORMAT_BIN
  355.   *         @arg @ref LL_RTC_FORMAT_BCD
  356.   * @param  RTC_DateStruct pointer to a RTC_DateTypeDef structure that contains
  357.   *                         the date configuration information for the RTC.
  358.   * @retval An ErrorStatus enumeration value:
  359.   *          - SUCCESS: RTC Day register is configured
  360.   *          - ERROR: RTC Day register is not configured
  361.   */
  362. ErrorStatus LL_RTC_DATE_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_DateTypeDef *RTC_DateStruct)
  363. {
  364.   ErrorStatus status = ERROR;
  365.  
  366.   /* Check the parameters */
  367.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  368.   assert_param(IS_LL_RTC_FORMAT(RTC_Format));
  369.  
  370.   if ((RTC_Format == LL_RTC_FORMAT_BIN) && ((RTC_DateStruct->Month & 0x10U) == 0x10U))
  371.   {
  372.     RTC_DateStruct->Month = (uint8_t)(RTC_DateStruct->Month & (uint8_t)~(0x10U)) + 0x0AU;
  373.   }
  374.   if (RTC_Format == LL_RTC_FORMAT_BIN)
  375.   {
  376.     assert_param(IS_LL_RTC_YEAR(RTC_DateStruct->Year));
  377.     assert_param(IS_LL_RTC_MONTH(RTC_DateStruct->Month));
  378.     assert_param(IS_LL_RTC_DAY(RTC_DateStruct->Day));
  379.   }
  380.   else
  381.   {
  382.     assert_param(IS_LL_RTC_YEAR(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Year)));
  383.     assert_param(IS_LL_RTC_MONTH(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Month)));
  384.     assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Day)));
  385.   }
  386.   assert_param(IS_LL_RTC_WEEKDAY(RTC_DateStruct->WeekDay));
  387.  
  388.   /* Disable the write protection for RTC registers */
  389.   LL_RTC_DisableWriteProtection(RTCx);
  390.  
  391.   /* Set Initialization mode */
  392.   if (LL_RTC_EnterInitMode(RTCx) != ERROR)
  393.   {
  394.     /* Check the input parameters format */
  395.     if (RTC_Format != LL_RTC_FORMAT_BIN)
  396.     {
  397.       LL_RTC_DATE_Config(RTCx, RTC_DateStruct->WeekDay, RTC_DateStruct->Day, RTC_DateStruct->Month, RTC_DateStruct->Year);
  398.     }
  399.     else
  400.     {
  401.       LL_RTC_DATE_Config(RTCx, RTC_DateStruct->WeekDay, __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Day),
  402.                          __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Month), __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Year));
  403.     }
  404.  
  405.     /* Exit Initialization mode */
  406.     LL_RTC_DisableInitMode(RTCx);
  407.  
  408. #if defined(RTC_CR_BYPSHAD)
  409.     /* If  RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
  410.     if (LL_RTC_IsShadowRegBypassEnabled(RTCx) == 0U)
  411.     {
  412.       status = LL_RTC_WaitForSynchro(RTCx);
  413.     }
  414.     else
  415.     {
  416.       status = SUCCESS;
  417.     }
  418. #else /* RTC_CR_BYPSHAD */
  419.     status = SUCCESS;
  420. #endif /* RTC_CR_BYPSHAD */
  421.   }
  422.   /* Enable the write protection for RTC registers */
  423.   LL_RTC_EnableWriteProtection(RTCx);
  424.  
  425.   return status;
  426. }
  427.  
  428. /**
  429.   * @brief  Set each @ref LL_RTC_DateTypeDef field to default value (date = Monday, January 01 xx00)
  430.   * @param  RTC_DateStruct pointer to a @ref LL_RTC_DateTypeDef structure which will be initialized.
  431.   * @retval None
  432.   */
  433. void LL_RTC_DATE_StructInit(LL_RTC_DateTypeDef *RTC_DateStruct)
  434. {
  435.   /* Monday, January 01 xx00 */
  436.   RTC_DateStruct->WeekDay = LL_RTC_WEEKDAY_MONDAY;
  437.   RTC_DateStruct->Day     = 1U;
  438.   RTC_DateStruct->Month   = LL_RTC_MONTH_JANUARY;
  439.   RTC_DateStruct->Year    = 0U;
  440. }
  441.  
  442. /**
  443.   * @brief  Set the RTC Alarm A.
  444.   * @note   The Alarm register can only be written when the corresponding Alarm
  445.   *         is disabled (Use @ref LL_RTC_ALMA_Disable function).
  446.   * @param  RTCx RTC Instance
  447.   * @param  RTC_Format This parameter can be one of the following values:
  448.   *         @arg @ref LL_RTC_FORMAT_BIN
  449.   *         @arg @ref LL_RTC_FORMAT_BCD
  450.   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure that
  451.   *                         contains the alarm configuration parameters.
  452.   * @retval An ErrorStatus enumeration value:
  453.   *          - SUCCESS: ALARMA registers are configured
  454.   *          - ERROR: ALARMA registers are not configured
  455.   */
  456. ErrorStatus LL_RTC_ALMA_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
  457. {
  458.   /* Check the parameters */
  459.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  460.   assert_param(IS_LL_RTC_FORMAT(RTC_Format));
  461.   assert_param(IS_LL_RTC_ALMA_MASK(RTC_AlarmStruct->AlarmMask));
  462.   assert_param(IS_LL_RTC_ALMA_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel));
  463.  
  464.   if (RTC_Format == LL_RTC_FORMAT_BIN)
  465.   {
  466.     if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
  467.     {
  468.       assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours));
  469.       assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
  470.     }
  471.     else
  472.     {
  473.       RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
  474.       assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
  475.     }
  476.     assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
  477.     assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
  478.  
  479.     if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
  480.     {
  481.       assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay));
  482.     }
  483.     else
  484.     {
  485.       assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay));
  486.     }
  487.   }
  488.   else
  489.   {
  490.     if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
  491.     {
  492.       assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
  493.       assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
  494.     }
  495.     else
  496.     {
  497.       RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
  498.       assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
  499.     }
  500.  
  501.     assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
  502.     assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
  503.  
  504.     if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
  505.     {
  506.       assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
  507.     }
  508.     else
  509.     {
  510.       assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
  511.     }
  512.   }
  513.  
  514.   /* Disable the write protection for RTC registers */
  515.   LL_RTC_DisableWriteProtection(RTCx);
  516.  
  517.   /* Select weekday selection */
  518.   if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
  519.   {
  520.     /* Set the date for ALARM */
  521.     LL_RTC_ALMA_DisableWeekday(RTCx);
  522.     if (RTC_Format != LL_RTC_FORMAT_BIN)
  523.     {
  524.       LL_RTC_ALMA_SetDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
  525.     }
  526.     else
  527.     {
  528.       LL_RTC_ALMA_SetDay(RTCx, __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmDateWeekDay));
  529.     }
  530.   }
  531.   else
  532.   {
  533.     /* Set the week day for ALARM */
  534.     LL_RTC_ALMA_EnableWeekday(RTCx);
  535.     LL_RTC_ALMA_SetWeekDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
  536.   }
  537.  
  538.   /* Configure the Alarm register */
  539.   if (RTC_Format != LL_RTC_FORMAT_BIN)
  540.   {
  541.     LL_RTC_ALMA_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat, RTC_AlarmStruct->AlarmTime.Hours,
  542.                            RTC_AlarmStruct->AlarmTime.Minutes, RTC_AlarmStruct->AlarmTime.Seconds);
  543.   }
  544.   else
  545.   {
  546.     LL_RTC_ALMA_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat,
  547.                            __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Hours),
  548.                            __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Minutes),
  549.                            __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Seconds));
  550.   }
  551.   /* Set ALARM mask */
  552.   LL_RTC_ALMA_SetMask(RTCx, RTC_AlarmStruct->AlarmMask);
  553.  
  554.   /* Enable the write protection for RTC registers */
  555.   LL_RTC_EnableWriteProtection(RTCx);
  556.  
  557.   return SUCCESS;
  558. }
  559.  
  560. /**
  561.   * @brief  Set the RTC Alarm B.
  562.   * @note   The Alarm register can only be written when the corresponding Alarm
  563.   *         is disabled (@ref LL_RTC_ALMB_Disable function).
  564.   * @param  RTCx RTC Instance
  565.   * @param  RTC_Format This parameter can be one of the following values:
  566.   *         @arg @ref LL_RTC_FORMAT_BIN
  567.   *         @arg @ref LL_RTC_FORMAT_BCD
  568.   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure that
  569.   *                         contains the alarm configuration parameters.
  570.   * @retval An ErrorStatus enumeration value:
  571.   *          - SUCCESS: ALARMB registers are configured
  572.   *          - ERROR: ALARMB registers are not configured
  573.   */
  574. ErrorStatus LL_RTC_ALMB_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
  575. {
  576.   /* Check the parameters */
  577.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  578.   assert_param(IS_LL_RTC_FORMAT(RTC_Format));
  579.   assert_param(IS_LL_RTC_ALMB_MASK(RTC_AlarmStruct->AlarmMask));
  580.   assert_param(IS_LL_RTC_ALMB_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel));
  581.  
  582.   if (RTC_Format == LL_RTC_FORMAT_BIN)
  583.   {
  584.     if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
  585.     {
  586.       assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours));
  587.       assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
  588.     }
  589.     else
  590.     {
  591.       RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
  592.       assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
  593.     }
  594.     assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
  595.     assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
  596.  
  597.     if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
  598.     {
  599.       assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay));
  600.     }
  601.     else
  602.     {
  603.       assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay));
  604.     }
  605.   }
  606.   else
  607.   {
  608.     if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
  609.     {
  610.       assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
  611.       assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
  612.     }
  613.     else
  614.     {
  615.       RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
  616.       assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
  617.     }
  618.  
  619.     assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
  620.     assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
  621.  
  622.     if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
  623.     {
  624.       assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
  625.     }
  626.     else
  627.     {
  628.       assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
  629.     }
  630.   }
  631.  
  632.   /* Disable the write protection for RTC registers */
  633.   LL_RTC_DisableWriteProtection(RTCx);
  634.  
  635.   /* Select weekday selection */
  636.   if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
  637.   {
  638.     /* Set the date for ALARM */
  639.     LL_RTC_ALMB_DisableWeekday(RTCx);
  640.     if (RTC_Format != LL_RTC_FORMAT_BIN)
  641.     {
  642.       LL_RTC_ALMB_SetDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
  643.     }
  644.     else
  645.     {
  646.       LL_RTC_ALMB_SetDay(RTCx, __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmDateWeekDay));
  647.     }
  648.   }
  649.   else
  650.   {
  651.     /* Set the week day for ALARM */
  652.     LL_RTC_ALMB_EnableWeekday(RTCx);
  653.     LL_RTC_ALMB_SetWeekDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
  654.   }
  655.  
  656.   /* Configure the Alarm register */
  657.   if (RTC_Format != LL_RTC_FORMAT_BIN)
  658.   {
  659.     LL_RTC_ALMB_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat, RTC_AlarmStruct->AlarmTime.Hours,
  660.                            RTC_AlarmStruct->AlarmTime.Minutes, RTC_AlarmStruct->AlarmTime.Seconds);
  661.   }
  662.   else
  663.   {
  664.     LL_RTC_ALMB_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat,
  665.                            __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Hours),
  666.                            __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Minutes),
  667.                            __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Seconds));
  668.   }
  669.   /* Set ALARM mask */
  670.   LL_RTC_ALMB_SetMask(RTCx, RTC_AlarmStruct->AlarmMask);
  671.  
  672.   /* Enable the write protection for RTC registers */
  673.   LL_RTC_EnableWriteProtection(RTCx);
  674.  
  675.   return SUCCESS;
  676. }
  677.  
  678. /**
  679.   * @brief  Set each @ref LL_RTC_AlarmTypeDef of ALARMA field to default value (Time = 00h:00mn:00sec /
  680.   *         Day = 1st day of the month/Mask = all fields are masked).
  681.   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure which will be initialized.
  682.   * @retval None
  683.   */
  684. void LL_RTC_ALMA_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
  685. {
  686.   /* Alarm Time Settings : Time = 00h:00mn:00sec */
  687.   RTC_AlarmStruct->AlarmTime.TimeFormat = LL_RTC_ALMA_TIME_FORMAT_AM;
  688.   RTC_AlarmStruct->AlarmTime.Hours      = 0U;
  689.   RTC_AlarmStruct->AlarmTime.Minutes    = 0U;
  690.   RTC_AlarmStruct->AlarmTime.Seconds    = 0U;
  691.  
  692.   /* Alarm Day Settings : Day = 1st day of the month */
  693.   RTC_AlarmStruct->AlarmDateWeekDaySel = LL_RTC_ALMA_DATEWEEKDAYSEL_DATE;
  694.   RTC_AlarmStruct->AlarmDateWeekDay    = 1U;
  695.  
  696.   /* Alarm Masks Settings : Mask =  all fields are not masked */
  697.   RTC_AlarmStruct->AlarmMask           = LL_RTC_ALMA_MASK_NONE;
  698. }
  699.  
  700. /**
  701.   * @brief  Set each @ref LL_RTC_AlarmTypeDef of ALARMA field to default value (Time = 00h:00mn:00sec /
  702.   *         Day = 1st day of the month/Mask = all fields are masked).
  703.   * @param  RTC_AlarmStruct pointer to a @ref LL_RTC_AlarmTypeDef structure which will be initialized.
  704.   * @retval None
  705.   */
  706. void LL_RTC_ALMB_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
  707. {
  708.   /* Alarm Time Settings : Time = 00h:00mn:00sec */
  709.   RTC_AlarmStruct->AlarmTime.TimeFormat = LL_RTC_ALMB_TIME_FORMAT_AM;
  710.   RTC_AlarmStruct->AlarmTime.Hours      = 0U;
  711.   RTC_AlarmStruct->AlarmTime.Minutes    = 0U;
  712.   RTC_AlarmStruct->AlarmTime.Seconds    = 0U;
  713.  
  714.   /* Alarm Day Settings : Day = 1st day of the month */
  715.   RTC_AlarmStruct->AlarmDateWeekDaySel = LL_RTC_ALMB_DATEWEEKDAYSEL_DATE;
  716.   RTC_AlarmStruct->AlarmDateWeekDay    = 1U;
  717.  
  718.   /* Alarm Masks Settings : Mask =  all fields are not masked */
  719.   RTC_AlarmStruct->AlarmMask           = LL_RTC_ALMB_MASK_NONE;
  720. }
  721.  
  722. /**
  723.   * @brief  Enters the RTC Initialization mode.
  724.   * @note   The RTC Initialization mode is write protected, use the
  725.   *         @ref LL_RTC_DisableWriteProtection before calling this function.
  726.   * @param  RTCx RTC Instance
  727.   * @retval An ErrorStatus enumeration value:
  728.   *          - SUCCESS: RTC is in Init mode
  729.   *          - ERROR: RTC is not in Init mode
  730.   */
  731. ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx)
  732. {
  733.   __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
  734.   ErrorStatus status = SUCCESS;
  735.   uint32_t tmp = 0U;
  736.  
  737.   /* Check the parameter */
  738.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  739.  
  740.   /* Check if the Initialization mode is set */
  741.   if (LL_RTC_IsActiveFlag_INIT(RTCx) == 0U)
  742.   {
  743.     /* Set the Initialization mode */
  744.     LL_RTC_EnableInitMode(RTCx);
  745.  
  746.     /* Wait till RTC is in INIT state and if Time out is reached exit */
  747.     tmp = LL_RTC_IsActiveFlag_INIT(RTCx);
  748.     while ((timeout != 0U) && (tmp != 1U))
  749.     {
  750.       if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
  751.       {
  752.         timeout --;
  753.       }
  754.       tmp = LL_RTC_IsActiveFlag_INIT(RTCx);
  755.       if (timeout == 0U)
  756.       {
  757.         status = ERROR;
  758.       }
  759.     }
  760.   }
  761.   return status;
  762. }
  763.  
  764. /**
  765.   * @brief  Exit the RTC Initialization mode.
  766.   * @note   When the initialization sequence is complete, the calendar restarts
  767.   *         counting after 4 RTCCLK cycles.
  768.   * @note   The RTC Initialization mode is write protected, use the
  769.   *         @ref LL_RTC_DisableWriteProtection before calling this function.
  770.   * @param  RTCx RTC Instance
  771.   * @retval An ErrorStatus enumeration value:
  772.   *          - SUCCESS: RTC exited from in Init mode
  773.   *          - ERROR: Not applicable
  774.   */
  775. ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
  776. {
  777.   /* Check the parameter */
  778.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  779.  
  780.   /* Disable initialization mode */
  781.   LL_RTC_DisableInitMode(RTCx);
  782.  
  783.   return SUCCESS;
  784. }
  785.  
  786. /**
  787.   * @brief  Waits until the RTC Time and Day registers (RTC_TR and RTC_DR) are
  788.   *         synchronized with RTC APB clock.
  789.   * @note   The RTC Resynchronization mode is write protected, use the
  790.   *         @ref LL_RTC_DisableWriteProtection before calling this function.
  791.   * @note   To read the calendar through the shadow registers after calendar
  792.   *         initialization, calendar update or after wakeup from low power modes
  793.   *         the software must first clear the RSF flag.
  794.   *         The software must then wait until it is set again before reading
  795.   *         the calendar, which means that the calendar registers have been
  796.   *         correctly copied into the RTC_TR and RTC_DR shadow registers.
  797.   * @param  RTCx RTC Instance
  798.   * @retval An ErrorStatus enumeration value:
  799.   *          - SUCCESS: RTC registers are synchronised
  800.   *          - ERROR: RTC registers are not synchronised
  801.   */
  802. ErrorStatus LL_RTC_WaitForSynchro(RTC_TypeDef *RTCx)
  803. {
  804.   __IO uint32_t timeout = RTC_SYNCHRO_TIMEOUT;
  805.   ErrorStatus status = SUCCESS;
  806.   uint32_t tmp = 0U;
  807.  
  808.   /* Check the parameter */
  809.   assert_param(IS_RTC_ALL_INSTANCE(RTCx));
  810.  
  811.   /* Clear RSF flag */
  812.   LL_RTC_ClearFlag_RS(RTCx);
  813.  
  814.   /* Wait the registers to be synchronised */
  815.   tmp = LL_RTC_IsActiveFlag_RS(RTCx);
  816.   while ((timeout != 0U) && (tmp != 1U))
  817.   {
  818.     if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
  819.     {
  820.       timeout--;
  821.     }
  822.     tmp = LL_RTC_IsActiveFlag_RS(RTCx);
  823.     if (timeout == 0U)
  824.     {
  825.       status = ERROR;
  826.     }
  827.   }
  828.  
  829.   return (status);
  830. }
  831.  
  832. /**
  833.   * @}
  834.   */
  835.  
  836. /**
  837.   * @}
  838.   */
  839.  
  840. /**
  841.   * @}
  842.   */
  843.  
  844. #endif /* defined(RTC) */
  845.  
  846. /**
  847.   * @}
  848.   */
  849.  
  850. #endif /* USE_FULL_LL_DRIVER */
  851.