?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
Merge pull request #11189 from klutvott123/move-telemetry-displayport-init
[betaflight.git] / lib / main / STM32G4 / Drivers / STM32G4xx_HAL_Driver / Inc / stm32g4xx_ll_rtc.h
blob2a0e72814b4b5d9d8cf5b57380c8079770062473
1 /**
2 ******************************************************************************
3 * @file stm32g4xx_ll_rtc.h
4 * @author MCD Application Team
5 * @brief Header file of RTC LL module.
6 ******************************************************************************
7 * @attention
8 *
9 * <h2><center>&copy; COPYRIGHT(c) 2017 STMicroelectronics</center></h2>
10 *
11 * This software component is licensed by ST under BSD 3-Clause license,
12 * the "License"; You may not use this file except in compliance with the
13 * License. You may obtain a copy of the License at:
14 * opensource.org/licenses/BSD-3-Clause
15 *
16 ******************************************************************************
17 */
18
19 /* Define to prevent recursive inclusion -------------------------------------*/
20 #ifndef STM32G4xx_LL_RTC_H
21 #define STM32G4xx_LL_RTC_H
22
23 #ifdef __cplusplus
24 extern "C" {
25 #endif
26
27 /* Includes ------------------------------------------------------------------*/
28 #include "stm32g4xx.h"
29
30 /** @addtogroup STM32G4xx_LL_Driver
31 * @{
32 */
33
34 #if defined(RTC)
35
36 /** @defgroup RTC_LL RTC
37 * @{
38 */
39
40 /* Private types -------------------------------------------------------------*/
41 /* Private variables ---------------------------------------------------------*/
42 /* Private constants ---------------------------------------------------------*/
43 /** @defgroup RTC_LL_Private_Constants RTC Private Constants
44 * @{
45 */
46 /* Masks Definition */
47 #define RTC_LL_INIT_MASK 0xFFFFFFFFU
48 #define RTC_LL_RSF_MASK 0xFFFFFF5FU
49
50 /* Write protection defines */
51 #define RTC_WRITE_PROTECTION_DISABLE (uint8_t)0xFF
52 #define RTC_WRITE_PROTECTION_ENABLE_1 (uint8_t)0xCA
53 #define RTC_WRITE_PROTECTION_ENABLE_2 (uint8_t)0x53
54
55 /* Defines used to combine date & time */
56 #define RTC_OFFSET_WEEKDAY 24U
57 #define RTC_OFFSET_DAY 16U
58 #define RTC_OFFSET_MONTH 8U
59 #define RTC_OFFSET_HOUR 16U
60 #define RTC_OFFSET_MINUTE 8U
61
62 /**
63 * @}
64 */
65
66 /* Private macros ------------------------------------------------------------*/
67 #if defined(USE_FULL_LL_DRIVER)
68 /** @defgroup RTC_LL_Private_Macros RTC Private Macros
69 * @{
70 */
71 /**
72 * @}
73 */
74 #endif /*USE_FULL_LL_DRIVER*/
75
76 #if !defined (UNUSED)
77 #define UNUSED(x) ((void)(x))
78 #endif
79
80 /* Exported types ------------------------------------------------------------*/
81 #if defined(USE_FULL_LL_DRIVER)
82 /** @defgroup RTC_LL_ES_INIT RTC Exported Init structure
83 * @{
84 */
85
86 /**
87 * @brief RTC Init structures definition
88 */
89 typedef struct
90 {
91 uint32_t HourFormat; /*!< Specifies the RTC Hours Format.
92 This parameter can be a value of @ref RTC_LL_EC_HOURFORMAT
93
94 This feature can be modified afterwards using unitary function
95 @ref LL_RTC_SetHourFormat(). */
96
97 uint32_t AsynchPrescaler; /*!< Specifies the RTC Asynchronous Predivider value.
98 This parameter must be a number between Min_Data = 0x00 and Max_Data = 0x7F
99
100 This feature can be modified afterwards using unitary function
101 @ref LL_RTC_SetAsynchPrescaler(). */
102
103 uint32_t SynchPrescaler; /*!< Specifies the RTC Synchronous Predivider value.
104 This parameter must be a number between Min_Data = 0x00 and Max_Data = 0x7FFF
105
106 This feature can be modified afterwards using unitary function
107 @ref LL_RTC_SetSynchPrescaler(). */
108 } LL_RTC_InitTypeDef;
109
110 /**
111 * @brief RTC Time structure definition
112 */
113 typedef struct
114 {
115 uint32_t TimeFormat; /*!< Specifies the RTC AM/PM Time.
116 This parameter can be a value of @ref RTC_LL_EC_TIME_FORMAT
117
118 This feature can be modified afterwards using unitary function @ref LL_RTC_TIME_SetFormat(). */
119
120 uint8_t Hours; /*!< Specifies the RTC Time Hours.
121 This parameter must be a number between Min_Data = 0 and Max_Data = 12 if the @ref LL_RTC_TIME_FORMAT_PM is selected.
122 This parameter must be a number between Min_Data = 0 and Max_Data = 23 if the @ref LL_RTC_TIME_FORMAT_AM_OR_24 is selected.
123
124 This feature can be modified afterwards using unitary function @ref LL_RTC_TIME_SetHour(). */
125
126 uint8_t Minutes; /*!< Specifies the RTC Time Minutes.
127 This parameter must be a number between Min_Data = 0 and Max_Data = 59
128
129 This feature can be modified afterwards using unitary function @ref LL_RTC_TIME_SetMinute(). */
130
131 uint8_t Seconds; /*!< Specifies the RTC Time Seconds.
132 This parameter must be a number between Min_Data = 0 and Max_Data = 59
133
134 This feature can be modified afterwards using unitary function @ref LL_RTC_TIME_SetSecond(). */
135 } LL_RTC_TimeTypeDef;
136
137 /**
138 * @brief RTC Date structure definition
139 */
140 typedef struct
141 {
142 uint8_t WeekDay; /*!< Specifies the RTC Date WeekDay.
143 This parameter can be a value of @ref RTC_LL_EC_WEEKDAY
144
145 This feature can be modified afterwards using unitary function @ref LL_RTC_DATE_SetWeekDay(). */
146
147 uint8_t Month; /*!< Specifies the RTC Date Month.
148 This parameter can be a value of @ref RTC_LL_EC_MONTH
149
150 This feature can be modified afterwards using unitary function @ref LL_RTC_DATE_SetMonth(). */
151
152 uint8_t Day; /*!< Specifies the RTC Date Day.
153 This parameter must be a number between Min_Data = 1 and Max_Data = 31
154
155 This feature can be modified afterwards using unitary function @ref LL_RTC_DATE_SetDay(). */
156
157 uint8_t Year; /*!< Specifies the RTC Date Year.
158 This parameter must be a number between Min_Data = 0 and Max_Data = 99
159
160 This feature can be modified afterwards using unitary function @ref LL_RTC_DATE_SetYear(). */
161 } LL_RTC_DateTypeDef;
162
163 /**
164 * @brief RTC Alarm structure definition
165 */
166 typedef struct
167 {
168 LL_RTC_TimeTypeDef AlarmTime; /*!< Specifies the RTC Alarm Time members. */
169
170 uint32_t AlarmMask; /*!< Specifies the RTC Alarm Masks.
171 This parameter can be a value of @ref RTC_LL_EC_ALMA_MASK for ALARM A or @ref RTC_LL_EC_ALMB_MASK for ALARM B.
172
173 This feature can be modified afterwards using unitary function @ref LL_RTC_ALMA_SetMask() for ALARM A
174 or @ref LL_RTC_ALMB_SetMask() for ALARM B
175 */
176
177 uint32_t AlarmDateWeekDaySel; /*!< Specifies the RTC Alarm is on day or WeekDay.
178 This parameter can be a value of @ref RTC_LL_EC_ALMA_WEEKDAY_SELECTION for ALARM A or @ref RTC_LL_EC_ALMB_WEEKDAY_SELECTION for ALARM B
179
180 This feature can be modified afterwards using unitary function @ref LL_RTC_ALMA_EnableWeekday() or @ref LL_RTC_ALMA_DisableWeekday()
181 for ALARM A or @ref LL_RTC_ALMB_EnableWeekday() or @ref LL_RTC_ALMB_DisableWeekday() for ALARM B
182 */
183
184 uint8_t AlarmDateWeekDay; /*!< Specifies the RTC Alarm Day/WeekDay.
185 If AlarmDateWeekDaySel set to day, this parameter must be a number between Min_Data = 1 and Max_Data = 31.
186
187 This feature can be modified afterwards using unitary function @ref LL_RTC_ALMA_SetDay()
188 for ALARM A or @ref LL_RTC_ALMB_SetDay() for ALARM B.
189
190 If AlarmDateWeekDaySel set to Weekday, this parameter can be a value of @ref RTC_LL_EC_WEEKDAY.
191
192 This feature can be modified afterwards using unitary function @ref LL_RTC_ALMA_SetWeekDay()
193 for ALARM A or @ref LL_RTC_ALMB_SetWeekDay() for ALARM B.
194 */
195 } LL_RTC_AlarmTypeDef;
196
197 /**
198 * @}
199 */
200 #endif /* USE_FULL_LL_DRIVER */
201
202 /* Exported constants --------------------------------------------------------*/
203 /** @defgroup RTC_LL_Exported_Constants RTC Exported Constants
204 * @{
205 */
206
207 #if defined(USE_FULL_LL_DRIVER)
208 /** @defgroup RTC_LL_EC_FORMAT FORMAT
209 * @{
210 */
211 #define LL_RTC_FORMAT_BIN 0x00000000U /*!< Binary data format */
212 #define LL_RTC_FORMAT_BCD 0x00000001U /*!< BCD data format */
213 /**
214 * @}
215 */
216
217 /** @defgroup RTC_LL_EC_ALMA_WEEKDAY_SELECTION RTC Alarm A Date WeekDay
218 * @{
219 */
220 #define LL_RTC_ALMA_DATEWEEKDAYSEL_DATE 0x00000000U /*!< Alarm A Date is selected */
221 #define LL_RTC_ALMA_DATEWEEKDAYSEL_WEEKDAY RTC_ALRMAR_WDSEL /*!< Alarm A WeekDay is selected */
222 /**
223 * @}
224 */
225
226 /** @defgroup RTC_LL_EC_ALMB_WEEKDAY_SELECTION RTC Alarm B Date WeekDay
227 * @{
228 */
229 #define LL_RTC_ALMB_DATEWEEKDAYSEL_DATE 0x00000000U /*!< Alarm B Date is selected */
230 #define LL_RTC_ALMB_DATEWEEKDAYSEL_WEEKDAY RTC_ALRMBR_WDSEL /*!< Alarm B WeekDay is selected */
231 /**
232 * @}
233 */
234
235 #endif /* USE_FULL_LL_DRIVER */
236
237 /** @defgroup RTC_LL_EC_GET_FLAG Get Flags Defines
238 * @brief Flags defines which can be used with LL_RTC_ReadReg function
239 * @{
240 */
241 #define LL_RTC_SCR_ITSF RTC_SCR_CITSF
242 #define LL_RTC_SCR_TSOVF RTC_SCR_CTSOVF
243 #define LL_RTC_SCR_TSF RTC_SCR_CTSF
244 #define LL_RTC_SCR_WUTF RTC_SCR_CWUTF
245 #define LL_RTC_SCR_ALRBF RTC_SCR_CALRBF
246 #define LL_RTC_CSR_ALRAF RTC_SCR_CALRAF
247
248 #define LL_RTC_ICSR_RECALPF RTC_ICSR_RECALPF
249 #define LL_RTC_ICSR_INITF RTC_ICSR_INITF
250 #define LL_RTC_ICSR_RSF RTC_ICSR_RSF
251 #define LL_RTC_ICSR_INITS RTC_ICSR_INITS
252 #define LL_RTC_ICSR_SHPF RTC_ICSR_SHPF
253 #define LL_RTC_ICSR_WUTWF RTC_ICSR_WUTWF
254 #define LL_RTC_ICSR_ALRBWF RTC_ICSR_ALRBWF
255 #define LL_RTC_ICSR_ALRAWF RTC_ICSR_ALRAWF
256 /**
257 * @}
258 */
259
260 /** @defgroup RTC_LL_EC_IT IT Defines
261 * @brief IT defines which can be used with LL_RTC_ReadReg and LL_RTC_WriteReg functions
262 * @{
263 */
264 #define LL_RTC_CR_TSIE RTC_CR_TSIE
265 #define LL_RTC_CR_WUTIE RTC_CR_WUTIE
266 #define LL_RTC_CR_ALRBIE RTC_CR_ALRBIE
267 #define LL_RTC_CR_ALRAIE RTC_CR_ALRAIE
268 /**
269 * @}
270 */
271
272 /** @defgroup RTC_LL_EC_WEEKDAY WEEK DAY
273 * @{
274 */
275 #define LL_RTC_WEEKDAY_MONDAY (uint8_t)0x01 /*!< Monday */
276 #define LL_RTC_WEEKDAY_TUESDAY (uint8_t)0x02 /*!< Tuesday */
277 #define LL_RTC_WEEKDAY_WEDNESDAY (uint8_t)0x03 /*!< Wednesday */
278 #define LL_RTC_WEEKDAY_THURSDAY (uint8_t)0x04 /*!< Thrusday */
279 #define LL_RTC_WEEKDAY_FRIDAY (uint8_t)0x05 /*!< Friday */
280 #define LL_RTC_WEEKDAY_SATURDAY (uint8_t)0x06 /*!< Saturday */
281 #define LL_RTC_WEEKDAY_SUNDAY (uint8_t)0x07 /*!< Sunday */
282 /**
283 * @}
284 */
285
286 /** @defgroup RTC_LL_EC_MONTH MONTH
287 * @{
288 */
289 #define LL_RTC_MONTH_JANUARY (uint8_t)0x01 /*!< January */
290 #define LL_RTC_MONTH_FEBRUARY (uint8_t)0x02 /*!< February */
291 #define LL_RTC_MONTH_MARCH (uint8_t)0x03 /*!< March */
292 #define LL_RTC_MONTH_APRIL (uint8_t)0x04 /*!< April */
293 #define LL_RTC_MONTH_MAY (uint8_t)0x05 /*!< May */
294 #define LL_RTC_MONTH_JUNE (uint8_t)0x06 /*!< June */
295 #define LL_RTC_MONTH_JULY (uint8_t)0x07 /*!< July */
296 #define LL_RTC_MONTH_AUGUST (uint8_t)0x08 /*!< August */
297 #define LL_RTC_MONTH_SEPTEMBER (uint8_t)0x09 /*!< September */
298 #define LL_RTC_MONTH_OCTOBER (uint8_t)0x10 /*!< October */
299 #define LL_RTC_MONTH_NOVEMBER (uint8_t)0x11 /*!< November */
300 #define LL_RTC_MONTH_DECEMBER (uint8_t)0x12 /*!< December */
301 /**
302 * @}
303 */
304
305 /** @defgroup RTC_LL_EC_HOURFORMAT HOUR FORMAT
306 * @{
307 */
308 #define LL_RTC_HOURFORMAT_24HOUR 0x00000000U /*!< 24 hour/day format */
309 #define LL_RTC_HOURFORMAT_AMPM RTC_CR_FMT /*!< AM/PM hour format */
310 /**
311 * @}
312 */
313
314 /** @defgroup RTC_LL_EC_ALARMOUT ALARM OUTPUT
315 * @{
316 */
317 #define LL_RTC_ALARMOUT_DISABLE 0x00000000U /*!< Output disabled */
318 #define LL_RTC_ALARMOUT_ALMA RTC_CR_OSEL_0 /*!< Alarm A output enabled */
319 #define LL_RTC_ALARMOUT_ALMB RTC_CR_OSEL_1 /*!< Alarm B output enabled */
320 #define LL_RTC_ALARMOUT_WAKEUP RTC_CR_OSEL /*!< Wakeup output enabled */
321 /**
322 * @}
323 */
324
325 /** @defgroup RTC_LL_EC_ALARM_OUTPUTTYPE ALARM OUTPUT TYPE
326 * @{
327 */
328 #define LL_RTC_ALARM_OUTPUTTYPE_OPENDRAIN 0x00000000U /*!< RTC_ALARM is open-drain output */
329 #define LL_RTC_ALARM_OUTPUTTYPE_PUSHPULL RTC_CR_TAMPALRM_TYPE /*!< RTC_ALARM is push-pull output */
330 /**
331 * @}
332 */
333
334 /** @defgroup RTC_LL_EC_OUTPUTPOLARITY_PIN OUTPUT POLARITY PIN
335 * @{
336 */
337 #define LL_RTC_OUTPUTPOLARITY_PIN_HIGH 0x00000000U /*!< Pin is high when ALRAF/ALRBF/WUTF is asserted (depending on OSEL)*/
338 #define LL_RTC_OUTPUTPOLARITY_PIN_LOW RTC_CR_POL /*!< Pin is low when ALRAF/ALRBF/WUTF is asserted (depending on OSEL) */
339 /**
340 * @}
341 */
342
343 /** @defgroup RTC_LL_EC_TIME_FORMAT TIME FORMAT
344 * @{
345 */
346 #define LL_RTC_TIME_FORMAT_AM_OR_24 0x00000000U /*!< AM or 24-hour format */
347 #define LL_RTC_TIME_FORMAT_PM RTC_TR_PM /*!< PM */
348 /**
349 * @}
350 */
351
352 /** @defgroup RTC_LL_EC_SHIFT_SECOND SHIFT SECOND
353 * @{
354 */
355 #define LL_RTC_SHIFT_SECOND_DELAY 0x00000000U /* Delay (seconds) = SUBFS / (PREDIV_S + 1) */
356 #define LL_RTC_SHIFT_SECOND_ADVANCE RTC_SHIFTR_ADD1S /* Advance (seconds) = (1 - (SUBFS / (PREDIV_S + 1))) */
357 /**
358 * @}
359 */
360
361 /** @defgroup RTC_LL_EC_ALMA_MASK ALARMA MASK
362 * @{
363 */
364 #define LL_RTC_ALMA_MASK_NONE 0x00000000U /*!< No masks applied on Alarm A*/
365 #define LL_RTC_ALMA_MASK_DATEWEEKDAY RTC_ALRMAR_MSK4 /*!< Date/day do not care in Alarm A comparison */
366 #define LL_RTC_ALMA_MASK_HOURS RTC_ALRMAR_MSK3 /*!< Hours do not care in Alarm A comparison */
367 #define LL_RTC_ALMA_MASK_MINUTES RTC_ALRMAR_MSK2 /*!< Minutes do not care in Alarm A comparison */
368 #define LL_RTC_ALMA_MASK_SECONDS RTC_ALRMAR_MSK1 /*!< Seconds do not care in Alarm A comparison */
369 #define LL_RTC_ALMA_MASK_ALL (RTC_ALRMAR_MSK4 | RTC_ALRMAR_MSK3 | RTC_ALRMAR_MSK2 | RTC_ALRMAR_MSK1) /*!< Masks all */
370 /**
371 * @}
372 */
373
374 /** @defgroup RTC_LL_EC_ALMA_TIME_FORMAT ALARMA TIME FORMAT
375 * @{
376 */
377 #define LL_RTC_ALMA_TIME_FORMAT_AM 0x00000000U /*!< AM or 24-hour format */
378 #define LL_RTC_ALMA_TIME_FORMAT_PM RTC_ALRMAR_PM /*!< PM */
379 /**
380 * @}
381 */
382
383 /** @defgroup RTC_LL_EC_ALMB_MASK ALARMB MASK
384 * @{
385 */
386 #define LL_RTC_ALMB_MASK_NONE 0x00000000U /*!< No masks applied on Alarm B*/
387 #define LL_RTC_ALMB_MASK_DATEWEEKDAY RTC_ALRMBR_MSK4 /*!< Date/day do not care in Alarm B comparison */
388 #define LL_RTC_ALMB_MASK_HOURS RTC_ALRMBR_MSK3 /*!< Hours do not care in Alarm B comparison */
389 #define LL_RTC_ALMB_MASK_MINUTES RTC_ALRMBR_MSK2 /*!< Minutes do not care in Alarm B comparison */
390 #define LL_RTC_ALMB_MASK_SECONDS RTC_ALRMBR_MSK1 /*!< Seconds do not care in Alarm B comparison */
391 #define LL_RTC_ALMB_MASK_ALL (RTC_ALRMBR_MSK4 | RTC_ALRMBR_MSK3 | RTC_ALRMBR_MSK2 | RTC_ALRMBR_MSK1) /*!< Masks all */
392 /**
393 * @}
394 */
395
396 /** @defgroup RTC_LL_EC_ALMB_TIME_FORMAT ALARMB TIME FORMAT
397 * @{
398 */
399 #define LL_RTC_ALMB_TIME_FORMAT_AM 0x00000000U /*!< AM or 24-hour format */
400 #define LL_RTC_ALMB_TIME_FORMAT_PM RTC_ALRMBR_PM /*!< PM */
401 /**
402 * @}
403 */
404
405 /** @defgroup RTC_LL_EC_TIMESTAMP_EDGE TIMESTAMP EDGE
406 * @{
407 */
408 #define LL_RTC_TIMESTAMP_EDGE_RISING 0x00000000U /*!< RTC_TS input rising edge generates a time-stamp event */
409 #define LL_RTC_TIMESTAMP_EDGE_FALLING RTC_CR_TSEDGE /*!< RTC_TS input falling edge generates a time-stamp even */
410 /**
411 * @}
412 */
413
414 /** @defgroup RTC_LL_EC_TS_TIME_FORMAT TIMESTAMP TIME FORMAT
415 * @{
416 */
417 #define LL_RTC_TS_TIME_FORMAT_AM 0x00000000U /*!< AM or 24-hour format */
418 #define LL_RTC_TS_TIME_FORMAT_PM RTC_TSTR_PM /*!< PM */
419 /**
420 * @}
421 */
422
423 /** @defgroup RTC_LL_EC_TAMPER TAMPER
424 * @{
425 */
426 #define LL_RTC_TAMPER_1 TAMP_CR1_TAMP1E /*!< Tamper 1 input detection */
427 #define LL_RTC_TAMPER_2 TAMP_CR1_TAMP2E /*!< Tamper 2 input detection */
428 #if (RTC_TAMP_NB == 3)
429 #define LL_RTC_TAMPER_3 TAMP_CR1_TAMP3E /*!< Tamper 3 input detection */
430 #elif (RTC_TAMP_NB == 8)
431 #define LL_RTC_TAMPER_3 TAMP_CR1_TAMP3E /*!< Tamper 3 input detection */
432 #define LL_RTC_TAMPER_3 TAMP_CR1_TAMP3E /*!< Tamper 3 input detection */
433 #define LL_RTC_TAMPER_4 TAMP_CR1_TAMP4E /*!< Tamper 4 input detection */
434 #define LL_RTC_TAMPER_5 TAMP_CR1_TAMP5E /*!< Tamper 5 input detection */
435 #define LL_RTC_TAMPER_6 TAMP_CR1_TAMP6E /*!< Tamper 6 input detection */
436 #define LL_RTC_TAMPER_7 TAMP_CR1_TAMP7E /*!< Tamper 7 input detection */
437 #define LL_RTC_TAMPER_8 TAMP_CR1_TAMP8E /*!< Tamper 8 input detection */
438 #else
439 #warning "RTC_TAMP_NB is not correct"
440 #endif /* (RTC_TAMP_NB) */
441 /**
442 * @}
443 */
444
445 /** @defgroup RTC_LL_EC_TAMPER_MASK TAMPER MASK
446 * @{
447 */
448 #define LL_RTC_TAMPER_MASK_TAMPER1 TAMP_CR2_TAMP1MF /*!< Tamper 1 event generates a trigger event. TAMP1F is masked and internally cleared by hardware.The backup registers are not erased */
449 #define LL_RTC_TAMPER_MASK_TAMPER2 TAMP_CR2_TAMP2MF /*!< Tamper 2 event generates a trigger event. TAMP2F is masked and internally cleared by hardware. The backup registers are not erased. */
450 #if (RTC_TAMP_NB == 3)
451 #define LL_RTC_TAMPER_MASK_TAMPER3 TAMP_CR2_TAMP3MF /*!< Tamper 3 event generates a trigger event. TAMP2F is masked and internally cleared by hardware. The backup registers are not erased. */
452 #elif (RTC_TAMP_NB == 8)
453 #define LL_RTC_TAMPER_MASK_TAMPER3 TAMP_CR2_TAMP3MF /*!< Tamper 3 event generates a trigger event. TAMP2F is masked and internally cleared by hardware. The backup registers are not erased. */
454 #define LL_RTC_TAMPER_MASK_TAMPER4 TAMP_CR2_TAMP4MF /*!< Tamper 4 event generates a trigger event. TAMP1F is masked and internally cleared by hardware.The backup registers are not erased */
455 #define LL_RTC_TAMPER_MASK_TAMPER5 TAMP_CR2_TAMP5MF /*!< Tamper 5 event generates a trigger event. TAMP2F is masked and internally cleared by hardware. The backup registers are not erased. */
456 #define LL_RTC_TAMPER_MASK_TAMPER6 TAMP_CR2_TAMP6MF /*!< Tamper 6 event generates a trigger event. TAMP1F is masked and internally cleared by hardware.The backup registers are not erased */
457 #define LL_RTC_TAMPER_MASK_TAMPER7 TAMP_CR2_TAMP7MF /*!< Tamper 7 event generates a trigger event. TAMP2F is masked and internally cleared by hardware. The backup registers are not erased. */
458 #define LL_RTC_TAMPER_MASK_TAMPER8 TAMP_CR2_TAMP8MF /*!< Tamper 8 event generates a trigger event. TAMP2F is masked and internally cleared by hardware. The backup registers are not erased. */
459 #else
460 #warning "RTC_TAMP_NB is not correct"
461 #endif /* (RTC_TAMP_NB) */
462 /**
463 * @}
464 */
465
466 /** @defgroup RTC_LL_EC_TAMPER_NOERASE TAMPER NO ERASE
467 * @{
468 */
469 #define LL_RTC_TAMPER_NOERASE_TAMPER1 TAMP_CR2_TAMP1NOERASE /*!< Tamper 1 event does not erase the backup registers. */
470 #define LL_RTC_TAMPER_NOERASE_TAMPER2 TAMP_CR2_TAMP2NOERASE /*!< Tamper 2 event does not erase the backup registers. */
471 #if (RTC_TAMP_NB == 3)
472 #define LL_RTC_TAMPER_NOERASE_TAMPER3 TAMP_CR2_TAMP3NOERASE /*!< Tamper 3 event does not erase the backup registers. */
473 #elif (RTC_TAMP_NB == 8)
474 #define LL_RTC_TAMPER_NOERASE_TAMPER3 TAMP_CR2_TAMP3NOERASE /*!< Tamper 3 event does not erase the backup registers. */
475 #define LL_RTC_TAMPER_NOERASE_TAMPER4 TAMP_CR2_TAMP4NOERASE /*!< Tamper 4 event does not erase the backup registers. */
476 #define LL_RTC_TAMPER_NOERASE_TAMPER5 TAMP_CR2_TAMP5NOERASE /*!< Tamper 5 event does not erase the backup registers. */
477 #define LL_RTC_TAMPER_NOERASE_TAMPER6 TAMP_CR2_TAMP6NOERASE /*!< Tamper 6 event does not erase the backup registers. */
478 #define LL_RTC_TAMPER_NOERASE_TAMPER7 TAMP_CR2_TAMP7NOERASE /*!< Tamper 7 event does not erase the backup registers. */
479 #define LL_RTC_TAMPER_NOERASE_TAMPER8 TAMP_CR2_TAMP8NOERASE /*!< Tamper 8 event does not erase the backup registers. */
480 #else
481 #warning "RTC_TAMP_NB is not correct"
482 #endif /* (RTC_TAMP_NB) */
483 /**
484 * @}
485 */
486
487 /** @defgroup RTC_LL_EC_TAMPER_DURATION TAMPER DURATION
488 * @{
489 */
490 #define LL_RTC_TAMPER_DURATION_1RTCCLK 0x00000000U /*!< Tamper pins are pre-charged before sampling during 1 RTCCLK cycle */
491 #define LL_RTC_TAMPER_DURATION_2RTCCLK TAMP_FLTCR_TAMPPRCH_0 /*!< Tamper pins are pre-charged before sampling during 2 RTCCLK cycles */
492 #define LL_RTC_TAMPER_DURATION_4RTCCLK TAMP_FLTCR_TAMPPRCH_1 /*!< Tamper pins are pre-charged before sampling during 4 RTCCLK cycles */
493 #define LL_RTC_TAMPER_DURATION_8RTCCLK TAMP_FLTCR_TAMPPRCH /*!< Tamper pins are pre-charged before sampling during 8 RTCCLK cycles */
494 /**
495 * @}
496 */
497
498 /** @defgroup RTC_LL_EC_TAMPER_FILTER TAMPER FILTER
499 * @{
500 */
501 #define LL_RTC_TAMPER_FILTER_DISABLE 0x00000000U /*!< Tamper filter is disabled */
502 #define LL_RTC_TAMPER_FILTER_2SAMPLE TAMP_FLTCR_TAMPFLT_0 /*!< Tamper is activated after 2 consecutive samples at the active level */
503 #define LL_RTC_TAMPER_FILTER_4SAMPLE TAMP_FLTCR_TAMPFLT_1 /*!< Tamper is activated after 4 consecutive samples at the active level */
504 #define LL_RTC_TAMPER_FILTER_8SAMPLE TAMP_FLTCR_TAMPFLT /*!< Tamper is activated after 8 consecutive samples at the active level. */
505 /**
506 * @}
507 */
508
509 /** @defgroup RTC_LL_EC_TAMPER_SAMPLFREQDIV TAMPER SAMPLING FREQUENCY DIVIDER
510 * @{
511 */
512 #define LL_RTC_TAMPER_SAMPLFREQDIV_32768 0x00000000U /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 32768 */
513 #define LL_RTC_TAMPER_SAMPLFREQDIV_16384 TAMP_FLTCR_TAMPFREQ_0 /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 16384 */
514 #define LL_RTC_TAMPER_SAMPLFREQDIV_8192 TAMP_FLTCR_TAMPFREQ_1 /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 8192 */
515 #define LL_RTC_TAMPER_SAMPLFREQDIV_4096 (TAMP_FLTCR_TAMPFREQ_1 | TAMP_FLTCR_TAMPFREQ_0) /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 4096 */
516 #define LL_RTC_TAMPER_SAMPLFREQDIV_2048 TAMP_FLTCR_TAMPFREQ_2 /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 2048 */
517 #define LL_RTC_TAMPER_SAMPLFREQDIV_1024 (TAMP_FLTCR_TAMPFREQ_2 | TAMP_FLTCR_TAMPFREQ_0) /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 1024 */
518 #define LL_RTC_TAMPER_SAMPLFREQDIV_512 (TAMP_FLTCR_TAMPFREQ_2 | TAMP_FLTCR_TAMPFREQ_1) /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 512 */
519 #define LL_RTC_TAMPER_SAMPLFREQDIV_256 TAMP_FLTCR_TAMPFREQ /*!< Each of the tamper inputs are sampled with a frequency = RTCCLK / 256 */
520 /**
521 * @}
522 */
523
524 /** @defgroup RTC_LL_EC_TAMPER_ACTIVELEVEL TAMPER ACTIVE LEVEL
525 * @{
526 */
527 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP1 TAMP_CR2_TAMP1TRG /*!< Tamper 1 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
528 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP2 TAMP_CR2_TAMP2TRG /*!< Tamper 2 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
529 #if (RTC_TAMP_NB == 3)
530 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP3 TAMP_CR2_TAMP3TRG /*!< Tamper 3 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
531 #elif (RTC_TAMP_NB == 8)
532 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP3 TAMP_CR2_TAMP3TRG /*!< Tamper 3 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
533 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP4 TAMP_CR2_TAMP4TRG /*!< Tamper 4 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
534 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP5 TAMP_CR2_TAMP5TRG /*!< Tamper 5 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
535 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP6 TAMP_CR2_TAMP6TRG /*!< Tamper 6 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
536 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP7 TAMP_CR2_TAMP7TRG /*!< Tamper 7 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
537 #define LL_RTC_TAMPER_ACTIVELEVEL_TAMP8 TAMP_CR2_TAMP8TRG /*!< Tamper 8 input falling edge (if TAMPFLT = 00) or staying high (if TAMPFLT != 00) triggers a tamper detection event */
538 #endif /* (RTC_TAMP_NB) */
539 /**
540 * @}
541 */
542
543
544 /** @defgroup RTC_LL_EC_INTERNAL INTERNAL TAMPER
545 * @{
546 */
547 #define LL_RTC_TAMPER_ITAMP1 TAMP_CR1_ITAMP1E /*!< Internal tamper 1: RTC supply voltage monitoring */
548 #if defined (RTC_TAMP_INT_2_SUPPORT)
549 #define LL_RTC_TAMPER_ITAMP2 TAMP_CR1_ITAMP2E /*!< Internal tamper 2: temperature monitoring */
550 #endif /* RTC_TAMP_INT_2_SUPPORT */
551 #define LL_RTC_TAMPER_ITAMP3 TAMP_CR1_ITAMP3E /*!< Internal tamper 3: LSE monitoring */
552 #define LL_RTC_TAMPER_ITAMP4 TAMP_CR1_ITAMP4E /*!< Internal tamper 4: HSE monitoring */
553 #define LL_RTC_TAMPER_ITAMP5 TAMP_CR1_ITAMP5E /*!< Internal tamper 5: RTC calendar overflow */
554 #if defined (RTC_TAMP_INT_6_SUPPORT)
555 #define LL_RTC_TAMPER_ITAMP6 TAMP_CR1_ITAMP6E /*!< Internal tamper 6: Test mode entry */
556 #endif /* RTC_TAMP_INT_6_SUPPORT */
557 #if defined (RTC_TAMP_INT_7_SUPPORT)
558 #define LL_RTC_TAMPER_ITAMP7 TAMP_CR1_ITAMP7E /*!< Internal tamper 7: Readout protection level decrease */
559 #endif /* RTC_TAMP_INT_7_SUPPORT */
560 #if defined (RTC_TAMP_INT_8_SUPPORT)
561 #define LL_RTC_TAMPER_ITAMP8 TAMP_CR1_ITAMP8E /*!< Internal tamper 8: Monotonic counter overflow */
562 #endif /* RTC_TAMP_INT_8_SUPPORT */
563
564 /**
565 * @}
566 */
567
568 /** @defgroup RTC_LL_EC_BKP BACKUP
569 * @{
570 */
571 #define LL_RTC_BKP_NUMBER RTC_BACKUP_NB
572 #if (LL_RTC_BKP_NUMBER == 5)
573 #define LL_RTC_BKP_DR0 0x00U
574 #define LL_RTC_BKP_DR1 0x01U
575 #define LL_RTC_BKP_DR2 0x02U
576 #define LL_RTC_BKP_DR3 0x03U
577 #define LL_RTC_BKP_DR4 0x04U
578 #elif (LL_RTC_BKP_NUMBER == 16)
579 #define LL_RTC_BKP_DR0 0x00U
580 #define LL_RTC_BKP_DR1 0x01U
581 #define LL_RTC_BKP_DR2 0x02U
582 #define LL_RTC_BKP_DR3 0x03U
583 #define LL_RTC_BKP_DR4 0x04U
584 #define LL_RTC_BKP_DR5 0x05U
585 #define LL_RTC_BKP_DR6 0x06U
586 #define LL_RTC_BKP_DR7 0x07U
587 #define LL_RTC_BKP_DR8 0x08U
588 #define LL_RTC_BKP_DR9 0x09U
589 #define LL_RTC_BKP_DR10 0x0AU
590 #define LL_RTC_BKP_DR11 0x0BU
591 #define LL_RTC_BKP_DR12 0x0CU
592 #define LL_RTC_BKP_DR13 0x0DU
593 #define LL_RTC_BKP_DR14 0x0EU
594 #define LL_RTC_BKP_DR15 0x0FU
595 #elif (LL_RTC_BKP_NUMBER == 32)
596 #define LL_RTC_BKP_DR0 0x00U
597 #define LL_RTC_BKP_DR1 0x01U
598 #define LL_RTC_BKP_DR2 0x02U
599 #define LL_RTC_BKP_DR3 0x03U
600 #define LL_RTC_BKP_DR4 0x04U
601 #define LL_RTC_BKP_DR5 0x05U
602 #define LL_RTC_BKP_DR6 0x06U
603 #define LL_RTC_BKP_DR7 0x07U
604 #define LL_RTC_BKP_DR8 0x08U
605 #define LL_RTC_BKP_DR9 0x09U
606 #define LL_RTC_BKP_DR10 0x0AU
607 #define LL_RTC_BKP_DR11 0x0BU
608 #define LL_RTC_BKP_DR12 0x0CU
609 #define LL_RTC_BKP_DR13 0x0DU
610 #define LL_RTC_BKP_DR14 0x0EU
611 #define LL_RTC_BKP_DR15 0x0FU
612 #define LL_RTC_BKP_DR16 0x10U
613 #define LL_RTC_BKP_DR17 0x11U
614 #define LL_RTC_BKP_DR18 0x12U
615 #define LL_RTC_BKP_DR19 0x13U
616 #define LL_RTC_BKP_DR20 0x14U
617 #define LL_RTC_BKP_DR21 0x15U
618 #define LL_RTC_BKP_DR22 0x16U
619 #define LL_RTC_BKP_DR23 0x17U
620 #define LL_RTC_BKP_DR24 0x18U
621 #define LL_RTC_BKP_DR25 0x19U
622 #define LL_RTC_BKP_DR26 0x1AU
623 #define LL_RTC_BKP_DR27 0x1BU
624 #define LL_RTC_BKP_DR28 0x1CU
625 #define LL_RTC_BKP_DR29 0x1DU
626 #define LL_RTC_BKP_DR30 0x1EU
627 #define LL_RTC_BKP_DR31 0x1FU
628 #else
629 #error "no LL Backup Registers Definition"
630 #endif /* (LL_RTC_BKP_NUMBER) */
631
632 /**
633 * @}
634 */
635
636 /** @defgroup RTC_LL_EC_WAKEUPCLOCK_DIV WAKEUP CLOCK DIV
637 * @{
638 */
639 #define LL_RTC_WAKEUPCLOCK_DIV_16 0x00000000U /*!< RTC/16 clock is selected */
640 #define LL_RTC_WAKEUPCLOCK_DIV_8 RTC_CR_WUCKSEL_0 /*!< RTC/8 clock is selected */
641 #define LL_RTC_WAKEUPCLOCK_DIV_4 RTC_CR_WUCKSEL_1 /*!< RTC/4 clock is selected */
642 #define LL_RTC_WAKEUPCLOCK_DIV_2 (RTC_CR_WUCKSEL_1 | RTC_CR_WUCKSEL_0) /*!< RTC/2 clock is selected */
643 #define LL_RTC_WAKEUPCLOCK_CKSPRE RTC_CR_WUCKSEL_2 /*!< ck_spre (usually 1 Hz) clock is selected */
644 #define LL_RTC_WAKEUPCLOCK_CKSPRE_WUT (RTC_CR_WUCKSEL_2 | RTC_CR_WUCKSEL_1) /*!< ck_spre (usually 1 Hz) clock is selected and 2exp16 is added to the WUT counter value*/
645 /**
646 * @}
647 */
648
649 /** @defgroup RTC_LL_EC_CALIB_OUTPUT Calibration output
650 * @{
651 */
652 #define LL_RTC_CALIB_OUTPUT_NONE 0x00000000U /*!< Calibration output disabled */
653 #define LL_RTC_CALIB_OUTPUT_1HZ (RTC_CR_COE | RTC_CR_COSEL) /*!< Calibration output is 1 Hz */
654 #define LL_RTC_CALIB_OUTPUT_512HZ RTC_CR_COE /*!< Calibration output is 512 Hz */
655 /**
656 * @}
657 */
658
659 /** @defgroup RTC_LL_EC_CALIB_INSERTPULSE Calibration pulse insertion
660 * @{
661 */
662 #define LL_RTC_CALIB_INSERTPULSE_NONE 0x00000000U /*!< No RTCCLK pulses are added */
663 #define LL_RTC_CALIB_INSERTPULSE_SET RTC_CALR_CALP /*!< One RTCCLK pulse is effectively inserted every 2exp11 pulses (frequency increased by 488.5 ppm) */
664 /**
665 * @}
666 */
667
668 /** @defgroup RTC_LL_EC_CALIB_PERIOD Calibration period
669 * @{
670 */
671 #define LL_RTC_CALIB_PERIOD_32SEC 0x00000000U /*!< Use a 32-second calibration cycle period */
672 #define LL_RTC_CALIB_PERIOD_16SEC RTC_CALR_CALW16 /*!< Use a 16-second calibration cycle period */
673 #define LL_RTC_CALIB_PERIOD_8SEC RTC_CALR_CALW8 /*!< Use a 8-second calibration cycle period */
674 /**
675 * @}
676 */
677
678 /**
679 * @}
680 */
681
682 /* Exported macro ------------------------------------------------------------*/
683 /** @defgroup RTC_LL_EM_Convert Convert helper Macros
684 * @{
685 */
686
687 /**
688 * @brief Helper macro to convert a value from 2 digit decimal format to BCD format
689 * @param __VALUE__ Byte to be converted
690 * @retval Converted byte
691 */
692 #define __LL_RTC_CONVERT_BIN2BCD(__VALUE__) (uint8_t)((((__VALUE__) / 10U) << 4U) | ((__VALUE__) % 10U))
693
694 /**
695 * @brief Helper macro to convert a value from BCD format to 2 digit decimal format
696 * @param __VALUE__ BCD value to be converted
697 * @retval Converted byte
698 */
699 #define __LL_RTC_CONVERT_BCD2BIN(__VALUE__) ((uint8_t)((((uint8_t)((__VALUE__) & (uint8_t)0xF0U) >> (uint8_t)0x4U) * 10U) + ((__VALUE__) & (uint8_t)0x0FU)))
700
701 /**
702 * @}
703 */
704
705 /** @defgroup RTC_LL_EM_Date Date helper Macros
706 * @{
707 */
708
709 /**
710 * @brief Helper macro to retrieve weekday.
711 * @param __RTC_DATE__ Date returned by @ref LL_RTC_DATE_Get function.
712 * @retval Returned value can be one of the following values:
713 * @arg @ref LL_RTC_WEEKDAY_MONDAY
714 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
715 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
716 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
717 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
718 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
719 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
720 */
721 #define __LL_RTC_GET_WEEKDAY(__RTC_DATE__) (((__RTC_DATE__) >> RTC_OFFSET_WEEKDAY) & 0x000000FFU)
722
723 /**
724 * @brief Helper macro to retrieve Year in BCD format
725 * @param __RTC_DATE__ Value returned by @ref LL_RTC_DATE_Get
726 * @retval Year in BCD format (0x00 . . . 0x99)
727 */
728 #define __LL_RTC_GET_YEAR(__RTC_DATE__) ((__RTC_DATE__) & 0x000000FFU)
729
730 /**
731 * @brief Helper macro to retrieve Month in BCD format
732 * @param __RTC_DATE__ Value returned by @ref LL_RTC_DATE_Get
733 * @retval Returned value can be one of the following values:
734 * @arg @ref LL_RTC_MONTH_JANUARY
735 * @arg @ref LL_RTC_MONTH_FEBRUARY
736 * @arg @ref LL_RTC_MONTH_MARCH
737 * @arg @ref LL_RTC_MONTH_APRIL
738 * @arg @ref LL_RTC_MONTH_MAY
739 * @arg @ref LL_RTC_MONTH_JUNE
740 * @arg @ref LL_RTC_MONTH_JULY
741 * @arg @ref LL_RTC_MONTH_AUGUST
742 * @arg @ref LL_RTC_MONTH_SEPTEMBER
743 * @arg @ref LL_RTC_MONTH_OCTOBER
744 * @arg @ref LL_RTC_MONTH_NOVEMBER
745 * @arg @ref LL_RTC_MONTH_DECEMBER
746 */
747 #define __LL_RTC_GET_MONTH(__RTC_DATE__) (((__RTC_DATE__) >>RTC_OFFSET_MONTH) & 0x000000FFU)
748
749 /**
750 * @brief Helper macro to retrieve Day in BCD format
751 * @param __RTC_DATE__ Value returned by @ref LL_RTC_DATE_Get
752 * @retval Day in BCD format (0x01 . . . 0x31)
753 */
754 #define __LL_RTC_GET_DAY(__RTC_DATE__) (((__RTC_DATE__) >>RTC_OFFSET_DAY) & 0x000000FFU)
755
756 /**
757 * @}
758 */
759
760 /** @defgroup RTC_LL_EM_Time Time helper Macros
761 * @{
762 */
763
764 /**
765 * @brief Helper macro to retrieve hour in BCD format
766 * @param __RTC_TIME__ RTC time returned by @ref LL_RTC_TIME_Get function
767 * @retval Hours in BCD format (0x01. . .0x12 or between Min_Data=0x00 and Max_Data=0x23)
768 */
769 #define __LL_RTC_GET_HOUR(__RTC_TIME__) (((__RTC_TIME__) >> RTC_OFFSET_HOUR) & 0x000000FFU)
770
771 /**
772 * @brief Helper macro to retrieve minute in BCD format
773 * @param __RTC_TIME__ RTC time returned by @ref LL_RTC_TIME_Get function
774 * @retval Minutes in BCD format (0x00. . .0x59)
775 */
776 #define __LL_RTC_GET_MINUTE(__RTC_TIME__) (((__RTC_TIME__) >> RTC_OFFSET_MINUTE) & 0x000000FFU)
777
778 /**
779 * @brief Helper macro to retrieve second in BCD format
780 * @param __RTC_TIME__ RTC time returned by @ref LL_RTC_TIME_Get function
781 * @retval Seconds in format (0x00. . .0x59)
782 */
783 #define __LL_RTC_GET_SECOND(__RTC_TIME__) ((__RTC_TIME__) & 0x000000FFU)
784
785 /**
786 * @}
787 */
788
789 /**
790 * @}
791 */
792
793 /* Exported functions --------------------------------------------------------*/
794 /** @defgroup RTC_LL_Exported_Functions RTC Exported Functions
795 * @{
796 */
797
798 /** @defgroup RTC_LL_EF_Configuration Configuration
799 * @{
800 */
801
802 /**
803 * @brief Set Hours format (24 hour/day or AM/PM hour format)
804 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
805 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
806 * @rmtoll RTC_CR FMT LL_RTC_SetHourFormat
807 * @param RTCx RTC Instance
808 * @param HourFormat This parameter can be one of the following values:
809 * @arg @ref LL_RTC_HOURFORMAT_24HOUR
810 * @arg @ref LL_RTC_HOURFORMAT_AMPM
811 * @retval None
812 */
813 __STATIC_INLINE void LL_RTC_SetHourFormat(RTC_TypeDef *RTCx, uint32_t HourFormat)
814 {
815 MODIFY_REG(RTCx->CR, RTC_CR_FMT, HourFormat);
816 }
817
818 /**
819 * @brief Get Hours format (24 hour/day or AM/PM hour format)
820 * @rmtoll RTC_CR FMT LL_RTC_GetHourFormat
821 * @param RTCx RTC Instance
822 * @retval Returned value can be one of the following values:
823 * @arg @ref LL_RTC_HOURFORMAT_24HOUR
824 * @arg @ref LL_RTC_HOURFORMAT_AMPM
825 */
826 __STATIC_INLINE uint32_t LL_RTC_GetHourFormat(RTC_TypeDef *RTCx)
827 {
828 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_FMT));
829 }
830
831 /**
832 * @brief Select the flag to be routed to RTC_ALARM output
833 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
834 * @rmtoll RTC_CR OSEL LL_RTC_SetAlarmOutEvent
835 * @param RTCx RTC Instance
836 * @param AlarmOutput This parameter can be one of the following values:
837 * @arg @ref LL_RTC_ALARMOUT_DISABLE
838 * @arg @ref LL_RTC_ALARMOUT_ALMA
839 * @arg @ref LL_RTC_ALARMOUT_ALMB
840 * @arg @ref LL_RTC_ALARMOUT_WAKEUP
841 * @retval None
842 */
843 __STATIC_INLINE void LL_RTC_SetAlarmOutEvent(RTC_TypeDef *RTCx, uint32_t AlarmOutput)
844 {
845 MODIFY_REG(RTCx->CR, RTC_CR_OSEL, AlarmOutput);
846 }
847
848 /**
849 * @brief Get the flag to be routed to RTC_ALARM output
850 * @rmtoll RTC_CR OSEL LL_RTC_GetAlarmOutEvent
851 * @param RTCx RTC Instance
852 * @retval Returned value can be one of the following values:
853 * @arg @ref LL_RTC_ALARMOUT_DISABLE
854 * @arg @ref LL_RTC_ALARMOUT_ALMA
855 * @arg @ref LL_RTC_ALARMOUT_ALMB
856 * @arg @ref LL_RTC_ALARMOUT_WAKEUP
857 */
858 __STATIC_INLINE uint32_t LL_RTC_GetAlarmOutEvent(RTC_TypeDef *RTCx)
859 {
860 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_OSEL));
861 }
862
863 /**
864 * @brief Set RTC_ALARM output type (ALARM in push-pull or open-drain output)
865 * @rmtoll RTC_CR TAMPALRM_TYPE LL_RTC_SetAlarmOutputType
866 * @param RTCx RTC Instance
867 * @param Output This parameter can be one of the following values:
868 * @arg @ref LL_RTC_ALARM_OUTPUTTYPE_OPENDRAIN
869 * @arg @ref LL_RTC_ALARM_OUTPUTTYPE_PUSHPULL
870 * @retval None
871 */
872 __STATIC_INLINE void LL_RTC_SetAlarmOutputType(RTC_TypeDef *RTCx, uint32_t Output)
873 {
874 MODIFY_REG(RTCx->CR, RTC_CR_TAMPALRM_TYPE, Output);
875 }
876
877 /**
878 * @brief Get RTC_ALARM output type (ALARM in push-pull or open-drain output)
879 * @rmtoll RTC_CR TAMPALRM_TYPE LL_RTC_SetAlarmOutputType
880 * @param RTCx RTC Instance
881 * @retval Returned value can be one of the following values:
882 * @arg @ref LL_RTC_ALARM_OUTPUTTYPE_OPENDRAIN
883 * @arg @ref LL_RTC_ALARM_OUTPUTTYPE_PUSHPULL
884 */
885 __STATIC_INLINE uint32_t LL_RTC_GetAlarmOutputType(RTC_TypeDef *RTCx)
886 {
887 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_TAMPALRM_TYPE));
888 }
889
890
891 /**
892 * @brief Enable initialization mode
893 * @note Initialization mode is used to program time and date register (RTC_TR and RTC_DR)
894 * and prescaler register (RTC_PRER).
895 * Counters are stopped and start counting from the new value when INIT is reset.
896 * @rmtoll RTC_ICSR INIT LL_RTC_EnableInitMode
897 * @param RTCx RTC Instance
898 * @retval None
899 */
900 __STATIC_INLINE void LL_RTC_EnableInitMode(RTC_TypeDef *RTCx)
901 {
902 /* Set the Initialization mode */
903 WRITE_REG(RTCx->ICSR, RTC_LL_INIT_MASK);
904 }
905
906 /**
907 * @brief Disable initialization mode (Free running mode)
908 * @rmtoll RTC_ICSR INIT LL_RTC_DisableInitMode
909 * @param RTCx RTC Instance
910 * @retval None
911 */
912 __STATIC_INLINE void LL_RTC_DisableInitMode(RTC_TypeDef *RTCx)
913 {
914 /* Exit Initialization mode */
915 WRITE_REG(RTCx->ICSR, (uint32_t)~RTC_ICSR_INIT);
916 }
917
918 /**
919 * @brief Set Output polarity (pin is low when ALRAF/ALRBF/WUTF is asserted)
920 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
921 * @rmtoll RTC_CR POL LL_RTC_SetOutputPolarity
922 * @param RTCx RTC Instance
923 * @param Polarity This parameter can be one of the following values:
924 * @arg @ref LL_RTC_OUTPUTPOLARITY_PIN_HIGH
925 * @arg @ref LL_RTC_OUTPUTPOLARITY_PIN_LOW
926 * @retval None
927 */
928 __STATIC_INLINE void LL_RTC_SetOutputPolarity(RTC_TypeDef *RTCx, uint32_t Polarity)
929 {
930 MODIFY_REG(RTCx->CR, RTC_CR_POL, Polarity);
931 }
932
933 /**
934 * @brief Get Output polarity
935 * @rmtoll RTC_CR POL LL_RTC_GetOutputPolarity
936 * @param RTCx RTC Instance
937 * @retval Returned value can be one of the following values:
938 * @arg @ref LL_RTC_OUTPUTPOLARITY_PIN_HIGH
939 * @arg @ref LL_RTC_OUTPUTPOLARITY_PIN_LOW
940 */
941 __STATIC_INLINE uint32_t LL_RTC_GetOutputPolarity(RTC_TypeDef *RTCx)
942 {
943 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_POL));
944 }
945
946 /**
947 * @brief Enable Bypass the shadow registers
948 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
949 * @rmtoll RTC_CR BYPSHAD LL_RTC_EnableShadowRegBypass
950 * @param RTCx RTC Instance
951 * @retval None
952 */
953 __STATIC_INLINE void LL_RTC_EnableShadowRegBypass(RTC_TypeDef *RTCx)
954 {
955 SET_BIT(RTCx->CR, RTC_CR_BYPSHAD);
956 }
957
958 /**
959 * @brief Disable Bypass the shadow registers
960 * @rmtoll RTC_CR BYPSHAD LL_RTC_DisableShadowRegBypass
961 * @param RTCx RTC Instance
962 * @retval None
963 */
964 __STATIC_INLINE void LL_RTC_DisableShadowRegBypass(RTC_TypeDef *RTCx)
965 {
966 CLEAR_BIT(RTCx->CR, RTC_CR_BYPSHAD);
967 }
968
969 /**
970 * @brief Check if Shadow registers bypass is enabled or not.
971 * @rmtoll RTC_CR BYPSHAD LL_RTC_IsShadowRegBypassEnabled
972 * @param RTCx RTC Instance
973 * @retval State of bit (1 or 0).
974 */
975 __STATIC_INLINE uint32_t LL_RTC_IsShadowRegBypassEnabled(RTC_TypeDef *RTCx)
976 {
977 return ((READ_BIT(RTCx->CR, RTC_CR_BYPSHAD) == (RTC_CR_BYPSHAD)) ? 1U : 0U);
978 }
979
980 /**
981 * @brief Enable RTC_REFIN reference clock detection (50 or 60 Hz)
982 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
983 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
984 * @rmtoll RTC_CR REFCKON LL_RTC_EnableRefClock
985 * @param RTCx RTC Instance
986 * @retval None
987 */
988 __STATIC_INLINE void LL_RTC_EnableRefClock(RTC_TypeDef *RTCx)
989 {
990 SET_BIT(RTCx->CR, RTC_CR_REFCKON);
991 }
992
993 /**
994 * @brief Disable RTC_REFIN reference clock detection (50 or 60 Hz)
995 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
996 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
997 * @rmtoll RTC_CR REFCKON LL_RTC_DisableRefClock
998 * @param RTCx RTC Instance
999 * @retval None
1000 */
1001 __STATIC_INLINE void LL_RTC_DisableRefClock(RTC_TypeDef *RTCx)
1002 {
1003 CLEAR_BIT(RTCx->CR, RTC_CR_REFCKON);
1004 }
1005
1006 /**
1007 * @brief Set Asynchronous prescaler factor
1008 * @rmtoll RTC_PRER PREDIV_A LL_RTC_SetAsynchPrescaler
1009 * @param RTCx RTC Instance
1010 * @param AsynchPrescaler Value between Min_Data = 0 and Max_Data = 0x7F
1011 * @retval None
1012 */
1013 __STATIC_INLINE void LL_RTC_SetAsynchPrescaler(RTC_TypeDef *RTCx, uint32_t AsynchPrescaler)
1014 {
1015 MODIFY_REG(RTCx->PRER, RTC_PRER_PREDIV_A, AsynchPrescaler << RTC_PRER_PREDIV_A_Pos);
1016 }
1017
1018 /**
1019 * @brief Set Synchronous prescaler factor
1020 * @rmtoll RTC_PRER PREDIV_S LL_RTC_SetSynchPrescaler
1021 * @param RTCx RTC Instance
1022 * @param SynchPrescaler Value between Min_Data = 0 and Max_Data = 0x7FFF
1023 * @retval None
1024 */
1025 __STATIC_INLINE void LL_RTC_SetSynchPrescaler(RTC_TypeDef *RTCx, uint32_t SynchPrescaler)
1026 {
1027 MODIFY_REG(RTCx->PRER, RTC_PRER_PREDIV_S, SynchPrescaler);
1028 }
1029
1030 /**
1031 * @brief Get Asynchronous prescaler factor
1032 * @rmtoll RTC_PRER PREDIV_A LL_RTC_GetAsynchPrescaler
1033 * @param RTCx RTC Instance
1034 * @retval Value between Min_Data = 0 and Max_Data = 0x7F
1035 */
1036 __STATIC_INLINE uint32_t LL_RTC_GetAsynchPrescaler(RTC_TypeDef *RTCx)
1037 {
1038 return (uint32_t)(READ_BIT(RTCx->PRER, RTC_PRER_PREDIV_A) >> RTC_PRER_PREDIV_A_Pos);
1039 }
1040
1041 /**
1042 * @brief Get Synchronous prescaler factor
1043 * @rmtoll RTC_PRER PREDIV_S LL_RTC_GetSynchPrescaler
1044 * @param RTCx RTC Instance
1045 * @retval Value between Min_Data = 0 and Max_Data = 0x7FFF
1046 */
1047 __STATIC_INLINE uint32_t LL_RTC_GetSynchPrescaler(RTC_TypeDef *RTCx)
1048 {
1049 return (uint32_t)(READ_BIT(RTCx->PRER, RTC_PRER_PREDIV_S));
1050 }
1051
1052 /**
1053 * @brief Enable the write protection for RTC registers.
1054 * @rmtoll RTC_WPR KEY LL_RTC_EnableWriteProtection
1055 * @param RTCx RTC Instance
1056 * @retval None
1057 */
1058 __STATIC_INLINE void LL_RTC_EnableWriteProtection(RTC_TypeDef *RTCx)
1059 {
1060 WRITE_REG(RTCx->WPR, RTC_WRITE_PROTECTION_DISABLE);
1061 }
1062
1063 /**
1064 * @brief Disable the write protection for RTC registers.
1065 * @rmtoll RTC_WPR KEY LL_RTC_DisableWriteProtection
1066 * @param RTCx RTC Instance
1067 * @retval None
1068 */
1069 __STATIC_INLINE void LL_RTC_DisableWriteProtection(RTC_TypeDef *RTCx)
1070 {
1071 WRITE_REG(RTCx->WPR, RTC_WRITE_PROTECTION_ENABLE_1);
1072 WRITE_REG(RTCx->WPR, RTC_WRITE_PROTECTION_ENABLE_2);
1073 }
1074
1075 /**
1076 * @brief Enable tamper output.
1077 * @note When the tamper output is enabled, all external and internal tamper flags
1078 * are ORed and routed to the TAMPALRM output.
1079 * @rmtoll RTC_CR TAMPOE LL_RTC_EnableTamperOutput
1080 * @param RTCx RTC Instance
1081 * @retval None
1082 */
1083 __STATIC_INLINE void LL_RTC_EnableTamperOutput(RTC_TypeDef *RTCx)
1084 {
1085 SET_BIT(RTCx->CR, RTC_CR_TAMPOE);
1086 }
1087
1088 /**
1089 * @brief Disable tamper output.
1090 * @rmtoll RTC_CR TAMPOE LL_RTC_DisableTamperOutput
1091 * @param RTCx RTC Instance
1092 * @retval None
1093 */
1094 __STATIC_INLINE void LL_RTC_DisableTamperOutput(RTC_TypeDef *RTCx)
1095 {
1096 CLEAR_BIT(RTCx->CR, RTC_CR_TAMPOE);
1097 }
1098
1099 /**
1100 * @brief Check if tamper output is enabled or not.
1101 * @rmtoll RTC_CR TAMPOE LL_RTC_IsTamperOutputEnabled
1102 * @param RTCx RTC Instance
1103 * @retval State of bit (1 or 0).
1104 */
1105 __STATIC_INLINE uint32_t LL_RTC_IsTamperOutputEnabled(RTC_TypeDef *RTCx)
1106 {
1107 return ((READ_BIT(RTCx->CR, RTC_CR_TAMPOE) == (RTC_CR_TAMPOE)) ? 1U : 0U);
1108 }
1109
1110 /**
1111 * @brief Enable internal pull-up in output mode.
1112 * @rmtoll RTC_CR TAMPALRM_PU LL_RTC_EnableAlarmPullUp
1113 * @param RTCx RTC Instance
1114 * @retval None
1115 */
1116 __STATIC_INLINE void LL_RTC_EnableAlarmPullUp(RTC_TypeDef *RTCx)
1117 {
1118 SET_BIT(RTCx->CR, RTC_CR_TAMPALRM_PU);
1119 }
1120
1121 /**
1122 * @brief Disable internal pull-up in output mode.
1123 * @rmtoll RTC_CR TAMPALRM_PU LL_RTC_EnableAlarmPullUp
1124 * @param RTCx RTC Instance
1125 * @retval None
1126 */
1127 __STATIC_INLINE void LL_RTC_DisableAlarmPullUp(RTC_TypeDef *RTCx)
1128 {
1129 CLEAR_BIT(RTCx->CR, RTC_CR_TAMPALRM_PU);
1130 }
1131
1132 /**
1133 * @brief Check if internal pull-up in output mode is enabled or not.
1134 * @rmtoll RTC_CR TAMPALRM_PU LL_RTC_IsAlarmPullUpEnabled
1135 * @param RTCx RTC Instance
1136 * @retval State of bit (1 or 0).
1137 */
1138 __STATIC_INLINE uint32_t LL_RTC_IsAlarmPullUpEnabled(RTC_TypeDef *RTCx)
1139 {
1140 return ((READ_BIT(RTCx->CR, RTC_CR_TAMPALRM_PU) == (RTC_CR_TAMPALRM_PU)) ? 1U : 0U);
1141 }
1142
1143 /**
1144 * @brief Enable RTC_OUT2 output
1145 * @note RTC_OUT2 mapping depends on both OSEL (@ref LL_RTC_SetAlarmOutEvent)
1146 * and COE (@ref LL_RTC_CAL_SetOutputFreq) settings.
1147 * @note RTC_OUT2 is not available ins VBAT mode.
1148 * @rmtoll RTC_CR OUT2EN LL_RTC_EnableOutput2
1149 * @param RTCx RTC Instance
1150 * @retval None
1151 */
1152 __STATIC_INLINE void LL_RTC_EnableOutput2(RTC_TypeDef *RTCx)
1153 {
1154 SET_BIT(RTCx->CR, RTC_CR_OUT2EN);
1155 }
1156
1157 /**
1158 * @brief Disable RTC_OUT2 output
1159 * @rmtoll RTC_CR OUT2EN LL_RTC_DisableOutput2
1160 * @param RTCx RTC Instance
1161 * @retval None
1162 */
1163 __STATIC_INLINE void LL_RTC_DisableOutput2(RTC_TypeDef *RTCx)
1164 {
1165 CLEAR_BIT(RTCx->CR, RTC_CR_OUT2EN);
1166 }
1167
1168 /**
1169 * @brief Check if RTC_OUT2 output is enabled or not.
1170 * @rmtoll RTC_CR OUT2EN LL_RTC_IsOutput2Enabled
1171 * @param RTCx RTC Instance
1172 * @retval State of bit (1 or 0).
1173 */
1174 __STATIC_INLINE uint32_t LL_RTC_IsOutput2Enabled(RTC_TypeDef *RTCx)
1175 {
1176 return ((READ_BIT(RTCx->CR, RTC_CR_OUT2EN) == (RTC_CR_OUT2EN)) ? 1U : 0U);
1177 }
1178
1179 /**
1180 * @}
1181 */
1182
1183 /** @defgroup RTC_LL_EF_Time Time
1184 * @{
1185 */
1186
1187 /**
1188 * @brief Set time format (AM/24-hour or PM notation)
1189 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1190 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
1191 * @rmtoll RTC_TR PM LL_RTC_TIME_SetFormat
1192 * @param RTCx RTC Instance
1193 * @param TimeFormat This parameter can be one of the following values:
1194 * @arg @ref LL_RTC_TIME_FORMAT_AM_OR_24
1195 * @arg @ref LL_RTC_TIME_FORMAT_PM
1196 * @retval None
1197 */
1198 __STATIC_INLINE void LL_RTC_TIME_SetFormat(RTC_TypeDef *RTCx, uint32_t TimeFormat)
1199 {
1200 MODIFY_REG(RTCx->TR, RTC_TR_PM, TimeFormat);
1201 }
1202
1203 /**
1204 * @brief Get time format (AM or PM notation)
1205 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1206 * before reading this bit
1207 * @note Read either RTC_SSR or RTC_TR locks the values in the higher-order calendar
1208 * shadow registers until RTC_DR is read (LL_RTC_ReadReg(RTC, DR)).
1209 * @rmtoll RTC_TR PM LL_RTC_TIME_GetFormat
1210 * @param RTCx RTC Instance
1211 * @retval Returned value can be one of the following values:
1212 * @arg @ref LL_RTC_TIME_FORMAT_AM_OR_24
1213 * @arg @ref LL_RTC_TIME_FORMAT_PM
1214 */
1215 __STATIC_INLINE uint32_t LL_RTC_TIME_GetFormat(RTC_TypeDef *RTCx)
1216 {
1217 return (uint32_t)(READ_BIT(RTCx->TR, RTC_TR_PM));
1218 }
1219
1220 /**
1221 * @brief Set Hours in BCD format
1222 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1223 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
1224 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert hour from binary to BCD format
1225 * @rmtoll RTC_TR HT LL_RTC_TIME_SetHour\n
1226 * RTC_TR HU LL_RTC_TIME_SetHour
1227 * @param RTCx RTC Instance
1228 * @param Hours Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
1229 * @retval None
1230 */
1231 __STATIC_INLINE void LL_RTC_TIME_SetHour(RTC_TypeDef *RTCx, uint32_t Hours)
1232 {
1233 MODIFY_REG(RTCx->TR, (RTC_TR_HT | RTC_TR_HU),
1234 (((Hours & 0xF0U) << (RTC_TR_HT_Pos - 4U)) | ((Hours & 0x0FU) << RTC_TR_HU_Pos)));
1235 }
1236
1237 /**
1238 * @brief Get Hours in BCD format
1239 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1240 * before reading this bit
1241 * @note Read either RTC_SSR or RTC_TR locks the values in the higher-order calendar
1242 * shadow registers until RTC_DR is read (LL_RTC_ReadReg(RTC, DR)).
1243 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert hour from BCD to
1244 * Binary format
1245 * @rmtoll RTC_TR HT LL_RTC_TIME_GetHour\n
1246 * RTC_TR HU LL_RTC_TIME_GetHour
1247 * @param RTCx RTC Instance
1248 * @retval Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
1249 */
1250 __STATIC_INLINE uint32_t LL_RTC_TIME_GetHour(RTC_TypeDef *RTCx)
1251 {
1252 return (uint32_t)((READ_BIT(RTCx->TR, (RTC_TR_HT | RTC_TR_HU))) >> RTC_TR_HU_Pos);
1253 }
1254
1255 /**
1256 * @brief Set Minutes in BCD format
1257 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1258 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
1259 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Minutes from binary to BCD format
1260 * @rmtoll RTC_TR MNT LL_RTC_TIME_SetMinute\n
1261 * RTC_TR MNU LL_RTC_TIME_SetMinute
1262 * @param RTCx RTC Instance
1263 * @param Minutes Value between Min_Data=0x00 and Max_Data=0x59
1264 * @retval None
1265 */
1266 __STATIC_INLINE void LL_RTC_TIME_SetMinute(RTC_TypeDef *RTCx, uint32_t Minutes)
1267 {
1268 MODIFY_REG(RTCx->TR, (RTC_TR_MNT | RTC_TR_MNU),
1269 (((Minutes & 0xF0U) << (RTC_TR_MNT_Pos - 4U)) | ((Minutes & 0x0FU) << RTC_TR_MNU_Pos)));
1270 }
1271
1272 /**
1273 * @brief Get Minutes in BCD format
1274 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1275 * before reading this bit
1276 * @note Read either RTC_SSR or RTC_TR locks the values in the higher-order calendar
1277 * shadow registers until RTC_DR is read (LL_RTC_ReadReg(RTC, DR)).
1278 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert minute from BCD
1279 * to Binary format
1280 * @rmtoll RTC_TR MNT LL_RTC_TIME_GetMinute\n
1281 * RTC_TR MNU LL_RTC_TIME_GetMinute
1282 * @param RTCx RTC Instance
1283 * @retval Value between Min_Data=0x00 and Max_Data=0x59
1284 */
1285 __STATIC_INLINE uint32_t LL_RTC_TIME_GetMinute(RTC_TypeDef *RTCx)
1286 {
1287 return (uint32_t)(READ_BIT(RTCx->TR, (RTC_TR_MNT | RTC_TR_MNU)) >> RTC_TR_MNU_Pos);
1288 }
1289
1290 /**
1291 * @brief Set Seconds in BCD format
1292 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1293 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
1294 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Seconds from binary to BCD format
1295 * @rmtoll RTC_TR ST LL_RTC_TIME_SetSecond\n
1296 * RTC_TR SU LL_RTC_TIME_SetSecond
1297 * @param RTCx RTC Instance
1298 * @param Seconds Value between Min_Data=0x00 and Max_Data=0x59
1299 * @retval None
1300 */
1301 __STATIC_INLINE void LL_RTC_TIME_SetSecond(RTC_TypeDef *RTCx, uint32_t Seconds)
1302 {
1303 MODIFY_REG(RTCx->TR, (RTC_TR_ST | RTC_TR_SU),
1304 (((Seconds & 0xF0U) << (RTC_TR_ST_Pos - 4U)) | ((Seconds & 0x0FU) << RTC_TR_SU_Pos)));
1305 }
1306
1307 /**
1308 * @brief Get Seconds in BCD format
1309 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1310 * before reading this bit
1311 * @note Read either RTC_SSR or RTC_TR locks the values in the higher-order calendar
1312 * shadow registers until RTC_DR is read (LL_RTC_ReadReg(RTC, DR)).
1313 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Seconds from BCD
1314 * to Binary format
1315 * @rmtoll RTC_TR ST LL_RTC_TIME_GetSecond\n
1316 * RTC_TR SU LL_RTC_TIME_GetSecond
1317 * @param RTCx RTC Instance
1318 * @retval Value between Min_Data=0x00 and Max_Data=0x59
1319 */
1320 __STATIC_INLINE uint32_t LL_RTC_TIME_GetSecond(RTC_TypeDef *RTCx)
1321 {
1322 return (uint32_t)(READ_BIT(RTCx->TR, (RTC_TR_ST | RTC_TR_SU)) >> RTC_TR_SU_Pos);
1323 }
1324
1325 /**
1326 * @brief Set time (hour, minute and second) in BCD format
1327 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1328 * @note It can be written in initialization mode only (@ref LL_RTC_EnableInitMode function)
1329 * @note TimeFormat and Hours should follow the same format
1330 * @rmtoll RTC_TR PM LL_RTC_TIME_Config\n
1331 * RTC_TR HT LL_RTC_TIME_Config\n
1332 * RTC_TR HU LL_RTC_TIME_Config\n
1333 * RTC_TR MNT LL_RTC_TIME_Config\n
1334 * RTC_TR MNU LL_RTC_TIME_Config\n
1335 * RTC_TR ST LL_RTC_TIME_Config\n
1336 * RTC_TR SU LL_RTC_TIME_Config
1337 * @param RTCx RTC Instance
1338 * @param Format12_24 This parameter can be one of the following values:
1339 * @arg @ref LL_RTC_TIME_FORMAT_AM_OR_24
1340 * @arg @ref LL_RTC_TIME_FORMAT_PM
1341 * @param Hours Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
1342 * @param Minutes Value between Min_Data=0x00 and Max_Data=0x59
1343 * @param Seconds Value between Min_Data=0x00 and Max_Data=0x59
1344 * @retval None
1345 */
1346 __STATIC_INLINE void LL_RTC_TIME_Config(RTC_TypeDef *RTCx, uint32_t Format12_24, uint32_t Hours, uint32_t Minutes,
1347 uint32_t Seconds)
1348 {
1349 register uint32_t temp;
1350
1351 temp = Format12_24 | \
1352 (((Hours & 0xF0U) << (RTC_TR_HT_Pos - 4U)) | ((Hours & 0x0FU) << RTC_TR_HU_Pos)) | \
1353 (((Minutes & 0xF0U) << (RTC_TR_MNT_Pos - 4U)) | ((Minutes & 0x0FU) << RTC_TR_MNU_Pos)) | \
1354 (((Seconds & 0xF0U) << (RTC_TR_ST_Pos - 4U)) | ((Seconds & 0x0FU) << RTC_TR_SU_Pos));
1355 MODIFY_REG(RTCx->TR, (RTC_TR_PM | RTC_TR_HT | RTC_TR_HU | RTC_TR_MNT | RTC_TR_MNU | RTC_TR_ST | RTC_TR_SU), temp);
1356 }
1357
1358 /**
1359 * @brief Get time (hour, minute and second) in BCD format
1360 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1361 * before reading this bit
1362 * @note Read either RTC_SSR or RTC_TR locks the values in the higher-order calendar
1363 * shadow registers until RTC_DR is read (LL_RTC_ReadReg(RTC, DR)).
1364 * @note helper macros __LL_RTC_GET_HOUR, __LL_RTC_GET_MINUTE and __LL_RTC_GET_SECOND
1365 * are available to get independently each parameter.
1366 * @rmtoll RTC_TR HT LL_RTC_TIME_Get\n
1367 * RTC_TR HU LL_RTC_TIME_Get\n
1368 * RTC_TR MNT LL_RTC_TIME_Get\n
1369 * RTC_TR MNU LL_RTC_TIME_Get\n
1370 * RTC_TR ST LL_RTC_TIME_Get\n
1371 * RTC_TR SU LL_RTC_TIME_Get
1372 * @param RTCx RTC Instance
1373 * @retval Combination of hours, minutes and seconds (Format: 0x00HHMMSS).
1374 */
1375 __STATIC_INLINE uint32_t LL_RTC_TIME_Get(RTC_TypeDef *RTCx)
1376 {
1377 register uint32_t temp;
1378
1379 temp = READ_BIT(RTCx->TR, (RTC_TR_HT | RTC_TR_HU | RTC_TR_MNT | RTC_TR_MNU | RTC_TR_ST | RTC_TR_SU));
1380 return (uint32_t)((((((temp & RTC_TR_HT) >> RTC_TR_HT_Pos) << 4U) | ((temp & RTC_TR_HU) >> RTC_TR_HU_Pos)) << RTC_OFFSET_HOUR) | \
1381 (((((temp & RTC_TR_MNT) >> RTC_TR_MNT_Pos) << 4U) | ((temp & RTC_TR_MNU) >> RTC_TR_MNU_Pos)) << RTC_OFFSET_MINUTE) | \
1382 ((((temp & RTC_TR_ST) >> RTC_TR_ST_Pos) << 4U) | ((temp & RTC_TR_SU) >> RTC_TR_SU_Pos)));
1383 }
1384
1385 /**
1386 * @brief Memorize whether the daylight saving time change has been performed
1387 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1388 * @rmtoll RTC_CR BKP LL_RTC_TIME_EnableDayLightStore
1389 * @param RTCx RTC Instance
1390 * @retval None
1391 */
1392 __STATIC_INLINE void LL_RTC_TIME_EnableDayLightStore(RTC_TypeDef *RTCx)
1393 {
1394 SET_BIT(RTCx->CR, RTC_CR_BKP);
1395 }
1396
1397 /**
1398 * @brief Disable memorization whether the daylight saving time change has been performed.
1399 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1400 * @rmtoll RTC_CR BKP LL_RTC_TIME_DisableDayLightStore
1401 * @param RTCx RTC Instance
1402 * @retval None
1403 */
1404 __STATIC_INLINE void LL_RTC_TIME_DisableDayLightStore(RTC_TypeDef *RTCx)
1405 {
1406 CLEAR_BIT(RTCx->CR, RTC_CR_BKP);
1407 }
1408
1409 /**
1410 * @brief Check if RTC Day Light Saving stored operation has been enabled or not
1411 * @rmtoll RTC_CR BKP LL_RTC_TIME_IsDayLightStoreEnabled
1412 * @param RTCx RTC Instance
1413 * @retval State of bit (1 or 0).
1414 */
1415 __STATIC_INLINE uint32_t LL_RTC_TIME_IsDayLightStoreEnabled(RTC_TypeDef *RTCx)
1416 {
1417 return ((READ_BIT(RTCx->CR, RTC_CR_BKP) == (RTC_CR_BKP)) ? 1U : 0U);
1418 }
1419
1420 /**
1421 * @brief Subtract 1 hour (winter time change)
1422 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1423 * @rmtoll RTC_CR SUB1H LL_RTC_TIME_DecHour
1424 * @param RTCx RTC Instance
1425 * @retval None
1426 */
1427 __STATIC_INLINE void LL_RTC_TIME_DecHour(RTC_TypeDef *RTCx)
1428 {
1429 SET_BIT(RTCx->CR, RTC_CR_SUB1H);
1430 }
1431
1432 /**
1433 * @brief Add 1 hour (summer time change)
1434 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1435 * @rmtoll RTC_CR ADD1H LL_RTC_TIME_IncHour
1436 * @param RTCx RTC Instance
1437 * @retval None
1438 */
1439 __STATIC_INLINE void LL_RTC_TIME_IncHour(RTC_TypeDef *RTCx)
1440 {
1441 SET_BIT(RTCx->CR, RTC_CR_ADD1H);
1442 }
1443
1444 /**
1445 * @brief Get Sub second value in the synchronous prescaler counter.
1446 * @note You can use both SubSeconds value and SecondFraction (PREDIV_S through
1447 * LL_RTC_GetSynchPrescaler function) terms returned to convert Calendar
1448 * SubSeconds value in second fraction ratio with time unit following
1449 * generic formula:
1450 * ==> Seconds fraction ratio * time_unit= [(SecondFraction-SubSeconds)/(SecondFraction+1)] * time_unit
1451 * This conversion can be performed only if no shift operation is pending
1452 * (ie. SHFP=0) when PREDIV_S >= SS.
1453 * @rmtoll RTC_SSR SS LL_RTC_TIME_GetSubSecond
1454 * @param RTCx RTC Instance
1455 * @retval Sub second value (number between 0 and 65535)
1456 */
1457 __STATIC_INLINE uint32_t LL_RTC_TIME_GetSubSecond(RTC_TypeDef *RTCx)
1458 {
1459 return (uint32_t)(READ_BIT(RTCx->SSR, RTC_SSR_SS));
1460 }
1461
1462 /**
1463 * @brief Synchronize to a remote clock with a high degree of precision.
1464 * @note This operation effectively subtracts from (delays) or advance the clock of a fraction of a second.
1465 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1466 * @note When REFCKON is set, firmware must not write to Shift control register.
1467 * @rmtoll RTC_SHIFTR ADD1S LL_RTC_TIME_Synchronize\n
1468 * RTC_SHIFTR SUBFS LL_RTC_TIME_Synchronize
1469 * @param RTCx RTC Instance
1470 * @param ShiftSecond This parameter can be one of the following values:
1471 * @arg @ref LL_RTC_SHIFT_SECOND_DELAY
1472 * @arg @ref LL_RTC_SHIFT_SECOND_ADVANCE
1473 * @param Fraction Number of Seconds Fractions (any value from 0 to 0x7FFF)
1474 * @retval None
1475 */
1476 __STATIC_INLINE void LL_RTC_TIME_Synchronize(RTC_TypeDef *RTCx, uint32_t ShiftSecond, uint32_t Fraction)
1477 {
1478 register uint32_t tmp = (ShiftSecond | Fraction);
1479 WRITE_REG(RTCx->SHIFTR, tmp);
1480 }
1481
1482 /**
1483 * @}
1484 */
1485
1486 /** @defgroup RTC_LL_EF_Date Date
1487 * @{
1488 */
1489
1490 /**
1491 * @brief Set Year in BCD format
1492 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Year from binary to BCD format
1493 * @rmtoll RTC_DR YT LL_RTC_DATE_SetYear\n
1494 * RTC_DR YU LL_RTC_DATE_SetYear
1495 * @param RTCx RTC Instance
1496 * @param Year Value between Min_Data=0x00 and Max_Data=0x99
1497 * @retval None
1498 */
1499 __STATIC_INLINE void LL_RTC_DATE_SetYear(RTC_TypeDef *RTCx, uint32_t Year)
1500 {
1501 MODIFY_REG(RTCx->DR, (RTC_DR_YT | RTC_DR_YU),
1502 (((Year & 0xF0U) << (RTC_DR_YT_Pos - 4U)) | ((Year & 0x0FU) << RTC_DR_YU_Pos)));
1503 }
1504
1505 /**
1506 * @brief Get Year in BCD format
1507 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1508 * before reading this bit
1509 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Year from BCD to Binary format
1510 * @rmtoll RTC_DR YT LL_RTC_DATE_GetYear\n
1511 * RTC_DR YU LL_RTC_DATE_GetYear
1512 * @param RTCx RTC Instance
1513 * @retval Value between Min_Data=0x00 and Max_Data=0x99
1514 */
1515 __STATIC_INLINE uint32_t LL_RTC_DATE_GetYear(RTC_TypeDef *RTCx)
1516 {
1517 return (uint32_t)((READ_BIT(RTCx->DR, (RTC_DR_YT | RTC_DR_YU))) >> RTC_DR_YU_Pos);
1518 }
1519
1520 /**
1521 * @brief Set Week day
1522 * @rmtoll RTC_DR WDU LL_RTC_DATE_SetWeekDay
1523 * @param RTCx RTC Instance
1524 * @param WeekDay This parameter can be one of the following values:
1525 * @arg @ref LL_RTC_WEEKDAY_MONDAY
1526 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
1527 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
1528 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
1529 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
1530 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
1531 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
1532 * @retval None
1533 */
1534 __STATIC_INLINE void LL_RTC_DATE_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
1535 {
1536 MODIFY_REG(RTCx->DR, RTC_DR_WDU, WeekDay << RTC_DR_WDU_Pos);
1537 }
1538
1539 /**
1540 * @brief Get Week day
1541 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1542 * before reading this bit
1543 * @rmtoll RTC_DR WDU LL_RTC_DATE_GetWeekDay
1544 * @param RTCx RTC Instance
1545 * @retval Returned value can be one of the following values:
1546 * @arg @ref LL_RTC_WEEKDAY_MONDAY
1547 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
1548 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
1549 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
1550 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
1551 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
1552 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
1553 */
1554 __STATIC_INLINE uint32_t LL_RTC_DATE_GetWeekDay(RTC_TypeDef *RTCx)
1555 {
1556 return (uint32_t)(READ_BIT(RTCx->DR, RTC_DR_WDU) >> RTC_DR_WDU_Pos);
1557 }
1558
1559 /**
1560 * @brief Set Month in BCD format
1561 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Month from binary to BCD format
1562 * @rmtoll RTC_DR MT LL_RTC_DATE_SetMonth\n
1563 * RTC_DR MU LL_RTC_DATE_SetMonth
1564 * @param RTCx RTC Instance
1565 * @param Month This parameter can be one of the following values:
1566 * @arg @ref LL_RTC_MONTH_JANUARY
1567 * @arg @ref LL_RTC_MONTH_FEBRUARY
1568 * @arg @ref LL_RTC_MONTH_MARCH
1569 * @arg @ref LL_RTC_MONTH_APRIL
1570 * @arg @ref LL_RTC_MONTH_MAY
1571 * @arg @ref LL_RTC_MONTH_JUNE
1572 * @arg @ref LL_RTC_MONTH_JULY
1573 * @arg @ref LL_RTC_MONTH_AUGUST
1574 * @arg @ref LL_RTC_MONTH_SEPTEMBER
1575 * @arg @ref LL_RTC_MONTH_OCTOBER
1576 * @arg @ref LL_RTC_MONTH_NOVEMBER
1577 * @arg @ref LL_RTC_MONTH_DECEMBER
1578 * @retval None
1579 */
1580 __STATIC_INLINE void LL_RTC_DATE_SetMonth(RTC_TypeDef *RTCx, uint32_t Month)
1581 {
1582 MODIFY_REG(RTCx->DR, (RTC_DR_MT | RTC_DR_MU),
1583 (((Month & 0xF0U) << (RTC_DR_MT_Pos - 4U)) | ((Month & 0x0FU) << RTC_DR_MU_Pos)));
1584 }
1585
1586 /**
1587 * @brief Get Month in BCD format
1588 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1589 * before reading this bit
1590 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Month from BCD to Binary format
1591 * @rmtoll RTC_DR MT LL_RTC_DATE_GetMonth\n
1592 * RTC_DR MU LL_RTC_DATE_GetMonth
1593 * @param RTCx RTC Instance
1594 * @retval Returned value can be one of the following values:
1595 * @arg @ref LL_RTC_MONTH_JANUARY
1596 * @arg @ref LL_RTC_MONTH_FEBRUARY
1597 * @arg @ref LL_RTC_MONTH_MARCH
1598 * @arg @ref LL_RTC_MONTH_APRIL
1599 * @arg @ref LL_RTC_MONTH_MAY
1600 * @arg @ref LL_RTC_MONTH_JUNE
1601 * @arg @ref LL_RTC_MONTH_JULY
1602 * @arg @ref LL_RTC_MONTH_AUGUST
1603 * @arg @ref LL_RTC_MONTH_SEPTEMBER
1604 * @arg @ref LL_RTC_MONTH_OCTOBER
1605 * @arg @ref LL_RTC_MONTH_NOVEMBER
1606 * @arg @ref LL_RTC_MONTH_DECEMBER
1607 */
1608 __STATIC_INLINE uint32_t LL_RTC_DATE_GetMonth(RTC_TypeDef *RTCx)
1609 {
1610 return (uint32_t)((READ_BIT(RTCx->DR, (RTC_DR_MT | RTC_DR_MU))) >> RTC_DR_MU_Pos);
1611 }
1612
1613 /**
1614 * @brief Set Day in BCD format
1615 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Day from binary to BCD format
1616 * @rmtoll RTC_DR DT LL_RTC_DATE_SetDay\n
1617 * RTC_DR DU LL_RTC_DATE_SetDay
1618 * @param RTCx RTC Instance
1619 * @param Day Value between Min_Data=0x01 and Max_Data=0x31
1620 * @retval None
1621 */
1622 __STATIC_INLINE void LL_RTC_DATE_SetDay(RTC_TypeDef *RTCx, uint32_t Day)
1623 {
1624 MODIFY_REG(RTCx->DR, (RTC_DR_DT | RTC_DR_DU),
1625 (((Day & 0xF0U) << (RTC_DR_DT_Pos - 4U)) | ((Day & 0x0FU) << RTC_DR_DU_Pos)));
1626 }
1627
1628 /**
1629 * @brief Get Day in BCD format
1630 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1631 * before reading this bit
1632 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Day from BCD to Binary format
1633 * @rmtoll RTC_DR DT LL_RTC_DATE_GetDay\n
1634 * RTC_DR DU LL_RTC_DATE_GetDay
1635 * @param RTCx RTC Instance
1636 * @retval Value between Min_Data=0x01 and Max_Data=0x31
1637 */
1638 __STATIC_INLINE uint32_t LL_RTC_DATE_GetDay(RTC_TypeDef *RTCx)
1639 {
1640 return (uint32_t)((READ_BIT(RTCx->DR, (RTC_DR_DT | RTC_DR_DU))) >> RTC_DR_DU_Pos);
1641 }
1642
1643 /**
1644 * @brief Set date (WeekDay, Day, Month and Year) in BCD format
1645 * @rmtoll RTC_DR WDU LL_RTC_DATE_Config\n
1646 * RTC_DR MT LL_RTC_DATE_Config\n
1647 * RTC_DR MU LL_RTC_DATE_Config\n
1648 * RTC_DR DT LL_RTC_DATE_Config\n
1649 * RTC_DR DU LL_RTC_DATE_Config\n
1650 * RTC_DR YT LL_RTC_DATE_Config\n
1651 * RTC_DR YU LL_RTC_DATE_Config
1652 * @param RTCx RTC Instance
1653 * @param WeekDay This parameter can be one of the following values:
1654 * @arg @ref LL_RTC_WEEKDAY_MONDAY
1655 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
1656 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
1657 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
1658 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
1659 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
1660 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
1661 * @param Day Value between Min_Data=0x01 and Max_Data=0x31
1662 * @param Month This parameter can be one of the following values:
1663 * @arg @ref LL_RTC_MONTH_JANUARY
1664 * @arg @ref LL_RTC_MONTH_FEBRUARY
1665 * @arg @ref LL_RTC_MONTH_MARCH
1666 * @arg @ref LL_RTC_MONTH_APRIL
1667 * @arg @ref LL_RTC_MONTH_MAY
1668 * @arg @ref LL_RTC_MONTH_JUNE
1669 * @arg @ref LL_RTC_MONTH_JULY
1670 * @arg @ref LL_RTC_MONTH_AUGUST
1671 * @arg @ref LL_RTC_MONTH_SEPTEMBER
1672 * @arg @ref LL_RTC_MONTH_OCTOBER
1673 * @arg @ref LL_RTC_MONTH_NOVEMBER
1674 * @arg @ref LL_RTC_MONTH_DECEMBER
1675 * @param Year Value between Min_Data=0x00 and Max_Data=0x99
1676 * @retval None
1677 */
1678 __STATIC_INLINE void LL_RTC_DATE_Config(RTC_TypeDef *RTCx, uint32_t WeekDay, uint32_t Day, uint32_t Month,
1679 uint32_t Year)
1680 {
1681 register uint32_t temp;
1682
1683 temp = (WeekDay << RTC_DR_WDU_Pos) | \
1684 (((Year & 0xF0U) << (RTC_DR_YT_Pos - 4U)) | ((Year & 0x0FU) << RTC_DR_YU_Pos)) | \
1685 (((Month & 0xF0U) << (RTC_DR_MT_Pos - 4U)) | ((Month & 0x0FU) << RTC_DR_MU_Pos)) | \
1686 (((Day & 0xF0U) << (RTC_DR_DT_Pos - 4U)) | ((Day & 0x0FU) << RTC_DR_DU_Pos));
1687
1688 MODIFY_REG(RTCx->DR, (RTC_DR_WDU | RTC_DR_MT | RTC_DR_MU | RTC_DR_DT | RTC_DR_DU | RTC_DR_YT | RTC_DR_YU), temp);
1689 }
1690
1691 /**
1692 * @brief Get date (WeekDay, Day, Month and Year) in BCD format
1693 * @note if shadow mode is disabled (BYPSHAD=0), need to check if RSF flag is set
1694 * before reading this bit
1695 * @note helper macros __LL_RTC_GET_WEEKDAY, __LL_RTC_GET_YEAR, __LL_RTC_GET_MONTH,
1696 * and __LL_RTC_GET_DAY are available to get independently each parameter.
1697 * @rmtoll RTC_DR WDU LL_RTC_DATE_Get\n
1698 * RTC_DR MT LL_RTC_DATE_Get\n
1699 * RTC_DR MU LL_RTC_DATE_Get\n
1700 * RTC_DR DT LL_RTC_DATE_Get\n
1701 * RTC_DR DU LL_RTC_DATE_Get\n
1702 * RTC_DR YT LL_RTC_DATE_Get\n
1703 * RTC_DR YU LL_RTC_DATE_Get
1704 * @param RTCx RTC Instance
1705 * @retval Combination of WeekDay, Day, Month and Year (Format: 0xWWDDMMYY).
1706 */
1707 __STATIC_INLINE uint32_t LL_RTC_DATE_Get(RTC_TypeDef *RTCx)
1708 {
1709 register uint32_t temp;
1710
1711 temp = READ_BIT(RTCx->DR, (RTC_DR_WDU | RTC_DR_MT | RTC_DR_MU | RTC_DR_DT | RTC_DR_DU | RTC_DR_YT | RTC_DR_YU));
1712 return (uint32_t)((((temp & RTC_DR_WDU) >> RTC_DR_WDU_Pos) << RTC_OFFSET_WEEKDAY) | \
1713 (((((temp & RTC_DR_DT) >> RTC_DR_DT_Pos) << 4U) | ((temp & RTC_DR_DU) >> RTC_DR_DU_Pos)) << RTC_OFFSET_DAY) | \
1714 (((((temp & RTC_DR_MT) >> RTC_DR_MT_Pos) << 4U) | ((temp & RTC_DR_MU) >> RTC_DR_MU_Pos)) << RTC_OFFSET_MONTH) | \
1715 ((((temp & RTC_DR_YT) >> RTC_DR_YT_Pos) << 4U) | ((temp & RTC_DR_YU) >> RTC_DR_YU_Pos)));
1716 }
1717
1718 /**
1719 * @}
1720 */
1721
1722 /** @defgroup RTC_LL_EF_ALARMA ALARMA
1723 * @{
1724 */
1725
1726 /**
1727 * @brief Enable Alarm A
1728 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1729 * @rmtoll RTC_CR ALRAE LL_RTC_ALMA_Enable
1730 * @param RTCx RTC Instance
1731 * @retval None
1732 */
1733 __STATIC_INLINE void LL_RTC_ALMA_Enable(RTC_TypeDef *RTCx)
1734 {
1735 SET_BIT(RTCx->CR, RTC_CR_ALRAE);
1736 }
1737
1738 /**
1739 * @brief Disable Alarm A
1740 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
1741 * @rmtoll RTC_CR ALRAE LL_RTC_ALMA_Disable
1742 * @param RTCx RTC Instance
1743 * @retval None
1744 */
1745 __STATIC_INLINE void LL_RTC_ALMA_Disable(RTC_TypeDef *RTCx)
1746 {
1747 CLEAR_BIT(RTCx->CR, RTC_CR_ALRAE);
1748 }
1749
1750 /**
1751 * @brief Specify the Alarm A masks.
1752 * @rmtoll RTC_ALRMAR MSK4 LL_RTC_ALMA_SetMask\n
1753 * RTC_ALRMAR MSK3 LL_RTC_ALMA_SetMask\n
1754 * RTC_ALRMAR MSK2 LL_RTC_ALMA_SetMask\n
1755 * RTC_ALRMAR MSK1 LL_RTC_ALMA_SetMask
1756 * @param RTCx RTC Instance
1757 * @param Mask This parameter can be a combination of the following values:
1758 * @arg @ref LL_RTC_ALMA_MASK_NONE
1759 * @arg @ref LL_RTC_ALMA_MASK_DATEWEEKDAY
1760 * @arg @ref LL_RTC_ALMA_MASK_HOURS
1761 * @arg @ref LL_RTC_ALMA_MASK_MINUTES
1762 * @arg @ref LL_RTC_ALMA_MASK_SECONDS
1763 * @arg @ref LL_RTC_ALMA_MASK_ALL
1764 * @retval None
1765 */
1766 __STATIC_INLINE void LL_RTC_ALMA_SetMask(RTC_TypeDef *RTCx, uint32_t Mask)
1767 {
1768 MODIFY_REG(RTCx->ALRMAR, RTC_ALRMAR_MSK4 | RTC_ALRMAR_MSK3 | RTC_ALRMAR_MSK2 | RTC_ALRMAR_MSK1, Mask);
1769 }
1770
1771 /**
1772 * @brief Get the Alarm A masks.
1773 * @rmtoll RTC_ALRMAR MSK4 LL_RTC_ALMA_GetMask\n
1774 * RTC_ALRMAR MSK3 LL_RTC_ALMA_GetMask\n
1775 * RTC_ALRMAR MSK2 LL_RTC_ALMA_GetMask\n
1776 * RTC_ALRMAR MSK1 LL_RTC_ALMA_GetMask
1777 * @param RTCx RTC Instance
1778 * @retval Returned value can be can be a combination of the following values:
1779 * @arg @ref LL_RTC_ALMA_MASK_NONE
1780 * @arg @ref LL_RTC_ALMA_MASK_DATEWEEKDAY
1781 * @arg @ref LL_RTC_ALMA_MASK_HOURS
1782 * @arg @ref LL_RTC_ALMA_MASK_MINUTES
1783 * @arg @ref LL_RTC_ALMA_MASK_SECONDS
1784 * @arg @ref LL_RTC_ALMA_MASK_ALL
1785 */
1786 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetMask(RTC_TypeDef *RTCx)
1787 {
1788 return (uint32_t)(READ_BIT(RTCx->ALRMAR, RTC_ALRMAR_MSK4 | RTC_ALRMAR_MSK3 | RTC_ALRMAR_MSK2 | RTC_ALRMAR_MSK1));
1789 }
1790
1791 /**
1792 * @brief Enable AlarmA Week day selection (DU[3:0] represents the week day. DT[1:0] is do not care)
1793 * @rmtoll RTC_ALRMAR WDSEL LL_RTC_ALMA_EnableWeekday
1794 * @param RTCx RTC Instance
1795 * @retval None
1796 */
1797 __STATIC_INLINE void LL_RTC_ALMA_EnableWeekday(RTC_TypeDef *RTCx)
1798 {
1799 SET_BIT(RTCx->ALRMAR, RTC_ALRMAR_WDSEL);
1800 }
1801
1802 /**
1803 * @brief Disable AlarmA Week day selection (DU[3:0] represents the date )
1804 * @rmtoll RTC_ALRMAR WDSEL LL_RTC_ALMA_DisableWeekday
1805 * @param RTCx RTC Instance
1806 * @retval None
1807 */
1808 __STATIC_INLINE void LL_RTC_ALMA_DisableWeekday(RTC_TypeDef *RTCx)
1809 {
1810 CLEAR_BIT(RTCx->ALRMAR, RTC_ALRMAR_WDSEL);
1811 }
1812
1813 /**
1814 * @brief Set ALARM A Day in BCD format
1815 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Day from binary to BCD format
1816 * @rmtoll RTC_ALRMAR DT LL_RTC_ALMA_SetDay\n
1817 * RTC_ALRMAR DU LL_RTC_ALMA_SetDay
1818 * @param RTCx RTC Instance
1819 * @param Day Value between Min_Data=0x01 and Max_Data=0x31
1820 * @retval None
1821 */
1822 __STATIC_INLINE void LL_RTC_ALMA_SetDay(RTC_TypeDef *RTCx, uint32_t Day)
1823 {
1824 MODIFY_REG(RTCx->ALRMAR, (RTC_ALRMAR_DT | RTC_ALRMAR_DU),
1825 (((Day & 0xF0U) << (RTC_ALRMAR_DT_Pos - 4U)) | ((Day & 0x0FU) << RTC_ALRMAR_DU_Pos)));
1826 }
1827
1828 /**
1829 * @brief Get ALARM A Day in BCD format
1830 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Day from BCD to Binary format
1831 * @rmtoll RTC_ALRMAR DT LL_RTC_ALMA_GetDay\n
1832 * RTC_ALRMAR DU LL_RTC_ALMA_GetDay
1833 * @param RTCx RTC Instance
1834 * @retval Value between Min_Data=0x01 and Max_Data=0x31
1835 */
1836 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetDay(RTC_TypeDef *RTCx)
1837 {
1838 return (uint32_t)((READ_BIT(RTCx->ALRMAR, (RTC_ALRMAR_DT | RTC_ALRMAR_DU))) >> RTC_ALRMAR_DU_Pos);
1839 }
1840
1841 /**
1842 * @brief Set ALARM A Weekday
1843 * @rmtoll RTC_ALRMAR DU LL_RTC_ALMA_SetWeekDay
1844 * @param RTCx RTC Instance
1845 * @param WeekDay This parameter can be one of the following values:
1846 * @arg @ref LL_RTC_WEEKDAY_MONDAY
1847 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
1848 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
1849 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
1850 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
1851 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
1852 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
1853 * @retval None
1854 */
1855 __STATIC_INLINE void LL_RTC_ALMA_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
1856 {
1857 MODIFY_REG(RTCx->ALRMAR, RTC_ALRMAR_DU, WeekDay << RTC_ALRMAR_DU_Pos);
1858 }
1859
1860 /**
1861 * @brief Get ALARM A Weekday
1862 * @rmtoll RTC_ALRMAR DU LL_RTC_ALMA_GetWeekDay
1863 * @param RTCx RTC Instance
1864 * @retval Returned value can be one of the following values:
1865 * @arg @ref LL_RTC_WEEKDAY_MONDAY
1866 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
1867 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
1868 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
1869 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
1870 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
1871 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
1872 */
1873 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetWeekDay(RTC_TypeDef *RTCx)
1874 {
1875 return (uint32_t)(READ_BIT(RTCx->ALRMAR, RTC_ALRMAR_DU) >> RTC_ALRMAR_DU_Pos);
1876 }
1877
1878 /**
1879 * @brief Set Alarm A time format (AM/24-hour or PM notation)
1880 * @rmtoll RTC_ALRMAR PM LL_RTC_ALMA_SetTimeFormat
1881 * @param RTCx RTC Instance
1882 * @param TimeFormat This parameter can be one of the following values:
1883 * @arg @ref LL_RTC_ALMA_TIME_FORMAT_AM
1884 * @arg @ref LL_RTC_ALMA_TIME_FORMAT_PM
1885 * @retval None
1886 */
1887 __STATIC_INLINE void LL_RTC_ALMA_SetTimeFormat(RTC_TypeDef *RTCx, uint32_t TimeFormat)
1888 {
1889 MODIFY_REG(RTCx->ALRMAR, RTC_ALRMAR_PM, TimeFormat);
1890 }
1891
1892 /**
1893 * @brief Get Alarm A time format (AM or PM notation)
1894 * @rmtoll RTC_ALRMAR PM LL_RTC_ALMA_GetTimeFormat
1895 * @param RTCx RTC Instance
1896 * @retval Returned value can be one of the following values:
1897 * @arg @ref LL_RTC_ALMA_TIME_FORMAT_AM
1898 * @arg @ref LL_RTC_ALMA_TIME_FORMAT_PM
1899 */
1900 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetTimeFormat(RTC_TypeDef *RTCx)
1901 {
1902 return (uint32_t)(READ_BIT(RTCx->ALRMAR, RTC_ALRMAR_PM));
1903 }
1904
1905 /**
1906 * @brief Set ALARM A Hours in BCD format
1907 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Hours from binary to BCD format
1908 * @rmtoll RTC_ALRMAR HT LL_RTC_ALMA_SetHour\n
1909 * RTC_ALRMAR HU LL_RTC_ALMA_SetHour
1910 * @param RTCx RTC Instance
1911 * @param Hours Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
1912 * @retval None
1913 */
1914 __STATIC_INLINE void LL_RTC_ALMA_SetHour(RTC_TypeDef *RTCx, uint32_t Hours)
1915 {
1916 MODIFY_REG(RTCx->ALRMAR, (RTC_ALRMAR_HT | RTC_ALRMAR_HU),
1917 (((Hours & 0xF0U) << (RTC_ALRMAR_HT_Pos - 4U)) | ((Hours & 0x0FU) << RTC_ALRMAR_HU_Pos)));
1918 }
1919
1920 /**
1921 * @brief Get ALARM A Hours in BCD format
1922 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Hours from BCD to Binary format
1923 * @rmtoll RTC_ALRMAR HT LL_RTC_ALMA_GetHour\n
1924 * RTC_ALRMAR HU LL_RTC_ALMA_GetHour
1925 * @param RTCx RTC Instance
1926 * @retval Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
1927 */
1928 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetHour(RTC_TypeDef *RTCx)
1929 {
1930 return (uint32_t)((READ_BIT(RTCx->ALRMAR, (RTC_ALRMAR_HT | RTC_ALRMAR_HU))) >> RTC_ALRMAR_HU_Pos);
1931 }
1932
1933 /**
1934 * @brief Set ALARM A Minutes in BCD format
1935 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Minutes from binary to BCD format
1936 * @rmtoll RTC_ALRMAR MNT LL_RTC_ALMA_SetMinute\n
1937 * RTC_ALRMAR MNU LL_RTC_ALMA_SetMinute
1938 * @param RTCx RTC Instance
1939 * @param Minutes Value between Min_Data=0x00 and Max_Data=0x59
1940 * @retval None
1941 */
1942 __STATIC_INLINE void LL_RTC_ALMA_SetMinute(RTC_TypeDef *RTCx, uint32_t Minutes)
1943 {
1944 MODIFY_REG(RTCx->ALRMAR, (RTC_ALRMAR_MNT | RTC_ALRMAR_MNU),
1945 (((Minutes & 0xF0U) << (RTC_ALRMAR_MNT_Pos - 4U)) | ((Minutes & 0x0FU) << RTC_ALRMAR_MNU_Pos)));
1946 }
1947
1948 /**
1949 * @brief Get ALARM A Minutes in BCD format
1950 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Minutes from BCD to Binary format
1951 * @rmtoll RTC_ALRMAR MNT LL_RTC_ALMA_GetMinute\n
1952 * RTC_ALRMAR MNU LL_RTC_ALMA_GetMinute
1953 * @param RTCx RTC Instance
1954 * @retval Value between Min_Data=0x00 and Max_Data=0x59
1955 */
1956 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetMinute(RTC_TypeDef *RTCx)
1957 {
1958 return (uint32_t)((READ_BIT(RTCx->ALRMAR, (RTC_ALRMAR_MNT | RTC_ALRMAR_MNU))) >> RTC_ALRMAR_MNU_Pos);
1959 }
1960
1961 /**
1962 * @brief Set ALARM A Seconds in BCD format
1963 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Seconds from binary to BCD format
1964 * @rmtoll RTC_ALRMAR ST LL_RTC_ALMA_SetSecond\n
1965 * RTC_ALRMAR SU LL_RTC_ALMA_SetSecond
1966 * @param RTCx RTC Instance
1967 * @param Seconds Value between Min_Data=0x00 and Max_Data=0x59
1968 * @retval None
1969 */
1970 __STATIC_INLINE void LL_RTC_ALMA_SetSecond(RTC_TypeDef *RTCx, uint32_t Seconds)
1971 {
1972 MODIFY_REG(RTCx->ALRMAR, (RTC_ALRMAR_ST | RTC_ALRMAR_SU),
1973 (((Seconds & 0xF0U) << (RTC_ALRMAR_ST_Pos - 4U)) | ((Seconds & 0x0FU) << RTC_ALRMAR_SU_Pos)));
1974 }
1975
1976 /**
1977 * @brief Get ALARM A Seconds in BCD format
1978 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Seconds from BCD to Binary format
1979 * @rmtoll RTC_ALRMAR ST LL_RTC_ALMA_GetSecond\n
1980 * RTC_ALRMAR SU LL_RTC_ALMA_GetSecond
1981 * @param RTCx RTC Instance
1982 * @retval Value between Min_Data=0x00 and Max_Data=0x59
1983 */
1984 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetSecond(RTC_TypeDef *RTCx)
1985 {
1986 return (uint32_t)((READ_BIT(RTCx->ALRMAR, (RTC_ALRMAR_ST | RTC_ALRMAR_SU))) >> RTC_ALRMAR_SU_Pos);
1987 }
1988
1989 /**
1990 * @brief Set Alarm A Time (hour, minute and second) in BCD format
1991 * @rmtoll RTC_ALRMAR PM LL_RTC_ALMA_ConfigTime\n
1992 * RTC_ALRMAR HT LL_RTC_ALMA_ConfigTime\n
1993 * RTC_ALRMAR HU LL_RTC_ALMA_ConfigTime\n
1994 * RTC_ALRMAR MNT LL_RTC_ALMA_ConfigTime\n
1995 * RTC_ALRMAR MNU LL_RTC_ALMA_ConfigTime\n
1996 * RTC_ALRMAR ST LL_RTC_ALMA_ConfigTime\n
1997 * RTC_ALRMAR SU LL_RTC_ALMA_ConfigTime
1998 * @param RTCx RTC Instance
1999 * @param Format12_24 This parameter can be one of the following values:
2000 * @arg @ref LL_RTC_ALMA_TIME_FORMAT_AM
2001 * @arg @ref LL_RTC_ALMA_TIME_FORMAT_PM
2002 * @param Hours Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
2003 * @param Minutes Value between Min_Data=0x00 and Max_Data=0x59
2004 * @param Seconds Value between Min_Data=0x00 and Max_Data=0x59
2005 * @retval None
2006 */
2007 __STATIC_INLINE void LL_RTC_ALMA_ConfigTime(RTC_TypeDef *RTCx, uint32_t Format12_24, uint32_t Hours, uint32_t Minutes,
2008 uint32_t Seconds)
2009 {
2010 register uint32_t temp;
2011
2012 temp = Format12_24 | (((Hours & 0xF0U) << (RTC_ALRMAR_HT_Pos - 4U)) | ((Hours & 0x0FU) << RTC_ALRMAR_HU_Pos)) | \
2013 (((Minutes & 0xF0U) << (RTC_ALRMAR_MNT_Pos - 4U)) | ((Minutes & 0x0FU) << RTC_ALRMAR_MNU_Pos)) | \
2014 (((Seconds & 0xF0U) << (RTC_ALRMAR_ST_Pos - 4U)) | ((Seconds & 0x0FU) << RTC_ALRMAR_SU_Pos));
2015
2016 MODIFY_REG(RTCx->ALRMAR, RTC_ALRMAR_PM | RTC_ALRMAR_HT | RTC_ALRMAR_HU | RTC_ALRMAR_MNT | RTC_ALRMAR_MNU | RTC_ALRMAR_ST
2017 | RTC_ALRMAR_SU, temp);
2018 }
2019
2020 /**
2021 * @brief Get Alarm B Time (hour, minute and second) in BCD format
2022 * @note helper macros __LL_RTC_GET_HOUR, __LL_RTC_GET_MINUTE and __LL_RTC_GET_SECOND
2023 * are available to get independently each parameter.
2024 * @rmtoll RTC_ALRMAR HT LL_RTC_ALMA_GetTime\n
2025 * RTC_ALRMAR HU LL_RTC_ALMA_GetTime\n
2026 * RTC_ALRMAR MNT LL_RTC_ALMA_GetTime\n
2027 * RTC_ALRMAR MNU LL_RTC_ALMA_GetTime\n
2028 * RTC_ALRMAR ST LL_RTC_ALMA_GetTime\n
2029 * RTC_ALRMAR SU LL_RTC_ALMA_GetTime
2030 * @param RTCx RTC Instance
2031 * @retval Combination of hours, minutes and seconds.
2032 */
2033 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetTime(RTC_TypeDef *RTCx)
2034 {
2035 return (uint32_t)((LL_RTC_ALMA_GetHour(RTCx) << RTC_OFFSET_HOUR) | (LL_RTC_ALMA_GetMinute(RTCx) << RTC_OFFSET_MINUTE) | LL_RTC_ALMA_GetSecond(RTCx));
2036 }
2037
2038 /**
2039 * @brief Set Alarm A Mask the most-significant bits starting at this bit
2040 * @note This register can be written only when ALRAE is reset in RTC_CR register,
2041 * or in initialization mode.
2042 * @rmtoll RTC_ALRMASSR MASKSS LL_RTC_ALMA_SetSubSecondMask
2043 * @param RTCx RTC Instance
2044 * @param Mask Value between Min_Data=0x00 and Max_Data=0xF
2045 * @retval None
2046 */
2047 __STATIC_INLINE void LL_RTC_ALMA_SetSubSecondMask(RTC_TypeDef *RTCx, uint32_t Mask)
2048 {
2049 MODIFY_REG(RTCx->ALRMASSR, RTC_ALRMASSR_MASKSS, Mask << RTC_ALRMASSR_MASKSS_Pos);
2050 }
2051
2052 /**
2053 * @brief Get Alarm A Mask the most-significant bits starting at this bit
2054 * @rmtoll RTC_ALRMASSR MASKSS LL_RTC_ALMA_GetSubSecondMask
2055 * @param RTCx RTC Instance
2056 * @retval Value between Min_Data=0x00 and Max_Data=0xF
2057 */
2058 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetSubSecondMask(RTC_TypeDef *RTCx)
2059 {
2060 return (uint32_t)(READ_BIT(RTCx->ALRMASSR, RTC_ALRMASSR_MASKSS) >> RTC_ALRMASSR_MASKSS_Pos);
2061 }
2062
2063 /**
2064 * @brief Set Alarm A Sub seconds value
2065 * @rmtoll RCT_ALRMASSR SS LL_RTC_ALMA_SetSubSecond
2066 * @param RTCx RTC Instance
2067 * @param Subsecond Value between Min_Data=0x00 and Max_Data=0x7FFF
2068 * @retval None
2069 */
2070 __STATIC_INLINE void LL_RTC_ALMA_SetSubSecond(RTC_TypeDef *RTCx, uint32_t Subsecond)
2071 {
2072 MODIFY_REG(RTCx->ALRMASSR, RTC_ALRMASSR_SS, Subsecond);
2073 }
2074
2075 /**
2076 * @brief Get Alarm A Sub seconds value
2077 * @rmtoll RCT_ALRMASSR SS LL_RTC_ALMA_GetSubSecond
2078 * @param RTCx RTC Instance
2079 * @retval Value between Min_Data=0x00 and Max_Data=0x7FFF
2080 */
2081 __STATIC_INLINE uint32_t LL_RTC_ALMA_GetSubSecond(RTC_TypeDef *RTCx)
2082 {
2083 return (uint32_t)(READ_BIT(RTCx->ALRMASSR, RTC_ALRMASSR_SS));
2084 }
2085
2086 /**
2087 * @}
2088 */
2089
2090 /** @defgroup RTC_LL_EF_ALARMB ALARMB
2091 * @{
2092 */
2093
2094 /**
2095 * @brief Enable Alarm B
2096 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2097 * @rmtoll RTC_CR ALRBE LL_RTC_ALMB_Enable
2098 * @param RTCx RTC Instance
2099 * @retval None
2100 */
2101 __STATIC_INLINE void LL_RTC_ALMB_Enable(RTC_TypeDef *RTCx)
2102 {
2103 SET_BIT(RTCx->CR, RTC_CR_ALRBE);
2104 }
2105
2106 /**
2107 * @brief Disable Alarm B
2108 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2109 * @rmtoll RTC_CR ALRBE LL_RTC_ALMB_Disable
2110 * @param RTCx RTC Instance
2111 * @retval None
2112 */
2113 __STATIC_INLINE void LL_RTC_ALMB_Disable(RTC_TypeDef *RTCx)
2114 {
2115 CLEAR_BIT(RTCx->CR, RTC_CR_ALRBE);
2116 }
2117
2118 /**
2119 * @brief Specify the Alarm B masks.
2120 * @rmtoll RTC_ALRMBR MSK4 LL_RTC_ALMB_SetMask\n
2121 * RTC_ALRMBR MSK3 LL_RTC_ALMB_SetMask\n
2122 * RTC_ALRMBR MSK2 LL_RTC_ALMB_SetMask\n
2123 * RTC_ALRMBR MSK1 LL_RTC_ALMB_SetMask
2124 * @param RTCx RTC Instance
2125 * @param Mask This parameter can be a combination of the following values:
2126 * @arg @ref LL_RTC_ALMB_MASK_NONE
2127 * @arg @ref LL_RTC_ALMB_MASK_DATEWEEKDAY
2128 * @arg @ref LL_RTC_ALMB_MASK_HOURS
2129 * @arg @ref LL_RTC_ALMB_MASK_MINUTES
2130 * @arg @ref LL_RTC_ALMB_MASK_SECONDS
2131 * @arg @ref LL_RTC_ALMB_MASK_ALL
2132 * @retval None
2133 */
2134 __STATIC_INLINE void LL_RTC_ALMB_SetMask(RTC_TypeDef *RTCx, uint32_t Mask)
2135 {
2136 MODIFY_REG(RTCx->ALRMBR, RTC_ALRMBR_MSK4 | RTC_ALRMBR_MSK3 | RTC_ALRMBR_MSK2 | RTC_ALRMBR_MSK1, Mask);
2137 }
2138
2139 /**
2140 * @brief Get the Alarm B masks.
2141 * @rmtoll RTC_ALRMBR MSK4 LL_RTC_ALMB_GetMask\n
2142 * RTC_ALRMBR MSK3 LL_RTC_ALMB_GetMask\n
2143 * RTC_ALRMBR MSK2 LL_RTC_ALMB_GetMask\n
2144 * RTC_ALRMBR MSK1 LL_RTC_ALMB_GetMask
2145 * @param RTCx RTC Instance
2146 * @retval Returned value can be can be a combination of the following values:
2147 * @arg @ref LL_RTC_ALMB_MASK_NONE
2148 * @arg @ref LL_RTC_ALMB_MASK_DATEWEEKDAY
2149 * @arg @ref LL_RTC_ALMB_MASK_HOURS
2150 * @arg @ref LL_RTC_ALMB_MASK_MINUTES
2151 * @arg @ref LL_RTC_ALMB_MASK_SECONDS
2152 * @arg @ref LL_RTC_ALMB_MASK_ALL
2153 */
2154 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetMask(RTC_TypeDef *RTCx)
2155 {
2156 return (uint32_t)(READ_BIT(RTCx->ALRMBR, RTC_ALRMBR_MSK4 | RTC_ALRMBR_MSK3 | RTC_ALRMBR_MSK2 | RTC_ALRMBR_MSK1));
2157 }
2158
2159 /**
2160 * @brief Enable AlarmB Week day selection (DU[3:0] represents the week day. DT[1:0] is do not care)
2161 * @rmtoll RTC_ALRMBR WDSEL LL_RTC_ALMB_EnableWeekday
2162 * @param RTCx RTC Instance
2163 * @retval None
2164 */
2165 __STATIC_INLINE void LL_RTC_ALMB_EnableWeekday(RTC_TypeDef *RTCx)
2166 {
2167 SET_BIT(RTCx->ALRMBR, RTC_ALRMBR_WDSEL);
2168 }
2169
2170 /**
2171 * @brief Disable AlarmB Week day selection (DU[3:0] represents the date )
2172 * @rmtoll RTC_ALRMBR WDSEL LL_RTC_ALMB_DisableWeekday
2173 * @param RTCx RTC Instance
2174 * @retval None
2175 */
2176 __STATIC_INLINE void LL_RTC_ALMB_DisableWeekday(RTC_TypeDef *RTCx)
2177 {
2178 CLEAR_BIT(RTCx->ALRMBR, RTC_ALRMBR_WDSEL);
2179 }
2180
2181 /**
2182 * @brief Set ALARM B Day in BCD format
2183 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Day from binary to BCD format
2184 * @rmtoll RTC_ALRMBR DT LL_RTC_ALMB_SetDay\n
2185 * RTC_ALRMBR DU LL_RTC_ALMB_SetDay
2186 * @param RTCx RTC Instance
2187 * @param Day Value between Min_Data=0x01 and Max_Data=0x31
2188 * @retval None
2189 */
2190 __STATIC_INLINE void LL_RTC_ALMB_SetDay(RTC_TypeDef *RTCx, uint32_t Day)
2191 {
2192 MODIFY_REG(RTCx->ALRMBR, (RTC_ALRMBR_DT | RTC_ALRMBR_DU),
2193 (((Day & 0xF0U) << (RTC_ALRMBR_DT_Pos - 4U)) | ((Day & 0x0FU) << RTC_ALRMBR_DU_Pos)));
2194 }
2195
2196 /**
2197 * @brief Get ALARM B Day in BCD format
2198 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Day from BCD to Binary format
2199 * @rmtoll RTC_ALRMBR DT LL_RTC_ALMB_GetDay\n
2200 * RTC_ALRMBR DU LL_RTC_ALMB_GetDay
2201 * @param RTCx RTC Instance
2202 * @retval Value between Min_Data=0x01 and Max_Data=0x31
2203 */
2204 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetDay(RTC_TypeDef *RTCx)
2205 {
2206 return (uint32_t)((READ_BIT(RTCx->ALRMBR, (RTC_ALRMBR_DT | RTC_ALRMBR_DU))) >> RTC_ALRMBR_DU_Pos);
2207 }
2208
2209 /**
2210 * @brief Set ALARM B Weekday
2211 * @rmtoll RTC_ALRMBR DU LL_RTC_ALMB_SetWeekDay
2212 * @param RTCx RTC Instance
2213 * @param WeekDay This parameter can be one of the following values:
2214 * @arg @ref LL_RTC_WEEKDAY_MONDAY
2215 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
2216 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
2217 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
2218 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
2219 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
2220 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
2221 * @retval None
2222 */
2223 __STATIC_INLINE void LL_RTC_ALMB_SetWeekDay(RTC_TypeDef *RTCx, uint32_t WeekDay)
2224 {
2225 MODIFY_REG(RTCx->ALRMBR, RTC_ALRMBR_DU, WeekDay << RTC_ALRMBR_DU_Pos);
2226 }
2227
2228 /**
2229 * @brief Get ALARM B Weekday
2230 * @rmtoll RTC_ALRMBR DU LL_RTC_ALMB_GetWeekDay
2231 * @param RTCx RTC Instance
2232 * @retval Returned value can be one of the following values:
2233 * @arg @ref LL_RTC_WEEKDAY_MONDAY
2234 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
2235 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
2236 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
2237 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
2238 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
2239 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
2240 */
2241 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetWeekDay(RTC_TypeDef *RTCx)
2242 {
2243 return (uint32_t)(READ_BIT(RTCx->ALRMBR, RTC_ALRMBR_DU) >> RTC_ALRMBR_DU_Pos);
2244 }
2245
2246 /**
2247 * @brief Set ALARM B time format (AM/24-hour or PM notation)
2248 * @rmtoll RTC_ALRMBR PM LL_RTC_ALMB_SetTimeFormat
2249 * @param RTCx RTC Instance
2250 * @param TimeFormat This parameter can be one of the following values:
2251 * @arg @ref LL_RTC_ALMB_TIME_FORMAT_AM
2252 * @arg @ref LL_RTC_ALMB_TIME_FORMAT_PM
2253 * @retval None
2254 */
2255 __STATIC_INLINE void LL_RTC_ALMB_SetTimeFormat(RTC_TypeDef *RTCx, uint32_t TimeFormat)
2256 {
2257 MODIFY_REG(RTCx->ALRMBR, RTC_ALRMBR_PM, TimeFormat);
2258 }
2259
2260 /**
2261 * @brief Get ALARM B time format (AM or PM notation)
2262 * @rmtoll RTC_ALRMBR PM LL_RTC_ALMB_GetTimeFormat
2263 * @param RTCx RTC Instance
2264 * @retval Returned value can be one of the following values:
2265 * @arg @ref LL_RTC_ALMB_TIME_FORMAT_AM
2266 * @arg @ref LL_RTC_ALMB_TIME_FORMAT_PM
2267 */
2268 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetTimeFormat(RTC_TypeDef *RTCx)
2269 {
2270 return (uint32_t)(READ_BIT(RTCx->ALRMBR, RTC_ALRMBR_PM));
2271 }
2272
2273 /**
2274 * @brief Set ALARM B Hours in BCD format
2275 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Hours from binary to BCD format
2276 * @rmtoll RTC_ALRMBR HT LL_RTC_ALMB_SetHour\n
2277 * RTC_ALRMBR HU LL_RTC_ALMB_SetHour
2278 * @param RTCx RTC Instance
2279 * @param Hours Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
2280 * @retval None
2281 */
2282 __STATIC_INLINE void LL_RTC_ALMB_SetHour(RTC_TypeDef *RTCx, uint32_t Hours)
2283 {
2284 MODIFY_REG(RTCx->ALRMBR, (RTC_ALRMBR_HT | RTC_ALRMBR_HU),
2285 (((Hours & 0xF0U) << (RTC_ALRMBR_HT_Pos - 4U)) | ((Hours & 0x0FU) << RTC_ALRMBR_HU_Pos)));
2286 }
2287
2288 /**
2289 * @brief Get ALARM B Hours in BCD format
2290 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Hours from BCD to Binary format
2291 * @rmtoll RTC_ALRMBR HT LL_RTC_ALMB_GetHour\n
2292 * RTC_ALRMBR HU LL_RTC_ALMB_GetHour
2293 * @param RTCx RTC Instance
2294 * @retval Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
2295 */
2296 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetHour(RTC_TypeDef *RTCx)
2297 {
2298 return (uint32_t)((READ_BIT(RTCx->ALRMBR, (RTC_ALRMBR_HT | RTC_ALRMBR_HU))) >> RTC_ALRMBR_HU_Pos);
2299 }
2300
2301 /**
2302 * @brief Set ALARM B Minutes in BCD format
2303 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Minutes from binary to BCD format
2304 * @rmtoll RTC_ALRMBR MNT LL_RTC_ALMB_SetMinute\n
2305 * RTC_ALRMBR MNU LL_RTC_ALMB_SetMinute
2306 * @param RTCx RTC Instance
2307 * @param Minutes between Min_Data=0x00 and Max_Data=0x59
2308 * @retval None
2309 */
2310 __STATIC_INLINE void LL_RTC_ALMB_SetMinute(RTC_TypeDef *RTCx, uint32_t Minutes)
2311 {
2312 MODIFY_REG(RTCx->ALRMBR, (RTC_ALRMBR_MNT | RTC_ALRMBR_MNU),
2313 (((Minutes & 0xF0U) << (RTC_ALRMBR_MNT_Pos - 4U)) | ((Minutes & 0x0FU) << RTC_ALRMBR_MNU_Pos)));
2314 }
2315
2316 /**
2317 * @brief Get ALARM B Minutes in BCD format
2318 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Minutes from BCD to Binary format
2319 * @rmtoll RTC_ALRMBR MNT LL_RTC_ALMB_GetMinute\n
2320 * RTC_ALRMBR MNU LL_RTC_ALMB_GetMinute
2321 * @param RTCx RTC Instance
2322 * @retval Value between Min_Data=0x00 and Max_Data=0x59
2323 */
2324 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetMinute(RTC_TypeDef *RTCx)
2325 {
2326 return (uint32_t)((READ_BIT(RTCx->ALRMBR, (RTC_ALRMBR_MNT | RTC_ALRMBR_MNU))) >> RTC_ALRMBR_MNU_Pos);
2327 }
2328
2329 /**
2330 * @brief Set ALARM B Seconds in BCD format
2331 * @note helper macro __LL_RTC_CONVERT_BIN2BCD is available to convert Seconds from binary to BCD format
2332 * @rmtoll RTC_ALRMBR ST LL_RTC_ALMB_SetSecond\n
2333 * RTC_ALRMBR SU LL_RTC_ALMB_SetSecond
2334 * @param RTCx RTC Instance
2335 * @param Seconds Value between Min_Data=0x00 and Max_Data=0x59
2336 * @retval None
2337 */
2338 __STATIC_INLINE void LL_RTC_ALMB_SetSecond(RTC_TypeDef *RTCx, uint32_t Seconds)
2339 {
2340 MODIFY_REG(RTCx->ALRMBR, (RTC_ALRMBR_ST | RTC_ALRMBR_SU),
2341 (((Seconds & 0xF0U) << (RTC_ALRMBR_ST_Pos - 4U)) | ((Seconds & 0x0FU) << RTC_ALRMBR_SU_Pos)));
2342 }
2343
2344 /**
2345 * @brief Get ALARM B Seconds in BCD format
2346 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Seconds from BCD to Binary format
2347 * @rmtoll RTC_ALRMBR ST LL_RTC_ALMB_GetSecond\n
2348 * RTC_ALRMBR SU LL_RTC_ALMB_GetSecond
2349 * @param RTCx RTC Instance
2350 * @retval Value between Min_Data=0x00 and Max_Data=0x59
2351 */
2352 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetSecond(RTC_TypeDef *RTCx)
2353 {
2354 return (uint32_t)((READ_BIT(RTCx->ALRMBR, (RTC_ALRMBR_ST | RTC_ALRMBR_SU))) >> RTC_ALRMBR_SU_Pos);
2355 }
2356
2357 /**
2358 * @brief Set Alarm B Time (hour, minute and second) in BCD format
2359 * @rmtoll RTC_ALRMBR PM LL_RTC_ALMB_ConfigTime\n
2360 * RTC_ALRMBR HT LL_RTC_ALMB_ConfigTime\n
2361 * RTC_ALRMBR HU LL_RTC_ALMB_ConfigTime\n
2362 * RTC_ALRMBR MNT LL_RTC_ALMB_ConfigTime\n
2363 * RTC_ALRMBR MNU LL_RTC_ALMB_ConfigTime\n
2364 * RTC_ALRMBR ST LL_RTC_ALMB_ConfigTime\n
2365 * RTC_ALRMBR SU LL_RTC_ALMB_ConfigTime
2366 * @param RTCx RTC Instance
2367 * @param Format12_24 This parameter can be one of the following values:
2368 * @arg @ref LL_RTC_ALMB_TIME_FORMAT_AM
2369 * @arg @ref LL_RTC_ALMB_TIME_FORMAT_PM
2370 * @param Hours Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
2371 * @param Minutes Value between Min_Data=0x00 and Max_Data=0x59
2372 * @param Seconds Value between Min_Data=0x00 and Max_Data=0x59
2373 * @retval None
2374 */
2375 __STATIC_INLINE void LL_RTC_ALMB_ConfigTime(RTC_TypeDef *RTCx, uint32_t Format12_24, uint32_t Hours, uint32_t Minutes,
2376 uint32_t Seconds)
2377 {
2378 register uint32_t temp;
2379
2380 temp = Format12_24 | (((Hours & 0xF0U) << (RTC_ALRMBR_HT_Pos - 4U)) | ((Hours & 0x0FU) << RTC_ALRMBR_HU_Pos)) | \
2381 (((Minutes & 0xF0U) << (RTC_ALRMBR_MNT_Pos - 4U)) | ((Minutes & 0x0FU) << RTC_ALRMBR_MNU_Pos)) | \
2382 (((Seconds & 0xF0U) << (RTC_ALRMBR_ST_Pos - 4U)) | ((Seconds & 0x0FU) << RTC_ALRMBR_SU_Pos));
2383
2384 MODIFY_REG(RTCx->ALRMBR, RTC_ALRMBR_PM | RTC_ALRMBR_HT | RTC_ALRMBR_HU | RTC_ALRMBR_MNT | RTC_ALRMBR_MNU | RTC_ALRMBR_ST
2385 | RTC_ALRMBR_SU, temp);
2386 }
2387
2388 /**
2389 * @brief Get Alarm B Time (hour, minute and second) in BCD format
2390 * @note helper macros __LL_RTC_GET_HOUR, __LL_RTC_GET_MINUTE and __LL_RTC_GET_SECOND
2391 * are available to get independently each parameter.
2392 * @rmtoll RTC_ALRMBR HT LL_RTC_ALMB_GetTime\n
2393 * RTC_ALRMBR HU LL_RTC_ALMB_GetTime\n
2394 * RTC_ALRMBR MNT LL_RTC_ALMB_GetTime\n
2395 * RTC_ALRMBR MNU LL_RTC_ALMB_GetTime\n
2396 * RTC_ALRMBR ST LL_RTC_ALMB_GetTime\n
2397 * RTC_ALRMBR SU LL_RTC_ALMB_GetTime
2398 * @param RTCx RTC Instance
2399 * @retval Combination of hours, minutes and seconds.
2400 */
2401 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetTime(RTC_TypeDef *RTCx)
2402 {
2403 return (uint32_t)((LL_RTC_ALMB_GetHour(RTCx) << RTC_OFFSET_HOUR) | (LL_RTC_ALMB_GetMinute(RTCx) << RTC_OFFSET_MINUTE) | LL_RTC_ALMB_GetSecond(RTCx));
2404 }
2405
2406 /**
2407 * @brief Set Alarm B Mask the most-significant bits starting at this bit
2408 * @note This register can be written only when ALRBE is reset in RTC_CR register,
2409 * or in initialization mode.
2410 * @rmtoll RTC_ALRMBSSR MASKSS LL_RTC_ALMB_SetSubSecondMask
2411 * @param RTCx RTC Instance
2412 * @param Mask Value between Min_Data=0x00 and Max_Data=0xF
2413 * @retval None
2414 */
2415 __STATIC_INLINE void LL_RTC_ALMB_SetSubSecondMask(RTC_TypeDef *RTCx, uint32_t Mask)
2416 {
2417 MODIFY_REG(RTCx->ALRMBSSR, RTC_ALRMBSSR_MASKSS, Mask << RTC_ALRMBSSR_MASKSS_Pos);
2418 }
2419
2420 /**
2421 * @brief Get Alarm B Mask the most-significant bits starting at this bit
2422 * @rmtoll RTC_ALRMBSSR MASKSS LL_RTC_ALMB_GetSubSecondMask
2423 * @param RTCx RTC Instance
2424 * @retval Value between Min_Data=0x00 and Max_Data=0xF
2425 */
2426 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetSubSecondMask(RTC_TypeDef *RTCx)
2427 {
2428 return (uint32_t)(READ_BIT(RTCx->ALRMBSSR, RTC_ALRMBSSR_MASKSS) >> RTC_ALRMBSSR_MASKSS_Pos);
2429 }
2430
2431 /**
2432 * @brief Set Alarm B Sub seconds value
2433 * @rmtoll RTC_ALRMBSSR SS LL_RTC_ALMB_SetSubSecond
2434 * @param RTCx RTC Instance
2435 * @param Subsecond Value between Min_Data=0x00 and Max_Data=0x7FFF
2436 * @retval None
2437 */
2438 __STATIC_INLINE void LL_RTC_ALMB_SetSubSecond(RTC_TypeDef *RTCx, uint32_t Subsecond)
2439 {
2440 MODIFY_REG(RTCx->ALRMBSSR, RTC_ALRMBSSR_SS, Subsecond);
2441 }
2442
2443 /**
2444 * @brief Get Alarm B Sub seconds value
2445 * @rmtoll RTC_ALRMBSSR SS LL_RTC_ALMB_GetSubSecond
2446 * @param RTCx RTC Instance
2447 * @retval Value between Min_Data=0x00 and Max_Data=0x7FFF
2448 */
2449 __STATIC_INLINE uint32_t LL_RTC_ALMB_GetSubSecond(RTC_TypeDef *RTCx)
2450 {
2451 return (uint32_t)(READ_BIT(RTCx->ALRMBSSR, RTC_ALRMBSSR_SS));
2452 }
2453
2454 /**
2455 * @}
2456 */
2457
2458 /** @defgroup RTC_LL_EF_Timestamp Timestamp
2459 * @{
2460 */
2461
2462 /**
2463 * @brief Enable internal event timestamp
2464 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2465 * @rmtoll RTC_CR ITSE LL_RTC_TS_EnableInternalEvent
2466 * @param RTCx RTC Instance
2467 * @retval None
2468 */
2469 __STATIC_INLINE void LL_RTC_TS_EnableInternalEvent(RTC_TypeDef *RTCx)
2470 {
2471 SET_BIT(RTCx->CR, RTC_CR_ITSE);
2472 }
2473
2474 /**
2475 * @brief Disable internal event timestamp
2476 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2477 * @rmtoll RTC_CR ITSE LL_RTC_TS_DisableInternalEvent
2478 * @param RTCx RTC Instance
2479 * @retval None
2480 */
2481 __STATIC_INLINE void LL_RTC_TS_DisableInternalEvent(RTC_TypeDef *RTCx)
2482 {
2483 CLEAR_BIT(RTCx->CR, RTC_CR_ITSE);
2484 }
2485
2486 /**
2487 * @brief Enable Timestamp
2488 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2489 * @rmtoll RTC_CR ITSE LL_RTC_TS_Enable
2490 * @param RTCx RTC Instance
2491 * @retval None
2492 */
2493 __STATIC_INLINE void LL_RTC_TS_Enable(RTC_TypeDef *RTCx)
2494 {
2495 SET_BIT(RTCx->CR, RTC_CR_TSE);
2496 }
2497
2498 /**
2499 * @brief Disable Timestamp
2500 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2501 * @rmtoll RTC_CR ITSE LL_RTC_TS_Disable
2502 * @param RTCx RTC Instance
2503 * @retval None
2504 */
2505 __STATIC_INLINE void LL_RTC_TS_Disable(RTC_TypeDef *RTCx)
2506 {
2507 CLEAR_BIT(RTCx->CR, RTC_CR_TSE);
2508 }
2509
2510 /**
2511 * @brief Set Time-stamp event active edge
2512 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2513 * @note TSE must be reset when TSEDGE is changed to avoid unwanted TSF setting
2514 * @rmtoll RTC_CR ITSEDGE LL_RTC_TS_SetActiveEdge
2515 * @param RTCx RTC Instance
2516 * @param Edge This parameter can be one of the following values:
2517 * @arg @ref LL_RTC_TIMESTAMP_EDGE_RISING
2518 * @arg @ref LL_RTC_TIMESTAMP_EDGE_FALLING
2519 * @retval None
2520 */
2521 __STATIC_INLINE void LL_RTC_TS_SetActiveEdge(RTC_TypeDef *RTCx, uint32_t Edge)
2522 {
2523 MODIFY_REG(RTCx->CR, RTC_CR_TSEDGE, Edge);
2524 }
2525
2526 /**
2527 * @brief Get Time-stamp event active edge
2528 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
2529 * @rmtoll RTC_CR ITSEDGE LL_RTC_TS_GetActiveEdge
2530 * @param RTCx RTC Instance
2531 * @retval Returned value can be one of the following values:
2532 * @arg @ref LL_RTC_TIMESTAMP_EDGE_RISING
2533 * @arg @ref LL_RTC_TIMESTAMP_EDGE_FALLING
2534 */
2535 __STATIC_INLINE uint32_t LL_RTC_TS_GetActiveEdge(RTC_TypeDef *RTCx)
2536 {
2537 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_TSEDGE));
2538 }
2539
2540 /**
2541 * @brief Get Timestamp AM/PM notation (AM or 24-hour format)
2542 * @rmtoll RTC_TSTR PM LL_RTC_TS_GetTimeFormat
2543 * @param RTCx RTC Instance
2544 * @retval Returned value can be one of the following values:
2545 * @arg @ref LL_RTC_TS_TIME_FORMAT_AM
2546 * @arg @ref LL_RTC_TS_TIME_FORMAT_PM
2547 */
2548 __STATIC_INLINE uint32_t LL_RTC_TS_GetTimeFormat(RTC_TypeDef *RTCx)
2549 {
2550 return (uint32_t)(READ_BIT(RTCx->TSTR, RTC_TSTR_PM));
2551 }
2552
2553 /**
2554 * @brief Get Timestamp Hours in BCD format
2555 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Hours from BCD to Binary format
2556 * @rmtoll RTC_TSTR HT LL_RTC_TS_GetHour\n
2557 * RTC_TSTR HU LL_RTC_TS_GetHour
2558 * @param RTCx RTC Instance
2559 * @retval Value between Min_Data=0x01 and Max_Data=0x12 or between Min_Data=0x00 and Max_Data=0x23
2560 */
2561 __STATIC_INLINE uint32_t LL_RTC_TS_GetHour(RTC_TypeDef *RTCx)
2562 {
2563 return (uint32_t)(READ_BIT(RTCx->TSTR, RTC_TSTR_HT | RTC_TSTR_HU) >> RTC_TSTR_HU_Pos);
2564 }
2565
2566 /**
2567 * @brief Get Timestamp Minutes in BCD format
2568 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Minutes from BCD to Binary format
2569 * @rmtoll RTC_TSTR MNT LL_RTC_TS_GetMinute\n
2570 * RTC_TSTR HU LL_RTC_TS_GetMinute
2571 * @param RTCx RTC Instance
2572 * @retval Value between Min_Data=0x00 and Max_Data=0x59
2573 */
2574 __STATIC_INLINE uint32_t LL_RTC_TS_GetMinute(RTC_TypeDef *RTCx)
2575 {
2576 return (uint32_t)(READ_BIT(RTCx->TSTR, RTC_TSTR_MNT | RTC_TSTR_MNU) >> RTC_TSTR_MNU_Pos);
2577 }
2578
2579 /**
2580 * @brief Get Timestamp Seconds in BCD format
2581 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Seconds from BCD to Binary format
2582 * @rmtoll RTC_TSTR ST LL_RTC_TS_GetSecond\n
2583 * RTC_TSTR HU LL_RTC_TS_GetSecond
2584 * @param RTCx RTC Instance
2585 * @retval Value between Min_Data=0x00 and Max_Data=0x59
2586 */
2587 __STATIC_INLINE uint32_t LL_RTC_TS_GetSecond(RTC_TypeDef *RTCx)
2588 {
2589 return (uint32_t)(READ_BIT(RTCx->TSTR, RTC_TSTR_ST | RTC_TSTR_SU));
2590 }
2591
2592 /**
2593 * @brief Get Timestamp time (hour, minute and second) in BCD format
2594 * @note helper macros __LL_RTC_GET_HOUR, __LL_RTC_GET_MINUTE and __LL_RTC_GET_SECOND
2595 * are available to get independently each parameter.
2596 * @rmtoll RTC_TSTR HT LL_RTC_TS_GetTime\n
2597 * RTC_TSTR HU LL_RTC_TS_GetTime\n
2598 * RTC_TSTR MNT LL_RTC_TS_GetTime\n
2599 * RTC_TSTR MNU LL_RTC_TS_GetTime\n
2600 * RTC_TSTR ST LL_RTC_TS_GetTime\n
2601 * RTC_TSTR SU LL_RTC_TS_GetTime
2602 * @param RTCx RTC Instance
2603 * @retval Combination of hours, minutes and seconds.
2604 */
2605 __STATIC_INLINE uint32_t LL_RTC_TS_GetTime(RTC_TypeDef *RTCx)
2606 {
2607 return (uint32_t)(READ_BIT(RTCx->TSTR,
2608 RTC_TSTR_HT | RTC_TSTR_HU | RTC_TSTR_MNT | RTC_TSTR_MNU | RTC_TSTR_ST | RTC_TSTR_SU));
2609 }
2610
2611 /**
2612 * @brief Get Timestamp Week day
2613 * @rmtoll RTC_TSDR WDU LL_RTC_TS_GetWeekDay
2614 * @param RTCx RTC Instance
2615 * @retval Returned value can be one of the following values:
2616 * @arg @ref LL_RTC_WEEKDAY_MONDAY
2617 * @arg @ref LL_RTC_WEEKDAY_TUESDAY
2618 * @arg @ref LL_RTC_WEEKDAY_WEDNESDAY
2619 * @arg @ref LL_RTC_WEEKDAY_THURSDAY
2620 * @arg @ref LL_RTC_WEEKDAY_FRIDAY
2621 * @arg @ref LL_RTC_WEEKDAY_SATURDAY
2622 * @arg @ref LL_RTC_WEEKDAY_SUNDAY
2623 */
2624 __STATIC_INLINE uint32_t LL_RTC_TS_GetWeekDay(RTC_TypeDef *RTCx)
2625 {
2626 return (uint32_t)(READ_BIT(RTCx->TSDR, RTC_TSDR_WDU) >> RTC_TSDR_WDU_Pos);
2627 }
2628
2629 /**
2630 * @brief Get Timestamp Month in BCD format
2631 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Month from BCD to Binary format
2632 * @rmtoll RTC_TSDR MT LL_RTC_TS_GetMonth\n
2633 * RTC_TSDR MU LL_RTC_TS_GetMonth
2634 * @param RTCx RTC Instance
2635 * @retval Returned value can be one of the following values:
2636 * @arg @ref LL_RTC_MONTH_JANUARY
2637 * @arg @ref LL_RTC_MONTH_FEBRUARY
2638 * @arg @ref LL_RTC_MONTH_MARCH
2639 * @arg @ref LL_RTC_MONTH_APRIL
2640 * @arg @ref LL_RTC_MONTH_MAY
2641 * @arg @ref LL_RTC_MONTH_JUNE
2642 * @arg @ref LL_RTC_MONTH_JULY
2643 * @arg @ref LL_RTC_MONTH_AUGUST
2644 * @arg @ref LL_RTC_MONTH_SEPTEMBER
2645 * @arg @ref LL_RTC_MONTH_OCTOBER
2646 * @arg @ref LL_RTC_MONTH_NOVEMBER
2647 * @arg @ref LL_RTC_MONTH_DECEMBER
2648 */
2649 __STATIC_INLINE uint32_t LL_RTC_TS_GetMonth(RTC_TypeDef *RTCx)
2650 {
2651 return (uint32_t)(READ_BIT(RTCx->TSDR, RTC_TSDR_MT | RTC_TSDR_MU) >> RTC_TSDR_MU_Pos);
2652 }
2653
2654 /**
2655 * @brief Get Timestamp Day in BCD format
2656 * @note helper macro __LL_RTC_CONVERT_BCD2BIN is available to convert Day from BCD to Binary format
2657 * @rmtoll RTC_TSDR DT LL_RTC_TS_GetDay\n
2658 * RTC_TSDR DU LL_RTC_TS_GetDay
2659 * @param RTCx RTC Instance
2660 * @retval Value between Min_Data=0x01 and Max_Data=0x31
2661 */
2662 __STATIC_INLINE uint32_t LL_RTC_TS_GetDay(RTC_TypeDef *RTCx)
2663 {
2664 return (uint32_t)(READ_BIT(RTCx->TSDR, RTC_TSDR_DT | RTC_TSDR_DU));
2665 }
2666
2667 /**
2668 * @brief Get Timestamp date (WeekDay, Day and Month) in BCD format
2669 * @note helper macros __LL_RTC_GET_WEEKDAY, __LL_RTC_GET_MONTH,
2670 * and __LL_RTC_GET_DAY are available to get independently each parameter.
2671 * @rmtoll RTC_TSDR WDU LL_RTC_TS_GetDate\n
2672 * RTC_TSDR MT LL_RTC_TS_GetDate\n
2673 * RTC_TSDR MU LL_RTC_TS_GetDate\n
2674 * RTC_TSDR DT LL_RTC_TS_GetDate\n
2675 * RTC_TSDR DU LL_RTC_TS_GetDate
2676 * @param RTCx RTC Instance
2677 * @retval Combination of Weekday, Day and Month
2678 */
2679 __STATIC_INLINE uint32_t LL_RTC_TS_GetDate(RTC_TypeDef *RTCx)
2680 {
2681 return (uint32_t)(READ_BIT(RTCx->TSDR, RTC_TSDR_WDU | RTC_TSDR_MT | RTC_TSDR_MU | RTC_TSDR_DT | RTC_TSDR_DU));
2682 }
2683
2684 /**
2685 * @brief Get time-stamp sub second value
2686 * @rmtoll RTC_TSDR SS LL_RTC_TS_GetSubSecond
2687 * @param RTCx RTC Instance
2688 * @retval Value between Min_Data=0x00 and Max_Data=0xFFFF
2689 */
2690 __STATIC_INLINE uint32_t LL_RTC_TS_GetSubSecond(RTC_TypeDef *RTCx)
2691 {
2692 return (uint32_t)(READ_BIT(RTCx->TSSSR, RTC_TSSSR_SS));
2693 }
2694
2695 /**
2696 * @brief Activate timestamp on tamper detection event
2697 * @rmtoll RTC_CR TAMPTS LL_RTC_TS_EnableOnTamper
2698 * @param RTCx RTC Instance
2699 * @retval None
2700 */
2701 __STATIC_INLINE void LL_RTC_TS_EnableOnTamper(RTC_TypeDef *RTCx)
2702 {
2703 SET_BIT(RTCx->CR, RTC_CR_TAMPTS);
2704 }
2705
2706 /**
2707 * @brief Disable timestamp on tamper detection event
2708 * @rmtoll RTC_CR TAMPTS LL_RTC_TS_DisableOnTamper
2709 * @param RTCx RTC Instance
2710 * @retval None
2711 */
2712 __STATIC_INLINE void LL_RTC_TS_DisableOnTamper(RTC_TypeDef *RTCx)
2713 {
2714 CLEAR_BIT(RTCx->CR, RTC_CR_TAMPTS);
2715 }
2716
2717
2718 /**
2719 * @}
2720 */
2721
2722 /** @defgroup RTC_LL_EF_Tamper Tamper
2723 * @{
2724 */
2725
2726 /**
2727 * @brief Enable TAMPx input detection
2728 * @rmtoll TAMP_CR1 TAMP1E LL_RTC_TAMPER_Enable\n
2729 * TAMP_CR1 TAMP2E... LL_RTC_TAMPER_Enable
2730 * @param RTCx RTC Instance
2731 * @param Tamper This parameter can be a combination of the following values:
2732 * @arg @ref LL_RTC_TAMPER_1
2733 * @arg @ref LL_RTC_TAMPER_2
2734 *
2735 * @retval None
2736 */
2737 __STATIC_INLINE void LL_RTC_TAMPER_Enable(RTC_TypeDef *RTCx, uint32_t Tamper)
2738 {
2739 UNUSED(RTCx);
2740 SET_BIT(TAMP->CR1, Tamper);
2741 }
2742
2743 /**
2744 * @brief Clear TAMPx input detection
2745 * @rmtoll TAMP_CR1 TAMP1E LL_RTC_TAMPER_Disable\n
2746 * TAMP_CR1 TAMP2E... LL_RTC_TAMPER_Disable
2747 * @param RTCx RTC Instance
2748 * @param Tamper This parameter can be a combination of the following values:
2749 * @arg @ref LL_RTC_TAMPER_1
2750 * @arg @ref LL_RTC_TAMPER_2
2751 *
2752 * @retval None
2753 */
2754 __STATIC_INLINE void LL_RTC_TAMPER_Disable(RTC_TypeDef *RTCx, uint32_t Tamper)
2755 {
2756 UNUSED(RTCx);
2757 CLEAR_BIT(TAMP->CR1, Tamper);
2758 }
2759
2760 /**
2761 * @brief Enable Tamper mask flag
2762 * @note Associated Tamper IT must not enabled when tamper mask is set.
2763 * @rmtoll TAMP_CR2 TAMP1MF LL_RTC_TAMPER_EnableMask\n
2764 * TAMP_CR2 TAMP2MF... LL_RTC_TAMPER_EnableMask
2765 * @param RTCx RTC Instance
2766 * @param Mask This parameter can be a combination of the following values:
2767 * @arg @ref LL_RTC_TAMPER_MASK_TAMPER1
2768 * @arg @ref LL_RTC_TAMPER_MASK_TAMPER2
2769 *
2770 * @retval None
2771 */
2772 __STATIC_INLINE void LL_RTC_TAMPER_EnableMask(RTC_TypeDef *RTCx, uint32_t Mask)
2773 {
2774 UNUSED(RTCx);
2775 SET_BIT(TAMP->CR2, Mask);
2776 }
2777
2778 /**
2779 * @brief Disable Tamper mask flag
2780 * @rmtoll TAMP_CR2 TAMP1MF LL_RTC_TAMPER_DisableMask\n
2781 * TAMP_CR2 TAMP2MF... LL_RTC_TAMPER_DisableMask
2782 * @param RTCx RTC Instance
2783 * @param Mask This parameter can be a combination of the following values:
2784 * @arg @ref LL_RTC_TAMPER_MASK_TAMPER1
2785 * @arg @ref LL_RTC_TAMPER_MASK_TAMPER2
2786 *
2787 * @retval None
2788 */
2789 __STATIC_INLINE void LL_RTC_TAMPER_DisableMask(RTC_TypeDef *RTCx, uint32_t Mask)
2790 {
2791 UNUSED(RTCx);
2792 CLEAR_BIT(TAMP->CR2, Mask);
2793 }
2794
2795 /**
2796 * @brief Enable backup register erase after Tamper event detection
2797 * @rmtoll TAMP_CR2 TAMP1NOERASE LL_RTC_TAMPER_EnableEraseBKP\n
2798 * TAMP_CR2 TAMP2NOERASE... LL_RTC_TAMPER_EnableEraseBKP
2799 * @param RTCx RTC Instance
2800 * @param Tamper This parameter can be a combination of the following values:
2801 * @arg @ref LL_RTC_TAMPER_NOERASE_TAMPER1
2802 * @arg @ref LL_RTC_TAMPER_NOERASE_TAMPER2
2803 *
2804 * @retval None
2805 */
2806 __STATIC_INLINE void LL_RTC_TAMPER_EnableEraseBKP(RTC_TypeDef *RTCx, uint32_t Tamper)
2807 {
2808 UNUSED(RTCx);
2809 CLEAR_BIT(TAMP->CR2, Tamper);
2810 }
2811
2812 /**
2813 * @brief Disable backup register erase after Tamper event detection
2814 * @rmtoll TAMP_CR2 TAMP1NOERASE LL_RTC_TAMPER_DisableEraseBKP\n
2815 * TAMP_CR2 TAMP2NOERASE... LL_RTC_TAMPER_DisableEraseBKP
2816 * @param RTCx RTC Instance
2817 * @param Tamper This parameter can be a combination of the following values:
2818 * @arg @ref LL_RTC_TAMPER_NOERASE_TAMPER1
2819 * @arg @ref LL_RTC_TAMPER_NOERASE_TAMPER2
2820 *
2821 * @retval None
2822 */
2823 __STATIC_INLINE void LL_RTC_TAMPER_DisableEraseBKP(RTC_TypeDef *RTCx, uint32_t Tamper)
2824 {
2825 UNUSED(RTCx);
2826 SET_BIT(TAMP->CR2, Tamper);
2827 }
2828
2829 /**
2830 * @brief Disable RTC_TAMPx pull-up disable (Disable precharge of RTC_TAMPx pins)
2831 * @rmtoll TAMP_FLTCR TAMPPUDIS LL_RTC_TAMPER_DisablePullUp
2832 * @param RTCx RTC Instance
2833 * @retval None
2834 */
2835 __STATIC_INLINE void LL_RTC_TAMPER_DisablePullUp(RTC_TypeDef *RTCx)
2836 {
2837 UNUSED(RTCx);
2838 SET_BIT(TAMP->FLTCR, TAMP_FLTCR_TAMPPUDIS);
2839 }
2840
2841 /**
2842 * @brief Enable RTC_TAMPx pull-up disable ( Precharge RTC_TAMPx pins before sampling)
2843 * @rmtoll TAMP_FLTCR TAMPPUDIS LL_RTC_TAMPER_EnablePullUp
2844 * @param RTCx RTC Instance
2845 * @retval None
2846 */
2847 __STATIC_INLINE void LL_RTC_TAMPER_EnablePullUp(RTC_TypeDef *RTCx)
2848 {
2849 UNUSED(RTCx);
2850 CLEAR_BIT(TAMP->FLTCR, TAMP_FLTCR_TAMPPUDIS);
2851 }
2852
2853 /**
2854 * @brief Set RTC_TAMPx precharge duration
2855 * @rmtoll TAMP_FLTCR TAMPPRCH LL_RTC_TAMPER_SetPrecharge
2856 * @param RTCx RTC Instance
2857 * @param Duration This parameter can be one of the following values:
2858 * @arg @ref LL_RTC_TAMPER_DURATION_1RTCCLK
2859 * @arg @ref LL_RTC_TAMPER_DURATION_2RTCCLK
2860 * @arg @ref LL_RTC_TAMPER_DURATION_4RTCCLK
2861 * @arg @ref LL_RTC_TAMPER_DURATION_8RTCCLK
2862 * @retval None
2863 */
2864 __STATIC_INLINE void LL_RTC_TAMPER_SetPrecharge(RTC_TypeDef *RTCx, uint32_t Duration)
2865 {
2866 UNUSED(RTCx);
2867 MODIFY_REG(TAMP->FLTCR, TAMP_FLTCR_TAMPPRCH, Duration);
2868 }
2869
2870 /**
2871 * @brief Get RTC_TAMPx precharge duration
2872 * @rmtoll TAMP_FLTCR TAMPPRCH LL_RTC_TAMPER_GetPrecharge
2873 * @param RTCx RTC Instance
2874 * @retval Returned value can be one of the following values:
2875 * @arg @ref LL_RTC_TAMPER_DURATION_1RTCCLK
2876 * @arg @ref LL_RTC_TAMPER_DURATION_2RTCCLK
2877 * @arg @ref LL_RTC_TAMPER_DURATION_4RTCCLK
2878 * @arg @ref LL_RTC_TAMPER_DURATION_8RTCCLK
2879 */
2880 __STATIC_INLINE uint32_t LL_RTC_TAMPER_GetPrecharge(RTC_TypeDef *RTCx)
2881 {
2882 UNUSED(RTCx);
2883 return (uint32_t)(READ_BIT(TAMP->FLTCR, TAMP_FLTCR_TAMPPRCH));
2884 }
2885
2886 /**
2887 * @brief Set RTC_TAMPx filter count
2888 * @rmtoll TAMP_FLTCR TAMPFLT LL_RTC_TAMPER_SetFilterCount
2889 * @param RTCx RTC Instance
2890 * @param FilterCount This parameter can be one of the following values:
2891 * @arg @ref LL_RTC_TAMPER_FILTER_DISABLE
2892 * @arg @ref LL_RTC_TAMPER_FILTER_2SAMPLE
2893 * @arg @ref LL_RTC_TAMPER_FILTER_4SAMPLE
2894 * @arg @ref LL_RTC_TAMPER_FILTER_8SAMPLE
2895 * @retval None
2896 */
2897 __STATIC_INLINE void LL_RTC_TAMPER_SetFilterCount(RTC_TypeDef *RTCx, uint32_t FilterCount)
2898 {
2899 UNUSED(RTCx);
2900 MODIFY_REG(TAMP->FLTCR, TAMP_FLTCR_TAMPFLT, FilterCount);
2901 }
2902
2903 /**
2904 * @brief Get RTC_TAMPx filter count
2905 * @rmtoll TAMP_FLTCR TAMPFLT LL_RTC_TAMPER_GetFilterCount
2906 * @param RTCx RTC Instance
2907 * @retval Returned value can be one of the following values:
2908 * @arg @ref LL_RTC_TAMPER_FILTER_DISABLE
2909 * @arg @ref LL_RTC_TAMPER_FILTER_2SAMPLE
2910 * @arg @ref LL_RTC_TAMPER_FILTER_4SAMPLE
2911 * @arg @ref LL_RTC_TAMPER_FILTER_8SAMPLE
2912 */
2913 __STATIC_INLINE uint32_t LL_RTC_TAMPER_GetFilterCount(RTC_TypeDef *RTCx)
2914 {
2915 UNUSED(RTCx);
2916 return (uint32_t)(READ_BIT(TAMP->FLTCR, TAMP_FLTCR_TAMPFLT));
2917 }
2918
2919 /**
2920 * @brief Set Tamper sampling frequency
2921 * @rmtoll TAMP_FLTCR TAMPFREQ LL_RTC_TAMPER_SetSamplingFreq
2922 * @param RTCx RTC Instance
2923 * @param SamplingFreq This parameter can be one of the following values:
2924 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_32768
2925 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_16384
2926 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_8192
2927 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_4096
2928 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_2048
2929 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_1024
2930 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_512
2931 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_256
2932 * @retval None
2933 */
2934 __STATIC_INLINE void LL_RTC_TAMPER_SetSamplingFreq(RTC_TypeDef *RTCx, uint32_t SamplingFreq)
2935 {
2936 UNUSED(RTCx);
2937 MODIFY_REG(TAMP->FLTCR, TAMP_FLTCR_TAMPFREQ, SamplingFreq);
2938 }
2939
2940 /**
2941 * @brief Get Tamper sampling frequency
2942 * @rmtoll TAMP_FLTCR TAMPFREQ LL_RTC_TAMPER_GetSamplingFreq
2943 * @param RTCx RTC Instance
2944 * @retval Returned value can be one of the following values:
2945 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_32768
2946 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_16384
2947 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_8192
2948 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_4096
2949 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_2048
2950 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_1024
2951 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_512
2952 * @arg @ref LL_RTC_TAMPER_SAMPLFREQDIV_256
2953 */
2954 __STATIC_INLINE uint32_t LL_RTC_TAMPER_GetSamplingFreq(RTC_TypeDef *RTCx)
2955 {
2956 UNUSED(RTCx);
2957 return (uint32_t)(READ_BIT(TAMP->FLTCR, TAMP_FLTCR_TAMPFREQ));
2958 }
2959
2960 /**
2961 * @brief Enable Active level for Tamper input
2962 * @rmtoll TAMP_CR2 TAMP1TRG LL_RTC_TAMPER_EnableActiveLevel\n
2963 * TAMP_CR2 TAMP2TRG... LL_RTC_TAMPER_EnableActiveLevel
2964 * @param RTCx RTC Instance
2965 * @param Tamper This parameter can be a combination of the following values:
2966 * @arg @ref LL_RTC_TAMPER_ACTIVELEVEL_TAMP1
2967 * @arg @ref LL_RTC_TAMPER_ACTIVELEVEL_TAMP2
2968 *
2969 * @retval None
2970 */
2971 __STATIC_INLINE void LL_RTC_TAMPER_EnableActiveLevel(RTC_TypeDef *RTCx, uint32_t Tamper)
2972 {
2973 UNUSED(RTCx);
2974 SET_BIT(TAMP->CR2, Tamper);
2975 }
2976
2977 /**
2978 * @brief Disable Active level for Tamper input
2979 * @rmtoll TAMP_CR2 TAMP1TRG LL_RTC_TAMPER_DisableActiveLevel\n
2980 * TAMP_CR2 TAMP2TRG... LL_RTC_TAMPER_DisableActiveLevel
2981 * @param RTCx RTC Instance
2982 * @param Tamper This parameter can be a combination of the following values:
2983 * @arg @ref LL_RTC_TAMPER_ACTIVELEVEL_TAMP1
2984 * @arg @ref LL_RTC_TAMPER_ACTIVELEVEL_TAMP2
2985 *
2986 * @retval None
2987 */
2988 __STATIC_INLINE void LL_RTC_TAMPER_DisableActiveLevel(RTC_TypeDef *RTCx, uint32_t Tamper)
2989 {
2990 UNUSED(RTCx);
2991 CLEAR_BIT(TAMP->CR2, Tamper);
2992 }
2993
2994 /**
2995 * @}
2996 */
2997
2998 /** @defgroup RTC_LL_EF_Internal_Tamper Internal Tamper
2999 * @{
3000 */
3001
3002 /**
3003 * @brief Enable internal tamper detection.
3004 * @rmtoll TAMP_CR1 ITAMP1E LL_RTC_TAMPER_ITAMP_Enable\n
3005 * TAMP_CR1 ITAMP3E LL_RTC_TAMPER_ITAMP_Enable\n
3006 * TAMP_CR1 ITAMP4E LL_RTC_TAMPER_ITAMP_Enable\n
3007 * TAMP_CR1 ITAMP5E LL_RTC_TAMPER_ITAMP_Enable\n
3008 * TAMP_CR1 ITAMP6E LL_RTC_TAMPER_ITAMP_Enable\n
3009 * TAMP_CR1 ITAMP7E... LL_RTC_TAMPER_ITAMP_Enable
3010 * @param RTCx RTC Instance
3011 * @param InternalTamper This parameter can be a combination of the following values:
3012 * @arg @ref LL_RTC_TAMPER_ITAMP1
3013 * @arg @ref LL_RTC_TAMPER_ITAMP3
3014 * @arg @ref LL_RTC_TAMPER_ITAMP4
3015 * @arg @ref LL_RTC_TAMPER_ITAMP5
3016 * @arg @ref LL_RTC_TAMPER_ITAMP6
3017 @if RTC_TAMP_INT_7_SUPPORT
3018 * @arg @ref LL_RTC_TAMPER_ITAMP7
3019 @endif
3020 *
3021 * @retval None
3022 */
3023 __STATIC_INLINE void LL_RTC_TAMPER_ITAMP_Enable(RTC_TypeDef *RTCx, uint32_t InternalTamper)
3024 {
3025 UNUSED(RTCx);
3026 SET_BIT(TAMP->CR1, InternalTamper);
3027 }
3028
3029 /**
3030 * @brief Disable internal tamper detection.
3031 * @rmtoll TAMP_CR1 ITAMP1E LL_RTC_TAMPER_ITAMP_Disable\n
3032 * TAMP_CR1 ITAMP3E LL_RTC_TAMPER_ITAMP_Disable\n
3033 * TAMP_CR1 ITAMP4E LL_RTC_TAMPER_ITAMP_Disable\n
3034 * TAMP_CR1 ITAMP5E LL_RTC_TAMPER_ITAMP_Disable\n
3035 * TAMP_CR1 ITAMP6E LL_RTC_TAMPER_ITAMP_Disable\n
3036 * TAMP_CR1 ITAMP7E... LL_RTC_TAMPER_ITAMP_Disable
3037 * @param RTCx RTC Instance
3038 * @param InternalTamper This parameter can be a combination of the following values:
3039 * @arg @ref LL_RTC_TAMPER_ITAMP1
3040 * @arg @ref LL_RTC_TAMPER_ITAMP3
3041 * @arg @ref LL_RTC_TAMPER_ITAMP4
3042 * @arg @ref LL_RTC_TAMPER_ITAMP5
3043 * @arg @ref LL_RTC_TAMPER_ITAMP6
3044 @if RTC_TAMP_INT_7_SUPPORT
3045 * @arg @ref LL_RTC_TAMPER_ITAMP7
3046 @endif
3047 *
3048 * @retval None
3049 */
3050 __STATIC_INLINE void LL_RTC_TAMPER_ITAMP_Disable(RTC_TypeDef *RTCx, uint32_t InternalTamper)
3051 {
3052 UNUSED(RTCx);
3053 CLEAR_BIT(TAMP->CR1, InternalTamper);
3054 }
3055
3056 /**
3057 * @}
3058 */
3059
3060
3061 /** @defgroup RTC_LL_EF_Wakeup Wakeup
3062 * @{
3063 */
3064
3065 /**
3066 * @brief Enable Wakeup timer
3067 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3068 * @rmtoll RTC_CR WUTE LL_RTC_WAKEUP_Enable
3069 * @param RTCx RTC Instance
3070 * @retval None
3071 */
3072 __STATIC_INLINE void LL_RTC_WAKEUP_Enable(RTC_TypeDef *RTCx)
3073 {
3074 SET_BIT(RTCx->CR, RTC_CR_WUTE);
3075 }
3076
3077 /**
3078 * @brief Disable Wakeup timer
3079 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3080 * @rmtoll RTC_CR WUTE LL_RTC_WAKEUP_Disable
3081 * @param RTCx RTC Instance
3082 * @retval None
3083 */
3084 __STATIC_INLINE void LL_RTC_WAKEUP_Disable(RTC_TypeDef *RTCx)
3085 {
3086 CLEAR_BIT(RTCx->CR, RTC_CR_WUTE);
3087 }
3088
3089 /**
3090 * @brief Check if Wakeup timer is enabled or not
3091 * @rmtoll RTC_CR WUTE LL_RTC_WAKEUP_IsEnabled
3092 * @param RTCx RTC Instance
3093 * @retval State of bit (1 or 0).
3094 */
3095 __STATIC_INLINE uint32_t LL_RTC_WAKEUP_IsEnabled(RTC_TypeDef *RTCx)
3096 {
3097 return ((READ_BIT(RTCx->CR, RTC_CR_WUTE) == (RTC_CR_WUTE)) ? 1U : 0U);
3098 }
3099
3100 /**
3101 * @brief Select Wakeup clock
3102 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3103 * @note Bit can be written only when RTC_CR WUTE bit = 0 and RTC_ICSR WUTWF bit = 1
3104 * @rmtoll RTC_CR WUCKSEL LL_RTC_WAKEUP_SetClock
3105 * @param RTCx RTC Instance
3106 * @param WakeupClock This parameter can be one of the following values:
3107 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_16
3108 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_8
3109 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_4
3110 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_2
3111 * @arg @ref LL_RTC_WAKEUPCLOCK_CKSPRE
3112 * @arg @ref LL_RTC_WAKEUPCLOCK_CKSPRE_WUT
3113 * @retval None
3114 */
3115 __STATIC_INLINE void LL_RTC_WAKEUP_SetClock(RTC_TypeDef *RTCx, uint32_t WakeupClock)
3116 {
3117 MODIFY_REG(RTCx->CR, RTC_CR_WUCKSEL, WakeupClock);
3118 }
3119
3120 /**
3121 * @brief Get Wakeup clock
3122 * @rmtoll RTC_CR WUCKSEL LL_RTC_WAKEUP_GetClock
3123 * @param RTCx RTC Instance
3124 * @retval Returned value can be one of the following values:
3125 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_16
3126 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_8
3127 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_4
3128 * @arg @ref LL_RTC_WAKEUPCLOCK_DIV_2
3129 * @arg @ref LL_RTC_WAKEUPCLOCK_CKSPRE
3130 * @arg @ref LL_RTC_WAKEUPCLOCK_CKSPRE_WUT
3131 */
3132 __STATIC_INLINE uint32_t LL_RTC_WAKEUP_GetClock(RTC_TypeDef *RTCx)
3133 {
3134 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_WUCKSEL));
3135 }
3136
3137 /**
3138 * @brief Set Wakeup auto-reload value
3139 * @note Bit can be written only when WUTWF is set to 1 in RTC_ICSR
3140 * @rmtoll RTC_WUTR WUT LL_RTC_WAKEUP_SetAutoReload
3141 * @param RTCx RTC Instance
3142 * @param Value Value between Min_Data=0x00 and Max_Data=0xFFFF
3143 * @retval None
3144 */
3145 __STATIC_INLINE void LL_RTC_WAKEUP_SetAutoReload(RTC_TypeDef *RTCx, uint32_t Value)
3146 {
3147 MODIFY_REG(RTCx->WUTR, RTC_WUTR_WUT, Value);
3148 }
3149
3150 /**
3151 * @brief Get Wakeup auto-reload value
3152 * @rmtoll RTC_WUTR WUT LL_RTC_WAKEUP_GetAutoReload
3153 * @param RTCx RTC Instance
3154 * @retval Value between Min_Data=0x00 and Max_Data=0xFFFF
3155 */
3156 __STATIC_INLINE uint32_t LL_RTC_WAKEUP_GetAutoReload(RTC_TypeDef *RTCx)
3157 {
3158 return (uint32_t)(READ_BIT(RTCx->WUTR, RTC_WUTR_WUT));
3159 }
3160
3161 /**
3162 * @}
3163 */
3164
3165 /** @defgroup RTC_LL_EF_Backup_Registers Backup_Registers
3166 * @{
3167 */
3168
3169 /**
3170 * @brief Writes a data in a specified Backup data register.
3171 * @rmtoll TAMP_BKPxR BKP LL_RTC_BKP_SetRegister
3172 * @param RTCx RTC Instance
3173 * @param BackupRegister This parameter can be one of the following values:
3174 * @arg @ref LL_RTC_BKP_DR0
3175 * @arg @ref LL_RTC_BKP_DR1
3176 * @arg @ref LL_RTC_BKP_DR2
3177 * @arg @ref LL_RTC_BKP_DR3
3178 * ...
3179 * @param Data Value between Min_Data=0x00 and Max_Data=0xFFFFFFFF
3180 * @retval None
3181 */
3182 __STATIC_INLINE void LL_RTC_BKP_SetRegister(RTC_TypeDef *RTCx, uint32_t BackupRegister, uint32_t Data)
3183 {
3184 register uint32_t tmp;
3185
3186 UNUSED(RTCx);
3187
3188 tmp = (uint32_t)(&(TAMP->BKP0R));
3189 tmp += (BackupRegister * 4U);
3190
3191 /* Write the specified register */
3192 *(__IO uint32_t *)tmp = (uint32_t)Data;
3193 }
3194
3195 /**
3196 * @brief Reads data from the specified RTC Backup data Register.
3197 * @rmtoll TAMP_BKPxR BKP LL_RTC_BKP_GetRegister
3198 * @param RTCx RTC Instance
3199 * @param BackupRegister This parameter can be one of the following values:
3200 * @arg @ref LL_RTC_BKP_DR0
3201 * @arg @ref LL_RTC_BKP_DR1
3202 * @arg @ref LL_RTC_BKP_DR2
3203 * @arg @ref LL_RTC_BKP_DR3
3204 * ...
3205 * @retval Value between Min_Data=0x00 and Max_Data=0xFFFFFFFF
3206 */
3207 __STATIC_INLINE uint32_t LL_RTC_BKP_GetRegister(RTC_TypeDef *RTCx, uint32_t BackupRegister)
3208 {
3209 register uint32_t tmp;
3210
3211 UNUSED(RTCx);
3212
3213 tmp = (uint32_t)(&(TAMP->BKP0R));
3214 tmp += (BackupRegister * 4U);
3215
3216 /* Read the specified register */
3217 return (*(__IO uint32_t *)tmp);
3218 }
3219
3220 /**
3221 * @}
3222 */
3223
3224 /** @defgroup RTC_LL_EF_Calibration Calibration
3225 * @{
3226 */
3227
3228 /**
3229 * @brief Set Calibration output frequency (1 Hz or 512 Hz)
3230 * @note Bits are write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3231 * @rmtoll RTC_CR COE LL_RTC_CAL_SetOutputFreq\n
3232 * RTC_CR COSEL LL_RTC_CAL_SetOutputFreq
3233 * @param RTCx RTC Instance
3234 * @param Frequency This parameter can be one of the following values:
3235 * @arg @ref LL_RTC_CALIB_OUTPUT_NONE
3236 * @arg @ref LL_RTC_CALIB_OUTPUT_1HZ
3237 * @arg @ref LL_RTC_CALIB_OUTPUT_512HZ
3238 * @retval None
3239 */
3240 __STATIC_INLINE void LL_RTC_CAL_SetOutputFreq(RTC_TypeDef *RTCx, uint32_t Frequency)
3241 {
3242 MODIFY_REG(RTCx->CR, RTC_CR_COE | RTC_CR_COSEL, Frequency);
3243 }
3244
3245 /**
3246 * @brief Get Calibration output frequency (1 Hz or 512 Hz)
3247 * @rmtoll RTC_CR COE LL_RTC_CAL_GetOutputFreq\n
3248 * RTC_CR COSEL LL_RTC_CAL_GetOutputFreq
3249 * @param RTCx RTC Instance
3250 * @retval Returned value can be one of the following values:
3251 * @arg @ref LL_RTC_CALIB_OUTPUT_NONE
3252 * @arg @ref LL_RTC_CALIB_OUTPUT_1HZ
3253 * @arg @ref LL_RTC_CALIB_OUTPUT_512HZ
3254 */
3255 __STATIC_INLINE uint32_t LL_RTC_CAL_GetOutputFreq(RTC_TypeDef *RTCx)
3256 {
3257 return (uint32_t)(READ_BIT(RTCx->CR, RTC_CR_COE | RTC_CR_COSEL));
3258 }
3259
3260 /**
3261 * @brief Insert or not One RTCCLK pulse every 2exp11 pulses (frequency increased by 488.5 ppm)
3262 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3263 * @note Bit can be written only when RECALPF is set to 0 in RTC_ICSR
3264 * @rmtoll RTC_CALR CALP LL_RTC_CAL_SetPulse
3265 * @param RTCx RTC Instance
3266 * @param Pulse This parameter can be one of the following values:
3267 * @arg @ref LL_RTC_CALIB_INSERTPULSE_NONE
3268 * @arg @ref LL_RTC_CALIB_INSERTPULSE_SET
3269 * @retval None
3270 */
3271 __STATIC_INLINE void LL_RTC_CAL_SetPulse(RTC_TypeDef *RTCx, uint32_t Pulse)
3272 {
3273 MODIFY_REG(RTCx->CALR, RTC_CALR_CALP, Pulse);
3274 }
3275
3276 /**
3277 * @brief Check if one RTCCLK has been inserted or not every 2exp11 pulses (frequency increased by 488.5 ppm)
3278 * @rmtoll RTC_CALR CALP LL_RTC_CAL_IsPulseInserted
3279 * @param RTCx RTC Instance
3280 * @retval State of bit (1 or 0).
3281 */
3282 __STATIC_INLINE uint32_t LL_RTC_CAL_IsPulseInserted(RTC_TypeDef *RTCx)
3283 {
3284 return ((READ_BIT(RTCx->CALR, RTC_CALR_CALP) == (RTC_CALR_CALP)) ? 1U : 0U);
3285 }
3286
3287 /**
3288 * @brief Set the calibration cycle period
3289 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3290 * @note Bit can be written only when RECALPF is set to 0 in RTC_ICSR
3291 * @rmtoll RTC_CALR CALW8 LL_RTC_CAL_SetPeriod\n
3292 * RTC_CALR CALW16 LL_RTC_CAL_SetPeriod
3293 * @param RTCx RTC Instance
3294 * @param Period This parameter can be one of the following values:
3295 * @arg @ref LL_RTC_CALIB_PERIOD_32SEC
3296 * @arg @ref LL_RTC_CALIB_PERIOD_16SEC
3297 * @arg @ref LL_RTC_CALIB_PERIOD_8SEC
3298 * @retval None
3299 */
3300 __STATIC_INLINE void LL_RTC_CAL_SetPeriod(RTC_TypeDef *RTCx, uint32_t Period)
3301 {
3302 MODIFY_REG(RTCx->CALR, RTC_CALR_CALW8 | RTC_CALR_CALW16, Period);
3303 }
3304
3305 /**
3306 * @brief Get the calibration cycle period
3307 * @rmtoll RTC_CALR CALW8 LL_RTC_CAL_GetPeriod\n
3308 * RTC_CALR CALW16 LL_RTC_CAL_GetPeriod
3309 * @param RTCx RTC Instance
3310 * @retval Returned value can be one of the following values:
3311 * @arg @ref LL_RTC_CALIB_PERIOD_32SEC
3312 * @arg @ref LL_RTC_CALIB_PERIOD_16SEC
3313 * @arg @ref LL_RTC_CALIB_PERIOD_8SEC
3314 */
3315 __STATIC_INLINE uint32_t LL_RTC_CAL_GetPeriod(RTC_TypeDef *RTCx)
3316 {
3317 return (uint32_t)(READ_BIT(RTCx->CALR, RTC_CALR_CALW8 | RTC_CALR_CALW16));
3318 }
3319
3320 /**
3321 * @brief Set Calibration minus
3322 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
3323 * @note Bit can be written only when RECALPF is set to 0 in RTC_ICSR
3324 * @rmtoll RTC_CALR CALM LL_RTC_CAL_SetMinus
3325 * @param RTCx RTC Instance
3326 * @param CalibMinus Value between Min_Data=0x00 and Max_Data=0x1FF
3327 * @retval None
3328 */
3329 __STATIC_INLINE void LL_RTC_CAL_SetMinus(RTC_TypeDef *RTCx, uint32_t CalibMinus)
3330 {
3331 MODIFY_REG(RTCx->CALR, RTC_CALR_CALM, CalibMinus);
3332 }
3333
3334 /**
3335 * @brief Get Calibration minus
3336 * @rmtoll RTC_CALR CALM LL_RTC_CAL_GetMinus
3337 * @param RTCx RTC Instance
3338 * @retval Value between Min_Data=0x00 and Max_Data= 0x1FF
3339 */
3340 __STATIC_INLINE uint32_t LL_RTC_CAL_GetMinus(RTC_TypeDef *RTCx)
3341 {
3342 return (uint32_t)(READ_BIT(RTCx->CALR, RTC_CALR_CALM));
3343 }
3344
3345 /**
3346 * @}
3347 */
3348
3349 /** @defgroup RTC_LL_EF_FLAG_Management FLAG_Management
3350 * @{
3351 */
3352
3353 /**
3354 * @brief Get Internal Time-stamp flag
3355 * @rmtoll RTC_SR ITSF LL_RTC_IsActiveFlag_ITS
3356 * @param RTCx RTC Instance
3357 * @retval State of bit (1 or 0).
3358 */
3359 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITS(RTC_TypeDef *RTCx)
3360 {
3361 return ((READ_BIT(RTCx->SR, RTC_SR_ITSF) == (RTC_SR_ITSF)) ? 1U : 0U);
3362 }
3363
3364 /**
3365 * @brief Get Recalibration pending Flag
3366 * @rmtoll RTC_ICSR RECALPF LL_RTC_IsActiveFlag_RECALP
3367 * @param RTCx RTC Instance
3368 * @retval State of bit (1 or 0).
3369 */
3370 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_RECALP(RTC_TypeDef *RTCx)
3371 {
3372 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_RECALPF) == (RTC_ICSR_RECALPF)) ? 1U : 0U);
3373 }
3374
3375 /**
3376 * @brief Get Time-stamp overflow flag
3377 * @rmtoll RTC_SR TSOVF LL_RTC_IsActiveFlag_TSOV
3378 * @param RTCx RTC Instance
3379 * @retval State of bit (1 or 0).
3380 */
3381 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TSOV(RTC_TypeDef *RTCx)
3382 {
3383 return ((READ_BIT(RTCx->SR, RTC_SR_TSOVF) == (RTC_SR_TSOVF)) ? 1U : 0U);
3384 }
3385
3386 /**
3387 * @brief Get Time-stamp flag
3388 * @rmtoll RTC_SR TSF LL_RTC_IsActiveFlag_TS
3389 * @param RTCx RTC Instance
3390 * @retval State of bit (1 or 0).
3391 */
3392 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TS(RTC_TypeDef *RTCx)
3393 {
3394 return ((READ_BIT(RTCx->SR, RTC_SR_TSF) == (RTC_SR_TSF)) ? 1U : 0U);
3395 }
3396
3397 /**
3398 * @brief Get Wakeup timer flag
3399 * @rmtoll RTC_SR WUTF LL_RTC_IsActiveFlag_WUT
3400 * @param RTCx RTC Instance
3401 * @retval State of bit (1 or 0).
3402 */
3403 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_WUT(RTC_TypeDef *RTCx)
3404 {
3405 return ((READ_BIT(RTCx->SR, RTC_SR_WUTF) == (RTC_SR_WUTF)) ? 1U : 0U);
3406 }
3407
3408 /**
3409 * @brief Get Alarm B flag
3410 * @rmtoll RTC_SR ALRBF LL_RTC_IsActiveFlag_ALRB
3411 * @param RTCx RTC Instance
3412 * @retval State of bit (1 or 0).
3413 */
3414 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ALRB(RTC_TypeDef *RTCx)
3415 {
3416 return ((READ_BIT(RTCx->SR, RTC_SR_ALRBF) == (RTC_SR_ALRBF)) ? 1U : 0U);
3417 }
3418
3419 /**
3420 * @brief Get Alarm A flag
3421 * @rmtoll RTC_SR ALRAF LL_RTC_IsActiveFlag_ALRA
3422 * @param RTCx RTC Instance
3423 * @retval State of bit (1 or 0).
3424 */
3425 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ALRA(RTC_TypeDef *RTCx)
3426 {
3427 return ((READ_BIT(RTCx->SR, RTC_SR_ALRAF) == (RTC_SR_ALRAF)) ? 1U : 0U);
3428 }
3429
3430 /**
3431 * @brief Clear Internal Time-stamp flag
3432 * @rmtoll RTC_SCR CITSF LL_RTC_ClearFlag_ITS
3433 * @param RTCx RTC Instance
3434 * @retval None
3435 */
3436 __STATIC_INLINE void LL_RTC_ClearFlag_ITS(RTC_TypeDef *RTCx)
3437 {
3438 SET_BIT(RTCx->SCR, RTC_SCR_CITSF);
3439 }
3440
3441 /**
3442 * @brief Clear Time-stamp overflow flag
3443 * @rmtoll RTC_SCR CTSOVF LL_RTC_ClearFlag_TSOV
3444 * @param RTCx RTC Instance
3445 * @retval None
3446 */
3447 __STATIC_INLINE void LL_RTC_ClearFlag_TSOV(RTC_TypeDef *RTCx)
3448 {
3449 SET_BIT(RTCx->SCR, RTC_SCR_CTSOVF);
3450 }
3451
3452 /**
3453 * @brief Clear Time-stamp flag
3454 * @rmtoll RTC_SCR CTSF LL_RTC_ClearFlag_TS
3455 * @param RTCx RTC Instance
3456 * @retval None
3457 */
3458 __STATIC_INLINE void LL_RTC_ClearFlag_TS(RTC_TypeDef *RTCx)
3459 {
3460 SET_BIT(RTCx->SCR, RTC_SCR_CTSF);
3461 }
3462
3463 /**
3464 * @brief Clear Wakeup timer flag
3465 * @rmtoll RTC_SCR CWUTF LL_RTC_ClearFlag_WUT
3466 * @param RTCx RTC Instance
3467 * @retval None
3468 */
3469 __STATIC_INLINE void LL_RTC_ClearFlag_WUT(RTC_TypeDef *RTCx)
3470 {
3471 SET_BIT(RTCx->SCR, RTC_SCR_CWUTF);
3472 }
3473
3474 /**
3475 * @brief Clear Alarm B flag
3476 * @rmtoll RTC_SCR CALRBF LL_RTC_ClearFlag_ALRB
3477 * @param RTCx RTC Instance
3478 * @retval None
3479 */
3480 __STATIC_INLINE void LL_RTC_ClearFlag_ALRB(RTC_TypeDef *RTCx)
3481 {
3482 SET_BIT(RTCx->SCR, RTC_SCR_CALRBF);
3483 }
3484
3485 /**
3486 * @brief Clear Alarm A flag
3487 * @rmtoll RTC_SCR CALRAF LL_RTC_ClearFlag_ALRA
3488 * @param RTCx RTC Instance
3489 * @retval None
3490 */
3491 __STATIC_INLINE void LL_RTC_ClearFlag_ALRA(RTC_TypeDef *RTCx)
3492 {
3493 SET_BIT(RTCx->SCR, RTC_SCR_CALRAF);
3494 }
3495
3496 /**
3497 * @brief Get Initialization flag
3498 * @rmtoll RTC_ICSR INITF LL_RTC_IsActiveFlag_INIT
3499 * @param RTCx RTC Instance
3500 * @retval State of bit (1 or 0).
3501 */
3502 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_INIT(RTC_TypeDef *RTCx)
3503 {
3504 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_INITF) == (RTC_ICSR_INITF)) ? 1U : 0U);
3505 }
3506
3507 /**
3508 * @brief Get Registers synchronization flag
3509 * @rmtoll RTC_ICSR RSF LL_RTC_IsActiveFlag_RS
3510 * @param RTCx RTC Instance
3511 * @retval State of bit (1 or 0).
3512 */
3513 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_RS(RTC_TypeDef *RTCx)
3514 {
3515 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_RSF) == (RTC_ICSR_RSF)) ? 1U : 0U);
3516 }
3517
3518 /**
3519 * @brief Clear Registers synchronization flag
3520 * @rmtoll RTC_ICSR RSF LL_RTC_ClearFlag_RS
3521 * @param RTCx RTC Instance
3522 * @retval None
3523 */
3524 __STATIC_INLINE void LL_RTC_ClearFlag_RS(RTC_TypeDef *RTCx)
3525 {
3526 WRITE_REG(RTCx->ICSR, (~((RTC_ICSR_RSF | RTC_ICSR_INIT) & 0x000000FFU) | (RTCx->ICSR & RTC_ICSR_INIT)));
3527 }
3528
3529 /**
3530 * @brief Get Initialization status flag
3531 * @rmtoll RTC_ICSR INITS LL_RTC_IsActiveFlag_INITS
3532 * @param RTCx RTC Instance
3533 * @retval State of bit (1 or 0).
3534 */
3535 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_INITS(RTC_TypeDef *RTCx)
3536 {
3537 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_INITS) == (RTC_ICSR_INITS)) ? 1U : 0U);
3538 }
3539
3540 /**
3541 * @brief Get Shift operation pending flag
3542 * @rmtoll RTC_ICSR SHPF LL_RTC_IsActiveFlag_SHP
3543 * @param RTCx RTC Instance
3544 * @retval State of bit (1 or 0).
3545 */
3546 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_SHP(RTC_TypeDef *RTCx)
3547 {
3548 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_SHPF) == (RTC_ICSR_SHPF)) ? 1U : 0U);
3549 }
3550
3551 /**
3552 * @brief Get Wakeup timer write flag
3553 * @rmtoll RTC_ICSR WUTWF LL_RTC_IsActiveFlag_WUTW
3554 * @param RTCx RTC Instance
3555 * @retval State of bit (1 or 0).
3556 */
3557 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_WUTW(RTC_TypeDef *RTCx)
3558 {
3559 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_WUTWF) == (RTC_ICSR_WUTWF)) ? 1U : 0U);
3560 }
3561
3562 /**
3563 * @brief Get Alarm B write flag
3564 * @rmtoll RTC_ICSR ALRBWF LL_RTC_IsActiveFlag_ALRBW
3565 * @param RTCx RTC Instance
3566 * @retval State of bit (1 or 0).
3567 */
3568 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ALRBW(RTC_TypeDef *RTCx)
3569 {
3570 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_ALRBWF) == (RTC_ICSR_ALRBWF)) ? 1U : 0U);
3571 }
3572
3573 /**
3574 * @brief Get Alarm A write flag
3575 * @rmtoll RTC_ICSR ALRAWF LL_RTC_IsActiveFlag_ALRAW
3576 * @param RTCx RTC Instance
3577 * @retval State of bit (1 or 0).
3578 */
3579 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ALRAW(RTC_TypeDef *RTCx)
3580 {
3581 return ((READ_BIT(RTCx->ICSR, RTC_ICSR_ALRAWF) == (RTC_ICSR_ALRAWF)) ? 1U : 0U);
3582 }
3583
3584 /**
3585 * @brief Get Alarm A masked flag.
3586 * @rmtoll RTC_MISR ALRAMF LL_RTC_IsActiveFlag_ALRAM
3587 * @param RTCx RTC Instance
3588 * @retval State of bit (1 or 0).
3589 */
3590 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ALRAM(RTC_TypeDef *RTCx)
3591 {
3592 return ((READ_BIT(RTCx->MISR, RTC_MISR_ALRAMF) == (RTC_MISR_ALRAMF)) ? 1U : 0U);
3593 }
3594
3595 /**
3596 * @brief Get Alarm B masked flag.
3597 * @rmtoll RTC_MISR ALRBMF LL_RTC_IsActiveFlag_ALRBM
3598 * @param RTCx RTC Instance
3599 * @retval State of bit (1 or 0).
3600 */
3601 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ALRBM(RTC_TypeDef *RTCx)
3602 {
3603 return ((READ_BIT(RTCx->MISR, RTC_MISR_ALRBMF) == (RTC_MISR_ALRBMF)) ? 1U : 0U);
3604 }
3605
3606 /**
3607 * @brief Get Wakeup timer masked flag.
3608 * @rmtoll RTC_MISR WUTMF LL_RTC_IsActiveFlag_WUTM
3609 * @param RTCx RTC Instance
3610 * @retval State of bit (1 or 0).
3611 */
3612 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_WUTM(RTC_TypeDef *RTCx)
3613 {
3614 return ((READ_BIT(RTCx->MISR, RTC_MISR_WUTMF) == (RTC_MISR_WUTMF)) ? 1U : 0U);
3615 }
3616
3617 /**
3618 * @brief Get Time-stamp masked flag.
3619 * @rmtoll RTC_MISR TSMF LL_RTC_IsActiveFlag_TSM
3620 * @param RTCx RTC Instance
3621 * @retval State of bit (1 or 0).
3622 */
3623 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TSM(RTC_TypeDef *RTCx)
3624 {
3625 return ((READ_BIT(RTCx->MISR, RTC_MISR_TSMF) == (RTC_MISR_TSMF)) ? 1U : 0U);
3626 }
3627
3628 /**
3629 * @brief Get Time-stamp overflow masked flag.
3630 * @rmtoll RTC_MISR TSOVMF LL_RTC_IsActiveFlag_TSOVM
3631 * @param RTCx RTC Instance
3632 * @retval State of bit (1 or 0).
3633 */
3634 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TSOVM(RTC_TypeDef *RTCx)
3635 {
3636 return ((READ_BIT(RTCx->MISR, RTC_MISR_TSOVMF) == (RTC_MISR_TSOVMF)) ? 1U : 0U);
3637 }
3638
3639 /**
3640 * @brief Get Internal Time-stamp masked flag.
3641 * @rmtoll RTC_MISR ITSMF LL_RTC_IsActiveFlag_ITSM
3642 * @param RTCx RTC Instance
3643 * @retval State of bit (1 or 0).
3644 */
3645 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITSM(RTC_TypeDef *RTCx)
3646 {
3647 return ((READ_BIT(RTCx->MISR, RTC_MISR_ITSMF) == (RTC_MISR_ITSMF)) ? 1U : 0U);
3648 }
3649
3650 /**
3651 * @brief Get tamper 1 detection flag.
3652 * @rmtoll TAMP_SR TAMP1F LL_RTC_IsActiveFlag_TAMP1
3653 * @param RTCx RTC Instance
3654 * @retval State of bit (1 or 0).
3655 */
3656 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP1(RTC_TypeDef *RTCx)
3657 {
3658 UNUSED(RTCx);
3659 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP1F) == (TAMP_SR_TAMP1F)) ? 1U : 0U);
3660 }
3661
3662 /**
3663 * @brief Get tamper 2 detection flag.
3664 * @rmtoll TAMP_SR TAMP2F LL_RTC_IsActiveFlag_TAMP2
3665 * @param RTCx RTC Instance
3666 * @retval State of bit (1 or 0).
3667 */
3668 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP2(RTC_TypeDef *RTCx)
3669 {
3670 UNUSED(RTCx);
3671 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP2F) == (TAMP_SR_TAMP2F)) ? 1U : 0U);
3672 }
3673
3674 #if (RTC_TAMP_NB==3)
3675 /**
3676 * @brief Get tamper 3 detection flag.
3677 * @rmtoll TAMP_SR TAMP3F LL_RTC_IsActiveFlag_TAMP3
3678 * @param RTCx RTC Instance
3679 * @retval State of bit (1 or 0).
3680 */
3681 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP3(RTC_TypeDef *RTCx)
3682 {
3683 UNUSED(RTCx);
3684 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP3F) == (TAMP_SR_TAMP3F)) ? 1U : 0U);
3685 }
3686 #elif (RTC_TAMP_NB==8)
3687
3688 /**
3689 * @brief Get tamper 3 detection flag.
3690 * @rmtoll TAMP_SR TAMP3F LL_RTC_IsActiveFlag_TAMP3
3691 * @param RTCx RTC Instance
3692 * @retval State of bit (1 or 0).
3693 */
3694 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP3(RTC_TypeDef *RTCx)
3695 {
3696 UNUSED(RTCx);
3697 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP3F) == (TAMP_SR_TAMP3F)) ? 1U : 0U);
3698 }
3699 /**
3700 * @brief Get tamper 4 detection flag.
3701 * @rmtoll TAMP_SR TAMP4F LL_RTC_IsActiveFlag_TAMP4
3702 * @param RTCx RTC Instance
3703 * @retval State of bit (1 or 0).
3704 */
3705 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP4(RTC_TypeDef *RTCx)
3706 {
3707 UNUSED(RTCx);
3708 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP4F) == (TAMP_SR_TAMP4F)) ? 1U : 0U);
3709 }
3710 /**
3711 * @brief Get tamper 5 detection flag.
3712 * @rmtoll TAMP_SR TAMP5F LL_RTC_IsActiveFlag_TAMP5
3713 * @param RTCx RTC Instance
3714 * @retval State of bit (1 or 0).
3715 */
3716 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP5(RTC_TypeDef *RTCx)
3717 {
3718 UNUSED(RTCx);
3719 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP5F) == (TAMP_SR_TAMP5F)) ? 1U : 0U);
3720 }
3721 /**
3722 * @brief Get tamper 6 detection flag.
3723 * @rmtoll TAMP_SR TAMP6F LL_RTC_IsActiveFlag_TAMP6
3724 * @param RTCx RTC Instance
3725 * @retval State of bit (1 or 0).
3726 */
3727 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP6(RTC_TypeDef *RTCx)
3728 {
3729 UNUSED(RTCx);
3730 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP6F) == (TAMP_SR_TAMP6F)) ? 1U : 0U);
3731 }
3732 /**
3733 * @brief Get tamper 7 detection flag.
3734 * @rmtoll TAMP_SR TAMP7F LL_RTC_IsActiveFlag_TAMP7
3735 * @param RTCx RTC Instance
3736 * @retval State of bit (1 or 0).
3737 */
3738 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP7(RTC_TypeDef *RTCx)
3739 {
3740 UNUSED(RTCx);
3741 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP7F) == (TAMP_SR_TAMP7F)) ? 1U : 0U);
3742 }
3743 /**
3744 * @brief Get tamper 8 detection flag.
3745 * @rmtoll TAMP_SR TAMP8F LL_RTC_IsActiveFlag_TAMP8
3746 * @param RTCx RTC Instance
3747 * @retval State of bit (1 or 0).
3748 */
3749 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP8(RTC_TypeDef *RTCx)
3750 {
3751 UNUSED(RTCx);
3752 return ((READ_BIT(TAMP->SR, TAMP_SR_TAMP8F) == (TAMP_SR_TAMP8F)) ? 1U : 0U);
3753 }
3754 #endif /* RTC_TAMP_NB */
3755
3756 #if defined (RTC_TAMP_INT_1_SUPPORT)
3757 /**
3758 * @brief Get internal tamper 1 detection flag.
3759 * @rmtoll TAMP_SR ITAMP1F LL_RTC_IsActiveFlag_ITAMP1
3760 * @param RTCx RTC Instance
3761 * @retval State of bit (1 or 0).
3762 */
3763 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP1(RTC_TypeDef *RTCx)
3764 {
3765 UNUSED(RTCx);
3766 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP1F) == (TAMP_SR_ITAMP1F)) ? 1U : 0U);
3767 }
3768
3769 #endif /* RTC_TAMP_INT_1_SUPPORT */
3770 #if defined (RTC_TAMP_INT_2_SUPPORT)
3771 /**
3772 * @brief Get internal tamper 2 detection flag.
3773 * @rmtoll TAMP_SR ITAMP2F LL_RTC_IsActiveFlag_ITAMP2
3774 * @param RTCx RTC Instance
3775 * @retval State of bit (1 or 0).
3776 */
3777 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP2(RTC_TypeDef *RTCx)
3778 {
3779 UNUSED(RTCx);
3780 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP2F) == (TAMP_SR_ITAMP2F)) ? 1U : 0U);
3781 }
3782
3783 #endif /* RTC_TAMP_INT_2_SUPPORT */
3784 /**
3785 * @brief Get internal tamper 3 detection flag.
3786 * @rmtoll TAMP_SR ITAMP3F LL_RTC_IsActiveFlag_ITAMP3
3787 * @param RTCx RTC Instance
3788 * @retval State of bit (1 or 0).
3789 */
3790 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP3(RTC_TypeDef *RTCx)
3791 {
3792 UNUSED(RTCx);
3793 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP3F) == (TAMP_SR_ITAMP3F)) ? 1U : 0U);
3794 }
3795
3796 /**
3797 * @brief Get internal tamper 4 detection flag.
3798 * @rmtoll TAMP_SR ITAMP4F LL_RTC_IsActiveFlag_ITAMP4
3799 * @param RTCx RTC Instance
3800 * @retval State of bit (1 or 0).
3801 */
3802 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP4(RTC_TypeDef *RTCx)
3803 {
3804 UNUSED(RTCx);
3805 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP4F) == (TAMP_SR_ITAMP4F)) ? 1U : 0U);
3806 }
3807 /**
3808 * @brief Get internal tamper 5 detection flag.
3809 * @rmtoll TAMP_SR ITAMP5F LL_RTC_IsActiveFlag_ITAMP5
3810 * @param RTCx RTC Instance
3811 * @retval State of bit (1 or 0).
3812 */
3813 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP5(RTC_TypeDef *RTCx)
3814 {
3815 UNUSED(RTCx);
3816 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP5F) == (TAMP_SR_ITAMP5F)) ? 1U : 0U);
3817 }
3818
3819 #if defined (RTC_TAMP_INT_6_SUPPORT)
3820 /**
3821 * @brief Get internal tamper 6 detection flag.
3822 * @rmtoll TAMP_SR ITAMP6F LL_RTC_IsActiveFlag_ITAMP6
3823 * @param RTCx RTC Instance
3824 * @retval State of bit (1 or 0).
3825 */
3826 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP6(RTC_TypeDef *RTCx)
3827 {
3828 UNUSED(RTCx);
3829 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP6F) == (TAMP_SR_ITAMP6F)) ? 1U : 0U);
3830 }
3831 #endif /* RTC_TAMP_INT_6_SUPPORT */
3832
3833 #if defined (RTC_TAMP_INT_7_SUPPORT)
3834 /**
3835 * @brief Get internal tamper 7 detection flag.
3836 * @rmtoll TAMP_SR ITAMP7F LL_RTC_IsActiveFlag_ITAMP7
3837 * @param RTCx RTC Instance
3838 * @retval State of bit (1 or 0).
3839 */
3840 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP7(RTC_TypeDef *RTCx)
3841 {
3842 UNUSED(RTCx);
3843 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP7F) == (TAMP_SR_ITAMP7F)) ? 1U : 0U);
3844 }
3845 #endif /* RTC_TAMP_INT_7_SUPPORT */
3846
3847 #if defined (RTC_TAMP_INT_8_SUPPORT)
3848 /**
3849 * @brief Get internal tamper 8 detection flag.
3850 * @rmtoll TAMP_SR ITAMP8F LL_RTC_IsActiveFlag_ITAMP8
3851 * @param RTCx RTC Instance
3852 * @retval State of bit (1 or 0).
3853 */
3854 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP8(RTC_TypeDef *RTCx)
3855 {
3856 UNUSED(RTCx);
3857 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP8F) == (TAMP_SR_ITAMP8F)) ? 1U : 0U);
3858 }
3859 #endif /* RTC_TAMP_INT_8_SUPPORT */
3860
3861 #if 0
3862 /**
3863 * @brief Get internal tamper 9 detection flag.
3864 * @rmtoll TAMP_SR ITAMP9F LL_RTC_IsActiveFlag_ITAMP9
3865 * @param RTCx RTC Instance
3866 * @retval State of bit (1 or 0).
3867 */
3868 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP9(RTC_TypeDef *RTCx)
3869 {
3870 UNUSED(RTCx);
3871 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP9F) == (TAMP_SR_ITAMP9F)) ? 1U : 0U);
3872 }
3873
3874 /**
3875 * @brief Get internal tamper 10 detection flag.
3876 * @rmtoll TAMP_SR ITAMP10F LL_RTC_IsActiveFlag_ITAMP10
3877 * @param RTCx RTC Instance
3878 * @retval State of bit (1 or 0).
3879 */
3880 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP10(RTC_TypeDef *RTCx)
3881 {
3882 UNUSED(RTCx);
3883 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP10F) == (TAMP_SR_ITAMP10F)) ? 1U : 0U);
3884 }
3885
3886 /**
3887 * @brief Get internal tamper 11 detection flag.
3888 * @rmtoll TAMP_SR ITAMP11F LL_RTC_IsActiveFlag_ITAMP11
3889 * @param RTCx RTC Instance
3890 * @retval State of bit (1 or 0).
3891 */
3892 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP11(RTC_TypeDef *RTCx)
3893 {
3894 UNUSED(RTCx);
3895 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP11F) == (TAMP_SR_ITAMP11F)) ? 1U : 0U);
3896 }
3897
3898 /**
3899 * @brief Get internal tamper 12 detection flag.
3900 * @rmtoll TAMP_SR ITAMP7F LL_RTC_IsActiveFlag_ITAMP12
3901 * @param RTCx RTC Instance
3902 * @retval State of bit (1 or 0).
3903 */
3904 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP12(RTC_TypeDef *RTCx)
3905 {
3906 UNUSED(RTCx);
3907 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP12F) == (TAMP_SR_ITAMP12F)) ? 1U : 0U);
3908 }
3909
3910 /**
3911 * @brief Get internal tamper 13 detection flag.
3912 * @rmtoll TAMP_SR ITAMP13F LL_RTC_IsActiveFlag_ITAMP13
3913 * @param RTCx RTC Instance
3914 * @retval State of bit (1 or 0).
3915 */
3916 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP13(RTC_TypeDef *RTCx)
3917 {
3918 UNUSED(RTCx);
3919 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP13F) == (TAMP_SR_ITAMP13F)) ? 1U : 0U);
3920 }
3921
3922 /**
3923 * @brief Get internal tamper 14 detection flag.
3924 * @rmtoll TAMP_SR ITAMP14F LL_RTC_IsActiveFlag_ITAMP14
3925 * @param RTCx RTC Instance
3926 * @retval State of bit (1 or 0).
3927 */
3928 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP14(RTC_TypeDef *RTCx)
3929 {
3930 UNUSED(RTCx);
3931 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP14F) == (TAMP_SR_ITAMP14F)) ? 1U : 0U);
3932 }
3933
3934 /**
3935 * @brief Get internal tamper 15 detection flag.
3936 * @rmtoll TAMP_SR ITAMP15F LL_RTC_IsActiveFlag_ITAMP15
3937 * @param RTCx RTC Instance
3938 * @retval State of bit (1 or 0).
3939 */
3940 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP15(RTC_TypeDef *RTCx)
3941 {
3942 UNUSED(RTCx);
3943 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP15F) == (TAMP_SR_ITAMP15F)) ? 1U : 0U);
3944 }
3945
3946 /**
3947 * @brief Get internal tamper 16 detection flag.
3948 * @rmtoll TAMP_SR ITAMP7F LL_RTC_IsActiveFlag_ITAMP16
3949 * @param RTCx RTC Instance
3950 * @retval State of bit (1 or 0).
3951 */
3952 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP16(RTC_TypeDef *RTCx)
3953 {
3954 UNUSED(RTCx);
3955 return ((READ_BIT(TAMP->SR, TAMP_SR_ITAMP16F) == (TAMP_SR_ITAMP16F)) ? 1U : 0U);
3956 }
3957 #endif /* 0 */
3958
3959 /**
3960 * @brief Get tamper 1 interrupt masked flag.
3961 * @rmtoll TAMP_MISR TAMP1MF LL_RTC_IsActiveFlag_TAMP1M
3962 * @param RTCx RTC Instance
3963 * @retval State of bit (1 or 0).
3964 */
3965 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP1M(RTC_TypeDef *RTCx)
3966 {
3967 UNUSED(RTCx);
3968 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP1MF) == (TAMP_MISR_TAMP1MF)) ? 1U : 0U);
3969 }
3970
3971 /**
3972 * @brief Get tamper 2 interrupt masked flag.
3973 * @rmtoll TAMP_MISR TAMP2MF LL_RTC_IsActiveFlag_TAMP2M
3974 * @param RTCx RTC Instance
3975 * @retval State of bit (1 or 0).
3976 */
3977 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP2M(RTC_TypeDef *RTCx)
3978 {
3979 UNUSED(RTCx);
3980 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP2MF) == (TAMP_MISR_TAMP2MF)) ? 1U : 0U);
3981 }
3982
3983 #if (RTC_TAMP_NB ==3)
3984 /**
3985 * @brief Get tamper 3 interrupt masked flag.
3986 * @rmtoll TAMP_MISR TAMP3MF LL_RTC_IsActiveFlag_TAMP3M
3987 * @param RTCx RTC Instance
3988 * @retval State of bit (1 or 0).
3989 */
3990 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP3M(RTC_TypeDef *RTCx)
3991 {
3992 UNUSED(RTCx);
3993 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP3MF) == (TAMP_MISR_TAMP3MF)) ? 1U : 0U);
3994 }
3995 #elif (RTC_TAMP_NB==8)
3996 /**
3997 * @brief Get tamper 3 interrupt masked flag.
3998 * @rmtoll TAMP_MISR TAMP3MF LL_RTC_IsActiveFlag_TAMP3M
3999 * @param RTCx RTC Instance
4000 * @retval State of bit (1 or 0).
4001 */
4002 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP3M(RTC_TypeDef *RTCx)
4003 {
4004 UNUSED(RTCx);
4005 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP3MF) == (TAMP_MISR_TAMP3MF)) ? 1U : 0U);
4006 }
4007 /**
4008 * @brief Get tamper 4 interrupt masked flag.
4009 * @rmtoll TAMP_MISR TAMP4MF LL_RTC_IsActiveFlag_TAMP4M
4010 * @param RTCx RTC Instance
4011 * @retval State of bit (1 or 0).
4012 */
4013 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP4M(RTC_TypeDef *RTCx)
4014 {
4015 UNUSED(RTCx);
4016 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP4MF) == (TAMP_MISR_TAMP4MF)) ? 1U : 0U);
4017 }
4018 /**
4019 * @brief Get tamper 5 interrupt masked flag.
4020 * @rmtoll TAMP_MISR TAMP5MF LL_RTC_IsActiveFlag_TAMP5M
4021 * @param RTCx RTC Instance
4022 * @retval State of bit (1 or 0).
4023 */
4024 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP5M(RTC_TypeDef *RTCx)
4025 {
4026 UNUSED(RTCx);
4027 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP5MF) == (TAMP_MISR_TAMP5MF)) ? 1U : 0U);
4028 }
4029 /**
4030 * @brief Get tamper 6 interrupt masked flag.
4031 * @rmtoll TAMP_MISR TAMP3MF LL_RTC_IsActiveFlag_TAMP6M
4032 * @param RTCx RTC Instance
4033 * @retval State of bit (1 or 0).
4034 */
4035 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP6M(RTC_TypeDef *RTCx)
4036 {
4037 UNUSED(RTCx);
4038 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP6MF) == (TAMP_MISR_TAMP6MF)) ? 1U : 0U);
4039 }
4040 /**
4041 * @brief Get tamper 7 interrupt masked flag.
4042 * @rmtoll TAMP_MISR TAMP7MF LL_RTC_IsActiveFlag_TAMP7M
4043 * @param RTCx RTC Instance
4044 * @retval State of bit (1 or 0).
4045 */
4046 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP7M(RTC_TypeDef *RTCx)
4047 {
4048 UNUSED(RTCx);
4049 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP7MF) == (TAMP_MISR_TAMP7MF)) ? 1U : 0U);
4050 }
4051 /**
4052 * @brief Get tamper 8 interrupt masked flag.
4053 * @rmtoll TAMP_MISR TAMP8MF LL_RTC_IsActiveFlag_TAMP8M
4054 * @param RTCx RTC Instance
4055 * @retval State of bit (1 or 0).
4056 */
4057 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_TAMP8M(RTC_TypeDef *RTCx)
4058 {
4059 UNUSED(RTCx);
4060 return ((READ_BIT(TAMP->MISR, TAMP_MISR_TAMP8MF) == (TAMP_MISR_TAMP8MF)) ? 1U : 0U);
4061 }
4062 #endif /* RTC_TAMP_NB */
4063
4064 #if defined (RTC_TAMP_INT_1_SUPPORT)
4065 /**
4066 * @brief Get internal tamper 1 interrupt masked flag.
4067 * @rmtoll TAMP_MISR ITAMP1MF LL_RTC_IsActiveFlag_ITAMP1M
4068 * @param RTCx RTC Instance
4069 * @retval State of bit (1 or 0).
4070 */
4071 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP1M(RTC_TypeDef *RTCx)
4072 {
4073 UNUSED(RTCx);
4074 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP1MF) == (TAMP_MISR_ITAMP1MF)) ? 1U : 0U);
4075 }
4076
4077 #endif /* RTC_TAMP_INT_1_SUPPORT */
4078 #if defined (RTC_TAMP_INT_2_SUPPORT)
4079 /**
4080 * @brief Get internal tamper 2 interrupt masked flag.
4081 * @rmtoll TAMP_MISR ITAMP2MF LL_RTC_IsActiveFlag_ITAMP2M
4082 * @param RTCx RTC Instance
4083 * @retval State of bit (1 or 0).
4084 */
4085 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP2M(RTC_TypeDef *RTCx)
4086 {
4087 UNUSED(RTCx);
4088 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP2MF) == (TAMP_MISR_ITAMP2MF)) ? 1U : 0U);
4089 }
4090
4091 #endif /* RTC_TAMP_INT_2_SUPPORT */
4092 /**
4093 * @brief Get internal tamper 3 interrupt masked flag.
4094 * @rmtoll TAMP_MISR ITAMP3MF LL_RTC_IsActiveFlag_ITAMP3M
4095 * @param RTCx RTC Instance
4096 * @retval State of bit (1 or 0).
4097 */
4098 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP3M(RTC_TypeDef *RTCx)
4099 {
4100 UNUSED(RTCx);
4101 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP3MF) == (TAMP_MISR_ITAMP3MF)) ? 1U : 0U);
4102 }
4103
4104 /**
4105 * @brief Get internal tamper 4 interrupt masked flag.
4106 * @rmtoll TAMP_MISR ITAMP4MF LL_RTC_IsActiveFlag_ITAMP4M
4107 * @param RTCx RTC Instance
4108 * @retval State of bit (1 or 0).
4109 */
4110 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP4M(RTC_TypeDef *RTCx)
4111 {
4112 UNUSED(RTCx);
4113 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP4MF) == (TAMP_MISR_ITAMP4MF)) ? 1U : 0U);
4114 }
4115
4116 /**
4117 * @brief Get internal tamper 5 interrupt masked flag.
4118 * @rmtoll TAMP_MISR ITAMP5MF LL_RTC_IsActiveFlag_ITAMP5M
4119 * @param RTCx RTC Instance
4120 * @retval State of bit (1 or 0).
4121 */
4122 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP5M(RTC_TypeDef *RTCx)
4123 {
4124 UNUSED(RTCx);
4125 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP5MF) == (TAMP_MISR_ITAMP5MF)) ? 1U : 0U);
4126 }
4127
4128 #if defined (RTC_TAMP_INT_6_SUPPORT)
4129 /**
4130 * @brief Get internal tamper 6 interrupt masked flag.
4131 * @rmtoll TAMP_MISR ITAMP6MF LL_RTC_IsActiveFlag_ITAMP6M
4132 * @param RTCx RTC Instance
4133 * @retval State of bit (1 or 0).
4134 */
4135 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP6M(RTC_TypeDef *RTCx)
4136 {
4137 UNUSED(RTCx);
4138 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP6MF) == (TAMP_MISR_ITAMP6MF)) ? 1U : 0U);
4139 }
4140 #endif /* RTC_TAMP_INT_6_SUPPORT */
4141
4142 #if defined (RTC_TAMP_INT_7_SUPPORT)
4143 /**
4144 * @brief Get internal tamper 7 interrupt masked flag.
4145 * @rmtoll TAMP_MISR ITAMP7MF LL_RTC_IsActiveFlag_ITAMP7M
4146 * @param RTCx RTC Instance
4147 * @retval State of bit (1 or 0).
4148 */
4149 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP7M(RTC_TypeDef *RTCx)
4150 {
4151 UNUSED(RTCx);
4152 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP7MF) == (TAMP_MISR_ITAMP7MF)) ? 1U : 0U);
4153 }
4154 #endif /* RTC_TAMP_INT_7_SUPPORT */
4155
4156 #if defined (RTC_TAMP_INT_8_SUPPORT)
4157 /**
4158 * @brief Get internal tamper 8 interrupt masked flag.
4159 * @rmtoll TAMP_MISR ITAMP8MF LL_RTC_IsActiveFlag_ITAMP8M
4160 * @param RTCx RTC Instance
4161 * @retval State of bit (1 or 0).
4162 */
4163 __STATIC_INLINE uint32_t LL_RTC_IsActiveFlag_ITAMP8M(RTC_TypeDef *RTCx)
4164 {
4165 UNUSED(RTCx);
4166 return ((READ_BIT(TAMP->MISR, TAMP_MISR_ITAMP8MF) == (TAMP_MISR_ITAMP8MF)) ? 1U : 0U);
4167 }
4168 #endif /* RTC_TAMP_INT_8_SUPPORT */
4169
4170 /**
4171 * @brief Clear tamper 1 detection flag.
4172 * @rmtoll TAMP_SCR CTAMP1F LL_RTC_ClearFlag_TAMP1
4173 * @param RTCx RTC Instance
4174 * @retval None
4175 */
4176 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP1(RTC_TypeDef *RTCx)
4177 {
4178 UNUSED(RTCx);
4179 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP1F);
4180 }
4181
4182 /**
4183 * @brief Clear tamper 2 detection flag.
4184 * @rmtoll TAMP_SCR CTAMP2F LL_RTC_ClearFlag_TAMP2
4185 * @param RTCx RTC Instance
4186 * @retval None
4187 */
4188 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP2(RTC_TypeDef *RTCx)
4189 {
4190 UNUSED(RTCx);
4191 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP2F);
4192 }
4193
4194 #if (RTC_TAMP_NB == 3)
4195 /**
4196 * @brief Clear tamper 3 detection flag.
4197 * @rmtoll TAMP_SCR CTAMP3F LL_RTC_ClearFlag_TAMP3
4198 * @param RTCx RTC Instance
4199 * @retval None
4200 */
4201 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP3(RTC_TypeDef *RTCx)
4202 {
4203 UNUSED(RTCx);
4204 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP3F);
4205 }
4206 #elif (RTC_TAMP_NB == 8)
4207 /**
4208 * @brief Clear tamper 3 detection flag.
4209 * @rmtoll TAMP_SCR CTAMP3F LL_RTC_ClearFlag_TAMP3
4210 * @param RTCx RTC Instance
4211 * @retval None
4212 */
4213 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP3(RTC_TypeDef *RTCx)
4214 {
4215 UNUSED(RTCx);
4216 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP3F);
4217 }
4218 /**
4219 * @brief Clear tamper 4 detection flag.
4220 * @rmtoll TAMP_SCR CTAMP3F LL_RTC_ClearFlag_TAMP4
4221 * @param RTCx RTC Instance
4222 * @retval None
4223 */
4224 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP4(RTC_TypeDef *RTCx)
4225 {
4226 UNUSED(RTCx);
4227 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP4F);
4228 }
4229 /**
4230 * @brief Clear tamper 5 detection flag.
4231 * @rmtoll TAMP_SCR CTAMP5F LL_RTC_ClearFlag_TAMP5
4232 * @param RTCx RTC Instance
4233 * @retval None
4234 */
4235 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP5(RTC_TypeDef *RTCx)
4236 {
4237 UNUSED(RTCx);
4238 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP5F);
4239 }
4240 /**
4241 * @brief Clear tamper 6 detection flag.
4242 * @rmtoll TAMP_SCR CTAMP6F LL_RTC_ClearFlag_TAMP6
4243 * @param RTCx RTC Instance
4244 * @retval None
4245 */
4246 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP6(RTC_TypeDef *RTCx)
4247 {
4248 UNUSED(RTCx);
4249 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP6F);
4250 }
4251 /**
4252 * @brief Clear tamper 7 detection flag.
4253 * @rmtoll TAMP_SCR CTAMP7F LL_RTC_ClearFlag_TAMP7
4254 * @param RTCx RTC Instance
4255 * @retval None
4256 */
4257 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP7(RTC_TypeDef *RTCx)
4258 {
4259 UNUSED(RTCx);
4260 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP7F);
4261 }
4262 /**
4263 * @brief Clear tamper 8 detection flag.
4264 * @rmtoll TAMP_SCR CTAMP8F LL_RTC_ClearFlag_TAMP8
4265 * @param RTCx RTC Instance
4266 * @retval None
4267 */
4268 __STATIC_INLINE void LL_RTC_ClearFlag_TAMP8(RTC_TypeDef *RTCx)
4269 {
4270 UNUSED(RTCx);
4271 SET_BIT(TAMP->SCR, TAMP_SCR_CTAMP8F);
4272 }
4273
4274 #endif /* RTC_TAMP_NB */
4275
4276 #if defined (RTC_TAMP_INT_1_SUPPORT)
4277 /**
4278 * @brief Clear internal tamper 1 detection flag.
4279 * @rmtoll TAMP_SCR CITAMP1F LL_RTC_ClearFlag_ITAMP1
4280 * @param RTCx RTC Instance
4281 * @retval None
4282 */
4283 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP1(RTC_TypeDef *RTCx)
4284 {
4285 UNUSED(RTCx);
4286 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP1F);
4287 }
4288
4289 #endif /* RTC_TAMP_INT_1_SUPPORT */
4290 #if defined (RTC_TAMP_INT_2_SUPPORT)
4291 /**
4292 * @brief Clear internal tamper 2 detection flag.
4293 * @rmtoll TAMP_SCR CITAMP2F LL_RTC_ClearFlag_ITAMP2
4294 * @param RTCx RTC Instance
4295 * @retval None
4296 */
4297 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP2(RTC_TypeDef *RTCx)
4298 {
4299 UNUSED(RTCx);
4300 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP2F);
4301 }
4302
4303 #endif /* RTC_TAMP_INT_2_SUPPORT */
4304 /**
4305 * @brief Clear internal tamper 3 detection flag.
4306 * @rmtoll TAMP_SCR CITAMP3F LL_RTC_ClearFlag_ITAMP3
4307 * @param RTCx RTC Instance
4308 * @retval None
4309 */
4310 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP3(RTC_TypeDef *RTCx)
4311 {
4312 UNUSED(RTCx);
4313 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP3F);
4314 }
4315
4316 /**
4317 * @brief Clear internal tamper 4 detection flag.
4318 * @rmtoll TAMP_SCR CITAMP4F LL_RTC_ClearFlag_ITAMP4
4319 * @param RTCx RTC Instance
4320 * @retval None
4321 */
4322 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP4(RTC_TypeDef *RTCx)
4323 {
4324 UNUSED(RTCx);
4325 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP4F);
4326 }
4327
4328 /**
4329 * @brief Clear internal tamper 5 detection flag.
4330 * @rmtoll TAMP_SCR CITAMP5F LL_RTC_ClearFlag_ITAMP5
4331 * @param RTCx RTC Instance
4332 * @retval None
4333 */
4334 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP5(RTC_TypeDef *RTCx)
4335 {
4336 UNUSED(RTCx);
4337 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP5F);
4338 }
4339
4340 #if defined (RTC_TAMP_INT_6_SUPPORT)
4341 /**
4342 * @brief Clear internal tamper 6 detection flag.
4343 * @rmtoll TAMP_SCR CITAMP6F LL_RTC_ClearFlag_ITAMP6
4344 * @param RTCx RTC Instance
4345 * @retval None
4346 */
4347 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP6(RTC_TypeDef *RTCx)
4348 {
4349 UNUSED(RTCx);
4350 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP6F);
4351 }
4352 #endif /* (RTC_TAMP_INT_2_SUPPORT)*/
4353
4354 #if defined (RTC_TAMP_INT_7_SUPPORT)
4355 /**
4356 * @brief Clear internal tamper 7 detection flag.
4357 * @rmtoll TAMP_SCR CITAMP7F LL_RTC_ClearFlag_ITAMP7
4358 * @param RTCx RTC Instance
4359 * @retval None
4360 */
4361 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP7(RTC_TypeDef *RTCx)
4362 {
4363 UNUSED(RTCx);
4364 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP7F);
4365 }
4366 #endif /* (RTC_TAMP_INT_7_SUPPORT) */
4367
4368 #if defined (RTC_TAMP_INT_8_SUPPORT)
4369 /**
4370 * @brief Clear internal tamper 8 detection flag.
4371 * @rmtoll TAMP_SCR CITAMP8F LL_RTC_ClearFlag_ITAMP8
4372 * @param RTCx RTC Instance
4373 * @retval None
4374 */
4375 __STATIC_INLINE void LL_RTC_ClearFlag_ITAMP8(RTC_TypeDef *RTCx)
4376 {
4377 UNUSED(RTCx);
4378 SET_BIT(TAMP->SCR, TAMP_SCR_CITAMP8F);
4379 }
4380 #endif /* (RTC_TAMP_INT_8_SUPPORT) */
4381
4382 /**
4383 * @}
4384 */
4385
4386 /** @defgroup RTC_LL_EF_IT_Management IT_Management
4387 * @{
4388 */
4389
4390 /**
4391 * @brief Enable Time-stamp interrupt
4392 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4393 * @rmtoll RTC_CR LL_RTC_EnableIT_TS
4394 * @param RTCx RTC Instance
4395 * @retval None
4396 */
4397 __STATIC_INLINE void LL_RTC_EnableIT_TS(RTC_TypeDef *RTCx)
4398 {
4399 SET_BIT(RTCx->CR, RTC_CR_TSIE);
4400 }
4401
4402 /**
4403 * @brief Disable Time-stamp interrupt
4404 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4405 * @rmtoll RTC_CR LL_RTC_DisableIT_TS
4406 * @param RTCx RTC Instance
4407 * @retval None
4408 */
4409 __STATIC_INLINE void LL_RTC_DisableIT_TS(RTC_TypeDef *RTCx)
4410 {
4411 CLEAR_BIT(RTCx->CR, RTC_CR_TSIE);
4412 }
4413
4414 /**
4415 * @brief Enable Wakeup timer interrupt
4416 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4417 * @rmtoll RTC_CR LL_RTC_EnableIT_WUT
4418 * @param RTCx RTC Instance
4419 * @retval None
4420 */
4421 __STATIC_INLINE void LL_RTC_EnableIT_WUT(RTC_TypeDef *RTCx)
4422 {
4423 SET_BIT(RTCx->CR, RTC_CR_WUTIE);
4424 }
4425
4426 /**
4427 * @brief Disable Wakeup timer interrupt
4428 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4429 * @rmtoll RTC_CR LL_RTC_DisableIT_WUT
4430 * @param RTCx RTC Instance
4431 * @retval None
4432 */
4433 __STATIC_INLINE void LL_RTC_DisableIT_WUT(RTC_TypeDef *RTCx)
4434 {
4435 CLEAR_BIT(RTCx->CR, RTC_CR_WUTIE);
4436 }
4437
4438 /**
4439 * @brief Enable Alarm B interrupt
4440 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4441 * @rmtoll RTC_CR ALRBIE LL_RTC_EnableIT_ALRB
4442 * @param RTCx RTC Instance
4443 * @retval None
4444 */
4445 __STATIC_INLINE void LL_RTC_EnableIT_ALRB(RTC_TypeDef *RTCx)
4446 {
4447 SET_BIT(RTCx->CR, RTC_CR_ALRBIE);
4448 }
4449
4450 /**
4451 * @brief Disable Alarm B interrupt
4452 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4453 * @rmtoll RTC_CR ALRBIE LL_RTC_DisableIT_ALRB
4454 * @param RTCx RTC Instance
4455 * @retval None
4456 */
4457 __STATIC_INLINE void LL_RTC_DisableIT_ALRB(RTC_TypeDef *RTCx)
4458 {
4459 CLEAR_BIT(RTCx->CR, RTC_CR_ALRBIE);
4460 }
4461
4462 /**
4463 * @brief Enable Alarm A interrupt
4464 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4465 * @rmtoll RTC_CR ALRAIE LL_RTC_EnableIT_ALRA
4466 * @param RTCx RTC Instance
4467 * @retval None
4468 */
4469 __STATIC_INLINE void LL_RTC_EnableIT_ALRA(RTC_TypeDef *RTCx)
4470 {
4471 SET_BIT(RTCx->CR, RTC_CR_ALRAIE);
4472 }
4473
4474 /**
4475 * @brief Disable Alarm A interrupt
4476 * @note Bit is write-protected. @ref LL_RTC_DisableWriteProtection function should be called before.
4477 * @rmtoll RTC_CR ALRAIE LL_RTC_DisableIT_ALRA
4478 * @param RTCx RTC Instance
4479 * @retval None
4480 */
4481 __STATIC_INLINE void LL_RTC_DisableIT_ALRA(RTC_TypeDef *RTCx)
4482 {
4483 CLEAR_BIT(RTCx->CR, RTC_CR_ALRAIE);
4484 }
4485
4486 /**
4487 * @brief Check if Time-stamp interrupt is enabled or not
4488 * @rmtoll RTC_CR TSIE LL_RTC_IsEnabledIT_TS
4489 * @param RTCx RTC Instance
4490 * @retval State of bit (1 or 0).
4491 */
4492 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TS(RTC_TypeDef *RTCx)
4493 {
4494 return ((READ_BIT(RTCx->CR, RTC_CR_TSIE) == (RTC_CR_TSIE)) ? 1U : 0U);
4495 }
4496
4497 /**
4498 * @brief Check if Wakeup timer interrupt is enabled or not
4499 * @rmtoll RTC_CR WUTIE LL_RTC_IsEnabledIT_WUT
4500 * @param RTCx RTC Instance
4501 * @retval State of bit (1 or 0).
4502 */
4503 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_WUT(RTC_TypeDef *RTCx)
4504 {
4505 return ((READ_BIT(RTCx->CR, RTC_CR_WUTIE) == (RTC_CR_WUTIE)) ? 1U : 0U);
4506 }
4507
4508 /**
4509 * @brief Check if Alarm B interrupt is enabled or not
4510 * @rmtoll RTC_CR ALRBIE LL_RTC_IsEnabledIT_ALRB
4511 * @param RTCx RTC Instance
4512 * @retval State of bit (1 or 0).
4513 */
4514 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ALRB(RTC_TypeDef *RTCx)
4515 {
4516 return ((READ_BIT(RTCx->CR, RTC_CR_ALRBIE) == (RTC_CR_ALRBIE)) ? 1U : 0U);
4517 }
4518
4519 /**
4520 * @brief Check if Alarm A interrupt is enabled or not
4521 * @rmtoll RTC_CR ALRAIE LL_RTC_IsEnabledIT_ALRA
4522 * @param RTCx RTC Instance
4523 * @retval State of bit (1 or 0).
4524 */
4525 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ALRA(RTC_TypeDef *RTCx)
4526 {
4527 return ((READ_BIT(RTCx->CR, RTC_CR_ALRAIE) == (RTC_CR_ALRAIE)) ? 1U : 0U);
4528 }
4529
4530 /**
4531 * @brief Enable tamper 1 interrupt.
4532 * @rmtoll TAMP_IER TAMP1IE LL_RTC_EnableIT_TAMP1
4533 * @param RTCx RTC Instance
4534 * @retval None
4535 */
4536 __STATIC_INLINE void LL_RTC_EnableIT_TAMP1(RTC_TypeDef *RTCx)
4537 {
4538 UNUSED(RTCx);
4539 SET_BIT(TAMP->IER, TAMP_IER_TAMP1IE);
4540 }
4541
4542 /**
4543 * @brief Disable tamper 1 interrupt.
4544 * @rmtoll TAMP_IER TAMP1IE LL_RTC_DisableIT_TAMP1
4545 * @param RTCx RTC Instance
4546 * @retval None
4547 */
4548 __STATIC_INLINE void LL_RTC_DisableIT_TAMP1(RTC_TypeDef *RTCx)
4549 {
4550 UNUSED(RTCx);
4551 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP1IE);
4552 }
4553
4554 /**
4555 * @brief Enable tamper 2 interrupt.
4556 * @rmtoll TAMP_IER TAMP2IE LL_RTC_EnableIT_TAMP2
4557 * @param RTCx RTC Instance
4558 * @retval None
4559 */
4560 __STATIC_INLINE void LL_RTC_EnableIT_TAMP2(RTC_TypeDef *RTCx)
4561 {
4562 UNUSED(RTCx);
4563 SET_BIT(TAMP->IER, TAMP_IER_TAMP2IE);
4564 }
4565
4566 /**
4567 * @brief Disable tamper 2 interrupt.
4568 * @rmtoll TAMP_IER TAMP2IE LL_RTC_DisableIT_TAMP2
4569 * @param RTCx RTC Instance
4570 * @retval None
4571 */
4572 __STATIC_INLINE void LL_RTC_DisableIT_TAMP2(RTC_TypeDef *RTCx)
4573 {
4574 UNUSED(RTCx);
4575 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP2IE);
4576 }
4577
4578 #if (RTC_TAMP_NB == 3)
4579 /**
4580 * @brief Enable tamper 3 interrupt.
4581 * @rmtoll TAMP_IER TAMP3IE LL_RTC_EnableIT_TAMP3
4582 * @param RTCx RTC Instance
4583 * @retval None
4584 */
4585 __STATIC_INLINE void LL_RTC_EnableIT_TAMP3(RTC_TypeDef *RTCx)
4586 {
4587 UNUSED(RTCx);
4588 SET_BIT(TAMP->IER, TAMP_IER_TAMP3IE);
4589 }
4590 /**
4591 * @brief Disable tamper 3 interrupt.
4592 * @rmtoll TAMP_IER TAMP3IE LL_RTC_DisableIT_TAMP3
4593 * @param RTCx RTC Instance
4594 * @retval None
4595 */
4596 __STATIC_INLINE void LL_RTC_DisableIT_TAMP3(RTC_TypeDef *RTCx)
4597 {
4598 UNUSED(RTCx);
4599 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP3IE);
4600 }
4601 #elif (RTC_TAMP_NB == 8)
4602 /**
4603 * @brief Enable tamper 3 interrupt.
4604 * @rmtoll TAMP_IER TAMP3IE LL_RTC_EnableIT_TAMP3
4605 * @param RTCx RTC Instance
4606 * @retval None
4607 */
4608 __STATIC_INLINE void LL_RTC_EnableIT_TAMP3(RTC_TypeDef *RTCx)
4609 {
4610 UNUSED(RTCx);
4611 SET_BIT(TAMP->IER, TAMP_IER_TAMP3IE);
4612 }
4613 /**
4614 * @brief Disable tamper 3 interrupt.
4615 * @rmtoll TAMP_IER TAMP3IE LL_RTC_DisableIT_TAMP3
4616 * @param RTCx RTC Instance
4617 * @retval None
4618 */
4619 __STATIC_INLINE void LL_RTC_DisableIT_TAMP3(RTC_TypeDef *RTCx)
4620 {
4621 UNUSED(RTCx);
4622 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP3IE);
4623 }
4624 /**
4625 * @brief Enable tamper 4 interrupt.
4626 * @rmtoll TAMP_IER TAMP4IE LL_RTC_EnableIT_TAMP4
4627 * @param RTCx RTC Instance
4628 * @retval None
4629 */
4630 __STATIC_INLINE void LL_RTC_EnableIT_TAMP4(RTC_TypeDef *RTCx)
4631 {
4632 UNUSED(RTCx);
4633 SET_BIT(TAMP->IER, TAMP_IER_TAMP4IE);
4634 }
4635 /**
4636 * @brief Disable tamper 4 interrupt.
4637 * @rmtoll TAMP_IER TAMP4IE LL_RTC_DisableIT_TAMP4
4638 * @param RTCx RTC Instance
4639 * @retval None
4640 */
4641 __STATIC_INLINE void LL_RTC_DisableIT_TAMP4(RTC_TypeDef *RTCx)
4642 {
4643 UNUSED(RTCx);
4644 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP4IE);
4645 }
4646
4647 /**
4648 * @brief Enable tamper 5 interrupt.
4649 * @rmtoll TAMP_IER TAMP5IE LL_RTC_EnableIT_TAMP5
4650 * @param RTCx RTC Instance
4651 * @retval None
4652 */
4653 __STATIC_INLINE void LL_RTC_EnableIT_TAMP5(RTC_TypeDef *RTCx)
4654 {
4655 UNUSED(RTCx);
4656 SET_BIT(TAMP->IER, TAMP_IER_TAMP5IE);
4657 }
4658 /**
4659 * @brief Disable tamper 5 interrupt.
4660 * @rmtoll TAMP_IER TAMP5IE LL_RTC_DisableIT_TAMP5
4661 * @param RTCx RTC Instance
4662 * @retval None
4663 */
4664 __STATIC_INLINE void LL_RTC_DisableIT_TAMP5(RTC_TypeDef *RTCx)
4665 {
4666 UNUSED(RTCx);
4667 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP5IE);
4668 }
4669
4670 /**
4671 * @brief Enable tamper 6 interrupt.
4672 * @rmtoll TAMP_IER TAMP6IE LL_RTC_EnableIT_TAMP6
4673 * @param RTCx RTC Instance
4674 * @retval None
4675 */
4676 __STATIC_INLINE void LL_RTC_EnableIT_TAMP6(RTC_TypeDef *RTCx)
4677 {
4678 UNUSED(RTCx);
4679 SET_BIT(TAMP->IER, TAMP_IER_TAMP6IE);
4680 }
4681 /**
4682 * @brief Disable tamper 6 interrupt.
4683 * @rmtoll TAMP_IER TAMP6IE LL_RTC_DisableIT_TAMP6
4684 * @param RTCx RTC Instance
4685 * @retval None
4686 */
4687 __STATIC_INLINE void LL_RTC_DisableIT_TAMP6(RTC_TypeDef *RTCx)
4688 {
4689 UNUSED(RTCx);
4690 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP6IE);
4691 }
4692
4693 /**
4694 * @brief Enable tamper 7 interrupt.
4695 * @rmtoll TAMP_IER TAMP7IE LL_RTC_EnableIT_TAMP7
4696 * @param RTCx RTC Instance
4697 * @retval None
4698 */
4699 __STATIC_INLINE void LL_RTC_EnableIT_TAMP7(RTC_TypeDef *RTCx)
4700 {
4701 UNUSED(RTCx);
4702 SET_BIT(TAMP->IER, TAMP_IER_TAMP7IE);
4703 }
4704 /**
4705 * @brief Disable tamper 7 interrupt.
4706 * @rmtoll TAMP_IER TAMP7IE LL_RTC_DisableIT_TAMP7
4707 * @param RTCx RTC Instance
4708 * @retval None
4709 */
4710 __STATIC_INLINE void LL_RTC_DisableIT_TAMP7(RTC_TypeDef *RTCx)
4711 {
4712 UNUSED(RTCx);
4713 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP7IE);
4714 }
4715
4716 /**
4717 * @brief Enable tamper 8 interrupt.
4718 * @rmtoll TAMP_IER TAMP8IE LL_RTC_EnableIT_TAMP8
4719 * @param RTCx RTC Instance
4720 * @retval None
4721 */
4722 __STATIC_INLINE void LL_RTC_EnableIT_TAMP8(RTC_TypeDef *RTCx)
4723 {
4724 UNUSED(RTCx);
4725 SET_BIT(TAMP->IER, TAMP_IER_TAMP8IE);
4726 }
4727 /**
4728 * @brief Disable tamper 8 interrupt.
4729 * @rmtoll TAMP_IER TAMP8IE LL_RTC_DisableIT_TAMP8
4730 * @param RTCx RTC Instance
4731 * @retval None
4732 */
4733 __STATIC_INLINE void LL_RTC_DisableIT_TAMP8(RTC_TypeDef *RTCx)
4734 {
4735 UNUSED(RTCx);
4736 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP8IE);
4737 }
4738 #endif /* RTC_TAMP_NB */
4739
4740 #if 0
4741 /**
4742 * @brief Enable tamper 92 interrupt.
4743 * @rmtoll TAMP_IER TAMP9IE LL_RTC_EnableIT_TAMP9
4744 * @param RTCx RTC Instance
4745 * @retval None
4746 */
4747 __STATIC_INLINE void LL_RTC_EnableIT_TAMP9(RTC_TypeDef *RTCx)
4748 {
4749 UNUSED(RTCx);
4750 SET_BIT(TAMP->IER, TAMP_IER_TAMP9IE);
4751 }
4752
4753 /**
4754 * @brief Disable tamper 9 interrupt.
4755 * @rmtoll TAMP_IER TAMP9IE LL_RTC_DisableIT_TAMP9
4756 * @param RTCx RTC Instance
4757 * @retval None
4758 */
4759 __STATIC_INLINE void LL_RTC_DisableIT_TAMP9(RTC_TypeDef *RTCx)
4760 {
4761 UNUSED(RTCx);
4762 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP9IE);
4763 }
4764 /**
4765 * @brief Enable tamper 10 interrupt.
4766 * @rmtoll TAMP_IER TAMP10IE LL_RTC_EnableIT_TAMP10
4767 * @param RTCx RTC Instance
4768 * @retval None
4769 */
4770 __STATIC_INLINE void LL_RTC_EnableIT_TAMP10(RTC_TypeDef *RTCx)
4771 {
4772 UNUSED(RTCx);
4773 SET_BIT(TAMP->IER, TAMP_IER_TAMP10IE);
4774 }
4775
4776 /**
4777 * @brief Disable tamper 10 interrupt.
4778 * @rmtoll TAMP_IER TAMP10IE LL_RTC_DisableIT_TAMP10
4779 * @param RTCx RTC Instance
4780 * @retval None
4781 */
4782 __STATIC_INLINE void LL_RTC_DisableIT_TAMP10(RTC_TypeDef *RTCx)
4783 {
4784 UNUSED(RTCx);
4785 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP10IE);
4786 }
4787 /**
4788 * @brief Enable tamper 11 interrupt.
4789 * @rmtoll TAMP_IER TAMP11IE LL_RTC_EnableIT_TAMP11
4790 * @param RTCx RTC Instance
4791 * @retval None
4792 */
4793 __STATIC_INLINE void LL_RTC_EnableIT_TAMP11(RTC_TypeDef *RTCx)
4794 {
4795 UNUSED(RTCx);
4796 SET_BIT(TAMP->IER, TAMP_IER_TAMP11IE);
4797 }
4798
4799 /**
4800 * @brief Disable tamper 11 interrupt.
4801 * @rmtoll TAMP_IER TAMP11IE LL_RTC_DisableIT_TAMP11
4802 * @param RTCx RTC Instance
4803 * @retval None
4804 */
4805 __STATIC_INLINE void LL_RTC_DisableIT_TAMP11(RTC_TypeDef *RTCx)
4806 {
4807 UNUSED(RTCx);
4808 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP11IE);
4809 }
4810 /**
4811 * @brief Enable tamper 12 interrupt.
4812 * @rmtoll TAMP_IER TAMP12IE LL_RTC_EnableIT_TAMP12
4813 * @param RTCx RTC Instance
4814 * @retval None
4815 */
4816 __STATIC_INLINE void LL_RTC_EnableIT_TAMP12(RTC_TypeDef *RTCx)
4817 {
4818 UNUSED(RTCx);
4819 SET_BIT(TAMP->IER, TAMP_IER_TAMP12IE);
4820 }
4821
4822 /**
4823 * @brief Disable tamper 12 interrupt.
4824 * @rmtoll TAMP_IER TAMP12IE LL_RTC_DisableIT_TAMP12
4825 * @param RTCx RTC Instance
4826 * @retval None
4827 */
4828 __STATIC_INLINE void LL_RTC_DisableIT_TAMP12(RTC_TypeDef *RTCx)
4829 {
4830 UNUSED(RTCx);
4831 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP12IE);
4832 }
4833 /**
4834 * @brief Enable tamper 13 interrupt.
4835 * @rmtoll TAMP_IER TAMP13IE LL_RTC_EnableIT_TAMP13
4836 * @param RTCx RTC Instance
4837 * @retval None
4838 */
4839 __STATIC_INLINE void LL_RTC_EnableIT_TAMP13(RTC_TypeDef *RTCx)
4840 {
4841 UNUSED(RTCx);
4842 SET_BIT(TAMP->IER, TAMP_IER_TAMP13IE);
4843 }
4844
4845 /**
4846 * @brief Disable tamper 13 interrupt.
4847 * @rmtoll TAMP_IER TAMP13IE LL_RTC_DisableIT_TAMP13
4848 * @param RTCx RTC Instance
4849 * @retval None
4850 */
4851 __STATIC_INLINE void LL_RTC_DisableIT_TAMP13(RTC_TypeDef *RTCx)
4852 {
4853 UNUSED(RTCx);
4854 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP13IE);
4855 }
4856 /**
4857 * @brief Enable tamper 14 interrupt.
4858 * @rmtoll TAMP_IER TAMP14IE LL_RTC_EnableIT_TAMP14
4859 * @param RTCx RTC Instance
4860 * @retval None
4861 */
4862 __STATIC_INLINE void LL_RTC_EnableIT_TAMP14(RTC_TypeDef *RTCx)
4863 {
4864 UNUSED(RTCx);
4865 SET_BIT(TAMP->IER, TAMP_IER_TAMP14IE);
4866 }
4867
4868 /**
4869 * @brief Disable tamper 14 interrupt.
4870 * @rmtoll TAMP_IER TAMP14IE LL_RTC_DisableIT_TAMP14
4871 * @param RTCx RTC Instance
4872 * @retval None
4873 */
4874 __STATIC_INLINE void LL_RTC_DisableIT_TAMP14(RTC_TypeDef *RTCx)
4875 {
4876 UNUSED(RTCx);
4877 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP14IE);
4878 }
4879 /**
4880 * @brief Enable tamper 15 interrupt.
4881 * @rmtoll TAMP_IER TAMP15IE LL_RTC_EnableIT_TAMP15
4882 * @param RTCx RTC Instance
4883 * @retval None
4884 */
4885 __STATIC_INLINE void LL_RTC_EnableIT_TAMP15(RTC_TypeDef *RTCx)
4886 {
4887 UNUSED(RTCx);
4888 SET_BIT(TAMP->IER, TAMP_IER_TAMP15IE);
4889 }
4890
4891 /**
4892 * @brief Disable tamper 15 interrupt.
4893 * @rmtoll TAMP_IER TAMP15IE LL_RTC_DisableIT_TAMP15
4894 * @param RTCx RTC Instance
4895 * @retval None
4896 */
4897 __STATIC_INLINE void LL_RTC_DisableIT_TAMP15(RTC_TypeDef *RTCx)
4898 {
4899 UNUSED(RTCx);
4900 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP15IE);
4901 }
4902 /**
4903 * @brief Enable tamper 16 interrupt.
4904 * @rmtoll TAMP_IER TAMP16IE LL_RTC_EnableIT_TAMP16
4905 * @param RTCx RTC Instance
4906 * @retval None
4907 */
4908 __STATIC_INLINE void LL_RTC_EnableIT_TAMP16(RTC_TypeDef *RTCx)
4909 {
4910 UNUSED(RTCx);
4911 SET_BIT(TAMP->IER, TAMP_IER_TAMP16IE);
4912 }
4913
4914 /**
4915 * @brief Disable tamper 16 interrupt.
4916 * @rmtoll TAMP_IER TAMP16IE LL_RTC_DisableIT_TAMP16
4917 * @param RTCx RTC Instance
4918 * @retval None
4919 */
4920 __STATIC_INLINE void LL_RTC_DisableIT_TAMP16(RTC_TypeDef *RTCx)
4921 {
4922 UNUSED(RTCx);
4923 CLEAR_BIT(TAMP->IER, TAMP_IER_TAMP16IE);
4924 }
4925 #endif /* 0 */
4926
4927 #if defined (RTC_TAMP_INT_1_SUPPORT)
4928 /**
4929 * @brief Enable internal tamper 1 interrupt.
4930 * @rmtoll TAMP_IER ITAMP1IE LL_RTC_EnableIT_ITAMP1
4931 * @param RTCx RTC Instance
4932 * @retval None
4933 */
4934 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP1(RTC_TypeDef *RTCx)
4935 {
4936 UNUSED(RTCx);
4937 SET_BIT(TAMP->IER, TAMP_IER_ITAMP1IE);
4938 }
4939 /**
4940 * @brief Disable internal tamper 1 interrupt.
4941 * @rmtoll TAMP_IER TAMP1IE LL_RTC_DisableIT_ITAMP1
4942 * @param RTCx RTC Instance
4943 * @retval None
4944 */
4945 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP1(RTC_TypeDef *RTCx)
4946 {
4947 UNUSED(RTCx);
4948 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP1IE);
4949 }
4950 #endif /* RTC_TAMP_INT_1_SUPPORT */
4951
4952 #if defined (RTC_TAMP_INT_2_SUPPORT)
4953 /**
4954 * @brief Enable internal tamper 2 interrupt.
4955 * @rmtoll TAMP_IER ITAMP2IE LL_RTC_EnableIT_ITAMP2
4956 * @param RTCx RTC Instance
4957 * @retval None
4958 */
4959 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP2(RTC_TypeDef *RTCx)
4960 {
4961 UNUSED(RTCx);
4962 SET_BIT(TAMP->IER, TAMP_IER_ITAMP2IE);
4963 }
4964 /**
4965 * @brief Disable internal tamper 2 interrupt.
4966 * @rmtoll TAMP_IER TAMP2IE LL_RTC_DisableIT_ITAMP2
4967 * @param RTCx RTC Instance
4968 * @retval None
4969 */
4970 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP2(RTC_TypeDef *RTCx)
4971 {
4972 UNUSED(RTCx);
4973 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP2IE);
4974 }
4975 #endif /* RTC_TAMP_INT_2_SUPPORT */
4976
4977 /**
4978 * @brief Enable internal tamper 3 interrupt.
4979 * @rmtoll TAMP_IER ITAMP3IE LL_RTC_EnableIT_ITAMP3
4980 * @param RTCx RTC Instance
4981 * @retval None
4982 */
4983 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP3(RTC_TypeDef *RTCx)
4984 {
4985 UNUSED(RTCx);
4986 SET_BIT(TAMP->IER, TAMP_IER_ITAMP3IE);
4987 }
4988 /**
4989 * @brief Disable internal tamper 3 interrupt.
4990 * @rmtoll TAMP_IER TAMP3IE LL_RTC_DisableIT_ITAMP3
4991 * @param RTCx RTC Instance
4992 * @retval None
4993 */
4994 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP3(RTC_TypeDef *RTCx)
4995 {
4996 UNUSED(RTCx);
4997 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP3IE);
4998 }
4999
5000 /**
5001 * @brief Enable internal tamper 4 interrupt.
5002 * @rmtoll TAMP_IER ITAMP4IE LL_RTC_EnableIT_ITAMP4
5003 * @param RTCx RTC Instance
5004 * @retval None
5005 */
5006 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP4(RTC_TypeDef *RTCx)
5007 {
5008 UNUSED(RTCx);
5009 SET_BIT(TAMP->IER, TAMP_IER_ITAMP4IE);
5010 }
5011 /**
5012 * @brief Disable internal tamper 4 interrupt.
5013 * @rmtoll TAMP_IER TAMP4IE LL_RTC_DisableIT_ITAMP4
5014 * @param RTCx RTC Instance
5015 * @retval None
5016 */
5017 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP4(RTC_TypeDef *RTCx)
5018 {
5019 UNUSED(RTCx);
5020 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP4IE);
5021 }
5022
5023 /**
5024 * @brief Enable internal tamper 5 interrupt.
5025 * @rmtoll TAMP_IER ITAMP5IE LL_RTC_EnableIT_ITAMP5
5026 * @param RTCx RTC Instance
5027 * @retval None
5028 */
5029 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP5(RTC_TypeDef *RTCx)
5030 {
5031 UNUSED(RTCx);
5032 SET_BIT(TAMP->IER, TAMP_IER_ITAMP5IE);
5033 }
5034 /**
5035 * @brief Disable internal tamper 5 interrupt.
5036 * @rmtoll TAMP_IER TAMP5IE LL_RTC_DisableIT_ITAMP5
5037 * @param RTCx RTC Instance
5038 * @retval None
5039 */
5040 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP5(RTC_TypeDef *RTCx)
5041 {
5042 UNUSED(RTCx);
5043 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP5IE);
5044 }
5045 #if defined (RTC_TAMP_INT_6_SUPPORT)
5046
5047 /**
5048 * @brief Enable internal tamper 6 interrupt.
5049 * @rmtoll TAMP_IER ITAMP6IE LL_RTC_EnableIT_ITAMP6
5050 * @param RTCx RTC Instance
5051 * @retval None
5052 */
5053 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP6(RTC_TypeDef *RTCx)
5054 {
5055 UNUSED(RTCx);
5056 SET_BIT(TAMP->IER, TAMP_IER_ITAMP6IE);
5057 }
5058 /**
5059 * @brief Disable internal tamper 6 interrupt.
5060 * @rmtoll TAMP_IER TAMP6IE LL_RTC_DisableIT_ITAMP6
5061 * @param RTCx RTC Instance
5062 * @retval None
5063 */
5064 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP6(RTC_TypeDef *RTCx)
5065 {
5066 UNUSED(RTCx);
5067 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP6IE);
5068 }
5069 #endif /* (RTC_TAMP_INT_2_SUPPORT) */
5070
5071 #if defined (RTC_TAMP_INT_7_SUPPORT)
5072
5073 /**
5074 * @brief Enable internal tamper 7 interrupt.
5075 * @rmtoll TAMP_IER ITAMP7IE LL_RTC_EnableIT_ITAMP7
5076 * @param RTCx RTC Instance
5077 * @retval None
5078 */
5079 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP7(RTC_TypeDef *RTCx)
5080 {
5081 UNUSED(RTCx);
5082 SET_BIT(TAMP->IER, TAMP_IER_ITAMP7IE);
5083 }
5084 /**
5085 * @brief Disable internal tamper 7 interrupt.
5086 * @rmtoll TAMP_IER TAMP7IE LL_RTC_DisableIT_ITAMP7
5087 * @param RTCx RTC Instance
5088 * @retval None
5089 */
5090 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP7(RTC_TypeDef *RTCx)
5091 {
5092 UNUSED(RTCx);
5093 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP7IE);
5094 }
5095 #endif /* (RTC_TAMP_INT_7_SUPPORT)*/
5096
5097 #if defined (RTC_TAMP_INT_8_SUPPORT)
5098
5099 /**
5100 * @brief Enable internal tamper 8 interrupt.
5101 * @rmtoll TAMP_IER ITAMP8IE LL_RTC_EnableIT_ITAMP8
5102 * @param RTCx RTC Instance
5103 * @retval None
5104 */
5105 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP8(RTC_TypeDef *RTCx)
5106 {
5107 UNUSED(RTCx);
5108 SET_BIT(TAMP->IER, TAMP_IER_ITAMP8IE);
5109 }
5110 /**
5111 * @brief Disable internal tamper 8 interrupt.
5112 * @rmtoll TAMP_IER TAMP8IE LL_RTC_DisableIT_ITAMP8
5113 * @param RTCx RTC Instance
5114 * @retval None
5115 */
5116 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP8(RTC_TypeDef *RTCx)
5117 {
5118 UNUSED(RTCx);
5119 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP8IE);
5120 }
5121 #endif /* (RTC_TAMP_INT_8_SUPPORT)*/
5122
5123 #if 0
5124 /**
5125 * @brief Enable internal tamper 9 interrupt.
5126 * @rmtoll TAMP_IER ITAMP7IE LL_RTC_EnableIT_ITAMP9
5127 * @param RTCx RTC Instance
5128 * @retval None
5129 */
5130 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP9(RTC_TypeDef *RTCx)
5131 {
5132 UNUSED(RTCx);
5133 SET_BIT(TAMP->IER, TAMP_IER_ITAMP9IE);
5134 }
5135 /**
5136 * @brief Disable internal tamper 9 interrupt.
5137 * @rmtoll TAMP_IER TAMP9IE LL_RTC_DisableIT_ITAMP9
5138 * @param RTCx RTC Instance
5139 * @retval None
5140 */
5141 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP9(RTC_TypeDef *RTCx)
5142 {
5143 UNUSED(RTCx);
5144 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP9IE);
5145 }
5146
5147 /**
5148 * @brief Enable internal tamper 10 interrupt.
5149 * @rmtoll TAMP_IER ITAMP10IE LL_RTC_EnableIT_ITAMP10
5150 * @param RTCx RTC Instance
5151 * @retval None
5152 */
5153 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP10(RTC_TypeDef *RTCx)
5154 {
5155 UNUSED(RTCx);
5156 SET_BIT(TAMP->IER, TAMP_IER_ITAMP10IE);
5157 }
5158 /**
5159 * @brief Disable internal tamper 10 interrupt.
5160 * @rmtoll TAMP_IER TAMP10IE LL_RTC_DisableIT_ITAMP10
5161 * @param RTCx RTC Instance
5162 * @retval None
5163 */
5164 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP10(RTC_TypeDef *RTCx)
5165 {
5166 UNUSED(RTCx);
5167 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP10IE);
5168 }
5169
5170 /**
5171 * @brief Enable internal tamper 11 interrupt.
5172 * @rmtoll TAMP_IER ITAMP11IE LL_RTC_EnableIT_ITAMP11
5173 * @param RTCx RTC Instance
5174 * @retval None
5175 */
5176 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP11(RTC_TypeDef *RTCx)
5177 {
5178 UNUSED(RTCx);
5179 SET_BIT(TAMP->IER, TAMP_IER_ITAMP11IE);
5180 }
5181 /**
5182 * @brief Disable internal tamper 11 interrupt.
5183 * @rmtoll TAMP_IER TAMP11IE LL_RTC_DisableIT_ITAMP11
5184 * @param RTCx RTC Instance
5185 * @retval None
5186 */
5187 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP11(RTC_TypeDef *RTCx)
5188 {
5189 UNUSED(RTCx);
5190 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP11IE);
5191 }
5192
5193 /**
5194 * @brief Enable internal tamper 12 interrupt.
5195 * @rmtoll TAMP_IER ITAMP12IE LL_RTC_EnableIT_ITAMP12
5196 * @param RTCx RTC Instance
5197 * @retval None
5198 */
5199 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP12(RTC_TypeDef *RTCx)
5200 {
5201 UNUSED(RTCx);
5202 SET_BIT(TAMP->IER, TAMP_IER_ITAMP12IE);
5203 }
5204 /**
5205 * @brief Disable internal tamper 12 interrupt.
5206 * @rmtoll TAMP_IER TAMP12IE LL_RTC_DisableIT_ITAMP12
5207 * @param RTCx RTC Instance
5208 * @retval None
5209 */
5210 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP12(RTC_TypeDef *RTCx)
5211 {
5212 UNUSED(RTCx);
5213 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP12IE);
5214 }
5215
5216 /**
5217 * @brief Enable internal tamper 13 interrupt.
5218 * @rmtoll TAMP_IER ITAMP13IE LL_RTC_EnableIT_ITAMP13
5219 * @param RTCx RTC Instance
5220 * @retval None
5221 */
5222 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP13(RTC_TypeDef *RTCx)
5223 {
5224 UNUSED(RTCx);
5225 SET_BIT(TAMP->IER, TAMP_IER_ITAMP13IE);
5226 }
5227 /**
5228 * @brief Disable internal tamper 13 interrupt.
5229 * @rmtoll TAMP_IER TAMP13IE LL_RTC_DisableIT_ITAMP13
5230 * @param RTCx RTC Instance
5231 * @retval None
5232 */
5233 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP13(RTC_TypeDef *RTCx)
5234 {
5235 UNUSED(RTCx);
5236 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP13IE);
5237 }
5238
5239 /**
5240 * @brief Enable internal tamper 14 interrupt.
5241 * @rmtoll TAMP_IER ITAMP14IE LL_RTC_EnableIT_ITAMP14
5242 * @param RTCx RTC Instance
5243 * @retval None
5244 */
5245 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP14(RTC_TypeDef *RTCx)
5246 {
5247 UNUSED(RTCx);
5248 SET_BIT(TAMP->IER, TAMP_IER_ITAMP14IE);
5249 }
5250 /**
5251 * @brief Disable internal tamper 14 interrupt.
5252 * @rmtoll TAMP_IER TAMP14IE LL_RTC_DisableIT_ITAMP14
5253 * @param RTCx RTC Instance
5254 * @retval None
5255 */
5256 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP14(RTC_TypeDef *RTCx)
5257 {
5258 UNUSED(RTCx);
5259 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP14IE);
5260 }
5261
5262 /**
5263 * @brief Enable internal tamper 15 interrupt.
5264 * @rmtoll TAMP_IER ITAMP15IE LL_RTC_EnableIT_ITAMP15
5265 * @param RTCx RTC Instance
5266 * @retval None
5267 */
5268 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP15(RTC_TypeDef *RTCx)
5269 {
5270 UNUSED(RTCx);
5271 SET_BIT(TAMP->IER, TAMP_IER_ITAMP15IE);
5272 }
5273 /**
5274 * @brief Disable internal tamper 15 interrupt.
5275 * @rmtoll TAMP_IER TAMP15IE LL_RTC_DisableIT_ITAMP15
5276 * @param RTCx RTC Instance
5277 * @retval None
5278 */
5279 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP15(RTC_TypeDef *RTCx)
5280 {
5281 UNUSED(RTCx);
5282 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP15IE);
5283 }
5284
5285 /**
5286 * @brief Enable internal tamper 16 interrupt.
5287 * @rmtoll TAMP_IER ITAMP16IE LL_RTC_EnableIT_ITAMP16
5288 * @param RTCx RTC Instance
5289 * @retval None
5290 */
5291 __STATIC_INLINE void LL_RTC_EnableIT_ITAMP16(RTC_TypeDef *RTCx)
5292 {
5293 UNUSED(RTCx);
5294 SET_BIT(TAMP->IER, TAMP_IER_ITAMP16IE);
5295 }
5296 /**
5297 * @brief Disable internal tamper 16 interrupt.
5298 * @rmtoll TAMP_IER TAMP16IE LL_RTC_DisableIT_ITAMP16
5299 * @param RTCx RTC Instance
5300 * @retval None
5301 */
5302 __STATIC_INLINE void LL_RTC_DisableIT_ITAMP16(RTC_TypeDef *RTCx)
5303 {
5304 UNUSED(RTCx);
5305 CLEAR_BIT(TAMP->IER, TAMP_IER_ITAMP16IE);
5306 }
5307 #endif /* 0 */
5308
5309 /**
5310 * @brief Check if tamper 1 interrupt is enabled or not.
5311 * @rmtoll TAMP_IER TAMP1IE LL_RTC_IsEnabledIT_TAMP1
5312 * @param RTCx RTC Instance
5313 * @retval State of bit (1 or 0).
5314 */
5315 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP1(RTC_TypeDef *RTCx)
5316 {
5317 UNUSED(RTCx);
5318 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP1IE) == (TAMP_IER_TAMP1IE)) ? 1U : 0U);
5319 }
5320
5321 /**
5322 * @brief Check if tamper 2 interrupt is enabled or not.
5323 * @rmtoll TAMP_IER TAMP2IE LL_RTC_IsEnabledIT_TAMP2
5324 * @param RTCx RTC Instance
5325 * @retval State of bit (1 or 0).
5326 */
5327 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP2(RTC_TypeDef *RTCx)
5328 {
5329 UNUSED(RTCx);
5330 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP2IE) == (TAMP_IER_TAMP2IE)) ? 1U : 0U);
5331 }
5332
5333 #if (RTC_TAMP_NB == 3)
5334
5335 /**
5336 * @brief Check if tamper 3 interrupt is enabled or not.
5337 * @rmtoll TAMP_IER TAMP3IE LL_RTC_IsEnabledIT_TAMP3
5338 * @param RTCx RTC Instance
5339 * @retval State of bit (1 or 0).
5340 */
5341 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP3(RTC_TypeDef *RTCx)
5342 {
5343 UNUSED(RTCx);
5344 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP3IE) == (TAMP_IER_TAMP3IE)) ? 1U : 0U);
5345 }
5346 #elif (RTC_TAMP_NB == 8)
5347
5348 /**
5349 * @brief Check if tamper 3 interrupt is enabled or not.
5350 * @rmtoll TAMP_IER TAMP3IE LL_RTC_IsEnabledIT_TAMP3
5351 * @param RTCx RTC Instance
5352 * @retval State of bit (1 or 0).
5353 */
5354 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP3(RTC_TypeDef *RTCx)
5355 {
5356 UNUSED(RTCx);
5357 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP3IE) == (TAMP_IER_TAMP3IE)) ? 1U : 0U);
5358 }
5359 /**
5360 * @brief Check if tamper 4 interrupt is enabled or not.
5361 * @rmtoll TAMP_IER TAMP4IE LL_RTC_IsEnabledIT_TAMP4
5362 * @param RTCx RTC Instance
5363 * @retval State of bit (1 or 0).
5364 */
5365 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP4(RTC_TypeDef *RTCx)
5366 {
5367 UNUSED(RTCx);
5368 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP4IE) == (TAMP_IER_TAMP4IE)) ? 1U : 0U);
5369 }
5370 /**
5371 * @brief Check if tamper 5 interrupt is enabled or not.
5372 * @rmtoll TAMP_IER TAMP1IE LL_RTC_IsEnabledIT_TAMP5
5373 * @param RTCx RTC Instance
5374 * @retval State of bit (1 or 0).
5375 */
5376 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP5(RTC_TypeDef *RTCx)
5377 {
5378 UNUSED(RTCx);
5379 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP5IE) == (TAMP_IER_TAMP5IE)) ? 1U : 0U);
5380 }
5381 /**
5382 * @brief Check if tamper 6 interrupt is enabled or not.
5383 * @rmtoll TAMP_IER TAMP6IE LL_RTC_IsEnabledIT_TAMP6
5384 * @param RTCx RTC Instance
5385 * @retval State of bit (1 or 0).
5386 */
5387 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP6(RTC_TypeDef *RTCx)
5388 {
5389 UNUSED(RTCx);
5390 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP6IE) == (TAMP_IER_TAMP6IE)) ? 1U : 0U);
5391 }
5392 /**
5393 * @brief Check if tamper 7 interrupt is enabled or not.
5394 * @rmtoll TAMP_IER TAMP1IE LL_RTC_IsEnabledIT_TAMP7
5395 * @param RTCx RTC Instance
5396 * @retval State of bit (1 or 0).
5397 */
5398 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP7(RTC_TypeDef *RTCx)
5399 {
5400 UNUSED(RTCx);
5401 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP7IE) == (TAMP_IER_TAMP7IE)) ? 1U : 0U);
5402 }
5403 /**
5404 * @brief Check if tamper 8 interrupt is enabled or not.
5405 * @rmtoll TAMP_IER TAMP8IE LL_RTC_IsEnabledIT_TAMP8
5406 * @param RTCx RTC Instance
5407 * @retval State of bit (1 or 0).
5408 */
5409 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_TAMP8(RTC_TypeDef *RTCx)
5410 {
5411 UNUSED(RTCx);
5412 return ((READ_BIT(TAMP->IER, TAMP_IER_TAMP8IE) == (TAMP_IER_TAMP8IE)) ? 1U : 0U);
5413 }
5414
5415 #endif /* RTC_TAMP_NB */
5416
5417
5418 #if defined (RTC_TAMP_INT_1_SUPPORT)
5419 /**
5420 * @brief Check if internal tamper 1 interrupt is enabled or not.
5421 * @rmtoll TAMP_IER ITAMP1IE LL_RTC_IsEnabledIT_ITAMP1
5422 * @param RTCx RTC Instance
5423 * @retval State of bit (1 or 0).
5424 */
5425 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP1(RTC_TypeDef *RTCx)
5426 {
5427 UNUSED(RTCx);
5428 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP1IE) == (TAMP_IER_ITAMP1IE)) ? 1U : 0U);
5429 }
5430 #endif /* RTC_TAMP_INT_1_SUPPORT */
5431 #if defined (RTC_TAMP_INT_2_SUPPORT)
5432
5433 /**
5434 * @brief Check if internal tamper 2 interrupt is enabled or not.
5435 * @rmtoll TAMP_IER ITAMP2IE LL_RTC_IsEnabledIT_ITAMP2
5436 * @param RTCx RTC Instance
5437 * @retval State of bit (1 or 0).
5438 */
5439 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP2(RTC_TypeDef *RTCx)
5440 {
5441 UNUSED(RTCx);
5442 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP2IE) == (TAMP_IER_ITAMP2IE)) ? 1U : 0U);
5443 }
5444 #endif /* RTC_TAMP_INT_2_SUPPORT */
5445
5446 /**
5447 * @brief Check if internal tamper 3 interrupt is enabled or not.
5448 * @rmtoll TAMP_IER ITAMP3IE LL_RTC_IsEnabledIT_ITAMP3
5449 * @param RTCx RTC Instance
5450 * @retval State of bit (1 or 0).
5451 */
5452 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP3(RTC_TypeDef *RTCx)
5453 {
5454 UNUSED(RTCx);
5455 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP3IE) == (TAMP_IER_ITAMP3IE)) ? 1U : 0U);
5456 }
5457 /**
5458 * @brief Check if internal tamper 4 interrupt is enabled or not.
5459 * @rmtoll TAMP_IER ITAMP4IE LL_RTC_IsEnabledIT_ITAMP4
5460 * @param RTCx RTC Instance
5461 * @retval State of bit (1 or 0).
5462 */
5463 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP4(RTC_TypeDef *RTCx)
5464 {
5465 UNUSED(RTCx);
5466 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP4IE) == (TAMP_IER_ITAMP4IE)) ? 1U : 0U);
5467 }
5468
5469 /**
5470 * @brief Check if internal tamper 5 interrupt is enabled or not.
5471 * @rmtoll TAMP_IER ITAMP5IE LL_RTC_IsEnabledIT_ITAMP5
5472 * @param RTCx RTC Instance
5473 * @retval State of bit (1 or 0).
5474 */
5475 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP5(RTC_TypeDef *RTCx)
5476 {
5477 UNUSED(RTCx);
5478 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP5IE) == (TAMP_IER_ITAMP5IE)) ? 1U : 0U);
5479 }
5480
5481 #if defined (RTC_TAMP_INT_6_SUPPORT)
5482 /**
5483 * @brief Check if internal tamper 6 interrupt is enabled or not.
5484 * @rmtoll TAMP_IER ITAMP6IE LL_RTC_IsEnabledIT_ITAMP6
5485 * @param RTCx RTC Instance
5486 * @retval State of bit (1 or 0).
5487 */
5488 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP6(RTC_TypeDef *RTCx)
5489 {
5490 UNUSED(RTCx);
5491 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP6IE) == (TAMP_IER_ITAMP6IE)) ? 1U : 0U);
5492 }
5493 #endif /* RTC_TAMP_INT_6_SUPPORT */
5494
5495
5496 #if defined (RTC_TAMP_INT_7_SUPPORT)
5497
5498 /**
5499 * @brief Check if internal tamper 7 interrupt is enabled or not.
5500 * @rmtoll TAMP_IER ITAMP7IE LL_RTC_IsEnabledIT_ITAMP7
5501 * @param RTCx RTC Instance
5502 * @retval State of bit (1 or 0).
5503 */
5504 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP7(RTC_TypeDef *RTCx)
5505 {
5506 UNUSED(RTCx);
5507 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP7IE) == (TAMP_IER_ITAMP7IE)) ? 1U : 0U);
5508 }
5509 #endif /* RTC_TAMP_INT_7_SUPPORT */
5510
5511 #if defined (RTC_TAMP_INT_8_SUPPORT)
5512
5513 /**
5514 * @brief Check if internal tamper 7 interrupt is enabled or not.
5515 * @rmtoll TAMP_IER ITAMP7IE LL_RTC_IsEnabledIT_ITAMP7
5516 * @param RTCx RTC Instance
5517 * @retval State of bit (1 or 0).
5518 */
5519 __STATIC_INLINE uint32_t LL_RTC_IsEnabledIT_ITAMP7(RTC_TypeDef *RTCx)
5520 {
5521 UNUSED(RTCx);
5522 return ((READ_BIT(TAMP->IER, TAMP_IER_ITAMP7IE) == (TAMP_IER_ITAMP7IE)) ? 1U : 0U);
5523 }
5524 #endif /* RTC_TAMP_INT_8_SUPPORT */
5525
5526 /**
5527 * @}
5528 */
5529
5530 #if defined(USE_FULL_LL_DRIVER)
5531 /** @defgroup RTC_LL_EF_Init Initialization and de-initialization functions
5532 * @{
5533 */
5534
5535 ErrorStatus LL_RTC_DeInit(RTC_TypeDef *RTCx);
5536 ErrorStatus LL_RTC_Init(RTC_TypeDef *RTCx, LL_RTC_InitTypeDef *RTC_InitStruct);
5537 void LL_RTC_StructInit(LL_RTC_InitTypeDef *RTC_InitStruct);
5538 ErrorStatus LL_RTC_TIME_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_TimeTypeDef *RTC_TimeStruct);
5539 void LL_RTC_TIME_StructInit(LL_RTC_TimeTypeDef *RTC_TimeStruct);
5540 ErrorStatus LL_RTC_DATE_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_DateTypeDef *RTC_DateStruct);
5541 void LL_RTC_DATE_StructInit(LL_RTC_DateTypeDef *RTC_DateStruct);
5542 ErrorStatus LL_RTC_ALMA_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct);
5543 ErrorStatus LL_RTC_ALMB_Init(RTC_TypeDef *RTCx, uint32_t RTC_Format, LL_RTC_AlarmTypeDef *RTC_AlarmStruct);
5544 void LL_RTC_ALMA_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct);
5545 void LL_RTC_ALMB_StructInit(LL_RTC_AlarmTypeDef *RTC_AlarmStruct);
5546 ErrorStatus LL_RTC_EnterInitMode(RTC_TypeDef *RTCx);
5547 ErrorStatus LL_RTC_ExitInitMode(RTC_TypeDef *RTCx);
5548 ErrorStatus LL_RTC_WaitForSynchro(RTC_TypeDef *RTCx);
5549
5550 /**
5551 * @}
5552 */
5553 #endif /* USE_FULL_LL_DRIVER */
5554
5555 /**
5556 * @}
5557 */
5558
5559 /**
5560 * @}
5561 */
5562
5563 #endif /* defined(RTC) */
5564
5565 /**
5566 * @}
5567 */
5568
5569 #ifdef __cplusplus
5570 }
5571 #endif
5572
5573 #endif /* STM32G4xx_LL_RTC_H */
5574
5575 /************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/