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