1#[doc = r" Value read from the register"]
2pub struct R {
3 bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7 bits: u32,
8}
9impl super::INTENCLR {
10 #[doc = r" Modifies the contents of the register"]
11 #[inline]
12 pub fn modify<F>(&self, f: F)
13 where
14 for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15 {
16 let bits = self.register.get();
17 let r = R { bits: bits };
18 let mut w = W { bits: bits };
19 f(&r, &mut w);
20 self.register.set(w.bits);
21 }
22 #[doc = r" Reads the contents of the register"]
23 #[inline]
24 pub fn read(&self) -> R {
25 R {
26 bits: self.register.get(),
27 }
28 }
29 #[doc = r" Writes to the register"]
30 #[inline]
31 pub fn write<F>(&self, f: F)
32 where
33 F: FnOnce(&mut W) -> &mut W,
34 {
35 let mut w = W::reset_value();
36 f(&mut w);
37 self.register.set(w.bits);
38 }
39 #[doc = r" Writes the reset value to the register"]
40 #[inline]
41 pub fn reset(&self) {
42 self.write(|w| w)
43 }
44}
45#[doc = "Possible values of the field `TRIGGERED0`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum TRIGGERED0R {
48 #[doc = "Read: Disabled"]
49 DISABLED,
50 #[doc = "Read: Enabled"]
51 ENABLED,
52}
53impl TRIGGERED0R {
54 #[doc = r" Returns `true` if the bit is clear (0)"]
55 #[inline]
56 pub fn bit_is_clear(&self) -> bool {
57 !self.bit()
58 }
59 #[doc = r" Returns `true` if the bit is set (1)"]
60 #[inline]
61 pub fn bit_is_set(&self) -> bool {
62 self.bit()
63 }
64 #[doc = r" Value of the field as raw bits"]
65 #[inline]
66 pub fn bit(&self) -> bool {
67 match *self {
68 TRIGGERED0R::DISABLED => false,
69 TRIGGERED0R::ENABLED => true,
70 }
71 }
72 #[allow(missing_docs)]
73 #[doc(hidden)]
74 #[inline]
75 pub fn _from(value: bool) -> TRIGGERED0R {
76 match value {
77 false => TRIGGERED0R::DISABLED,
78 true => TRIGGERED0R::ENABLED,
79 }
80 }
81 #[doc = "Checks if the value of the field is `DISABLED`"]
82 #[inline]
83 pub fn is_disabled(&self) -> bool {
84 *self == TRIGGERED0R::DISABLED
85 }
86 #[doc = "Checks if the value of the field is `ENABLED`"]
87 #[inline]
88 pub fn is_enabled(&self) -> bool {
89 *self == TRIGGERED0R::ENABLED
90 }
91}
92#[doc = "Possible values of the field `TRIGGERED1`"]
93#[derive(Clone, Copy, Debug, PartialEq)]
94pub enum TRIGGERED1R {
95 #[doc = "Read: Disabled"]
96 DISABLED,
97 #[doc = "Read: Enabled"]
98 ENABLED,
99}
100impl TRIGGERED1R {
101 #[doc = r" Returns `true` if the bit is clear (0)"]
102 #[inline]
103 pub fn bit_is_clear(&self) -> bool {
104 !self.bit()
105 }
106 #[doc = r" Returns `true` if the bit is set (1)"]
107 #[inline]
108 pub fn bit_is_set(&self) -> bool {
109 self.bit()
110 }
111 #[doc = r" Value of the field as raw bits"]
112 #[inline]
113 pub fn bit(&self) -> bool {
114 match *self {
115 TRIGGERED1R::DISABLED => false,
116 TRIGGERED1R::ENABLED => true,
117 }
118 }
119 #[allow(missing_docs)]
120 #[doc(hidden)]
121 #[inline]
122 pub fn _from(value: bool) -> TRIGGERED1R {
123 match value {
124 false => TRIGGERED1R::DISABLED,
125 true => TRIGGERED1R::ENABLED,
126 }
127 }
128 #[doc = "Checks if the value of the field is `DISABLED`"]
129 #[inline]
130 pub fn is_disabled(&self) -> bool {
131 *self == TRIGGERED1R::DISABLED
132 }
133 #[doc = "Checks if the value of the field is `ENABLED`"]
134 #[inline]
135 pub fn is_enabled(&self) -> bool {
136 *self == TRIGGERED1R::ENABLED
137 }
138}
139#[doc = "Possible values of the field `TRIGGERED2`"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141pub enum TRIGGERED2R {
142 #[doc = "Read: Disabled"]
143 DISABLED,
144 #[doc = "Read: Enabled"]
145 ENABLED,
146}
147impl TRIGGERED2R {
148 #[doc = r" Returns `true` if the bit is clear (0)"]
149 #[inline]
150 pub fn bit_is_clear(&self) -> bool {
151 !self.bit()
152 }
153 #[doc = r" Returns `true` if the bit is set (1)"]
154 #[inline]
155 pub fn bit_is_set(&self) -> bool {
156 self.bit()
157 }
158 #[doc = r" Value of the field as raw bits"]
159 #[inline]
160 pub fn bit(&self) -> bool {
161 match *self {
162 TRIGGERED2R::DISABLED => false,
163 TRIGGERED2R::ENABLED => true,
164 }
165 }
166 #[allow(missing_docs)]
167 #[doc(hidden)]
168 #[inline]
169 pub fn _from(value: bool) -> TRIGGERED2R {
170 match value {
171 false => TRIGGERED2R::DISABLED,
172 true => TRIGGERED2R::ENABLED,
173 }
174 }
175 #[doc = "Checks if the value of the field is `DISABLED`"]
176 #[inline]
177 pub fn is_disabled(&self) -> bool {
178 *self == TRIGGERED2R::DISABLED
179 }
180 #[doc = "Checks if the value of the field is `ENABLED`"]
181 #[inline]
182 pub fn is_enabled(&self) -> bool {
183 *self == TRIGGERED2R::ENABLED
184 }
185}
186#[doc = "Possible values of the field `TRIGGERED3`"]
187#[derive(Clone, Copy, Debug, PartialEq)]
188pub enum TRIGGERED3R {
189 #[doc = "Read: Disabled"]
190 DISABLED,
191 #[doc = "Read: Enabled"]
192 ENABLED,
193}
194impl TRIGGERED3R {
195 #[doc = r" Returns `true` if the bit is clear (0)"]
196 #[inline]
197 pub fn bit_is_clear(&self) -> bool {
198 !self.bit()
199 }
200 #[doc = r" Returns `true` if the bit is set (1)"]
201 #[inline]
202 pub fn bit_is_set(&self) -> bool {
203 self.bit()
204 }
205 #[doc = r" Value of the field as raw bits"]
206 #[inline]
207 pub fn bit(&self) -> bool {
208 match *self {
209 TRIGGERED3R::DISABLED => false,
210 TRIGGERED3R::ENABLED => true,
211 }
212 }
213 #[allow(missing_docs)]
214 #[doc(hidden)]
215 #[inline]
216 pub fn _from(value: bool) -> TRIGGERED3R {
217 match value {
218 false => TRIGGERED3R::DISABLED,
219 true => TRIGGERED3R::ENABLED,
220 }
221 }
222 #[doc = "Checks if the value of the field is `DISABLED`"]
223 #[inline]
224 pub fn is_disabled(&self) -> bool {
225 *self == TRIGGERED3R::DISABLED
226 }
227 #[doc = "Checks if the value of the field is `ENABLED`"]
228 #[inline]
229 pub fn is_enabled(&self) -> bool {
230 *self == TRIGGERED3R::ENABLED
231 }
232}
233#[doc = "Possible values of the field `TRIGGERED4`"]
234#[derive(Clone, Copy, Debug, PartialEq)]
235pub enum TRIGGERED4R {
236 #[doc = "Read: Disabled"]
237 DISABLED,
238 #[doc = "Read: Enabled"]
239 ENABLED,
240}
241impl TRIGGERED4R {
242 #[doc = r" Returns `true` if the bit is clear (0)"]
243 #[inline]
244 pub fn bit_is_clear(&self) -> bool {
245 !self.bit()
246 }
247 #[doc = r" Returns `true` if the bit is set (1)"]
248 #[inline]
249 pub fn bit_is_set(&self) -> bool {
250 self.bit()
251 }
252 #[doc = r" Value of the field as raw bits"]
253 #[inline]
254 pub fn bit(&self) -> bool {
255 match *self {
256 TRIGGERED4R::DISABLED => false,
257 TRIGGERED4R::ENABLED => true,
258 }
259 }
260 #[allow(missing_docs)]
261 #[doc(hidden)]
262 #[inline]
263 pub fn _from(value: bool) -> TRIGGERED4R {
264 match value {
265 false => TRIGGERED4R::DISABLED,
266 true => TRIGGERED4R::ENABLED,
267 }
268 }
269 #[doc = "Checks if the value of the field is `DISABLED`"]
270 #[inline]
271 pub fn is_disabled(&self) -> bool {
272 *self == TRIGGERED4R::DISABLED
273 }
274 #[doc = "Checks if the value of the field is `ENABLED`"]
275 #[inline]
276 pub fn is_enabled(&self) -> bool {
277 *self == TRIGGERED4R::ENABLED
278 }
279}
280#[doc = "Possible values of the field `TRIGGERED5`"]
281#[derive(Clone, Copy, Debug, PartialEq)]
282pub enum TRIGGERED5R {
283 #[doc = "Read: Disabled"]
284 DISABLED,
285 #[doc = "Read: Enabled"]
286 ENABLED,
287}
288impl TRIGGERED5R {
289 #[doc = r" Returns `true` if the bit is clear (0)"]
290 #[inline]
291 pub fn bit_is_clear(&self) -> bool {
292 !self.bit()
293 }
294 #[doc = r" Returns `true` if the bit is set (1)"]
295 #[inline]
296 pub fn bit_is_set(&self) -> bool {
297 self.bit()
298 }
299 #[doc = r" Value of the field as raw bits"]
300 #[inline]
301 pub fn bit(&self) -> bool {
302 match *self {
303 TRIGGERED5R::DISABLED => false,
304 TRIGGERED5R::ENABLED => true,
305 }
306 }
307 #[allow(missing_docs)]
308 #[doc(hidden)]
309 #[inline]
310 pub fn _from(value: bool) -> TRIGGERED5R {
311 match value {
312 false => TRIGGERED5R::DISABLED,
313 true => TRIGGERED5R::ENABLED,
314 }
315 }
316 #[doc = "Checks if the value of the field is `DISABLED`"]
317 #[inline]
318 pub fn is_disabled(&self) -> bool {
319 *self == TRIGGERED5R::DISABLED
320 }
321 #[doc = "Checks if the value of the field is `ENABLED`"]
322 #[inline]
323 pub fn is_enabled(&self) -> bool {
324 *self == TRIGGERED5R::ENABLED
325 }
326}
327#[doc = "Possible values of the field `TRIGGERED6`"]
328#[derive(Clone, Copy, Debug, PartialEq)]
329pub enum TRIGGERED6R {
330 #[doc = "Read: Disabled"]
331 DISABLED,
332 #[doc = "Read: Enabled"]
333 ENABLED,
334}
335impl TRIGGERED6R {
336 #[doc = r" Returns `true` if the bit is clear (0)"]
337 #[inline]
338 pub fn bit_is_clear(&self) -> bool {
339 !self.bit()
340 }
341 #[doc = r" Returns `true` if the bit is set (1)"]
342 #[inline]
343 pub fn bit_is_set(&self) -> bool {
344 self.bit()
345 }
346 #[doc = r" Value of the field as raw bits"]
347 #[inline]
348 pub fn bit(&self) -> bool {
349 match *self {
350 TRIGGERED6R::DISABLED => false,
351 TRIGGERED6R::ENABLED => true,
352 }
353 }
354 #[allow(missing_docs)]
355 #[doc(hidden)]
356 #[inline]
357 pub fn _from(value: bool) -> TRIGGERED6R {
358 match value {
359 false => TRIGGERED6R::DISABLED,
360 true => TRIGGERED6R::ENABLED,
361 }
362 }
363 #[doc = "Checks if the value of the field is `DISABLED`"]
364 #[inline]
365 pub fn is_disabled(&self) -> bool {
366 *self == TRIGGERED6R::DISABLED
367 }
368 #[doc = "Checks if the value of the field is `ENABLED`"]
369 #[inline]
370 pub fn is_enabled(&self) -> bool {
371 *self == TRIGGERED6R::ENABLED
372 }
373}
374#[doc = "Possible values of the field `TRIGGERED7`"]
375#[derive(Clone, Copy, Debug, PartialEq)]
376pub enum TRIGGERED7R {
377 #[doc = "Read: Disabled"]
378 DISABLED,
379 #[doc = "Read: Enabled"]
380 ENABLED,
381}
382impl TRIGGERED7R {
383 #[doc = r" Returns `true` if the bit is clear (0)"]
384 #[inline]
385 pub fn bit_is_clear(&self) -> bool {
386 !self.bit()
387 }
388 #[doc = r" Returns `true` if the bit is set (1)"]
389 #[inline]
390 pub fn bit_is_set(&self) -> bool {
391 self.bit()
392 }
393 #[doc = r" Value of the field as raw bits"]
394 #[inline]
395 pub fn bit(&self) -> bool {
396 match *self {
397 TRIGGERED7R::DISABLED => false,
398 TRIGGERED7R::ENABLED => true,
399 }
400 }
401 #[allow(missing_docs)]
402 #[doc(hidden)]
403 #[inline]
404 pub fn _from(value: bool) -> TRIGGERED7R {
405 match value {
406 false => TRIGGERED7R::DISABLED,
407 true => TRIGGERED7R::ENABLED,
408 }
409 }
410 #[doc = "Checks if the value of the field is `DISABLED`"]
411 #[inline]
412 pub fn is_disabled(&self) -> bool {
413 *self == TRIGGERED7R::DISABLED
414 }
415 #[doc = "Checks if the value of the field is `ENABLED`"]
416 #[inline]
417 pub fn is_enabled(&self) -> bool {
418 *self == TRIGGERED7R::ENABLED
419 }
420}
421#[doc = "Possible values of the field `TRIGGERED8`"]
422#[derive(Clone, Copy, Debug, PartialEq)]
423pub enum TRIGGERED8R {
424 #[doc = "Read: Disabled"]
425 DISABLED,
426 #[doc = "Read: Enabled"]
427 ENABLED,
428}
429impl TRIGGERED8R {
430 #[doc = r" Returns `true` if the bit is clear (0)"]
431 #[inline]
432 pub fn bit_is_clear(&self) -> bool {
433 !self.bit()
434 }
435 #[doc = r" Returns `true` if the bit is set (1)"]
436 #[inline]
437 pub fn bit_is_set(&self) -> bool {
438 self.bit()
439 }
440 #[doc = r" Value of the field as raw bits"]
441 #[inline]
442 pub fn bit(&self) -> bool {
443 match *self {
444 TRIGGERED8R::DISABLED => false,
445 TRIGGERED8R::ENABLED => true,
446 }
447 }
448 #[allow(missing_docs)]
449 #[doc(hidden)]
450 #[inline]
451 pub fn _from(value: bool) -> TRIGGERED8R {
452 match value {
453 false => TRIGGERED8R::DISABLED,
454 true => TRIGGERED8R::ENABLED,
455 }
456 }
457 #[doc = "Checks if the value of the field is `DISABLED`"]
458 #[inline]
459 pub fn is_disabled(&self) -> bool {
460 *self == TRIGGERED8R::DISABLED
461 }
462 #[doc = "Checks if the value of the field is `ENABLED`"]
463 #[inline]
464 pub fn is_enabled(&self) -> bool {
465 *self == TRIGGERED8R::ENABLED
466 }
467}
468#[doc = "Possible values of the field `TRIGGERED9`"]
469#[derive(Clone, Copy, Debug, PartialEq)]
470pub enum TRIGGERED9R {
471 #[doc = "Read: Disabled"]
472 DISABLED,
473 #[doc = "Read: Enabled"]
474 ENABLED,
475}
476impl TRIGGERED9R {
477 #[doc = r" Returns `true` if the bit is clear (0)"]
478 #[inline]
479 pub fn bit_is_clear(&self) -> bool {
480 !self.bit()
481 }
482 #[doc = r" Returns `true` if the bit is set (1)"]
483 #[inline]
484 pub fn bit_is_set(&self) -> bool {
485 self.bit()
486 }
487 #[doc = r" Value of the field as raw bits"]
488 #[inline]
489 pub fn bit(&self) -> bool {
490 match *self {
491 TRIGGERED9R::DISABLED => false,
492 TRIGGERED9R::ENABLED => true,
493 }
494 }
495 #[allow(missing_docs)]
496 #[doc(hidden)]
497 #[inline]
498 pub fn _from(value: bool) -> TRIGGERED9R {
499 match value {
500 false => TRIGGERED9R::DISABLED,
501 true => TRIGGERED9R::ENABLED,
502 }
503 }
504 #[doc = "Checks if the value of the field is `DISABLED`"]
505 #[inline]
506 pub fn is_disabled(&self) -> bool {
507 *self == TRIGGERED9R::DISABLED
508 }
509 #[doc = "Checks if the value of the field is `ENABLED`"]
510 #[inline]
511 pub fn is_enabled(&self) -> bool {
512 *self == TRIGGERED9R::ENABLED
513 }
514}
515#[doc = "Possible values of the field `TRIGGERED10`"]
516#[derive(Clone, Copy, Debug, PartialEq)]
517pub enum TRIGGERED10R {
518 #[doc = "Read: Disabled"]
519 DISABLED,
520 #[doc = "Read: Enabled"]
521 ENABLED,
522}
523impl TRIGGERED10R {
524 #[doc = r" Returns `true` if the bit is clear (0)"]
525 #[inline]
526 pub fn bit_is_clear(&self) -> bool {
527 !self.bit()
528 }
529 #[doc = r" Returns `true` if the bit is set (1)"]
530 #[inline]
531 pub fn bit_is_set(&self) -> bool {
532 self.bit()
533 }
534 #[doc = r" Value of the field as raw bits"]
535 #[inline]
536 pub fn bit(&self) -> bool {
537 match *self {
538 TRIGGERED10R::DISABLED => false,
539 TRIGGERED10R::ENABLED => true,
540 }
541 }
542 #[allow(missing_docs)]
543 #[doc(hidden)]
544 #[inline]
545 pub fn _from(value: bool) -> TRIGGERED10R {
546 match value {
547 false => TRIGGERED10R::DISABLED,
548 true => TRIGGERED10R::ENABLED,
549 }
550 }
551 #[doc = "Checks if the value of the field is `DISABLED`"]
552 #[inline]
553 pub fn is_disabled(&self) -> bool {
554 *self == TRIGGERED10R::DISABLED
555 }
556 #[doc = "Checks if the value of the field is `ENABLED`"]
557 #[inline]
558 pub fn is_enabled(&self) -> bool {
559 *self == TRIGGERED10R::ENABLED
560 }
561}
562#[doc = "Possible values of the field `TRIGGERED11`"]
563#[derive(Clone, Copy, Debug, PartialEq)]
564pub enum TRIGGERED11R {
565 #[doc = "Read: Disabled"]
566 DISABLED,
567 #[doc = "Read: Enabled"]
568 ENABLED,
569}
570impl TRIGGERED11R {
571 #[doc = r" Returns `true` if the bit is clear (0)"]
572 #[inline]
573 pub fn bit_is_clear(&self) -> bool {
574 !self.bit()
575 }
576 #[doc = r" Returns `true` if the bit is set (1)"]
577 #[inline]
578 pub fn bit_is_set(&self) -> bool {
579 self.bit()
580 }
581 #[doc = r" Value of the field as raw bits"]
582 #[inline]
583 pub fn bit(&self) -> bool {
584 match *self {
585 TRIGGERED11R::DISABLED => false,
586 TRIGGERED11R::ENABLED => true,
587 }
588 }
589 #[allow(missing_docs)]
590 #[doc(hidden)]
591 #[inline]
592 pub fn _from(value: bool) -> TRIGGERED11R {
593 match value {
594 false => TRIGGERED11R::DISABLED,
595 true => TRIGGERED11R::ENABLED,
596 }
597 }
598 #[doc = "Checks if the value of the field is `DISABLED`"]
599 #[inline]
600 pub fn is_disabled(&self) -> bool {
601 *self == TRIGGERED11R::DISABLED
602 }
603 #[doc = "Checks if the value of the field is `ENABLED`"]
604 #[inline]
605 pub fn is_enabled(&self) -> bool {
606 *self == TRIGGERED11R::ENABLED
607 }
608}
609#[doc = "Possible values of the field `TRIGGERED12`"]
610#[derive(Clone, Copy, Debug, PartialEq)]
611pub enum TRIGGERED12R {
612 #[doc = "Read: Disabled"]
613 DISABLED,
614 #[doc = "Read: Enabled"]
615 ENABLED,
616}
617impl TRIGGERED12R {
618 #[doc = r" Returns `true` if the bit is clear (0)"]
619 #[inline]
620 pub fn bit_is_clear(&self) -> bool {
621 !self.bit()
622 }
623 #[doc = r" Returns `true` if the bit is set (1)"]
624 #[inline]
625 pub fn bit_is_set(&self) -> bool {
626 self.bit()
627 }
628 #[doc = r" Value of the field as raw bits"]
629 #[inline]
630 pub fn bit(&self) -> bool {
631 match *self {
632 TRIGGERED12R::DISABLED => false,
633 TRIGGERED12R::ENABLED => true,
634 }
635 }
636 #[allow(missing_docs)]
637 #[doc(hidden)]
638 #[inline]
639 pub fn _from(value: bool) -> TRIGGERED12R {
640 match value {
641 false => TRIGGERED12R::DISABLED,
642 true => TRIGGERED12R::ENABLED,
643 }
644 }
645 #[doc = "Checks if the value of the field is `DISABLED`"]
646 #[inline]
647 pub fn is_disabled(&self) -> bool {
648 *self == TRIGGERED12R::DISABLED
649 }
650 #[doc = "Checks if the value of the field is `ENABLED`"]
651 #[inline]
652 pub fn is_enabled(&self) -> bool {
653 *self == TRIGGERED12R::ENABLED
654 }
655}
656#[doc = "Possible values of the field `TRIGGERED13`"]
657#[derive(Clone, Copy, Debug, PartialEq)]
658pub enum TRIGGERED13R {
659 #[doc = "Read: Disabled"]
660 DISABLED,
661 #[doc = "Read: Enabled"]
662 ENABLED,
663}
664impl TRIGGERED13R {
665 #[doc = r" Returns `true` if the bit is clear (0)"]
666 #[inline]
667 pub fn bit_is_clear(&self) -> bool {
668 !self.bit()
669 }
670 #[doc = r" Returns `true` if the bit is set (1)"]
671 #[inline]
672 pub fn bit_is_set(&self) -> bool {
673 self.bit()
674 }
675 #[doc = r" Value of the field as raw bits"]
676 #[inline]
677 pub fn bit(&self) -> bool {
678 match *self {
679 TRIGGERED13R::DISABLED => false,
680 TRIGGERED13R::ENABLED => true,
681 }
682 }
683 #[allow(missing_docs)]
684 #[doc(hidden)]
685 #[inline]
686 pub fn _from(value: bool) -> TRIGGERED13R {
687 match value {
688 false => TRIGGERED13R::DISABLED,
689 true => TRIGGERED13R::ENABLED,
690 }
691 }
692 #[doc = "Checks if the value of the field is `DISABLED`"]
693 #[inline]
694 pub fn is_disabled(&self) -> bool {
695 *self == TRIGGERED13R::DISABLED
696 }
697 #[doc = "Checks if the value of the field is `ENABLED`"]
698 #[inline]
699 pub fn is_enabled(&self) -> bool {
700 *self == TRIGGERED13R::ENABLED
701 }
702}
703#[doc = "Possible values of the field `TRIGGERED14`"]
704#[derive(Clone, Copy, Debug, PartialEq)]
705pub enum TRIGGERED14R {
706 #[doc = "Read: Disabled"]
707 DISABLED,
708 #[doc = "Read: Enabled"]
709 ENABLED,
710}
711impl TRIGGERED14R {
712 #[doc = r" Returns `true` if the bit is clear (0)"]
713 #[inline]
714 pub fn bit_is_clear(&self) -> bool {
715 !self.bit()
716 }
717 #[doc = r" Returns `true` if the bit is set (1)"]
718 #[inline]
719 pub fn bit_is_set(&self) -> bool {
720 self.bit()
721 }
722 #[doc = r" Value of the field as raw bits"]
723 #[inline]
724 pub fn bit(&self) -> bool {
725 match *self {
726 TRIGGERED14R::DISABLED => false,
727 TRIGGERED14R::ENABLED => true,
728 }
729 }
730 #[allow(missing_docs)]
731 #[doc(hidden)]
732 #[inline]
733 pub fn _from(value: bool) -> TRIGGERED14R {
734 match value {
735 false => TRIGGERED14R::DISABLED,
736 true => TRIGGERED14R::ENABLED,
737 }
738 }
739 #[doc = "Checks if the value of the field is `DISABLED`"]
740 #[inline]
741 pub fn is_disabled(&self) -> bool {
742 *self == TRIGGERED14R::DISABLED
743 }
744 #[doc = "Checks if the value of the field is `ENABLED`"]
745 #[inline]
746 pub fn is_enabled(&self) -> bool {
747 *self == TRIGGERED14R::ENABLED
748 }
749}
750#[doc = "Possible values of the field `TRIGGERED15`"]
751#[derive(Clone, Copy, Debug, PartialEq)]
752pub enum TRIGGERED15R {
753 #[doc = "Read: Disabled"]
754 DISABLED,
755 #[doc = "Read: Enabled"]
756 ENABLED,
757}
758impl TRIGGERED15R {
759 #[doc = r" Returns `true` if the bit is clear (0)"]
760 #[inline]
761 pub fn bit_is_clear(&self) -> bool {
762 !self.bit()
763 }
764 #[doc = r" Returns `true` if the bit is set (1)"]
765 #[inline]
766 pub fn bit_is_set(&self) -> bool {
767 self.bit()
768 }
769 #[doc = r" Value of the field as raw bits"]
770 #[inline]
771 pub fn bit(&self) -> bool {
772 match *self {
773 TRIGGERED15R::DISABLED => false,
774 TRIGGERED15R::ENABLED => true,
775 }
776 }
777 #[allow(missing_docs)]
778 #[doc(hidden)]
779 #[inline]
780 pub fn _from(value: bool) -> TRIGGERED15R {
781 match value {
782 false => TRIGGERED15R::DISABLED,
783 true => TRIGGERED15R::ENABLED,
784 }
785 }
786 #[doc = "Checks if the value of the field is `DISABLED`"]
787 #[inline]
788 pub fn is_disabled(&self) -> bool {
789 *self == TRIGGERED15R::DISABLED
790 }
791 #[doc = "Checks if the value of the field is `ENABLED`"]
792 #[inline]
793 pub fn is_enabled(&self) -> bool {
794 *self == TRIGGERED15R::ENABLED
795 }
796}
797#[doc = "Values that can be written to the field `TRIGGERED0`"]
798pub enum TRIGGERED0W {
799 #[doc = "Disable"]
800 CLEAR,
801}
802impl TRIGGERED0W {
803 #[allow(missing_docs)]
804 #[doc(hidden)]
805 #[inline]
806 pub fn _bits(&self) -> bool {
807 match *self {
808 TRIGGERED0W::CLEAR => true,
809 }
810 }
811}
812#[doc = r" Proxy"]
813pub struct _TRIGGERED0W<'a> {
814 w: &'a mut W,
815}
816impl<'a> _TRIGGERED0W<'a> {
817 #[doc = r" Writes `variant` to the field"]
818 #[inline]
819 pub fn variant(self, variant: TRIGGERED0W) -> &'a mut W {
820 {
821 self.bit(variant._bits())
822 }
823 }
824 #[doc = "Disable"]
825 #[inline]
826 pub fn clear(self) -> &'a mut W {
827 self.variant(TRIGGERED0W::CLEAR)
828 }
829 #[doc = r" Sets the field bit"]
830 pub fn set_bit(self) -> &'a mut W {
831 self.bit(true)
832 }
833 #[doc = r" Clears the field bit"]
834 pub fn clear_bit(self) -> &'a mut W {
835 self.bit(false)
836 }
837 #[doc = r" Writes raw bits to the field"]
838 #[inline]
839 pub fn bit(self, value: bool) -> &'a mut W {
840 const MASK: bool = true;
841 const OFFSET: u8 = 0;
842 self.w.bits &= !((MASK as u32) << OFFSET);
843 self.w.bits |= ((value & MASK) as u32) << OFFSET;
844 self.w
845 }
846}
847#[doc = "Values that can be written to the field `TRIGGERED1`"]
848pub enum TRIGGERED1W {
849 #[doc = "Disable"]
850 CLEAR,
851}
852impl TRIGGERED1W {
853 #[allow(missing_docs)]
854 #[doc(hidden)]
855 #[inline]
856 pub fn _bits(&self) -> bool {
857 match *self {
858 TRIGGERED1W::CLEAR => true,
859 }
860 }
861}
862#[doc = r" Proxy"]
863pub struct _TRIGGERED1W<'a> {
864 w: &'a mut W,
865}
866impl<'a> _TRIGGERED1W<'a> {
867 #[doc = r" Writes `variant` to the field"]
868 #[inline]
869 pub fn variant(self, variant: TRIGGERED1W) -> &'a mut W {
870 {
871 self.bit(variant._bits())
872 }
873 }
874 #[doc = "Disable"]
875 #[inline]
876 pub fn clear(self) -> &'a mut W {
877 self.variant(TRIGGERED1W::CLEAR)
878 }
879 #[doc = r" Sets the field bit"]
880 pub fn set_bit(self) -> &'a mut W {
881 self.bit(true)
882 }
883 #[doc = r" Clears the field bit"]
884 pub fn clear_bit(self) -> &'a mut W {
885 self.bit(false)
886 }
887 #[doc = r" Writes raw bits to the field"]
888 #[inline]
889 pub fn bit(self, value: bool) -> &'a mut W {
890 const MASK: bool = true;
891 const OFFSET: u8 = 1;
892 self.w.bits &= !((MASK as u32) << OFFSET);
893 self.w.bits |= ((value & MASK) as u32) << OFFSET;
894 self.w
895 }
896}
897#[doc = "Values that can be written to the field `TRIGGERED2`"]
898pub enum TRIGGERED2W {
899 #[doc = "Disable"]
900 CLEAR,
901}
902impl TRIGGERED2W {
903 #[allow(missing_docs)]
904 #[doc(hidden)]
905 #[inline]
906 pub fn _bits(&self) -> bool {
907 match *self {
908 TRIGGERED2W::CLEAR => true,
909 }
910 }
911}
912#[doc = r" Proxy"]
913pub struct _TRIGGERED2W<'a> {
914 w: &'a mut W,
915}
916impl<'a> _TRIGGERED2W<'a> {
917 #[doc = r" Writes `variant` to the field"]
918 #[inline]
919 pub fn variant(self, variant: TRIGGERED2W) -> &'a mut W {
920 {
921 self.bit(variant._bits())
922 }
923 }
924 #[doc = "Disable"]
925 #[inline]
926 pub fn clear(self) -> &'a mut W {
927 self.variant(TRIGGERED2W::CLEAR)
928 }
929 #[doc = r" Sets the field bit"]
930 pub fn set_bit(self) -> &'a mut W {
931 self.bit(true)
932 }
933 #[doc = r" Clears the field bit"]
934 pub fn clear_bit(self) -> &'a mut W {
935 self.bit(false)
936 }
937 #[doc = r" Writes raw bits to the field"]
938 #[inline]
939 pub fn bit(self, value: bool) -> &'a mut W {
940 const MASK: bool = true;
941 const OFFSET: u8 = 2;
942 self.w.bits &= !((MASK as u32) << OFFSET);
943 self.w.bits |= ((value & MASK) as u32) << OFFSET;
944 self.w
945 }
946}
947#[doc = "Values that can be written to the field `TRIGGERED3`"]
948pub enum TRIGGERED3W {
949 #[doc = "Disable"]
950 CLEAR,
951}
952impl TRIGGERED3W {
953 #[allow(missing_docs)]
954 #[doc(hidden)]
955 #[inline]
956 pub fn _bits(&self) -> bool {
957 match *self {
958 TRIGGERED3W::CLEAR => true,
959 }
960 }
961}
962#[doc = r" Proxy"]
963pub struct _TRIGGERED3W<'a> {
964 w: &'a mut W,
965}
966impl<'a> _TRIGGERED3W<'a> {
967 #[doc = r" Writes `variant` to the field"]
968 #[inline]
969 pub fn variant(self, variant: TRIGGERED3W) -> &'a mut W {
970 {
971 self.bit(variant._bits())
972 }
973 }
974 #[doc = "Disable"]
975 #[inline]
976 pub fn clear(self) -> &'a mut W {
977 self.variant(TRIGGERED3W::CLEAR)
978 }
979 #[doc = r" Sets the field bit"]
980 pub fn set_bit(self) -> &'a mut W {
981 self.bit(true)
982 }
983 #[doc = r" Clears the field bit"]
984 pub fn clear_bit(self) -> &'a mut W {
985 self.bit(false)
986 }
987 #[doc = r" Writes raw bits to the field"]
988 #[inline]
989 pub fn bit(self, value: bool) -> &'a mut W {
990 const MASK: bool = true;
991 const OFFSET: u8 = 3;
992 self.w.bits &= !((MASK as u32) << OFFSET);
993 self.w.bits |= ((value & MASK) as u32) << OFFSET;
994 self.w
995 }
996}
997#[doc = "Values that can be written to the field `TRIGGERED4`"]
998pub enum TRIGGERED4W {
999 #[doc = "Disable"]
1000 CLEAR,
1001}
1002impl TRIGGERED4W {
1003 #[allow(missing_docs)]
1004 #[doc(hidden)]
1005 #[inline]
1006 pub fn _bits(&self) -> bool {
1007 match *self {
1008 TRIGGERED4W::CLEAR => true,
1009 }
1010 }
1011}
1012#[doc = r" Proxy"]
1013pub struct _TRIGGERED4W<'a> {
1014 w: &'a mut W,
1015}
1016impl<'a> _TRIGGERED4W<'a> {
1017 #[doc = r" Writes `variant` to the field"]
1018 #[inline]
1019 pub fn variant(self, variant: TRIGGERED4W) -> &'a mut W {
1020 {
1021 self.bit(variant._bits())
1022 }
1023 }
1024 #[doc = "Disable"]
1025 #[inline]
1026 pub fn clear(self) -> &'a mut W {
1027 self.variant(TRIGGERED4W::CLEAR)
1028 }
1029 #[doc = r" Sets the field bit"]
1030 pub fn set_bit(self) -> &'a mut W {
1031 self.bit(true)
1032 }
1033 #[doc = r" Clears the field bit"]
1034 pub fn clear_bit(self) -> &'a mut W {
1035 self.bit(false)
1036 }
1037 #[doc = r" Writes raw bits to the field"]
1038 #[inline]
1039 pub fn bit(self, value: bool) -> &'a mut W {
1040 const MASK: bool = true;
1041 const OFFSET: u8 = 4;
1042 self.w.bits &= !((MASK as u32) << OFFSET);
1043 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1044 self.w
1045 }
1046}
1047#[doc = "Values that can be written to the field `TRIGGERED5`"]
1048pub enum TRIGGERED5W {
1049 #[doc = "Disable"]
1050 CLEAR,
1051}
1052impl TRIGGERED5W {
1053 #[allow(missing_docs)]
1054 #[doc(hidden)]
1055 #[inline]
1056 pub fn _bits(&self) -> bool {
1057 match *self {
1058 TRIGGERED5W::CLEAR => true,
1059 }
1060 }
1061}
1062#[doc = r" Proxy"]
1063pub struct _TRIGGERED5W<'a> {
1064 w: &'a mut W,
1065}
1066impl<'a> _TRIGGERED5W<'a> {
1067 #[doc = r" Writes `variant` to the field"]
1068 #[inline]
1069 pub fn variant(self, variant: TRIGGERED5W) -> &'a mut W {
1070 {
1071 self.bit(variant._bits())
1072 }
1073 }
1074 #[doc = "Disable"]
1075 #[inline]
1076 pub fn clear(self) -> &'a mut W {
1077 self.variant(TRIGGERED5W::CLEAR)
1078 }
1079 #[doc = r" Sets the field bit"]
1080 pub fn set_bit(self) -> &'a mut W {
1081 self.bit(true)
1082 }
1083 #[doc = r" Clears the field bit"]
1084 pub fn clear_bit(self) -> &'a mut W {
1085 self.bit(false)
1086 }
1087 #[doc = r" Writes raw bits to the field"]
1088 #[inline]
1089 pub fn bit(self, value: bool) -> &'a mut W {
1090 const MASK: bool = true;
1091 const OFFSET: u8 = 5;
1092 self.w.bits &= !((MASK as u32) << OFFSET);
1093 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1094 self.w
1095 }
1096}
1097#[doc = "Values that can be written to the field `TRIGGERED6`"]
1098pub enum TRIGGERED6W {
1099 #[doc = "Disable"]
1100 CLEAR,
1101}
1102impl TRIGGERED6W {
1103 #[allow(missing_docs)]
1104 #[doc(hidden)]
1105 #[inline]
1106 pub fn _bits(&self) -> bool {
1107 match *self {
1108 TRIGGERED6W::CLEAR => true,
1109 }
1110 }
1111}
1112#[doc = r" Proxy"]
1113pub struct _TRIGGERED6W<'a> {
1114 w: &'a mut W,
1115}
1116impl<'a> _TRIGGERED6W<'a> {
1117 #[doc = r" Writes `variant` to the field"]
1118 #[inline]
1119 pub fn variant(self, variant: TRIGGERED6W) -> &'a mut W {
1120 {
1121 self.bit(variant._bits())
1122 }
1123 }
1124 #[doc = "Disable"]
1125 #[inline]
1126 pub fn clear(self) -> &'a mut W {
1127 self.variant(TRIGGERED6W::CLEAR)
1128 }
1129 #[doc = r" Sets the field bit"]
1130 pub fn set_bit(self) -> &'a mut W {
1131 self.bit(true)
1132 }
1133 #[doc = r" Clears the field bit"]
1134 pub fn clear_bit(self) -> &'a mut W {
1135 self.bit(false)
1136 }
1137 #[doc = r" Writes raw bits to the field"]
1138 #[inline]
1139 pub fn bit(self, value: bool) -> &'a mut W {
1140 const MASK: bool = true;
1141 const OFFSET: u8 = 6;
1142 self.w.bits &= !((MASK as u32) << OFFSET);
1143 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1144 self.w
1145 }
1146}
1147#[doc = "Values that can be written to the field `TRIGGERED7`"]
1148pub enum TRIGGERED7W {
1149 #[doc = "Disable"]
1150 CLEAR,
1151}
1152impl TRIGGERED7W {
1153 #[allow(missing_docs)]
1154 #[doc(hidden)]
1155 #[inline]
1156 pub fn _bits(&self) -> bool {
1157 match *self {
1158 TRIGGERED7W::CLEAR => true,
1159 }
1160 }
1161}
1162#[doc = r" Proxy"]
1163pub struct _TRIGGERED7W<'a> {
1164 w: &'a mut W,
1165}
1166impl<'a> _TRIGGERED7W<'a> {
1167 #[doc = r" Writes `variant` to the field"]
1168 #[inline]
1169 pub fn variant(self, variant: TRIGGERED7W) -> &'a mut W {
1170 {
1171 self.bit(variant._bits())
1172 }
1173 }
1174 #[doc = "Disable"]
1175 #[inline]
1176 pub fn clear(self) -> &'a mut W {
1177 self.variant(TRIGGERED7W::CLEAR)
1178 }
1179 #[doc = r" Sets the field bit"]
1180 pub fn set_bit(self) -> &'a mut W {
1181 self.bit(true)
1182 }
1183 #[doc = r" Clears the field bit"]
1184 pub fn clear_bit(self) -> &'a mut W {
1185 self.bit(false)
1186 }
1187 #[doc = r" Writes raw bits to the field"]
1188 #[inline]
1189 pub fn bit(self, value: bool) -> &'a mut W {
1190 const MASK: bool = true;
1191 const OFFSET: u8 = 7;
1192 self.w.bits &= !((MASK as u32) << OFFSET);
1193 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1194 self.w
1195 }
1196}
1197#[doc = "Values that can be written to the field `TRIGGERED8`"]
1198pub enum TRIGGERED8W {
1199 #[doc = "Disable"]
1200 CLEAR,
1201}
1202impl TRIGGERED8W {
1203 #[allow(missing_docs)]
1204 #[doc(hidden)]
1205 #[inline]
1206 pub fn _bits(&self) -> bool {
1207 match *self {
1208 TRIGGERED8W::CLEAR => true,
1209 }
1210 }
1211}
1212#[doc = r" Proxy"]
1213pub struct _TRIGGERED8W<'a> {
1214 w: &'a mut W,
1215}
1216impl<'a> _TRIGGERED8W<'a> {
1217 #[doc = r" Writes `variant` to the field"]
1218 #[inline]
1219 pub fn variant(self, variant: TRIGGERED8W) -> &'a mut W {
1220 {
1221 self.bit(variant._bits())
1222 }
1223 }
1224 #[doc = "Disable"]
1225 #[inline]
1226 pub fn clear(self) -> &'a mut W {
1227 self.variant(TRIGGERED8W::CLEAR)
1228 }
1229 #[doc = r" Sets the field bit"]
1230 pub fn set_bit(self) -> &'a mut W {
1231 self.bit(true)
1232 }
1233 #[doc = r" Clears the field bit"]
1234 pub fn clear_bit(self) -> &'a mut W {
1235 self.bit(false)
1236 }
1237 #[doc = r" Writes raw bits to the field"]
1238 #[inline]
1239 pub fn bit(self, value: bool) -> &'a mut W {
1240 const MASK: bool = true;
1241 const OFFSET: u8 = 8;
1242 self.w.bits &= !((MASK as u32) << OFFSET);
1243 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1244 self.w
1245 }
1246}
1247#[doc = "Values that can be written to the field `TRIGGERED9`"]
1248pub enum TRIGGERED9W {
1249 #[doc = "Disable"]
1250 CLEAR,
1251}
1252impl TRIGGERED9W {
1253 #[allow(missing_docs)]
1254 #[doc(hidden)]
1255 #[inline]
1256 pub fn _bits(&self) -> bool {
1257 match *self {
1258 TRIGGERED9W::CLEAR => true,
1259 }
1260 }
1261}
1262#[doc = r" Proxy"]
1263pub struct _TRIGGERED9W<'a> {
1264 w: &'a mut W,
1265}
1266impl<'a> _TRIGGERED9W<'a> {
1267 #[doc = r" Writes `variant` to the field"]
1268 #[inline]
1269 pub fn variant(self, variant: TRIGGERED9W) -> &'a mut W {
1270 {
1271 self.bit(variant._bits())
1272 }
1273 }
1274 #[doc = "Disable"]
1275 #[inline]
1276 pub fn clear(self) -> &'a mut W {
1277 self.variant(TRIGGERED9W::CLEAR)
1278 }
1279 #[doc = r" Sets the field bit"]
1280 pub fn set_bit(self) -> &'a mut W {
1281 self.bit(true)
1282 }
1283 #[doc = r" Clears the field bit"]
1284 pub fn clear_bit(self) -> &'a mut W {
1285 self.bit(false)
1286 }
1287 #[doc = r" Writes raw bits to the field"]
1288 #[inline]
1289 pub fn bit(self, value: bool) -> &'a mut W {
1290 const MASK: bool = true;
1291 const OFFSET: u8 = 9;
1292 self.w.bits &= !((MASK as u32) << OFFSET);
1293 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1294 self.w
1295 }
1296}
1297#[doc = "Values that can be written to the field `TRIGGERED10`"]
1298pub enum TRIGGERED10W {
1299 #[doc = "Disable"]
1300 CLEAR,
1301}
1302impl TRIGGERED10W {
1303 #[allow(missing_docs)]
1304 #[doc(hidden)]
1305 #[inline]
1306 pub fn _bits(&self) -> bool {
1307 match *self {
1308 TRIGGERED10W::CLEAR => true,
1309 }
1310 }
1311}
1312#[doc = r" Proxy"]
1313pub struct _TRIGGERED10W<'a> {
1314 w: &'a mut W,
1315}
1316impl<'a> _TRIGGERED10W<'a> {
1317 #[doc = r" Writes `variant` to the field"]
1318 #[inline]
1319 pub fn variant(self, variant: TRIGGERED10W) -> &'a mut W {
1320 {
1321 self.bit(variant._bits())
1322 }
1323 }
1324 #[doc = "Disable"]
1325 #[inline]
1326 pub fn clear(self) -> &'a mut W {
1327 self.variant(TRIGGERED10W::CLEAR)
1328 }
1329 #[doc = r" Sets the field bit"]
1330 pub fn set_bit(self) -> &'a mut W {
1331 self.bit(true)
1332 }
1333 #[doc = r" Clears the field bit"]
1334 pub fn clear_bit(self) -> &'a mut W {
1335 self.bit(false)
1336 }
1337 #[doc = r" Writes raw bits to the field"]
1338 #[inline]
1339 pub fn bit(self, value: bool) -> &'a mut W {
1340 const MASK: bool = true;
1341 const OFFSET: u8 = 10;
1342 self.w.bits &= !((MASK as u32) << OFFSET);
1343 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1344 self.w
1345 }
1346}
1347#[doc = "Values that can be written to the field `TRIGGERED11`"]
1348pub enum TRIGGERED11W {
1349 #[doc = "Disable"]
1350 CLEAR,
1351}
1352impl TRIGGERED11W {
1353 #[allow(missing_docs)]
1354 #[doc(hidden)]
1355 #[inline]
1356 pub fn _bits(&self) -> bool {
1357 match *self {
1358 TRIGGERED11W::CLEAR => true,
1359 }
1360 }
1361}
1362#[doc = r" Proxy"]
1363pub struct _TRIGGERED11W<'a> {
1364 w: &'a mut W,
1365}
1366impl<'a> _TRIGGERED11W<'a> {
1367 #[doc = r" Writes `variant` to the field"]
1368 #[inline]
1369 pub fn variant(self, variant: TRIGGERED11W) -> &'a mut W {
1370 {
1371 self.bit(variant._bits())
1372 }
1373 }
1374 #[doc = "Disable"]
1375 #[inline]
1376 pub fn clear(self) -> &'a mut W {
1377 self.variant(TRIGGERED11W::CLEAR)
1378 }
1379 #[doc = r" Sets the field bit"]
1380 pub fn set_bit(self) -> &'a mut W {
1381 self.bit(true)
1382 }
1383 #[doc = r" Clears the field bit"]
1384 pub fn clear_bit(self) -> &'a mut W {
1385 self.bit(false)
1386 }
1387 #[doc = r" Writes raw bits to the field"]
1388 #[inline]
1389 pub fn bit(self, value: bool) -> &'a mut W {
1390 const MASK: bool = true;
1391 const OFFSET: u8 = 11;
1392 self.w.bits &= !((MASK as u32) << OFFSET);
1393 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1394 self.w
1395 }
1396}
1397#[doc = "Values that can be written to the field `TRIGGERED12`"]
1398pub enum TRIGGERED12W {
1399 #[doc = "Disable"]
1400 CLEAR,
1401}
1402impl TRIGGERED12W {
1403 #[allow(missing_docs)]
1404 #[doc(hidden)]
1405 #[inline]
1406 pub fn _bits(&self) -> bool {
1407 match *self {
1408 TRIGGERED12W::CLEAR => true,
1409 }
1410 }
1411}
1412#[doc = r" Proxy"]
1413pub struct _TRIGGERED12W<'a> {
1414 w: &'a mut W,
1415}
1416impl<'a> _TRIGGERED12W<'a> {
1417 #[doc = r" Writes `variant` to the field"]
1418 #[inline]
1419 pub fn variant(self, variant: TRIGGERED12W) -> &'a mut W {
1420 {
1421 self.bit(variant._bits())
1422 }
1423 }
1424 #[doc = "Disable"]
1425 #[inline]
1426 pub fn clear(self) -> &'a mut W {
1427 self.variant(TRIGGERED12W::CLEAR)
1428 }
1429 #[doc = r" Sets the field bit"]
1430 pub fn set_bit(self) -> &'a mut W {
1431 self.bit(true)
1432 }
1433 #[doc = r" Clears the field bit"]
1434 pub fn clear_bit(self) -> &'a mut W {
1435 self.bit(false)
1436 }
1437 #[doc = r" Writes raw bits to the field"]
1438 #[inline]
1439 pub fn bit(self, value: bool) -> &'a mut W {
1440 const MASK: bool = true;
1441 const OFFSET: u8 = 12;
1442 self.w.bits &= !((MASK as u32) << OFFSET);
1443 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1444 self.w
1445 }
1446}
1447#[doc = "Values that can be written to the field `TRIGGERED13`"]
1448pub enum TRIGGERED13W {
1449 #[doc = "Disable"]
1450 CLEAR,
1451}
1452impl TRIGGERED13W {
1453 #[allow(missing_docs)]
1454 #[doc(hidden)]
1455 #[inline]
1456 pub fn _bits(&self) -> bool {
1457 match *self {
1458 TRIGGERED13W::CLEAR => true,
1459 }
1460 }
1461}
1462#[doc = r" Proxy"]
1463pub struct _TRIGGERED13W<'a> {
1464 w: &'a mut W,
1465}
1466impl<'a> _TRIGGERED13W<'a> {
1467 #[doc = r" Writes `variant` to the field"]
1468 #[inline]
1469 pub fn variant(self, variant: TRIGGERED13W) -> &'a mut W {
1470 {
1471 self.bit(variant._bits())
1472 }
1473 }
1474 #[doc = "Disable"]
1475 #[inline]
1476 pub fn clear(self) -> &'a mut W {
1477 self.variant(TRIGGERED13W::CLEAR)
1478 }
1479 #[doc = r" Sets the field bit"]
1480 pub fn set_bit(self) -> &'a mut W {
1481 self.bit(true)
1482 }
1483 #[doc = r" Clears the field bit"]
1484 pub fn clear_bit(self) -> &'a mut W {
1485 self.bit(false)
1486 }
1487 #[doc = r" Writes raw bits to the field"]
1488 #[inline]
1489 pub fn bit(self, value: bool) -> &'a mut W {
1490 const MASK: bool = true;
1491 const OFFSET: u8 = 13;
1492 self.w.bits &= !((MASK as u32) << OFFSET);
1493 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1494 self.w
1495 }
1496}
1497#[doc = "Values that can be written to the field `TRIGGERED14`"]
1498pub enum TRIGGERED14W {
1499 #[doc = "Disable"]
1500 CLEAR,
1501}
1502impl TRIGGERED14W {
1503 #[allow(missing_docs)]
1504 #[doc(hidden)]
1505 #[inline]
1506 pub fn _bits(&self) -> bool {
1507 match *self {
1508 TRIGGERED14W::CLEAR => true,
1509 }
1510 }
1511}
1512#[doc = r" Proxy"]
1513pub struct _TRIGGERED14W<'a> {
1514 w: &'a mut W,
1515}
1516impl<'a> _TRIGGERED14W<'a> {
1517 #[doc = r" Writes `variant` to the field"]
1518 #[inline]
1519 pub fn variant(self, variant: TRIGGERED14W) -> &'a mut W {
1520 {
1521 self.bit(variant._bits())
1522 }
1523 }
1524 #[doc = "Disable"]
1525 #[inline]
1526 pub fn clear(self) -> &'a mut W {
1527 self.variant(TRIGGERED14W::CLEAR)
1528 }
1529 #[doc = r" Sets the field bit"]
1530 pub fn set_bit(self) -> &'a mut W {
1531 self.bit(true)
1532 }
1533 #[doc = r" Clears the field bit"]
1534 pub fn clear_bit(self) -> &'a mut W {
1535 self.bit(false)
1536 }
1537 #[doc = r" Writes raw bits to the field"]
1538 #[inline]
1539 pub fn bit(self, value: bool) -> &'a mut W {
1540 const MASK: bool = true;
1541 const OFFSET: u8 = 14;
1542 self.w.bits &= !((MASK as u32) << OFFSET);
1543 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1544 self.w
1545 }
1546}
1547#[doc = "Values that can be written to the field `TRIGGERED15`"]
1548pub enum TRIGGERED15W {
1549 #[doc = "Disable"]
1550 CLEAR,
1551}
1552impl TRIGGERED15W {
1553 #[allow(missing_docs)]
1554 #[doc(hidden)]
1555 #[inline]
1556 pub fn _bits(&self) -> bool {
1557 match *self {
1558 TRIGGERED15W::CLEAR => true,
1559 }
1560 }
1561}
1562#[doc = r" Proxy"]
1563pub struct _TRIGGERED15W<'a> {
1564 w: &'a mut W,
1565}
1566impl<'a> _TRIGGERED15W<'a> {
1567 #[doc = r" Writes `variant` to the field"]
1568 #[inline]
1569 pub fn variant(self, variant: TRIGGERED15W) -> &'a mut W {
1570 {
1571 self.bit(variant._bits())
1572 }
1573 }
1574 #[doc = "Disable"]
1575 #[inline]
1576 pub fn clear(self) -> &'a mut W {
1577 self.variant(TRIGGERED15W::CLEAR)
1578 }
1579 #[doc = r" Sets the field bit"]
1580 pub fn set_bit(self) -> &'a mut W {
1581 self.bit(true)
1582 }
1583 #[doc = r" Clears the field bit"]
1584 pub fn clear_bit(self) -> &'a mut W {
1585 self.bit(false)
1586 }
1587 #[doc = r" Writes raw bits to the field"]
1588 #[inline]
1589 pub fn bit(self, value: bool) -> &'a mut W {
1590 const MASK: bool = true;
1591 const OFFSET: u8 = 15;
1592 self.w.bits &= !((MASK as u32) << OFFSET);
1593 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1594 self.w
1595 }
1596}
1597impl R {
1598 #[doc = r" Value of the register as raw bits"]
1599 #[inline]
1600 pub fn bits(&self) -> u32 {
1601 self.bits
1602 }
1603 #[doc = "Bit 0 - Write '1' to Disable interrupt for TRIGGERED[0] event"]
1604 #[inline]
1605 pub fn triggered0(&self) -> TRIGGERED0R {
1606 TRIGGERED0R::_from({
1607 const MASK: bool = true;
1608 const OFFSET: u8 = 0;
1609 ((self.bits >> OFFSET) & MASK as u32) != 0
1610 })
1611 }
1612 #[doc = "Bit 1 - Write '1' to Disable interrupt for TRIGGERED[1] event"]
1613 #[inline]
1614 pub fn triggered1(&self) -> TRIGGERED1R {
1615 TRIGGERED1R::_from({
1616 const MASK: bool = true;
1617 const OFFSET: u8 = 1;
1618 ((self.bits >> OFFSET) & MASK as u32) != 0
1619 })
1620 }
1621 #[doc = "Bit 2 - Write '1' to Disable interrupt for TRIGGERED[2] event"]
1622 #[inline]
1623 pub fn triggered2(&self) -> TRIGGERED2R {
1624 TRIGGERED2R::_from({
1625 const MASK: bool = true;
1626 const OFFSET: u8 = 2;
1627 ((self.bits >> OFFSET) & MASK as u32) != 0
1628 })
1629 }
1630 #[doc = "Bit 3 - Write '1' to Disable interrupt for TRIGGERED[3] event"]
1631 #[inline]
1632 pub fn triggered3(&self) -> TRIGGERED3R {
1633 TRIGGERED3R::_from({
1634 const MASK: bool = true;
1635 const OFFSET: u8 = 3;
1636 ((self.bits >> OFFSET) & MASK as u32) != 0
1637 })
1638 }
1639 #[doc = "Bit 4 - Write '1' to Disable interrupt for TRIGGERED[4] event"]
1640 #[inline]
1641 pub fn triggered4(&self) -> TRIGGERED4R {
1642 TRIGGERED4R::_from({
1643 const MASK: bool = true;
1644 const OFFSET: u8 = 4;
1645 ((self.bits >> OFFSET) & MASK as u32) != 0
1646 })
1647 }
1648 #[doc = "Bit 5 - Write '1' to Disable interrupt for TRIGGERED[5] event"]
1649 #[inline]
1650 pub fn triggered5(&self) -> TRIGGERED5R {
1651 TRIGGERED5R::_from({
1652 const MASK: bool = true;
1653 const OFFSET: u8 = 5;
1654 ((self.bits >> OFFSET) & MASK as u32) != 0
1655 })
1656 }
1657 #[doc = "Bit 6 - Write '1' to Disable interrupt for TRIGGERED[6] event"]
1658 #[inline]
1659 pub fn triggered6(&self) -> TRIGGERED6R {
1660 TRIGGERED6R::_from({
1661 const MASK: bool = true;
1662 const OFFSET: u8 = 6;
1663 ((self.bits >> OFFSET) & MASK as u32) != 0
1664 })
1665 }
1666 #[doc = "Bit 7 - Write '1' to Disable interrupt for TRIGGERED[7] event"]
1667 #[inline]
1668 pub fn triggered7(&self) -> TRIGGERED7R {
1669 TRIGGERED7R::_from({
1670 const MASK: bool = true;
1671 const OFFSET: u8 = 7;
1672 ((self.bits >> OFFSET) & MASK as u32) != 0
1673 })
1674 }
1675 #[doc = "Bit 8 - Write '1' to Disable interrupt for TRIGGERED[8] event"]
1676 #[inline]
1677 pub fn triggered8(&self) -> TRIGGERED8R {
1678 TRIGGERED8R::_from({
1679 const MASK: bool = true;
1680 const OFFSET: u8 = 8;
1681 ((self.bits >> OFFSET) & MASK as u32) != 0
1682 })
1683 }
1684 #[doc = "Bit 9 - Write '1' to Disable interrupt for TRIGGERED[9] event"]
1685 #[inline]
1686 pub fn triggered9(&self) -> TRIGGERED9R {
1687 TRIGGERED9R::_from({
1688 const MASK: bool = true;
1689 const OFFSET: u8 = 9;
1690 ((self.bits >> OFFSET) & MASK as u32) != 0
1691 })
1692 }
1693 #[doc = "Bit 10 - Write '1' to Disable interrupt for TRIGGERED[10] event"]
1694 #[inline]
1695 pub fn triggered10(&self) -> TRIGGERED10R {
1696 TRIGGERED10R::_from({
1697 const MASK: bool = true;
1698 const OFFSET: u8 = 10;
1699 ((self.bits >> OFFSET) & MASK as u32) != 0
1700 })
1701 }
1702 #[doc = "Bit 11 - Write '1' to Disable interrupt for TRIGGERED[11] event"]
1703 #[inline]
1704 pub fn triggered11(&self) -> TRIGGERED11R {
1705 TRIGGERED11R::_from({
1706 const MASK: bool = true;
1707 const OFFSET: u8 = 11;
1708 ((self.bits >> OFFSET) & MASK as u32) != 0
1709 })
1710 }
1711 #[doc = "Bit 12 - Write '1' to Disable interrupt for TRIGGERED[12] event"]
1712 #[inline]
1713 pub fn triggered12(&self) -> TRIGGERED12R {
1714 TRIGGERED12R::_from({
1715 const MASK: bool = true;
1716 const OFFSET: u8 = 12;
1717 ((self.bits >> OFFSET) & MASK as u32) != 0
1718 })
1719 }
1720 #[doc = "Bit 13 - Write '1' to Disable interrupt for TRIGGERED[13] event"]
1721 #[inline]
1722 pub fn triggered13(&self) -> TRIGGERED13R {
1723 TRIGGERED13R::_from({
1724 const MASK: bool = true;
1725 const OFFSET: u8 = 13;
1726 ((self.bits >> OFFSET) & MASK as u32) != 0
1727 })
1728 }
1729 #[doc = "Bit 14 - Write '1' to Disable interrupt for TRIGGERED[14] event"]
1730 #[inline]
1731 pub fn triggered14(&self) -> TRIGGERED14R {
1732 TRIGGERED14R::_from({
1733 const MASK: bool = true;
1734 const OFFSET: u8 = 14;
1735 ((self.bits >> OFFSET) & MASK as u32) != 0
1736 })
1737 }
1738 #[doc = "Bit 15 - Write '1' to Disable interrupt for TRIGGERED[15] event"]
1739 #[inline]
1740 pub fn triggered15(&self) -> TRIGGERED15R {
1741 TRIGGERED15R::_from({
1742 const MASK: bool = true;
1743 const OFFSET: u8 = 15;
1744 ((self.bits >> OFFSET) & MASK as u32) != 0
1745 })
1746 }
1747}
1748impl W {
1749 #[doc = r" Reset value of the register"]
1750 #[inline]
1751 pub fn reset_value() -> W {
1752 W { bits: 0 }
1753 }
1754 #[doc = r" Writes raw bits to the register"]
1755 #[inline]
1756 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1757 self.bits = bits;
1758 self
1759 }
1760 #[doc = "Bit 0 - Write '1' to Disable interrupt for TRIGGERED[0] event"]
1761 #[inline]
1762 pub fn triggered0(&mut self) -> _TRIGGERED0W {
1763 _TRIGGERED0W { w: self }
1764 }
1765 #[doc = "Bit 1 - Write '1' to Disable interrupt for TRIGGERED[1] event"]
1766 #[inline]
1767 pub fn triggered1(&mut self) -> _TRIGGERED1W {
1768 _TRIGGERED1W { w: self }
1769 }
1770 #[doc = "Bit 2 - Write '1' to Disable interrupt for TRIGGERED[2] event"]
1771 #[inline]
1772 pub fn triggered2(&mut self) -> _TRIGGERED2W {
1773 _TRIGGERED2W { w: self }
1774 }
1775 #[doc = "Bit 3 - Write '1' to Disable interrupt for TRIGGERED[3] event"]
1776 #[inline]
1777 pub fn triggered3(&mut self) -> _TRIGGERED3W {
1778 _TRIGGERED3W { w: self }
1779 }
1780 #[doc = "Bit 4 - Write '1' to Disable interrupt for TRIGGERED[4] event"]
1781 #[inline]
1782 pub fn triggered4(&mut self) -> _TRIGGERED4W {
1783 _TRIGGERED4W { w: self }
1784 }
1785 #[doc = "Bit 5 - Write '1' to Disable interrupt for TRIGGERED[5] event"]
1786 #[inline]
1787 pub fn triggered5(&mut self) -> _TRIGGERED5W {
1788 _TRIGGERED5W { w: self }
1789 }
1790 #[doc = "Bit 6 - Write '1' to Disable interrupt for TRIGGERED[6] event"]
1791 #[inline]
1792 pub fn triggered6(&mut self) -> _TRIGGERED6W {
1793 _TRIGGERED6W { w: self }
1794 }
1795 #[doc = "Bit 7 - Write '1' to Disable interrupt for TRIGGERED[7] event"]
1796 #[inline]
1797 pub fn triggered7(&mut self) -> _TRIGGERED7W {
1798 _TRIGGERED7W { w: self }
1799 }
1800 #[doc = "Bit 8 - Write '1' to Disable interrupt for TRIGGERED[8] event"]
1801 #[inline]
1802 pub fn triggered8(&mut self) -> _TRIGGERED8W {
1803 _TRIGGERED8W { w: self }
1804 }
1805 #[doc = "Bit 9 - Write '1' to Disable interrupt for TRIGGERED[9] event"]
1806 #[inline]
1807 pub fn triggered9(&mut self) -> _TRIGGERED9W {
1808 _TRIGGERED9W { w: self }
1809 }
1810 #[doc = "Bit 10 - Write '1' to Disable interrupt for TRIGGERED[10] event"]
1811 #[inline]
1812 pub fn triggered10(&mut self) -> _TRIGGERED10W {
1813 _TRIGGERED10W { w: self }
1814 }
1815 #[doc = "Bit 11 - Write '1' to Disable interrupt for TRIGGERED[11] event"]
1816 #[inline]
1817 pub fn triggered11(&mut self) -> _TRIGGERED11W {
1818 _TRIGGERED11W { w: self }
1819 }
1820 #[doc = "Bit 12 - Write '1' to Disable interrupt for TRIGGERED[12] event"]
1821 #[inline]
1822 pub fn triggered12(&mut self) -> _TRIGGERED12W {
1823 _TRIGGERED12W { w: self }
1824 }
1825 #[doc = "Bit 13 - Write '1' to Disable interrupt for TRIGGERED[13] event"]
1826 #[inline]
1827 pub fn triggered13(&mut self) -> _TRIGGERED13W {
1828 _TRIGGERED13W { w: self }
1829 }
1830 #[doc = "Bit 14 - Write '1' to Disable interrupt for TRIGGERED[14] event"]
1831 #[inline]
1832 pub fn triggered14(&mut self) -> _TRIGGERED14W {
1833 _TRIGGERED14W { w: self }
1834 }
1835 #[doc = "Bit 15 - Write '1' to Disable interrupt for TRIGGERED[15] event"]
1836 #[inline]
1837 pub fn triggered15(&mut self) -> _TRIGGERED15W {
1838 _TRIGGERED15W { w: self }
1839 }
1840}