xmc4700/ccu80_cc80/
ins.rs

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}