STM32L4xx_HAL_Driver  1.14.0
stm32l4xx_ll_rtc.c
Go to the documentation of this file.
1 
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 
34 #if defined(RTC)
35 
40 /* Private types -------------------------------------------------------------*/
41 /* Private variables ---------------------------------------------------------*/
42 /* Private constants ---------------------------------------------------------*/
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 
57 /* Private macros ------------------------------------------------------------*/
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 
119 /* Private function prototypes -----------------------------------------------*/
120 /* Exported functions --------------------------------------------------------*/
138 ErrorStatus LL_RTC_DeInit(RTC_TypeDef *RTCx)
139 {
140  ErrorStatus status = ERROR;
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  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
150  {
151  /* Reset TR, DR and CR registers */
152  LL_RTC_WriteReg(RTCx, TR, 0x00000000U);
153 
154  LL_RTC_WriteReg(RTCx, WUTR, RTC_WUTR_WUT);
155  LL_RTC_WriteReg(RTCx, DR, (RTC_DR_WDU_0 | RTC_DR_MU_0 | RTC_DR_DU_0));
156  /* Reset All CR bits except CR[2:0] */
157  LL_RTC_WriteReg(RTCx, CR, (LL_RTC_ReadReg(RTCx, CR) & RTC_CR_WUCKSEL));
158 
159  LL_RTC_WriteReg(RTCx, PRER, (RTC_PRER_PREDIV_A | RTC_SYNCH_PRESC_DEFAULT));
160  LL_RTC_WriteReg(RTCx, ALRMAR, 0x00000000U);
161  LL_RTC_WriteReg(RTCx, ALRMBR, 0x00000000U);
162  LL_RTC_WriteReg(RTCx, SHIFTR, 0x00000000U);
163  LL_RTC_WriteReg(RTCx, CALR, 0x00000000U);
164  LL_RTC_WriteReg(RTCx, ALRMASSR, 0x00000000U);
165  LL_RTC_WriteReg(RTCx, ALRMBSSR, 0x00000000U);
166 
167 #if defined(STM32L412xx) || defined(STM32L422xx)
168 #else /* #if defined(STM32L412xx) || defined(STM32L422xx) */
169  /* Reset ISR register and exit initialization mode */
170  LL_RTC_WriteReg(RTCx, ISR, 0x00000000U);
171 
172  /* Reset Tamper and alternate functions configuration register */
173  LL_RTC_WriteReg(RTCx, TAMPCR, 0x00000000U);
174 
175  /* Reset Option register */
176  LL_RTC_WriteReg(RTCx, OR, 0x00000000U);
177 #endif /* #if defined(STM32L412xx) || defined(STM32L422xx) */
178 
179  /* Wait till the RTC RSF flag is set */
180  status = LL_RTC_WaitForSynchro(RTCx);
181  }
182 
183  /* Enable the write protection for RTC registers */
184  LL_RTC_EnableWriteProtection(RTCx);
185 
186  return status;
187 }
188 
201 ErrorStatus LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_InitTypeDef *RTC_InitStruct)
202 {
203  ErrorStatus status = ERROR;
204 
205  /* Check the parameters */
206  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
207  assert_param(IS_LL_RTC_HOURFORMAT(RTC_InitStruct->HourFormat));
208  assert_param(IS_LL_RTC_ASYNCH_PREDIV(RTC_InitStruct->AsynchPrescaler));
209  assert_param(IS_LL_RTC_SYNCH_PREDIV(RTC_InitStruct->SynchPrescaler));
210 
211  /* Disable the write protection for RTC registers */
212  LL_RTC_DisableWriteProtection(RTCx);
213 
214  /* Set Initialization mode */
215  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
216  {
217  /* Set Hour Format */
218  LL_RTC_SetHourFormat(RTCx, RTC_InitStruct->HourFormat);
219 
220  /* Configure Synchronous and Asynchronous prescaler factor */
221  LL_RTC_SetSynchPrescaler(RTCx, RTC_InitStruct->SynchPrescaler);
222  LL_RTC_SetAsynchPrescaler(RTCx, RTC_InitStruct->AsynchPrescaler);
223 
224  /* Exit Initialization mode */
225  LL_RTC_DisableInitMode(RTCx);
226 
227  status = SUCCESS;
228  }
229  /* Enable the write protection for RTC registers */
230  LL_RTC_EnableWriteProtection(RTCx);
231 
232  return status;
233 }
234 
240 void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct)
241 {
242  /* Set RTC_InitStruct fields to default values */
243  RTC_InitStruct->HourFormat = LL_RTC_HOURFORMAT_24HOUR;
244  RTC_InitStruct->AsynchPrescaler = RTC_ASYNCH_PRESC_DEFAULT;
245  RTC_InitStruct->SynchPrescaler = RTC_SYNCH_PRESC_DEFAULT;
246 }
247 
260 ErrorStatus LL_RTC_TIME_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_TimeTypeDef *RTC_TimeStruct)
261 {
262  ErrorStatus status = ERROR;
263 
264  /* Check the parameters */
265  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
266  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
267 
268  if (RTC_Format == LL_RTC_FORMAT_BIN)
269  {
270  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
271  {
272  assert_param(IS_LL_RTC_HOUR12(RTC_TimeStruct->Hours));
273  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat));
274  }
275  else
276  {
277  RTC_TimeStruct->TimeFormat = 0x00U;
278  assert_param(IS_LL_RTC_HOUR24(RTC_TimeStruct->Hours));
279  }
280  assert_param(IS_LL_RTC_MINUTES(RTC_TimeStruct->Minutes));
281  assert_param(IS_LL_RTC_SECONDS(RTC_TimeStruct->Seconds));
282  }
283  else
284  {
285  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
286  {
287  assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
288  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat));
289  }
290  else
291  {
292  RTC_TimeStruct->TimeFormat = 0x00U;
293  assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
294  }
295  assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)));
296  assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds)));
297  }
298 
299  /* Disable the write protection for RTC registers */
300  LL_RTC_DisableWriteProtection(RTCx);
301 
302  /* Set Initialization mode */
303  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
304  {
305  /* Check the input parameters format */
306  if (RTC_Format != LL_RTC_FORMAT_BIN)
307  {
308  LL_RTC_TIME_Config(RTCx, RTC_TimeStruct->TimeFormat, RTC_TimeStruct->Hours,
309  RTC_TimeStruct->Minutes, RTC_TimeStruct->Seconds);
310  }
311  else
312  {
313  LL_RTC_TIME_Config(RTCx, RTC_TimeStruct->TimeFormat, __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Hours),
314  __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Minutes),
315  __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Seconds));
316  }
317 
318  /* Exit Initialization mode */
319  LL_RTC_DisableInitMode(RTC);
320 
321  /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
322  if (LL_RTC_IsShadowRegBypassEnabled(RTCx) == 0U)
323  {
324  status = LL_RTC_WaitForSynchro(RTCx);
325  }
326  else
327  {
328  status = SUCCESS;
329  }
330  }
331  /* Enable the write protection for RTC registers */
332  LL_RTC_EnableWriteProtection(RTCx);
333 
334  return status;
335 }
336 
342 void LL_RTC_TIME_StructInit(LL_RTC_TimeTypeDef *RTC_TimeStruct)
343 {
344  /* Time = 00h:00min:00sec */
345  RTC_TimeStruct->TimeFormat = LL_RTC_TIME_FORMAT_AM_OR_24;
346  RTC_TimeStruct->Hours = 0U;
347  RTC_TimeStruct->Minutes = 0U;
348  RTC_TimeStruct->Seconds = 0U;
349 }
350 
363 ErrorStatus LL_RTC_DATE_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_DateTypeDef *RTC_DateStruct)
364 {
365  ErrorStatus status = ERROR;
366 
367  /* Check the parameters */
368  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
369  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
370 
371  if ((RTC_Format == LL_RTC_FORMAT_BIN) && ((RTC_DateStruct->Month & 0x10U) == 0x10U))
372  {
373  RTC_DateStruct->Month = (uint8_t)((RTC_DateStruct->Month & (uint8_t)~(0x10U)) + 0x0AU);
374  }
375 
376  if (RTC_Format == LL_RTC_FORMAT_BIN)
377  {
378  assert_param(IS_LL_RTC_YEAR(RTC_DateStruct->Year));
379  assert_param(IS_LL_RTC_MONTH(RTC_DateStruct->Month));
380  assert_param(IS_LL_RTC_DAY(RTC_DateStruct->Day));
381  }
382  else
383  {
384  assert_param(IS_LL_RTC_YEAR(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Year)));
385  assert_param(IS_LL_RTC_MONTH(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Month)));
386  assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Day)));
387  }
388  assert_param(IS_LL_RTC_WEEKDAY(RTC_DateStruct->WeekDay));
389 
390  /* Disable the write protection for RTC registers */
391  LL_RTC_DisableWriteProtection(RTCx);
392 
393  /* Set Initialization mode */
394  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
395  {
396  /* Check the input parameters format */
397  if (RTC_Format != LL_RTC_FORMAT_BIN)
398  {
399  LL_RTC_DATE_Config(RTCx, RTC_DateStruct->WeekDay, RTC_DateStruct->Day, RTC_DateStruct->Month, RTC_DateStruct->Year);
400  }
401  else
402  {
403  LL_RTC_DATE_Config(RTCx, RTC_DateStruct->WeekDay, __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Day),
404  __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Month), __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Year));
405  }
406 
407  /* Exit Initialization mode */
408  LL_RTC_DisableInitMode(RTC);
409 
410  /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
411  if (LL_RTC_IsShadowRegBypassEnabled(RTCx) == 0U)
412  {
413  status = LL_RTC_WaitForSynchro(RTCx);
414  }
415  else
416  {
417  status = SUCCESS;
418  }
419  }
420  /* Enable the write protection for RTC registers */
421  LL_RTC_EnableWriteProtection(RTCx);
422 
423  return status;
424 }
425 
431 void LL_RTC_DATE_StructInit(LL_RTC_DateTypeDef *RTC_DateStruct)
432 {
433  /* Monday, January 01 xx00 */
434  RTC_DateStruct->WeekDay = LL_RTC_WEEKDAY_MONDAY;
435  RTC_DateStruct->Day = 1U;
436  RTC_DateStruct->Month = LL_RTC_MONTH_JANUARY;
437  RTC_DateStruct->Year = 0U;
438 }
439 
454 ErrorStatus LL_RTC_ALMA_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
455 {
456  /* Check the parameters */
457  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
458  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
459  assert_param(IS_LL_RTC_ALMA_MASK(RTC_AlarmStruct->AlarmMask));
460  assert_param(IS_LL_RTC_ALMA_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel));
461 
462  if (RTC_Format == LL_RTC_FORMAT_BIN)
463  {
464  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
465  {
466  assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours));
467  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
468  }
469  else
470  {
471  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
472  assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
473  }
474  assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
475  assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
476 
477  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
478  {
479  assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay));
480  }
481  else
482  {
483  assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay));
484  }
485  }
486  else
487  {
488  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
489  {
490  assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
491  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
492  }
493  else
494  {
495  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
496  assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
497  }
498 
499  assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
500  assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
501 
502  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
503  {
504  assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
505  }
506  else
507  {
508  assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
509  }
510  }
511 
512  /* Disable the write protection for RTC registers */
513  LL_RTC_DisableWriteProtection(RTCx);
514 
515  /* Select weekday selection */
516  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
517  {
518  /* Set the date for ALARM */
519  LL_RTC_ALMA_DisableWeekday(RTCx);
520  if (RTC_Format != LL_RTC_FORMAT_BIN)
521  {
522  LL_RTC_ALMA_SetDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
523  }
524  else
525  {
526  LL_RTC_ALMA_SetDay(RTCx, __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmDateWeekDay));
527  }
528  }
529  else
530  {
531  /* Set the week day for ALARM */
532  LL_RTC_ALMA_EnableWeekday(RTCx);
533  LL_RTC_ALMA_SetWeekDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
534  }
535 
536  /* Configure the Alarm register */
537  if (RTC_Format != LL_RTC_FORMAT_BIN)
538  {
539  LL_RTC_ALMA_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat, RTC_AlarmStruct->AlarmTime.Hours,
540  RTC_AlarmStruct->AlarmTime.Minutes, RTC_AlarmStruct->AlarmTime.Seconds);
541  }
542  else
543  {
544  LL_RTC_ALMA_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat,
545  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Hours),
546  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Minutes),
547  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Seconds));
548  }
549  /* Set ALARM mask */
550  LL_RTC_ALMA_SetMask(RTCx, RTC_AlarmStruct->AlarmMask);
551 
552  /* Enable the write protection for RTC registers */
553  LL_RTC_EnableWriteProtection(RTCx);
554 
555  return SUCCESS;
556 }
557 
572 ErrorStatus LL_RTC_ALMB_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
573 {
574  /* Check the parameters */
575  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
576  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
577  assert_param(IS_LL_RTC_ALMB_MASK(RTC_AlarmStruct->AlarmMask));
578  assert_param(IS_LL_RTC_ALMB_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel));
579 
580  if (RTC_Format == LL_RTC_FORMAT_BIN)
581  {
582  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
583  {
584  assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours));
585  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
586  }
587  else
588  {
589  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
590  assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
591  }
592  assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
593  assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
594 
595  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
596  {
597  assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay));
598  }
599  else
600  {
601  assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay));
602  }
603  }
604  else
605  {
606  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
607  {
608  assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
609  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
610  }
611  else
612  {
613  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
614  assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
615  }
616 
617  assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
618  assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
619 
620  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
621  {
622  assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
623  }
624  else
625  {
626  assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
627  }
628  }
629 
630  /* Disable the write protection for RTC registers */
631  LL_RTC_DisableWriteProtection(RTCx);
632 
633  /* Select weekday selection */
634  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
635  {
636  /* Set the date for ALARM */
637  LL_RTC_ALMB_DisableWeekday(RTCx);
638  if (RTC_Format != LL_RTC_FORMAT_BIN)
639  {
640  LL_RTC_ALMB_SetDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
641  }
642  else
643  {
644  LL_RTC_ALMB_SetDay(RTCx, __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmDateWeekDay));
645  }
646  }
647  else
648  {
649  /* Set the week day for ALARM */
650  LL_RTC_ALMB_EnableWeekday(RTCx);
651  LL_RTC_ALMB_SetWeekDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
652  }
653 
654  /* Configure the Alarm register */
655  if (RTC_Format != LL_RTC_FORMAT_BIN)
656  {
657  LL_RTC_ALMB_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat, RTC_AlarmStruct->AlarmTime.Hours,
658  RTC_AlarmStruct->AlarmTime.Minutes, RTC_AlarmStruct->AlarmTime.Seconds);
659  }
660  else
661  {
662  LL_RTC_ALMB_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat,
663  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Hours),
664  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Minutes),
665  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Seconds));
666  }
667  /* Set ALARM mask */
668  LL_RTC_ALMB_SetMask(RTCx, RTC_AlarmStruct->AlarmMask);
669 
670  /* Enable the write protection for RTC registers */
671  LL_RTC_EnableWriteProtection(RTCx);
672 
673  return SUCCESS;
674 }
675 
682 void LL_RTC_ALMA_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
683 {
684  /* Alarm Time Settings : Time = 00h:00mn:00sec */
685  RTC_AlarmStruct->AlarmTime.TimeFormat = LL_RTC_ALMA_TIME_FORMAT_AM;
686  RTC_AlarmStruct->AlarmTime.Hours = 0U;
687  RTC_AlarmStruct->AlarmTime.Minutes = 0U;
688  RTC_AlarmStruct->AlarmTime.Seconds = 0U;
689 
690  /* Alarm Day Settings : Day = 1st day of the month */
691  RTC_AlarmStruct->AlarmDateWeekDaySel = LL_RTC_ALMA_DATEWEEKDAYSEL_DATE;
692  RTC_AlarmStruct->AlarmDateWeekDay = 1U;
693 
694  /* Alarm Masks Settings : Mask = all fields are not masked */
695  RTC_AlarmStruct->AlarmMask = LL_RTC_ALMA_MASK_NONE;
696 }
697 
704 void LL_RTC_ALMB_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
705 {
706  /* Alarm Time Settings : Time = 00h:00mn:00sec */
707  RTC_AlarmStruct->AlarmTime.TimeFormat = LL_RTC_ALMB_TIME_FORMAT_AM;
708  RTC_AlarmStruct->AlarmTime.Hours = 0U;
709  RTC_AlarmStruct->AlarmTime.Minutes = 0U;
710  RTC_AlarmStruct->AlarmTime.Seconds = 0U;
711 
712  /* Alarm Day Settings : Day = 1st day of the month */
713  RTC_AlarmStruct->AlarmDateWeekDaySel = LL_RTC_ALMB_DATEWEEKDAYSEL_DATE;
714  RTC_AlarmStruct->AlarmDateWeekDay = 1U;
715 
716  /* Alarm Masks Settings : Mask = all fields are not masked */
717  RTC_AlarmStruct->AlarmMask = LL_RTC_ALMB_MASK_NONE;
718 }
719 
729 ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx)
730 {
731  __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
732  ErrorStatus status = SUCCESS;
733  uint32_t tmp;
734 
735  /* Check the parameter */
736  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
737 
738  /* Check if the Initialization mode is set */
739  if (LL_RTC_IsActiveFlag_INIT(RTCx) == 0U)
740  {
741  /* Set the Initialization mode */
742  LL_RTC_EnableInitMode(RTCx);
743 
744  /* Wait till RTC is in INIT state and if Time out is reached exit */
745  tmp = LL_RTC_IsActiveFlag_INIT(RTCx);
746  while ((timeout != 0U) && (tmp != 1U))
747  {
748  if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
749  {
750  timeout --;
751  }
752  tmp = LL_RTC_IsActiveFlag_INIT(RTCx);
753  if (timeout == 0U)
754  {
755  status = ERROR;
756  }
757  }
758  }
759  return status;
760 }
761 
773 ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
774 {
775  /* Check the parameter */
776  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
777 
778  /* Disable initialization mode */
779  LL_RTC_DisableInitMode(RTCx);
780 
781  return SUCCESS;
782 }
783 
800 ErrorStatus LL_RTC_WaitForSynchro(RTC_TypeDef *RTCx)
801 {
802  __IO uint32_t timeout = RTC_SYNCHRO_TIMEOUT;
803  ErrorStatus status = SUCCESS;
804  uint32_t tmp;
805 
806  /* Check the parameter */
807  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
808 
809  /* Clear RSF flag */
810  LL_RTC_ClearFlag_RS(RTCx);
811 
812  /* Wait the registers to be synchronised */
813  tmp = LL_RTC_IsActiveFlag_RS(RTCx);
814  while ((timeout != 0U) && (tmp != 0U))
815  {
816  if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
817  {
818  timeout--;
819  }
820  tmp = LL_RTC_IsActiveFlag_RS(RTCx);
821  if (timeout == 0U)
822  {
823  status = ERROR;
824  }
825  }
826 
827  if (status != ERROR)
828  {
829  timeout = RTC_SYNCHRO_TIMEOUT;
830  tmp = LL_RTC_IsActiveFlag_RS(RTCx);
831  while ((timeout != 0U) && (tmp != 1U))
832  {
833  if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
834  {
835  timeout--;
836  }
837  tmp = LL_RTC_IsActiveFlag_RS(RTCx);
838  if (timeout == 0U)
839  {
840  status = ERROR;
841  }
842  }
843  }
844 
845  return (status);
846 }
847 
860 #endif /* defined(RTC) */
861 
866 #endif /* USE_FULL_LL_DRIVER */
867 
868 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/
LL_RTC_ALMA_ConfigTime
__STATIC_INLINE void LL_RTC_ALMA_ConfigTime(RTC_TypeDef *RTCx, uint32_t Format12_24, uint32_t Hours, uint32_t Minutes, uint32_t Seconds)
Set Alarm A Time (hour, minute and second) in BCD format RTC_ALRMAR PM LL_RTC_ALMA_ConfigTime RTC_A...
Definition: stm32l4xx_ll_rtc.h:2165
stm32l4xx_ll_rtc.h
Header file of RTC LL module.
LL_RTC_InitTypeDef::SynchPrescaler
uint32_t SynchPrescaler
Definition: stm32l4xx_ll_rtc.h:100
LL_RTC_ALMA_EnableWeekday
__STATIC_INLINE void LL_RTC_ALMA_EnableWeekday(RTC_TypeDef *RTCx)
Enable AlarmA Week day selection (DU[3:0] represents the week day. DT[1:0] is do not care) RTC_ALRMA...
Definition: stm32l4xx_ll_rtc.h:1955
LL_RTC_WaitForSynchro
ErrorStatus LL_RTC_WaitForSynchro(RTC_TypeDef *RTCx)
Waits until the RTC Time and Day registers (RTC_TR and RTC_DR) are synchronized with RTC APB clock...
Definition: stm32l4xx_ll_rtc.c:800
LL_RTC_IsShadowRegBypassEnabled
__STATIC_INLINE uint32_t LL_RTC_IsShadowRegBypassEnabled(RTC_TypeDef *RTCx)
Check if Shadow registers bypass is enabled or not. RTC_CR BYPSHAD LL_RTC_IsShadowRegBypassEnabled.
Definition: stm32l4xx_ll_rtc.h:1110
LL_RTC_ALMB_ConfigTime
__STATIC_INLINE void LL_RTC_ALMB_ConfigTime(RTC_TypeDef *RTCx, uint32_t Format12_24, uint32_t Hours, uint32_t Minutes, uint32_t Seconds)
Set Alarm B Time (hour, minute and second) in BCD format RTC_ALRMBR PM LL_RTC_ALMB_ConfigTime RTC_A...
Definition: stm32l4xx_ll_rtc.h:2531
LL_RTC_DATE_Config
__STATIC_INLINE void LL_RTC_DATE_Config(RTC_TypeDef *RTCx, uint32_t WeekDay, uint32_t Day, uint32_t Month, uint32_t Year)
Set date (WeekDay, Day, Month and Year) in BCD format RTC_DR WDU LL_RTC_DATE_Config RTC_DR MT LL_RT...
Definition: stm32l4xx_ll_rtc.h:1837
LL_RTC_TIME_Init
ErrorStatus LL_RTC_TIME_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_TimeTypeDef *RTC_TimeStruct)
Set the RTC current time.
Definition: stm32l4xx_ll_rtc.c:260
LL_RTC_DateTypeDef
RTC Date structure definition.
Definition: stm32l4xx_ll_rtc.h:137
LL_RTC_ExitInitMode
ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
Exit the RTC Initialization mode.
Definition: stm32l4xx_ll_rtc.c:773
LL_RTC_StructInit
void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct)
Set each LL_RTC_InitTypeDef field to default value.
Definition: stm32l4xx_ll_rtc.c:240
LL_RTC_TimeTypeDef::Seconds
uint8_t Seconds
Definition: stm32l4xx_ll_rtc.h:128
LL_RTC_DATE_Init
ErrorStatus LL_RTC_DATE_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_DateTypeDef *RTC_DateStruct)
Set the RTC current date.
Definition: stm32l4xx_ll_rtc.c:363
LL_RTC_DisableInitMode
__STATIC_INLINE void LL_RTC_DisableInitMode(RTC_TypeDef *RTCx)
Disable initialization mode (Free running mode) RTC_ICSR INIT LL_RTC_DisableInitMode.
Definition: stm32l4xx_ll_rtc.h:988
LL_RTC_ALMA_DisableWeekday
__STATIC_INLINE void LL_RTC_ALMA_DisableWeekday(RTC_TypeDef *RTCx)
Disable AlarmA Week day selection (DU[3:0] represents the date ) RTC_ALRMAR WDSEL LL_RTC_ALMA_Disabl...
Definition: stm32l4xx_ll_rtc.h:1966
LL_RTC_ALMB_EnableWeekday
__STATIC_INLINE void LL_RTC_ALMB_EnableWeekday(RTC_TypeDef *RTCx)
Enable AlarmB Week day selection (DU[3:0] represents the week day. DT[1:0] is do not care) RTC_ALRMB...
Definition: stm32l4xx_ll_rtc.h:2321
LL_RTC_AlarmTypeDef::AlarmDateWeekDay
uint8_t AlarmDateWeekDay
Definition: stm32l4xx_ll_rtc.h:181
LL_RTC_ClearFlag_RS
__STATIC_INLINE void LL_RTC_ClearFlag_RS(RTC_TypeDef *RTCx)
Clear Registers synchronization flag RTC_ICSR RSF LL_RTC_ClearFlag_RS.
Definition: stm32l4xx_ll_rtc.h:3662
LL_RTC_SetHourFormat
__STATIC_INLINE void LL_RTC_SetHourFormat(RTC_TypeDef *RTCx, uint32_t HourFormat)
Set Hours format (24 hour/day or AM/PM hour format)
Definition: stm32l4xx_ll_rtc.h:889
LL_RTC_EnableWriteProtection
__STATIC_INLINE void LL_RTC_EnableWriteProtection(RTC_TypeDef *RTCx)
Enable the write protection for RTC registers. RTC_WPR KEY LL_RTC_EnableWriteProtection.
Definition: stm32l4xx_ll_rtc.h:1193
LL_RTC_SetAsynchPrescaler
__STATIC_INLINE void LL_RTC_SetAsynchPrescaler(RTC_TypeDef *RTCx, uint32_t AsynchPrescaler)
Set Asynchronous prescaler factor RTC_PRER PREDIV_A LL_RTC_SetAsynchPrescaler.
Definition: stm32l4xx_ll_rtc.h:1148
LL_RTC_InitTypeDef::HourFormat
uint32_t HourFormat
Definition: stm32l4xx_ll_rtc.h:88
LL_RTC_DeInit
ErrorStatus LL_RTC_DeInit(RTC_TypeDef *RTCx)
De-Initializes the RTC registers to their default reset values.
Definition: stm32l4xx_ll_rtc.c:138
LL_RTC_DisableWriteProtection
__STATIC_INLINE void LL_RTC_DisableWriteProtection(RTC_TypeDef *RTCx)
Disable the write protection for RTC registers. RTC_WPR KEY LL_RTC_DisableWriteProtection.
Definition: stm32l4xx_ll_rtc.h:1204
LL_RTC_ALMB_StructInit
void LL_RTC_ALMB_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
Set each LL_RTC_AlarmTypeDef of ALARMA field to default value (Time = 00h:00mn:00sec / Day = 1st day ...
Definition: stm32l4xx_ll_rtc.c:704
LL_RTC_IsActiveFlag_RS
__STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_RS(RTC_TypeDef *RTCx)
Get Registers synchronization flag RTC_ICSR RSF LL_RTC_IsActiveFlag_RS.
Definition: stm32l4xx_ll_rtc.h:3651
LL_RTC_EnableInitMode
__STATIC_INLINE void LL_RTC_EnableInitMode(RTC_TypeDef *RTCx)
Enable initialization mode.
Definition: stm32l4xx_ll_rtc.h:976
LL_RTC_ALMB_DisableWeekday
__STATIC_INLINE void LL_RTC_ALMB_DisableWeekday(RTC_TypeDef *RTCx)
Disable AlarmB Week day selection (DU[3:0] represents the date ) RTC_ALRMBR WDSEL LL_RTC_ALMB_Disabl...
Definition: stm32l4xx_ll_rtc.h:2332
LL_RTC_InitTypeDef::AsynchPrescaler
uint32_t AsynchPrescaler
Definition: stm32l4xx_ll_rtc.h:94
WUTR
hrtc Instance WUTR
Definition: stm32l4xx_hal_rtc_ex.c:844
LL_RTC_TimeTypeDef
RTC Time structure definition.
Definition: stm32l4xx_ll_rtc.h:110
LL_RTC_ALMA_StructInit
void LL_RTC_ALMA_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
Set each LL_RTC_AlarmTypeDef of ALARMA field to default value (Time = 00h:00mn:00sec / Day = 1st day ...
Definition: stm32l4xx_ll_rtc.c:682
LL_RTC_DateTypeDef::Day
uint8_t Day
Definition: stm32l4xx_ll_rtc.h:149
LL_RTC_InitTypeDef
RTC Init structures definition.
Definition: stm32l4xx_ll_rtc.h:86
LL_RTC_DateTypeDef::Year
uint8_t Year
Definition: stm32l4xx_ll_rtc.h:154
LL_RTC_TimeTypeDef::Hours
uint8_t Hours
Definition: stm32l4xx_ll_rtc.h:117
LL_RTC_DATE_StructInit
void LL_RTC_DATE_StructInit(LL_RTC_DateTypeDef *RTC_DateStruct)
Set each LL_RTC_DateTypeDef field to default value (date = Monday, January 01 xx00) ...
Definition: stm32l4xx_ll_rtc.c:431
LL_RTC_ALMB_Init
ErrorStatus LL_RTC_ALMB_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
Set the RTC Alarm B.
Definition: stm32l4xx_ll_rtc.c:572
LL_RTC_DateTypeDef::WeekDay
uint8_t WeekDay
Definition: stm32l4xx_ll_rtc.h:139
LL_RTC_GetHourFormat
__STATIC_INLINE uint32_t LL_RTC_GetHourFormat(RTC_TypeDef *RTCx)
Get Hours format (24 hour/day or AM/PM hour format) RTC_CR FMT LL_RTC_GetHourFormat.
Definition: stm32l4xx_ll_rtc.h:902
LL_RTC_DateTypeDef::Month
uint8_t Month
Definition: stm32l4xx_ll_rtc.h:144
LL_RTC_AlarmTypeDef::AlarmTime
LL_RTC_TimeTypeDef AlarmTime
Definition: stm32l4xx_ll_rtc.h:165
LL_RTC_AlarmTypeDef::AlarmDateWeekDaySel
uint32_t AlarmDateWeekDaySel
Definition: stm32l4xx_ll_rtc.h:174
LL_RTC_ALMA_SetMask
__STATIC_INLINE void LL_RTC_ALMA_SetMask(RTC_TypeDef *RTCx, uint32_t Mask)
Specify the Alarm A masks. RTC_ALRMAR MSK4 LL_RTC_ALMA_SetMask RTC_ALRMAR MSK3 LL_RTC_ALMA_SetMask ...
Definition: stm32l4xx_ll_rtc.h:1924
LL_RTC_IsActiveFlag_INIT
__STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_INIT(RTC_TypeDef *RTCx)
Get Initialization flag RTC_ICSR INITF LL_RTC_IsActiveFlag_INIT.
Definition: stm32l4xx_ll_rtc.h:3640
LL_RTC_TIME_Config
__STATIC_INLINE void LL_RTC_TIME_Config(RTC_TypeDef *RTCx, uint32_t Format12_24, uint32_t Hours, uint32_t Minutes, uint32_t Seconds)
Set time (hour, minute and second) in BCD format.
Definition: stm32l4xx_ll_rtc.h:1507
stm32l4xx_ll_cortex.h
Header file of CORTEX LL module.
LL_RTC_AlarmTypeDef
RTC Alarm structure definition.
Definition: stm32l4xx_ll_rtc.h:163
LL_SYSTICK_IsActiveCounterFlag
__STATIC_INLINE uint32_t LL_SYSTICK_IsActiveCounterFlag(void)
This function checks if the Systick counter flag is active or not.
Definition: stm32l4xx_ll_cortex.h:230
LL_RTC_Init
ErrorStatus LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_InitTypeDef *RTC_InitStruct)
Initializes the RTC registers according to the specified parameters in RTC_InitStruct.
Definition: stm32l4xx_ll_rtc.c:201
LL_RTC_ALMB_SetDay
__STATIC_INLINE void LL_RTC_ALMB_SetDay(RTC_TypeDef *RTCx, uint32_t Day)
Set ALARM B Day in BCD format.
Definition: stm32l4xx_ll_rtc.h:2346
LL_RTC_ALMA_SetWeekDay
__STATIC_INLINE void LL_RTC_ALMA_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
Set ALARM A Weekday RTC_ALRMAR DU LL_RTC_ALMA_SetWeekDay.
Definition: stm32l4xx_ll_rtc.h:2013
LL_RTC_AlarmTypeDef::AlarmMask
uint32_t AlarmMask
Definition: stm32l4xx_ll_rtc.h:167
LL_RTC_TIME_StructInit
void LL_RTC_TIME_StructInit(LL_RTC_TimeTypeDef *RTC_TimeStruct)
Set each LL_RTC_TimeTypeDef field to default value (Time = 00h:00min:00sec).
Definition: stm32l4xx_ll_rtc.c:342
LL_RTC_ALMA_Init
ErrorStatus LL_RTC_ALMA_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
Set the RTC Alarm A.
Definition: stm32l4xx_ll_rtc.c:454
LL_RTC_SetSynchPrescaler
__STATIC_INLINE void LL_RTC_SetSynchPrescaler(RTC_TypeDef *RTCx, uint32_t SynchPrescaler)
Set Synchronous prescaler factor RTC_PRER PREDIV_S LL_RTC_SetSynchPrescaler.
Definition: stm32l4xx_ll_rtc.h:1160
LL_RTC_ALMB_SetWeekDay
__STATIC_INLINE void LL_RTC_ALMB_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
Set ALARM B Weekday RTC_ALRMBR DU LL_RTC_ALMB_SetWeekDay.
Definition: stm32l4xx_ll_rtc.h:2379
LL_RTC_TimeTypeDef::TimeFormat
uint32_t TimeFormat
Definition: stm32l4xx_ll_rtc.h:112
LL_RTC_ALMA_SetDay
__STATIC_INLINE void LL_RTC_ALMA_SetDay(RTC_TypeDef *RTCx, uint32_t Day)
Set ALARM A Day in BCD format.
Definition: stm32l4xx_ll_rtc.h:1980
LL_RTC_TimeTypeDef::Minutes
uint8_t Minutes
Definition: stm32l4xx_ll_rtc.h:123
LL_RTC_ALMB_SetMask
__STATIC_INLINE void LL_RTC_ALMB_SetMask(RTC_TypeDef *RTCx, uint32_t Mask)
Specify the Alarm B masks. RTC_ALRMBR MSK4 LL_RTC_ALMB_SetMask RTC_ALRMBR MSK3 LL_RTC_ALMB_SetMask ...
Definition: stm32l4xx_ll_rtc.h:2290
assert_param
assert_param(IS_RTC_WAKEUP_CLOCK(WakeUpClock))
LL_RTC_EnterInitMode
ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx)
Enters the RTC Initialization mode.
Definition: stm32l4xx_ll_rtc.c:729