tm4c129x/adc0/
emux.rs

1#[doc = "Reader of register EMUX"]
2pub type R = crate::R<u32, super::EMUX>;
3#[doc = "Writer for register EMUX"]
4pub type W = crate::W<u32, super::EMUX>;
5#[doc = "Register EMUX `reset()`'s with value 0"]
6impl crate::ResetValue for super::EMUX {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "SS0 Trigger Select\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15#[repr(u8)]
16pub enum EM0_A {
17    #[doc = "0: Processor (default)"]
18    PROCESSOR = 0,
19    #[doc = "1: Analog Comparator 0"]
20    COMP0 = 1,
21    #[doc = "2: Analog Comparator 1"]
22    COMP1 = 2,
23    #[doc = "3: Analog Comparator 2"]
24    COMP2 = 3,
25    #[doc = "4: External (GPIO Pins)"]
26    EXTERNAL = 4,
27    #[doc = "5: Timer"]
28    TIMER = 5,
29    #[doc = "6: PWM generator 0"]
30    PWM0 = 6,
31    #[doc = "7: PWM generator 1"]
32    PWM1 = 7,
33    #[doc = "8: PWM generator 2"]
34    PWM2 = 8,
35    #[doc = "9: PWM generator 3"]
36    PWM3 = 9,
37    #[doc = "14: Never Trigger"]
38    NEVER = 14,
39    #[doc = "15: Always (continuously sample)"]
40    ALWAYS = 15,
41}
42impl From<EM0_A> for u8 {
43    #[inline(always)]
44    fn from(variant: EM0_A) -> Self {
45        variant as _
46    }
47}
48#[doc = "Reader of field `EM0`"]
49pub type EM0_R = crate::R<u8, EM0_A>;
50impl EM0_R {
51    #[doc = r"Get enumerated values variant"]
52    #[inline(always)]
53    pub fn variant(&self) -> crate::Variant<u8, EM0_A> {
54        use crate::Variant::*;
55        match self.bits {
56            0 => Val(EM0_A::PROCESSOR),
57            1 => Val(EM0_A::COMP0),
58            2 => Val(EM0_A::COMP1),
59            3 => Val(EM0_A::COMP2),
60            4 => Val(EM0_A::EXTERNAL),
61            5 => Val(EM0_A::TIMER),
62            6 => Val(EM0_A::PWM0),
63            7 => Val(EM0_A::PWM1),
64            8 => Val(EM0_A::PWM2),
65            9 => Val(EM0_A::PWM3),
66            14 => Val(EM0_A::NEVER),
67            15 => Val(EM0_A::ALWAYS),
68            i => Res(i),
69        }
70    }
71    #[doc = "Checks if the value of the field is `PROCESSOR`"]
72    #[inline(always)]
73    pub fn is_processor(&self) -> bool {
74        *self == EM0_A::PROCESSOR
75    }
76    #[doc = "Checks if the value of the field is `COMP0`"]
77    #[inline(always)]
78    pub fn is_comp0(&self) -> bool {
79        *self == EM0_A::COMP0
80    }
81    #[doc = "Checks if the value of the field is `COMP1`"]
82    #[inline(always)]
83    pub fn is_comp1(&self) -> bool {
84        *self == EM0_A::COMP1
85    }
86    #[doc = "Checks if the value of the field is `COMP2`"]
87    #[inline(always)]
88    pub fn is_comp2(&self) -> bool {
89        *self == EM0_A::COMP2
90    }
91    #[doc = "Checks if the value of the field is `EXTERNAL`"]
92    #[inline(always)]
93    pub fn is_external(&self) -> bool {
94        *self == EM0_A::EXTERNAL
95    }
96    #[doc = "Checks if the value of the field is `TIMER`"]
97    #[inline(always)]
98    pub fn is_timer(&self) -> bool {
99        *self == EM0_A::TIMER
100    }
101    #[doc = "Checks if the value of the field is `PWM0`"]
102    #[inline(always)]
103    pub fn is_pwm0(&self) -> bool {
104        *self == EM0_A::PWM0
105    }
106    #[doc = "Checks if the value of the field is `PWM1`"]
107    #[inline(always)]
108    pub fn is_pwm1(&self) -> bool {
109        *self == EM0_A::PWM1
110    }
111    #[doc = "Checks if the value of the field is `PWM2`"]
112    #[inline(always)]
113    pub fn is_pwm2(&self) -> bool {
114        *self == EM0_A::PWM2
115    }
116    #[doc = "Checks if the value of the field is `PWM3`"]
117    #[inline(always)]
118    pub fn is_pwm3(&self) -> bool {
119        *self == EM0_A::PWM3
120    }
121    #[doc = "Checks if the value of the field is `NEVER`"]
122    #[inline(always)]
123    pub fn is_never(&self) -> bool {
124        *self == EM0_A::NEVER
125    }
126    #[doc = "Checks if the value of the field is `ALWAYS`"]
127    #[inline(always)]
128    pub fn is_always(&self) -> bool {
129        *self == EM0_A::ALWAYS
130    }
131}
132#[doc = "Write proxy for field `EM0`"]
133pub struct EM0_W<'a> {
134    w: &'a mut W,
135}
136impl<'a> EM0_W<'a> {
137    #[doc = r"Writes `variant` to the field"]
138    #[inline(always)]
139    pub fn variant(self, variant: EM0_A) -> &'a mut W {
140        unsafe { self.bits(variant.into()) }
141    }
142    #[doc = "Processor (default)"]
143    #[inline(always)]
144    pub fn processor(self) -> &'a mut W {
145        self.variant(EM0_A::PROCESSOR)
146    }
147    #[doc = "Analog Comparator 0"]
148    #[inline(always)]
149    pub fn comp0(self) -> &'a mut W {
150        self.variant(EM0_A::COMP0)
151    }
152    #[doc = "Analog Comparator 1"]
153    #[inline(always)]
154    pub fn comp1(self) -> &'a mut W {
155        self.variant(EM0_A::COMP1)
156    }
157    #[doc = "Analog Comparator 2"]
158    #[inline(always)]
159    pub fn comp2(self) -> &'a mut W {
160        self.variant(EM0_A::COMP2)
161    }
162    #[doc = "External (GPIO Pins)"]
163    #[inline(always)]
164    pub fn external(self) -> &'a mut W {
165        self.variant(EM0_A::EXTERNAL)
166    }
167    #[doc = "Timer"]
168    #[inline(always)]
169    pub fn timer(self) -> &'a mut W {
170        self.variant(EM0_A::TIMER)
171    }
172    #[doc = "PWM generator 0"]
173    #[inline(always)]
174    pub fn pwm0(self) -> &'a mut W {
175        self.variant(EM0_A::PWM0)
176    }
177    #[doc = "PWM generator 1"]
178    #[inline(always)]
179    pub fn pwm1(self) -> &'a mut W {
180        self.variant(EM0_A::PWM1)
181    }
182    #[doc = "PWM generator 2"]
183    #[inline(always)]
184    pub fn pwm2(self) -> &'a mut W {
185        self.variant(EM0_A::PWM2)
186    }
187    #[doc = "PWM generator 3"]
188    #[inline(always)]
189    pub fn pwm3(self) -> &'a mut W {
190        self.variant(EM0_A::PWM3)
191    }
192    #[doc = "Never Trigger"]
193    #[inline(always)]
194    pub fn never(self) -> &'a mut W {
195        self.variant(EM0_A::NEVER)
196    }
197    #[doc = "Always (continuously sample)"]
198    #[inline(always)]
199    pub fn always(self) -> &'a mut W {
200        self.variant(EM0_A::ALWAYS)
201    }
202    #[doc = r"Writes raw bits to the field"]
203    #[inline(always)]
204    pub unsafe fn bits(self, value: u8) -> &'a mut W {
205        self.w.bits = (self.w.bits & !0x0f) | ((value as u32) & 0x0f);
206        self.w
207    }
208}
209#[doc = "SS1 Trigger Select\n\nValue on reset: 0"]
210#[derive(Clone, Copy, Debug, PartialEq)]
211#[repr(u8)]
212pub enum EM1_A {
213    #[doc = "0: Processor (default)"]
214    PROCESSOR = 0,
215    #[doc = "1: Analog Comparator 0"]
216    COMP0 = 1,
217    #[doc = "2: Analog Comparator 1"]
218    COMP1 = 2,
219    #[doc = "3: Analog Comparator 2"]
220    COMP2 = 3,
221    #[doc = "4: External (GPIO Pins)"]
222    EXTERNAL = 4,
223    #[doc = "5: Timer"]
224    TIMER = 5,
225    #[doc = "6: PWM generator 0"]
226    PWM0 = 6,
227    #[doc = "7: PWM generator 1"]
228    PWM1 = 7,
229    #[doc = "8: PWM generator 2"]
230    PWM2 = 8,
231    #[doc = "9: PWM generator 3"]
232    PWM3 = 9,
233    #[doc = "14: Never Trigger"]
234    NEVER = 14,
235    #[doc = "15: Always (continuously sample)"]
236    ALWAYS = 15,
237}
238impl From<EM1_A> for u8 {
239    #[inline(always)]
240    fn from(variant: EM1_A) -> Self {
241        variant as _
242    }
243}
244#[doc = "Reader of field `EM1`"]
245pub type EM1_R = crate::R<u8, EM1_A>;
246impl EM1_R {
247    #[doc = r"Get enumerated values variant"]
248    #[inline(always)]
249    pub fn variant(&self) -> crate::Variant<u8, EM1_A> {
250        use crate::Variant::*;
251        match self.bits {
252            0 => Val(EM1_A::PROCESSOR),
253            1 => Val(EM1_A::COMP0),
254            2 => Val(EM1_A::COMP1),
255            3 => Val(EM1_A::COMP2),
256            4 => Val(EM1_A::EXTERNAL),
257            5 => Val(EM1_A::TIMER),
258            6 => Val(EM1_A::PWM0),
259            7 => Val(EM1_A::PWM1),
260            8 => Val(EM1_A::PWM2),
261            9 => Val(EM1_A::PWM3),
262            14 => Val(EM1_A::NEVER),
263            15 => Val(EM1_A::ALWAYS),
264            i => Res(i),
265        }
266    }
267    #[doc = "Checks if the value of the field is `PROCESSOR`"]
268    #[inline(always)]
269    pub fn is_processor(&self) -> bool {
270        *self == EM1_A::PROCESSOR
271    }
272    #[doc = "Checks if the value of the field is `COMP0`"]
273    #[inline(always)]
274    pub fn is_comp0(&self) -> bool {
275        *self == EM1_A::COMP0
276    }
277    #[doc = "Checks if the value of the field is `COMP1`"]
278    #[inline(always)]
279    pub fn is_comp1(&self) -> bool {
280        *self == EM1_A::COMP1
281    }
282    #[doc = "Checks if the value of the field is `COMP2`"]
283    #[inline(always)]
284    pub fn is_comp2(&self) -> bool {
285        *self == EM1_A::COMP2
286    }
287    #[doc = "Checks if the value of the field is `EXTERNAL`"]
288    #[inline(always)]
289    pub fn is_external(&self) -> bool {
290        *self == EM1_A::EXTERNAL
291    }
292    #[doc = "Checks if the value of the field is `TIMER`"]
293    #[inline(always)]
294    pub fn is_timer(&self) -> bool {
295        *self == EM1_A::TIMER
296    }
297    #[doc = "Checks if the value of the field is `PWM0`"]
298    #[inline(always)]
299    pub fn is_pwm0(&self) -> bool {
300        *self == EM1_A::PWM0
301    }
302    #[doc = "Checks if the value of the field is `PWM1`"]
303    #[inline(always)]
304    pub fn is_pwm1(&self) -> bool {
305        *self == EM1_A::PWM1
306    }
307    #[doc = "Checks if the value of the field is `PWM2`"]
308    #[inline(always)]
309    pub fn is_pwm2(&self) -> bool {
310        *self == EM1_A::PWM2
311    }
312    #[doc = "Checks if the value of the field is `PWM3`"]
313    #[inline(always)]
314    pub fn is_pwm3(&self) -> bool {
315        *self == EM1_A::PWM3
316    }
317    #[doc = "Checks if the value of the field is `NEVER`"]
318    #[inline(always)]
319    pub fn is_never(&self) -> bool {
320        *self == EM1_A::NEVER
321    }
322    #[doc = "Checks if the value of the field is `ALWAYS`"]
323    #[inline(always)]
324    pub fn is_always(&self) -> bool {
325        *self == EM1_A::ALWAYS
326    }
327}
328#[doc = "Write proxy for field `EM1`"]
329pub struct EM1_W<'a> {
330    w: &'a mut W,
331}
332impl<'a> EM1_W<'a> {
333    #[doc = r"Writes `variant` to the field"]
334    #[inline(always)]
335    pub fn variant(self, variant: EM1_A) -> &'a mut W {
336        unsafe { self.bits(variant.into()) }
337    }
338    #[doc = "Processor (default)"]
339    #[inline(always)]
340    pub fn processor(self) -> &'a mut W {
341        self.variant(EM1_A::PROCESSOR)
342    }
343    #[doc = "Analog Comparator 0"]
344    #[inline(always)]
345    pub fn comp0(self) -> &'a mut W {
346        self.variant(EM1_A::COMP0)
347    }
348    #[doc = "Analog Comparator 1"]
349    #[inline(always)]
350    pub fn comp1(self) -> &'a mut W {
351        self.variant(EM1_A::COMP1)
352    }
353    #[doc = "Analog Comparator 2"]
354    #[inline(always)]
355    pub fn comp2(self) -> &'a mut W {
356        self.variant(EM1_A::COMP2)
357    }
358    #[doc = "External (GPIO Pins)"]
359    #[inline(always)]
360    pub fn external(self) -> &'a mut W {
361        self.variant(EM1_A::EXTERNAL)
362    }
363    #[doc = "Timer"]
364    #[inline(always)]
365    pub fn timer(self) -> &'a mut W {
366        self.variant(EM1_A::TIMER)
367    }
368    #[doc = "PWM generator 0"]
369    #[inline(always)]
370    pub fn pwm0(self) -> &'a mut W {
371        self.variant(EM1_A::PWM0)
372    }
373    #[doc = "PWM generator 1"]
374    #[inline(always)]
375    pub fn pwm1(self) -> &'a mut W {
376        self.variant(EM1_A::PWM1)
377    }
378    #[doc = "PWM generator 2"]
379    #[inline(always)]
380    pub fn pwm2(self) -> &'a mut W {
381        self.variant(EM1_A::PWM2)
382    }
383    #[doc = "PWM generator 3"]
384    #[inline(always)]
385    pub fn pwm3(self) -> &'a mut W {
386        self.variant(EM1_A::PWM3)
387    }
388    #[doc = "Never Trigger"]
389    #[inline(always)]
390    pub fn never(self) -> &'a mut W {
391        self.variant(EM1_A::NEVER)
392    }
393    #[doc = "Always (continuously sample)"]
394    #[inline(always)]
395    pub fn always(self) -> &'a mut W {
396        self.variant(EM1_A::ALWAYS)
397    }
398    #[doc = r"Writes raw bits to the field"]
399    #[inline(always)]
400    pub unsafe fn bits(self, value: u8) -> &'a mut W {
401        self.w.bits = (self.w.bits & !(0x0f << 4)) | (((value as u32) & 0x0f) << 4);
402        self.w
403    }
404}
405#[doc = "SS2 Trigger Select\n\nValue on reset: 0"]
406#[derive(Clone, Copy, Debug, PartialEq)]
407#[repr(u8)]
408pub enum EM2_A {
409    #[doc = "0: Processor (default)"]
410    PROCESSOR = 0,
411    #[doc = "1: Analog Comparator 0"]
412    COMP0 = 1,
413    #[doc = "2: Analog Comparator 1"]
414    COMP1 = 2,
415    #[doc = "3: Analog Comparator 2"]
416    COMP2 = 3,
417    #[doc = "4: External (GPIO Pins)"]
418    EXTERNAL = 4,
419    #[doc = "5: Timer"]
420    TIMER = 5,
421    #[doc = "6: PWM generator 0"]
422    PWM0 = 6,
423    #[doc = "7: PWM generator 1"]
424    PWM1 = 7,
425    #[doc = "8: PWM generator 2"]
426    PWM2 = 8,
427    #[doc = "9: PWM generator 3"]
428    PWM3 = 9,
429    #[doc = "14: Never Trigger"]
430    NEVER = 14,
431    #[doc = "15: Always (continuously sample)"]
432    ALWAYS = 15,
433}
434impl From<EM2_A> for u8 {
435    #[inline(always)]
436    fn from(variant: EM2_A) -> Self {
437        variant as _
438    }
439}
440#[doc = "Reader of field `EM2`"]
441pub type EM2_R = crate::R<u8, EM2_A>;
442impl EM2_R {
443    #[doc = r"Get enumerated values variant"]
444    #[inline(always)]
445    pub fn variant(&self) -> crate::Variant<u8, EM2_A> {
446        use crate::Variant::*;
447        match self.bits {
448            0 => Val(EM2_A::PROCESSOR),
449            1 => Val(EM2_A::COMP0),
450            2 => Val(EM2_A::COMP1),
451            3 => Val(EM2_A::COMP2),
452            4 => Val(EM2_A::EXTERNAL),
453            5 => Val(EM2_A::TIMER),
454            6 => Val(EM2_A::PWM0),
455            7 => Val(EM2_A::PWM1),
456            8 => Val(EM2_A::PWM2),
457            9 => Val(EM2_A::PWM3),
458            14 => Val(EM2_A::NEVER),
459            15 => Val(EM2_A::ALWAYS),
460            i => Res(i),
461        }
462    }
463    #[doc = "Checks if the value of the field is `PROCESSOR`"]
464    #[inline(always)]
465    pub fn is_processor(&self) -> bool {
466        *self == EM2_A::PROCESSOR
467    }
468    #[doc = "Checks if the value of the field is `COMP0`"]
469    #[inline(always)]
470    pub fn is_comp0(&self) -> bool {
471        *self == EM2_A::COMP0
472    }
473    #[doc = "Checks if the value of the field is `COMP1`"]
474    #[inline(always)]
475    pub fn is_comp1(&self) -> bool {
476        *self == EM2_A::COMP1
477    }
478    #[doc = "Checks if the value of the field is `COMP2`"]
479    #[inline(always)]
480    pub fn is_comp2(&self) -> bool {
481        *self == EM2_A::COMP2
482    }
483    #[doc = "Checks if the value of the field is `EXTERNAL`"]
484    #[inline(always)]
485    pub fn is_external(&self) -> bool {
486        *self == EM2_A::EXTERNAL
487    }
488    #[doc = "Checks if the value of the field is `TIMER`"]
489    #[inline(always)]
490    pub fn is_timer(&self) -> bool {
491        *self == EM2_A::TIMER
492    }
493    #[doc = "Checks if the value of the field is `PWM0`"]
494    #[inline(always)]
495    pub fn is_pwm0(&self) -> bool {
496        *self == EM2_A::PWM0
497    }
498    #[doc = "Checks if the value of the field is `PWM1`"]
499    #[inline(always)]
500    pub fn is_pwm1(&self) -> bool {
501        *self == EM2_A::PWM1
502    }
503    #[doc = "Checks if the value of the field is `PWM2`"]
504    #[inline(always)]
505    pub fn is_pwm2(&self) -> bool {
506        *self == EM2_A::PWM2
507    }
508    #[doc = "Checks if the value of the field is `PWM3`"]
509    #[inline(always)]
510    pub fn is_pwm3(&self) -> bool {
511        *self == EM2_A::PWM3
512    }
513    #[doc = "Checks if the value of the field is `NEVER`"]
514    #[inline(always)]
515    pub fn is_never(&self) -> bool {
516        *self == EM2_A::NEVER
517    }
518    #[doc = "Checks if the value of the field is `ALWAYS`"]
519    #[inline(always)]
520    pub fn is_always(&self) -> bool {
521        *self == EM2_A::ALWAYS
522    }
523}
524#[doc = "Write proxy for field `EM2`"]
525pub struct EM2_W<'a> {
526    w: &'a mut W,
527}
528impl<'a> EM2_W<'a> {
529    #[doc = r"Writes `variant` to the field"]
530    #[inline(always)]
531    pub fn variant(self, variant: EM2_A) -> &'a mut W {
532        unsafe { self.bits(variant.into()) }
533    }
534    #[doc = "Processor (default)"]
535    #[inline(always)]
536    pub fn processor(self) -> &'a mut W {
537        self.variant(EM2_A::PROCESSOR)
538    }
539    #[doc = "Analog Comparator 0"]
540    #[inline(always)]
541    pub fn comp0(self) -> &'a mut W {
542        self.variant(EM2_A::COMP0)
543    }
544    #[doc = "Analog Comparator 1"]
545    #[inline(always)]
546    pub fn comp1(self) -> &'a mut W {
547        self.variant(EM2_A::COMP1)
548    }
549    #[doc = "Analog Comparator 2"]
550    #[inline(always)]
551    pub fn comp2(self) -> &'a mut W {
552        self.variant(EM2_A::COMP2)
553    }
554    #[doc = "External (GPIO Pins)"]
555    #[inline(always)]
556    pub fn external(self) -> &'a mut W {
557        self.variant(EM2_A::EXTERNAL)
558    }
559    #[doc = "Timer"]
560    #[inline(always)]
561    pub fn timer(self) -> &'a mut W {
562        self.variant(EM2_A::TIMER)
563    }
564    #[doc = "PWM generator 0"]
565    #[inline(always)]
566    pub fn pwm0(self) -> &'a mut W {
567        self.variant(EM2_A::PWM0)
568    }
569    #[doc = "PWM generator 1"]
570    #[inline(always)]
571    pub fn pwm1(self) -> &'a mut W {
572        self.variant(EM2_A::PWM1)
573    }
574    #[doc = "PWM generator 2"]
575    #[inline(always)]
576    pub fn pwm2(self) -> &'a mut W {
577        self.variant(EM2_A::PWM2)
578    }
579    #[doc = "PWM generator 3"]
580    #[inline(always)]
581    pub fn pwm3(self) -> &'a mut W {
582        self.variant(EM2_A::PWM3)
583    }
584    #[doc = "Never Trigger"]
585    #[inline(always)]
586    pub fn never(self) -> &'a mut W {
587        self.variant(EM2_A::NEVER)
588    }
589    #[doc = "Always (continuously sample)"]
590    #[inline(always)]
591    pub fn always(self) -> &'a mut W {
592        self.variant(EM2_A::ALWAYS)
593    }
594    #[doc = r"Writes raw bits to the field"]
595    #[inline(always)]
596    pub unsafe fn bits(self, value: u8) -> &'a mut W {
597        self.w.bits = (self.w.bits & !(0x0f << 8)) | (((value as u32) & 0x0f) << 8);
598        self.w
599    }
600}
601#[doc = "SS3 Trigger Select\n\nValue on reset: 0"]
602#[derive(Clone, Copy, Debug, PartialEq)]
603#[repr(u8)]
604pub enum EM3_A {
605    #[doc = "0: Processor (default)"]
606    PROCESSOR = 0,
607    #[doc = "1: Analog Comparator 0"]
608    COMP0 = 1,
609    #[doc = "2: Analog Comparator 1"]
610    COMP1 = 2,
611    #[doc = "3: Analog Comparator 2"]
612    COMP2 = 3,
613    #[doc = "4: External (GPIO Pins)"]
614    EXTERNAL = 4,
615    #[doc = "5: Timer"]
616    TIMER = 5,
617    #[doc = "6: PWM generator 0"]
618    PWM0 = 6,
619    #[doc = "7: PWM generator 1"]
620    PWM1 = 7,
621    #[doc = "8: PWM generator 2"]
622    PWM2 = 8,
623    #[doc = "9: PWM generator 3"]
624    PWM3 = 9,
625    #[doc = "14: Never Trigger"]
626    NEVER = 14,
627    #[doc = "15: Always (continuously sample)"]
628    ALWAYS = 15,
629}
630impl From<EM3_A> for u8 {
631    #[inline(always)]
632    fn from(variant: EM3_A) -> Self {
633        variant as _
634    }
635}
636#[doc = "Reader of field `EM3`"]
637pub type EM3_R = crate::R<u8, EM3_A>;
638impl EM3_R {
639    #[doc = r"Get enumerated values variant"]
640    #[inline(always)]
641    pub fn variant(&self) -> crate::Variant<u8, EM3_A> {
642        use crate::Variant::*;
643        match self.bits {
644            0 => Val(EM3_A::PROCESSOR),
645            1 => Val(EM3_A::COMP0),
646            2 => Val(EM3_A::COMP1),
647            3 => Val(EM3_A::COMP2),
648            4 => Val(EM3_A::EXTERNAL),
649            5 => Val(EM3_A::TIMER),
650            6 => Val(EM3_A::PWM0),
651            7 => Val(EM3_A::PWM1),
652            8 => Val(EM3_A::PWM2),
653            9 => Val(EM3_A::PWM3),
654            14 => Val(EM3_A::NEVER),
655            15 => Val(EM3_A::ALWAYS),
656            i => Res(i),
657        }
658    }
659    #[doc = "Checks if the value of the field is `PROCESSOR`"]
660    #[inline(always)]
661    pub fn is_processor(&self) -> bool {
662        *self == EM3_A::PROCESSOR
663    }
664    #[doc = "Checks if the value of the field is `COMP0`"]
665    #[inline(always)]
666    pub fn is_comp0(&self) -> bool {
667        *self == EM3_A::COMP0
668    }
669    #[doc = "Checks if the value of the field is `COMP1`"]
670    #[inline(always)]
671    pub fn is_comp1(&self) -> bool {
672        *self == EM3_A::COMP1
673    }
674    #[doc = "Checks if the value of the field is `COMP2`"]
675    #[inline(always)]
676    pub fn is_comp2(&self) -> bool {
677        *self == EM3_A::COMP2
678    }
679    #[doc = "Checks if the value of the field is `EXTERNAL`"]
680    #[inline(always)]
681    pub fn is_external(&self) -> bool {
682        *self == EM3_A::EXTERNAL
683    }
684    #[doc = "Checks if the value of the field is `TIMER`"]
685    #[inline(always)]
686    pub fn is_timer(&self) -> bool {
687        *self == EM3_A::TIMER
688    }
689    #[doc = "Checks if the value of the field is `PWM0`"]
690    #[inline(always)]
691    pub fn is_pwm0(&self) -> bool {
692        *self == EM3_A::PWM0
693    }
694    #[doc = "Checks if the value of the field is `PWM1`"]
695    #[inline(always)]
696    pub fn is_pwm1(&self) -> bool {
697        *self == EM3_A::PWM1
698    }
699    #[doc = "Checks if the value of the field is `PWM2`"]
700    #[inline(always)]
701    pub fn is_pwm2(&self) -> bool {
702        *self == EM3_A::PWM2
703    }
704    #[doc = "Checks if the value of the field is `PWM3`"]
705    #[inline(always)]
706    pub fn is_pwm3(&self) -> bool {
707        *self == EM3_A::PWM3
708    }
709    #[doc = "Checks if the value of the field is `NEVER`"]
710    #[inline(always)]
711    pub fn is_never(&self) -> bool {
712        *self == EM3_A::NEVER
713    }
714    #[doc = "Checks if the value of the field is `ALWAYS`"]
715    #[inline(always)]
716    pub fn is_always(&self) -> bool {
717        *self == EM3_A::ALWAYS
718    }
719}
720#[doc = "Write proxy for field `EM3`"]
721pub struct EM3_W<'a> {
722    w: &'a mut W,
723}
724impl<'a> EM3_W<'a> {
725    #[doc = r"Writes `variant` to the field"]
726    #[inline(always)]
727    pub fn variant(self, variant: EM3_A) -> &'a mut W {
728        unsafe { self.bits(variant.into()) }
729    }
730    #[doc = "Processor (default)"]
731    #[inline(always)]
732    pub fn processor(self) -> &'a mut W {
733        self.variant(EM3_A::PROCESSOR)
734    }
735    #[doc = "Analog Comparator 0"]
736    #[inline(always)]
737    pub fn comp0(self) -> &'a mut W {
738        self.variant(EM3_A::COMP0)
739    }
740    #[doc = "Analog Comparator 1"]
741    #[inline(always)]
742    pub fn comp1(self) -> &'a mut W {
743        self.variant(EM3_A::COMP1)
744    }
745    #[doc = "Analog Comparator 2"]
746    #[inline(always)]
747    pub fn comp2(self) -> &'a mut W {
748        self.variant(EM3_A::COMP2)
749    }
750    #[doc = "External (GPIO Pins)"]
751    #[inline(always)]
752    pub fn external(self) -> &'a mut W {
753        self.variant(EM3_A::EXTERNAL)
754    }
755    #[doc = "Timer"]
756    #[inline(always)]
757    pub fn timer(self) -> &'a mut W {
758        self.variant(EM3_A::TIMER)
759    }
760    #[doc = "PWM generator 0"]
761    #[inline(always)]
762    pub fn pwm0(self) -> &'a mut W {
763        self.variant(EM3_A::PWM0)
764    }
765    #[doc = "PWM generator 1"]
766    #[inline(always)]
767    pub fn pwm1(self) -> &'a mut W {
768        self.variant(EM3_A::PWM1)
769    }
770    #[doc = "PWM generator 2"]
771    #[inline(always)]
772    pub fn pwm2(self) -> &'a mut W {
773        self.variant(EM3_A::PWM2)
774    }
775    #[doc = "PWM generator 3"]
776    #[inline(always)]
777    pub fn pwm3(self) -> &'a mut W {
778        self.variant(EM3_A::PWM3)
779    }
780    #[doc = "Never Trigger"]
781    #[inline(always)]
782    pub fn never(self) -> &'a mut W {
783        self.variant(EM3_A::NEVER)
784    }
785    #[doc = "Always (continuously sample)"]
786    #[inline(always)]
787    pub fn always(self) -> &'a mut W {
788        self.variant(EM3_A::ALWAYS)
789    }
790    #[doc = r"Writes raw bits to the field"]
791    #[inline(always)]
792    pub unsafe fn bits(self, value: u8) -> &'a mut W {
793        self.w.bits = (self.w.bits & !(0x0f << 12)) | (((value as u32) & 0x0f) << 12);
794        self.w
795    }
796}
797impl R {
798    #[doc = "Bits 0:3 - SS0 Trigger Select"]
799    #[inline(always)]
800    pub fn em0(&self) -> EM0_R {
801        EM0_R::new((self.bits & 0x0f) as u8)
802    }
803    #[doc = "Bits 4:7 - SS1 Trigger Select"]
804    #[inline(always)]
805    pub fn em1(&self) -> EM1_R {
806        EM1_R::new(((self.bits >> 4) & 0x0f) as u8)
807    }
808    #[doc = "Bits 8:11 - SS2 Trigger Select"]
809    #[inline(always)]
810    pub fn em2(&self) -> EM2_R {
811        EM2_R::new(((self.bits >> 8) & 0x0f) as u8)
812    }
813    #[doc = "Bits 12:15 - SS3 Trigger Select"]
814    #[inline(always)]
815    pub fn em3(&self) -> EM3_R {
816        EM3_R::new(((self.bits >> 12) & 0x0f) as u8)
817    }
818}
819impl W {
820    #[doc = "Bits 0:3 - SS0 Trigger Select"]
821    #[inline(always)]
822    pub fn em0(&mut self) -> EM0_W {
823        EM0_W { w: self }
824    }
825    #[doc = "Bits 4:7 - SS1 Trigger Select"]
826    #[inline(always)]
827    pub fn em1(&mut self) -> EM1_W {
828        EM1_W { w: self }
829    }
830    #[doc = "Bits 8:11 - SS2 Trigger Select"]
831    #[inline(always)]
832    pub fn em2(&mut self) -> EM2_W {
833        EM2_W { w: self }
834    }
835    #[doc = "Bits 12:15 - SS3 Trigger Select"]
836    #[inline(always)]
837    pub fn em3(&mut self) -> EM3_W {
838        EM3_W { w: self }
839    }
840}