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