STM32F4xx_HAL_Driver  1.8.3
stm32f4xx_ll_rtc.c
Go to the documentation of this file.
1 
18 #if defined(USE_FULL_LL_DRIVER)
19 
20 /* Includes ------------------------------------------------------------------*/
21 #include "stm32f4xx_ll_rtc.h"
22 #include "stm32f4xx_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 
33 #if defined(RTC)
34 
39 /* Private types -------------------------------------------------------------*/
40 /* Private variables ---------------------------------------------------------*/
41 /* Private constants ---------------------------------------------------------*/
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 */
56 /* Private macros ------------------------------------------------------------*/
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 
116 /* Private function prototypes -----------------------------------------------*/
117 /* Exported functions --------------------------------------------------------*/
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  LL_RTC_WriteReg(RTCx, CALR, 0x00000000U);
160  LL_RTC_WriteReg(RTCx, SHIFTR, 0x00000000U);
161  LL_RTC_WriteReg(RTCx, ALRMASSR, 0x00000000U);
162  LL_RTC_WriteReg(RTCx, ALRMBSSR, 0x00000000U);
163 
164  /* Reset ISR register and exit initialization mode */
165  LL_RTC_WriteReg(RTCx, ISR, 0x00000000U);
166 
167  /* Reset Tamper and alternate functions configuration register */
168  LL_RTC_WriteReg(RTCx, TAFCR, 0x00000000U);
169 
170  /* Wait till the RTC RSF flag is set */
171  status = LL_RTC_WaitForSynchro(RTCx);
172  }
173 
174  /* Enable the write protection for RTC registers */
175  LL_RTC_EnableWriteProtection(RTCx);
176 
177  return status;
178 }
179 
192 ErrorStatus LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_InitTypeDef *RTC_InitStruct)
193 {
194  ErrorStatus status = ERROR;
195 
196  /* Check the parameters */
197  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
198  assert_param(IS_LL_RTC_HOURFORMAT(RTC_InitStruct->HourFormat));
199  assert_param(IS_LL_RTC_ASYNCH_PREDIV(RTC_InitStruct->AsynchPrescaler));
200  assert_param(IS_LL_RTC_SYNCH_PREDIV(RTC_InitStruct->SynchPrescaler));
201 
202  /* Disable the write protection for RTC registers */
203  LL_RTC_DisableWriteProtection(RTCx);
204 
205  /* Set Initialization mode */
206  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
207  {
208  /* Set Hour Format */
209  LL_RTC_SetHourFormat(RTCx, RTC_InitStruct->HourFormat);
210 
211  /* Configure Synchronous and Asynchronous prescaler factor */
212  LL_RTC_SetSynchPrescaler(RTCx, RTC_InitStruct->SynchPrescaler);
213  LL_RTC_SetAsynchPrescaler(RTCx, RTC_InitStruct->AsynchPrescaler);
214 
215  /* Exit Initialization mode */
216  LL_RTC_DisableInitMode(RTCx);
217 
218  status = SUCCESS;
219  }
220  /* Enable the write protection for RTC registers */
221  LL_RTC_EnableWriteProtection(RTCx);
222 
223  return status;
224 }
225 
231 void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct)
232 {
233  /* Set RTC_InitStruct fields to default values */
234  RTC_InitStruct->HourFormat = LL_RTC_HOURFORMAT_24HOUR;
235  RTC_InitStruct->AsynchPrescaler = RTC_ASYNCH_PRESC_DEFAULT;
236  RTC_InitStruct->SynchPrescaler = RTC_SYNCH_PRESC_DEFAULT;
237 }
238 
251 ErrorStatus LL_RTC_TIME_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_TimeTypeDef *RTC_TimeStruct)
252 {
253  ErrorStatus status = ERROR;
254 
255  /* Check the parameters */
256  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
257  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
258 
259  if (RTC_Format == LL_RTC_FORMAT_BIN)
260  {
261  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
262  {
263  assert_param(IS_LL_RTC_HOUR12(RTC_TimeStruct->Hours));
264  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat));
265  }
266  else
267  {
268  RTC_TimeStruct->TimeFormat = 0x00U;
269  assert_param(IS_LL_RTC_HOUR24(RTC_TimeStruct->Hours));
270  }
271  assert_param(IS_LL_RTC_MINUTES(RTC_TimeStruct->Minutes));
272  assert_param(IS_LL_RTC_SECONDS(RTC_TimeStruct->Seconds));
273  }
274  else
275  {
276  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
277  {
278  assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
279  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_TimeStruct->TimeFormat));
280  }
281  else
282  {
283  RTC_TimeStruct->TimeFormat = 0x00U;
284  assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Hours)));
285  }
286  assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Minutes)));
287  assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_TimeStruct->Seconds)));
288  }
289 
290  /* Disable the write protection for RTC registers */
291  LL_RTC_DisableWriteProtection(RTCx);
292 
293  /* Set Initialization mode */
294  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
295  {
296  /* Check the input parameters format */
297  if (RTC_Format != LL_RTC_FORMAT_BIN)
298  {
299  LL_RTC_TIME_Config(RTCx, RTC_TimeStruct->TimeFormat, RTC_TimeStruct->Hours,
300  RTC_TimeStruct->Minutes, RTC_TimeStruct->Seconds);
301  }
302  else
303  {
304  LL_RTC_TIME_Config(RTCx, RTC_TimeStruct->TimeFormat, __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Hours),
305  __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Minutes),
306  __LL_RTC_CONVERT_BIN2BCD(RTC_TimeStruct->Seconds));
307  }
308 
309  /* Exit Initialization mode */
310  LL_RTC_DisableInitMode(RTCx);
311 
312  /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
313  if (LL_RTC_IsShadowRegBypassEnabled(RTCx) == 0U)
314  {
315  status = LL_RTC_WaitForSynchro(RTCx);
316  }
317  else
318  {
319  status = SUCCESS;
320  }
321  }
322  /* Enable the write protection for RTC registers */
323  LL_RTC_EnableWriteProtection(RTCx);
324 
325  return status;
326 }
327 
333 void LL_RTC_TIME_StructInit(LL_RTC_TimeTypeDef *RTC_TimeStruct)
334 {
335  /* Time = 00h:00min:00sec */
336  RTC_TimeStruct->TimeFormat = LL_RTC_TIME_FORMAT_AM_OR_24;
337  RTC_TimeStruct->Hours = 0U;
338  RTC_TimeStruct->Minutes = 0U;
339  RTC_TimeStruct->Seconds = 0U;
340 }
341 
354 ErrorStatus LL_RTC_DATE_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_DateTypeDef *RTC_DateStruct)
355 {
356  ErrorStatus status = ERROR;
357 
358  /* Check the parameters */
359  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
360  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
361 
362  if ((RTC_Format == LL_RTC_FORMAT_BIN) && ((RTC_DateStruct->Month & 0x10U) == 0x10U))
363  {
364  RTC_DateStruct->Month = (uint8_t)(RTC_DateStruct->Month & (uint8_t)~(0x10U)) + 0x0AU;
365  }
366  if (RTC_Format == LL_RTC_FORMAT_BIN)
367  {
368  assert_param(IS_LL_RTC_YEAR(RTC_DateStruct->Year));
369  assert_param(IS_LL_RTC_MONTH(RTC_DateStruct->Month));
370  assert_param(IS_LL_RTC_DAY(RTC_DateStruct->Day));
371  }
372  else
373  {
374  assert_param(IS_LL_RTC_YEAR(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Year)));
375  assert_param(IS_LL_RTC_MONTH(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Month)));
376  assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_DateStruct->Day)));
377  }
378  assert_param(IS_LL_RTC_WEEKDAY(RTC_DateStruct->WeekDay));
379 
380  /* Disable the write protection for RTC registers */
381  LL_RTC_DisableWriteProtection(RTCx);
382 
383  /* Set Initialization mode */
384  if (LL_RTC_EnterInitMode(RTCx) != ERROR)
385  {
386  /* Check the input parameters format */
387  if (RTC_Format != LL_RTC_FORMAT_BIN)
388  {
389  LL_RTC_DATE_Config(RTCx, RTC_DateStruct->WeekDay, RTC_DateStruct->Day, RTC_DateStruct->Month, RTC_DateStruct->Year);
390  }
391  else
392  {
393  LL_RTC_DATE_Config(RTCx, RTC_DateStruct->WeekDay, __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Day),
394  __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Month), __LL_RTC_CONVERT_BIN2BCD(RTC_DateStruct->Year));
395  }
396 
397  /* Exit Initialization mode */
398  LL_RTC_DisableInitMode(RTCx);
399 
400  /* If RTC_CR_BYPSHAD bit = 0, wait for synchro else this check is not needed */
401  if (LL_RTC_IsShadowRegBypassEnabled(RTCx) == 0U)
402  {
403  status = LL_RTC_WaitForSynchro(RTCx);
404  }
405  else
406  {
407  status = SUCCESS;
408  }
409  }
410  /* Enable the write protection for RTC registers */
411  LL_RTC_EnableWriteProtection(RTCx);
412 
413  return status;
414 }
415 
421 void LL_RTC_DATE_StructInit(LL_RTC_DateTypeDef *RTC_DateStruct)
422 {
423  /* Monday, January 01 xx00 */
424  RTC_DateStruct->WeekDay = LL_RTC_WEEKDAY_MONDAY;
425  RTC_DateStruct->Day = 1U;
426  RTC_DateStruct->Month = LL_RTC_MONTH_JANUARY;
427  RTC_DateStruct->Year = 0U;
428 }
429 
444 ErrorStatus LL_RTC_ALMA_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
445 {
446  /* Check the parameters */
447  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
448  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
449  assert_param(IS_LL_RTC_ALMA_MASK(RTC_AlarmStruct->AlarmMask));
450  assert_param(IS_LL_RTC_ALMA_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel));
451 
452  if (RTC_Format == LL_RTC_FORMAT_BIN)
453  {
454  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
455  {
456  assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours));
457  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
458  }
459  else
460  {
461  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
462  assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
463  }
464  assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
465  assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
466 
467  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
468  {
469  assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay));
470  }
471  else
472  {
473  assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay));
474  }
475  }
476  else
477  {
478  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
479  {
480  assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
481  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
482  }
483  else
484  {
485  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
486  assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
487  }
488 
489  assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
490  assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
491 
492  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
493  {
494  assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
495  }
496  else
497  {
498  assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
499  }
500  }
501 
502  /* Disable the write protection for RTC registers */
503  LL_RTC_DisableWriteProtection(RTCx);
504 
505  /* Select weekday selection */
506  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMA_DATEWEEKDAYSEL_DATE)
507  {
508  /* Set the date for ALARM */
509  LL_RTC_ALMA_DisableWeekday(RTCx);
510  if (RTC_Format != LL_RTC_FORMAT_BIN)
511  {
512  LL_RTC_ALMA_SetDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
513  }
514  else
515  {
516  LL_RTC_ALMA_SetDay(RTCx, __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmDateWeekDay));
517  }
518  }
519  else
520  {
521  /* Set the week day for ALARM */
522  LL_RTC_ALMA_EnableWeekday(RTCx);
523  LL_RTC_ALMA_SetWeekDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
524  }
525 
526  /* Configure the Alarm register */
527  if (RTC_Format != LL_RTC_FORMAT_BIN)
528  {
529  LL_RTC_ALMA_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat, RTC_AlarmStruct->AlarmTime.Hours,
530  RTC_AlarmStruct->AlarmTime.Minutes, RTC_AlarmStruct->AlarmTime.Seconds);
531  }
532  else
533  {
534  LL_RTC_ALMA_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat,
535  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Hours),
536  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Minutes),
537  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Seconds));
538  }
539  /* Set ALARM mask */
540  LL_RTC_ALMA_SetMask(RTCx, RTC_AlarmStruct->AlarmMask);
541 
542  /* Enable the write protection for RTC registers */
543  LL_RTC_EnableWriteProtection(RTCx);
544 
545  return SUCCESS;
546 }
547 
562 ErrorStatus LL_RTC_ALMB_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
563 {
564  /* Check the parameters */
565  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
566  assert_param(IS_LL_RTC_FORMAT(RTC_Format));
567  assert_param(IS_LL_RTC_ALMB_MASK(RTC_AlarmStruct->AlarmMask));
568  assert_param(IS_LL_RTC_ALMB_DATE_WEEKDAY_SEL(RTC_AlarmStruct->AlarmDateWeekDaySel));
569 
570  if (RTC_Format == LL_RTC_FORMAT_BIN)
571  {
572  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
573  {
574  assert_param(IS_LL_RTC_HOUR12(RTC_AlarmStruct->AlarmTime.Hours));
575  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
576  }
577  else
578  {
579  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
580  assert_param(IS_LL_RTC_HOUR24(RTC_AlarmStruct->AlarmTime.Hours));
581  }
582  assert_param(IS_LL_RTC_MINUTES(RTC_AlarmStruct->AlarmTime.Minutes));
583  assert_param(IS_LL_RTC_SECONDS(RTC_AlarmStruct->AlarmTime.Seconds));
584 
585  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
586  {
587  assert_param(IS_LL_RTC_DAY(RTC_AlarmStruct->AlarmDateWeekDay));
588  }
589  else
590  {
591  assert_param(IS_LL_RTC_WEEKDAY(RTC_AlarmStruct->AlarmDateWeekDay));
592  }
593  }
594  else
595  {
596  if (LL_RTC_GetHourFormat(RTCx) != LL_RTC_HOURFORMAT_24HOUR)
597  {
598  assert_param(IS_LL_RTC_HOUR12(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
599  assert_param(IS_LL_RTC_TIME_FORMAT(RTC_AlarmStruct->AlarmTime.TimeFormat));
600  }
601  else
602  {
603  RTC_AlarmStruct->AlarmTime.TimeFormat = 0x00U;
604  assert_param(IS_LL_RTC_HOUR24(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Hours)));
605  }
606 
607  assert_param(IS_LL_RTC_MINUTES(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Minutes)));
608  assert_param(IS_LL_RTC_SECONDS(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmTime.Seconds)));
609 
610  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
611  {
612  assert_param(IS_LL_RTC_DAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
613  }
614  else
615  {
616  assert_param(IS_LL_RTC_WEEKDAY(__LL_RTC_CONVERT_BCD2BIN(RTC_AlarmStruct->AlarmDateWeekDay)));
617  }
618  }
619 
620  /* Disable the write protection for RTC registers */
621  LL_RTC_DisableWriteProtection(RTCx);
622 
623  /* Select weekday selection */
624  if (RTC_AlarmStruct->AlarmDateWeekDaySel == LL_RTC_ALMB_DATEWEEKDAYSEL_DATE)
625  {
626  /* Set the date for ALARM */
627  LL_RTC_ALMB_DisableWeekday(RTCx);
628  if (RTC_Format != LL_RTC_FORMAT_BIN)
629  {
630  LL_RTC_ALMB_SetDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
631  }
632  else
633  {
634  LL_RTC_ALMB_SetDay(RTCx, __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmDateWeekDay));
635  }
636  }
637  else
638  {
639  /* Set the week day for ALARM */
640  LL_RTC_ALMB_EnableWeekday(RTCx);
641  LL_RTC_ALMB_SetWeekDay(RTCx, RTC_AlarmStruct->AlarmDateWeekDay);
642  }
643 
644  /* Configure the Alarm register */
645  if (RTC_Format != LL_RTC_FORMAT_BIN)
646  {
647  LL_RTC_ALMB_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat, RTC_AlarmStruct->AlarmTime.Hours,
648  RTC_AlarmStruct->AlarmTime.Minutes, RTC_AlarmStruct->AlarmTime.Seconds);
649  }
650  else
651  {
652  LL_RTC_ALMB_ConfigTime(RTCx, RTC_AlarmStruct->AlarmTime.TimeFormat,
653  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Hours),
654  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Minutes),
655  __LL_RTC_CONVERT_BIN2BCD(RTC_AlarmStruct->AlarmTime.Seconds));
656  }
657  /* Set ALARM mask */
658  LL_RTC_ALMB_SetMask(RTCx, RTC_AlarmStruct->AlarmMask);
659 
660  /* Enable the write protection for RTC registers */
661  LL_RTC_EnableWriteProtection(RTCx);
662 
663  return SUCCESS;
664 }
665 
672 void LL_RTC_ALMA_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
673 {
674  /* Alarm Time Settings : Time = 00h:00mn:00sec */
675  RTC_AlarmStruct->AlarmTime.TimeFormat = LL_RTC_ALMA_TIME_FORMAT_AM;
676  RTC_AlarmStruct->AlarmTime.Hours = 0U;
677  RTC_AlarmStruct->AlarmTime.Minutes = 0U;
678  RTC_AlarmStruct->AlarmTime.Seconds = 0U;
679 
680  /* Alarm Day Settings : Day = 1st day of the month */
681  RTC_AlarmStruct->AlarmDateWeekDaySel = LL_RTC_ALMA_DATEWEEKDAYSEL_DATE;
682  RTC_AlarmStruct->AlarmDateWeekDay = 1U;
683 
684  /* Alarm Masks Settings : Mask = all fields are not masked */
685  RTC_AlarmStruct->AlarmMask = LL_RTC_ALMA_MASK_NONE;
686 }
687 
694 void LL_RTC_ALMB_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct)
695 {
696  /* Alarm Time Settings : Time = 00h:00mn:00sec */
697  RTC_AlarmStruct->AlarmTime.TimeFormat = LL_RTC_ALMB_TIME_FORMAT_AM;
698  RTC_AlarmStruct->AlarmTime.Hours = 0U;
699  RTC_AlarmStruct->AlarmTime.Minutes = 0U;
700  RTC_AlarmStruct->AlarmTime.Seconds = 0U;
701 
702  /* Alarm Day Settings : Day = 1st day of the month */
703  RTC_AlarmStruct->AlarmDateWeekDaySel = LL_RTC_ALMB_DATEWEEKDAYSEL_DATE;
704  RTC_AlarmStruct->AlarmDateWeekDay = 1U;
705 
706  /* Alarm Masks Settings : Mask = all fields are not masked */
707  RTC_AlarmStruct->AlarmMask = LL_RTC_ALMB_MASK_NONE;
708 }
709 
719 ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx)
720 {
721  __IO uint32_t timeout = RTC_INITMODE_TIMEOUT;
722  ErrorStatus status = SUCCESS;
723  uint32_t tmp = 0U;
724 
725  /* Check the parameter */
726  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
727 
728  /* Check if the Initialization mode is set */
729  if (LL_RTC_IsActiveFlag_INIT(RTCx) == 0U)
730  {
731  /* Set the Initialization mode */
732  LL_RTC_EnableInitMode(RTCx);
733 
734  /* Wait till RTC is in INIT state and if Time out is reached exit */
735  tmp = LL_RTC_IsActiveFlag_INIT(RTCx);
736  while ((timeout != 0U) && (tmp != 1U))
737  {
738  if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
739  {
740  timeout --;
741  }
742  tmp = LL_RTC_IsActiveFlag_INIT(RTCx);
743  if (timeout == 0U)
744  {
745  status = ERROR;
746  }
747  }
748  }
749  return status;
750 }
751 
763 ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
764 {
765  /* Check the parameter */
766  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
767 
768  /* Disable initialization mode */
769  LL_RTC_DisableInitMode(RTCx);
770 
771  return SUCCESS;
772 }
773 
790 ErrorStatus LL_RTC_WaitForSynchro(RTC_TypeDef *RTCx)
791 {
792  __IO uint32_t timeout = RTC_SYNCHRO_TIMEOUT;
793  ErrorStatus status = SUCCESS;
794  uint32_t tmp = 0U;
795 
796  /* Check the parameter */
797  assert_param(IS_RTC_ALL_INSTANCE(RTCx));
798 
799  /* Clear RSF flag */
800  LL_RTC_ClearFlag_RS(RTCx);
801 
802  /* Wait the registers to be synchronised */
803  tmp = LL_RTC_IsActiveFlag_RS(RTCx);
804  while ((timeout != 0U) && (tmp != 1U))
805  {
806  if (LL_SYSTICK_IsActiveCounterFlag() == 1U)
807  {
808  timeout--;
809  }
810  tmp = LL_RTC_IsActiveFlag_RS(RTCx);
811  if (timeout == 0U)
812  {
813  status = ERROR;
814  }
815  }
816 
817  return (status);
818 }
819 
832 #endif /* defined(RTC) */
833 
838 #endif /* USE_FULL_LL_DRIVER */
LL_SYSTICK_IsActiveCounterFlag
__STATIC_INLINE uint32_t LL_SYSTICK_IsActiveCounterFlag(void)
This function checks if the Systick counter flag is active or not.
Definition: stm32f4xx_ll_cortex.h:229
LL_RTC_ALMA_SetMask
__STATIC_INLINE void LL_RTC_ALMA_SetMask(RTC_TypeDef *RTCx, uint32_t Mask)
Specify the Alarm A masks. @rmtoll ALRMAR MSK4 LL_RTC_ALMA_SetMask ALRMAR MSK3 LL_RTC_ALMA_SetMask ...
Definition: stm32f4xx_ll_rtc.h:1588
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: stm32f4xx_ll_rtc.h:1644
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 ) @rmtoll ALRMAR WDSEL LL_RTC_ALMA_Dis...
Definition: stm32f4xx_ll_rtc.h:1630
LL_RTC_ALMA_SetWeekDay
__STATIC_INLINE void LL_RTC_ALMA_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
Set ALARM A Weekday @rmtoll ALRMAR DU LL_RTC_ALMA_SetWeekDay.
Definition: stm32f4xx_ll_rtc.h:1677
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 @rmtoll ALRMAR PM LL_RTC_ALMA_ConfigTime AL...
Definition: stm32f4xx_ll_rtc.h:1829
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) @rmtoll AL...
Definition: stm32f4xx_ll_rtc.h:1619
LL_RTC_ALMB_SetWeekDay
__STATIC_INLINE void LL_RTC_ALMB_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
Set ALARM B Weekday @rmtoll ALRMBR DU LL_RTC_ALMB_SetWeekDay.
Definition: stm32f4xx_ll_rtc.h:2045
LL_RTC_ALMB_SetMask
__STATIC_INLINE void LL_RTC_ALMB_SetMask(RTC_TypeDef *RTCx, uint32_t Mask)
Specify the Alarm B masks. @rmtoll ALRMBR MSK4 LL_RTC_ALMB_SetMask ALRMBR MSK3 LL_RTC_ALMB_SetMask ...
Definition: stm32f4xx_ll_rtc.h:1956
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 ) @rmtoll ALRMBR WDSEL LL_RTC_ALMB_Dis...
Definition: stm32f4xx_ll_rtc.h:1998
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: stm32f4xx_ll_rtc.h:2012
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) @rmtoll AL...
Definition: stm32f4xx_ll_rtc.h:1987
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 @rmtoll ALRMBR PM LL_RTC_ALMB_ConfigTime AL...
Definition: stm32f4xx_ll_rtc.h:2197
LL_RTC_DisableInitMode
__STATIC_INLINE void LL_RTC_DisableInitMode(RTC_TypeDef *RTCx)
Disable initialization mode (Free running mode) @rmtoll ISR INIT LL_RTC_DisableInitMode.
Definition: stm32f4xx_ll_rtc.h:844
LL_RTC_EnableInitMode
__STATIC_INLINE void LL_RTC_EnableInitMode(RTC_TypeDef *RTCx)
Enable initialization mode.
Definition: stm32f4xx_ll_rtc.h:832
LL_RTC_GetHourFormat
__STATIC_INLINE uint32_t LL_RTC_GetHourFormat(RTC_TypeDef *RTCx)
Get Hours format (24 hour/day or AM/PM hour format) @rmtoll CR FMT LL_RTC_GetHourFormat.
Definition: stm32f4xx_ll_rtc.h:757
LL_RTC_DisableWriteProtection
__STATIC_INLINE void LL_RTC_DisableWriteProtection(RTC_TypeDef *RTCx)
Disable the write protection for RTC registers. @rmtoll WPR KEY LL_RTC_DisableWriteProtection.
Definition: stm32f4xx_ll_rtc.h:1001
LL_RTC_IsShadowRegBypassEnabled
__STATIC_INLINE uint32_t LL_RTC_IsShadowRegBypassEnabled(RTC_TypeDef *RTCx)
Check if Shadow registers bypass is enabled or not. @rmtoll CR BYPSHAD LL_RTC_IsShadowRegBypassEnable...
Definition: stm32f4xx_ll_rtc.h:907
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: stm32f4xx_ll_rtc.h:744
LL_RTC_SetAsynchPrescaler
__STATIC_INLINE void LL_RTC_SetAsynchPrescaler(RTC_TypeDef *RTCx, uint32_t AsynchPrescaler)
Set Asynchronous prescaler factor @rmtoll PRER PREDIV_A LL_RTC_SetAsynchPrescaler.
Definition: stm32f4xx_ll_rtc.h:945
LL_RTC_SetSynchPrescaler
__STATIC_INLINE void LL_RTC_SetSynchPrescaler(RTC_TypeDef *RTCx, uint32_t SynchPrescaler)
Set Synchronous prescaler factor @rmtoll PRER PREDIV_S LL_RTC_SetSynchPrescaler.
Definition: stm32f4xx_ll_rtc.h:957
LL_RTC_EnableWriteProtection
__STATIC_INLINE void LL_RTC_EnableWriteProtection(RTC_TypeDef *RTCx)
Enable the write protection for RTC registers. @rmtoll WPR KEY LL_RTC_EnableWriteProtection.
Definition: stm32f4xx_ll_rtc.h:990
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 @rmtoll DR WDU LL_RTC_DATE_Config DR MT LL_RTC...
Definition: stm32f4xx_ll_rtc.h:1500
LL_RTC_IsActiveFlag_INIT
__STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_INIT(RTC_TypeDef *RTCx)
Get Initialization flag @rmtoll ISR INITF LL_RTC_IsActiveFlag_INIT.
Definition: stm32f4xx_ll_rtc.h:3352
LL_RTC_IsActiveFlag_RS
__STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_RS(RTC_TypeDef *RTCx)
Get Registers synchronization flag @rmtoll ISR RSF LL_RTC_IsActiveFlag_RS.
Definition: stm32f4xx_ll_rtc.h:3363
LL_RTC_ClearFlag_RS
__STATIC_INLINE void LL_RTC_ClearFlag_RS(RTC_TypeDef *RTCx)
Clear Registers synchronization flag @rmtoll ISR RSF LL_RTC_ClearFlag_RS.
Definition: stm32f4xx_ll_rtc.h:3374
LL_RTC_EnterInitMode
ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx)
Enters the RTC Initialization mode.
Definition: stm32f4xx_ll_rtc.c:719
LL_RTC_StructInit
void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct)
Set each LL_RTC_InitTypeDef field to default value.
Definition: stm32f4xx_ll_rtc.c:231
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: stm32f4xx_ll_rtc.c:694
LL_RTC_ExitInitMode
ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx)
Exit the RTC Initialization mode.
Definition: stm32f4xx_ll_rtc.c:763
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: stm32f4xx_ll_rtc.c:672
LL_RTC_DeInit
ErrorStatus LL_RTC_DeInit(RTC_TypeDef *RTCx)
De-Initializes the RTC registers to their default reset values.
Definition: stm32f4xx_ll_rtc.c:135
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: stm32f4xx_ll_rtc.c:421
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: stm32f4xx_ll_rtc.c:251
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: stm32f4xx_ll_rtc.c:354
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: stm32f4xx_ll_rtc.c:790
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: stm32f4xx_ll_rtc.c:333
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: stm32f4xx_ll_rtc.c:444
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: stm32f4xx_ll_rtc.c:192
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: stm32f4xx_ll_rtc.c:562
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: stm32f4xx_ll_rtc.h:1174
LL_RTC_DateTypeDef::Year
uint8_t Year
Definition: stm32f4xx_ll_rtc.h:153
LL_RTC_AlarmTypeDef::AlarmDateWeekDaySel
uint32_t AlarmDateWeekDaySel
Definition: stm32f4xx_ll_rtc.h:173
LL_RTC_DateTypeDef::Month
uint8_t Month
Definition: stm32f4xx_ll_rtc.h:143
LL_RTC_AlarmTypeDef::AlarmDateWeekDay
uint8_t AlarmDateWeekDay
Definition: stm32f4xx_ll_rtc.h:180
LL_RTC_InitTypeDef::SynchPrescaler
uint32_t SynchPrescaler
Definition: stm32f4xx_ll_rtc.h:99
LL_RTC_InitTypeDef::HourFormat
uint32_t HourFormat
Definition: stm32f4xx_ll_rtc.h:87
LL_RTC_DateTypeDef::Day
uint8_t Day
Definition: stm32f4xx_ll_rtc.h:148
LL_RTC_TimeTypeDef::Minutes
uint8_t Minutes
Definition: stm32f4xx_ll_rtc.h:122
LL_RTC_AlarmTypeDef::AlarmMask
uint32_t AlarmMask
Definition: stm32f4xx_ll_rtc.h:166
LL_RTC_TimeTypeDef::Hours
uint8_t Hours
Definition: stm32f4xx_ll_rtc.h:116
LL_RTC_TimeTypeDef::Seconds
uint8_t Seconds
Definition: stm32f4xx_ll_rtc.h:127
LL_RTC_TimeTypeDef::TimeFormat
uint32_t TimeFormat
Definition: stm32f4xx_ll_rtc.h:111
LL_RTC_DateTypeDef::WeekDay
uint8_t WeekDay
Definition: stm32f4xx_ll_rtc.h:138
LL_RTC_InitTypeDef::AsynchPrescaler
uint32_t AsynchPrescaler
Definition: stm32f4xx_ll_rtc.h:93
LL_RTC_AlarmTypeDef::AlarmTime
LL_RTC_TimeTypeDef AlarmTime
Definition: stm32f4xx_ll_rtc.h:164
LL_RTC_AlarmTypeDef
RTC Alarm structure definition.
Definition: stm32f4xx_ll_rtc.h:163
LL_RTC_DateTypeDef
RTC Date structure definition.
Definition: stm32f4xx_ll_rtc.h:137
LL_RTC_InitTypeDef
RTC Init structures definition.
Definition: stm32f4xx_ll_rtc.h:86
LL_RTC_TimeTypeDef
RTC Time structure definition.
Definition: stm32f4xx_ll_rtc.h:110
stm32f4xx_ll_cortex.h
Header file of CORTEX LL module.
stm32f4xx_ll_rtc.h
Header file of RTC LL module.