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