ll_dual_tim.h
Go to the documentation of this file.
1 /**
2 ****************************************************************************************
3 *
4 * @file ll_dual_tim.h
5 * @author BLE Driver Team
6 * @brief Header file containing functions prototypes of DUAL TIMER LL library.
7 *
8 ****************************************************************************************
9 * @attention
10 #####Copyright (c) 2019 GOODIX
11 All rights reserved.
12
13 Redistribution and use in source and binary forms, with or without
14 modification, are permitted provided that the following conditions are met:
15 * Redistributions of source code must retain the above copyright
16 notice, this list of conditions and the following disclaimer.
17 * Redistributions in binary form must reproduce the above copyright
18 notice, this list of conditions and the following disclaimer in the
19 documentation and/or other materials provided with the distribution.
20 * Neither the name of GOODIX nor the names of its contributors may be used
21 to endorse or promote products derived from this software without
22 specific prior written permission.
23
24 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
25 AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
26 IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
27 ARE DISCLAIMED. IN NO EVENT SHALL COPYRIGHT HOLDERS AND CONTRIBUTORS BE
28 LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
29 CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
30 SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
31 INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
32 CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
33 ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
34 POSSIBILITY OF SUCH DAMAGE.
35 ****************************************************************************************
36 */
37
38 /** @addtogroup PERIPHERAL Peripheral Driver
39 * @{
40 */
41
42 /** @addtogroup LL_DRIVER LL Driver
43 * @{
44 */
45
46 /** @defgroup LL_DUAL_TIMER DUAL_TIMER
47 * @brief DUAL TIM LL module driver.
48 * @{
49 */
50
51 /* Define to prevent recursive inclusion -------------------------------------*/
52 #ifndef LL_DUAL_TIMER_H
53 #define LL_DUAL_TIMER_H
54
55 #ifdef __cplusplus
56 extern "C" {
57 #endif
58
59 /* Includes ------------------------------------------------------------------*/
60 #include "gr5x.h"
61
62 #if defined (DUAL_TIMER0) || defined (DUAL_TIMER1)
63
64 /** @defgroup DUAL_TIMER_LL_STRUCTURES Structures
65 * @{
66 */
67
68 /* Exported types ------------------------------------------------------------*/
69 /** @defgroup DUAL_TIMER_LL_ES_INIT DUAL_TIM Exported init structures
70 * @{
71 */
72
73 /**
74 * @brief LL DUAL TIMER init Structure definition
75 */
76 typedef struct
77 {
78 uint32_t prescaler; /**< Specifies the prescaler value used to divide the TIMER clock.
79 This parameter can be a value of @ref DUAL_TIMER_EC_LL_PRESCALER.
80
81 This feature can be modified afterwards using unitary function @ref ll_dual_timer_set_prescaler().*/
82
83 uint32_t counter_size; /**< Specifies the prescaler value used to divide the DUAL_TIMER clock.
84 This parameter can be a value of @ref DUAL_TIMER_EC_LL_COUNTERSIZE.
85
86 This feature can be modified afterwards using unitary function @ref ll_dual_timer_set_counter_size().*/
87
88 uint32_t counter_mode; /**< Specifies the counter mode.
89 This parameter can be a value of @ref DUAL_TIMER_LL_EC_COUNTERMODE.
90
91 This feature can be modified afterwards using unitary function @ref ll_dual_timer_set_counter_mode().*/
92
93 uint32_t auto_reload; /**< Specifies the auto reload value to be loaded into the active
94 Auto-Reload Register at the next update event.
95 This parameter must be a number between Min_Data=0x00000000 and Max_Data=0xFFFFFFFF.
96 Some timer instances may support 16 bits counters. In that case this parameter must be a number between 0x0000 and 0xFFFF.
97
98 This feature can be modified afterwards using unitary function @ref ll_dual_timer_set_auto_reload().*/
99 } ll_dual_timer_init_t;
100
101 /** @} */
102
103 /** @} */
104
105 /**
106 * @defgroup DUAL_TIMER_LL_MACRO Defines
107 * @{
108 */
109
110 /* Exported constants --------------------------------------------------------*/
111 /** @defgroup DUAL_TIMER_LL_Exported_Constants DUAL_TIM Exported Constants
112 * @{
113 */
114
115 /** @defgroup DUAL_TIMER_LL_EC_COUNTERMODE DUAL_TIM counter mode
116 * @{
117 */
118 #define LL_DUAL_TIMER_FREERUNNING_MODE 0x00000000U /**< Free running mode */
119 #define LL_DUAL_TIMER_PERIODIC_MODE DUAL_TIMER_CTRL_MODE /**< Periodic mode */
120 /** @} */
121
122 /** @defgroup DUAL_TIMER_EC_LL_PRESCALER DUAL_TIM prescaler
123 * @{
124 */
125 #define LL_DUAL_TIMER_PRESCALER_DIV0 0x00000000U /**< 0 stage of prescale, clock is divided by 1. */
126 #define LL_DUAL_TIMER_PRESCALER_DIV16 (1UL << DUAL_TIMER_CTRL_PRE_Pos) /**< 4 stages of prescale, clock is divided by 16. */
127 #define LL_DUAL_TIMER_PRESCALER_DIV256 (2UL << DUAL_TIMER_CTRL_PRE_Pos) /**< 8 stages of prescale, clock is divided by 256. */
128 /** @} */
129
130 /** @defgroup DUAL_TIMER_EC_LL_COUNTERSIZE DUAL_TIM counter size
131 * @{
132 */
133 #define LL_DUAL_TIMER_COUNTERSIZE_16 0x00000000U /**< Counter size 16 bits */
134 #define LL_DUAL_TIMER_COUNTERSIZE_32 DUAL_TIMER_CTRL_SIZE /**< Counter size 32 bits */
135 /** @} */
136
137 /** @defgroup DUAL_TIMER_EC_LL_IO_ACTION DUAL_TIM io action
138 * @{
139 */
140 #define LL_DUAL_TIMER_IO_ACTION_NONE 0x00000000U /**< Do noting */
141 #define LL_DUAL_TIMER_IO_ACTION_SET 0x00000001U /**< io set */
142 #define LL_DUAL_TIMER_IO_ACTION_RESET 0x00000002U /**< io reset */
143 #define LL_DUAL_TIMER_IO_ACTION_TOGGLE 0x00000003U /**< io toggle */
144 /** @} */
145
146 /** @defgroup DUAL_TIMER_EC_LL_IO_INIT DUAL_TIM io init
147 * @{
148 */
149 #define LL_DUAL_TIMER_IO_INIT_RESET 0x00000000U /**< io init reset */
150 #define LL_DUAL_TIMER_IO_INIT_SET 0x00000001U /**< io init set */
151 /** @} */
152
153 /** @defgroup DUAL_TIMER_EC_LL_INTSTAT DUAL_TIM Interrupt source identify
154 * @{
155 */
156 #define LL_DUAL_TIMER_INTSTAT_COUNTDONE DUAL_TIMER_ISR_TI /**< COUNTDONE flag */
157 #define LL_DUAL_TIMER_INTSTAT_ACT_START DUAL_TIMER_INT_ACT_START /**< Action Start flag */
158 #define LL_DUAL_TIMER_INTSTAT_IOA_ACT_C1 DUAL_TIMER_INT_IOA_ACT_C1 /**< IOA Action Count 1 flag */
159 #define LL_DUAL_TIMER_INTSTAT_IOA_ACT_C2 DUAL_TIMER_INT_IOA_ACT_C2 /**< IOA Action Count 2 flag */
160 #define LL_DUAL_TIMER_INTSTAT_ACT_PERIOD DUAL_TIMER_INT_ACT_PERIOD /**< Action Period flag */
161 #define LL_DUAL_TIMER_INTSTAT_ACT_STOP DUAL_TIMER_INT_ACT_STOP /**< Action Stop flag */
162 #define LL_DUAL_TIMER_INTSTAT_IOB_ACT_C1 DUAL_TIMER_INT_IOB_ACT_C1 /**< IOB Action Count 1 flag */
163 #define LL_DUAL_TIMER_INTSTAT_IOB_ACT_C2 DUAL_TIMER_INT_IOB_ACT_C2 /**< IOB Action Count 2 flag */
164 #define LL_DUAL_TIMER_INTSTAT_IOC_ACT_C1 DUAL_TIMER_INT_IOC_ACT_C1 /**< IOC Action Count 1 flag */
165 #define LL_DUAL_TIMER_INTSTAT_IOC_ACT_C2 DUAL_TIMER_INT_IOC_ACT_C2 /**< IOC Action Count 2 flag */
166 #define LL_DUAL_TIMER_INTSTAT_BLEPULSE1 DUAL_TIMER_INT_BLEPULSE1 /**< BLE Pulse Count 1 flag */
167 #define LL_DUAL_TIMER_INTSTAT_BLEPULSE2 DUAL_TIMER_INT_BLEPULSE2 /**< BLE Pulse Count 2 flag */
168 /** @} */
169
170 /** @defgroup DUAL_TIMER_LL_EC_DEFAULT_CONFIG InitStrcut default configuartion
171 * @{
172 */
173
174 /**
175 * @brief LL DUAL_TIMER InitStrcut default configuartion
176 */
177 #define DUAL_TIMER_DEFAULT_CONFIG \
178 { \
179 .prescaler = LL_DUAL_TIMER_PRESCALER_DIV0, \
180 .counter_size = LL_DUAL_TIMER_COUNTERSIZE_32, \
181 .counter_mode = LL_DUAL_TIMER_PERIODIC_MODE, \
182 .auto_reload = SystemCoreClock - 1U, \
183 }
184 /** @} */
185
186 /** @} */
187
188 /* Exported macro ------------------------------------------------------------*/
189 /** @defgroup DUAL_TIMER_LL_Exported_Macros DUAL_TIM Exported Macros
190 * @{
191 */
192
193 /** @defgroup DUAL_TIMER_LL_EM_WRITE_READ Common Write and read registers Macros
194 * @{
195 */
196
197 /**
198 * @brief Write a value in DUAL_TIMER register
199 * @param __instance__ DUAL_TIMER instance
200 * @param __REG__ Register to be written
201 * @param __VALUE__ Value to be written in the register
202 * @retval None
203 */
204 #define LL_DUAL_TIMER_WriteReg(__instance__, __REG__, __VALUE__) WRITE_REG(__instance__->__REG__, (__VALUE__))
205
206 /**
207 * @brief Read a value in DUAL_TIMER register
208 * @param __instance__ DUAL_TIMER instance
209 * @param __REG__ Register to be read
210 * @retval Register value
211 */
212 #define LL_DUAL_TIMER_ReadReg(__instance__, __REG__) READ_REG(__instance__->__REG__)
213
214 /** @} */
215
216 /** @} */
217
218 /** @} */
219
220 /* Exported functions --------------------------------------------------------*/
221 /** @defgroup DUAL_TIMER_LL_DRIVER_FUNCTIONS Functions
222 * @{
223 */
224
225 /** @defgroup DUAL_TIMER_LL_EF_Configuration Configuration functions
226 * @{
227 */
228
229
230 /**
231 * @brief Enable dual_timer counter.
232 *
233 * Register|BitsName
234 * --------|--------
235 * CTRL | EN
236 *
237 * @param DUAL_TIMERx Timer instance
238 * @retval None
239 */
240 __STATIC_INLINE void ll_dual_timer_enable_counter(dual_timer_regs_t *DUAL_TIMERx)
241 {
242 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_EN);
243 }
244
245 /**
246 * @brief Disable dual_timer counter.
247 *
248 * Register|BitsName
249 * --------|--------
250 * CTRL | EN
251 *
252 * @param DUAL_TIMERx Timer instance
253 * @retval None
254 */
255 __STATIC_INLINE void ll_dual_timer_disable_counter(dual_timer_regs_t *DUAL_TIMERx)
256 {
257 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_EN);
258 }
259
260 /**
261 * @brief Indicate whether the dual_timer counter is enabled.
262 *
263 * Register|BitsName
264 * --------|--------
265 * CTRL | EN
266 *
267 * @param DUAL_TIMERx Timer instance
268 * @retval State of bit (1 or 0).
269 */
270 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_counter(dual_timer_regs_t *DUAL_TIMERx)
271 {
272 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_EN) == (DUAL_TIMER_CTRL_EN));
273 }
274
275 /**
276 * @brief Set the counter mode.
277 *
278 * Register|BitsName
279 * --------|--------
280 * CTRL | MODE
281 *
282 * @param DUAL_TIMERx Timer instance
283 * @param counter_mode This parameter can be one of the following values:
284 * @arg @ref LL_DUAL_TIMER_FREERUNNING_MODE
285 * @arg @ref LL_DUAL_TIMER_PERIODIC_MODE
286 * @retval None
287 */
288 __STATIC_INLINE void ll_dual_timer_set_counter_mode(dual_timer_regs_t *DUAL_TIMERx, uint32_t counter_mode)
289 {
290 MODIFY_REG(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_MODE, counter_mode);
291 }
292
293 /**
294 * @brief Get the counter mode.
295 *
296 * Register|BitsName
297 * --------|--------
298 * CTRL | MODE
299 *
300 * @param DUAL_TIMERx Timer instance
301 * @retval Return value can be one of the following values:
302 * @arg @ref LL_DUAL_TIMER_FREERUNNING_MODE
303 * @arg @ref LL_DUAL_TIMER_PERIODIC_MODE
304 */
305 __STATIC_INLINE uint32_t ll_dual_timer_get_counter_mode(dual_timer_regs_t *DUAL_TIMERx)
306 {
307 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_MODE));
308 }
309
310 /**
311 * @brief Set the prescaler.
312 *
313 * Register|BitsName
314 * --------|--------
315 * CTRL | PRE
316 *
317 * @param DUAL_TIMERx Timer instance
318 * @param prescaler This parameter can be one of the following values:
319 * @arg @ref LL_DUAL_TIMER_PRESCALER_DIV0
320 * @arg @ref LL_DUAL_TIMER_PRESCALER_DIV16
321 * @arg @ref LL_DUAL_TIMER_PRESCALER_DIV256
322 * @retval None
323 */
324 __STATIC_INLINE void ll_dual_timer_set_prescaler(dual_timer_regs_t *DUAL_TIMERx, uint32_t prescaler)
325 {
326 MODIFY_REG(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_PRE, prescaler);
327 }
328
329 /**
330 * @brief Get the prescaler.
331 *
332 * Register|BitsName
333 * --------|--------
334 * CTRL | PRE
335 *
336 * @param DUAL_TIMERx Timer instance
337 * @retval Return value can be one of the following values:
338 * @arg @ref LL_DUAL_TIMER_PRESCALER_DIV0
339 * @arg @ref LL_DUAL_TIMER_PRESCALER_DIV16
340 * @arg @ref LL_DUAL_TIMER_PRESCALER_DIV256
341 */
342 __STATIC_INLINE uint32_t ll_dual_timer_get_prescaler(dual_timer_regs_t *DUAL_TIMERx)
343 {
344 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_PRE));
345 }
346
347 /**
348 * @brief Set the counter size.
349 *
350 * Register|BitsName
351 * --------|--------
352 * CTRL | SIZE
353 *
354 * @param DUAL_TIMERx Timer instance
355 * @param counter_size This parameter can be one of the following values:
356 * @arg @ref LL_DUAL_TIMER_COUNTERSIZE_16
357 * @arg @ref LL_DUAL_TIMER_COUNTERSIZE_32
358 * @retval None
359 */
360 __STATIC_INLINE void ll_dual_timer_set_counter_size(dual_timer_regs_t *DUAL_TIMERx, uint32_t counter_size)
361 {
362 MODIFY_REG(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_SIZE, counter_size);
363 }
364
365 /**
366 * @brief Get the counter size.
367 *
368 * Register|BitsName
369 * --------|--------
370 * CTRL | SIZE
371 *
372 * @param DUAL_TIMERx Timer instance
373 * @retval Return value can be one of the following values:
374 * @arg @ref LL_DUAL_TIMER_COUNTERSIZE_16
375 * @arg @ref LL_DUAL_TIMER_COUNTERSIZE_32
376 */
377 __STATIC_INLINE uint32_t ll_dual_timer_get_counter_size(dual_timer_regs_t *DUAL_TIMERx)
378 {
379 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_SIZE));
380 }
381
382 /**
383 * @brief Enable one-shot mode.
384 *
385 * Register|BitsName
386 * --------|--------
387 * CTRL | ONESHOT
388 *
389 * @param DUAL_TIMERx Timer instance
390 * @retval None
391 */
392 __STATIC_INLINE void ll_dual_timer_enable_oneshot(dual_timer_regs_t *DUAL_TIMERx)
393 {
394 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ONESHOT);
395 }
396
397 /**
398 * @brief Disable one-shot mode.
399 *
400 * Register|BitsName
401 * --------|--------
402 * CTRL | ONESHOT
403 *
404 * @param DUAL_TIMERx Timer instance
405 * @retval None
406 */
407 __STATIC_INLINE void ll_dual_timer_disable_oneshot(dual_timer_regs_t *DUAL_TIMERx)
408 {
409 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ONESHOT);
410 }
411
412 /**
413 * @brief Indicate whether the one-shot mode is enabled.
414 *
415 * Register|BitsName
416 * --------|--------
417 * CTRL | ONESHOT
418 *
419 * @param DUAL_TIMERx Timer instance
420 * @retval State of bit (1 or 0).
421 */
422 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_oneshot(dual_timer_regs_t *DUAL_TIMERx)
423 {
424 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ONESHOT) == (DUAL_TIMER_CTRL_ONESHOT));
425 }
426
427 /**
428 * @brief Get the counter value.
429 *
430 * Register|BitsName
431 * --------|--------
432 * VALUE | VALUE
433 *
434 * @param DUAL_TIMERx Timer instance
435 * @retval Counter value (between Min_Data=0 and Max_Data=0xFFFFFFFF)
436 */
437 __STATIC_INLINE uint32_t ll_dual_timer_get_counter(dual_timer_regs_t *DUAL_TIMERx)
438 {
439 return (uint32_t)(READ_REG(DUAL_TIMERx->VALUE));
440 }
441
442 /**
443 * @brief Set the auto-reload value.
444 * @note The counter is blocked while the auto-reload value is null.
445 *
446 * Register|BitsName
447 * --------|--------
448 * RELOAD | RELOAD
449 *
450 * @param DUAL_TIMERx Timer instance
451 * @param auto_reload between Min_Data=0 and Max_Data=0xFFFFFFFF
452 * @retval None
453 */
454 __STATIC_INLINE void ll_dual_timer_set_auto_reload(dual_timer_regs_t *DUAL_TIMERx, uint32_t auto_reload)
455 {
456 WRITE_REG(DUAL_TIMERx->RELOAD, auto_reload);
457 }
458
459 /**
460 * @brief Get the auto-reload value.
461 *
462 * Register|BitsName
463 * --------|--------
464 * RELOAD | RELOAD
465 *
466 * @param DUAL_TIMERx Timer instance
467 * @retval Auto-reload value
468 */
469 __STATIC_INLINE uint32_t ll_dual_timer_get_auto_reload(dual_timer_regs_t *DUAL_TIMERx)
470 {
471 return (uint32_t)(READ_REG(DUAL_TIMERx->RELOAD));
472 }
473
474 /**
475 * @brief Set the backgroud-reload value.
476 *
477 * Register|BitsName
478 * --------|--------
479 * BG_LOAD | BG_LOAD
480 *
481 * @param DUAL_TIMERx Timer instance
482 * @param background_reload between Min_Data=0 and Max_Data=0xFFFFFFFF
483 * @retval None
484 */
485 __STATIC_INLINE void ll_dual_timer_set_background_reload(dual_timer_regs_t *DUAL_TIMERx, uint32_t background_reload)
486 {
487 WRITE_REG(DUAL_TIMERx->BG_LOAD, background_reload);
488 }
489
490 /**
491 * @brief Get the backgroud-reload value.
492 *
493 * Register|BitsName
494 * --------|--------
495 * BG_LOAD | BG_LOAD
496 *
497 * @param DUAL_TIMERx Timer instance
498 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
499 */
500 __STATIC_INLINE uint32_t ll_dual_timer_get_background_reload(dual_timer_regs_t *DUAL_TIMERx)
501 {
502 return (uint32_t)(READ_REG(DUAL_TIMERx->BG_LOAD));
503 }
504
505 /**
506 * @brief Enable dual_timer IOA ctrl.
507 *
508 * Register|BitsName
509 * --------|--------
510 * CTRL | IOA
511 *
512 * @param DUAL_TIMERx Timer instance
513 * @retval None
514 */
515 __STATIC_INLINE void ll_dual_timer_enable_ioa_ctrl(dual_timer_regs_t *DUAL_TIMERx)
516 {
517 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA);
518 }
519
520 /**
521 * @brief Disable dual_timer IOA ctrl.
522 *
523 * Register|BitsName
524 * --------|--------
525 * CTRL | IOA
526 *
527 * @param DUAL_TIMERx Timer instance
528 * @retval None
529 */
530 __STATIC_INLINE void ll_dual_timer_disable_ioa_ctrl(dual_timer_regs_t *DUAL_TIMERx)
531 {
532 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA);
533 }
534
535 /**
536 * @brief Indicate whether the dual_timer IOA ctrl is enabled.
537 *
538 * Register|BitsName
539 * --------|--------
540 * CTRL | IOA
541 *
542 * @param DUAL_TIMERx Timer instance
543 * @retval State of bit (1 or 0).
544 */
545 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioa_ctrl(dual_timer_regs_t *DUAL_TIMERx)
546 {
547 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA) == (DUAL_TIMER_CTRL_IOA));
548 }
549
550 /**
551 * @brief Enable dual_timer IOB ctrl.
552 *
553 * Register|BitsName
554 * --------|--------
555 * CTRL | IOB
556 *
557 * @param DUAL_TIMERx Timer instance
558 * @retval None
559 */
560 __STATIC_INLINE void ll_dual_timer_enable_iob_ctrl(dual_timer_regs_t *DUAL_TIMERx)
561 {
562 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB);
563 }
564
565 /**
566 * @brief Disable dual_timer IOB ctrl.
567 *
568 * Register|BitsName
569 * --------|--------
570 * CTRL | IOB
571 *
572 * @param DUAL_TIMERx Timer instance
573 * @retval None
574 */
575 __STATIC_INLINE void ll_dual_timer_disable_iob_ctrl(dual_timer_regs_t *DUAL_TIMERx)
576 {
577 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB);
578 }
579
580 /**
581 * @brief Indicate whether the dual_timer IOB ctrl is enabled.
582 *
583 * Register|BitsName
584 * --------|--------
585 * CTRL | IOB
586 *
587 * @param DUAL_TIMERx Timer instance
588 * @retval State of bit (1 or 0).
589 */
590 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_iob_ctrl(dual_timer_regs_t *DUAL_TIMERx)
591 {
592 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB) == (DUAL_TIMER_CTRL_IOB));
593 }
594
595 /**
596 * @brief Enable dual_timer IOC ctrl.
597 *
598 * Register|BitsName
599 * --------|--------
600 * CTRL | IOC
601 *
602 * @param DUAL_TIMERx Timer instance
603 * @retval None
604 */
605 __STATIC_INLINE void ll_dual_timer_enable_ioc_ctrl(dual_timer_regs_t *DUAL_TIMERx)
606 {
607 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC);
608 }
609
610 /**
611 * @brief Disable dual_timer IOC ctrl.
612 *
613 * Register|BitsName
614 * --------|--------
615 * CTRL | IOC
616 *
617 * @param DUAL_TIMERx Timer instance
618 * @retval None
619 */
620 __STATIC_INLINE void ll_dual_timer_disable_ioc_ctrl(dual_timer_regs_t *DUAL_TIMERx)
621 {
622 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC);
623 }
624
625 /**
626 * @brief Indicate whether the dual_timer IOC ctrl is enabled.
627 *
628 * Register|BitsName
629 * --------|--------
630 * CTRL | IOC
631 *
632 * @param DUAL_TIMERx Timer instance
633 * @retval State of bit (1 or 0).
634 */
635 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioc_ctrl(dual_timer_regs_t *DUAL_TIMERx)
636 {
637 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC) == (DUAL_TIMER_CTRL_IOC));
638 }
639
640 /**
641 * @brief Enable dual_timer BLE ctrl.
642 *
643 * Register|BitsName
644 * --------|--------
645 * CTRL | BLE
646 *
647 * @param DUAL_TIMERx Timer instance
648 * @retval None
649 */
650 __STATIC_INLINE void ll_dual_timer_enable_ble_ctrl(dual_timer_regs_t *DUAL_TIMERx)
651 {
652 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLE);
653 }
654
655 /**
656 * @brief Disable dual_timer BLE ctrl.
657 *
658 * Register|BitsName
659 * --------|--------
660 * CTRL | BLE
661 *
662 * @param DUAL_TIMERx Timer instance
663 * @retval None
664 */
665 __STATIC_INLINE void ll_dual_timer_disable_ble_ctrl(dual_timer_regs_t *DUAL_TIMERx)
666 {
667 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLE);
668 }
669
670 /**
671 * @brief Indicate whether the dual_timer BLE ctrl is enabled.
672 *
673 * Register|BitsName
674 * --------|--------
675 * CTRL | BLE
676 *
677 * @param DUAL_TIMERx Timer instance
678 * @retval State of bit (1 or 0).
679 */
680 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ble_ctrl(dual_timer_regs_t *DUAL_TIMERx)
681 {
682 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLE) == (DUAL_TIMER_CTRL_BLE));
683 }
684
685 /**
686 * @brief Set the ioa count 1 value.
687 *
688 * Register|BitsName
689 * --------|--------
690 * COUNT_A1IO | COUNT_A1IO
691 *
692 * @param DUAL_TIMERx Timer instance
693 * @param count_value count 1 value between Min_Data=0 and Max_Data=0xFFFFFFFF
694 * @retval None
695 */
696 __STATIC_INLINE void ll_dual_timer_set_ioa_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
697 {
698 WRITE_REG(DUAL_TIMERx->COUNT_A1IO, count_value);
699 }
700
701 /**
702 * @brief Get the ioa count 1 value.
703 *
704 * Register|BitsName
705 * --------|--------
706 * COUNT_A1IO | COUNT_A1IO
707 *
708 * @param DUAL_TIMERx Timer instance
709 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
710 */
711 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_count1(dual_timer_regs_t *DUAL_TIMERx)
712 {
713 return (uint32_t)(READ_REG(DUAL_TIMERx->COUNT_A1IO));
714 }
715
716 /**
717 * @brief Set the ioa count 2 value.
718 *
719 * Register|BitsName
720 * --------|--------
721 * COUNT_A2IO | COUNT_A2IO
722 *
723 * @param DUAL_TIMERx Timer instance
724 * @param count_value count 2 value between Min_Data=0 and Max_Data=0xFFFFFFFF
725 * @retval None
726 */
727 __STATIC_INLINE void ll_dual_timer_set_ioa_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
728 {
729 WRITE_REG(DUAL_TIMERx->COUNT_A2IO, count_value);
730 }
731
732 /**
733 * @brief Get the ioa count 2 value.
734 *
735 * Register|BitsName
736 * --------|--------
737 * COUNT_A2IO | COUNT_A2IO
738 *
739 * @param DUAL_TIMERx Timer instance
740 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
741 */
742 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_count2(dual_timer_regs_t *DUAL_TIMERx)
743 {
744 return (uint32_t)(READ_REG(DUAL_TIMERx->COUNT_A2IO));
745 }
746
747 /**
748 * @brief Set the iob count 1 value.
749 *
750 * Register|BitsName
751 * --------|--------
752 * COUNT_B1IO | COUNT_B1IO
753 *
754 * @param DUAL_TIMERx Timer instance
755 * @param count_value count 1 value between Min_Data=0 and Max_Data=0xFFFFFFFF
756 * @retval None
757 */
758 __STATIC_INLINE void ll_dual_timer_set_iob_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
759 {
760 WRITE_REG(DUAL_TIMERx->COUNT_B1IO, count_value);
761 }
762
763 /**
764 * @brief Get the iob count 1 value.
765 *
766 * Register|BitsName
767 * --------|--------
768 * COUNT_B1IO | COUNT_B1IO
769 *
770 * @param DUAL_TIMERx Timer instance
771 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
772 */
773 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_count1(dual_timer_regs_t *DUAL_TIMERx)
774 {
775 return (uint32_t)(READ_REG(DUAL_TIMERx->COUNT_B1IO));
776 }
777
778 /**
779 * @brief Set the iob count 2 value.
780 *
781 * Register|BitsName
782 * --------|--------
783 * COUNT_B2IO | COUNT_B2IO
784 *
785 * @param DUAL_TIMERx Timer instance
786 * @param count_value count 2 value between Min_Data=0 and Max_Data=0xFFFFFFFF
787 * @retval None
788 */
789 __STATIC_INLINE void ll_dual_timer_set_iob_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
790 {
791 WRITE_REG(DUAL_TIMERx->COUNT_B2IO, count_value);
792 }
793
794 /**
795 * @brief Get the iob count 2 value.
796 *
797 * Register|BitsName
798 * --------|--------
799 * COUNT_B2IO | COUNT_B2IO
800 *
801 * @param DUAL_TIMERx Timer instance
802 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
803 */
804 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_count2(dual_timer_regs_t *DUAL_TIMERx)
805 {
806 return (uint32_t)(READ_REG(DUAL_TIMERx->COUNT_B2IO));
807 }
808
809 /**
810 * @brief Set the ioc count 1 value.
811 *
812 * Register|BitsName
813 * --------|--------
814 * COUNT_C1IO | COUNT_C1IO
815 *
816 * @param DUAL_TIMERx Timer instance
817 * @param count_value count 1 value between Min_Data=0 and Max_Data=0xFFFFFFFF
818 * @retval None
819 */
820 __STATIC_INLINE void ll_dual_timer_set_ioc_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
821 {
822 WRITE_REG(DUAL_TIMERx->COUNT_C1IO, count_value);
823 }
824
825 /**
826 * @brief Get the ioc count 1 value.
827 *
828 * Register|BitsName
829 * --------|--------
830 * COUNT_C1IO | COUNT_C1IO
831 *
832 * @param DUAL_TIMERx Timer instance
833 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
834 */
835 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_count1(dual_timer_regs_t *DUAL_TIMERx)
836 {
837 return (uint32_t)(READ_REG(DUAL_TIMERx->COUNT_C1IO));
838 }
839
840 /**
841 * @brief Set the ioc count 2 value.
842 *
843 * Register|BitsName
844 * --------|--------
845 * COUNT_C2IO | COUNT_C2IO
846 *
847 * @param DUAL_TIMERx Timer instance
848 * @param count_value count 2 value between Min_Data=0 and Max_Data=0xFFFFFFFF
849 * @retval None
850 */
851 __STATIC_INLINE void ll_dual_timer_set_ioc_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
852 {
853 WRITE_REG(DUAL_TIMERx->COUNT_C2IO, count_value);
854 }
855
856 /**
857 * @brief Get the ioc count 2 value.
858 *
859 * Register|BitsName
860 * --------|--------
861 * COUNT_C2IO | COUNT_C2IO
862 *
863 * @param DUAL_TIMERx Timer instance
864 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
865 */
866 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_count2(dual_timer_regs_t *DUAL_TIMERx)
867 {
868 return (uint32_t)(READ_REG(DUAL_TIMERx->COUNT_C2IO));
869 }
870
871 /**
872 * @brief Set ioa action when timer start.
873 *
874 * Register|BitsName
875 * --------|--------
876 * IO_ACT_CTRL | IOA_ACT_CTRL_START
877 *
878 * @param DUAL_TIMERx Timer instance
879 * @param action This parameter can be one of the following values:
880 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
881 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
882 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
883 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
884 * @retval None
885 */
886 __STATIC_INLINE void ll_dual_timer_set_ioa_action_start(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
887 {
888 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_START, (action << DUAL_TIMER_IOA_ACT_CTRL_START_Pos));
889 }
890
891 /**
892 * @brief Get ioa action when timer start.
893 *
894 * Register|BitsName
895 * --------|--------
896 * IO_ACT_CTRL | IOA_ACT_CTRL_START
897 *
898 * @param DUAL_TIMERx Timer instance
899 * @retval Return value can be one of the following values:
900 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
901 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
902 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
903 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
904 */
905 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_start(dual_timer_regs_t *DUAL_TIMERx)
906 {
907 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_START) >> DUAL_TIMER_IOA_ACT_CTRL_START_Pos));
908 }
909
910 /**
911 * @brief Set ioa action when value meets to COUNT_A1IO.
912 *
913 * Register|BitsName
914 * --------|--------
915 * IO_ACT_CTRL | IOA_ACT_CTRL_C1
916 *
917 * @param DUAL_TIMERx Timer instance
918 * @param action This parameter can be one of the following values:
919 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
920 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
921 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
922 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
923 * @retval None
924 */
925 __STATIC_INLINE void ll_dual_timer_set_ioa_action_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
926 {
927 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_C1, (action << DUAL_TIMER_IOA_ACT_CTRL_C1_Pos));
928 }
929
930 /**
931 * @brief Get ioa action when value meets to COUNT_A1IO.
932 *
933 * Register|BitsName
934 * --------|--------
935 * IO_ACT_CTRL | IOA_ACT_CTRL_C1
936 *
937 * @param DUAL_TIMERx Timer instance
938 * @retval Return value can be one of the following values:
939 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
940 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
941 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
942 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
943 */
944 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_count1(dual_timer_regs_t *DUAL_TIMERx)
945 {
946 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_C1) >> DUAL_TIMER_IOA_ACT_CTRL_C1_Pos));
947 }
948
949 /**
950 * @brief Set ioa action when value meets to COUNT_A2IO.
951 *
952 * Register|BitsName
953 * --------|--------
954 * IO_ACT_CTRL | IOA_ACT_CTRL_C2
955 *
956 * @param DUAL_TIMERx Timer instance
957 * @param action This parameter can be one of the following values:
958 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
959 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
960 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
961 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
962 * @retval None
963 */
964 __STATIC_INLINE void ll_dual_timer_set_ioa_action_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
965 {
966 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_C2, (action << DUAL_TIMER_IOA_ACT_CTRL_C2_Pos));
967 }
968
969 /**
970 * @brief Get ioa action when value meets to COUNT_A2IO.
971 *
972 * Register|BitsName
973 * --------|--------
974 * IO_ACT_CTRL | IOA_ACT_CTRL_C2
975 *
976 * @param DUAL_TIMERx Timer instance
977 * @retval Return value can be one of the following values:
978 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
979 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
980 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
981 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
982 */
983 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_count2(dual_timer_regs_t *DUAL_TIMERx)
984 {
985 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_C2) >> DUAL_TIMER_IOA_ACT_CTRL_C2_Pos));
986 }
987
988 /**
989 * @brief Set ioa action when value downs to 0.
990 *
991 * Register|BitsName
992 * --------|--------
993 * IO_ACT_CTRL | IOA_ACT_CTRL_PERIOD
994 *
995 * @param DUAL_TIMERx Timer instance
996 * @param action This parameter can be one of the following values:
997 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
998 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
999 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1000 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1001 * @retval None
1002 */
1003 __STATIC_INLINE void ll_dual_timer_set_ioa_action_period(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1004 {
1005 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_PERIOD, (action << DUAL_TIMER_IOA_ACT_CTRL_PERIOD_Pos));
1006 }
1007
1008 /**
1009 * @brief Get ioa action when value downs to 0.
1010 *
1011 * Register|BitsName
1012 * --------|--------
1013 * IO_ACT_CTRL | IOA_ACT_CTRL_PERIOD
1014 *
1015 * @param DUAL_TIMERx Timer instance
1016 * @retval Return value can be one of the following values:
1017 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1018 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1019 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1020 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1021 */
1022 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_period(dual_timer_regs_t *DUAL_TIMERx)
1023 {
1024 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_PERIOD) >> DUAL_TIMER_IOA_ACT_CTRL_PERIOD_Pos));
1025 }
1026
1027 /**
1028 * @brief Set ioa action when timer stop.
1029 *
1030 * Register|BitsName
1031 * --------|--------
1032 * IO_ACT_CTRL | IOA_ACT_CTRL_STOP
1033 *
1034 * @param DUAL_TIMERx Timer instance
1035 * @param action This parameter can be one of the following values:
1036 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1037 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1038 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1039 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1040 * @retval None
1041 */
1042 __STATIC_INLINE void ll_dual_timer_set_ioa_action_stop(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1043 {
1044 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_STOP, (action << DUAL_TIMER_IOA_ACT_CTRL_STOP_Pos));
1045 }
1046
1047 /**
1048 * @brief Get ioa action when timer stop.
1049 *
1050 * Register|BitsName
1051 * --------|--------
1052 * IO_ACT_CTRL | IOA_ACT_CTRL_STOP
1053 *
1054 * @param DUAL_TIMERx Timer instance
1055 * @retval Return value can be one of the following values:
1056 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1057 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1058 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1059 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1060 */
1061 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_stop(dual_timer_regs_t *DUAL_TIMERx)
1062 {
1063 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOA_ACT_CTRL_STOP) >> DUAL_TIMER_IOA_ACT_CTRL_STOP_Pos));
1064 }
1065
1066 /**
1067 * @brief Set iob action when timer start.
1068 *
1069 * Register|BitsName
1070 * --------|--------
1071 * IO_ACT_CTRL | IOB_ACT_CTRL_START
1072 *
1073 * @param DUAL_TIMERx Timer instance
1074 * @param action This parameter can be one of the following values:
1075 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1076 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1077 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1078 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1079 * @retval None
1080 */
1081 __STATIC_INLINE void ll_dual_timer_set_iob_action_start(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1082 {
1083 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_START, (action << DUAL_TIMER_IOB_ACT_CTRL_START_Pos));
1084 }
1085
1086 /**
1087 * @brief Get iob action when timer start.
1088 *
1089 * Register|BitsName
1090 * --------|--------
1091 * IO_ACT_CTRL | IOB_ACT_CTRL_START
1092 *
1093 * @param DUAL_TIMERx Timer instance
1094 * @retval Return value can be one of the following values:
1095 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1096 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1097 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1098 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1099 */
1100 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_start(dual_timer_regs_t *DUAL_TIMERx)
1101 {
1102 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_START) >> DUAL_TIMER_IOB_ACT_CTRL_START_Pos));
1103 }
1104
1105 /**
1106 * @brief Set iob action when value meets to COUNT_B1IO.
1107 *
1108 * Register|BitsName
1109 * --------|--------
1110 * IO_ACT_CTRL | IOB_ACT_CTRL_C1
1111 *
1112 * @param DUAL_TIMERx Timer instance
1113 * @param action This parameter can be one of the following values:
1114 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1115 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1116 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1117 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1118 * @retval None
1119 */
1120 __STATIC_INLINE void ll_dual_timer_set_iob_action_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1121 {
1122 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_C1, (action << DUAL_TIMER_IOB_ACT_CTRL_C1_Pos));
1123 }
1124
1125 /**
1126 * @brief Get iob action when value meets to COUNT_B1IO.
1127 *
1128 * Register|BitsName
1129 * --------|--------
1130 * IO_ACT_CTRL | IOB_ACT_CTRL_C1
1131 *
1132 * @param DUAL_TIMERx Timer instance
1133 * @retval Return value can be one of the following values:
1134 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1135 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1136 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1137 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1138 */
1139 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_count1(dual_timer_regs_t *DUAL_TIMERx)
1140 {
1141 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_C1) >> DUAL_TIMER_IOB_ACT_CTRL_C1_Pos));
1142 }
1143
1144 /**
1145 * @brief Set iob action when value meets to COUNT_B2IO.
1146 *
1147 * Register|BitsName
1148 * --------|--------
1149 * IO_ACT_CTRL | IOB_ACT_CTRL_C2
1150 *
1151 * @param DUAL_TIMERx Timer instance
1152 * @param action This parameter can be one of the following values:
1153 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1154 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1155 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1156 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1157 * @retval None
1158 */
1159 __STATIC_INLINE void ll_dual_timer_set_iob_action_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1160 {
1161 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_C2, (action << DUAL_TIMER_IOB_ACT_CTRL_C2_Pos));
1162 }
1163
1164 /**
1165 * @brief Get iob action when value meets to COUNT_B2IO.
1166 *
1167 * Register|BitsName
1168 * --------|--------
1169 * IO_ACT_CTRL | IOB_ACT_CTRL_C2
1170 *
1171 * @param DUAL_TIMERx Timer instance
1172 * @retval Return value can be one of the following values:
1173 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1174 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1175 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1176 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1177 */
1178 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_count2(dual_timer_regs_t *DUAL_TIMERx)
1179 {
1180 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_C2) >> DUAL_TIMER_IOB_ACT_CTRL_C2_Pos));
1181 }
1182
1183 /**
1184 * @brief Set iob action when value downs to 0.
1185 *
1186 * Register|BitsName
1187 * --------|--------
1188 * IO_ACT_CTRL | IOB_ACT_CTRL_PERIOD
1189 *
1190 * @param DUAL_TIMERx Timer instance
1191 * @param action This parameter can be one of the following values:
1192 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1193 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1194 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1195 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1196 * @retval None
1197 */
1198 __STATIC_INLINE void ll_dual_timer_set_iob_action_period(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1199 {
1200 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_PERIOD, (action << DUAL_TIMER_IOB_ACT_CTRL_PERIOD_Pos));
1201 }
1202
1203 /**
1204 * @brief Get iob action when value downs to 0.
1205 *
1206 * Register|BitsName
1207 * --------|--------
1208 * IO_ACT_CTRL | IOB_ACT_CTRL_PERIOD
1209 *
1210 * @param DUAL_TIMERx Timer instance
1211 * @retval Return value can be one of the following values:
1212 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1213 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1214 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1215 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1216 */
1217 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_period(dual_timer_regs_t *DUAL_TIMERx)
1218 {
1219 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_PERIOD) >> DUAL_TIMER_IOB_ACT_CTRL_PERIOD_Pos));
1220 }
1221
1222 /**
1223 * @brief Set iob action when timer stop.
1224 *
1225 * Register|BitsName
1226 * --------|--------
1227 * IO_ACT_CTRL | IOB_ACT_CTRL_STOP
1228 *
1229 * @param DUAL_TIMERx Timer instance
1230 * @param action This parameter can be one of the following values:
1231 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1232 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1233 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1234 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1235 * @retval None
1236 */
1237 __STATIC_INLINE void ll_dual_timer_set_iob_action_stop(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1238 {
1239 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_STOP, (action << DUAL_TIMER_IOB_ACT_CTRL_STOP_Pos));
1240 }
1241
1242 /**
1243 * @brief Get iob action when timer stop.
1244 *
1245 * Register|BitsName
1246 * --------|--------
1247 * IO_ACT_CTRL | IOB_ACT_CTRL_STOP
1248 *
1249 * @param DUAL_TIMERx Timer instance
1250 * @retval Return value can be one of the following values:
1251 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1252 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1253 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1254 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1255 */
1256 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_stop(dual_timer_regs_t *DUAL_TIMERx)
1257 {
1258 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOB_ACT_CTRL_STOP) >> DUAL_TIMER_IOB_ACT_CTRL_STOP_Pos));
1259 }
1260
1261 /**
1262 * @brief Set ioc action when timer start.
1263 *
1264 * Register|BitsName
1265 * --------|--------
1266 * IO_ACT_CTRL | IOC_ACT_CTRL_START
1267 *
1268 * @param DUAL_TIMERx Timer instance
1269 * @param action This parameter can be one of the following values:
1270 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1271 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1272 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1273 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1274 * @retval None
1275 */
1276 __STATIC_INLINE void ll_dual_timer_set_ioc_action_start(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1277 {
1278 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_START, (action << DUAL_TIMER_IOC_ACT_CTRL_START_Pos));
1279 }
1280
1281 /**
1282 * @brief Get ioc action when timer start.
1283 *
1284 * Register|BitsName
1285 * --------|--------
1286 * IO_ACT_CTRL | IOC_ACT_CTRL_START
1287 *
1288 * @param DUAL_TIMERx Timer instance
1289 * @retval Return value can be one of the following values:
1290 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1291 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1292 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1293 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1294 */
1295 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_start(dual_timer_regs_t *DUAL_TIMERx)
1296 {
1297 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_START) >> DUAL_TIMER_IOC_ACT_CTRL_START_Pos));
1298 }
1299
1300 /**
1301 * @brief Set ioc action when value meets to COUNT_C1IO.
1302 *
1303 * Register|BitsName
1304 * --------|--------
1305 * IO_ACT_CTRL | IOC_ACT_CTRL_C1
1306 *
1307 * @param DUAL_TIMERx Timer instance
1308 * @param action This parameter can be one of the following values:
1309 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1310 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1311 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1312 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1313 * @retval None
1314 */
1315 __STATIC_INLINE void ll_dual_timer_set_ioc_action_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1316 {
1317 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_C1, (action << DUAL_TIMER_IOC_ACT_CTRL_C1_Pos));
1318 }
1319
1320 /**
1321 * @brief Get ioc action when value meets to COUNT_C1IO.
1322 *
1323 * Register|BitsName
1324 * --------|--------
1325 * IO_ACT_CTRL | IOC_ACT_CTRL_C1
1326 *
1327 * @param DUAL_TIMERx Timer instance
1328 * @retval Return value can be one of the following values:
1329 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1330 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1331 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1332 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1333 */
1334 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_count1(dual_timer_regs_t *DUAL_TIMERx)
1335 {
1336 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_C1) >> DUAL_TIMER_IOC_ACT_CTRL_C1_Pos));
1337 }
1338
1339 /**
1340 * @brief Set ioc action when value meets to COUNT_C2IO.
1341 *
1342 * Register|BitsName
1343 * --------|--------
1344 * IO_ACT_CTRL | IOC_ACT_CTRL_C2
1345 *
1346 * @param DUAL_TIMERx Timer instance
1347 * @param action This parameter can be one of the following values:
1348 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1349 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1350 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1351 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1352 * @retval None
1353 */
1354 __STATIC_INLINE void ll_dual_timer_set_ioc_action_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1355 {
1356 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_C2, (action << DUAL_TIMER_IOC_ACT_CTRL_C2_Pos));
1357 }
1358
1359 /**
1360 * @brief Get ioc action when value meets to COUNT_C2IO.
1361 *
1362 * Register|BitsName
1363 * --------|--------
1364 * IO_ACT_CTRL | IOC_ACT_CTRL_C2
1365 *
1366 * @param DUAL_TIMERx Timer instance
1367 * @retval Return value can be one of the following values:
1368 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1369 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1370 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1371 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1372 */
1373 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_count2(dual_timer_regs_t *DUAL_TIMERx)
1374 {
1375 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_C2) >> DUAL_TIMER_IOC_ACT_CTRL_C2_Pos));
1376 }
1377
1378 /**
1379 * @brief Set ioc action when value downs to 0.
1380 *
1381 * Register|BitsName
1382 * --------|--------
1383 * IO_ACT_CTRL | IOC_ACT_CTRL_PERIOD
1384 *
1385 * @param DUAL_TIMERx Timer instance
1386 * @param action This parameter can be one of the following values:
1387 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1388 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1389 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1390 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1391 * @retval None
1392 */
1393 __STATIC_INLINE void ll_dual_timer_set_ioc_action_period(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1394 {
1395 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_PERIOD, (action << DUAL_TIMER_IOC_ACT_CTRL_PERIOD_Pos));
1396 }
1397
1398 /**
1399 * @brief Get ioc action when value downs to 0.
1400 *
1401 * Register|BitsName
1402 * --------|--------
1403 * IO_ACT_CTRL | IOC_ACT_CTRL_PERIOD
1404 *
1405 * @param DUAL_TIMERx Timer instance
1406 * @retval Return value can be one of the following values:
1407 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1408 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1409 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1410 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1411 */
1412 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_period(dual_timer_regs_t *DUAL_TIMERx)
1413 {
1414 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_PERIOD) >> DUAL_TIMER_IOC_ACT_CTRL_PERIOD_Pos));
1415 }
1416
1417 /**
1418 * @brief Set ioc action when timer stop.
1419 *
1420 * Register|BitsName
1421 * --------|--------
1422 * IO_ACT_CTRL | IOC_ACT_CTRL_STOP
1423 *
1424 * @param DUAL_TIMERx Timer instance
1425 * @param action This parameter can be one of the following values:
1426 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1427 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1428 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1429 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1430 * @retval None
1431 */
1432 __STATIC_INLINE void ll_dual_timer_set_ioc_action_stop(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
1433 {
1434 MODIFY_REG(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_STOP, (action << DUAL_TIMER_IOC_ACT_CTRL_STOP_Pos));
1435 }
1436
1437 /**
1438 * @brief Get ioc action when timer stop.
1439 *
1440 * Register|BitsName
1441 * --------|--------
1442 * IO_ACT_CTRL | IOC_ACT_CTRL_STOP
1443 *
1444 * @param DUAL_TIMERx Timer instance
1445 * @retval Return value can be one of the following values:
1446 * @arg @ref LL_DUAL_TIMER_IO_ACTION_NONE
1447 * @arg @ref LL_DUAL_TIMER_IO_ACTION_SET
1448 * @arg @ref LL_DUAL_TIMER_IO_ACTION_RESET
1449 * @arg @ref LL_DUAL_TIMER_IO_ACTION_TOGGLE
1450 */
1451 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_stop(dual_timer_regs_t *DUAL_TIMERx)
1452 {
1453 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_ACT_CTRL, DUAL_TIMER_IOC_ACT_CTRL_STOP) >> DUAL_TIMER_IOC_ACT_CTRL_STOP_Pos));
1454 }
1455
1456 /**
1457 * @brief Set ioa initial vaule when DUAL_TIMER_CTRL_IOA is disable.
1458 *
1459 * Register|BitsName
1460 * --------|--------
1461 * IO_INIT_SET | IOA_ACT_INIT
1462 *
1463 * @param DUAL_TIMERx Timer instance
1464 * @param value This parameter can be one of the following values:
1465 * @arg @ref LL_DUAL_TIMER_IO_INIT_RESET
1466 * @arg @ref LL_DUAL_TIMER_IO_INIT_SET
1467 * @retval None
1468 */
1469 __STATIC_INLINE void ll_dual_timer_set_ioa_action_init(dual_timer_regs_t *DUAL_TIMERx, uint32_t value)
1470 {
1471 MODIFY_REG(DUAL_TIMERx->IO_INIT_SET, DUAL_TIMER_IOA_ACT_INIT, (value << DUAL_TIMER_IOA_ACT_INIT_Pos));
1472 }
1473
1474 /**
1475 * @brief Get ioa initial vaule.
1476 *
1477 * Register|BitsName
1478 * --------|--------
1479 * IO_INIT_SET | IOA_ACT_INIT
1480 *
1481 * @param DUAL_TIMERx Timer instance
1482 * @retval Return value can be one of the following values:
1483 * @arg @ref LL_DUAL_TIMER_IO_INIT_RESET
1484 * @arg @ref LL_DUAL_TIMER_IO_INIT_SET
1485 */
1486 __STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_init(dual_timer_regs_t *DUAL_TIMERx)
1487 {
1488 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_INIT_SET, DUAL_TIMER_IOA_ACT_INIT) >> DUAL_TIMER_IOA_ACT_INIT_Pos));
1489 }
1490
1491 /**
1492 * @brief Set iob initial vaule when DUAL_TIMER_CTRL_IOB is disable.
1493 *
1494 * Register|BitsName
1495 * --------|--------
1496 * IO_INIT_SET | IOB_ACT_INIT
1497 *
1498 * @param DUAL_TIMERx Timer instance
1499 * @param value This parameter can be one of the following values:
1500 * @arg @ref LL_DUAL_TIMER_IO_INIT_RESET
1501 * @arg @ref LL_DUAL_TIMER_IO_INIT_SET
1502 * @retval None
1503 */
1504 __STATIC_INLINE void ll_dual_timer_set_iob_action_init(dual_timer_regs_t *DUAL_TIMERx, uint32_t value)
1505 {
1506 MODIFY_REG(DUAL_TIMERx->IO_INIT_SET, DUAL_TIMER_IOB_ACT_INIT, (value << DUAL_TIMER_IOB_ACT_INIT_Pos));
1507 }
1508
1509 /**
1510 * @brief Get iob initial vaule.
1511 *
1512 * Register|BitsName
1513 * --------|--------
1514 * IO_INIT_SET | IOB_ACT_INIT
1515 *
1516 * @param DUAL_TIMERx Timer instance
1517 * @retval Return value can be one of the following values:
1518 * @arg @ref LL_DUAL_TIMER_IO_INIT_RESET
1519 * @arg @ref LL_DUAL_TIMER_IO_INIT_SET
1520 */
1521 __STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_init(dual_timer_regs_t *DUAL_TIMERx)
1522 {
1523 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_INIT_SET, DUAL_TIMER_IOB_ACT_INIT) >> DUAL_TIMER_IOB_ACT_INIT_Pos));
1524 }
1525
1526 /**
1527 * @brief Set ioc initial vaule when DUAL_TIMER_CTRL_IOC is disable.
1528 *
1529 * Register|BitsName
1530 * --------|--------
1531 * IO_INIT_SET | IOC_ACT_INIT
1532 *
1533 * @param DUAL_TIMERx Timer instance
1534 * @param value This parameter can be one of the following values:
1535 * @arg @ref LL_DUAL_TIMER_IO_INIT_RESET
1536 * @arg @ref LL_DUAL_TIMER_IO_INIT_SET
1537 * @retval None
1538 */
1539 __STATIC_INLINE void ll_dual_timer_set_ioc_action_init(dual_timer_regs_t *DUAL_TIMERx, uint32_t value)
1540 {
1541 MODIFY_REG(DUAL_TIMERx->IO_INIT_SET, DUAL_TIMER_IOC_ACT_INIT, (value << DUAL_TIMER_IOC_ACT_INIT_Pos));
1542 }
1543
1544 /**
1545 * @brief Get ioc initial vaule.
1546 *
1547 * Register|BitsName
1548 * --------|--------
1549 * IO_INIT_SET | IOC_ACT_INIT
1550 *
1551 * @param DUAL_TIMERx Timer instance
1552 * @retval Return value can be one of the following values:
1553 * @arg @ref LL_DUAL_TIMER_IO_INIT_RESET
1554 * @arg @ref LL_DUAL_TIMER_IO_INIT_SET
1555 */
1556 __STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_init(dual_timer_regs_t *DUAL_TIMERx)
1557 {
1558 return (uint32_t)((READ_BITS(DUAL_TIMERx->IO_INIT_SET, DUAL_TIMER_IOC_ACT_INIT) >> DUAL_TIMER_IOC_ACT_INIT_Pos));
1559 }
1560
1561 /**
1562 * @brief Set the one-time reload value.
1563 *
1564 * Register|BitsName
1565 * --------|--------
1566 * TP_LOAD | TP_LOAD
1567 *
1568 * @param DUAL_TIMERx Timer instance
1569 * @param onetime_reload between Min_Data=0 and Max_Data=0xFFFFFFFF
1570 * @retval None
1571 */
1572 __STATIC_INLINE void ll_dual_timer_set_onetime_reload(dual_timer_regs_t *DUAL_TIMERx, uint32_t onetime_reload)
1573 {
1574 WRITE_REG(DUAL_TIMERx->TP_LOAD, onetime_reload);
1575 }
1576
1577 /**
1578 * @brief Get the one-time reload value.
1579 *
1580 * Register|BitsName
1581 * --------|--------
1582 * TP_LOAD | TP_LOAD
1583 *
1584 * @param DUAL_TIMERx Timer instance
1585 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
1586 */
1587 __STATIC_INLINE uint32_t ll_dual_timer_get_onetime_reload(dual_timer_regs_t *DUAL_TIMERx)
1588 {
1589 return (uint32_t)(READ_REG(DUAL_TIMERx->TP_LOAD));
1590 }
1591
1592 /**
1593 * @brief Set the BLE count 1 value.
1594 *
1595 * Register|BitsName
1596 * --------|--------
1597 * BLE_COUNT1 | BLE_COUNT1
1598 *
1599 * @param DUAL_TIMERx Timer instance
1600 * @param count_value count 1 value between Min_Data=0 and Max_Data=0xFFFFFFFF
1601 * @retval None
1602 */
1603 __STATIC_INLINE void ll_dual_timer_set_ble_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
1604 {
1605 WRITE_REG(DUAL_TIMERx->BLE_COUNT1, count_value);
1606 }
1607
1608 /**
1609 * @brief Get the BLE count 1 value.
1610 *
1611 * Register|BitsName
1612 * --------|--------
1613 * BLE_COUNT1 | BLE_COUNT1
1614 *
1615 * @param DUAL_TIMERx Timer instance
1616 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
1617 */
1618 __STATIC_INLINE uint32_t ll_dual_timer_get_ble_count1(dual_timer_regs_t *DUAL_TIMERx)
1619 {
1620 return (uint32_t)(READ_REG(DUAL_TIMERx->BLE_COUNT1));
1621 }
1622
1623 /**
1624 * @brief Set the BLE count 2 value.
1625 *
1626 * Register|BitsName
1627 * --------|--------
1628 * BLE_COUNT2 | BLE_COUNT2
1629 *
1630 * @param DUAL_TIMERx Timer instance
1631 * @param count_value count 2 value between Min_Data=0 and Max_Data=0xFFFFFFFF
1632 * @retval None
1633 */
1634 __STATIC_INLINE void ll_dual_timer_set_ble_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
1635 {
1636 WRITE_REG(DUAL_TIMERx->BLE_COUNT2, count_value);
1637 }
1638
1639 /**
1640 * @brief Get the BLE count 2 value.
1641 *
1642 * Register|BitsName
1643 * --------|--------
1644 * BLE_COUNT2 | BLE_COUNT2
1645 *
1646 * @param DUAL_TIMERx Timer instance
1647 * @retval Return value between Min_Data=0 and Max_Data=0xFFFFFFFF
1648 */
1649 __STATIC_INLINE uint32_t ll_dual_timer_get_ble_count2(dual_timer_regs_t *DUAL_TIMERx)
1650 {
1651 return (uint32_t)(READ_REG(DUAL_TIMERx->BLE_COUNT2));
1652 }
1653
1654 /**
1655 * @brief Set the BLE pulse width.
1656 *
1657 * Register|BitsName
1658 * --------|--------
1659 * BLE_PULSEWIDTH | BLE_PULSEWIDTH
1660 *
1661 * @param DUAL_TIMERx Timer instance
1662 * @param width pulse width
1663 * @retval None
1664 */
1665 __STATIC_INLINE void ll_dual_timer_set_ble_pulse_width(dual_timer_regs_t *DUAL_TIMERx, uint32_t width)
1666 {
1667 MODIFY_REG(DUAL_TIMERx->BLE_PULSEWIDTH, DUAL_TIMER_BLE_PULSEWIDTH, (width << DUAL_TIMER_BLE_PULSEWIDTH_Pos));
1668 }
1669
1670 /**
1671 * @brief Get the BLE pulse width.
1672 *
1673 * Register|BitsName
1674 * --------|--------
1675 * BLE_PULSEWIDTH | BLE_PULSEWIDTH
1676 *
1677 * @param DUAL_TIMERx Timer instance
1678 * @retval BLE pulse width
1679 */
1680 __STATIC_INLINE uint32_t ll_dual_timer_get_ble_pulse_width(dual_timer_regs_t *DUAL_TIMERx)
1681 {
1682 return (uint32_t)((READ_BITS(DUAL_TIMERx->BLE_PULSEWIDTH, DUAL_TIMER_BLE_PULSEWIDTH) >> DUAL_TIMER_BLE_PULSEWIDTH_Pos));
1683 }
1684
1685 /**
1686 * @brief Set the period count in period mode.
1687 *
1688 * Register|BitsName
1689 * --------|--------
1690 * PERIOD_COUNT | PERIOD_COUNT
1691 *
1692 * @param DUAL_TIMERx Timer instance
1693 * @param count between Min_Data=2 and Max_Data=0xFFFF
1694 * @retval None
1695 */
1696 __STATIC_INLINE void ll_dual_timer_set_period_count(dual_timer_regs_t *DUAL_TIMERx, uint32_t count)
1697 {
1698 WRITE_REG(DUAL_TIMERx->PERIOD_COUNT, count);
1699 }
1700
1701 /**
1702 * @brief Get the period count in period mode.
1703 *
1704 * Register|BitsName
1705 * --------|--------
1706 * PERIOD_COUNT | PERIOD_COUNT
1707 *
1708 * @param DUAL_TIMERx Timer instance
1709 * @retval Return value between Min_Data=2 and Max_Data=0xFFFF
1710 */
1711 __STATIC_INLINE uint32_t ll_dual_timer_get_period_count(dual_timer_regs_t *DUAL_TIMERx)
1712 {
1713 return (uint32_t)(READ_REG(DUAL_TIMERx->PERIOD_COUNT));
1714 }
1715 /** @} */
1716
1717 /** @defgroup DUAL_TIM_LL_EF_IT_Management IT_Management
1718 * @{
1719 */
1720
1721 /**
1722 * @brief Enable dual_timer interrupt.
1723 *
1724 * Register|BitsName
1725 * --------|--------
1726 * CTRL | INTEN
1727 *
1728 * @param DUAL_TIMERx Timer instance
1729 * @retval None
1730 */
1731 __STATIC_INLINE void ll_dual_timer_enable_it(dual_timer_regs_t *DUAL_TIMERx)
1732 {
1733 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_INTEN);
1734 }
1735
1736 /**
1737 * @brief Disable dual_timer interrput.
1738 *
1739 * Register|BitsName
1740 * --------|--------
1741 * CTRL | INTEN
1742 *
1743 * @param DUAL_TIMERx Timer instance
1744 * @retval None
1745 */
1746 __STATIC_INLINE void ll_dual_timer_disable_it(dual_timer_regs_t *DUAL_TIMERx)
1747 {
1748 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_INTEN);
1749 }
1750
1751 /**
1752 * @brief Indicate whether the dual_timer interrput is enabled.
1753 *
1754 * Register|BitsName
1755 * --------|--------
1756 * CTRL | INTEN
1757 *
1758 * @param DUAL_TIMERx Timer instance
1759 * @retval State of bit (1 or 0).
1760 */
1761 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_it(dual_timer_regs_t *DUAL_TIMERx)
1762 {
1763 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_INTEN) == (DUAL_TIMER_CTRL_INTEN));
1764 }
1765
1766 /**
1767 * @brief Enable dual_timer action interrupt when timer start.
1768 *
1769 * Register|BitsName
1770 * --------|--------
1771 * CTRL | ACT_START_INTEN
1772 *
1773 * @param DUAL_TIMERx Timer instance
1774 * @retval None
1775 */
1776 __STATIC_INLINE void ll_dual_timer_enable_act_start_it(dual_timer_regs_t *DUAL_TIMERx)
1777 {
1778 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_START_INTEN);
1779 }
1780
1781 /**
1782 * @brief Disable dual_timer action interrupt when timer start.
1783 *
1784 * Register|BitsName
1785 * --------|--------
1786 * CTRL | ACT_START_INTEN
1787 *
1788 * @param DUAL_TIMERx Timer instance
1789 * @retval None
1790 */
1791 __STATIC_INLINE void ll_dual_timer_disable_act_start_it(dual_timer_regs_t *DUAL_TIMERx)
1792 {
1793 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_START_INTEN);
1794 }
1795
1796 /**
1797 * @brief Indicate whether the dual_timer action interrupt when timer start is enabled.
1798 *
1799 * Register|BitsName
1800 * --------|--------
1801 * CTRL | ACT_START_INTEN
1802 *
1803 * @param DUAL_TIMERx Timer instance
1804 * @retval State of bit (1 or 0).
1805 */
1806 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_act_start_it(dual_timer_regs_t *DUAL_TIMERx)
1807 {
1808 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_START_INTEN) == (DUAL_TIMER_CTRL_ACT_START_INTEN));
1809 }
1810
1811 /**
1812 * @brief Enable dual_timer action interrupt when timer value meets to COUNT_A1IO.
1813 *
1814 * Register|BitsName
1815 * --------|--------
1816 * CTRL | IOA_ACT_C1_INTEN
1817 *
1818 * @param DUAL_TIMERx Timer instance
1819 * @retval None
1820 */
1821 __STATIC_INLINE void ll_dual_timer_enable_ioa_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
1822 {
1823 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA_ACT_C1_INTEN);
1824 }
1825
1826 /**
1827 * @brief Disable dual_timer action interrupt when timer value meets to COUNT_A1IO.
1828 *
1829 * Register|BitsName
1830 * --------|--------
1831 * CTRL | IOA_ACT_C1_INTEN
1832 *
1833 * @param DUAL_TIMERx Timer instance
1834 * @retval None
1835 */
1836 __STATIC_INLINE void ll_dual_timer_disable_ioa_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
1837 {
1838 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA_ACT_C1_INTEN);
1839 }
1840
1841 /**
1842 * @brief Indicate whether the dual_timer action interrupt when timer value meets to COUNT_A1IO is enabled.
1843 *
1844 * Register|BitsName
1845 * --------|--------
1846 * CTRL | IOA_ACT_C1_INTEN
1847 *
1848 * @param DUAL_TIMERx Timer instance
1849 * @retval State of bit (1 or 0).
1850 */
1851 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioa_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
1852 {
1853 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA_ACT_C1_INTEN) == (DUAL_TIMER_CTRL_IOA_ACT_C1_INTEN));
1854 }
1855
1856 /**
1857 * @brief Enable dual_timer action interrupt when timer value meets to COUNT_A2IO.
1858 *
1859 * Register|BitsName
1860 * --------|--------
1861 * CTRL | IOA_ACT_C2_INTEN
1862 *
1863 * @param DUAL_TIMERx Timer instance
1864 * @retval None
1865 */
1866 __STATIC_INLINE void ll_dual_timer_enable_ioa_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
1867 {
1868 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA_ACT_C2_INTEN);
1869 }
1870
1871 /**
1872 * @brief Disable dual_timer action interrupt when timer value meets to COUNT_A2IO.
1873 *
1874 * Register|BitsName
1875 * --------|--------
1876 * CTRL | IOA_ACT_C2_INTEN
1877 *
1878 * @param DUAL_TIMERx Timer instance
1879 * @retval None
1880 */
1881 __STATIC_INLINE void ll_dual_timer_disable_ioa_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
1882 {
1883 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA_ACT_C2_INTEN);
1884 }
1885
1886 /**
1887 * @brief Indicate whether the dual_timer action interrupt when timer value meets to COUNT_A2IO is enabled.
1888 *
1889 * Register|BitsName
1890 * --------|--------
1891 * CTRL | IOA_ACT_C2_INTEN
1892 *
1893 * @param DUAL_TIMERx Timer instance
1894 * @retval State of bit (1 or 0).
1895 */
1896 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioa_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
1897 {
1898 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOA_ACT_C2_INTEN) == (DUAL_TIMER_CTRL_IOA_ACT_C2_INTEN));
1899 }
1900
1901 /**
1902 * @brief Enable dual_timer action interrupt when timer value meets to 0.
1903 *
1904 * Register|BitsName
1905 * --------|--------
1906 * CTRL | ACT_PERIOD_INTEN
1907 *
1908 * @param DUAL_TIMERx Timer instance
1909 * @retval None
1910 */
1911 __STATIC_INLINE void ll_dual_timer_enable_act_period_it(dual_timer_regs_t *DUAL_TIMERx)
1912 {
1913 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_PERIOD_INTEN);
1914 }
1915
1916 /**
1917 * @brief Disable dual_timer action interrupt when timer value meets to 0.
1918 *
1919 * Register|BitsName
1920 * --------|--------
1921 * CTRL | ACT_PERIOD_INTEN
1922 *
1923 * @param DUAL_TIMERx Timer instance
1924 * @retval None
1925 */
1926 __STATIC_INLINE void ll_dual_timer_disable_act_period_it(dual_timer_regs_t *DUAL_TIMERx)
1927 {
1928 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_PERIOD_INTEN);
1929 }
1930
1931 /**
1932 * @brief Indicate whether the dual_timer action interrupt when timer value meets to 0 is enabled.
1933 *
1934 * Register|BitsName
1935 * --------|--------
1936 * CTRL | ACT_PERIOD_INTEN
1937 *
1938 * @param DUAL_TIMERx Timer instance
1939 * @retval State of bit (1 or 0).
1940 */
1941 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_act_period_it(dual_timer_regs_t *DUAL_TIMERx)
1942 {
1943 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_PERIOD_INTEN) == (DUAL_TIMER_CTRL_ACT_PERIOD_INTEN));
1944 }
1945
1946 /**
1947 * @brief Enable dual_timer action interrupt when timer stop.
1948 *
1949 * Register|BitsName
1950 * --------|--------
1951 * CTRL | ACT_STOP_INTEN
1952 *
1953 * @param DUAL_TIMERx Timer instance
1954 * @retval None
1955 */
1956 __STATIC_INLINE void ll_dual_timer_enable_act_stop_it(dual_timer_regs_t *DUAL_TIMERx)
1957 {
1958 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_STOP_INTEN);
1959 }
1960
1961 /**
1962 * @brief Disable dual_timer action interrupt when timer stop.
1963 *
1964 * Register|BitsName
1965 * --------|--------
1966 * CTRL | ACT_STOP_INTEN
1967 *
1968 * @param DUAL_TIMERx Timer instance
1969 * @retval None
1970 */
1971 __STATIC_INLINE void ll_dual_timer_disable_act_stop_it(dual_timer_regs_t *DUAL_TIMERx)
1972 {
1973 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_STOP_INTEN);
1974 }
1975
1976 /**
1977 * @brief Indicate whether the dual_timer action interrupt when timer stop.
1978 *
1979 * Register|BitsName
1980 * --------|--------
1981 * CTRL | ACT_STOP_INTEN
1982 *
1983 * @param DUAL_TIMERx Timer instance
1984 * @retval State of bit (1 or 0).
1985 */
1986 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_act_stop_it(dual_timer_regs_t *DUAL_TIMERx)
1987 {
1988 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_ACT_STOP_INTEN) == (DUAL_TIMER_CTRL_ACT_STOP_INTEN));
1989 }
1990
1991 /**
1992 * @brief Enable dual_timer action interrupt when timer value meets to COUNT_B1IO.
1993 *
1994 * Register|BitsName
1995 * --------|--------
1996 * CTRL | IOB_ACT_C1_INTEN
1997 *
1998 * @param DUAL_TIMERx Timer instance
1999 * @retval None
2000 */
2001 __STATIC_INLINE void ll_dual_timer_enable_iob_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
2002 {
2003 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB_ACT_C1_INTEN);
2004 }
2005
2006 /**
2007 * @brief Disable dual_timer action interrupt when timer value meets to COUNT_B1IO.
2008 *
2009 * Register|BitsName
2010 * --------|--------
2011 * CTRL | IOB_ACT_C1_INTEN
2012 *
2013 * @param DUAL_TIMERx Timer instance
2014 * @retval None
2015 */
2016 __STATIC_INLINE void ll_dual_timer_disable_iob_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
2017 {
2018 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB_ACT_C1_INTEN);
2019 }
2020
2021 /**
2022 * @brief Indicate whether the dual_timer action interrupt when timer value meets to COUNT_B1IO is enabled.
2023 *
2024 * Register|BitsName
2025 * --------|--------
2026 * CTRL | IOB_ACT_C1_INTEN
2027 *
2028 * @param DUAL_TIMERx Timer instance
2029 * @retval State of bit (1 or 0).
2030 */
2031 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_iob_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
2032 {
2033 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB_ACT_C1_INTEN) == (DUAL_TIMER_CTRL_IOB_ACT_C1_INTEN));
2034 }
2035
2036 /**
2037 * @brief Enable dual_timer action interrupt when timer value meets to COUNT_B2IO.
2038 *
2039 * Register|BitsName
2040 * --------|--------
2041 * CTRL | IOB_ACT_C2_INTEN
2042 *
2043 * @param DUAL_TIMERx Timer instance
2044 * @retval None
2045 */
2046 __STATIC_INLINE void ll_dual_timer_enable_iob_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
2047 {
2048 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB_ACT_C2_INTEN);
2049 }
2050
2051 /**
2052 * @brief Disable dual_timer action interrupt when timer value meets to COUNT_B2IO.
2053 *
2054 * Register|BitsName
2055 * --------|--------
2056 * CTRL | IOB_ACT_C2_INTEN
2057 *
2058 * @param DUAL_TIMERx Timer instance
2059 * @retval None
2060 */
2061 __STATIC_INLINE void ll_dual_timer_disable_iob_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
2062 {
2063 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB_ACT_C2_INTEN);
2064 }
2065
2066 /**
2067 * @brief Indicate whether the dual_timer action interrupt when timer value meets to COUNT_B2IO is enabled.
2068 *
2069 * Register|BitsName
2070 * --------|--------
2071 * CTRL | IOB_ACT_C2_INTEN
2072 *
2073 * @param DUAL_TIMERx Timer instance
2074 * @retval State of bit (1 or 0).
2075 */
2076 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_iob_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
2077 {
2078 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOB_ACT_C2_INTEN) == (DUAL_TIMER_CTRL_IOB_ACT_C2_INTEN));
2079 }
2080
2081 /**
2082 * @brief Enable dual_timer action interrupt when timer value meets to COUNT_C1IO.
2083 *
2084 * Register|BitsName
2085 * --------|--------
2086 * CTRL | IOC_ACT_C1_INTEN
2087 *
2088 * @param DUAL_TIMERx Timer instance
2089 * @retval None
2090 */
2091 __STATIC_INLINE void ll_dual_timer_enable_ioc_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
2092 {
2093 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC_ACT_C1_INTEN);
2094 }
2095
2096 /**
2097 * @brief Disable dual_timer action interrupt when timer value meets to COUNT_C1IO.
2098 *
2099 * Register|BitsName
2100 * --------|--------
2101 * CTRL | IOC_ACT_C1_INTEN
2102 *
2103 * @param DUAL_TIMERx Timer instance
2104 * @retval None
2105 */
2106 __STATIC_INLINE void ll_dual_timer_disable_ioc_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
2107 {
2108 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC_ACT_C1_INTEN);
2109 }
2110
2111 /**
2112 * @brief Indicate whether the dual_timer action interrupt when timer value meets to COUNT_C1IO is enabled.
2113 *
2114 * Register|BitsName
2115 * --------|--------
2116 * CTRL | IOC_ACT_C1_INTEN
2117 *
2118 * @param DUAL_TIMERx Timer instance
2119 * @retval State of bit (1 or 0).
2120 */
2121 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioc_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
2122 {
2123 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC_ACT_C1_INTEN) == (DUAL_TIMER_CTRL_IOC_ACT_C1_INTEN));
2124 }
2125
2126 /**
2127 * @brief Enable dual_timer action interrupt when timer value meets to COUNT_C2IO.
2128 *
2129 * Register|BitsName
2130 * --------|--------
2131 * CTRL | IOC_ACT_C2_INTEN
2132 *
2133 * @param DUAL_TIMERx Timer instance
2134 * @retval None
2135 */
2136 __STATIC_INLINE void ll_dual_timer_enable_ioc_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
2137 {
2138 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC_ACT_C2_INTEN);
2139 }
2140
2141 /**
2142 * @brief Disable dual_timer action interrupt when timer value meets to COUNT_C2IO.
2143 *
2144 * Register|BitsName
2145 * --------|--------
2146 * CTRL | IOC_ACT_C2_INTEN
2147 *
2148 * @param DUAL_TIMERx Timer instance
2149 * @retval None
2150 */
2151 __STATIC_INLINE void ll_dual_timer_disable_ioc_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
2152 {
2153 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC_ACT_C2_INTEN);
2154 }
2155
2156 /**
2157 * @brief Indicate whether the dual_timer action interrupt when timer value meets to COUNT_C2IO is enabled.
2158 *
2159 * Register|BitsName
2160 * --------|--------
2161 * CTRL | IOC_ACT_C2_INTEN
2162 *
2163 * @param DUAL_TIMERx Timer instance
2164 * @retval State of bit (1 or 0).
2165 */
2166 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioc_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
2167 {
2168 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_IOC_ACT_C2_INTEN) == (DUAL_TIMER_CTRL_IOC_ACT_C2_INTEN));
2169 }
2170
2171 /**
2172 * @brief Enable dual_timer interrupt when timer value meets to BLE_COUNT1.
2173 *
2174 * Register|BitsName
2175 * --------|--------
2176 * CTRL | BLEPULSE1_INTEN
2177 *
2178 * @param DUAL_TIMERx Timer instance
2179 * @retval None
2180 */
2181 __STATIC_INLINE void ll_dual_timer_enable_ble_pulse1_it(dual_timer_regs_t *DUAL_TIMERx)
2182 {
2183 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLEPULSE1_INTEN);
2184 }
2185
2186 /**
2187 * @brief Disable dual_timer interrupt when timer value meets to BLE_COUNT1.
2188 *
2189 * Register|BitsName
2190 * --------|--------
2191 * CTRL | BLEPULSE1_INTEN
2192 *
2193 * @param DUAL_TIMERx Timer instance
2194 * @retval None
2195 */
2196 __STATIC_INLINE void ll_dual_timer_disable_ble_pulse1_it(dual_timer_regs_t *DUAL_TIMERx)
2197 {
2198 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLEPULSE1_INTEN);
2199 }
2200
2201 /**
2202 * @brief Indicate whether the dual_timer interrupt when timer value meets to BLE_COUNT1 is enabled.
2203 *
2204 * Register|BitsName
2205 * --------|--------
2206 * CTRL | BLEPULSE1_INTEN
2207 *
2208 * @param DUAL_TIMERx Timer instance
2209 * @retval State of bit (1 or 0).
2210 */
2211 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ble_pulse1_it(dual_timer_regs_t *DUAL_TIMERx)
2212 {
2213 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLEPULSE1_INTEN) == (DUAL_TIMER_CTRL_BLEPULSE1_INTEN));
2214 }
2215
2216 /**
2217 * @brief Enable dual_timer interrupt when timer value meets to BLE_COUNT2.
2218 *
2219 * Register|BitsName
2220 * --------|--------
2221 * CTRL | BLEPULSE2_INTEN
2222 *
2223 * @param DUAL_TIMERx Timer instance
2224 * @retval None
2225 */
2226 __STATIC_INLINE void ll_dual_timer_enable_ble_pulse2_it(dual_timer_regs_t *DUAL_TIMERx)
2227 {
2228 SET_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLEPULSE2_INTEN);
2229 }
2230
2231 /**
2232 * @brief Disable dual_timer interrupt when timer value meets to BLE_COUNT2.
2233 *
2234 * Register|BitsName
2235 * --------|--------
2236 * CTRL | BLEPULSE2_INTEN
2237 *
2238 * @param DUAL_TIMERx Timer instance
2239 * @retval None
2240 */
2241 __STATIC_INLINE void ll_dual_timer_disable_ble_pulse2_it(dual_timer_regs_t *DUAL_TIMERx)
2242 {
2243 CLEAR_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLEPULSE2_INTEN);
2244 }
2245
2246 /**
2247 * @brief Indicate whether the dual_timer interrupt when timer value meets to BLE_COUNT2 is enabled.
2248 *
2249 * Register|BitsName
2250 * --------|--------
2251 * CTRL | BLEPULSE2_INTEN
2252 *
2253 * @param DUAL_TIMERx Timer instance
2254 * @retval State of bit (1 or 0).
2255 */
2256 __STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ble_pulse2_it(dual_timer_regs_t *DUAL_TIMERx)
2257 {
2258 return (READ_BITS(DUAL_TIMERx->CTRL, DUAL_TIMER_CTRL_BLEPULSE2_INTEN) == (DUAL_TIMER_CTRL_BLEPULSE2_INTEN));
2259 }
2260 /** @} */
2261
2262 /** @defgroup DUAL_TIMER_LL_EF_FLAG_Management FLAG_Management
2263 * @{
2264 */
2265
2266 /**
2267 * @brief Clear the interrupt flag (INTSTAT).
2268 *
2269
2270 * Register|BitsName
2271 * --------|--------
2272 * INTCLR | INTCLR
2273 *
2274 * @param DUAL_TIMERx Timer instance
2275 * @retval None
2276 */
2277 __STATIC_INLINE void ll_dual_timer_clear_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2278 {
2279 WRITE_REG(DUAL_TIMERx->INTCLR, DUAL_TIMER_INT_CLR);
2280 }
2281
2282 /**
2283 * @brief Indicate whether interrupt flag (INTSTAT) is set (interrupt is pending).
2284 *
2285 * Register|BitsName
2286 * --------|--------
2287 * INTSTAT | INTSTAT
2288 *
2289 * @param DUAL_TIMERx Timer instance
2290 * @retval State of bit (1 or 0).
2291 */
2292 __STATIC_INLINE uint32_t ll_dual_timer_is_active_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2293 {
2294 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_ISR_TI) == (DUAL_TIMER_ISR_TI));
2295 }
2296
2297 /**
2298 * @brief Get Dual_timer raw interrupt flags
2299 *
2300 * Register|BitsName
2301 * --------|--------
2302 * RAW_INTSTAT | RAW_INTSTAT
2303 *
2304 * @param DUAL_TIMERx Timer instance
2305 * @retval State of bit (1 or 0).
2306 */
2307 __STATIC_INLINE uint32_t ll_dual_timer_get_raw_it_flag(dual_timer_regs_t *DUAL_TIMERx)
2308 {
2309 return (READ_REG(DUAL_TIMERx->RAW_INTSTAT));
2310 }
2311
2312 /**
2313 * @brief Get dual timer interrupt flag
2314 *
2315 * Register|BitsName
2316 * --------|--------
2317 * INTSTAT | INTSTAT
2318 *
2319 * @param DUAL_TIMERx Timer instance
2320 * @retval interrupt flag
2321 */
2322 __STATIC_INLINE uint32_t ll_dual_timer_get_it_flag(dual_timer_regs_t *DUAL_TIMERx)
2323 {
2324 return (uint32_t )(READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_STAT));
2325 }
2326
2327 /**
2328 * @brief Indicate whether action interrupt flag is set when timer start.
2329 *
2330 * Register|BitsName
2331 * --------|--------
2332 * INTSTAT | ACT_START
2333 *
2334 * @param DUAL_TIMERx Timer instance
2335 * @retval State of bit (1 or 0).
2336 */
2337 __STATIC_INLINE uint32_t ll_dual_timer_is_action_start_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2338 {
2339 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_ACT_START) == (DUAL_TIMER_INT_ACT_START));
2340 }
2341
2342 /**
2343 * @brief Indicate whether action interrupt flag is set when timer value meets to COUNT_A1IO.
2344 *
2345 * Register|BitsName
2346 * --------|--------
2347 * INTSTAT | IOA_ACT_C1
2348 *
2349 * @param DUAL_TIMERx Timer instance
2350 * @retval State of bit (1 or 0).
2351 */
2352 __STATIC_INLINE uint32_t ll_dual_timer_is_ioa_action_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2353 {
2354 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_IOA_ACT_C1) == (DUAL_TIMER_INT_IOA_ACT_C1));
2355 }
2356
2357 /**
2358 * @brief Indicate whether action interrupt flag is set when timer value meets to COUNT_A2IO.
2359 *
2360 * Register|BitsName
2361 * --------|--------
2362 * INTSTAT | IOA_ACT_C2
2363 *
2364 * @param DUAL_TIMERx Timer instance
2365 * @retval State of bit (1 or 0).
2366 */
2367 __STATIC_INLINE uint32_t ll_dual_timer_is_ioa_action_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2368 {
2369 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_IOA_ACT_C2) == (DUAL_TIMER_INT_IOA_ACT_C2));
2370 }
2371
2372 /**
2373 * @brief Indicate whether action interrupt flag is set when timer value meets to 0.
2374 *
2375 * Register|BitsName
2376 * --------|--------
2377 * INTSTAT | ACT_PERIOD
2378 *
2379 * @param DUAL_TIMERx Timer instance
2380 * @retval State of bit (1 or 0).
2381 */
2382 __STATIC_INLINE uint32_t ll_dual_timer_is_action_period_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2383 {
2384 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_ACT_PERIOD) == (DUAL_TIMER_INT_ACT_PERIOD));
2385 }
2386
2387 /**
2388 * @brief Indicate whether action interrupt flag is set when timer stop.
2389 *
2390 * Register|BitsName
2391 * --------|--------
2392 * INTSTAT | ACT_STOP
2393 *
2394 * @param DUAL_TIMERx Timer instance
2395 * @retval State of bit (1 or 0).
2396 */
2397 __STATIC_INLINE uint32_t ll_dual_timer_is_action_stop_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2398 {
2399 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_ACT_STOP) == (DUAL_TIMER_INT_ACT_STOP));
2400 }
2401
2402 /**
2403 * @brief Indicate whether action interrupt flag is set when timer value meets to COUNT_B1IO.
2404 *
2405 * Register|BitsName
2406 * --------|--------
2407 * INTSTAT | IOB_ACT_C1
2408 *
2409 * @param DUAL_TIMERx Timer instance
2410 * @retval State of bit (1 or 0).
2411 */
2412 __STATIC_INLINE uint32_t ll_dual_timer_is_iob_action_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2413 {
2414 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_IOB_ACT_C1) == (DUAL_TIMER_INT_IOB_ACT_C1));
2415 }
2416
2417 /**
2418 * @brief Indicate whether action interrupt flag is set when timer value meets to COUNT_B2IO.
2419 *
2420 * Register|BitsName
2421 * --------|--------
2422 * INTSTAT | IOB_ACT_C2
2423 *
2424 * @param DUAL_TIMERx Timer instance
2425 * @retval State of bit (1 or 0).
2426 */
2427 __STATIC_INLINE uint32_t ll_dual_timer_is_iob_action_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2428 {
2429 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_IOB_ACT_C2) == (DUAL_TIMER_INT_IOB_ACT_C2));
2430 }
2431
2432 /**
2433 * @brief Indicate whether action interrupt flag is set when timer value meets to COUNT_C1IO.
2434 *
2435 * Register|BitsName
2436 * --------|--------
2437 * INTSTAT | IOC_ACT_C1
2438 *
2439 * @param DUAL_TIMERx Timer instance
2440 * @retval State of bit (1 or 0).
2441 */
2442 __STATIC_INLINE uint32_t ll_dual_timer_is_ioc_action_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2443 {
2444 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_IOC_ACT_C1) == (DUAL_TIMER_INT_IOC_ACT_C1));
2445 }
2446
2447 /**
2448 * @brief Indicate whether action interrupt flag is set when timer value meets to COUNT_C2IO.
2449 *
2450 * Register|BitsName
2451 * --------|--------
2452 * INTSTAT | IOC_ACT_C2
2453 *
2454 * @param DUAL_TIMERx Timer instance
2455 * @retval State of bit (1 or 0).
2456 */
2457 __STATIC_INLINE uint32_t ll_dual_timer_is_ioc_action_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2458 {
2459 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_IOC_ACT_C2) == (DUAL_TIMER_INT_IOC_ACT_C2));
2460 }
2461
2462 /**
2463 * @brief Indicate whether interrupt flag is set when timer value meets to BLE_COUNT1.
2464 *
2465 * Register|BitsName
2466 * --------|--------
2467 * INTSTAT | BLEPULSE1
2468 *
2469 * @param DUAL_TIMERx Timer instance
2470 * @retval State of bit (1 or 0).
2471 */
2472 __STATIC_INLINE uint32_t ll_dual_timer_is_ble_pulse1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2473 {
2474 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_BLEPULSE1) == (DUAL_TIMER_INT_BLEPULSE1));
2475 }
2476
2477 /**
2478 * @brief Indicate whether interrupt flag is set when timer value meets to BLE_COUNT2.
2479 *
2480 * Register|BitsName
2481 * --------|--------
2482 * INTSTAT | BLEPULSE2
2483 *
2484 * @param DUAL_TIMERx Timer instance
2485 * @retval State of bit (1 or 0).
2486 */
2487 __STATIC_INLINE uint32_t ll_dual_timer_is_ble_pulse2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2488 {
2489 return (READ_BITS(DUAL_TIMERx->INTSTAT, DUAL_TIMER_INT_BLEPULSE2) == (DUAL_TIMER_INT_BLEPULSE2));
2490 }
2491
2492 /**
2493 * @brief Clear the start action interrupt flag.
2494 *
2495 * Register|BitsName
2496 * --------|--------
2497 * IO_BLE_INTCLR | ACT_START_INTCLR
2498 *
2499 * @param DUAL_TIMERx Timer instance
2500 * @retval None
2501 */
2502 __STATIC_INLINE void ll_dual_timer_clear_act_start_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2503 {
2504 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_ACT_START_INTCLR);
2505 }
2506
2507 /**
2508 * @brief Clear the ioa action interrupt flag when timer value meets to COUNT_A1IO.
2509 *
2510 * Register|BitsName
2511 * --------|--------
2512 * IO_BLE_INTCLR | IOA_ACT_C1_INTCLR
2513 *
2514 * @param DUAL_TIMERx Timer instance
2515 * @retval None
2516 */
2517 __STATIC_INLINE void ll_dual_timer_clear_ioa_act_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2518 {
2519 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IOA_ACT_C1_INTCLR);
2520 }
2521
2522 /**
2523 * @brief Clear the ioa action interrupt flag when timer value meets to COUNT_A2IO.
2524 *
2525 * Register|BitsName
2526 * --------|--------
2527 * IO_BLE_INTCLR | IOA_ACT_C2_INTCLR
2528 *
2529 * @param DUAL_TIMERx Timer instance
2530 * @retval None
2531 */
2532 __STATIC_INLINE void ll_dual_timer_clear_ioa_act_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2533 {
2534 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IOA_ACT_C2_INTCLR);
2535 }
2536
2537 /**
2538 * @brief Clear the period action interrupt flag.
2539 *
2540 * Register|BitsName
2541 * --------|--------
2542 * IO_BLE_INTCLR | ACT_PERIOD_INTCLR
2543 *
2544 * @param DUAL_TIMERx Timer instance
2545 * @retval None
2546 */
2547 __STATIC_INLINE void ll_dual_timer_clear_act_period_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2548 {
2549 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_ACT_PERIOD_INTCLR);
2550 }
2551
2552 /**
2553 * @brief Clear the stop action interrupt flag.
2554 *
2555 * Register|BitsName
2556 * --------|--------
2557 * IO_BLE_INTCLR | ACT_STOP_INTCLR
2558 *
2559 * @param DUAL_TIMERx Timer instance
2560 * @retval None
2561 */
2562 __STATIC_INLINE void ll_dual_timer_clear_act_stop_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2563 {
2564 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_ACT_STOP_INTCLR);
2565 }
2566
2567 /**
2568 * @brief Clear the iob action interrupt flag when timer value meets to COUNT_B1IO.
2569 *
2570 * Register|BitsName
2571 * --------|--------
2572 * IO_BLE_INTCLR | IOB_ACT_C1_INTCLR
2573 *
2574 * @param DUAL_TIMERx Timer instance
2575 * @retval None
2576 */
2577 __STATIC_INLINE void ll_dual_timer_clear_iob_act_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2578 {
2579 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IOB_ACT_C1_INTCLR);
2580 }
2581
2582 /**
2583 * @brief Clear the iob action interrupt flag when timer value meets to COUNT_B2IO.
2584 *
2585 * Register|BitsName
2586 * --------|--------
2587 * IO_BLE_INTCLR | IOB_ACT_C2_INTCLR
2588 *
2589 * @param DUAL_TIMERx Timer instance
2590 * @retval None
2591 */
2592 __STATIC_INLINE void ll_dual_timer_clear_iob_act_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2593 {
2594 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IOB_ACT_C2_INTCLR);
2595 }
2596
2597 /**
2598 * @brief Clear the ioc action interrupt flag when timer value meets to COUNT_C1IO.
2599 *
2600 * Register|BitsName
2601 * --------|--------
2602 * IO_BLE_INTCLR | IOC_ACT_C1_INTCLR
2603 *
2604 * @param DUAL_TIMERx Timer instance
2605 * @retval None
2606 */
2607 __STATIC_INLINE void ll_dual_timer_clear_ioc_act_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2608 {
2609 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IOC_ACT_C1_INTCLR);
2610 }
2611
2612 /**
2613 * @brief Clear the ioc action interrupt flag when timer value meets to COUNT_C2IO.
2614 *
2615 * Register|BitsName
2616 * --------|--------
2617 * IO_BLE_INTCLR | IOC_ACT_C2_INTCLR
2618 *
2619 * @param DUAL_TIMERx Timer instance
2620 * @retval None
2621 */
2622 __STATIC_INLINE void ll_dual_timer_clear_ioc_act_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2623 {
2624 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IOC_ACT_C2_INTCLR);
2625 }
2626
2627 /**
2628 * @brief Clear the interrupt flag when timer value meets to BLE_COUNT1.
2629 *
2630 * Register|BitsName
2631 * --------|--------
2632 * IO_BLE_INTCLR | BLEPULSE1_INTCLR
2633 *
2634 * @param DUAL_TIMERx Timer instance
2635 * @retval None
2636 */
2637 __STATIC_INLINE void ll_dual_timer_clear_ble_pulse1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2638 {
2639 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_BLEPULSE1_INTCLR);
2640 }
2641
2642 /**
2643 * @brief Clear the interrupt flag when timer value meets to BLE_COUNT2.
2644 *
2645 * Register|BitsName
2646 * --------|--------
2647 * IO_BLE_INTCLR | BLEPULSE2_INTCLR
2648 *
2649 * @param DUAL_TIMERx Timer instance
2650 * @retval None
2651 */
2652 __STATIC_INLINE void ll_dual_timer_clear_ble_pulse2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2653 {
2654 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_BLEPULSE2_INTCLR);
2655 }
2656
2657 /**
2658 * @brief Clear all of the io action interrupt flag.
2659 *
2660 * Register|BitsName
2661 * --------|--------
2662 * IO_BLE_INTCLR | ACT_ALL_INTCLR
2663 *
2664 * @param DUAL_TIMERx Timer instance
2665 * @retval None
2666 */
2667 __STATIC_INLINE void ll_dual_timer_clear_act_all_flag_it(dual_timer_regs_t *DUAL_TIMERx)
2668 {
2669 WRITE_REG(DUAL_TIMERx->IO_BLE_INTCLR, DUAL_TIMER_IO_ACT_ALL_INTCLR);
2670 }
2671 /** @} */
2672
2673 /** @} */
2674
2675
2676 #endif /* DUAL_TIMER0 || DUAL_TIMER1 */
2677
2678 #ifdef __cplusplus
2679 }
2680 #endif
2681
2682 #endif /* LL_DUAL_TIMER_H */
2683
2684 /** @} */
2685
2686 /** @} */
2687
2688 /** @} */
ll_dual_timer_clear_act_period_flag_it
__STATIC_INLINE void ll_dual_timer_clear_act_period_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the period action interrupt flag.
Definition: ll_dual_tim.h:2547
ll_dual_timer_set_ioa_action_count1
__STATIC_INLINE void ll_dual_timer_set_ioa_action_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioa action when value meets to COUNT_A1IO.
Definition: ll_dual_tim.h:925
ll_dual_timer_enable_it
__STATIC_INLINE void ll_dual_timer_enable_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer interrupt.
Definition: ll_dual_tim.h:1731
ll_dual_timer_get_ioa_action_stop
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_stop(dual_timer_regs_t *DUAL_TIMERx)
Get ioa action when timer stop.
Definition: ll_dual_tim.h:1061
ll_dual_timer_clear_ioc_act_c1_flag_it
__STATIC_INLINE void ll_dual_timer_clear_ioc_act_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the ioc action interrupt flag when timer value meets to COUNT_C1IO.
Definition: ll_dual_tim.h:2607
ll_dual_timer_disable_act_period_it
__STATIC_INLINE void ll_dual_timer_disable_act_period_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to 0.
Definition: ll_dual_tim.h:1926
ll_dual_timer_is_ioc_action_c2_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_ioc_action_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to COUNT_C2IO.
Definition: ll_dual_tim.h:2457
ll_dual_timer_set_ioc_action_start
__STATIC_INLINE void ll_dual_timer_set_ioc_action_start(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioc action when timer start.
Definition: ll_dual_tim.h:1276
ll_dual_timer_disable_ioa_act_c2_it
__STATIC_INLINE void ll_dual_timer_disable_ioa_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to COUNT_A2IO.
Definition: ll_dual_tim.h:1881
ll_dual_timer_set_iob_action_stop
__STATIC_INLINE void ll_dual_timer_set_iob_action_stop(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set iob action when timer stop.
Definition: ll_dual_tim.h:1237
ll_dual_timer_get_raw_it_flag
__STATIC_INLINE uint32_t ll_dual_timer_get_raw_it_flag(dual_timer_regs_t *DUAL_TIMERx)
Get Dual_timer raw interrupt flags.
Definition: ll_dual_tim.h:2307
ll_dual_timer_disable_ble_ctrl
__STATIC_INLINE void ll_dual_timer_disable_ble_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer BLE ctrl.
Definition: ll_dual_tim.h:665
ll_dual_timer_is_ble_pulse1_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_ble_pulse1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether interrupt flag is set when timer value meets to BLE_COUNT1.
Definition: ll_dual_tim.h:2472
ll_dual_timer_set_ble_count2
__STATIC_INLINE void ll_dual_timer_set_ble_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the BLE count 2 value.
Definition: ll_dual_tim.h:1634
ll_dual_timer_disable_act_stop_it
__STATIC_INLINE void ll_dual_timer_disable_act_stop_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer stop.
Definition: ll_dual_tim.h:1971
ll_dual_timer_set_iob_action_init
__STATIC_INLINE void ll_dual_timer_set_iob_action_init(dual_timer_regs_t *DUAL_TIMERx, uint32_t value)
Set iob initial vaule when DUAL_TIMER_CTRL_IOB is disable.
Definition: ll_dual_tim.h:1504
ll_dual_timer_init_t::counter_size
uint32_t counter_size
Definition: ll_dual_tim.h:83
ll_dual_timer_get_iob_action_start
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_start(dual_timer_regs_t *DUAL_TIMERx)
Get iob action when timer start.
Definition: ll_dual_tim.h:1100
ll_dual_timer_get_counter_mode
__STATIC_INLINE uint32_t ll_dual_timer_get_counter_mode(dual_timer_regs_t *DUAL_TIMERx)
Get the counter mode.
Definition: ll_dual_tim.h:305
ll_dual_timer_set_iob_action_count2
__STATIC_INLINE void ll_dual_timer_set_iob_action_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set iob action when value meets to COUNT_B2IO.
Definition: ll_dual_tim.h:1159
ll_dual_timer_get_iob_action_stop
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_stop(dual_timer_regs_t *DUAL_TIMERx)
Get iob action when timer stop.
Definition: ll_dual_tim.h:1256
ll_dual_timer_is_active_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_active_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether interrupt flag (INTSTAT) is set (interrupt is pending).
Definition: ll_dual_tim.h:2292
ll_dual_timer_clear_act_start_flag_it
__STATIC_INLINE void ll_dual_timer_clear_act_start_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the start action interrupt flag.
Definition: ll_dual_tim.h:2502
ll_dual_timer_enable_iob_ctrl
__STATIC_INLINE void ll_dual_timer_enable_iob_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer IOB ctrl.
Definition: ll_dual_tim.h:560
ll_dual_timer_clear_act_all_flag_it
__STATIC_INLINE void ll_dual_timer_clear_act_all_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear all of the io action interrupt flag.
Definition: ll_dual_tim.h:2667
ll_dual_timer_disable_it
__STATIC_INLINE void ll_dual_timer_disable_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer interrput.
Definition: ll_dual_tim.h:1746
ll_dual_timer_disable_iob_act_c1_it
__STATIC_INLINE void ll_dual_timer_disable_iob_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to COUNT_B1IO.
Definition: ll_dual_tim.h:2016
ll_dual_timer_enable_ioa_act_c2_it
__STATIC_INLINE void ll_dual_timer_enable_ioa_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to COUNT_A2IO.
Definition: ll_dual_tim.h:1866
ll_dual_timer_set_prescaler
__STATIC_INLINE void ll_dual_timer_set_prescaler(dual_timer_regs_t *DUAL_TIMERx, uint32_t prescaler)
Set the prescaler.
Definition: ll_dual_tim.h:324
ll_dual_timer_is_enabled_iob_act_c2_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_iob_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to COUNT_B2IO is enabled.
Definition: ll_dual_tim.h:2076
ll_dual_timer_clear_iob_act_c2_flag_it
__STATIC_INLINE void ll_dual_timer_clear_iob_act_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the iob action interrupt flag when timer value meets to COUNT_B2IO.
Definition: ll_dual_tim.h:2592
ll_dual_timer_clear_ioa_act_c1_flag_it
__STATIC_INLINE void ll_dual_timer_clear_ioa_act_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the ioa action interrupt flag when timer value meets to COUNT_A1IO.
Definition: ll_dual_tim.h:2517
ll_dual_timer_set_auto_reload
__STATIC_INLINE void ll_dual_timer_set_auto_reload(dual_timer_regs_t *DUAL_TIMERx, uint32_t auto_reload)
Set the auto-reload value.
Definition: ll_dual_tim.h:454
ll_dual_timer_is_enabled_ioc_ctrl
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioc_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer IOC ctrl is enabled.
Definition: ll_dual_tim.h:635
ll_dual_timer_set_ioa_action_start
__STATIC_INLINE void ll_dual_timer_set_ioa_action_start(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioa action when timer start.
Definition: ll_dual_tim.h:886
ll_dual_timer_is_enabled_ioc_act_c2_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioc_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to COUNT_C2IO is enabled.
Definition: ll_dual_tim.h:2166
ll_dual_timer_disable_ioc_act_c2_it
__STATIC_INLINE void ll_dual_timer_disable_ioc_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to COUNT_C2IO.
Definition: ll_dual_tim.h:2151
ll_dual_timer_set_iob_count1
__STATIC_INLINE void ll_dual_timer_set_iob_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the iob count 1 value.
Definition: ll_dual_tim.h:758
ll_dual_timer_enable_counter
__STATIC_INLINE void ll_dual_timer_enable_counter(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer counter.
Definition: ll_dual_tim.h:240
ll_dual_timer_enable_ble_ctrl
__STATIC_INLINE void ll_dual_timer_enable_ble_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer BLE ctrl.
Definition: ll_dual_tim.h:650
ll_dual_timer_disable_ioa_ctrl
__STATIC_INLINE void ll_dual_timer_disable_ioa_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer IOA ctrl.
Definition: ll_dual_tim.h:530
ll_dual_timer_set_ioc_action_stop
__STATIC_INLINE void ll_dual_timer_set_ioc_action_stop(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioc action when timer stop.
Definition: ll_dual_tim.h:1432
ll_dual_timer_get_prescaler
__STATIC_INLINE uint32_t ll_dual_timer_get_prescaler(dual_timer_regs_t *DUAL_TIMERx)
Get the prescaler.
Definition: ll_dual_tim.h:342
ll_dual_timer_get_ble_pulse_width
__STATIC_INLINE uint32_t ll_dual_timer_get_ble_pulse_width(dual_timer_regs_t *DUAL_TIMERx)
Get the BLE pulse width.
Definition: ll_dual_tim.h:1680
ll_dual_timer_is_enabled_act_start_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_act_start_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer start is enabled.
Definition: ll_dual_tim.h:1806
ll_dual_timer_get_onetime_reload
__STATIC_INLINE uint32_t ll_dual_timer_get_onetime_reload(dual_timer_regs_t *DUAL_TIMERx)
Get the one-time reload value.
Definition: ll_dual_tim.h:1587
ll_dual_timer_set_ioc_action_count1
__STATIC_INLINE void ll_dual_timer_set_ioc_action_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioc action when value meets to COUNT_C1IO.
Definition: ll_dual_tim.h:1315
ll_dual_timer_clear_act_stop_flag_it
__STATIC_INLINE void ll_dual_timer_clear_act_stop_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the stop action interrupt flag.
Definition: ll_dual_tim.h:2562
ll_dual_timer_clear_flag_it
__STATIC_INLINE void ll_dual_timer_clear_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the interrupt flag (INTSTAT).
Definition: ll_dual_tim.h:2277
ll_dual_timer_get_ioa_action_start
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_start(dual_timer_regs_t *DUAL_TIMERx)
Get ioa action when timer start.
Definition: ll_dual_tim.h:905
ll_dual_timer_enable_ioc_act_c2_it
__STATIC_INLINE void ll_dual_timer_enable_ioc_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to COUNT_C2IO.
Definition: ll_dual_tim.h:2136
ll_dual_timer_get_iob_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_count2(dual_timer_regs_t *DUAL_TIMERx)
Get the iob count 2 value.
Definition: ll_dual_tim.h:804
ll_dual_timer_disable_oneshot
__STATIC_INLINE void ll_dual_timer_disable_oneshot(dual_timer_regs_t *DUAL_TIMERx)
Disable one-shot mode.
Definition: ll_dual_tim.h:407
ll_dual_timer_get_it_flag
__STATIC_INLINE uint32_t ll_dual_timer_get_it_flag(dual_timer_regs_t *DUAL_TIMERx)
Get dual timer interrupt flag.
Definition: ll_dual_tim.h:2322
ll_dual_timer_get_ioa_action_init
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_init(dual_timer_regs_t *DUAL_TIMERx)
Get ioa initial vaule.
Definition: ll_dual_tim.h:1486
ll_dual_timer_disable_ioc_act_c1_it
__STATIC_INLINE void ll_dual_timer_disable_ioc_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to COUNT_C1IO.
Definition: ll_dual_tim.h:2106
ll_dual_timer_is_enabled_ioa_ctrl
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioa_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer IOA ctrl is enabled.
Definition: ll_dual_tim.h:545
ll_dual_timer_set_counter_mode
__STATIC_INLINE void ll_dual_timer_set_counter_mode(dual_timer_regs_t *DUAL_TIMERx, uint32_t counter_mode)
Set the counter mode.
Definition: ll_dual_tim.h:288
ll_dual_timer_get_ioa_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_count2(dual_timer_regs_t *DUAL_TIMERx)
Get the ioa count 2 value.
Definition: ll_dual_tim.h:742
ll_dual_timer_set_ioc_count1
__STATIC_INLINE void ll_dual_timer_set_ioc_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the ioc count 1 value.
Definition: ll_dual_tim.h:820
ll_dual_timer_set_background_reload
__STATIC_INLINE void ll_dual_timer_set_background_reload(dual_timer_regs_t *DUAL_TIMERx, uint32_t background_reload)
Set the backgroud-reload value.
Definition: ll_dual_tim.h:485
ll_dual_timer_get_ble_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_ble_count2(dual_timer_regs_t *DUAL_TIMERx)
Get the BLE count 2 value.
Definition: ll_dual_tim.h:1649
ll_dual_timer_disable_ble_pulse1_it
__STATIC_INLINE void ll_dual_timer_disable_ble_pulse1_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer interrupt when timer value meets to BLE_COUNT1.
Definition: ll_dual_tim.h:2196
ll_dual_timer_enable_iob_act_c2_it
__STATIC_INLINE void ll_dual_timer_enable_iob_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to COUNT_B2IO.
Definition: ll_dual_tim.h:2046
ll_dual_timer_enable_act_stop_it
__STATIC_INLINE void ll_dual_timer_enable_act_stop_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer stop.
Definition: ll_dual_tim.h:1956
ll_dual_timer_is_ioc_action_c1_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_ioc_action_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to COUNT_C1IO.
Definition: ll_dual_tim.h:2442
ll_dual_timer_get_iob_action_period
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_period(dual_timer_regs_t *DUAL_TIMERx)
Get iob action when value downs to 0.
Definition: ll_dual_tim.h:1217
ll_dual_timer_is_enabled_act_stop_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_act_stop_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer stop.
Definition: ll_dual_tim.h:1986
gr5x.h
CMSIS Cortex-M# Core Peripheral Access Layer Header File for Device GR5405.
ll_dual_timer_is_ioa_action_c1_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_ioa_action_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to COUNT_A1IO.
Definition: ll_dual_tim.h:2352
ll_dual_timer_is_enabled_iob_act_c1_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_iob_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to COUNT_B1IO is enabled.
Definition: ll_dual_tim.h:2031
ll_dual_timer_enable_ble_pulse1_it
__STATIC_INLINE void ll_dual_timer_enable_ble_pulse1_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer interrupt when timer value meets to BLE_COUNT1.
Definition: ll_dual_tim.h:2181
ll_dual_timer_get_ioc_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_count2(dual_timer_regs_t *DUAL_TIMERx)
Get the ioc count 2 value.
Definition: ll_dual_tim.h:866
ll_dual_timer_enable_oneshot
__STATIC_INLINE void ll_dual_timer_enable_oneshot(dual_timer_regs_t *DUAL_TIMERx)
Enable one-shot mode.
Definition: ll_dual_tim.h:392
ll_dual_timer_set_iob_action_period
__STATIC_INLINE void ll_dual_timer_set_iob_action_period(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set iob action when value downs to 0.
Definition: ll_dual_tim.h:1198
ll_dual_timer_is_enabled_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer interrput is enabled.
Definition: ll_dual_tim.h:1761
ll_dual_timer_is_iob_action_c2_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_iob_action_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to COUNT_B2IO.
Definition: ll_dual_tim.h:2427
ll_dual_timer_set_iob_action_count1
__STATIC_INLINE void ll_dual_timer_set_iob_action_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set iob action when value meets to COUNT_B1IO.
Definition: ll_dual_tim.h:1120
ll_dual_timer_enable_ioa_ctrl
__STATIC_INLINE void ll_dual_timer_enable_ioa_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer IOA ctrl.
Definition: ll_dual_tim.h:515
ll_dual_timer_is_enabled_iob_ctrl
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_iob_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer IOB ctrl is enabled.
Definition: ll_dual_tim.h:590
ll_dual_timer_set_iob_action_start
__STATIC_INLINE void ll_dual_timer_set_iob_action_start(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set iob action when timer start.
Definition: ll_dual_tim.h:1081
ll_dual_timer_clear_ioa_act_c2_flag_it
__STATIC_INLINE void ll_dual_timer_clear_ioa_act_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the ioa action interrupt flag when timer value meets to COUNT_A2IO.
Definition: ll_dual_tim.h:2532
ll_dual_timer_set_ioa_action_init
__STATIC_INLINE void ll_dual_timer_set_ioa_action_init(dual_timer_regs_t *DUAL_TIMERx, uint32_t value)
Set ioa initial vaule when DUAL_TIMER_CTRL_IOA is disable.
Definition: ll_dual_tim.h:1469
ll_dual_timer_enable_ble_pulse2_it
__STATIC_INLINE void ll_dual_timer_enable_ble_pulse2_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer interrupt when timer value meets to BLE_COUNT2.
Definition: ll_dual_tim.h:2226
ll_dual_timer_disable_ioc_ctrl
__STATIC_INLINE void ll_dual_timer_disable_ioc_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer IOC ctrl.
Definition: ll_dual_tim.h:620
ll_dual_timer_init_t
LL DUAL TIMER init Structure definition.
Definition: ll_dual_tim.h:77
ll_dual_timer_disable_ioa_act_c1_it
__STATIC_INLINE void ll_dual_timer_disable_ioa_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to COUNT_A1IO.
Definition: ll_dual_tim.h:1836
ll_dual_timer_set_ioc_count2
__STATIC_INLINE void ll_dual_timer_set_ioc_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the ioc count 2 value.
Definition: ll_dual_tim.h:851
ll_dual_timer_is_enabled_ioc_act_c1_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioc_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to COUNT_C1IO is enabled.
Definition: ll_dual_tim.h:2121
ll_dual_timer_get_iob_action_init
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_init(dual_timer_regs_t *DUAL_TIMERx)
Get iob initial vaule.
Definition: ll_dual_tim.h:1521
ll_dual_timer_clear_iob_act_c1_flag_it
__STATIC_INLINE void ll_dual_timer_clear_iob_act_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the iob action interrupt flag when timer value meets to COUNT_B1IO.
Definition: ll_dual_tim.h:2577
ll_dual_timer_get_background_reload
__STATIC_INLINE uint32_t ll_dual_timer_get_background_reload(dual_timer_regs_t *DUAL_TIMERx)
Get the backgroud-reload value.
Definition: ll_dual_tim.h:500
ll_dual_timer_get_ioa_action_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_count1(dual_timer_regs_t *DUAL_TIMERx)
Get ioa action when value meets to COUNT_A1IO.
Definition: ll_dual_tim.h:944
ll_dual_timer_enable_ioc_act_c1_it
__STATIC_INLINE void ll_dual_timer_enable_ioc_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to COUNT_C1IO.
Definition: ll_dual_tim.h:2091
ll_dual_timer_get_counter
__STATIC_INLINE uint32_t ll_dual_timer_get_counter(dual_timer_regs_t *DUAL_TIMERx)
Get the counter value.
Definition: ll_dual_tim.h:437
ll_dual_timer_enable_ioa_act_c1_it
__STATIC_INLINE void ll_dual_timer_enable_ioa_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to COUNT_A1IO.
Definition: ll_dual_tim.h:1821
ll_dual_timer_set_onetime_reload
__STATIC_INLINE void ll_dual_timer_set_onetime_reload(dual_timer_regs_t *DUAL_TIMERx, uint32_t onetime_reload)
Set the one-time reload value.
Definition: ll_dual_tim.h:1572
ll_dual_timer_is_enabled_oneshot
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_oneshot(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the one-shot mode is enabled.
Definition: ll_dual_tim.h:422
ll_dual_timer_enable_act_period_it
__STATIC_INLINE void ll_dual_timer_enable_act_period_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to 0.
Definition: ll_dual_tim.h:1911
ll_dual_timer_set_ioc_action_count2
__STATIC_INLINE void ll_dual_timer_set_ioc_action_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioc action when value meets to COUNT_C2IO.
Definition: ll_dual_tim.h:1354
ll_dual_timer_set_ioa_count2
__STATIC_INLINE void ll_dual_timer_set_ioa_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the ioa count 2 value.
Definition: ll_dual_tim.h:727
ll_dual_timer_get_ioa_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_count1(dual_timer_regs_t *DUAL_TIMERx)
Get the ioa count 1 value.
Definition: ll_dual_tim.h:711
ll_dual_timer_clear_ioc_act_c2_flag_it
__STATIC_INLINE void ll_dual_timer_clear_ioc_act_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the ioc action interrupt flag when timer value meets to COUNT_C2IO.
Definition: ll_dual_tim.h:2622
ll_dual_timer_clear_ble_pulse2_flag_it
__STATIC_INLINE void ll_dual_timer_clear_ble_pulse2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the interrupt flag when timer value meets to BLE_COUNT2.
Definition: ll_dual_tim.h:2652
ll_dual_timer_set_ble_count1
__STATIC_INLINE void ll_dual_timer_set_ble_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the BLE count 1 value.
Definition: ll_dual_tim.h:1603
ll_dual_timer_set_period_count
__STATIC_INLINE void ll_dual_timer_set_period_count(dual_timer_regs_t *DUAL_TIMERx, uint32_t count)
Set the period count in period mode.
Definition: ll_dual_tim.h:1696
ll_dual_timer_disable_ble_pulse2_it
__STATIC_INLINE void ll_dual_timer_disable_ble_pulse2_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer interrupt when timer value meets to BLE_COUNT2.
Definition: ll_dual_tim.h:2241
ll_dual_timer_enable_ioc_ctrl
__STATIC_INLINE void ll_dual_timer_enable_ioc_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer IOC ctrl.
Definition: ll_dual_tim.h:605
ll_dual_timer_get_iob_action_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_count2(dual_timer_regs_t *DUAL_TIMERx)
Get iob action when value meets to COUNT_B2IO.
Definition: ll_dual_tim.h:1178
ll_dual_timer_get_ioc_action_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_count1(dual_timer_regs_t *DUAL_TIMERx)
Get ioc action when value meets to COUNT_C1IO.
Definition: ll_dual_tim.h:1334
ll_dual_timer_disable_iob_ctrl
__STATIC_INLINE void ll_dual_timer_disable_iob_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer IOB ctrl.
Definition: ll_dual_tim.h:575
ll_dual_timer_is_enabled_counter
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_counter(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer counter is enabled.
Definition: ll_dual_tim.h:270
ll_dual_timer_get_ioc_action_init
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_init(dual_timer_regs_t *DUAL_TIMERx)
Get ioc initial vaule.
Definition: ll_dual_tim.h:1556
ll_dual_timer_disable_act_start_it
__STATIC_INLINE void ll_dual_timer_disable_act_start_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer start.
Definition: ll_dual_tim.h:1791
ll_dual_timer_is_enabled_ioa_act_c1_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioa_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to COUNT_A1IO is enabled.
Definition: ll_dual_tim.h:1851
ll_dual_timer_is_enabled_ble_pulse1_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ble_pulse1_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer interrupt when timer value meets to BLE_COUNT1 is enabled.
Definition: ll_dual_tim.h:2211
ll_dual_timer_is_ble_pulse2_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_ble_pulse2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether interrupt flag is set when timer value meets to BLE_COUNT2.
Definition: ll_dual_tim.h:2487
ll_dual_timer_get_ioc_action_start
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_start(dual_timer_regs_t *DUAL_TIMERx)
Get ioc action when timer start.
Definition: ll_dual_tim.h:1295
ll_dual_timer_set_ioc_action_init
__STATIC_INLINE void ll_dual_timer_set_ioc_action_init(dual_timer_regs_t *DUAL_TIMERx, uint32_t value)
Set ioc initial vaule when DUAL_TIMER_CTRL_IOC is disable.
Definition: ll_dual_tim.h:1539
ll_dual_timer_init_t::auto_reload
uint32_t auto_reload
Definition: ll_dual_tim.h:93
ll_dual_timer_clear_ble_pulse1_flag_it
__STATIC_INLINE void ll_dual_timer_clear_ble_pulse1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Clear the interrupt flag when timer value meets to BLE_COUNT1.
Definition: ll_dual_tim.h:2637
ll_dual_timer_is_action_start_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_action_start_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer start.
Definition: ll_dual_tim.h:2337
ll_dual_timer_is_enabled_act_period_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_act_period_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to 0 is enabled.
Definition: ll_dual_tim.h:1941
ll_dual_timer_enable_iob_act_c1_it
__STATIC_INLINE void ll_dual_timer_enable_iob_act_c1_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer value meets to COUNT_B1IO.
Definition: ll_dual_tim.h:2001
ll_dual_timer_get_ioc_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_count1(dual_timer_regs_t *DUAL_TIMERx)
Get the ioc count 1 value.
Definition: ll_dual_tim.h:835
ll_dual_timer_get_ioc_action_stop
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_stop(dual_timer_regs_t *DUAL_TIMERx)
Get ioc action when timer stop.
Definition: ll_dual_tim.h:1451
ll_dual_timer_get_iob_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_count1(dual_timer_regs_t *DUAL_TIMERx)
Get the iob count 1 value.
Definition: ll_dual_tim.h:773
ll_dual_timer_disable_iob_act_c2_it
__STATIC_INLINE void ll_dual_timer_disable_iob_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer action interrupt when timer value meets to COUNT_B2IO.
Definition: ll_dual_tim.h:2061
ll_dual_timer_disable_counter
__STATIC_INLINE void ll_dual_timer_disable_counter(dual_timer_regs_t *DUAL_TIMERx)
Disable dual_timer counter.
Definition: ll_dual_tim.h:255
ll_dual_timer_get_ioc_action_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_count2(dual_timer_regs_t *DUAL_TIMERx)
Get ioc action when value meets to COUNT_C2IO.
Definition: ll_dual_tim.h:1373
ll_dual_timer_get_period_count
__STATIC_INLINE uint32_t ll_dual_timer_get_period_count(dual_timer_regs_t *DUAL_TIMERx)
Get the period count in period mode.
Definition: ll_dual_tim.h:1711
ll_dual_timer_set_ioa_action_stop
__STATIC_INLINE void ll_dual_timer_set_ioa_action_stop(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioa action when timer stop.
Definition: ll_dual_tim.h:1042
ll_dual_timer_is_ioa_action_c2_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_ioa_action_c2_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to COUNT_A2IO.
Definition: ll_dual_tim.h:2367
ll_dual_timer_get_auto_reload
__STATIC_INLINE uint32_t ll_dual_timer_get_auto_reload(dual_timer_regs_t *DUAL_TIMERx)
Get the auto-reload value.
Definition: ll_dual_tim.h:469
ll_dual_timer_get_ble_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_ble_count1(dual_timer_regs_t *DUAL_TIMERx)
Get the BLE count 1 value.
Definition: ll_dual_tim.h:1618
ll_dual_timer_set_ioa_action_period
__STATIC_INLINE void ll_dual_timer_set_ioa_action_period(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioa action when value downs to 0.
Definition: ll_dual_tim.h:1003
ll_dual_timer_init_t::prescaler
uint32_t prescaler
Definition: ll_dual_tim.h:78
ll_dual_timer_is_enabled_ble_pulse2_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ble_pulse2_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer interrupt when timer value meets to BLE_COUNT2 is enabled.
Definition: ll_dual_tim.h:2256
ll_dual_timer_is_action_stop_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_action_stop_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer stop.
Definition: ll_dual_tim.h:2397
ll_dual_timer_is_action_period_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_action_period_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to 0.
Definition: ll_dual_tim.h:2382
ll_dual_timer_get_ioc_action_period
__STATIC_INLINE uint32_t ll_dual_timer_get_ioc_action_period(dual_timer_regs_t *DUAL_TIMERx)
Get ioc action when value downs to 0.
Definition: ll_dual_tim.h:1412
ll_dual_timer_is_iob_action_c1_flag_it
__STATIC_INLINE uint32_t ll_dual_timer_is_iob_action_c1_flag_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether action interrupt flag is set when timer value meets to COUNT_B1IO.
Definition: ll_dual_tim.h:2412
ll_dual_timer_get_ioa_action_count2
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_count2(dual_timer_regs_t *DUAL_TIMERx)
Get ioa action when value meets to COUNT_A2IO.
Definition: ll_dual_tim.h:983
ll_dual_timer_set_ioc_action_period
__STATIC_INLINE void ll_dual_timer_set_ioc_action_period(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioc action when value downs to 0.
Definition: ll_dual_tim.h:1393
ll_dual_timer_set_counter_size
__STATIC_INLINE void ll_dual_timer_set_counter_size(dual_timer_regs_t *DUAL_TIMERx, uint32_t counter_size)
Set the counter size.
Definition: ll_dual_tim.h:360
ll_dual_timer_is_enabled_ioa_act_c2_it
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ioa_act_c2_it(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer action interrupt when timer value meets to COUNT_A2IO is enabled.
Definition: ll_dual_tim.h:1896
ll_dual_timer_set_ioa_count1
__STATIC_INLINE void ll_dual_timer_set_ioa_count1(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the ioa count 1 value.
Definition: ll_dual_tim.h:696
ll_dual_timer_get_counter_size
__STATIC_INLINE uint32_t ll_dual_timer_get_counter_size(dual_timer_regs_t *DUAL_TIMERx)
Get the counter size.
Definition: ll_dual_tim.h:377
ll_dual_timer_is_enabled_ble_ctrl
__STATIC_INLINE uint32_t ll_dual_timer_is_enabled_ble_ctrl(dual_timer_regs_t *DUAL_TIMERx)
Indicate whether the dual_timer BLE ctrl is enabled.
Definition: ll_dual_tim.h:680
ll_dual_timer_set_ble_pulse_width
__STATIC_INLINE void ll_dual_timer_set_ble_pulse_width(dual_timer_regs_t *DUAL_TIMERx, uint32_t width)
Set the BLE pulse width.
Definition: ll_dual_tim.h:1665
ll_dual_timer_init_t::counter_mode
uint32_t counter_mode
Definition: ll_dual_tim.h:88
ll_dual_timer_set_iob_count2
__STATIC_INLINE void ll_dual_timer_set_iob_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t count_value)
Set the iob count 2 value.
Definition: ll_dual_tim.h:789
ll_dual_timer_get_ioa_action_period
__STATIC_INLINE uint32_t ll_dual_timer_get_ioa_action_period(dual_timer_regs_t *DUAL_TIMERx)
Get ioa action when value downs to 0.
Definition: ll_dual_tim.h:1022
ll_dual_timer_get_iob_action_count1
__STATIC_INLINE uint32_t ll_dual_timer_get_iob_action_count1(dual_timer_regs_t *DUAL_TIMERx)
Get iob action when value meets to COUNT_B1IO.
Definition: ll_dual_tim.h:1139
ll_dual_timer_enable_act_start_it
__STATIC_INLINE void ll_dual_timer_enable_act_start_it(dual_timer_regs_t *DUAL_TIMERx)
Enable dual_timer action interrupt when timer start.
Definition: ll_dual_tim.h:1776
ll_dual_timer_set_ioa_action_count2
__STATIC_INLINE void ll_dual_timer_set_ioa_action_count2(dual_timer_regs_t *DUAL_TIMERx, uint32_t action)
Set ioa action when value meets to COUNT_A2IO.
Definition: ll_dual_tim.h:964