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}