1#[doc = "Register `INS` reader"]
2pub type R = crate::R<INS_SPEC>;
3#[doc = "Register `INS` writer"]
4pub type W = crate::W<INS_SPEC>;
5#[doc = "Event 0 signal selection\n\nValue on reset: 0"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u8)]
8pub enum EV0IS_A {
9 #[doc = "0: CCU8x.INyA"]
10 VALUE1 = 0,
11 #[doc = "1: CCU8x.INyB"]
12 VALUE2 = 1,
13 #[doc = "2: CCU8x.INyC"]
14 VALUE3 = 2,
15 #[doc = "3: CCU8x.INyD"]
16 VALUE4 = 3,
17 #[doc = "4: CCU8x.INyE"]
18 VALUE5 = 4,
19 #[doc = "5: CCU8x.INyF"]
20 VALUE6 = 5,
21 #[doc = "6: CCU8x.INyG"]
22 VALUE7 = 6,
23 #[doc = "7: CCU8x.INyH"]
24 VALUE8 = 7,
25 #[doc = "8: CCU8x.INyI"]
26 VALUE9 = 8,
27 #[doc = "9: CCU8x.INyJ"]
28 VALUE10 = 9,
29 #[doc = "10: CCU8x.INyK"]
30 VALUE11 = 10,
31 #[doc = "11: CCU8x.INyL"]
32 VALUE12 = 11,
33 #[doc = "12: CCU8x.INyM"]
34 VALUE13 = 12,
35 #[doc = "13: CCU8x.INyN"]
36 VALUE14 = 13,
37 #[doc = "14: CCU8x.INyO"]
38 VALUE15 = 14,
39 #[doc = "15: CCU8x.INyP"]
40 VALUE16 = 15,
41}
42impl From<EV0IS_A> for u8 {
43 #[inline(always)]
44 fn from(variant: EV0IS_A) -> Self {
45 variant as _
46 }
47}
48impl crate::FieldSpec for EV0IS_A {
49 type Ux = u8;
50}
51impl crate::IsEnum for EV0IS_A {}
52#[doc = "Field `EV0IS` reader - Event 0 signal selection"]
53pub type EV0IS_R = crate::FieldReader<EV0IS_A>;
54impl EV0IS_R {
55 #[doc = "Get enumerated values variant"]
56 #[inline(always)]
57 pub const fn variant(&self) -> EV0IS_A {
58 match self.bits {
59 0 => EV0IS_A::VALUE1,
60 1 => EV0IS_A::VALUE2,
61 2 => EV0IS_A::VALUE3,
62 3 => EV0IS_A::VALUE4,
63 4 => EV0IS_A::VALUE5,
64 5 => EV0IS_A::VALUE6,
65 6 => EV0IS_A::VALUE7,
66 7 => EV0IS_A::VALUE8,
67 8 => EV0IS_A::VALUE9,
68 9 => EV0IS_A::VALUE10,
69 10 => EV0IS_A::VALUE11,
70 11 => EV0IS_A::VALUE12,
71 12 => EV0IS_A::VALUE13,
72 13 => EV0IS_A::VALUE14,
73 14 => EV0IS_A::VALUE15,
74 15 => EV0IS_A::VALUE16,
75 _ => unreachable!(),
76 }
77 }
78 #[doc = "CCU8x.INyA"]
79 #[inline(always)]
80 pub fn is_value1(&self) -> bool {
81 *self == EV0IS_A::VALUE1
82 }
83 #[doc = "CCU8x.INyB"]
84 #[inline(always)]
85 pub fn is_value2(&self) -> bool {
86 *self == EV0IS_A::VALUE2
87 }
88 #[doc = "CCU8x.INyC"]
89 #[inline(always)]
90 pub fn is_value3(&self) -> bool {
91 *self == EV0IS_A::VALUE3
92 }
93 #[doc = "CCU8x.INyD"]
94 #[inline(always)]
95 pub fn is_value4(&self) -> bool {
96 *self == EV0IS_A::VALUE4
97 }
98 #[doc = "CCU8x.INyE"]
99 #[inline(always)]
100 pub fn is_value5(&self) -> bool {
101 *self == EV0IS_A::VALUE5
102 }
103 #[doc = "CCU8x.INyF"]
104 #[inline(always)]
105 pub fn is_value6(&self) -> bool {
106 *self == EV0IS_A::VALUE6
107 }
108 #[doc = "CCU8x.INyG"]
109 #[inline(always)]
110 pub fn is_value7(&self) -> bool {
111 *self == EV0IS_A::VALUE7
112 }
113 #[doc = "CCU8x.INyH"]
114 #[inline(always)]
115 pub fn is_value8(&self) -> bool {
116 *self == EV0IS_A::VALUE8
117 }
118 #[doc = "CCU8x.INyI"]
119 #[inline(always)]
120 pub fn is_value9(&self) -> bool {
121 *self == EV0IS_A::VALUE9
122 }
123 #[doc = "CCU8x.INyJ"]
124 #[inline(always)]
125 pub fn is_value10(&self) -> bool {
126 *self == EV0IS_A::VALUE10
127 }
128 #[doc = "CCU8x.INyK"]
129 #[inline(always)]
130 pub fn is_value11(&self) -> bool {
131 *self == EV0IS_A::VALUE11
132 }
133 #[doc = "CCU8x.INyL"]
134 #[inline(always)]
135 pub fn is_value12(&self) -> bool {
136 *self == EV0IS_A::VALUE12
137 }
138 #[doc = "CCU8x.INyM"]
139 #[inline(always)]
140 pub fn is_value13(&self) -> bool {
141 *self == EV0IS_A::VALUE13
142 }
143 #[doc = "CCU8x.INyN"]
144 #[inline(always)]
145 pub fn is_value14(&self) -> bool {
146 *self == EV0IS_A::VALUE14
147 }
148 #[doc = "CCU8x.INyO"]
149 #[inline(always)]
150 pub fn is_value15(&self) -> bool {
151 *self == EV0IS_A::VALUE15
152 }
153 #[doc = "CCU8x.INyP"]
154 #[inline(always)]
155 pub fn is_value16(&self) -> bool {
156 *self == EV0IS_A::VALUE16
157 }
158}
159#[doc = "Field `EV0IS` writer - Event 0 signal selection"]
160pub type EV0IS_W<'a, REG> = crate::FieldWriter<'a, REG, 4, EV0IS_A, crate::Safe>;
161impl<'a, REG> EV0IS_W<'a, REG>
162where
163 REG: crate::Writable + crate::RegisterSpec,
164 REG::Ux: From<u8>,
165{
166 #[doc = "CCU8x.INyA"]
167 #[inline(always)]
168 pub fn value1(self) -> &'a mut crate::W<REG> {
169 self.variant(EV0IS_A::VALUE1)
170 }
171 #[doc = "CCU8x.INyB"]
172 #[inline(always)]
173 pub fn value2(self) -> &'a mut crate::W<REG> {
174 self.variant(EV0IS_A::VALUE2)
175 }
176 #[doc = "CCU8x.INyC"]
177 #[inline(always)]
178 pub fn value3(self) -> &'a mut crate::W<REG> {
179 self.variant(EV0IS_A::VALUE3)
180 }
181 #[doc = "CCU8x.INyD"]
182 #[inline(always)]
183 pub fn value4(self) -> &'a mut crate::W<REG> {
184 self.variant(EV0IS_A::VALUE4)
185 }
186 #[doc = "CCU8x.INyE"]
187 #[inline(always)]
188 pub fn value5(self) -> &'a mut crate::W<REG> {
189 self.variant(EV0IS_A::VALUE5)
190 }
191 #[doc = "CCU8x.INyF"]
192 #[inline(always)]
193 pub fn value6(self) -> &'a mut crate::W<REG> {
194 self.variant(EV0IS_A::VALUE6)
195 }
196 #[doc = "CCU8x.INyG"]
197 #[inline(always)]
198 pub fn value7(self) -> &'a mut crate::W<REG> {
199 self.variant(EV0IS_A::VALUE7)
200 }
201 #[doc = "CCU8x.INyH"]
202 #[inline(always)]
203 pub fn value8(self) -> &'a mut crate::W<REG> {
204 self.variant(EV0IS_A::VALUE8)
205 }
206 #[doc = "CCU8x.INyI"]
207 #[inline(always)]
208 pub fn value9(self) -> &'a mut crate::W<REG> {
209 self.variant(EV0IS_A::VALUE9)
210 }
211 #[doc = "CCU8x.INyJ"]
212 #[inline(always)]
213 pub fn value10(self) -> &'a mut crate::W<REG> {
214 self.variant(EV0IS_A::VALUE10)
215 }
216 #[doc = "CCU8x.INyK"]
217 #[inline(always)]
218 pub fn value11(self) -> &'a mut crate::W<REG> {
219 self.variant(EV0IS_A::VALUE11)
220 }
221 #[doc = "CCU8x.INyL"]
222 #[inline(always)]
223 pub fn value12(self) -> &'a mut crate::W<REG> {
224 self.variant(EV0IS_A::VALUE12)
225 }
226 #[doc = "CCU8x.INyM"]
227 #[inline(always)]
228 pub fn value13(self) -> &'a mut crate::W<REG> {
229 self.variant(EV0IS_A::VALUE13)
230 }
231 #[doc = "CCU8x.INyN"]
232 #[inline(always)]
233 pub fn value14(self) -> &'a mut crate::W<REG> {
234 self.variant(EV0IS_A::VALUE14)
235 }
236 #[doc = "CCU8x.INyO"]
237 #[inline(always)]
238 pub fn value15(self) -> &'a mut crate::W<REG> {
239 self.variant(EV0IS_A::VALUE15)
240 }
241 #[doc = "CCU8x.INyP"]
242 #[inline(always)]
243 pub fn value16(self) -> &'a mut crate::W<REG> {
244 self.variant(EV0IS_A::VALUE16)
245 }
246}
247#[doc = "Event 1 signal selection\n\nValue on reset: 0"]
248#[derive(Clone, Copy, Debug, PartialEq, Eq)]
249#[repr(u8)]
250pub enum EV1IS_A {
251 #[doc = "0: CCU8x.INyA"]
252 VALUE1 = 0,
253 #[doc = "1: CCU8x.INyB"]
254 VALUE2 = 1,
255 #[doc = "2: CCU8x.INyC"]
256 VALUE3 = 2,
257 #[doc = "3: CCU8x.INyD"]
258 VALUE4 = 3,
259 #[doc = "4: CCU8x.INyE"]
260 VALUE5 = 4,
261 #[doc = "5: CCU8x.INyF"]
262 VALUE6 = 5,
263 #[doc = "6: CCU8x.INyG"]
264 VALUE7 = 6,
265 #[doc = "7: CCU8x.INyH"]
266 VALUE8 = 7,
267 #[doc = "8: CCU8x.INyI"]
268 VALUE9 = 8,
269 #[doc = "9: CCU8x.INyJ"]
270 VALUE10 = 9,
271 #[doc = "10: CCU8x.INyK"]
272 VALUE11 = 10,
273 #[doc = "11: CCU8x.INyL"]
274 VALUE12 = 11,
275 #[doc = "12: CCU8x.INyM"]
276 VALUE13 = 12,
277 #[doc = "13: CCU8x.INyN"]
278 VALUE14 = 13,
279 #[doc = "14: CCU8x.INyO"]
280 VALUE15 = 14,
281 #[doc = "15: CCU8x.INyP"]
282 VALUE16 = 15,
283}
284impl From<EV1IS_A> for u8 {
285 #[inline(always)]
286 fn from(variant: EV1IS_A) -> Self {
287 variant as _
288 }
289}
290impl crate::FieldSpec for EV1IS_A {
291 type Ux = u8;
292}
293impl crate::IsEnum for EV1IS_A {}
294#[doc = "Field `EV1IS` reader - Event 1 signal selection"]
295pub type EV1IS_R = crate::FieldReader<EV1IS_A>;
296impl EV1IS_R {
297 #[doc = "Get enumerated values variant"]
298 #[inline(always)]
299 pub const fn variant(&self) -> EV1IS_A {
300 match self.bits {
301 0 => EV1IS_A::VALUE1,
302 1 => EV1IS_A::VALUE2,
303 2 => EV1IS_A::VALUE3,
304 3 => EV1IS_A::VALUE4,
305 4 => EV1IS_A::VALUE5,
306 5 => EV1IS_A::VALUE6,
307 6 => EV1IS_A::VALUE7,
308 7 => EV1IS_A::VALUE8,
309 8 => EV1IS_A::VALUE9,
310 9 => EV1IS_A::VALUE10,
311 10 => EV1IS_A::VALUE11,
312 11 => EV1IS_A::VALUE12,
313 12 => EV1IS_A::VALUE13,
314 13 => EV1IS_A::VALUE14,
315 14 => EV1IS_A::VALUE15,
316 15 => EV1IS_A::VALUE16,
317 _ => unreachable!(),
318 }
319 }
320 #[doc = "CCU8x.INyA"]
321 #[inline(always)]
322 pub fn is_value1(&self) -> bool {
323 *self == EV1IS_A::VALUE1
324 }
325 #[doc = "CCU8x.INyB"]
326 #[inline(always)]
327 pub fn is_value2(&self) -> bool {
328 *self == EV1IS_A::VALUE2
329 }
330 #[doc = "CCU8x.INyC"]
331 #[inline(always)]
332 pub fn is_value3(&self) -> bool {
333 *self == EV1IS_A::VALUE3
334 }
335 #[doc = "CCU8x.INyD"]
336 #[inline(always)]
337 pub fn is_value4(&self) -> bool {
338 *self == EV1IS_A::VALUE4
339 }
340 #[doc = "CCU8x.INyE"]
341 #[inline(always)]
342 pub fn is_value5(&self) -> bool {
343 *self == EV1IS_A::VALUE5
344 }
345 #[doc = "CCU8x.INyF"]
346 #[inline(always)]
347 pub fn is_value6(&self) -> bool {
348 *self == EV1IS_A::VALUE6
349 }
350 #[doc = "CCU8x.INyG"]
351 #[inline(always)]
352 pub fn is_value7(&self) -> bool {
353 *self == EV1IS_A::VALUE7
354 }
355 #[doc = "CCU8x.INyH"]
356 #[inline(always)]
357 pub fn is_value8(&self) -> bool {
358 *self == EV1IS_A::VALUE8
359 }
360 #[doc = "CCU8x.INyI"]
361 #[inline(always)]
362 pub fn is_value9(&self) -> bool {
363 *self == EV1IS_A::VALUE9
364 }
365 #[doc = "CCU8x.INyJ"]
366 #[inline(always)]
367 pub fn is_value10(&self) -> bool {
368 *self == EV1IS_A::VALUE10
369 }
370 #[doc = "CCU8x.INyK"]
371 #[inline(always)]
372 pub fn is_value11(&self) -> bool {
373 *self == EV1IS_A::VALUE11
374 }
375 #[doc = "CCU8x.INyL"]
376 #[inline(always)]
377 pub fn is_value12(&self) -> bool {
378 *self == EV1IS_A::VALUE12
379 }
380 #[doc = "CCU8x.INyM"]
381 #[inline(always)]
382 pub fn is_value13(&self) -> bool {
383 *self == EV1IS_A::VALUE13
384 }
385 #[doc = "CCU8x.INyN"]
386 #[inline(always)]
387 pub fn is_value14(&self) -> bool {
388 *self == EV1IS_A::VALUE14
389 }
390 #[doc = "CCU8x.INyO"]
391 #[inline(always)]
392 pub fn is_value15(&self) -> bool {
393 *self == EV1IS_A::VALUE15
394 }
395 #[doc = "CCU8x.INyP"]
396 #[inline(always)]
397 pub fn is_value16(&self) -> bool {
398 *self == EV1IS_A::VALUE16
399 }
400}
401#[doc = "Field `EV1IS` writer - Event 1 signal selection"]
402pub type EV1IS_W<'a, REG> = crate::FieldWriter<'a, REG, 4, EV1IS_A, crate::Safe>;
403impl<'a, REG> EV1IS_W<'a, REG>
404where
405 REG: crate::Writable + crate::RegisterSpec,
406 REG::Ux: From<u8>,
407{
408 #[doc = "CCU8x.INyA"]
409 #[inline(always)]
410 pub fn value1(self) -> &'a mut crate::W<REG> {
411 self.variant(EV1IS_A::VALUE1)
412 }
413 #[doc = "CCU8x.INyB"]
414 #[inline(always)]
415 pub fn value2(self) -> &'a mut crate::W<REG> {
416 self.variant(EV1IS_A::VALUE2)
417 }
418 #[doc = "CCU8x.INyC"]
419 #[inline(always)]
420 pub fn value3(self) -> &'a mut crate::W<REG> {
421 self.variant(EV1IS_A::VALUE3)
422 }
423 #[doc = "CCU8x.INyD"]
424 #[inline(always)]
425 pub fn value4(self) -> &'a mut crate::W<REG> {
426 self.variant(EV1IS_A::VALUE4)
427 }
428 #[doc = "CCU8x.INyE"]
429 #[inline(always)]
430 pub fn value5(self) -> &'a mut crate::W<REG> {
431 self.variant(EV1IS_A::VALUE5)
432 }
433 #[doc = "CCU8x.INyF"]
434 #[inline(always)]
435 pub fn value6(self) -> &'a mut crate::W<REG> {
436 self.variant(EV1IS_A::VALUE6)
437 }
438 #[doc = "CCU8x.INyG"]
439 #[inline(always)]
440 pub fn value7(self) -> &'a mut crate::W<REG> {
441 self.variant(EV1IS_A::VALUE7)
442 }
443 #[doc = "CCU8x.INyH"]
444 #[inline(always)]
445 pub fn value8(self) -> &'a mut crate::W<REG> {
446 self.variant(EV1IS_A::VALUE8)
447 }
448 #[doc = "CCU8x.INyI"]
449 #[inline(always)]
450 pub fn value9(self) -> &'a mut crate::W<REG> {
451 self.variant(EV1IS_A::VALUE9)
452 }
453 #[doc = "CCU8x.INyJ"]
454 #[inline(always)]
455 pub fn value10(self) -> &'a mut crate::W<REG> {
456 self.variant(EV1IS_A::VALUE10)
457 }
458 #[doc = "CCU8x.INyK"]
459 #[inline(always)]
460 pub fn value11(self) -> &'a mut crate::W<REG> {
461 self.variant(EV1IS_A::VALUE11)
462 }
463 #[doc = "CCU8x.INyL"]
464 #[inline(always)]
465 pub fn value12(self) -> &'a mut crate::W<REG> {
466 self.variant(EV1IS_A::VALUE12)
467 }
468 #[doc = "CCU8x.INyM"]
469 #[inline(always)]
470 pub fn value13(self) -> &'a mut crate::W<REG> {
471 self.variant(EV1IS_A::VALUE13)
472 }
473 #[doc = "CCU8x.INyN"]
474 #[inline(always)]
475 pub fn value14(self) -> &'a mut crate::W<REG> {
476 self.variant(EV1IS_A::VALUE14)
477 }
478 #[doc = "CCU8x.INyO"]
479 #[inline(always)]
480 pub fn value15(self) -> &'a mut crate::W<REG> {
481 self.variant(EV1IS_A::VALUE15)
482 }
483 #[doc = "CCU8x.INyP"]
484 #[inline(always)]
485 pub fn value16(self) -> &'a mut crate::W<REG> {
486 self.variant(EV1IS_A::VALUE16)
487 }
488}
489#[doc = "Event 2 signal selection\n\nValue on reset: 0"]
490#[derive(Clone, Copy, Debug, PartialEq, Eq)]
491#[repr(u8)]
492pub enum EV2IS_A {
493 #[doc = "0: CCU8x.INyA"]
494 VALUE1 = 0,
495 #[doc = "1: CCU8x.INyB"]
496 VALUE2 = 1,
497 #[doc = "2: CCU8x.INyC"]
498 VALUE3 = 2,
499 #[doc = "3: CCU8x.INyD"]
500 VALUE4 = 3,
501 #[doc = "4: CCU8x.INyE"]
502 VALUE5 = 4,
503 #[doc = "5: CCU8x.INyF"]
504 VALUE6 = 5,
505 #[doc = "6: CCU8x.INyG"]
506 VALUE7 = 6,
507 #[doc = "7: CCU8x.INyH"]
508 VALUE8 = 7,
509 #[doc = "8: CCU8x.INyI"]
510 VALUE9 = 8,
511 #[doc = "9: CCU8x.INyJ"]
512 VALUE10 = 9,
513 #[doc = "10: CCU8x.INyK"]
514 VALUE11 = 10,
515 #[doc = "11: CCU8x.INyL"]
516 VALUE12 = 11,
517 #[doc = "12: CCU8x.INyM"]
518 VALUE13 = 12,
519 #[doc = "13: CCU8x.INyN"]
520 VALUE14 = 13,
521 #[doc = "14: CCU8x.INyO"]
522 VALUE15 = 14,
523 #[doc = "15: CCU8x.INyP"]
524 VALUE16 = 15,
525}
526impl From<EV2IS_A> for u8 {
527 #[inline(always)]
528 fn from(variant: EV2IS_A) -> Self {
529 variant as _
530 }
531}
532impl crate::FieldSpec for EV2IS_A {
533 type Ux = u8;
534}
535impl crate::IsEnum for EV2IS_A {}
536#[doc = "Field `EV2IS` reader - Event 2 signal selection"]
537pub type EV2IS_R = crate::FieldReader<EV2IS_A>;
538impl EV2IS_R {
539 #[doc = "Get enumerated values variant"]
540 #[inline(always)]
541 pub const fn variant(&self) -> EV2IS_A {
542 match self.bits {
543 0 => EV2IS_A::VALUE1,
544 1 => EV2IS_A::VALUE2,
545 2 => EV2IS_A::VALUE3,
546 3 => EV2IS_A::VALUE4,
547 4 => EV2IS_A::VALUE5,
548 5 => EV2IS_A::VALUE6,
549 6 => EV2IS_A::VALUE7,
550 7 => EV2IS_A::VALUE8,
551 8 => EV2IS_A::VALUE9,
552 9 => EV2IS_A::VALUE10,
553 10 => EV2IS_A::VALUE11,
554 11 => EV2IS_A::VALUE12,
555 12 => EV2IS_A::VALUE13,
556 13 => EV2IS_A::VALUE14,
557 14 => EV2IS_A::VALUE15,
558 15 => EV2IS_A::VALUE16,
559 _ => unreachable!(),
560 }
561 }
562 #[doc = "CCU8x.INyA"]
563 #[inline(always)]
564 pub fn is_value1(&self) -> bool {
565 *self == EV2IS_A::VALUE1
566 }
567 #[doc = "CCU8x.INyB"]
568 #[inline(always)]
569 pub fn is_value2(&self) -> bool {
570 *self == EV2IS_A::VALUE2
571 }
572 #[doc = "CCU8x.INyC"]
573 #[inline(always)]
574 pub fn is_value3(&self) -> bool {
575 *self == EV2IS_A::VALUE3
576 }
577 #[doc = "CCU8x.INyD"]
578 #[inline(always)]
579 pub fn is_value4(&self) -> bool {
580 *self == EV2IS_A::VALUE4
581 }
582 #[doc = "CCU8x.INyE"]
583 #[inline(always)]
584 pub fn is_value5(&self) -> bool {
585 *self == EV2IS_A::VALUE5
586 }
587 #[doc = "CCU8x.INyF"]
588 #[inline(always)]
589 pub fn is_value6(&self) -> bool {
590 *self == EV2IS_A::VALUE6
591 }
592 #[doc = "CCU8x.INyG"]
593 #[inline(always)]
594 pub fn is_value7(&self) -> bool {
595 *self == EV2IS_A::VALUE7
596 }
597 #[doc = "CCU8x.INyH"]
598 #[inline(always)]
599 pub fn is_value8(&self) -> bool {
600 *self == EV2IS_A::VALUE8
601 }
602 #[doc = "CCU8x.INyI"]
603 #[inline(always)]
604 pub fn is_value9(&self) -> bool {
605 *self == EV2IS_A::VALUE9
606 }
607 #[doc = "CCU8x.INyJ"]
608 #[inline(always)]
609 pub fn is_value10(&self) -> bool {
610 *self == EV2IS_A::VALUE10
611 }
612 #[doc = "CCU8x.INyK"]
613 #[inline(always)]
614 pub fn is_value11(&self) -> bool {
615 *self == EV2IS_A::VALUE11
616 }
617 #[doc = "CCU8x.INyL"]
618 #[inline(always)]
619 pub fn is_value12(&self) -> bool {
620 *self == EV2IS_A::VALUE12
621 }
622 #[doc = "CCU8x.INyM"]
623 #[inline(always)]
624 pub fn is_value13(&self) -> bool {
625 *self == EV2IS_A::VALUE13
626 }
627 #[doc = "CCU8x.INyN"]
628 #[inline(always)]
629 pub fn is_value14(&self) -> bool {
630 *self == EV2IS_A::VALUE14
631 }
632 #[doc = "CCU8x.INyO"]
633 #[inline(always)]
634 pub fn is_value15(&self) -> bool {
635 *self == EV2IS_A::VALUE15
636 }
637 #[doc = "CCU8x.INyP"]
638 #[inline(always)]
639 pub fn is_value16(&self) -> bool {
640 *self == EV2IS_A::VALUE16
641 }
642}
643#[doc = "Field `EV2IS` writer - Event 2 signal selection"]
644pub type EV2IS_W<'a, REG> = crate::FieldWriter<'a, REG, 4, EV2IS_A, crate::Safe>;
645impl<'a, REG> EV2IS_W<'a, REG>
646where
647 REG: crate::Writable + crate::RegisterSpec,
648 REG::Ux: From<u8>,
649{
650 #[doc = "CCU8x.INyA"]
651 #[inline(always)]
652 pub fn value1(self) -> &'a mut crate::W<REG> {
653 self.variant(EV2IS_A::VALUE1)
654 }
655 #[doc = "CCU8x.INyB"]
656 #[inline(always)]
657 pub fn value2(self) -> &'a mut crate::W<REG> {
658 self.variant(EV2IS_A::VALUE2)
659 }
660 #[doc = "CCU8x.INyC"]
661 #[inline(always)]
662 pub fn value3(self) -> &'a mut crate::W<REG> {
663 self.variant(EV2IS_A::VALUE3)
664 }
665 #[doc = "CCU8x.INyD"]
666 #[inline(always)]
667 pub fn value4(self) -> &'a mut crate::W<REG> {
668 self.variant(EV2IS_A::VALUE4)
669 }
670 #[doc = "CCU8x.INyE"]
671 #[inline(always)]
672 pub fn value5(self) -> &'a mut crate::W<REG> {
673 self.variant(EV2IS_A::VALUE5)
674 }
675 #[doc = "CCU8x.INyF"]
676 #[inline(always)]
677 pub fn value6(self) -> &'a mut crate::W<REG> {
678 self.variant(EV2IS_A::VALUE6)
679 }
680 #[doc = "CCU8x.INyG"]
681 #[inline(always)]
682 pub fn value7(self) -> &'a mut crate::W<REG> {
683 self.variant(EV2IS_A::VALUE7)
684 }
685 #[doc = "CCU8x.INyH"]
686 #[inline(always)]
687 pub fn value8(self) -> &'a mut crate::W<REG> {
688 self.variant(EV2IS_A::VALUE8)
689 }
690 #[doc = "CCU8x.INyI"]
691 #[inline(always)]
692 pub fn value9(self) -> &'a mut crate::W<REG> {
693 self.variant(EV2IS_A::VALUE9)
694 }
695 #[doc = "CCU8x.INyJ"]
696 #[inline(always)]
697 pub fn value10(self) -> &'a mut crate::W<REG> {
698 self.variant(EV2IS_A::VALUE10)
699 }
700 #[doc = "CCU8x.INyK"]
701 #[inline(always)]
702 pub fn value11(self) -> &'a mut crate::W<REG> {
703 self.variant(EV2IS_A::VALUE11)
704 }
705 #[doc = "CCU8x.INyL"]
706 #[inline(always)]
707 pub fn value12(self) -> &'a mut crate::W<REG> {
708 self.variant(EV2IS_A::VALUE12)
709 }
710 #[doc = "CCU8x.INyM"]
711 #[inline(always)]
712 pub fn value13(self) -> &'a mut crate::W<REG> {
713 self.variant(EV2IS_A::VALUE13)
714 }
715 #[doc = "CCU8x.INyN"]
716 #[inline(always)]
717 pub fn value14(self) -> &'a mut crate::W<REG> {
718 self.variant(EV2IS_A::VALUE14)
719 }
720 #[doc = "CCU8x.INyO"]
721 #[inline(always)]
722 pub fn value15(self) -> &'a mut crate::W<REG> {
723 self.variant(EV2IS_A::VALUE15)
724 }
725 #[doc = "CCU8x.INyP"]
726 #[inline(always)]
727 pub fn value16(self) -> &'a mut crate::W<REG> {
728 self.variant(EV2IS_A::VALUE16)
729 }
730}
731#[doc = "Event 0 Edge Selection\n\nValue on reset: 0"]
732#[derive(Clone, Copy, Debug, PartialEq, Eq)]
733#[repr(u8)]
734pub enum EV0EM_A {
735 #[doc = "0: No action"]
736 VALUE1 = 0,
737 #[doc = "1: Signal active on rising edge"]
738 VALUE2 = 1,
739 #[doc = "2: Signal active on falling edge"]
740 VALUE3 = 2,
741 #[doc = "3: Signal active on both edges"]
742 VALUE4 = 3,
743}
744impl From<EV0EM_A> for u8 {
745 #[inline(always)]
746 fn from(variant: EV0EM_A) -> Self {
747 variant as _
748 }
749}
750impl crate::FieldSpec for EV0EM_A {
751 type Ux = u8;
752}
753impl crate::IsEnum for EV0EM_A {}
754#[doc = "Field `EV0EM` reader - Event 0 Edge Selection"]
755pub type EV0EM_R = crate::FieldReader<EV0EM_A>;
756impl EV0EM_R {
757 #[doc = "Get enumerated values variant"]
758 #[inline(always)]
759 pub const fn variant(&self) -> EV0EM_A {
760 match self.bits {
761 0 => EV0EM_A::VALUE1,
762 1 => EV0EM_A::VALUE2,
763 2 => EV0EM_A::VALUE3,
764 3 => EV0EM_A::VALUE4,
765 _ => unreachable!(),
766 }
767 }
768 #[doc = "No action"]
769 #[inline(always)]
770 pub fn is_value1(&self) -> bool {
771 *self == EV0EM_A::VALUE1
772 }
773 #[doc = "Signal active on rising edge"]
774 #[inline(always)]
775 pub fn is_value2(&self) -> bool {
776 *self == EV0EM_A::VALUE2
777 }
778 #[doc = "Signal active on falling edge"]
779 #[inline(always)]
780 pub fn is_value3(&self) -> bool {
781 *self == EV0EM_A::VALUE3
782 }
783 #[doc = "Signal active on both edges"]
784 #[inline(always)]
785 pub fn is_value4(&self) -> bool {
786 *self == EV0EM_A::VALUE4
787 }
788}
789#[doc = "Field `EV0EM` writer - Event 0 Edge Selection"]
790pub type EV0EM_W<'a, REG> = crate::FieldWriter<'a, REG, 2, EV0EM_A, crate::Safe>;
791impl<'a, REG> EV0EM_W<'a, REG>
792where
793 REG: crate::Writable + crate::RegisterSpec,
794 REG::Ux: From<u8>,
795{
796 #[doc = "No action"]
797 #[inline(always)]
798 pub fn value1(self) -> &'a mut crate::W<REG> {
799 self.variant(EV0EM_A::VALUE1)
800 }
801 #[doc = "Signal active on rising edge"]
802 #[inline(always)]
803 pub fn value2(self) -> &'a mut crate::W<REG> {
804 self.variant(EV0EM_A::VALUE2)
805 }
806 #[doc = "Signal active on falling edge"]
807 #[inline(always)]
808 pub fn value3(self) -> &'a mut crate::W<REG> {
809 self.variant(EV0EM_A::VALUE3)
810 }
811 #[doc = "Signal active on both edges"]
812 #[inline(always)]
813 pub fn value4(self) -> &'a mut crate::W<REG> {
814 self.variant(EV0EM_A::VALUE4)
815 }
816}
817#[doc = "Event 1 Edge Selection\n\nValue on reset: 0"]
818#[derive(Clone, Copy, Debug, PartialEq, Eq)]
819#[repr(u8)]
820pub enum EV1EM_A {
821 #[doc = "0: No action"]
822 VALUE1 = 0,
823 #[doc = "1: Signal active on rising edge"]
824 VALUE2 = 1,
825 #[doc = "2: Signal active on falling edge"]
826 VALUE3 = 2,
827 #[doc = "3: Signal active on both edges"]
828 VALUE4 = 3,
829}
830impl From<EV1EM_A> for u8 {
831 #[inline(always)]
832 fn from(variant: EV1EM_A) -> Self {
833 variant as _
834 }
835}
836impl crate::FieldSpec for EV1EM_A {
837 type Ux = u8;
838}
839impl crate::IsEnum for EV1EM_A {}
840#[doc = "Field `EV1EM` reader - Event 1 Edge Selection"]
841pub type EV1EM_R = crate::FieldReader<EV1EM_A>;
842impl EV1EM_R {
843 #[doc = "Get enumerated values variant"]
844 #[inline(always)]
845 pub const fn variant(&self) -> EV1EM_A {
846 match self.bits {
847 0 => EV1EM_A::VALUE1,
848 1 => EV1EM_A::VALUE2,
849 2 => EV1EM_A::VALUE3,
850 3 => EV1EM_A::VALUE4,
851 _ => unreachable!(),
852 }
853 }
854 #[doc = "No action"]
855 #[inline(always)]
856 pub fn is_value1(&self) -> bool {
857 *self == EV1EM_A::VALUE1
858 }
859 #[doc = "Signal active on rising edge"]
860 #[inline(always)]
861 pub fn is_value2(&self) -> bool {
862 *self == EV1EM_A::VALUE2
863 }
864 #[doc = "Signal active on falling edge"]
865 #[inline(always)]
866 pub fn is_value3(&self) -> bool {
867 *self == EV1EM_A::VALUE3
868 }
869 #[doc = "Signal active on both edges"]
870 #[inline(always)]
871 pub fn is_value4(&self) -> bool {
872 *self == EV1EM_A::VALUE4
873 }
874}
875#[doc = "Field `EV1EM` writer - Event 1 Edge Selection"]
876pub type EV1EM_W<'a, REG> = crate::FieldWriter<'a, REG, 2, EV1EM_A, crate::Safe>;
877impl<'a, REG> EV1EM_W<'a, REG>
878where
879 REG: crate::Writable + crate::RegisterSpec,
880 REG::Ux: From<u8>,
881{
882 #[doc = "No action"]
883 #[inline(always)]
884 pub fn value1(self) -> &'a mut crate::W<REG> {
885 self.variant(EV1EM_A::VALUE1)
886 }
887 #[doc = "Signal active on rising edge"]
888 #[inline(always)]
889 pub fn value2(self) -> &'a mut crate::W<REG> {
890 self.variant(EV1EM_A::VALUE2)
891 }
892 #[doc = "Signal active on falling edge"]
893 #[inline(always)]
894 pub fn value3(self) -> &'a mut crate::W<REG> {
895 self.variant(EV1EM_A::VALUE3)
896 }
897 #[doc = "Signal active on both edges"]
898 #[inline(always)]
899 pub fn value4(self) -> &'a mut crate::W<REG> {
900 self.variant(EV1EM_A::VALUE4)
901 }
902}
903#[doc = "Event 2 Edge Selection\n\nValue on reset: 0"]
904#[derive(Clone, Copy, Debug, PartialEq, Eq)]
905#[repr(u8)]
906pub enum EV2EM_A {
907 #[doc = "0: No action"]
908 VALUE1 = 0,
909 #[doc = "1: Signal active on rising edge"]
910 VALUE2 = 1,
911 #[doc = "2: Signal active on falling edge"]
912 VALUE3 = 2,
913 #[doc = "3: Signal active on both edges"]
914 VALUE4 = 3,
915}
916impl From<EV2EM_A> for u8 {
917 #[inline(always)]
918 fn from(variant: EV2EM_A) -> Self {
919 variant as _
920 }
921}
922impl crate::FieldSpec for EV2EM_A {
923 type Ux = u8;
924}
925impl crate::IsEnum for EV2EM_A {}
926#[doc = "Field `EV2EM` reader - Event 2 Edge Selection"]
927pub type EV2EM_R = crate::FieldReader<EV2EM_A>;
928impl EV2EM_R {
929 #[doc = "Get enumerated values variant"]
930 #[inline(always)]
931 pub const fn variant(&self) -> EV2EM_A {
932 match self.bits {
933 0 => EV2EM_A::VALUE1,
934 1 => EV2EM_A::VALUE2,
935 2 => EV2EM_A::VALUE3,
936 3 => EV2EM_A::VALUE4,
937 _ => unreachable!(),
938 }
939 }
940 #[doc = "No action"]
941 #[inline(always)]
942 pub fn is_value1(&self) -> bool {
943 *self == EV2EM_A::VALUE1
944 }
945 #[doc = "Signal active on rising edge"]
946 #[inline(always)]
947 pub fn is_value2(&self) -> bool {
948 *self == EV2EM_A::VALUE2
949 }
950 #[doc = "Signal active on falling edge"]
951 #[inline(always)]
952 pub fn is_value3(&self) -> bool {
953 *self == EV2EM_A::VALUE3
954 }
955 #[doc = "Signal active on both edges"]
956 #[inline(always)]
957 pub fn is_value4(&self) -> bool {
958 *self == EV2EM_A::VALUE4
959 }
960}
961#[doc = "Field `EV2EM` writer - Event 2 Edge Selection"]
962pub type EV2EM_W<'a, REG> = crate::FieldWriter<'a, REG, 2, EV2EM_A, crate::Safe>;
963impl<'a, REG> EV2EM_W<'a, REG>
964where
965 REG: crate::Writable + crate::RegisterSpec,
966 REG::Ux: From<u8>,
967{
968 #[doc = "No action"]
969 #[inline(always)]
970 pub fn value1(self) -> &'a mut crate::W<REG> {
971 self.variant(EV2EM_A::VALUE1)
972 }
973 #[doc = "Signal active on rising edge"]
974 #[inline(always)]
975 pub fn value2(self) -> &'a mut crate::W<REG> {
976 self.variant(EV2EM_A::VALUE2)
977 }
978 #[doc = "Signal active on falling edge"]
979 #[inline(always)]
980 pub fn value3(self) -> &'a mut crate::W<REG> {
981 self.variant(EV2EM_A::VALUE3)
982 }
983 #[doc = "Signal active on both edges"]
984 #[inline(always)]
985 pub fn value4(self) -> &'a mut crate::W<REG> {
986 self.variant(EV2EM_A::VALUE4)
987 }
988}
989#[doc = "Event 0 Level Selection\n\nValue on reset: 0"]
990#[derive(Clone, Copy, Debug, PartialEq, Eq)]
991pub enum EV0LM_A {
992 #[doc = "0: Active on HIGH level"]
993 VALUE1 = 0,
994 #[doc = "1: Active on LOW level"]
995 VALUE2 = 1,
996}
997impl From<EV0LM_A> for bool {
998 #[inline(always)]
999 fn from(variant: EV0LM_A) -> Self {
1000 variant as u8 != 0
1001 }
1002}
1003#[doc = "Field `EV0LM` reader - Event 0 Level Selection"]
1004pub type EV0LM_R = crate::BitReader<EV0LM_A>;
1005impl EV0LM_R {
1006 #[doc = "Get enumerated values variant"]
1007 #[inline(always)]
1008 pub const fn variant(&self) -> EV0LM_A {
1009 match self.bits {
1010 false => EV0LM_A::VALUE1,
1011 true => EV0LM_A::VALUE2,
1012 }
1013 }
1014 #[doc = "Active on HIGH level"]
1015 #[inline(always)]
1016 pub fn is_value1(&self) -> bool {
1017 *self == EV0LM_A::VALUE1
1018 }
1019 #[doc = "Active on LOW level"]
1020 #[inline(always)]
1021 pub fn is_value2(&self) -> bool {
1022 *self == EV0LM_A::VALUE2
1023 }
1024}
1025#[doc = "Field `EV0LM` writer - Event 0 Level Selection"]
1026pub type EV0LM_W<'a, REG> = crate::BitWriter<'a, REG, EV0LM_A>;
1027impl<'a, REG> EV0LM_W<'a, REG>
1028where
1029 REG: crate::Writable + crate::RegisterSpec,
1030{
1031 #[doc = "Active on HIGH level"]
1032 #[inline(always)]
1033 pub fn value1(self) -> &'a mut crate::W<REG> {
1034 self.variant(EV0LM_A::VALUE1)
1035 }
1036 #[doc = "Active on LOW level"]
1037 #[inline(always)]
1038 pub fn value2(self) -> &'a mut crate::W<REG> {
1039 self.variant(EV0LM_A::VALUE2)
1040 }
1041}
1042#[doc = "Event 1 Level Selection\n\nValue on reset: 0"]
1043#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1044pub enum EV1LM_A {
1045 #[doc = "0: Active on HIGH level"]
1046 VALUE1 = 0,
1047 #[doc = "1: Active on LOW level"]
1048 VALUE2 = 1,
1049}
1050impl From<EV1LM_A> for bool {
1051 #[inline(always)]
1052 fn from(variant: EV1LM_A) -> Self {
1053 variant as u8 != 0
1054 }
1055}
1056#[doc = "Field `EV1LM` reader - Event 1 Level Selection"]
1057pub type EV1LM_R = crate::BitReader<EV1LM_A>;
1058impl EV1LM_R {
1059 #[doc = "Get enumerated values variant"]
1060 #[inline(always)]
1061 pub const fn variant(&self) -> EV1LM_A {
1062 match self.bits {
1063 false => EV1LM_A::VALUE1,
1064 true => EV1LM_A::VALUE2,
1065 }
1066 }
1067 #[doc = "Active on HIGH level"]
1068 #[inline(always)]
1069 pub fn is_value1(&self) -> bool {
1070 *self == EV1LM_A::VALUE1
1071 }
1072 #[doc = "Active on LOW level"]
1073 #[inline(always)]
1074 pub fn is_value2(&self) -> bool {
1075 *self == EV1LM_A::VALUE2
1076 }
1077}
1078#[doc = "Field `EV1LM` writer - Event 1 Level Selection"]
1079pub type EV1LM_W<'a, REG> = crate::BitWriter<'a, REG, EV1LM_A>;
1080impl<'a, REG> EV1LM_W<'a, REG>
1081where
1082 REG: crate::Writable + crate::RegisterSpec,
1083{
1084 #[doc = "Active on HIGH level"]
1085 #[inline(always)]
1086 pub fn value1(self) -> &'a mut crate::W<REG> {
1087 self.variant(EV1LM_A::VALUE1)
1088 }
1089 #[doc = "Active on LOW level"]
1090 #[inline(always)]
1091 pub fn value2(self) -> &'a mut crate::W<REG> {
1092 self.variant(EV1LM_A::VALUE2)
1093 }
1094}
1095#[doc = "Event 2 Level Selection\n\nValue on reset: 0"]
1096#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1097pub enum EV2LM_A {
1098 #[doc = "0: Active on HIGH level"]
1099 VALUE1 = 0,
1100 #[doc = "1: Active on LOW level"]
1101 VALUE2 = 1,
1102}
1103impl From<EV2LM_A> for bool {
1104 #[inline(always)]
1105 fn from(variant: EV2LM_A) -> Self {
1106 variant as u8 != 0
1107 }
1108}
1109#[doc = "Field `EV2LM` reader - Event 2 Level Selection"]
1110pub type EV2LM_R = crate::BitReader<EV2LM_A>;
1111impl EV2LM_R {
1112 #[doc = "Get enumerated values variant"]
1113 #[inline(always)]
1114 pub const fn variant(&self) -> EV2LM_A {
1115 match self.bits {
1116 false => EV2LM_A::VALUE1,
1117 true => EV2LM_A::VALUE2,
1118 }
1119 }
1120 #[doc = "Active on HIGH level"]
1121 #[inline(always)]
1122 pub fn is_value1(&self) -> bool {
1123 *self == EV2LM_A::VALUE1
1124 }
1125 #[doc = "Active on LOW level"]
1126 #[inline(always)]
1127 pub fn is_value2(&self) -> bool {
1128 *self == EV2LM_A::VALUE2
1129 }
1130}
1131#[doc = "Field `EV2LM` writer - Event 2 Level Selection"]
1132pub type EV2LM_W<'a, REG> = crate::BitWriter<'a, REG, EV2LM_A>;
1133impl<'a, REG> EV2LM_W<'a, REG>
1134where
1135 REG: crate::Writable + crate::RegisterSpec,
1136{
1137 #[doc = "Active on HIGH level"]
1138 #[inline(always)]
1139 pub fn value1(self) -> &'a mut crate::W<REG> {
1140 self.variant(EV2LM_A::VALUE1)
1141 }
1142 #[doc = "Active on LOW level"]
1143 #[inline(always)]
1144 pub fn value2(self) -> &'a mut crate::W<REG> {
1145 self.variant(EV2LM_A::VALUE2)
1146 }
1147}
1148#[doc = "Event 0 Low Pass Filter Configuration\n\nValue on reset: 0"]
1149#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1150#[repr(u8)]
1151pub enum LPF0M_A {
1152 #[doc = "0: LPF is disabled"]
1153 VALUE1 = 0,
1154 #[doc = "1: 3 clock cycles of fCCU8"]
1155 VALUE2 = 1,
1156 #[doc = "2: 5 clock cycles of fCCU8"]
1157 VALUE3 = 2,
1158 #[doc = "3: 7 clock cycles of fCCU8"]
1159 VALUE4 = 3,
1160}
1161impl From<LPF0M_A> for u8 {
1162 #[inline(always)]
1163 fn from(variant: LPF0M_A) -> Self {
1164 variant as _
1165 }
1166}
1167impl crate::FieldSpec for LPF0M_A {
1168 type Ux = u8;
1169}
1170impl crate::IsEnum for LPF0M_A {}
1171#[doc = "Field `LPF0M` reader - Event 0 Low Pass Filter Configuration"]
1172pub type LPF0M_R = crate::FieldReader<LPF0M_A>;
1173impl LPF0M_R {
1174 #[doc = "Get enumerated values variant"]
1175 #[inline(always)]
1176 pub const fn variant(&self) -> LPF0M_A {
1177 match self.bits {
1178 0 => LPF0M_A::VALUE1,
1179 1 => LPF0M_A::VALUE2,
1180 2 => LPF0M_A::VALUE3,
1181 3 => LPF0M_A::VALUE4,
1182 _ => unreachable!(),
1183 }
1184 }
1185 #[doc = "LPF is disabled"]
1186 #[inline(always)]
1187 pub fn is_value1(&self) -> bool {
1188 *self == LPF0M_A::VALUE1
1189 }
1190 #[doc = "3 clock cycles of fCCU8"]
1191 #[inline(always)]
1192 pub fn is_value2(&self) -> bool {
1193 *self == LPF0M_A::VALUE2
1194 }
1195 #[doc = "5 clock cycles of fCCU8"]
1196 #[inline(always)]
1197 pub fn is_value3(&self) -> bool {
1198 *self == LPF0M_A::VALUE3
1199 }
1200 #[doc = "7 clock cycles of fCCU8"]
1201 #[inline(always)]
1202 pub fn is_value4(&self) -> bool {
1203 *self == LPF0M_A::VALUE4
1204 }
1205}
1206#[doc = "Field `LPF0M` writer - Event 0 Low Pass Filter Configuration"]
1207pub type LPF0M_W<'a, REG> = crate::FieldWriter<'a, REG, 2, LPF0M_A, crate::Safe>;
1208impl<'a, REG> LPF0M_W<'a, REG>
1209where
1210 REG: crate::Writable + crate::RegisterSpec,
1211 REG::Ux: From<u8>,
1212{
1213 #[doc = "LPF is disabled"]
1214 #[inline(always)]
1215 pub fn value1(self) -> &'a mut crate::W<REG> {
1216 self.variant(LPF0M_A::VALUE1)
1217 }
1218 #[doc = "3 clock cycles of fCCU8"]
1219 #[inline(always)]
1220 pub fn value2(self) -> &'a mut crate::W<REG> {
1221 self.variant(LPF0M_A::VALUE2)
1222 }
1223 #[doc = "5 clock cycles of fCCU8"]
1224 #[inline(always)]
1225 pub fn value3(self) -> &'a mut crate::W<REG> {
1226 self.variant(LPF0M_A::VALUE3)
1227 }
1228 #[doc = "7 clock cycles of fCCU8"]
1229 #[inline(always)]
1230 pub fn value4(self) -> &'a mut crate::W<REG> {
1231 self.variant(LPF0M_A::VALUE4)
1232 }
1233}
1234#[doc = "Event 1 Low Pass Filter Configuration\n\nValue on reset: 0"]
1235#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1236#[repr(u8)]
1237pub enum LPF1M_A {
1238 #[doc = "0: LPF is disabled"]
1239 VALUE1 = 0,
1240 #[doc = "1: 3 clock cycles of fCCU8"]
1241 VALUE2 = 1,
1242 #[doc = "2: 5 clock cycles of fCCU8"]
1243 VALUE3 = 2,
1244 #[doc = "3: 7 clock cycles of fCCU8"]
1245 VALUE4 = 3,
1246}
1247impl From<LPF1M_A> for u8 {
1248 #[inline(always)]
1249 fn from(variant: LPF1M_A) -> Self {
1250 variant as _
1251 }
1252}
1253impl crate::FieldSpec for LPF1M_A {
1254 type Ux = u8;
1255}
1256impl crate::IsEnum for LPF1M_A {}
1257#[doc = "Field `LPF1M` reader - Event 1 Low Pass Filter Configuration"]
1258pub type LPF1M_R = crate::FieldReader<LPF1M_A>;
1259impl LPF1M_R {
1260 #[doc = "Get enumerated values variant"]
1261 #[inline(always)]
1262 pub const fn variant(&self) -> LPF1M_A {
1263 match self.bits {
1264 0 => LPF1M_A::VALUE1,
1265 1 => LPF1M_A::VALUE2,
1266 2 => LPF1M_A::VALUE3,
1267 3 => LPF1M_A::VALUE4,
1268 _ => unreachable!(),
1269 }
1270 }
1271 #[doc = "LPF is disabled"]
1272 #[inline(always)]
1273 pub fn is_value1(&self) -> bool {
1274 *self == LPF1M_A::VALUE1
1275 }
1276 #[doc = "3 clock cycles of fCCU8"]
1277 #[inline(always)]
1278 pub fn is_value2(&self) -> bool {
1279 *self == LPF1M_A::VALUE2
1280 }
1281 #[doc = "5 clock cycles of fCCU8"]
1282 #[inline(always)]
1283 pub fn is_value3(&self) -> bool {
1284 *self == LPF1M_A::VALUE3
1285 }
1286 #[doc = "7 clock cycles of fCCU8"]
1287 #[inline(always)]
1288 pub fn is_value4(&self) -> bool {
1289 *self == LPF1M_A::VALUE4
1290 }
1291}
1292#[doc = "Field `LPF1M` writer - Event 1 Low Pass Filter Configuration"]
1293pub type LPF1M_W<'a, REG> = crate::FieldWriter<'a, REG, 2, LPF1M_A, crate::Safe>;
1294impl<'a, REG> LPF1M_W<'a, REG>
1295where
1296 REG: crate::Writable + crate::RegisterSpec,
1297 REG::Ux: From<u8>,
1298{
1299 #[doc = "LPF is disabled"]
1300 #[inline(always)]
1301 pub fn value1(self) -> &'a mut crate::W<REG> {
1302 self.variant(LPF1M_A::VALUE1)
1303 }
1304 #[doc = "3 clock cycles of fCCU8"]
1305 #[inline(always)]
1306 pub fn value2(self) -> &'a mut crate::W<REG> {
1307 self.variant(LPF1M_A::VALUE2)
1308 }
1309 #[doc = "5 clock cycles of fCCU8"]
1310 #[inline(always)]
1311 pub fn value3(self) -> &'a mut crate::W<REG> {
1312 self.variant(LPF1M_A::VALUE3)
1313 }
1314 #[doc = "7 clock cycles of fCCU8"]
1315 #[inline(always)]
1316 pub fn value4(self) -> &'a mut crate::W<REG> {
1317 self.variant(LPF1M_A::VALUE4)
1318 }
1319}
1320#[doc = "Event 2 Low Pass Filter Configuration\n\nValue on reset: 0"]
1321#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1322#[repr(u8)]
1323pub enum LPF2M_A {
1324 #[doc = "0: LPF is disabled"]
1325 VALUE1 = 0,
1326 #[doc = "1: 3 clock cycles of fCCU8"]
1327 VALUE2 = 1,
1328 #[doc = "2: 5 clock cycles of fCCU8"]
1329 VALUE3 = 2,
1330 #[doc = "3: 7 clock cycles of fCCU8"]
1331 VALUE4 = 3,
1332}
1333impl From<LPF2M_A> for u8 {
1334 #[inline(always)]
1335 fn from(variant: LPF2M_A) -> Self {
1336 variant as _
1337 }
1338}
1339impl crate::FieldSpec for LPF2M_A {
1340 type Ux = u8;
1341}
1342impl crate::IsEnum for LPF2M_A {}
1343#[doc = "Field `LPF2M` reader - Event 2 Low Pass Filter Configuration"]
1344pub type LPF2M_R = crate::FieldReader<LPF2M_A>;
1345impl LPF2M_R {
1346 #[doc = "Get enumerated values variant"]
1347 #[inline(always)]
1348 pub const fn variant(&self) -> LPF2M_A {
1349 match self.bits {
1350 0 => LPF2M_A::VALUE1,
1351 1 => LPF2M_A::VALUE2,
1352 2 => LPF2M_A::VALUE3,
1353 3 => LPF2M_A::VALUE4,
1354 _ => unreachable!(),
1355 }
1356 }
1357 #[doc = "LPF is disabled"]
1358 #[inline(always)]
1359 pub fn is_value1(&self) -> bool {
1360 *self == LPF2M_A::VALUE1
1361 }
1362 #[doc = "3 clock cycles of fCCU8"]
1363 #[inline(always)]
1364 pub fn is_value2(&self) -> bool {
1365 *self == LPF2M_A::VALUE2
1366 }
1367 #[doc = "5 clock cycles of fCCU8"]
1368 #[inline(always)]
1369 pub fn is_value3(&self) -> bool {
1370 *self == LPF2M_A::VALUE3
1371 }
1372 #[doc = "7 clock cycles of fCCU8"]
1373 #[inline(always)]
1374 pub fn is_value4(&self) -> bool {
1375 *self == LPF2M_A::VALUE4
1376 }
1377}
1378#[doc = "Field `LPF2M` writer - Event 2 Low Pass Filter Configuration"]
1379pub type LPF2M_W<'a, REG> = crate::FieldWriter<'a, REG, 2, LPF2M_A, crate::Safe>;
1380impl<'a, REG> LPF2M_W<'a, REG>
1381where
1382 REG: crate::Writable + crate::RegisterSpec,
1383 REG::Ux: From<u8>,
1384{
1385 #[doc = "LPF is disabled"]
1386 #[inline(always)]
1387 pub fn value1(self) -> &'a mut crate::W<REG> {
1388 self.variant(LPF2M_A::VALUE1)
1389 }
1390 #[doc = "3 clock cycles of fCCU8"]
1391 #[inline(always)]
1392 pub fn value2(self) -> &'a mut crate::W<REG> {
1393 self.variant(LPF2M_A::VALUE2)
1394 }
1395 #[doc = "5 clock cycles of fCCU8"]
1396 #[inline(always)]
1397 pub fn value3(self) -> &'a mut crate::W<REG> {
1398 self.variant(LPF2M_A::VALUE3)
1399 }
1400 #[doc = "7 clock cycles of fCCU8"]
1401 #[inline(always)]
1402 pub fn value4(self) -> &'a mut crate::W<REG> {
1403 self.variant(LPF2M_A::VALUE4)
1404 }
1405}
1406impl R {
1407 #[doc = "Bits 0:3 - Event 0 signal selection"]
1408 #[inline(always)]
1409 pub fn ev0is(&self) -> EV0IS_R {
1410 EV0IS_R::new((self.bits & 0x0f) as u8)
1411 }
1412 #[doc = "Bits 4:7 - Event 1 signal selection"]
1413 #[inline(always)]
1414 pub fn ev1is(&self) -> EV1IS_R {
1415 EV1IS_R::new(((self.bits >> 4) & 0x0f) as u8)
1416 }
1417 #[doc = "Bits 8:11 - Event 2 signal selection"]
1418 #[inline(always)]
1419 pub fn ev2is(&self) -> EV2IS_R {
1420 EV2IS_R::new(((self.bits >> 8) & 0x0f) as u8)
1421 }
1422 #[doc = "Bits 16:17 - Event 0 Edge Selection"]
1423 #[inline(always)]
1424 pub fn ev0em(&self) -> EV0EM_R {
1425 EV0EM_R::new(((self.bits >> 16) & 3) as u8)
1426 }
1427 #[doc = "Bits 18:19 - Event 1 Edge Selection"]
1428 #[inline(always)]
1429 pub fn ev1em(&self) -> EV1EM_R {
1430 EV1EM_R::new(((self.bits >> 18) & 3) as u8)
1431 }
1432 #[doc = "Bits 20:21 - Event 2 Edge Selection"]
1433 #[inline(always)]
1434 pub fn ev2em(&self) -> EV2EM_R {
1435 EV2EM_R::new(((self.bits >> 20) & 3) as u8)
1436 }
1437 #[doc = "Bit 22 - Event 0 Level Selection"]
1438 #[inline(always)]
1439 pub fn ev0lm(&self) -> EV0LM_R {
1440 EV0LM_R::new(((self.bits >> 22) & 1) != 0)
1441 }
1442 #[doc = "Bit 23 - Event 1 Level Selection"]
1443 #[inline(always)]
1444 pub fn ev1lm(&self) -> EV1LM_R {
1445 EV1LM_R::new(((self.bits >> 23) & 1) != 0)
1446 }
1447 #[doc = "Bit 24 - Event 2 Level Selection"]
1448 #[inline(always)]
1449 pub fn ev2lm(&self) -> EV2LM_R {
1450 EV2LM_R::new(((self.bits >> 24) & 1) != 0)
1451 }
1452 #[doc = "Bits 25:26 - Event 0 Low Pass Filter Configuration"]
1453 #[inline(always)]
1454 pub fn lpf0m(&self) -> LPF0M_R {
1455 LPF0M_R::new(((self.bits >> 25) & 3) as u8)
1456 }
1457 #[doc = "Bits 27:28 - Event 1 Low Pass Filter Configuration"]
1458 #[inline(always)]
1459 pub fn lpf1m(&self) -> LPF1M_R {
1460 LPF1M_R::new(((self.bits >> 27) & 3) as u8)
1461 }
1462 #[doc = "Bits 29:30 - Event 2 Low Pass Filter Configuration"]
1463 #[inline(always)]
1464 pub fn lpf2m(&self) -> LPF2M_R {
1465 LPF2M_R::new(((self.bits >> 29) & 3) as u8)
1466 }
1467}
1468impl W {
1469 #[doc = "Bits 0:3 - Event 0 signal selection"]
1470 #[inline(always)]
1471 pub fn ev0is(&mut self) -> EV0IS_W<INS_SPEC> {
1472 EV0IS_W::new(self, 0)
1473 }
1474 #[doc = "Bits 4:7 - Event 1 signal selection"]
1475 #[inline(always)]
1476 pub fn ev1is(&mut self) -> EV1IS_W<INS_SPEC> {
1477 EV1IS_W::new(self, 4)
1478 }
1479 #[doc = "Bits 8:11 - Event 2 signal selection"]
1480 #[inline(always)]
1481 pub fn ev2is(&mut self) -> EV2IS_W<INS_SPEC> {
1482 EV2IS_W::new(self, 8)
1483 }
1484 #[doc = "Bits 16:17 - Event 0 Edge Selection"]
1485 #[inline(always)]
1486 pub fn ev0em(&mut self) -> EV0EM_W<INS_SPEC> {
1487 EV0EM_W::new(self, 16)
1488 }
1489 #[doc = "Bits 18:19 - Event 1 Edge Selection"]
1490 #[inline(always)]
1491 pub fn ev1em(&mut self) -> EV1EM_W<INS_SPEC> {
1492 EV1EM_W::new(self, 18)
1493 }
1494 #[doc = "Bits 20:21 - Event 2 Edge Selection"]
1495 #[inline(always)]
1496 pub fn ev2em(&mut self) -> EV2EM_W<INS_SPEC> {
1497 EV2EM_W::new(self, 20)
1498 }
1499 #[doc = "Bit 22 - Event 0 Level Selection"]
1500 #[inline(always)]
1501 pub fn ev0lm(&mut self) -> EV0LM_W<INS_SPEC> {
1502 EV0LM_W::new(self, 22)
1503 }
1504 #[doc = "Bit 23 - Event 1 Level Selection"]
1505 #[inline(always)]
1506 pub fn ev1lm(&mut self) -> EV1LM_W<INS_SPEC> {
1507 EV1LM_W::new(self, 23)
1508 }
1509 #[doc = "Bit 24 - Event 2 Level Selection"]
1510 #[inline(always)]
1511 pub fn ev2lm(&mut self) -> EV2LM_W<INS_SPEC> {
1512 EV2LM_W::new(self, 24)
1513 }
1514 #[doc = "Bits 25:26 - Event 0 Low Pass Filter Configuration"]
1515 #[inline(always)]
1516 pub fn lpf0m(&mut self) -> LPF0M_W<INS_SPEC> {
1517 LPF0M_W::new(self, 25)
1518 }
1519 #[doc = "Bits 27:28 - Event 1 Low Pass Filter Configuration"]
1520 #[inline(always)]
1521 pub fn lpf1m(&mut self) -> LPF1M_W<INS_SPEC> {
1522 LPF1M_W::new(self, 27)
1523 }
1524 #[doc = "Bits 29:30 - Event 2 Low Pass Filter Configuration"]
1525 #[inline(always)]
1526 pub fn lpf2m(&mut self) -> LPF2M_W<INS_SPEC> {
1527 LPF2M_W::new(self, 29)
1528 }
1529}
1530#[doc = "Input Selector Configuration\n\nYou can [`read`](crate::Reg::read) this register and get [`ins::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`ins::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1531pub struct INS_SPEC;
1532impl crate::RegisterSpec for INS_SPEC {
1533 type Ux = u32;
1534}
1535#[doc = "`read()` method returns [`ins::R`](R) reader structure"]
1536impl crate::Readable for INS_SPEC {}
1537#[doc = "`write(|w| ..)` method takes [`ins::W`](W) writer structure"]
1538impl crate::Writable for INS_SPEC {
1539 type Safety = crate::Unsafe;
1540 const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1541 const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1542}
1543#[doc = "`reset()` method sets INS to value 0"]
1544impl crate::Resettable for INS_SPEC {
1545 const RESET_VALUE: u32 = 0;
1546}