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