mk66f18/gpioa/
pdir.rs

1#[doc = "Reader of register PDIR"]
2pub type R = crate::R<u32, super::PDIR>;
3#[doc = "Port Data Input\n\nValue on reset: 0"]
4#[derive(Clone, Copy, Debug, PartialEq)]
5pub enum PDI0_A {
6    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
7    _0,
8    #[doc = "1: Pin logic level is logic 1."]
9    _1,
10}
11impl From<PDI0_A> for bool {
12    #[inline(always)]
13    fn from(variant: PDI0_A) -> Self {
14        match variant {
15            PDI0_A::_0 => false,
16            PDI0_A::_1 => true,
17        }
18    }
19}
20#[doc = "Reader of field `PDI0`"]
21pub type PDI0_R = crate::R<bool, PDI0_A>;
22impl PDI0_R {
23    #[doc = r"Get enumerated values variant"]
24    #[inline(always)]
25    pub fn variant(&self) -> PDI0_A {
26        match self.bits {
27            false => PDI0_A::_0,
28            true => PDI0_A::_1,
29        }
30    }
31    #[doc = "Checks if the value of the field is `_0`"]
32    #[inline(always)]
33    pub fn is_0(&self) -> bool {
34        *self == PDI0_A::_0
35    }
36    #[doc = "Checks if the value of the field is `_1`"]
37    #[inline(always)]
38    pub fn is_1(&self) -> bool {
39        *self == PDI0_A::_1
40    }
41}
42#[doc = "Port Data Input\n\nValue on reset: 0"]
43#[derive(Clone, Copy, Debug, PartialEq)]
44pub enum PDI1_A {
45    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
46    _0,
47    #[doc = "1: Pin logic level is logic 1."]
48    _1,
49}
50impl From<PDI1_A> for bool {
51    #[inline(always)]
52    fn from(variant: PDI1_A) -> Self {
53        match variant {
54            PDI1_A::_0 => false,
55            PDI1_A::_1 => true,
56        }
57    }
58}
59#[doc = "Reader of field `PDI1`"]
60pub type PDI1_R = crate::R<bool, PDI1_A>;
61impl PDI1_R {
62    #[doc = r"Get enumerated values variant"]
63    #[inline(always)]
64    pub fn variant(&self) -> PDI1_A {
65        match self.bits {
66            false => PDI1_A::_0,
67            true => PDI1_A::_1,
68        }
69    }
70    #[doc = "Checks if the value of the field is `_0`"]
71    #[inline(always)]
72    pub fn is_0(&self) -> bool {
73        *self == PDI1_A::_0
74    }
75    #[doc = "Checks if the value of the field is `_1`"]
76    #[inline(always)]
77    pub fn is_1(&self) -> bool {
78        *self == PDI1_A::_1
79    }
80}
81#[doc = "Port Data Input\n\nValue on reset: 0"]
82#[derive(Clone, Copy, Debug, PartialEq)]
83pub enum PDI2_A {
84    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
85    _0,
86    #[doc = "1: Pin logic level is logic 1."]
87    _1,
88}
89impl From<PDI2_A> for bool {
90    #[inline(always)]
91    fn from(variant: PDI2_A) -> Self {
92        match variant {
93            PDI2_A::_0 => false,
94            PDI2_A::_1 => true,
95        }
96    }
97}
98#[doc = "Reader of field `PDI2`"]
99pub type PDI2_R = crate::R<bool, PDI2_A>;
100impl PDI2_R {
101    #[doc = r"Get enumerated values variant"]
102    #[inline(always)]
103    pub fn variant(&self) -> PDI2_A {
104        match self.bits {
105            false => PDI2_A::_0,
106            true => PDI2_A::_1,
107        }
108    }
109    #[doc = "Checks if the value of the field is `_0`"]
110    #[inline(always)]
111    pub fn is_0(&self) -> bool {
112        *self == PDI2_A::_0
113    }
114    #[doc = "Checks if the value of the field is `_1`"]
115    #[inline(always)]
116    pub fn is_1(&self) -> bool {
117        *self == PDI2_A::_1
118    }
119}
120#[doc = "Port Data Input\n\nValue on reset: 0"]
121#[derive(Clone, Copy, Debug, PartialEq)]
122pub enum PDI3_A {
123    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
124    _0,
125    #[doc = "1: Pin logic level is logic 1."]
126    _1,
127}
128impl From<PDI3_A> for bool {
129    #[inline(always)]
130    fn from(variant: PDI3_A) -> Self {
131        match variant {
132            PDI3_A::_0 => false,
133            PDI3_A::_1 => true,
134        }
135    }
136}
137#[doc = "Reader of field `PDI3`"]
138pub type PDI3_R = crate::R<bool, PDI3_A>;
139impl PDI3_R {
140    #[doc = r"Get enumerated values variant"]
141    #[inline(always)]
142    pub fn variant(&self) -> PDI3_A {
143        match self.bits {
144            false => PDI3_A::_0,
145            true => PDI3_A::_1,
146        }
147    }
148    #[doc = "Checks if the value of the field is `_0`"]
149    #[inline(always)]
150    pub fn is_0(&self) -> bool {
151        *self == PDI3_A::_0
152    }
153    #[doc = "Checks if the value of the field is `_1`"]
154    #[inline(always)]
155    pub fn is_1(&self) -> bool {
156        *self == PDI3_A::_1
157    }
158}
159#[doc = "Port Data Input\n\nValue on reset: 0"]
160#[derive(Clone, Copy, Debug, PartialEq)]
161pub enum PDI4_A {
162    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
163    _0,
164    #[doc = "1: Pin logic level is logic 1."]
165    _1,
166}
167impl From<PDI4_A> for bool {
168    #[inline(always)]
169    fn from(variant: PDI4_A) -> Self {
170        match variant {
171            PDI4_A::_0 => false,
172            PDI4_A::_1 => true,
173        }
174    }
175}
176#[doc = "Reader of field `PDI4`"]
177pub type PDI4_R = crate::R<bool, PDI4_A>;
178impl PDI4_R {
179    #[doc = r"Get enumerated values variant"]
180    #[inline(always)]
181    pub fn variant(&self) -> PDI4_A {
182        match self.bits {
183            false => PDI4_A::_0,
184            true => PDI4_A::_1,
185        }
186    }
187    #[doc = "Checks if the value of the field is `_0`"]
188    #[inline(always)]
189    pub fn is_0(&self) -> bool {
190        *self == PDI4_A::_0
191    }
192    #[doc = "Checks if the value of the field is `_1`"]
193    #[inline(always)]
194    pub fn is_1(&self) -> bool {
195        *self == PDI4_A::_1
196    }
197}
198#[doc = "Port Data Input\n\nValue on reset: 0"]
199#[derive(Clone, Copy, Debug, PartialEq)]
200pub enum PDI5_A {
201    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
202    _0,
203    #[doc = "1: Pin logic level is logic 1."]
204    _1,
205}
206impl From<PDI5_A> for bool {
207    #[inline(always)]
208    fn from(variant: PDI5_A) -> Self {
209        match variant {
210            PDI5_A::_0 => false,
211            PDI5_A::_1 => true,
212        }
213    }
214}
215#[doc = "Reader of field `PDI5`"]
216pub type PDI5_R = crate::R<bool, PDI5_A>;
217impl PDI5_R {
218    #[doc = r"Get enumerated values variant"]
219    #[inline(always)]
220    pub fn variant(&self) -> PDI5_A {
221        match self.bits {
222            false => PDI5_A::_0,
223            true => PDI5_A::_1,
224        }
225    }
226    #[doc = "Checks if the value of the field is `_0`"]
227    #[inline(always)]
228    pub fn is_0(&self) -> bool {
229        *self == PDI5_A::_0
230    }
231    #[doc = "Checks if the value of the field is `_1`"]
232    #[inline(always)]
233    pub fn is_1(&self) -> bool {
234        *self == PDI5_A::_1
235    }
236}
237#[doc = "Port Data Input\n\nValue on reset: 0"]
238#[derive(Clone, Copy, Debug, PartialEq)]
239pub enum PDI6_A {
240    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
241    _0,
242    #[doc = "1: Pin logic level is logic 1."]
243    _1,
244}
245impl From<PDI6_A> for bool {
246    #[inline(always)]
247    fn from(variant: PDI6_A) -> Self {
248        match variant {
249            PDI6_A::_0 => false,
250            PDI6_A::_1 => true,
251        }
252    }
253}
254#[doc = "Reader of field `PDI6`"]
255pub type PDI6_R = crate::R<bool, PDI6_A>;
256impl PDI6_R {
257    #[doc = r"Get enumerated values variant"]
258    #[inline(always)]
259    pub fn variant(&self) -> PDI6_A {
260        match self.bits {
261            false => PDI6_A::_0,
262            true => PDI6_A::_1,
263        }
264    }
265    #[doc = "Checks if the value of the field is `_0`"]
266    #[inline(always)]
267    pub fn is_0(&self) -> bool {
268        *self == PDI6_A::_0
269    }
270    #[doc = "Checks if the value of the field is `_1`"]
271    #[inline(always)]
272    pub fn is_1(&self) -> bool {
273        *self == PDI6_A::_1
274    }
275}
276#[doc = "Port Data Input\n\nValue on reset: 0"]
277#[derive(Clone, Copy, Debug, PartialEq)]
278pub enum PDI7_A {
279    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
280    _0,
281    #[doc = "1: Pin logic level is logic 1."]
282    _1,
283}
284impl From<PDI7_A> for bool {
285    #[inline(always)]
286    fn from(variant: PDI7_A) -> Self {
287        match variant {
288            PDI7_A::_0 => false,
289            PDI7_A::_1 => true,
290        }
291    }
292}
293#[doc = "Reader of field `PDI7`"]
294pub type PDI7_R = crate::R<bool, PDI7_A>;
295impl PDI7_R {
296    #[doc = r"Get enumerated values variant"]
297    #[inline(always)]
298    pub fn variant(&self) -> PDI7_A {
299        match self.bits {
300            false => PDI7_A::_0,
301            true => PDI7_A::_1,
302        }
303    }
304    #[doc = "Checks if the value of the field is `_0`"]
305    #[inline(always)]
306    pub fn is_0(&self) -> bool {
307        *self == PDI7_A::_0
308    }
309    #[doc = "Checks if the value of the field is `_1`"]
310    #[inline(always)]
311    pub fn is_1(&self) -> bool {
312        *self == PDI7_A::_1
313    }
314}
315#[doc = "Port Data Input\n\nValue on reset: 0"]
316#[derive(Clone, Copy, Debug, PartialEq)]
317pub enum PDI8_A {
318    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
319    _0,
320    #[doc = "1: Pin logic level is logic 1."]
321    _1,
322}
323impl From<PDI8_A> for bool {
324    #[inline(always)]
325    fn from(variant: PDI8_A) -> Self {
326        match variant {
327            PDI8_A::_0 => false,
328            PDI8_A::_1 => true,
329        }
330    }
331}
332#[doc = "Reader of field `PDI8`"]
333pub type PDI8_R = crate::R<bool, PDI8_A>;
334impl PDI8_R {
335    #[doc = r"Get enumerated values variant"]
336    #[inline(always)]
337    pub fn variant(&self) -> PDI8_A {
338        match self.bits {
339            false => PDI8_A::_0,
340            true => PDI8_A::_1,
341        }
342    }
343    #[doc = "Checks if the value of the field is `_0`"]
344    #[inline(always)]
345    pub fn is_0(&self) -> bool {
346        *self == PDI8_A::_0
347    }
348    #[doc = "Checks if the value of the field is `_1`"]
349    #[inline(always)]
350    pub fn is_1(&self) -> bool {
351        *self == PDI8_A::_1
352    }
353}
354#[doc = "Port Data Input\n\nValue on reset: 0"]
355#[derive(Clone, Copy, Debug, PartialEq)]
356pub enum PDI9_A {
357    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
358    _0,
359    #[doc = "1: Pin logic level is logic 1."]
360    _1,
361}
362impl From<PDI9_A> for bool {
363    #[inline(always)]
364    fn from(variant: PDI9_A) -> Self {
365        match variant {
366            PDI9_A::_0 => false,
367            PDI9_A::_1 => true,
368        }
369    }
370}
371#[doc = "Reader of field `PDI9`"]
372pub type PDI9_R = crate::R<bool, PDI9_A>;
373impl PDI9_R {
374    #[doc = r"Get enumerated values variant"]
375    #[inline(always)]
376    pub fn variant(&self) -> PDI9_A {
377        match self.bits {
378            false => PDI9_A::_0,
379            true => PDI9_A::_1,
380        }
381    }
382    #[doc = "Checks if the value of the field is `_0`"]
383    #[inline(always)]
384    pub fn is_0(&self) -> bool {
385        *self == PDI9_A::_0
386    }
387    #[doc = "Checks if the value of the field is `_1`"]
388    #[inline(always)]
389    pub fn is_1(&self) -> bool {
390        *self == PDI9_A::_1
391    }
392}
393#[doc = "Port Data Input\n\nValue on reset: 0"]
394#[derive(Clone, Copy, Debug, PartialEq)]
395pub enum PDI10_A {
396    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
397    _0,
398    #[doc = "1: Pin logic level is logic 1."]
399    _1,
400}
401impl From<PDI10_A> for bool {
402    #[inline(always)]
403    fn from(variant: PDI10_A) -> Self {
404        match variant {
405            PDI10_A::_0 => false,
406            PDI10_A::_1 => true,
407        }
408    }
409}
410#[doc = "Reader of field `PDI10`"]
411pub type PDI10_R = crate::R<bool, PDI10_A>;
412impl PDI10_R {
413    #[doc = r"Get enumerated values variant"]
414    #[inline(always)]
415    pub fn variant(&self) -> PDI10_A {
416        match self.bits {
417            false => PDI10_A::_0,
418            true => PDI10_A::_1,
419        }
420    }
421    #[doc = "Checks if the value of the field is `_0`"]
422    #[inline(always)]
423    pub fn is_0(&self) -> bool {
424        *self == PDI10_A::_0
425    }
426    #[doc = "Checks if the value of the field is `_1`"]
427    #[inline(always)]
428    pub fn is_1(&self) -> bool {
429        *self == PDI10_A::_1
430    }
431}
432#[doc = "Port Data Input\n\nValue on reset: 0"]
433#[derive(Clone, Copy, Debug, PartialEq)]
434pub enum PDI11_A {
435    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
436    _0,
437    #[doc = "1: Pin logic level is logic 1."]
438    _1,
439}
440impl From<PDI11_A> for bool {
441    #[inline(always)]
442    fn from(variant: PDI11_A) -> Self {
443        match variant {
444            PDI11_A::_0 => false,
445            PDI11_A::_1 => true,
446        }
447    }
448}
449#[doc = "Reader of field `PDI11`"]
450pub type PDI11_R = crate::R<bool, PDI11_A>;
451impl PDI11_R {
452    #[doc = r"Get enumerated values variant"]
453    #[inline(always)]
454    pub fn variant(&self) -> PDI11_A {
455        match self.bits {
456            false => PDI11_A::_0,
457            true => PDI11_A::_1,
458        }
459    }
460    #[doc = "Checks if the value of the field is `_0`"]
461    #[inline(always)]
462    pub fn is_0(&self) -> bool {
463        *self == PDI11_A::_0
464    }
465    #[doc = "Checks if the value of the field is `_1`"]
466    #[inline(always)]
467    pub fn is_1(&self) -> bool {
468        *self == PDI11_A::_1
469    }
470}
471#[doc = "Port Data Input\n\nValue on reset: 0"]
472#[derive(Clone, Copy, Debug, PartialEq)]
473pub enum PDI12_A {
474    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
475    _0,
476    #[doc = "1: Pin logic level is logic 1."]
477    _1,
478}
479impl From<PDI12_A> for bool {
480    #[inline(always)]
481    fn from(variant: PDI12_A) -> Self {
482        match variant {
483            PDI12_A::_0 => false,
484            PDI12_A::_1 => true,
485        }
486    }
487}
488#[doc = "Reader of field `PDI12`"]
489pub type PDI12_R = crate::R<bool, PDI12_A>;
490impl PDI12_R {
491    #[doc = r"Get enumerated values variant"]
492    #[inline(always)]
493    pub fn variant(&self) -> PDI12_A {
494        match self.bits {
495            false => PDI12_A::_0,
496            true => PDI12_A::_1,
497        }
498    }
499    #[doc = "Checks if the value of the field is `_0`"]
500    #[inline(always)]
501    pub fn is_0(&self) -> bool {
502        *self == PDI12_A::_0
503    }
504    #[doc = "Checks if the value of the field is `_1`"]
505    #[inline(always)]
506    pub fn is_1(&self) -> bool {
507        *self == PDI12_A::_1
508    }
509}
510#[doc = "Port Data Input\n\nValue on reset: 0"]
511#[derive(Clone, Copy, Debug, PartialEq)]
512pub enum PDI13_A {
513    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
514    _0,
515    #[doc = "1: Pin logic level is logic 1."]
516    _1,
517}
518impl From<PDI13_A> for bool {
519    #[inline(always)]
520    fn from(variant: PDI13_A) -> Self {
521        match variant {
522            PDI13_A::_0 => false,
523            PDI13_A::_1 => true,
524        }
525    }
526}
527#[doc = "Reader of field `PDI13`"]
528pub type PDI13_R = crate::R<bool, PDI13_A>;
529impl PDI13_R {
530    #[doc = r"Get enumerated values variant"]
531    #[inline(always)]
532    pub fn variant(&self) -> PDI13_A {
533        match self.bits {
534            false => PDI13_A::_0,
535            true => PDI13_A::_1,
536        }
537    }
538    #[doc = "Checks if the value of the field is `_0`"]
539    #[inline(always)]
540    pub fn is_0(&self) -> bool {
541        *self == PDI13_A::_0
542    }
543    #[doc = "Checks if the value of the field is `_1`"]
544    #[inline(always)]
545    pub fn is_1(&self) -> bool {
546        *self == PDI13_A::_1
547    }
548}
549#[doc = "Port Data Input\n\nValue on reset: 0"]
550#[derive(Clone, Copy, Debug, PartialEq)]
551pub enum PDI14_A {
552    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
553    _0,
554    #[doc = "1: Pin logic level is logic 1."]
555    _1,
556}
557impl From<PDI14_A> for bool {
558    #[inline(always)]
559    fn from(variant: PDI14_A) -> Self {
560        match variant {
561            PDI14_A::_0 => false,
562            PDI14_A::_1 => true,
563        }
564    }
565}
566#[doc = "Reader of field `PDI14`"]
567pub type PDI14_R = crate::R<bool, PDI14_A>;
568impl PDI14_R {
569    #[doc = r"Get enumerated values variant"]
570    #[inline(always)]
571    pub fn variant(&self) -> PDI14_A {
572        match self.bits {
573            false => PDI14_A::_0,
574            true => PDI14_A::_1,
575        }
576    }
577    #[doc = "Checks if the value of the field is `_0`"]
578    #[inline(always)]
579    pub fn is_0(&self) -> bool {
580        *self == PDI14_A::_0
581    }
582    #[doc = "Checks if the value of the field is `_1`"]
583    #[inline(always)]
584    pub fn is_1(&self) -> bool {
585        *self == PDI14_A::_1
586    }
587}
588#[doc = "Port Data Input\n\nValue on reset: 0"]
589#[derive(Clone, Copy, Debug, PartialEq)]
590pub enum PDI15_A {
591    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
592    _0,
593    #[doc = "1: Pin logic level is logic 1."]
594    _1,
595}
596impl From<PDI15_A> for bool {
597    #[inline(always)]
598    fn from(variant: PDI15_A) -> Self {
599        match variant {
600            PDI15_A::_0 => false,
601            PDI15_A::_1 => true,
602        }
603    }
604}
605#[doc = "Reader of field `PDI15`"]
606pub type PDI15_R = crate::R<bool, PDI15_A>;
607impl PDI15_R {
608    #[doc = r"Get enumerated values variant"]
609    #[inline(always)]
610    pub fn variant(&self) -> PDI15_A {
611        match self.bits {
612            false => PDI15_A::_0,
613            true => PDI15_A::_1,
614        }
615    }
616    #[doc = "Checks if the value of the field is `_0`"]
617    #[inline(always)]
618    pub fn is_0(&self) -> bool {
619        *self == PDI15_A::_0
620    }
621    #[doc = "Checks if the value of the field is `_1`"]
622    #[inline(always)]
623    pub fn is_1(&self) -> bool {
624        *self == PDI15_A::_1
625    }
626}
627#[doc = "Port Data Input\n\nValue on reset: 0"]
628#[derive(Clone, Copy, Debug, PartialEq)]
629pub enum PDI16_A {
630    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
631    _0,
632    #[doc = "1: Pin logic level is logic 1."]
633    _1,
634}
635impl From<PDI16_A> for bool {
636    #[inline(always)]
637    fn from(variant: PDI16_A) -> Self {
638        match variant {
639            PDI16_A::_0 => false,
640            PDI16_A::_1 => true,
641        }
642    }
643}
644#[doc = "Reader of field `PDI16`"]
645pub type PDI16_R = crate::R<bool, PDI16_A>;
646impl PDI16_R {
647    #[doc = r"Get enumerated values variant"]
648    #[inline(always)]
649    pub fn variant(&self) -> PDI16_A {
650        match self.bits {
651            false => PDI16_A::_0,
652            true => PDI16_A::_1,
653        }
654    }
655    #[doc = "Checks if the value of the field is `_0`"]
656    #[inline(always)]
657    pub fn is_0(&self) -> bool {
658        *self == PDI16_A::_0
659    }
660    #[doc = "Checks if the value of the field is `_1`"]
661    #[inline(always)]
662    pub fn is_1(&self) -> bool {
663        *self == PDI16_A::_1
664    }
665}
666#[doc = "Port Data Input\n\nValue on reset: 0"]
667#[derive(Clone, Copy, Debug, PartialEq)]
668pub enum PDI17_A {
669    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
670    _0,
671    #[doc = "1: Pin logic level is logic 1."]
672    _1,
673}
674impl From<PDI17_A> for bool {
675    #[inline(always)]
676    fn from(variant: PDI17_A) -> Self {
677        match variant {
678            PDI17_A::_0 => false,
679            PDI17_A::_1 => true,
680        }
681    }
682}
683#[doc = "Reader of field `PDI17`"]
684pub type PDI17_R = crate::R<bool, PDI17_A>;
685impl PDI17_R {
686    #[doc = r"Get enumerated values variant"]
687    #[inline(always)]
688    pub fn variant(&self) -> PDI17_A {
689        match self.bits {
690            false => PDI17_A::_0,
691            true => PDI17_A::_1,
692        }
693    }
694    #[doc = "Checks if the value of the field is `_0`"]
695    #[inline(always)]
696    pub fn is_0(&self) -> bool {
697        *self == PDI17_A::_0
698    }
699    #[doc = "Checks if the value of the field is `_1`"]
700    #[inline(always)]
701    pub fn is_1(&self) -> bool {
702        *self == PDI17_A::_1
703    }
704}
705#[doc = "Port Data Input\n\nValue on reset: 0"]
706#[derive(Clone, Copy, Debug, PartialEq)]
707pub enum PDI18_A {
708    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
709    _0,
710    #[doc = "1: Pin logic level is logic 1."]
711    _1,
712}
713impl From<PDI18_A> for bool {
714    #[inline(always)]
715    fn from(variant: PDI18_A) -> Self {
716        match variant {
717            PDI18_A::_0 => false,
718            PDI18_A::_1 => true,
719        }
720    }
721}
722#[doc = "Reader of field `PDI18`"]
723pub type PDI18_R = crate::R<bool, PDI18_A>;
724impl PDI18_R {
725    #[doc = r"Get enumerated values variant"]
726    #[inline(always)]
727    pub fn variant(&self) -> PDI18_A {
728        match self.bits {
729            false => PDI18_A::_0,
730            true => PDI18_A::_1,
731        }
732    }
733    #[doc = "Checks if the value of the field is `_0`"]
734    #[inline(always)]
735    pub fn is_0(&self) -> bool {
736        *self == PDI18_A::_0
737    }
738    #[doc = "Checks if the value of the field is `_1`"]
739    #[inline(always)]
740    pub fn is_1(&self) -> bool {
741        *self == PDI18_A::_1
742    }
743}
744#[doc = "Port Data Input\n\nValue on reset: 0"]
745#[derive(Clone, Copy, Debug, PartialEq)]
746pub enum PDI19_A {
747    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
748    _0,
749    #[doc = "1: Pin logic level is logic 1."]
750    _1,
751}
752impl From<PDI19_A> for bool {
753    #[inline(always)]
754    fn from(variant: PDI19_A) -> Self {
755        match variant {
756            PDI19_A::_0 => false,
757            PDI19_A::_1 => true,
758        }
759    }
760}
761#[doc = "Reader of field `PDI19`"]
762pub type PDI19_R = crate::R<bool, PDI19_A>;
763impl PDI19_R {
764    #[doc = r"Get enumerated values variant"]
765    #[inline(always)]
766    pub fn variant(&self) -> PDI19_A {
767        match self.bits {
768            false => PDI19_A::_0,
769            true => PDI19_A::_1,
770        }
771    }
772    #[doc = "Checks if the value of the field is `_0`"]
773    #[inline(always)]
774    pub fn is_0(&self) -> bool {
775        *self == PDI19_A::_0
776    }
777    #[doc = "Checks if the value of the field is `_1`"]
778    #[inline(always)]
779    pub fn is_1(&self) -> bool {
780        *self == PDI19_A::_1
781    }
782}
783#[doc = "Port Data Input\n\nValue on reset: 0"]
784#[derive(Clone, Copy, Debug, PartialEq)]
785pub enum PDI20_A {
786    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
787    _0,
788    #[doc = "1: Pin logic level is logic 1."]
789    _1,
790}
791impl From<PDI20_A> for bool {
792    #[inline(always)]
793    fn from(variant: PDI20_A) -> Self {
794        match variant {
795            PDI20_A::_0 => false,
796            PDI20_A::_1 => true,
797        }
798    }
799}
800#[doc = "Reader of field `PDI20`"]
801pub type PDI20_R = crate::R<bool, PDI20_A>;
802impl PDI20_R {
803    #[doc = r"Get enumerated values variant"]
804    #[inline(always)]
805    pub fn variant(&self) -> PDI20_A {
806        match self.bits {
807            false => PDI20_A::_0,
808            true => PDI20_A::_1,
809        }
810    }
811    #[doc = "Checks if the value of the field is `_0`"]
812    #[inline(always)]
813    pub fn is_0(&self) -> bool {
814        *self == PDI20_A::_0
815    }
816    #[doc = "Checks if the value of the field is `_1`"]
817    #[inline(always)]
818    pub fn is_1(&self) -> bool {
819        *self == PDI20_A::_1
820    }
821}
822#[doc = "Port Data Input\n\nValue on reset: 0"]
823#[derive(Clone, Copy, Debug, PartialEq)]
824pub enum PDI21_A {
825    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
826    _0,
827    #[doc = "1: Pin logic level is logic 1."]
828    _1,
829}
830impl From<PDI21_A> for bool {
831    #[inline(always)]
832    fn from(variant: PDI21_A) -> Self {
833        match variant {
834            PDI21_A::_0 => false,
835            PDI21_A::_1 => true,
836        }
837    }
838}
839#[doc = "Reader of field `PDI21`"]
840pub type PDI21_R = crate::R<bool, PDI21_A>;
841impl PDI21_R {
842    #[doc = r"Get enumerated values variant"]
843    #[inline(always)]
844    pub fn variant(&self) -> PDI21_A {
845        match self.bits {
846            false => PDI21_A::_0,
847            true => PDI21_A::_1,
848        }
849    }
850    #[doc = "Checks if the value of the field is `_0`"]
851    #[inline(always)]
852    pub fn is_0(&self) -> bool {
853        *self == PDI21_A::_0
854    }
855    #[doc = "Checks if the value of the field is `_1`"]
856    #[inline(always)]
857    pub fn is_1(&self) -> bool {
858        *self == PDI21_A::_1
859    }
860}
861#[doc = "Port Data Input\n\nValue on reset: 0"]
862#[derive(Clone, Copy, Debug, PartialEq)]
863pub enum PDI22_A {
864    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
865    _0,
866    #[doc = "1: Pin logic level is logic 1."]
867    _1,
868}
869impl From<PDI22_A> for bool {
870    #[inline(always)]
871    fn from(variant: PDI22_A) -> Self {
872        match variant {
873            PDI22_A::_0 => false,
874            PDI22_A::_1 => true,
875        }
876    }
877}
878#[doc = "Reader of field `PDI22`"]
879pub type PDI22_R = crate::R<bool, PDI22_A>;
880impl PDI22_R {
881    #[doc = r"Get enumerated values variant"]
882    #[inline(always)]
883    pub fn variant(&self) -> PDI22_A {
884        match self.bits {
885            false => PDI22_A::_0,
886            true => PDI22_A::_1,
887        }
888    }
889    #[doc = "Checks if the value of the field is `_0`"]
890    #[inline(always)]
891    pub fn is_0(&self) -> bool {
892        *self == PDI22_A::_0
893    }
894    #[doc = "Checks if the value of the field is `_1`"]
895    #[inline(always)]
896    pub fn is_1(&self) -> bool {
897        *self == PDI22_A::_1
898    }
899}
900#[doc = "Port Data Input\n\nValue on reset: 0"]
901#[derive(Clone, Copy, Debug, PartialEq)]
902pub enum PDI23_A {
903    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
904    _0,
905    #[doc = "1: Pin logic level is logic 1."]
906    _1,
907}
908impl From<PDI23_A> for bool {
909    #[inline(always)]
910    fn from(variant: PDI23_A) -> Self {
911        match variant {
912            PDI23_A::_0 => false,
913            PDI23_A::_1 => true,
914        }
915    }
916}
917#[doc = "Reader of field `PDI23`"]
918pub type PDI23_R = crate::R<bool, PDI23_A>;
919impl PDI23_R {
920    #[doc = r"Get enumerated values variant"]
921    #[inline(always)]
922    pub fn variant(&self) -> PDI23_A {
923        match self.bits {
924            false => PDI23_A::_0,
925            true => PDI23_A::_1,
926        }
927    }
928    #[doc = "Checks if the value of the field is `_0`"]
929    #[inline(always)]
930    pub fn is_0(&self) -> bool {
931        *self == PDI23_A::_0
932    }
933    #[doc = "Checks if the value of the field is `_1`"]
934    #[inline(always)]
935    pub fn is_1(&self) -> bool {
936        *self == PDI23_A::_1
937    }
938}
939#[doc = "Port Data Input\n\nValue on reset: 0"]
940#[derive(Clone, Copy, Debug, PartialEq)]
941pub enum PDI24_A {
942    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
943    _0,
944    #[doc = "1: Pin logic level is logic 1."]
945    _1,
946}
947impl From<PDI24_A> for bool {
948    #[inline(always)]
949    fn from(variant: PDI24_A) -> Self {
950        match variant {
951            PDI24_A::_0 => false,
952            PDI24_A::_1 => true,
953        }
954    }
955}
956#[doc = "Reader of field `PDI24`"]
957pub type PDI24_R = crate::R<bool, PDI24_A>;
958impl PDI24_R {
959    #[doc = r"Get enumerated values variant"]
960    #[inline(always)]
961    pub fn variant(&self) -> PDI24_A {
962        match self.bits {
963            false => PDI24_A::_0,
964            true => PDI24_A::_1,
965        }
966    }
967    #[doc = "Checks if the value of the field is `_0`"]
968    #[inline(always)]
969    pub fn is_0(&self) -> bool {
970        *self == PDI24_A::_0
971    }
972    #[doc = "Checks if the value of the field is `_1`"]
973    #[inline(always)]
974    pub fn is_1(&self) -> bool {
975        *self == PDI24_A::_1
976    }
977}
978#[doc = "Port Data Input\n\nValue on reset: 0"]
979#[derive(Clone, Copy, Debug, PartialEq)]
980pub enum PDI25_A {
981    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
982    _0,
983    #[doc = "1: Pin logic level is logic 1."]
984    _1,
985}
986impl From<PDI25_A> for bool {
987    #[inline(always)]
988    fn from(variant: PDI25_A) -> Self {
989        match variant {
990            PDI25_A::_0 => false,
991            PDI25_A::_1 => true,
992        }
993    }
994}
995#[doc = "Reader of field `PDI25`"]
996pub type PDI25_R = crate::R<bool, PDI25_A>;
997impl PDI25_R {
998    #[doc = r"Get enumerated values variant"]
999    #[inline(always)]
1000    pub fn variant(&self) -> PDI25_A {
1001        match self.bits {
1002            false => PDI25_A::_0,
1003            true => PDI25_A::_1,
1004        }
1005    }
1006    #[doc = "Checks if the value of the field is `_0`"]
1007    #[inline(always)]
1008    pub fn is_0(&self) -> bool {
1009        *self == PDI25_A::_0
1010    }
1011    #[doc = "Checks if the value of the field is `_1`"]
1012    #[inline(always)]
1013    pub fn is_1(&self) -> bool {
1014        *self == PDI25_A::_1
1015    }
1016}
1017#[doc = "Port Data Input\n\nValue on reset: 0"]
1018#[derive(Clone, Copy, Debug, PartialEq)]
1019pub enum PDI26_A {
1020    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
1021    _0,
1022    #[doc = "1: Pin logic level is logic 1."]
1023    _1,
1024}
1025impl From<PDI26_A> for bool {
1026    #[inline(always)]
1027    fn from(variant: PDI26_A) -> Self {
1028        match variant {
1029            PDI26_A::_0 => false,
1030            PDI26_A::_1 => true,
1031        }
1032    }
1033}
1034#[doc = "Reader of field `PDI26`"]
1035pub type PDI26_R = crate::R<bool, PDI26_A>;
1036impl PDI26_R {
1037    #[doc = r"Get enumerated values variant"]
1038    #[inline(always)]
1039    pub fn variant(&self) -> PDI26_A {
1040        match self.bits {
1041            false => PDI26_A::_0,
1042            true => PDI26_A::_1,
1043        }
1044    }
1045    #[doc = "Checks if the value of the field is `_0`"]
1046    #[inline(always)]
1047    pub fn is_0(&self) -> bool {
1048        *self == PDI26_A::_0
1049    }
1050    #[doc = "Checks if the value of the field is `_1`"]
1051    #[inline(always)]
1052    pub fn is_1(&self) -> bool {
1053        *self == PDI26_A::_1
1054    }
1055}
1056#[doc = "Port Data Input\n\nValue on reset: 0"]
1057#[derive(Clone, Copy, Debug, PartialEq)]
1058pub enum PDI27_A {
1059    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
1060    _0,
1061    #[doc = "1: Pin logic level is logic 1."]
1062    _1,
1063}
1064impl From<PDI27_A> for bool {
1065    #[inline(always)]
1066    fn from(variant: PDI27_A) -> Self {
1067        match variant {
1068            PDI27_A::_0 => false,
1069            PDI27_A::_1 => true,
1070        }
1071    }
1072}
1073#[doc = "Reader of field `PDI27`"]
1074pub type PDI27_R = crate::R<bool, PDI27_A>;
1075impl PDI27_R {
1076    #[doc = r"Get enumerated values variant"]
1077    #[inline(always)]
1078    pub fn variant(&self) -> PDI27_A {
1079        match self.bits {
1080            false => PDI27_A::_0,
1081            true => PDI27_A::_1,
1082        }
1083    }
1084    #[doc = "Checks if the value of the field is `_0`"]
1085    #[inline(always)]
1086    pub fn is_0(&self) -> bool {
1087        *self == PDI27_A::_0
1088    }
1089    #[doc = "Checks if the value of the field is `_1`"]
1090    #[inline(always)]
1091    pub fn is_1(&self) -> bool {
1092        *self == PDI27_A::_1
1093    }
1094}
1095#[doc = "Port Data Input\n\nValue on reset: 0"]
1096#[derive(Clone, Copy, Debug, PartialEq)]
1097pub enum PDI28_A {
1098    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
1099    _0,
1100    #[doc = "1: Pin logic level is logic 1."]
1101    _1,
1102}
1103impl From<PDI28_A> for bool {
1104    #[inline(always)]
1105    fn from(variant: PDI28_A) -> Self {
1106        match variant {
1107            PDI28_A::_0 => false,
1108            PDI28_A::_1 => true,
1109        }
1110    }
1111}
1112#[doc = "Reader of field `PDI28`"]
1113pub type PDI28_R = crate::R<bool, PDI28_A>;
1114impl PDI28_R {
1115    #[doc = r"Get enumerated values variant"]
1116    #[inline(always)]
1117    pub fn variant(&self) -> PDI28_A {
1118        match self.bits {
1119            false => PDI28_A::_0,
1120            true => PDI28_A::_1,
1121        }
1122    }
1123    #[doc = "Checks if the value of the field is `_0`"]
1124    #[inline(always)]
1125    pub fn is_0(&self) -> bool {
1126        *self == PDI28_A::_0
1127    }
1128    #[doc = "Checks if the value of the field is `_1`"]
1129    #[inline(always)]
1130    pub fn is_1(&self) -> bool {
1131        *self == PDI28_A::_1
1132    }
1133}
1134#[doc = "Port Data Input\n\nValue on reset: 0"]
1135#[derive(Clone, Copy, Debug, PartialEq)]
1136pub enum PDI29_A {
1137    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
1138    _0,
1139    #[doc = "1: Pin logic level is logic 1."]
1140    _1,
1141}
1142impl From<PDI29_A> for bool {
1143    #[inline(always)]
1144    fn from(variant: PDI29_A) -> Self {
1145        match variant {
1146            PDI29_A::_0 => false,
1147            PDI29_A::_1 => true,
1148        }
1149    }
1150}
1151#[doc = "Reader of field `PDI29`"]
1152pub type PDI29_R = crate::R<bool, PDI29_A>;
1153impl PDI29_R {
1154    #[doc = r"Get enumerated values variant"]
1155    #[inline(always)]
1156    pub fn variant(&self) -> PDI29_A {
1157        match self.bits {
1158            false => PDI29_A::_0,
1159            true => PDI29_A::_1,
1160        }
1161    }
1162    #[doc = "Checks if the value of the field is `_0`"]
1163    #[inline(always)]
1164    pub fn is_0(&self) -> bool {
1165        *self == PDI29_A::_0
1166    }
1167    #[doc = "Checks if the value of the field is `_1`"]
1168    #[inline(always)]
1169    pub fn is_1(&self) -> bool {
1170        *self == PDI29_A::_1
1171    }
1172}
1173#[doc = "Port Data Input\n\nValue on reset: 0"]
1174#[derive(Clone, Copy, Debug, PartialEq)]
1175pub enum PDI30_A {
1176    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
1177    _0,
1178    #[doc = "1: Pin logic level is logic 1."]
1179    _1,
1180}
1181impl From<PDI30_A> for bool {
1182    #[inline(always)]
1183    fn from(variant: PDI30_A) -> Self {
1184        match variant {
1185            PDI30_A::_0 => false,
1186            PDI30_A::_1 => true,
1187        }
1188    }
1189}
1190#[doc = "Reader of field `PDI30`"]
1191pub type PDI30_R = crate::R<bool, PDI30_A>;
1192impl PDI30_R {
1193    #[doc = r"Get enumerated values variant"]
1194    #[inline(always)]
1195    pub fn variant(&self) -> PDI30_A {
1196        match self.bits {
1197            false => PDI30_A::_0,
1198            true => PDI30_A::_1,
1199        }
1200    }
1201    #[doc = "Checks if the value of the field is `_0`"]
1202    #[inline(always)]
1203    pub fn is_0(&self) -> bool {
1204        *self == PDI30_A::_0
1205    }
1206    #[doc = "Checks if the value of the field is `_1`"]
1207    #[inline(always)]
1208    pub fn is_1(&self) -> bool {
1209        *self == PDI30_A::_1
1210    }
1211}
1212#[doc = "Port Data Input\n\nValue on reset: 0"]
1213#[derive(Clone, Copy, Debug, PartialEq)]
1214pub enum PDI31_A {
1215    #[doc = "0: Pin logic level is logic 0, or is not configured for use by digital function."]
1216    _0,
1217    #[doc = "1: Pin logic level is logic 1."]
1218    _1,
1219}
1220impl From<PDI31_A> for bool {
1221    #[inline(always)]
1222    fn from(variant: PDI31_A) -> Self {
1223        match variant {
1224            PDI31_A::_0 => false,
1225            PDI31_A::_1 => true,
1226        }
1227    }
1228}
1229#[doc = "Reader of field `PDI31`"]
1230pub type PDI31_R = crate::R<bool, PDI31_A>;
1231impl PDI31_R {
1232    #[doc = r"Get enumerated values variant"]
1233    #[inline(always)]
1234    pub fn variant(&self) -> PDI31_A {
1235        match self.bits {
1236            false => PDI31_A::_0,
1237            true => PDI31_A::_1,
1238        }
1239    }
1240    #[doc = "Checks if the value of the field is `_0`"]
1241    #[inline(always)]
1242    pub fn is_0(&self) -> bool {
1243        *self == PDI31_A::_0
1244    }
1245    #[doc = "Checks if the value of the field is `_1`"]
1246    #[inline(always)]
1247    pub fn is_1(&self) -> bool {
1248        *self == PDI31_A::_1
1249    }
1250}
1251impl R {
1252    #[doc = "Bit 0 - Port Data Input"]
1253    #[inline(always)]
1254    pub fn pdi0(&self) -> PDI0_R {
1255        PDI0_R::new((self.bits & 0x01) != 0)
1256    }
1257    #[doc = "Bit 1 - Port Data Input"]
1258    #[inline(always)]
1259    pub fn pdi1(&self) -> PDI1_R {
1260        PDI1_R::new(((self.bits >> 1) & 0x01) != 0)
1261    }
1262    #[doc = "Bit 2 - Port Data Input"]
1263    #[inline(always)]
1264    pub fn pdi2(&self) -> PDI2_R {
1265        PDI2_R::new(((self.bits >> 2) & 0x01) != 0)
1266    }
1267    #[doc = "Bit 3 - Port Data Input"]
1268    #[inline(always)]
1269    pub fn pdi3(&self) -> PDI3_R {
1270        PDI3_R::new(((self.bits >> 3) & 0x01) != 0)
1271    }
1272    #[doc = "Bit 4 - Port Data Input"]
1273    #[inline(always)]
1274    pub fn pdi4(&self) -> PDI4_R {
1275        PDI4_R::new(((self.bits >> 4) & 0x01) != 0)
1276    }
1277    #[doc = "Bit 5 - Port Data Input"]
1278    #[inline(always)]
1279    pub fn pdi5(&self) -> PDI5_R {
1280        PDI5_R::new(((self.bits >> 5) & 0x01) != 0)
1281    }
1282    #[doc = "Bit 6 - Port Data Input"]
1283    #[inline(always)]
1284    pub fn pdi6(&self) -> PDI6_R {
1285        PDI6_R::new(((self.bits >> 6) & 0x01) != 0)
1286    }
1287    #[doc = "Bit 7 - Port Data Input"]
1288    #[inline(always)]
1289    pub fn pdi7(&self) -> PDI7_R {
1290        PDI7_R::new(((self.bits >> 7) & 0x01) != 0)
1291    }
1292    #[doc = "Bit 8 - Port Data Input"]
1293    #[inline(always)]
1294    pub fn pdi8(&self) -> PDI8_R {
1295        PDI8_R::new(((self.bits >> 8) & 0x01) != 0)
1296    }
1297    #[doc = "Bit 9 - Port Data Input"]
1298    #[inline(always)]
1299    pub fn pdi9(&self) -> PDI9_R {
1300        PDI9_R::new(((self.bits >> 9) & 0x01) != 0)
1301    }
1302    #[doc = "Bit 10 - Port Data Input"]
1303    #[inline(always)]
1304    pub fn pdi10(&self) -> PDI10_R {
1305        PDI10_R::new(((self.bits >> 10) & 0x01) != 0)
1306    }
1307    #[doc = "Bit 11 - Port Data Input"]
1308    #[inline(always)]
1309    pub fn pdi11(&self) -> PDI11_R {
1310        PDI11_R::new(((self.bits >> 11) & 0x01) != 0)
1311    }
1312    #[doc = "Bit 12 - Port Data Input"]
1313    #[inline(always)]
1314    pub fn pdi12(&self) -> PDI12_R {
1315        PDI12_R::new(((self.bits >> 12) & 0x01) != 0)
1316    }
1317    #[doc = "Bit 13 - Port Data Input"]
1318    #[inline(always)]
1319    pub fn pdi13(&self) -> PDI13_R {
1320        PDI13_R::new(((self.bits >> 13) & 0x01) != 0)
1321    }
1322    #[doc = "Bit 14 - Port Data Input"]
1323    #[inline(always)]
1324    pub fn pdi14(&self) -> PDI14_R {
1325        PDI14_R::new(((self.bits >> 14) & 0x01) != 0)
1326    }
1327    #[doc = "Bit 15 - Port Data Input"]
1328    #[inline(always)]
1329    pub fn pdi15(&self) -> PDI15_R {
1330        PDI15_R::new(((self.bits >> 15) & 0x01) != 0)
1331    }
1332    #[doc = "Bit 16 - Port Data Input"]
1333    #[inline(always)]
1334    pub fn pdi16(&self) -> PDI16_R {
1335        PDI16_R::new(((self.bits >> 16) & 0x01) != 0)
1336    }
1337    #[doc = "Bit 17 - Port Data Input"]
1338    #[inline(always)]
1339    pub fn pdi17(&self) -> PDI17_R {
1340        PDI17_R::new(((self.bits >> 17) & 0x01) != 0)
1341    }
1342    #[doc = "Bit 18 - Port Data Input"]
1343    #[inline(always)]
1344    pub fn pdi18(&self) -> PDI18_R {
1345        PDI18_R::new(((self.bits >> 18) & 0x01) != 0)
1346    }
1347    #[doc = "Bit 19 - Port Data Input"]
1348    #[inline(always)]
1349    pub fn pdi19(&self) -> PDI19_R {
1350        PDI19_R::new(((self.bits >> 19) & 0x01) != 0)
1351    }
1352    #[doc = "Bit 20 - Port Data Input"]
1353    #[inline(always)]
1354    pub fn pdi20(&self) -> PDI20_R {
1355        PDI20_R::new(((self.bits >> 20) & 0x01) != 0)
1356    }
1357    #[doc = "Bit 21 - Port Data Input"]
1358    #[inline(always)]
1359    pub fn pdi21(&self) -> PDI21_R {
1360        PDI21_R::new(((self.bits >> 21) & 0x01) != 0)
1361    }
1362    #[doc = "Bit 22 - Port Data Input"]
1363    #[inline(always)]
1364    pub fn pdi22(&self) -> PDI22_R {
1365        PDI22_R::new(((self.bits >> 22) & 0x01) != 0)
1366    }
1367    #[doc = "Bit 23 - Port Data Input"]
1368    #[inline(always)]
1369    pub fn pdi23(&self) -> PDI23_R {
1370        PDI23_R::new(((self.bits >> 23) & 0x01) != 0)
1371    }
1372    #[doc = "Bit 24 - Port Data Input"]
1373    #[inline(always)]
1374    pub fn pdi24(&self) -> PDI24_R {
1375        PDI24_R::new(((self.bits >> 24) & 0x01) != 0)
1376    }
1377    #[doc = "Bit 25 - Port Data Input"]
1378    #[inline(always)]
1379    pub fn pdi25(&self) -> PDI25_R {
1380        PDI25_R::new(((self.bits >> 25) & 0x01) != 0)
1381    }
1382    #[doc = "Bit 26 - Port Data Input"]
1383    #[inline(always)]
1384    pub fn pdi26(&self) -> PDI26_R {
1385        PDI26_R::new(((self.bits >> 26) & 0x01) != 0)
1386    }
1387    #[doc = "Bit 27 - Port Data Input"]
1388    #[inline(always)]
1389    pub fn pdi27(&self) -> PDI27_R {
1390        PDI27_R::new(((self.bits >> 27) & 0x01) != 0)
1391    }
1392    #[doc = "Bit 28 - Port Data Input"]
1393    #[inline(always)]
1394    pub fn pdi28(&self) -> PDI28_R {
1395        PDI28_R::new(((self.bits >> 28) & 0x01) != 0)
1396    }
1397    #[doc = "Bit 29 - Port Data Input"]
1398    #[inline(always)]
1399    pub fn pdi29(&self) -> PDI29_R {
1400        PDI29_R::new(((self.bits >> 29) & 0x01) != 0)
1401    }
1402    #[doc = "Bit 30 - Port Data Input"]
1403    #[inline(always)]
1404    pub fn pdi30(&self) -> PDI30_R {
1405        PDI30_R::new(((self.bits >> 30) & 0x01) != 0)
1406    }
1407    #[doc = "Bit 31 - Port Data Input"]
1408    #[inline(always)]
1409    pub fn pdi31(&self) -> PDI31_R {
1410        PDI31_R::new(((self.bits >> 31) & 0x01) != 0)
1411    }
1412}
mk66f18/gpioa/pdir.rs

mk66f18/gpioa/
pdir.rs
