ra2a2_pac/
port0.rs

1/*
2DISCLAIMER
3This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products.
4No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all
5applicable laws, including copyright laws.
6THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED
7OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
8NON-INFRINGEMENT.  ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY
9LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT,
10INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR
11ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
12Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability
13of this software. By using this software, you agree to the additional terms and conditions found by accessing the
14following link:
15http://www.renesas.com/disclaimer
16
17*/
18// Generated from SVD 1.20.02, with svd2pac 0.6.1 on Sun, 15 Mar 2026 07:01:00 +0000
19
20#![allow(clippy::identity_op)]
21#![allow(clippy::module_inception)]
22#![allow(clippy::derivable_impls)]
23#[allow(unused_imports)]
24use crate::common::sealed;
25#[allow(unused_imports)]
26use crate::common::*;
27#[doc = r"Port 0 Control Registers"]
28unsafe impl ::core::marker::Send for super::Port0 {}
29unsafe impl ::core::marker::Sync for super::Port0 {}
30impl super::Port0 {
31    #[allow(unused)]
32    #[inline(always)]
33    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
34        self.ptr
35    }
36
37    #[doc = "Port Control Register 1"]
38    #[inline(always)]
39    pub const fn pcntr1(
40        &self,
41    ) -> &'static crate::common::Reg<self::Pcntr1_SPEC, crate::common::RW> {
42        unsafe {
43            crate::common::Reg::<self::Pcntr1_SPEC, crate::common::RW>::from_ptr(
44                self._svd2pac_as_ptr().add(0usize),
45            )
46        }
47    }
48
49    #[doc = "Port Control Register 1"]
50    #[inline(always)]
51    pub const fn podr(&self) -> &'static crate::common::Reg<self::Podr_SPEC, crate::common::RW> {
52        unsafe {
53            crate::common::Reg::<self::Podr_SPEC, crate::common::RW>::from_ptr(
54                self._svd2pac_as_ptr().add(0usize),
55            )
56        }
57    }
58
59    #[doc = "Port Control Register 1"]
60    #[inline(always)]
61    pub const fn pdr(&self) -> &'static crate::common::Reg<self::Pdr_SPEC, crate::common::RW> {
62        unsafe {
63            crate::common::Reg::<self::Pdr_SPEC, crate::common::RW>::from_ptr(
64                self._svd2pac_as_ptr().add(2usize),
65            )
66        }
67    }
68
69    #[doc = "Port Control Register 2"]
70    #[inline(always)]
71    pub const fn pcntr2(&self) -> &'static crate::common::Reg<self::Pcntr2_SPEC, crate::common::R> {
72        unsafe {
73            crate::common::Reg::<self::Pcntr2_SPEC, crate::common::R>::from_ptr(
74                self._svd2pac_as_ptr().add(4usize),
75            )
76        }
77    }
78
79    #[doc = "Port Control Register 2"]
80    #[inline(always)]
81    pub const fn eidr(&self) -> &'static crate::common::Reg<self::Eidr_SPEC, crate::common::R> {
82        unsafe {
83            crate::common::Reg::<self::Eidr_SPEC, crate::common::R>::from_ptr(
84                self._svd2pac_as_ptr().add(4usize),
85            )
86        }
87    }
88
89    #[doc = "Port Control Register 2"]
90    #[inline(always)]
91    pub const fn pidr(&self) -> &'static crate::common::Reg<self::Pidr_SPEC, crate::common::R> {
92        unsafe {
93            crate::common::Reg::<self::Pidr_SPEC, crate::common::R>::from_ptr(
94                self._svd2pac_as_ptr().add(6usize),
95            )
96        }
97    }
98
99    #[doc = "Port Control Register 3"]
100    #[inline(always)]
101    pub const fn pcntr3(&self) -> &'static crate::common::Reg<self::Pcntr3_SPEC, crate::common::W> {
102        unsafe {
103            crate::common::Reg::<self::Pcntr3_SPEC, crate::common::W>::from_ptr(
104                self._svd2pac_as_ptr().add(8usize),
105            )
106        }
107    }
108
109    #[doc = "Port Control Register 3"]
110    #[inline(always)]
111    pub const fn porr(&self) -> &'static crate::common::Reg<self::Porr_SPEC, crate::common::W> {
112        unsafe {
113            crate::common::Reg::<self::Porr_SPEC, crate::common::W>::from_ptr(
114                self._svd2pac_as_ptr().add(8usize),
115            )
116        }
117    }
118
119    #[doc = "Port Control Register 3"]
120    #[inline(always)]
121    pub const fn posr(&self) -> &'static crate::common::Reg<self::Posr_SPEC, crate::common::W> {
122        unsafe {
123            crate::common::Reg::<self::Posr_SPEC, crate::common::W>::from_ptr(
124                self._svd2pac_as_ptr().add(10usize),
125            )
126        }
127    }
128}
129#[doc(hidden)]
130#[derive(Copy, Clone, Eq, PartialEq)]
131pub struct Pcntr1_SPEC;
132impl crate::sealed::RegSpec for Pcntr1_SPEC {
133    type DataType = u32;
134}
135
136#[doc = "Port Control Register 1"]
137pub type Pcntr1 = crate::RegValueT<Pcntr1_SPEC>;
138
139impl Pcntr1 {
140    #[doc = "Pmn Direction"]
141    #[inline(always)]
142    pub fn pdr00(
143        self,
144    ) -> crate::common::RegisterField<
145        0,
146        0x1,
147        1,
148        0,
149        pcntr1::Pdr00,
150        pcntr1::Pdr00,
151        Pcntr1_SPEC,
152        crate::common::RW,
153    > {
154        crate::common::RegisterField::<
155            0,
156            0x1,
157            1,
158            0,
159            pcntr1::Pdr00,
160            pcntr1::Pdr00,
161            Pcntr1_SPEC,
162            crate::common::RW,
163        >::from_register(self, 0)
164    }
165
166    #[doc = "Pmn Direction"]
167    #[inline(always)]
168    pub fn pdr01(
169        self,
170    ) -> crate::common::RegisterField<
171        1,
172        0x1,
173        1,
174        0,
175        pcntr1::Pdr01,
176        pcntr1::Pdr01,
177        Pcntr1_SPEC,
178        crate::common::RW,
179    > {
180        crate::common::RegisterField::<
181            1,
182            0x1,
183            1,
184            0,
185            pcntr1::Pdr01,
186            pcntr1::Pdr01,
187            Pcntr1_SPEC,
188            crate::common::RW,
189        >::from_register(self, 0)
190    }
191
192    #[doc = "Pmn Direction"]
193    #[inline(always)]
194    pub fn pdr02(
195        self,
196    ) -> crate::common::RegisterField<
197        2,
198        0x1,
199        1,
200        0,
201        pcntr1::Pdr02,
202        pcntr1::Pdr02,
203        Pcntr1_SPEC,
204        crate::common::RW,
205    > {
206        crate::common::RegisterField::<
207            2,
208            0x1,
209            1,
210            0,
211            pcntr1::Pdr02,
212            pcntr1::Pdr02,
213            Pcntr1_SPEC,
214            crate::common::RW,
215        >::from_register(self, 0)
216    }
217
218    #[doc = "Pmn Direction"]
219    #[inline(always)]
220    pub fn pdr03(
221        self,
222    ) -> crate::common::RegisterField<
223        3,
224        0x1,
225        1,
226        0,
227        pcntr1::Pdr03,
228        pcntr1::Pdr03,
229        Pcntr1_SPEC,
230        crate::common::RW,
231    > {
232        crate::common::RegisterField::<
233            3,
234            0x1,
235            1,
236            0,
237            pcntr1::Pdr03,
238            pcntr1::Pdr03,
239            Pcntr1_SPEC,
240            crate::common::RW,
241        >::from_register(self, 0)
242    }
243
244    #[doc = "Pmn Direction"]
245    #[inline(always)]
246    pub fn pdr04(
247        self,
248    ) -> crate::common::RegisterField<
249        4,
250        0x1,
251        1,
252        0,
253        pcntr1::Pdr04,
254        pcntr1::Pdr04,
255        Pcntr1_SPEC,
256        crate::common::RW,
257    > {
258        crate::common::RegisterField::<
259            4,
260            0x1,
261            1,
262            0,
263            pcntr1::Pdr04,
264            pcntr1::Pdr04,
265            Pcntr1_SPEC,
266            crate::common::RW,
267        >::from_register(self, 0)
268    }
269
270    #[doc = "Pmn Direction"]
271    #[inline(always)]
272    pub fn pdr05(
273        self,
274    ) -> crate::common::RegisterField<
275        5,
276        0x1,
277        1,
278        0,
279        pcntr1::Pdr05,
280        pcntr1::Pdr05,
281        Pcntr1_SPEC,
282        crate::common::RW,
283    > {
284        crate::common::RegisterField::<
285            5,
286            0x1,
287            1,
288            0,
289            pcntr1::Pdr05,
290            pcntr1::Pdr05,
291            Pcntr1_SPEC,
292            crate::common::RW,
293        >::from_register(self, 0)
294    }
295
296    #[doc = "Pmn Direction"]
297    #[inline(always)]
298    pub fn pdr06(
299        self,
300    ) -> crate::common::RegisterField<
301        6,
302        0x1,
303        1,
304        0,
305        pcntr1::Pdr06,
306        pcntr1::Pdr06,
307        Pcntr1_SPEC,
308        crate::common::RW,
309    > {
310        crate::common::RegisterField::<
311            6,
312            0x1,
313            1,
314            0,
315            pcntr1::Pdr06,
316            pcntr1::Pdr06,
317            Pcntr1_SPEC,
318            crate::common::RW,
319        >::from_register(self, 0)
320    }
321
322    #[doc = "Pmn Direction"]
323    #[inline(always)]
324    pub fn pdr07(
325        self,
326    ) -> crate::common::RegisterField<
327        7,
328        0x1,
329        1,
330        0,
331        pcntr1::Pdr07,
332        pcntr1::Pdr07,
333        Pcntr1_SPEC,
334        crate::common::RW,
335    > {
336        crate::common::RegisterField::<
337            7,
338            0x1,
339            1,
340            0,
341            pcntr1::Pdr07,
342            pcntr1::Pdr07,
343            Pcntr1_SPEC,
344            crate::common::RW,
345        >::from_register(self, 0)
346    }
347
348    #[doc = "Pmn Direction"]
349    #[inline(always)]
350    pub fn pdr08(
351        self,
352    ) -> crate::common::RegisterField<
353        8,
354        0x1,
355        1,
356        0,
357        pcntr1::Pdr08,
358        pcntr1::Pdr08,
359        Pcntr1_SPEC,
360        crate::common::RW,
361    > {
362        crate::common::RegisterField::<
363            8,
364            0x1,
365            1,
366            0,
367            pcntr1::Pdr08,
368            pcntr1::Pdr08,
369            Pcntr1_SPEC,
370            crate::common::RW,
371        >::from_register(self, 0)
372    }
373
374    #[doc = "Pmn Direction"]
375    #[inline(always)]
376    pub fn pdr09(
377        self,
378    ) -> crate::common::RegisterField<
379        9,
380        0x1,
381        1,
382        0,
383        pcntr1::Pdr09,
384        pcntr1::Pdr09,
385        Pcntr1_SPEC,
386        crate::common::RW,
387    > {
388        crate::common::RegisterField::<
389            9,
390            0x1,
391            1,
392            0,
393            pcntr1::Pdr09,
394            pcntr1::Pdr09,
395            Pcntr1_SPEC,
396            crate::common::RW,
397        >::from_register(self, 0)
398    }
399
400    #[doc = "Pmn Direction"]
401    #[inline(always)]
402    pub fn pdr10(
403        self,
404    ) -> crate::common::RegisterField<
405        10,
406        0x1,
407        1,
408        0,
409        pcntr1::Pdr10,
410        pcntr1::Pdr10,
411        Pcntr1_SPEC,
412        crate::common::RW,
413    > {
414        crate::common::RegisterField::<
415            10,
416            0x1,
417            1,
418            0,
419            pcntr1::Pdr10,
420            pcntr1::Pdr10,
421            Pcntr1_SPEC,
422            crate::common::RW,
423        >::from_register(self, 0)
424    }
425
426    #[doc = "Pmn Direction"]
427    #[inline(always)]
428    pub fn pdr11(
429        self,
430    ) -> crate::common::RegisterField<
431        11,
432        0x1,
433        1,
434        0,
435        pcntr1::Pdr11,
436        pcntr1::Pdr11,
437        Pcntr1_SPEC,
438        crate::common::RW,
439    > {
440        crate::common::RegisterField::<
441            11,
442            0x1,
443            1,
444            0,
445            pcntr1::Pdr11,
446            pcntr1::Pdr11,
447            Pcntr1_SPEC,
448            crate::common::RW,
449        >::from_register(self, 0)
450    }
451
452    #[doc = "Pmn Direction"]
453    #[inline(always)]
454    pub fn pdr12(
455        self,
456    ) -> crate::common::RegisterField<
457        12,
458        0x1,
459        1,
460        0,
461        pcntr1::Pdr12,
462        pcntr1::Pdr12,
463        Pcntr1_SPEC,
464        crate::common::RW,
465    > {
466        crate::common::RegisterField::<
467            12,
468            0x1,
469            1,
470            0,
471            pcntr1::Pdr12,
472            pcntr1::Pdr12,
473            Pcntr1_SPEC,
474            crate::common::RW,
475        >::from_register(self, 0)
476    }
477
478    #[doc = "Pmn Direction"]
479    #[inline(always)]
480    pub fn pdr13(
481        self,
482    ) -> crate::common::RegisterField<
483        13,
484        0x1,
485        1,
486        0,
487        pcntr1::Pdr13,
488        pcntr1::Pdr13,
489        Pcntr1_SPEC,
490        crate::common::RW,
491    > {
492        crate::common::RegisterField::<
493            13,
494            0x1,
495            1,
496            0,
497            pcntr1::Pdr13,
498            pcntr1::Pdr13,
499            Pcntr1_SPEC,
500            crate::common::RW,
501        >::from_register(self, 0)
502    }
503
504    #[doc = "Pmn Direction"]
505    #[inline(always)]
506    pub fn pdr14(
507        self,
508    ) -> crate::common::RegisterField<
509        14,
510        0x1,
511        1,
512        0,
513        pcntr1::Pdr14,
514        pcntr1::Pdr14,
515        Pcntr1_SPEC,
516        crate::common::RW,
517    > {
518        crate::common::RegisterField::<
519            14,
520            0x1,
521            1,
522            0,
523            pcntr1::Pdr14,
524            pcntr1::Pdr14,
525            Pcntr1_SPEC,
526            crate::common::RW,
527        >::from_register(self, 0)
528    }
529
530    #[doc = "Pmn Direction"]
531    #[inline(always)]
532    pub fn pdr15(
533        self,
534    ) -> crate::common::RegisterField<
535        15,
536        0x1,
537        1,
538        0,
539        pcntr1::Pdr15,
540        pcntr1::Pdr15,
541        Pcntr1_SPEC,
542        crate::common::RW,
543    > {
544        crate::common::RegisterField::<
545            15,
546            0x1,
547            1,
548            0,
549            pcntr1::Pdr15,
550            pcntr1::Pdr15,
551            Pcntr1_SPEC,
552            crate::common::RW,
553        >::from_register(self, 0)
554    }
555
556    #[doc = "Pmn Output Data"]
557    #[inline(always)]
558    pub fn podr00(
559        self,
560    ) -> crate::common::RegisterField<
561        16,
562        0x1,
563        1,
564        0,
565        pcntr1::Podr00,
566        pcntr1::Podr00,
567        Pcntr1_SPEC,
568        crate::common::RW,
569    > {
570        crate::common::RegisterField::<
571            16,
572            0x1,
573            1,
574            0,
575            pcntr1::Podr00,
576            pcntr1::Podr00,
577            Pcntr1_SPEC,
578            crate::common::RW,
579        >::from_register(self, 0)
580    }
581
582    #[doc = "Pmn Output Data"]
583    #[inline(always)]
584    pub fn podr01(
585        self,
586    ) -> crate::common::RegisterField<
587        17,
588        0x1,
589        1,
590        0,
591        pcntr1::Podr01,
592        pcntr1::Podr01,
593        Pcntr1_SPEC,
594        crate::common::RW,
595    > {
596        crate::common::RegisterField::<
597            17,
598            0x1,
599            1,
600            0,
601            pcntr1::Podr01,
602            pcntr1::Podr01,
603            Pcntr1_SPEC,
604            crate::common::RW,
605        >::from_register(self, 0)
606    }
607
608    #[doc = "Pmn Output Data"]
609    #[inline(always)]
610    pub fn podr02(
611        self,
612    ) -> crate::common::RegisterField<
613        18,
614        0x1,
615        1,
616        0,
617        pcntr1::Podr02,
618        pcntr1::Podr02,
619        Pcntr1_SPEC,
620        crate::common::RW,
621    > {
622        crate::common::RegisterField::<
623            18,
624            0x1,
625            1,
626            0,
627            pcntr1::Podr02,
628            pcntr1::Podr02,
629            Pcntr1_SPEC,
630            crate::common::RW,
631        >::from_register(self, 0)
632    }
633
634    #[doc = "Pmn Output Data"]
635    #[inline(always)]
636    pub fn podr03(
637        self,
638    ) -> crate::common::RegisterField<
639        19,
640        0x1,
641        1,
642        0,
643        pcntr1::Podr03,
644        pcntr1::Podr03,
645        Pcntr1_SPEC,
646        crate::common::RW,
647    > {
648        crate::common::RegisterField::<
649            19,
650            0x1,
651            1,
652            0,
653            pcntr1::Podr03,
654            pcntr1::Podr03,
655            Pcntr1_SPEC,
656            crate::common::RW,
657        >::from_register(self, 0)
658    }
659
660    #[doc = "Pmn Output Data"]
661    #[inline(always)]
662    pub fn podr04(
663        self,
664    ) -> crate::common::RegisterField<
665        20,
666        0x1,
667        1,
668        0,
669        pcntr1::Podr04,
670        pcntr1::Podr04,
671        Pcntr1_SPEC,
672        crate::common::RW,
673    > {
674        crate::common::RegisterField::<
675            20,
676            0x1,
677            1,
678            0,
679            pcntr1::Podr04,
680            pcntr1::Podr04,
681            Pcntr1_SPEC,
682            crate::common::RW,
683        >::from_register(self, 0)
684    }
685
686    #[doc = "Pmn Output Data"]
687    #[inline(always)]
688    pub fn podr05(
689        self,
690    ) -> crate::common::RegisterField<
691        21,
692        0x1,
693        1,
694        0,
695        pcntr1::Podr05,
696        pcntr1::Podr05,
697        Pcntr1_SPEC,
698        crate::common::RW,
699    > {
700        crate::common::RegisterField::<
701            21,
702            0x1,
703            1,
704            0,
705            pcntr1::Podr05,
706            pcntr1::Podr05,
707            Pcntr1_SPEC,
708            crate::common::RW,
709        >::from_register(self, 0)
710    }
711
712    #[doc = "Pmn Output Data"]
713    #[inline(always)]
714    pub fn podr06(
715        self,
716    ) -> crate::common::RegisterField<
717        22,
718        0x1,
719        1,
720        0,
721        pcntr1::Podr06,
722        pcntr1::Podr06,
723        Pcntr1_SPEC,
724        crate::common::RW,
725    > {
726        crate::common::RegisterField::<
727            22,
728            0x1,
729            1,
730            0,
731            pcntr1::Podr06,
732            pcntr1::Podr06,
733            Pcntr1_SPEC,
734            crate::common::RW,
735        >::from_register(self, 0)
736    }
737
738    #[doc = "Pmn Output Data"]
739    #[inline(always)]
740    pub fn podr07(
741        self,
742    ) -> crate::common::RegisterField<
743        23,
744        0x1,
745        1,
746        0,
747        pcntr1::Podr07,
748        pcntr1::Podr07,
749        Pcntr1_SPEC,
750        crate::common::RW,
751    > {
752        crate::common::RegisterField::<
753            23,
754            0x1,
755            1,
756            0,
757            pcntr1::Podr07,
758            pcntr1::Podr07,
759            Pcntr1_SPEC,
760            crate::common::RW,
761        >::from_register(self, 0)
762    }
763
764    #[doc = "Pmn Output Data"]
765    #[inline(always)]
766    pub fn podr08(
767        self,
768    ) -> crate::common::RegisterField<
769        24,
770        0x1,
771        1,
772        0,
773        pcntr1::Podr08,
774        pcntr1::Podr08,
775        Pcntr1_SPEC,
776        crate::common::RW,
777    > {
778        crate::common::RegisterField::<
779            24,
780            0x1,
781            1,
782            0,
783            pcntr1::Podr08,
784            pcntr1::Podr08,
785            Pcntr1_SPEC,
786            crate::common::RW,
787        >::from_register(self, 0)
788    }
789
790    #[doc = "Pmn Output Data"]
791    #[inline(always)]
792    pub fn podr09(
793        self,
794    ) -> crate::common::RegisterField<
795        25,
796        0x1,
797        1,
798        0,
799        pcntr1::Podr09,
800        pcntr1::Podr09,
801        Pcntr1_SPEC,
802        crate::common::RW,
803    > {
804        crate::common::RegisterField::<
805            25,
806            0x1,
807            1,
808            0,
809            pcntr1::Podr09,
810            pcntr1::Podr09,
811            Pcntr1_SPEC,
812            crate::common::RW,
813        >::from_register(self, 0)
814    }
815
816    #[doc = "Pmn Output Data"]
817    #[inline(always)]
818    pub fn podr10(
819        self,
820    ) -> crate::common::RegisterField<
821        26,
822        0x1,
823        1,
824        0,
825        pcntr1::Podr10,
826        pcntr1::Podr10,
827        Pcntr1_SPEC,
828        crate::common::RW,
829    > {
830        crate::common::RegisterField::<
831            26,
832            0x1,
833            1,
834            0,
835            pcntr1::Podr10,
836            pcntr1::Podr10,
837            Pcntr1_SPEC,
838            crate::common::RW,
839        >::from_register(self, 0)
840    }
841
842    #[doc = "Pmn Output Data"]
843    #[inline(always)]
844    pub fn podr11(
845        self,
846    ) -> crate::common::RegisterField<
847        27,
848        0x1,
849        1,
850        0,
851        pcntr1::Podr11,
852        pcntr1::Podr11,
853        Pcntr1_SPEC,
854        crate::common::RW,
855    > {
856        crate::common::RegisterField::<
857            27,
858            0x1,
859            1,
860            0,
861            pcntr1::Podr11,
862            pcntr1::Podr11,
863            Pcntr1_SPEC,
864            crate::common::RW,
865        >::from_register(self, 0)
866    }
867
868    #[doc = "Pmn Output Data"]
869    #[inline(always)]
870    pub fn podr12(
871        self,
872    ) -> crate::common::RegisterField<
873        28,
874        0x1,
875        1,
876        0,
877        pcntr1::Podr12,
878        pcntr1::Podr12,
879        Pcntr1_SPEC,
880        crate::common::RW,
881    > {
882        crate::common::RegisterField::<
883            28,
884            0x1,
885            1,
886            0,
887            pcntr1::Podr12,
888            pcntr1::Podr12,
889            Pcntr1_SPEC,
890            crate::common::RW,
891        >::from_register(self, 0)
892    }
893
894    #[doc = "Pmn Output Data"]
895    #[inline(always)]
896    pub fn podr13(
897        self,
898    ) -> crate::common::RegisterField<
899        29,
900        0x1,
901        1,
902        0,
903        pcntr1::Podr13,
904        pcntr1::Podr13,
905        Pcntr1_SPEC,
906        crate::common::RW,
907    > {
908        crate::common::RegisterField::<
909            29,
910            0x1,
911            1,
912            0,
913            pcntr1::Podr13,
914            pcntr1::Podr13,
915            Pcntr1_SPEC,
916            crate::common::RW,
917        >::from_register(self, 0)
918    }
919
920    #[doc = "Pmn Output Data"]
921    #[inline(always)]
922    pub fn podr14(
923        self,
924    ) -> crate::common::RegisterField<
925        30,
926        0x1,
927        1,
928        0,
929        pcntr1::Podr14,
930        pcntr1::Podr14,
931        Pcntr1_SPEC,
932        crate::common::RW,
933    > {
934        crate::common::RegisterField::<
935            30,
936            0x1,
937            1,
938            0,
939            pcntr1::Podr14,
940            pcntr1::Podr14,
941            Pcntr1_SPEC,
942            crate::common::RW,
943        >::from_register(self, 0)
944    }
945
946    #[doc = "Pmn Output Data"]
947    #[inline(always)]
948    pub fn podr15(
949        self,
950    ) -> crate::common::RegisterField<
951        31,
952        0x1,
953        1,
954        0,
955        pcntr1::Podr15,
956        pcntr1::Podr15,
957        Pcntr1_SPEC,
958        crate::common::RW,
959    > {
960        crate::common::RegisterField::<
961            31,
962            0x1,
963            1,
964            0,
965            pcntr1::Podr15,
966            pcntr1::Podr15,
967            Pcntr1_SPEC,
968            crate::common::RW,
969        >::from_register(self, 0)
970    }
971}
972impl ::core::default::Default for Pcntr1 {
973    #[inline(always)]
974    fn default() -> Pcntr1 {
975        <crate::RegValueT<Pcntr1_SPEC> as RegisterValue<_>>::new(0)
976    }
977}
978pub mod pcntr1 {
979
980    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
981    pub struct Pdr00_SPEC;
982    pub type Pdr00 = crate::EnumBitfieldStruct<u8, Pdr00_SPEC>;
983    impl Pdr00 {
984        #[doc = "Input (functions as an input pin)"]
985        pub const _0: Self = Self::new(0);
986
987        #[doc = "Output (functions as an output pin)"]
988        pub const _1: Self = Self::new(1);
989    }
990    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
991    pub struct Pdr01_SPEC;
992    pub type Pdr01 = crate::EnumBitfieldStruct<u8, Pdr01_SPEC>;
993    impl Pdr01 {
994        #[doc = "Input (functions as an input pin)"]
995        pub const _0: Self = Self::new(0);
996
997        #[doc = "Output (functions as an output pin)"]
998        pub const _1: Self = Self::new(1);
999    }
1000    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1001    pub struct Pdr02_SPEC;
1002    pub type Pdr02 = crate::EnumBitfieldStruct<u8, Pdr02_SPEC>;
1003    impl Pdr02 {
1004        #[doc = "Input (functions as an input pin)"]
1005        pub const _0: Self = Self::new(0);
1006
1007        #[doc = "Output (functions as an output pin)"]
1008        pub const _1: Self = Self::new(1);
1009    }
1010    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1011    pub struct Pdr03_SPEC;
1012    pub type Pdr03 = crate::EnumBitfieldStruct<u8, Pdr03_SPEC>;
1013    impl Pdr03 {
1014        #[doc = "Input (functions as an input pin)"]
1015        pub const _0: Self = Self::new(0);
1016
1017        #[doc = "Output (functions as an output pin)"]
1018        pub const _1: Self = Self::new(1);
1019    }
1020    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1021    pub struct Pdr04_SPEC;
1022    pub type Pdr04 = crate::EnumBitfieldStruct<u8, Pdr04_SPEC>;
1023    impl Pdr04 {
1024        #[doc = "Input (functions as an input pin)"]
1025        pub const _0: Self = Self::new(0);
1026
1027        #[doc = "Output (functions as an output pin)"]
1028        pub const _1: Self = Self::new(1);
1029    }
1030    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1031    pub struct Pdr05_SPEC;
1032    pub type Pdr05 = crate::EnumBitfieldStruct<u8, Pdr05_SPEC>;
1033    impl Pdr05 {
1034        #[doc = "Input (functions as an input pin)"]
1035        pub const _0: Self = Self::new(0);
1036
1037        #[doc = "Output (functions as an output pin)"]
1038        pub const _1: Self = Self::new(1);
1039    }
1040    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1041    pub struct Pdr06_SPEC;
1042    pub type Pdr06 = crate::EnumBitfieldStruct<u8, Pdr06_SPEC>;
1043    impl Pdr06 {
1044        #[doc = "Input (functions as an input pin)"]
1045        pub const _0: Self = Self::new(0);
1046
1047        #[doc = "Output (functions as an output pin)"]
1048        pub const _1: Self = Self::new(1);
1049    }
1050    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1051    pub struct Pdr07_SPEC;
1052    pub type Pdr07 = crate::EnumBitfieldStruct<u8, Pdr07_SPEC>;
1053    impl Pdr07 {
1054        #[doc = "Input (functions as an input pin)"]
1055        pub const _0: Self = Self::new(0);
1056
1057        #[doc = "Output (functions as an output pin)"]
1058        pub const _1: Self = Self::new(1);
1059    }
1060    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1061    pub struct Pdr08_SPEC;
1062    pub type Pdr08 = crate::EnumBitfieldStruct<u8, Pdr08_SPEC>;
1063    impl Pdr08 {
1064        #[doc = "Input (functions as an input pin)"]
1065        pub const _0: Self = Self::new(0);
1066
1067        #[doc = "Output (functions as an output pin)"]
1068        pub const _1: Self = Self::new(1);
1069    }
1070    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1071    pub struct Pdr09_SPEC;
1072    pub type Pdr09 = crate::EnumBitfieldStruct<u8, Pdr09_SPEC>;
1073    impl Pdr09 {
1074        #[doc = "Input (functions as an input pin)"]
1075        pub const _0: Self = Self::new(0);
1076
1077        #[doc = "Output (functions as an output pin)"]
1078        pub const _1: Self = Self::new(1);
1079    }
1080    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1081    pub struct Pdr10_SPEC;
1082    pub type Pdr10 = crate::EnumBitfieldStruct<u8, Pdr10_SPEC>;
1083    impl Pdr10 {
1084        #[doc = "Input (functions as an input pin)"]
1085        pub const _0: Self = Self::new(0);
1086
1087        #[doc = "Output (functions as an output pin)"]
1088        pub const _1: Self = Self::new(1);
1089    }
1090    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1091    pub struct Pdr11_SPEC;
1092    pub type Pdr11 = crate::EnumBitfieldStruct<u8, Pdr11_SPEC>;
1093    impl Pdr11 {
1094        #[doc = "Input (functions as an input pin)"]
1095        pub const _0: Self = Self::new(0);
1096
1097        #[doc = "Output (functions as an output pin)"]
1098        pub const _1: Self = Self::new(1);
1099    }
1100    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1101    pub struct Pdr12_SPEC;
1102    pub type Pdr12 = crate::EnumBitfieldStruct<u8, Pdr12_SPEC>;
1103    impl Pdr12 {
1104        #[doc = "Input (functions as an input pin)"]
1105        pub const _0: Self = Self::new(0);
1106
1107        #[doc = "Output (functions as an output pin)"]
1108        pub const _1: Self = Self::new(1);
1109    }
1110    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1111    pub struct Pdr13_SPEC;
1112    pub type Pdr13 = crate::EnumBitfieldStruct<u8, Pdr13_SPEC>;
1113    impl Pdr13 {
1114        #[doc = "Input (functions as an input pin)"]
1115        pub const _0: Self = Self::new(0);
1116
1117        #[doc = "Output (functions as an output pin)"]
1118        pub const _1: Self = Self::new(1);
1119    }
1120    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1121    pub struct Pdr14_SPEC;
1122    pub type Pdr14 = crate::EnumBitfieldStruct<u8, Pdr14_SPEC>;
1123    impl Pdr14 {
1124        #[doc = "Input (functions as an input pin)"]
1125        pub const _0: Self = Self::new(0);
1126
1127        #[doc = "Output (functions as an output pin)"]
1128        pub const _1: Self = Self::new(1);
1129    }
1130    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1131    pub struct Pdr15_SPEC;
1132    pub type Pdr15 = crate::EnumBitfieldStruct<u8, Pdr15_SPEC>;
1133    impl Pdr15 {
1134        #[doc = "Input (functions as an input pin)"]
1135        pub const _0: Self = Self::new(0);
1136
1137        #[doc = "Output (functions as an output pin)"]
1138        pub const _1: Self = Self::new(1);
1139    }
1140    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1141    pub struct Podr00_SPEC;
1142    pub type Podr00 = crate::EnumBitfieldStruct<u8, Podr00_SPEC>;
1143    impl Podr00 {
1144        #[doc = "Low output"]
1145        pub const _0: Self = Self::new(0);
1146
1147        #[doc = "High output"]
1148        pub const _1: Self = Self::new(1);
1149    }
1150    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1151    pub struct Podr01_SPEC;
1152    pub type Podr01 = crate::EnumBitfieldStruct<u8, Podr01_SPEC>;
1153    impl Podr01 {
1154        #[doc = "Low output"]
1155        pub const _0: Self = Self::new(0);
1156
1157        #[doc = "High output"]
1158        pub const _1: Self = Self::new(1);
1159    }
1160    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1161    pub struct Podr02_SPEC;
1162    pub type Podr02 = crate::EnumBitfieldStruct<u8, Podr02_SPEC>;
1163    impl Podr02 {
1164        #[doc = "Low output"]
1165        pub const _0: Self = Self::new(0);
1166
1167        #[doc = "High output"]
1168        pub const _1: Self = Self::new(1);
1169    }
1170    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1171    pub struct Podr03_SPEC;
1172    pub type Podr03 = crate::EnumBitfieldStruct<u8, Podr03_SPEC>;
1173    impl Podr03 {
1174        #[doc = "Low output"]
1175        pub const _0: Self = Self::new(0);
1176
1177        #[doc = "High output"]
1178        pub const _1: Self = Self::new(1);
1179    }
1180    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1181    pub struct Podr04_SPEC;
1182    pub type Podr04 = crate::EnumBitfieldStruct<u8, Podr04_SPEC>;
1183    impl Podr04 {
1184        #[doc = "Low output"]
1185        pub const _0: Self = Self::new(0);
1186
1187        #[doc = "High output"]
1188        pub const _1: Self = Self::new(1);
1189    }
1190    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1191    pub struct Podr05_SPEC;
1192    pub type Podr05 = crate::EnumBitfieldStruct<u8, Podr05_SPEC>;
1193    impl Podr05 {
1194        #[doc = "Low output"]
1195        pub const _0: Self = Self::new(0);
1196
1197        #[doc = "High output"]
1198        pub const _1: Self = Self::new(1);
1199    }
1200    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1201    pub struct Podr06_SPEC;
1202    pub type Podr06 = crate::EnumBitfieldStruct<u8, Podr06_SPEC>;
1203    impl Podr06 {
1204        #[doc = "Low output"]
1205        pub const _0: Self = Self::new(0);
1206
1207        #[doc = "High output"]
1208        pub const _1: Self = Self::new(1);
1209    }
1210    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1211    pub struct Podr07_SPEC;
1212    pub type Podr07 = crate::EnumBitfieldStruct<u8, Podr07_SPEC>;
1213    impl Podr07 {
1214        #[doc = "Low output"]
1215        pub const _0: Self = Self::new(0);
1216
1217        #[doc = "High output"]
1218        pub const _1: Self = Self::new(1);
1219    }
1220    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1221    pub struct Podr08_SPEC;
1222    pub type Podr08 = crate::EnumBitfieldStruct<u8, Podr08_SPEC>;
1223    impl Podr08 {
1224        #[doc = "Low output"]
1225        pub const _0: Self = Self::new(0);
1226
1227        #[doc = "High output"]
1228        pub const _1: Self = Self::new(1);
1229    }
1230    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1231    pub struct Podr09_SPEC;
1232    pub type Podr09 = crate::EnumBitfieldStruct<u8, Podr09_SPEC>;
1233    impl Podr09 {
1234        #[doc = "Low output"]
1235        pub const _0: Self = Self::new(0);
1236
1237        #[doc = "High output"]
1238        pub const _1: Self = Self::new(1);
1239    }
1240    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1241    pub struct Podr10_SPEC;
1242    pub type Podr10 = crate::EnumBitfieldStruct<u8, Podr10_SPEC>;
1243    impl Podr10 {
1244        #[doc = "Low output"]
1245        pub const _0: Self = Self::new(0);
1246
1247        #[doc = "High output"]
1248        pub const _1: Self = Self::new(1);
1249    }
1250    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1251    pub struct Podr11_SPEC;
1252    pub type Podr11 = crate::EnumBitfieldStruct<u8, Podr11_SPEC>;
1253    impl Podr11 {
1254        #[doc = "Low output"]
1255        pub const _0: Self = Self::new(0);
1256
1257        #[doc = "High output"]
1258        pub const _1: Self = Self::new(1);
1259    }
1260    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1261    pub struct Podr12_SPEC;
1262    pub type Podr12 = crate::EnumBitfieldStruct<u8, Podr12_SPEC>;
1263    impl Podr12 {
1264        #[doc = "Low output"]
1265        pub const _0: Self = Self::new(0);
1266
1267        #[doc = "High output"]
1268        pub const _1: Self = Self::new(1);
1269    }
1270    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1271    pub struct Podr13_SPEC;
1272    pub type Podr13 = crate::EnumBitfieldStruct<u8, Podr13_SPEC>;
1273    impl Podr13 {
1274        #[doc = "Low output"]
1275        pub const _0: Self = Self::new(0);
1276
1277        #[doc = "High output"]
1278        pub const _1: Self = Self::new(1);
1279    }
1280    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1281    pub struct Podr14_SPEC;
1282    pub type Podr14 = crate::EnumBitfieldStruct<u8, Podr14_SPEC>;
1283    impl Podr14 {
1284        #[doc = "Low output"]
1285        pub const _0: Self = Self::new(0);
1286
1287        #[doc = "High output"]
1288        pub const _1: Self = Self::new(1);
1289    }
1290    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1291    pub struct Podr15_SPEC;
1292    pub type Podr15 = crate::EnumBitfieldStruct<u8, Podr15_SPEC>;
1293    impl Podr15 {
1294        #[doc = "Low output"]
1295        pub const _0: Self = Self::new(0);
1296
1297        #[doc = "High output"]
1298        pub const _1: Self = Self::new(1);
1299    }
1300}
1301#[doc(hidden)]
1302#[derive(Copy, Clone, Eq, PartialEq)]
1303pub struct Podr_SPEC;
1304impl crate::sealed::RegSpec for Podr_SPEC {
1305    type DataType = u16;
1306}
1307
1308#[doc = "Port Control Register 1"]
1309pub type Podr = crate::RegValueT<Podr_SPEC>;
1310
1311impl Podr {
1312    #[doc = "Pmn Output Data"]
1313    #[inline(always)]
1314    pub fn podr00(
1315        self,
1316    ) -> crate::common::RegisterField<
1317        0,
1318        0x1,
1319        1,
1320        0,
1321        podr::Podr00,
1322        podr::Podr00,
1323        Podr_SPEC,
1324        crate::common::RW,
1325    > {
1326        crate::common::RegisterField::<
1327            0,
1328            0x1,
1329            1,
1330            0,
1331            podr::Podr00,
1332            podr::Podr00,
1333            Podr_SPEC,
1334            crate::common::RW,
1335        >::from_register(self, 0)
1336    }
1337
1338    #[doc = "Pmn Output Data"]
1339    #[inline(always)]
1340    pub fn podr01(
1341        self,
1342    ) -> crate::common::RegisterField<
1343        1,
1344        0x1,
1345        1,
1346        0,
1347        podr::Podr01,
1348        podr::Podr01,
1349        Podr_SPEC,
1350        crate::common::RW,
1351    > {
1352        crate::common::RegisterField::<
1353            1,
1354            0x1,
1355            1,
1356            0,
1357            podr::Podr01,
1358            podr::Podr01,
1359            Podr_SPEC,
1360            crate::common::RW,
1361        >::from_register(self, 0)
1362    }
1363
1364    #[doc = "Pmn Output Data"]
1365    #[inline(always)]
1366    pub fn podr02(
1367        self,
1368    ) -> crate::common::RegisterField<
1369        2,
1370        0x1,
1371        1,
1372        0,
1373        podr::Podr02,
1374        podr::Podr02,
1375        Podr_SPEC,
1376        crate::common::RW,
1377    > {
1378        crate::common::RegisterField::<
1379            2,
1380            0x1,
1381            1,
1382            0,
1383            podr::Podr02,
1384            podr::Podr02,
1385            Podr_SPEC,
1386            crate::common::RW,
1387        >::from_register(self, 0)
1388    }
1389
1390    #[doc = "Pmn Output Data"]
1391    #[inline(always)]
1392    pub fn podr03(
1393        self,
1394    ) -> crate::common::RegisterField<
1395        3,
1396        0x1,
1397        1,
1398        0,
1399        podr::Podr03,
1400        podr::Podr03,
1401        Podr_SPEC,
1402        crate::common::RW,
1403    > {
1404        crate::common::RegisterField::<
1405            3,
1406            0x1,
1407            1,
1408            0,
1409            podr::Podr03,
1410            podr::Podr03,
1411            Podr_SPEC,
1412            crate::common::RW,
1413        >::from_register(self, 0)
1414    }
1415
1416    #[doc = "Pmn Output Data"]
1417    #[inline(always)]
1418    pub fn podr04(
1419        self,
1420    ) -> crate::common::RegisterField<
1421        4,
1422        0x1,
1423        1,
1424        0,
1425        podr::Podr04,
1426        podr::Podr04,
1427        Podr_SPEC,
1428        crate::common::RW,
1429    > {
1430        crate::common::RegisterField::<
1431            4,
1432            0x1,
1433            1,
1434            0,
1435            podr::Podr04,
1436            podr::Podr04,
1437            Podr_SPEC,
1438            crate::common::RW,
1439        >::from_register(self, 0)
1440    }
1441
1442    #[doc = "Pmn Output Data"]
1443    #[inline(always)]
1444    pub fn podr05(
1445        self,
1446    ) -> crate::common::RegisterField<
1447        5,
1448        0x1,
1449        1,
1450        0,
1451        podr::Podr05,
1452        podr::Podr05,
1453        Podr_SPEC,
1454        crate::common::RW,
1455    > {
1456        crate::common::RegisterField::<
1457            5,
1458            0x1,
1459            1,
1460            0,
1461            podr::Podr05,
1462            podr::Podr05,
1463            Podr_SPEC,
1464            crate::common::RW,
1465        >::from_register(self, 0)
1466    }
1467
1468    #[doc = "Pmn Output Data"]
1469    #[inline(always)]
1470    pub fn podr06(
1471        self,
1472    ) -> crate::common::RegisterField<
1473        6,
1474        0x1,
1475        1,
1476        0,
1477        podr::Podr06,
1478        podr::Podr06,
1479        Podr_SPEC,
1480        crate::common::RW,
1481    > {
1482        crate::common::RegisterField::<
1483            6,
1484            0x1,
1485            1,
1486            0,
1487            podr::Podr06,
1488            podr::Podr06,
1489            Podr_SPEC,
1490            crate::common::RW,
1491        >::from_register(self, 0)
1492    }
1493
1494    #[doc = "Pmn Output Data"]
1495    #[inline(always)]
1496    pub fn podr07(
1497        self,
1498    ) -> crate::common::RegisterField<
1499        7,
1500        0x1,
1501        1,
1502        0,
1503        podr::Podr07,
1504        podr::Podr07,
1505        Podr_SPEC,
1506        crate::common::RW,
1507    > {
1508        crate::common::RegisterField::<
1509            7,
1510            0x1,
1511            1,
1512            0,
1513            podr::Podr07,
1514            podr::Podr07,
1515            Podr_SPEC,
1516            crate::common::RW,
1517        >::from_register(self, 0)
1518    }
1519
1520    #[doc = "Pmn Output Data"]
1521    #[inline(always)]
1522    pub fn podr08(
1523        self,
1524    ) -> crate::common::RegisterField<
1525        8,
1526        0x1,
1527        1,
1528        0,
1529        podr::Podr08,
1530        podr::Podr08,
1531        Podr_SPEC,
1532        crate::common::RW,
1533    > {
1534        crate::common::RegisterField::<
1535            8,
1536            0x1,
1537            1,
1538            0,
1539            podr::Podr08,
1540            podr::Podr08,
1541            Podr_SPEC,
1542            crate::common::RW,
1543        >::from_register(self, 0)
1544    }
1545
1546    #[doc = "Pmn Output Data"]
1547    #[inline(always)]
1548    pub fn podr09(
1549        self,
1550    ) -> crate::common::RegisterField<
1551        9,
1552        0x1,
1553        1,
1554        0,
1555        podr::Podr09,
1556        podr::Podr09,
1557        Podr_SPEC,
1558        crate::common::RW,
1559    > {
1560        crate::common::RegisterField::<
1561            9,
1562            0x1,
1563            1,
1564            0,
1565            podr::Podr09,
1566            podr::Podr09,
1567            Podr_SPEC,
1568            crate::common::RW,
1569        >::from_register(self, 0)
1570    }
1571
1572    #[doc = "Pmn Output Data"]
1573    #[inline(always)]
1574    pub fn podr10(
1575        self,
1576    ) -> crate::common::RegisterField<
1577        10,
1578        0x1,
1579        1,
1580        0,
1581        podr::Podr10,
1582        podr::Podr10,
1583        Podr_SPEC,
1584        crate::common::RW,
1585    > {
1586        crate::common::RegisterField::<
1587            10,
1588            0x1,
1589            1,
1590            0,
1591            podr::Podr10,
1592            podr::Podr10,
1593            Podr_SPEC,
1594            crate::common::RW,
1595        >::from_register(self, 0)
1596    }
1597
1598    #[doc = "Pmn Output Data"]
1599    #[inline(always)]
1600    pub fn podr11(
1601        self,
1602    ) -> crate::common::RegisterField<
1603        11,
1604        0x1,
1605        1,
1606        0,
1607        podr::Podr11,
1608        podr::Podr11,
1609        Podr_SPEC,
1610        crate::common::RW,
1611    > {
1612        crate::common::RegisterField::<
1613            11,
1614            0x1,
1615            1,
1616            0,
1617            podr::Podr11,
1618            podr::Podr11,
1619            Podr_SPEC,
1620            crate::common::RW,
1621        >::from_register(self, 0)
1622    }
1623
1624    #[doc = "Pmn Output Data"]
1625    #[inline(always)]
1626    pub fn podr12(
1627        self,
1628    ) -> crate::common::RegisterField<
1629        12,
1630        0x1,
1631        1,
1632        0,
1633        podr::Podr12,
1634        podr::Podr12,
1635        Podr_SPEC,
1636        crate::common::RW,
1637    > {
1638        crate::common::RegisterField::<
1639            12,
1640            0x1,
1641            1,
1642            0,
1643            podr::Podr12,
1644            podr::Podr12,
1645            Podr_SPEC,
1646            crate::common::RW,
1647        >::from_register(self, 0)
1648    }
1649
1650    #[doc = "Pmn Output Data"]
1651    #[inline(always)]
1652    pub fn podr13(
1653        self,
1654    ) -> crate::common::RegisterField<
1655        13,
1656        0x1,
1657        1,
1658        0,
1659        podr::Podr13,
1660        podr::Podr13,
1661        Podr_SPEC,
1662        crate::common::RW,
1663    > {
1664        crate::common::RegisterField::<
1665            13,
1666            0x1,
1667            1,
1668            0,
1669            podr::Podr13,
1670            podr::Podr13,
1671            Podr_SPEC,
1672            crate::common::RW,
1673        >::from_register(self, 0)
1674    }
1675
1676    #[doc = "Pmn Output Data"]
1677    #[inline(always)]
1678    pub fn podr14(
1679        self,
1680    ) -> crate::common::RegisterField<
1681        14,
1682        0x1,
1683        1,
1684        0,
1685        podr::Podr14,
1686        podr::Podr14,
1687        Podr_SPEC,
1688        crate::common::RW,
1689    > {
1690        crate::common::RegisterField::<
1691            14,
1692            0x1,
1693            1,
1694            0,
1695            podr::Podr14,
1696            podr::Podr14,
1697            Podr_SPEC,
1698            crate::common::RW,
1699        >::from_register(self, 0)
1700    }
1701
1702    #[doc = "Pmn Output Data"]
1703    #[inline(always)]
1704    pub fn podr15(
1705        self,
1706    ) -> crate::common::RegisterField<
1707        15,
1708        0x1,
1709        1,
1710        0,
1711        podr::Podr15,
1712        podr::Podr15,
1713        Podr_SPEC,
1714        crate::common::RW,
1715    > {
1716        crate::common::RegisterField::<
1717            15,
1718            0x1,
1719            1,
1720            0,
1721            podr::Podr15,
1722            podr::Podr15,
1723            Podr_SPEC,
1724            crate::common::RW,
1725        >::from_register(self, 0)
1726    }
1727}
1728impl ::core::default::Default for Podr {
1729    #[inline(always)]
1730    fn default() -> Podr {
1731        <crate::RegValueT<Podr_SPEC> as RegisterValue<_>>::new(0)
1732    }
1733}
1734pub mod podr {
1735
1736    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1737    pub struct Podr00_SPEC;
1738    pub type Podr00 = crate::EnumBitfieldStruct<u8, Podr00_SPEC>;
1739    impl Podr00 {
1740        #[doc = "Low output"]
1741        pub const _0: Self = Self::new(0);
1742
1743        #[doc = "High output"]
1744        pub const _1: Self = Self::new(1);
1745    }
1746    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1747    pub struct Podr01_SPEC;
1748    pub type Podr01 = crate::EnumBitfieldStruct<u8, Podr01_SPEC>;
1749    impl Podr01 {
1750        #[doc = "Low output"]
1751        pub const _0: Self = Self::new(0);
1752
1753        #[doc = "High output"]
1754        pub const _1: Self = Self::new(1);
1755    }
1756    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1757    pub struct Podr02_SPEC;
1758    pub type Podr02 = crate::EnumBitfieldStruct<u8, Podr02_SPEC>;
1759    impl Podr02 {
1760        #[doc = "Low output"]
1761        pub const _0: Self = Self::new(0);
1762
1763        #[doc = "High output"]
1764        pub const _1: Self = Self::new(1);
1765    }
1766    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1767    pub struct Podr03_SPEC;
1768    pub type Podr03 = crate::EnumBitfieldStruct<u8, Podr03_SPEC>;
1769    impl Podr03 {
1770        #[doc = "Low output"]
1771        pub const _0: Self = Self::new(0);
1772
1773        #[doc = "High output"]
1774        pub const _1: Self = Self::new(1);
1775    }
1776    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1777    pub struct Podr04_SPEC;
1778    pub type Podr04 = crate::EnumBitfieldStruct<u8, Podr04_SPEC>;
1779    impl Podr04 {
1780        #[doc = "Low output"]
1781        pub const _0: Self = Self::new(0);
1782
1783        #[doc = "High output"]
1784        pub const _1: Self = Self::new(1);
1785    }
1786    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1787    pub struct Podr05_SPEC;
1788    pub type Podr05 = crate::EnumBitfieldStruct<u8, Podr05_SPEC>;
1789    impl Podr05 {
1790        #[doc = "Low output"]
1791        pub const _0: Self = Self::new(0);
1792
1793        #[doc = "High output"]
1794        pub const _1: Self = Self::new(1);
1795    }
1796    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1797    pub struct Podr06_SPEC;
1798    pub type Podr06 = crate::EnumBitfieldStruct<u8, Podr06_SPEC>;
1799    impl Podr06 {
1800        #[doc = "Low output"]
1801        pub const _0: Self = Self::new(0);
1802
1803        #[doc = "High output"]
1804        pub const _1: Self = Self::new(1);
1805    }
1806    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1807    pub struct Podr07_SPEC;
1808    pub type Podr07 = crate::EnumBitfieldStruct<u8, Podr07_SPEC>;
1809    impl Podr07 {
1810        #[doc = "Low output"]
1811        pub const _0: Self = Self::new(0);
1812
1813        #[doc = "High output"]
1814        pub const _1: Self = Self::new(1);
1815    }
1816    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1817    pub struct Podr08_SPEC;
1818    pub type Podr08 = crate::EnumBitfieldStruct<u8, Podr08_SPEC>;
1819    impl Podr08 {
1820        #[doc = "Low output"]
1821        pub const _0: Self = Self::new(0);
1822
1823        #[doc = "High output"]
1824        pub const _1: Self = Self::new(1);
1825    }
1826    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1827    pub struct Podr09_SPEC;
1828    pub type Podr09 = crate::EnumBitfieldStruct<u8, Podr09_SPEC>;
1829    impl Podr09 {
1830        #[doc = "Low output"]
1831        pub const _0: Self = Self::new(0);
1832
1833        #[doc = "High output"]
1834        pub const _1: Self = Self::new(1);
1835    }
1836    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1837    pub struct Podr10_SPEC;
1838    pub type Podr10 = crate::EnumBitfieldStruct<u8, Podr10_SPEC>;
1839    impl Podr10 {
1840        #[doc = "Low output"]
1841        pub const _0: Self = Self::new(0);
1842
1843        #[doc = "High output"]
1844        pub const _1: Self = Self::new(1);
1845    }
1846    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1847    pub struct Podr11_SPEC;
1848    pub type Podr11 = crate::EnumBitfieldStruct<u8, Podr11_SPEC>;
1849    impl Podr11 {
1850        #[doc = "Low output"]
1851        pub const _0: Self = Self::new(0);
1852
1853        #[doc = "High output"]
1854        pub const _1: Self = Self::new(1);
1855    }
1856    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1857    pub struct Podr12_SPEC;
1858    pub type Podr12 = crate::EnumBitfieldStruct<u8, Podr12_SPEC>;
1859    impl Podr12 {
1860        #[doc = "Low output"]
1861        pub const _0: Self = Self::new(0);
1862
1863        #[doc = "High output"]
1864        pub const _1: Self = Self::new(1);
1865    }
1866    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1867    pub struct Podr13_SPEC;
1868    pub type Podr13 = crate::EnumBitfieldStruct<u8, Podr13_SPEC>;
1869    impl Podr13 {
1870        #[doc = "Low output"]
1871        pub const _0: Self = Self::new(0);
1872
1873        #[doc = "High output"]
1874        pub const _1: Self = Self::new(1);
1875    }
1876    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1877    pub struct Podr14_SPEC;
1878    pub type Podr14 = crate::EnumBitfieldStruct<u8, Podr14_SPEC>;
1879    impl Podr14 {
1880        #[doc = "Low output"]
1881        pub const _0: Self = Self::new(0);
1882
1883        #[doc = "High output"]
1884        pub const _1: Self = Self::new(1);
1885    }
1886    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1887    pub struct Podr15_SPEC;
1888    pub type Podr15 = crate::EnumBitfieldStruct<u8, Podr15_SPEC>;
1889    impl Podr15 {
1890        #[doc = "Low output"]
1891        pub const _0: Self = Self::new(0);
1892
1893        #[doc = "High output"]
1894        pub const _1: Self = Self::new(1);
1895    }
1896}
1897#[doc(hidden)]
1898#[derive(Copy, Clone, Eq, PartialEq)]
1899pub struct Pdr_SPEC;
1900impl crate::sealed::RegSpec for Pdr_SPEC {
1901    type DataType = u16;
1902}
1903
1904#[doc = "Port Control Register 1"]
1905pub type Pdr = crate::RegValueT<Pdr_SPEC>;
1906
1907impl Pdr {
1908    #[doc = "Pmn Direction"]
1909    #[inline(always)]
1910    pub fn pdr00(
1911        self,
1912    ) -> crate::common::RegisterField<
1913        0,
1914        0x1,
1915        1,
1916        0,
1917        pdr::Pdr00,
1918        pdr::Pdr00,
1919        Pdr_SPEC,
1920        crate::common::RW,
1921    > {
1922        crate::common::RegisterField::<
1923            0,
1924            0x1,
1925            1,
1926            0,
1927            pdr::Pdr00,
1928            pdr::Pdr00,
1929            Pdr_SPEC,
1930            crate::common::RW,
1931        >::from_register(self, 0)
1932    }
1933
1934    #[doc = "Pmn Direction"]
1935    #[inline(always)]
1936    pub fn pdr01(
1937        self,
1938    ) -> crate::common::RegisterField<
1939        1,
1940        0x1,
1941        1,
1942        0,
1943        pdr::Pdr01,
1944        pdr::Pdr01,
1945        Pdr_SPEC,
1946        crate::common::RW,
1947    > {
1948        crate::common::RegisterField::<
1949            1,
1950            0x1,
1951            1,
1952            0,
1953            pdr::Pdr01,
1954            pdr::Pdr01,
1955            Pdr_SPEC,
1956            crate::common::RW,
1957        >::from_register(self, 0)
1958    }
1959
1960    #[doc = "Pmn Direction"]
1961    #[inline(always)]
1962    pub fn pdr02(
1963        self,
1964    ) -> crate::common::RegisterField<
1965        2,
1966        0x1,
1967        1,
1968        0,
1969        pdr::Pdr02,
1970        pdr::Pdr02,
1971        Pdr_SPEC,
1972        crate::common::RW,
1973    > {
1974        crate::common::RegisterField::<
1975            2,
1976            0x1,
1977            1,
1978            0,
1979            pdr::Pdr02,
1980            pdr::Pdr02,
1981            Pdr_SPEC,
1982            crate::common::RW,
1983        >::from_register(self, 0)
1984    }
1985
1986    #[doc = "Pmn Direction"]
1987    #[inline(always)]
1988    pub fn pdr03(
1989        self,
1990    ) -> crate::common::RegisterField<
1991        3,
1992        0x1,
1993        1,
1994        0,
1995        pdr::Pdr03,
1996        pdr::Pdr03,
1997        Pdr_SPEC,
1998        crate::common::RW,
1999    > {
2000        crate::common::RegisterField::<
2001            3,
2002            0x1,
2003            1,
2004            0,
2005            pdr::Pdr03,
2006            pdr::Pdr03,
2007            Pdr_SPEC,
2008            crate::common::RW,
2009        >::from_register(self, 0)
2010    }
2011
2012    #[doc = "Pmn Direction"]
2013    #[inline(always)]
2014    pub fn pdr04(
2015        self,
2016    ) -> crate::common::RegisterField<
2017        4,
2018        0x1,
2019        1,
2020        0,
2021        pdr::Pdr04,
2022        pdr::Pdr04,
2023        Pdr_SPEC,
2024        crate::common::RW,
2025    > {
2026        crate::common::RegisterField::<
2027            4,
2028            0x1,
2029            1,
2030            0,
2031            pdr::Pdr04,
2032            pdr::Pdr04,
2033            Pdr_SPEC,
2034            crate::common::RW,
2035        >::from_register(self, 0)
2036    }
2037
2038    #[doc = "Pmn Direction"]
2039    #[inline(always)]
2040    pub fn pdr05(
2041        self,
2042    ) -> crate::common::RegisterField<
2043        5,
2044        0x1,
2045        1,
2046        0,
2047        pdr::Pdr05,
2048        pdr::Pdr05,
2049        Pdr_SPEC,
2050        crate::common::RW,
2051    > {
2052        crate::common::RegisterField::<
2053            5,
2054            0x1,
2055            1,
2056            0,
2057            pdr::Pdr05,
2058            pdr::Pdr05,
2059            Pdr_SPEC,
2060            crate::common::RW,
2061        >::from_register(self, 0)
2062    }
2063
2064    #[doc = "Pmn Direction"]
2065    #[inline(always)]
2066    pub fn pdr06(
2067        self,
2068    ) -> crate::common::RegisterField<
2069        6,
2070        0x1,
2071        1,
2072        0,
2073        pdr::Pdr06,
2074        pdr::Pdr06,
2075        Pdr_SPEC,
2076        crate::common::RW,
2077    > {
2078        crate::common::RegisterField::<
2079            6,
2080            0x1,
2081            1,
2082            0,
2083            pdr::Pdr06,
2084            pdr::Pdr06,
2085            Pdr_SPEC,
2086            crate::common::RW,
2087        >::from_register(self, 0)
2088    }
2089
2090    #[doc = "Pmn Direction"]
2091    #[inline(always)]
2092    pub fn pdr07(
2093        self,
2094    ) -> crate::common::RegisterField<
2095        7,
2096        0x1,
2097        1,
2098        0,
2099        pdr::Pdr07,
2100        pdr::Pdr07,
2101        Pdr_SPEC,
2102        crate::common::RW,
2103    > {
2104        crate::common::RegisterField::<
2105            7,
2106            0x1,
2107            1,
2108            0,
2109            pdr::Pdr07,
2110            pdr::Pdr07,
2111            Pdr_SPEC,
2112            crate::common::RW,
2113        >::from_register(self, 0)
2114    }
2115
2116    #[doc = "Pmn Direction"]
2117    #[inline(always)]
2118    pub fn pdr08(
2119        self,
2120    ) -> crate::common::RegisterField<
2121        8,
2122        0x1,
2123        1,
2124        0,
2125        pdr::Pdr08,
2126        pdr::Pdr08,
2127        Pdr_SPEC,
2128        crate::common::RW,
2129    > {
2130        crate::common::RegisterField::<
2131            8,
2132            0x1,
2133            1,
2134            0,
2135            pdr::Pdr08,
2136            pdr::Pdr08,
2137            Pdr_SPEC,
2138            crate::common::RW,
2139        >::from_register(self, 0)
2140    }
2141
2142    #[doc = "Pmn Direction"]
2143    #[inline(always)]
2144    pub fn pdr09(
2145        self,
2146    ) -> crate::common::RegisterField<
2147        9,
2148        0x1,
2149        1,
2150        0,
2151        pdr::Pdr09,
2152        pdr::Pdr09,
2153        Pdr_SPEC,
2154        crate::common::RW,
2155    > {
2156        crate::common::RegisterField::<
2157            9,
2158            0x1,
2159            1,
2160            0,
2161            pdr::Pdr09,
2162            pdr::Pdr09,
2163            Pdr_SPEC,
2164            crate::common::RW,
2165        >::from_register(self, 0)
2166    }
2167
2168    #[doc = "Pmn Direction"]
2169    #[inline(always)]
2170    pub fn pdr10(
2171        self,
2172    ) -> crate::common::RegisterField<
2173        10,
2174        0x1,
2175        1,
2176        0,
2177        pdr::Pdr10,
2178        pdr::Pdr10,
2179        Pdr_SPEC,
2180        crate::common::RW,
2181    > {
2182        crate::common::RegisterField::<
2183            10,
2184            0x1,
2185            1,
2186            0,
2187            pdr::Pdr10,
2188            pdr::Pdr10,
2189            Pdr_SPEC,
2190            crate::common::RW,
2191        >::from_register(self, 0)
2192    }
2193
2194    #[doc = "Pmn Direction"]
2195    #[inline(always)]
2196    pub fn pdr11(
2197        self,
2198    ) -> crate::common::RegisterField<
2199        11,
2200        0x1,
2201        1,
2202        0,
2203        pdr::Pdr11,
2204        pdr::Pdr11,
2205        Pdr_SPEC,
2206        crate::common::RW,
2207    > {
2208        crate::common::RegisterField::<
2209            11,
2210            0x1,
2211            1,
2212            0,
2213            pdr::Pdr11,
2214            pdr::Pdr11,
2215            Pdr_SPEC,
2216            crate::common::RW,
2217        >::from_register(self, 0)
2218    }
2219
2220    #[doc = "Pmn Direction"]
2221    #[inline(always)]
2222    pub fn pdr12(
2223        self,
2224    ) -> crate::common::RegisterField<
2225        12,
2226        0x1,
2227        1,
2228        0,
2229        pdr::Pdr12,
2230        pdr::Pdr12,
2231        Pdr_SPEC,
2232        crate::common::RW,
2233    > {
2234        crate::common::RegisterField::<
2235            12,
2236            0x1,
2237            1,
2238            0,
2239            pdr::Pdr12,
2240            pdr::Pdr12,
2241            Pdr_SPEC,
2242            crate::common::RW,
2243        >::from_register(self, 0)
2244    }
2245
2246    #[doc = "Pmn Direction"]
2247    #[inline(always)]
2248    pub fn pdr13(
2249        self,
2250    ) -> crate::common::RegisterField<
2251        13,
2252        0x1,
2253        1,
2254        0,
2255        pdr::Pdr13,
2256        pdr::Pdr13,
2257        Pdr_SPEC,
2258        crate::common::RW,
2259    > {
2260        crate::common::RegisterField::<
2261            13,
2262            0x1,
2263            1,
2264            0,
2265            pdr::Pdr13,
2266            pdr::Pdr13,
2267            Pdr_SPEC,
2268            crate::common::RW,
2269        >::from_register(self, 0)
2270    }
2271
2272    #[doc = "Pmn Direction"]
2273    #[inline(always)]
2274    pub fn pdr14(
2275        self,
2276    ) -> crate::common::RegisterField<
2277        14,
2278        0x1,
2279        1,
2280        0,
2281        pdr::Pdr14,
2282        pdr::Pdr14,
2283        Pdr_SPEC,
2284        crate::common::RW,
2285    > {
2286        crate::common::RegisterField::<
2287            14,
2288            0x1,
2289            1,
2290            0,
2291            pdr::Pdr14,
2292            pdr::Pdr14,
2293            Pdr_SPEC,
2294            crate::common::RW,
2295        >::from_register(self, 0)
2296    }
2297
2298    #[doc = "Pmn Direction"]
2299    #[inline(always)]
2300    pub fn pdr15(
2301        self,
2302    ) -> crate::common::RegisterField<
2303        15,
2304        0x1,
2305        1,
2306        0,
2307        pdr::Pdr15,
2308        pdr::Pdr15,
2309        Pdr_SPEC,
2310        crate::common::RW,
2311    > {
2312        crate::common::RegisterField::<
2313            15,
2314            0x1,
2315            1,
2316            0,
2317            pdr::Pdr15,
2318            pdr::Pdr15,
2319            Pdr_SPEC,
2320            crate::common::RW,
2321        >::from_register(self, 0)
2322    }
2323}
2324impl ::core::default::Default for Pdr {
2325    #[inline(always)]
2326    fn default() -> Pdr {
2327        <crate::RegValueT<Pdr_SPEC> as RegisterValue<_>>::new(0)
2328    }
2329}
2330pub mod pdr {
2331
2332    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2333    pub struct Pdr00_SPEC;
2334    pub type Pdr00 = crate::EnumBitfieldStruct<u8, Pdr00_SPEC>;
2335    impl Pdr00 {
2336        #[doc = "Input (functions as an input pin)"]
2337        pub const _0: Self = Self::new(0);
2338
2339        #[doc = "Output (functions as an output pin)"]
2340        pub const _1: Self = Self::new(1);
2341    }
2342    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2343    pub struct Pdr01_SPEC;
2344    pub type Pdr01 = crate::EnumBitfieldStruct<u8, Pdr01_SPEC>;
2345    impl Pdr01 {
2346        #[doc = "Input (functions as an input pin)"]
2347        pub const _0: Self = Self::new(0);
2348
2349        #[doc = "Output (functions as an output pin)"]
2350        pub const _1: Self = Self::new(1);
2351    }
2352    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2353    pub struct Pdr02_SPEC;
2354    pub type Pdr02 = crate::EnumBitfieldStruct<u8, Pdr02_SPEC>;
2355    impl Pdr02 {
2356        #[doc = "Input (functions as an input pin)"]
2357        pub const _0: Self = Self::new(0);
2358
2359        #[doc = "Output (functions as an output pin)"]
2360        pub const _1: Self = Self::new(1);
2361    }
2362    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2363    pub struct Pdr03_SPEC;
2364    pub type Pdr03 = crate::EnumBitfieldStruct<u8, Pdr03_SPEC>;
2365    impl Pdr03 {
2366        #[doc = "Input (functions as an input pin)"]
2367        pub const _0: Self = Self::new(0);
2368
2369        #[doc = "Output (functions as an output pin)"]
2370        pub const _1: Self = Self::new(1);
2371    }
2372    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2373    pub struct Pdr04_SPEC;
2374    pub type Pdr04 = crate::EnumBitfieldStruct<u8, Pdr04_SPEC>;
2375    impl Pdr04 {
2376        #[doc = "Input (functions as an input pin)"]
2377        pub const _0: Self = Self::new(0);
2378
2379        #[doc = "Output (functions as an output pin)"]
2380        pub const _1: Self = Self::new(1);
2381    }
2382    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2383    pub struct Pdr05_SPEC;
2384    pub type Pdr05 = crate::EnumBitfieldStruct<u8, Pdr05_SPEC>;
2385    impl Pdr05 {
2386        #[doc = "Input (functions as an input pin)"]
2387        pub const _0: Self = Self::new(0);
2388
2389        #[doc = "Output (functions as an output pin)"]
2390        pub const _1: Self = Self::new(1);
2391    }
2392    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2393    pub struct Pdr06_SPEC;
2394    pub type Pdr06 = crate::EnumBitfieldStruct<u8, Pdr06_SPEC>;
2395    impl Pdr06 {
2396        #[doc = "Input (functions as an input pin)"]
2397        pub const _0: Self = Self::new(0);
2398
2399        #[doc = "Output (functions as an output pin)"]
2400        pub const _1: Self = Self::new(1);
2401    }
2402    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2403    pub struct Pdr07_SPEC;
2404    pub type Pdr07 = crate::EnumBitfieldStruct<u8, Pdr07_SPEC>;
2405    impl Pdr07 {
2406        #[doc = "Input (functions as an input pin)"]
2407        pub const _0: Self = Self::new(0);
2408
2409        #[doc = "Output (functions as an output pin)"]
2410        pub const _1: Self = Self::new(1);
2411    }
2412    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2413    pub struct Pdr08_SPEC;
2414    pub type Pdr08 = crate::EnumBitfieldStruct<u8, Pdr08_SPEC>;
2415    impl Pdr08 {
2416        #[doc = "Input (functions as an input pin)"]
2417        pub const _0: Self = Self::new(0);
2418
2419        #[doc = "Output (functions as an output pin)"]
2420        pub const _1: Self = Self::new(1);
2421    }
2422    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2423    pub struct Pdr09_SPEC;
2424    pub type Pdr09 = crate::EnumBitfieldStruct<u8, Pdr09_SPEC>;
2425    impl Pdr09 {
2426        #[doc = "Input (functions as an input pin)"]
2427        pub const _0: Self = Self::new(0);
2428
2429        #[doc = "Output (functions as an output pin)"]
2430        pub const _1: Self = Self::new(1);
2431    }
2432    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2433    pub struct Pdr10_SPEC;
2434    pub type Pdr10 = crate::EnumBitfieldStruct<u8, Pdr10_SPEC>;
2435    impl Pdr10 {
2436        #[doc = "Input (functions as an input pin)"]
2437        pub const _0: Self = Self::new(0);
2438
2439        #[doc = "Output (functions as an output pin)"]
2440        pub const _1: Self = Self::new(1);
2441    }
2442    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2443    pub struct Pdr11_SPEC;
2444    pub type Pdr11 = crate::EnumBitfieldStruct<u8, Pdr11_SPEC>;
2445    impl Pdr11 {
2446        #[doc = "Input (functions as an input pin)"]
2447        pub const _0: Self = Self::new(0);
2448
2449        #[doc = "Output (functions as an output pin)"]
2450        pub const _1: Self = Self::new(1);
2451    }
2452    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2453    pub struct Pdr12_SPEC;
2454    pub type Pdr12 = crate::EnumBitfieldStruct<u8, Pdr12_SPEC>;
2455    impl Pdr12 {
2456        #[doc = "Input (functions as an input pin)"]
2457        pub const _0: Self = Self::new(0);
2458
2459        #[doc = "Output (functions as an output pin)"]
2460        pub const _1: Self = Self::new(1);
2461    }
2462    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2463    pub struct Pdr13_SPEC;
2464    pub type Pdr13 = crate::EnumBitfieldStruct<u8, Pdr13_SPEC>;
2465    impl Pdr13 {
2466        #[doc = "Input (functions as an input pin)"]
2467        pub const _0: Self = Self::new(0);
2468
2469        #[doc = "Output (functions as an output pin)"]
2470        pub const _1: Self = Self::new(1);
2471    }
2472    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2473    pub struct Pdr14_SPEC;
2474    pub type Pdr14 = crate::EnumBitfieldStruct<u8, Pdr14_SPEC>;
2475    impl Pdr14 {
2476        #[doc = "Input (functions as an input pin)"]
2477        pub const _0: Self = Self::new(0);
2478
2479        #[doc = "Output (functions as an output pin)"]
2480        pub const _1: Self = Self::new(1);
2481    }
2482    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2483    pub struct Pdr15_SPEC;
2484    pub type Pdr15 = crate::EnumBitfieldStruct<u8, Pdr15_SPEC>;
2485    impl Pdr15 {
2486        #[doc = "Input (functions as an input pin)"]
2487        pub const _0: Self = Self::new(0);
2488
2489        #[doc = "Output (functions as an output pin)"]
2490        pub const _1: Self = Self::new(1);
2491    }
2492}
2493#[doc(hidden)]
2494#[derive(Copy, Clone, Eq, PartialEq)]
2495pub struct Pcntr2_SPEC;
2496impl crate::sealed::RegSpec for Pcntr2_SPEC {
2497    type DataType = u32;
2498}
2499
2500#[doc = "Port Control Register 2"]
2501pub type Pcntr2 = crate::RegValueT<Pcntr2_SPEC>;
2502
2503impl Pcntr2 {
2504    #[doc = "Pmn State"]
2505    #[inline(always)]
2506    pub fn pidr00(
2507        self,
2508    ) -> crate::common::RegisterField<
2509        0,
2510        0x1,
2511        1,
2512        0,
2513        pcntr2::Pidr00,
2514        pcntr2::Pidr00,
2515        Pcntr2_SPEC,
2516        crate::common::R,
2517    > {
2518        crate::common::RegisterField::<
2519            0,
2520            0x1,
2521            1,
2522            0,
2523            pcntr2::Pidr00,
2524            pcntr2::Pidr00,
2525            Pcntr2_SPEC,
2526            crate::common::R,
2527        >::from_register(self, 0)
2528    }
2529
2530    #[doc = "Pmn State"]
2531    #[inline(always)]
2532    pub fn pidr01(
2533        self,
2534    ) -> crate::common::RegisterField<
2535        1,
2536        0x1,
2537        1,
2538        0,
2539        pcntr2::Pidr01,
2540        pcntr2::Pidr01,
2541        Pcntr2_SPEC,
2542        crate::common::R,
2543    > {
2544        crate::common::RegisterField::<
2545            1,
2546            0x1,
2547            1,
2548            0,
2549            pcntr2::Pidr01,
2550            pcntr2::Pidr01,
2551            Pcntr2_SPEC,
2552            crate::common::R,
2553        >::from_register(self, 0)
2554    }
2555
2556    #[doc = "Pmn State"]
2557    #[inline(always)]
2558    pub fn pidr02(
2559        self,
2560    ) -> crate::common::RegisterField<
2561        2,
2562        0x1,
2563        1,
2564        0,
2565        pcntr2::Pidr02,
2566        pcntr2::Pidr02,
2567        Pcntr2_SPEC,
2568        crate::common::R,
2569    > {
2570        crate::common::RegisterField::<
2571            2,
2572            0x1,
2573            1,
2574            0,
2575            pcntr2::Pidr02,
2576            pcntr2::Pidr02,
2577            Pcntr2_SPEC,
2578            crate::common::R,
2579        >::from_register(self, 0)
2580    }
2581
2582    #[doc = "Pmn State"]
2583    #[inline(always)]
2584    pub fn pidr03(
2585        self,
2586    ) -> crate::common::RegisterField<
2587        3,
2588        0x1,
2589        1,
2590        0,
2591        pcntr2::Pidr03,
2592        pcntr2::Pidr03,
2593        Pcntr2_SPEC,
2594        crate::common::R,
2595    > {
2596        crate::common::RegisterField::<
2597            3,
2598            0x1,
2599            1,
2600            0,
2601            pcntr2::Pidr03,
2602            pcntr2::Pidr03,
2603            Pcntr2_SPEC,
2604            crate::common::R,
2605        >::from_register(self, 0)
2606    }
2607
2608    #[doc = "Pmn State"]
2609    #[inline(always)]
2610    pub fn pidr04(
2611        self,
2612    ) -> crate::common::RegisterField<
2613        4,
2614        0x1,
2615        1,
2616        0,
2617        pcntr2::Pidr04,
2618        pcntr2::Pidr04,
2619        Pcntr2_SPEC,
2620        crate::common::R,
2621    > {
2622        crate::common::RegisterField::<
2623            4,
2624            0x1,
2625            1,
2626            0,
2627            pcntr2::Pidr04,
2628            pcntr2::Pidr04,
2629            Pcntr2_SPEC,
2630            crate::common::R,
2631        >::from_register(self, 0)
2632    }
2633
2634    #[doc = "Pmn State"]
2635    #[inline(always)]
2636    pub fn pidr05(
2637        self,
2638    ) -> crate::common::RegisterField<
2639        5,
2640        0x1,
2641        1,
2642        0,
2643        pcntr2::Pidr05,
2644        pcntr2::Pidr05,
2645        Pcntr2_SPEC,
2646        crate::common::R,
2647    > {
2648        crate::common::RegisterField::<
2649            5,
2650            0x1,
2651            1,
2652            0,
2653            pcntr2::Pidr05,
2654            pcntr2::Pidr05,
2655            Pcntr2_SPEC,
2656            crate::common::R,
2657        >::from_register(self, 0)
2658    }
2659
2660    #[doc = "Pmn State"]
2661    #[inline(always)]
2662    pub fn pidr06(
2663        self,
2664    ) -> crate::common::RegisterField<
2665        6,
2666        0x1,
2667        1,
2668        0,
2669        pcntr2::Pidr06,
2670        pcntr2::Pidr06,
2671        Pcntr2_SPEC,
2672        crate::common::R,
2673    > {
2674        crate::common::RegisterField::<
2675            6,
2676            0x1,
2677            1,
2678            0,
2679            pcntr2::Pidr06,
2680            pcntr2::Pidr06,
2681            Pcntr2_SPEC,
2682            crate::common::R,
2683        >::from_register(self, 0)
2684    }
2685
2686    #[doc = "Pmn State"]
2687    #[inline(always)]
2688    pub fn pidr07(
2689        self,
2690    ) -> crate::common::RegisterField<
2691        7,
2692        0x1,
2693        1,
2694        0,
2695        pcntr2::Pidr07,
2696        pcntr2::Pidr07,
2697        Pcntr2_SPEC,
2698        crate::common::R,
2699    > {
2700        crate::common::RegisterField::<
2701            7,
2702            0x1,
2703            1,
2704            0,
2705            pcntr2::Pidr07,
2706            pcntr2::Pidr07,
2707            Pcntr2_SPEC,
2708            crate::common::R,
2709        >::from_register(self, 0)
2710    }
2711
2712    #[doc = "Pmn State"]
2713    #[inline(always)]
2714    pub fn pidr08(
2715        self,
2716    ) -> crate::common::RegisterField<
2717        8,
2718        0x1,
2719        1,
2720        0,
2721        pcntr2::Pidr08,
2722        pcntr2::Pidr08,
2723        Pcntr2_SPEC,
2724        crate::common::R,
2725    > {
2726        crate::common::RegisterField::<
2727            8,
2728            0x1,
2729            1,
2730            0,
2731            pcntr2::Pidr08,
2732            pcntr2::Pidr08,
2733            Pcntr2_SPEC,
2734            crate::common::R,
2735        >::from_register(self, 0)
2736    }
2737
2738    #[doc = "Pmn State"]
2739    #[inline(always)]
2740    pub fn pidr09(
2741        self,
2742    ) -> crate::common::RegisterField<
2743        9,
2744        0x1,
2745        1,
2746        0,
2747        pcntr2::Pidr09,
2748        pcntr2::Pidr09,
2749        Pcntr2_SPEC,
2750        crate::common::R,
2751    > {
2752        crate::common::RegisterField::<
2753            9,
2754            0x1,
2755            1,
2756            0,
2757            pcntr2::Pidr09,
2758            pcntr2::Pidr09,
2759            Pcntr2_SPEC,
2760            crate::common::R,
2761        >::from_register(self, 0)
2762    }
2763
2764    #[doc = "Pmn State"]
2765    #[inline(always)]
2766    pub fn pidr10(
2767        self,
2768    ) -> crate::common::RegisterField<
2769        10,
2770        0x1,
2771        1,
2772        0,
2773        pcntr2::Pidr10,
2774        pcntr2::Pidr10,
2775        Pcntr2_SPEC,
2776        crate::common::R,
2777    > {
2778        crate::common::RegisterField::<
2779            10,
2780            0x1,
2781            1,
2782            0,
2783            pcntr2::Pidr10,
2784            pcntr2::Pidr10,
2785            Pcntr2_SPEC,
2786            crate::common::R,
2787        >::from_register(self, 0)
2788    }
2789
2790    #[doc = "Pmn State"]
2791    #[inline(always)]
2792    pub fn pidr11(
2793        self,
2794    ) -> crate::common::RegisterField<
2795        11,
2796        0x1,
2797        1,
2798        0,
2799        pcntr2::Pidr11,
2800        pcntr2::Pidr11,
2801        Pcntr2_SPEC,
2802        crate::common::R,
2803    > {
2804        crate::common::RegisterField::<
2805            11,
2806            0x1,
2807            1,
2808            0,
2809            pcntr2::Pidr11,
2810            pcntr2::Pidr11,
2811            Pcntr2_SPEC,
2812            crate::common::R,
2813        >::from_register(self, 0)
2814    }
2815
2816    #[doc = "Pmn State"]
2817    #[inline(always)]
2818    pub fn pidr12(
2819        self,
2820    ) -> crate::common::RegisterField<
2821        12,
2822        0x1,
2823        1,
2824        0,
2825        pcntr2::Pidr12,
2826        pcntr2::Pidr12,
2827        Pcntr2_SPEC,
2828        crate::common::R,
2829    > {
2830        crate::common::RegisterField::<
2831            12,
2832            0x1,
2833            1,
2834            0,
2835            pcntr2::Pidr12,
2836            pcntr2::Pidr12,
2837            Pcntr2_SPEC,
2838            crate::common::R,
2839        >::from_register(self, 0)
2840    }
2841
2842    #[doc = "Pmn State"]
2843    #[inline(always)]
2844    pub fn pidr13(
2845        self,
2846    ) -> crate::common::RegisterField<
2847        13,
2848        0x1,
2849        1,
2850        0,
2851        pcntr2::Pidr13,
2852        pcntr2::Pidr13,
2853        Pcntr2_SPEC,
2854        crate::common::R,
2855    > {
2856        crate::common::RegisterField::<
2857            13,
2858            0x1,
2859            1,
2860            0,
2861            pcntr2::Pidr13,
2862            pcntr2::Pidr13,
2863            Pcntr2_SPEC,
2864            crate::common::R,
2865        >::from_register(self, 0)
2866    }
2867
2868    #[doc = "Pmn State"]
2869    #[inline(always)]
2870    pub fn pidr14(
2871        self,
2872    ) -> crate::common::RegisterField<
2873        14,
2874        0x1,
2875        1,
2876        0,
2877        pcntr2::Pidr14,
2878        pcntr2::Pidr14,
2879        Pcntr2_SPEC,
2880        crate::common::R,
2881    > {
2882        crate::common::RegisterField::<
2883            14,
2884            0x1,
2885            1,
2886            0,
2887            pcntr2::Pidr14,
2888            pcntr2::Pidr14,
2889            Pcntr2_SPEC,
2890            crate::common::R,
2891        >::from_register(self, 0)
2892    }
2893
2894    #[doc = "Pmn State"]
2895    #[inline(always)]
2896    pub fn pidr15(
2897        self,
2898    ) -> crate::common::RegisterField<
2899        15,
2900        0x1,
2901        1,
2902        0,
2903        pcntr2::Pidr15,
2904        pcntr2::Pidr15,
2905        Pcntr2_SPEC,
2906        crate::common::R,
2907    > {
2908        crate::common::RegisterField::<
2909            15,
2910            0x1,
2911            1,
2912            0,
2913            pcntr2::Pidr15,
2914            pcntr2::Pidr15,
2915            Pcntr2_SPEC,
2916            crate::common::R,
2917        >::from_register(self, 0)
2918    }
2919
2920    #[doc = "Port Event Input Data"]
2921    #[inline(always)]
2922    pub fn eidr00(
2923        self,
2924    ) -> crate::common::RegisterField<
2925        16,
2926        0x1,
2927        1,
2928        0,
2929        pcntr2::Eidr00,
2930        pcntr2::Eidr00,
2931        Pcntr2_SPEC,
2932        crate::common::R,
2933    > {
2934        crate::common::RegisterField::<
2935            16,
2936            0x1,
2937            1,
2938            0,
2939            pcntr2::Eidr00,
2940            pcntr2::Eidr00,
2941            Pcntr2_SPEC,
2942            crate::common::R,
2943        >::from_register(self, 0)
2944    }
2945
2946    #[doc = "Port Event Input Data"]
2947    #[inline(always)]
2948    pub fn eidr01(
2949        self,
2950    ) -> crate::common::RegisterField<
2951        17,
2952        0x1,
2953        1,
2954        0,
2955        pcntr2::Eidr01,
2956        pcntr2::Eidr01,
2957        Pcntr2_SPEC,
2958        crate::common::R,
2959    > {
2960        crate::common::RegisterField::<
2961            17,
2962            0x1,
2963            1,
2964            0,
2965            pcntr2::Eidr01,
2966            pcntr2::Eidr01,
2967            Pcntr2_SPEC,
2968            crate::common::R,
2969        >::from_register(self, 0)
2970    }
2971
2972    #[doc = "Port Event Input Data"]
2973    #[inline(always)]
2974    pub fn eidr02(
2975        self,
2976    ) -> crate::common::RegisterField<
2977        18,
2978        0x1,
2979        1,
2980        0,
2981        pcntr2::Eidr02,
2982        pcntr2::Eidr02,
2983        Pcntr2_SPEC,
2984        crate::common::R,
2985    > {
2986        crate::common::RegisterField::<
2987            18,
2988            0x1,
2989            1,
2990            0,
2991            pcntr2::Eidr02,
2992            pcntr2::Eidr02,
2993            Pcntr2_SPEC,
2994            crate::common::R,
2995        >::from_register(self, 0)
2996    }
2997
2998    #[doc = "Port Event Input Data"]
2999    #[inline(always)]
3000    pub fn eidr03(
3001        self,
3002    ) -> crate::common::RegisterField<
3003        19,
3004        0x1,
3005        1,
3006        0,
3007        pcntr2::Eidr03,
3008        pcntr2::Eidr03,
3009        Pcntr2_SPEC,
3010        crate::common::R,
3011    > {
3012        crate::common::RegisterField::<
3013            19,
3014            0x1,
3015            1,
3016            0,
3017            pcntr2::Eidr03,
3018            pcntr2::Eidr03,
3019            Pcntr2_SPEC,
3020            crate::common::R,
3021        >::from_register(self, 0)
3022    }
3023
3024    #[doc = "Port Event Input Data"]
3025    #[inline(always)]
3026    pub fn eidr04(
3027        self,
3028    ) -> crate::common::RegisterField<
3029        20,
3030        0x1,
3031        1,
3032        0,
3033        pcntr2::Eidr04,
3034        pcntr2::Eidr04,
3035        Pcntr2_SPEC,
3036        crate::common::R,
3037    > {
3038        crate::common::RegisterField::<
3039            20,
3040            0x1,
3041            1,
3042            0,
3043            pcntr2::Eidr04,
3044            pcntr2::Eidr04,
3045            Pcntr2_SPEC,
3046            crate::common::R,
3047        >::from_register(self, 0)
3048    }
3049
3050    #[doc = "Port Event Input Data"]
3051    #[inline(always)]
3052    pub fn eidr05(
3053        self,
3054    ) -> crate::common::RegisterField<
3055        21,
3056        0x1,
3057        1,
3058        0,
3059        pcntr2::Eidr05,
3060        pcntr2::Eidr05,
3061        Pcntr2_SPEC,
3062        crate::common::R,
3063    > {
3064        crate::common::RegisterField::<
3065            21,
3066            0x1,
3067            1,
3068            0,
3069            pcntr2::Eidr05,
3070            pcntr2::Eidr05,
3071            Pcntr2_SPEC,
3072            crate::common::R,
3073        >::from_register(self, 0)
3074    }
3075
3076    #[doc = "Port Event Input Data"]
3077    #[inline(always)]
3078    pub fn eidr06(
3079        self,
3080    ) -> crate::common::RegisterField<
3081        22,
3082        0x1,
3083        1,
3084        0,
3085        pcntr2::Eidr06,
3086        pcntr2::Eidr06,
3087        Pcntr2_SPEC,
3088        crate::common::R,
3089    > {
3090        crate::common::RegisterField::<
3091            22,
3092            0x1,
3093            1,
3094            0,
3095            pcntr2::Eidr06,
3096            pcntr2::Eidr06,
3097            Pcntr2_SPEC,
3098            crate::common::R,
3099        >::from_register(self, 0)
3100    }
3101
3102    #[doc = "Port Event Input Data"]
3103    #[inline(always)]
3104    pub fn eidr07(
3105        self,
3106    ) -> crate::common::RegisterField<
3107        23,
3108        0x1,
3109        1,
3110        0,
3111        pcntr2::Eidr07,
3112        pcntr2::Eidr07,
3113        Pcntr2_SPEC,
3114        crate::common::R,
3115    > {
3116        crate::common::RegisterField::<
3117            23,
3118            0x1,
3119            1,
3120            0,
3121            pcntr2::Eidr07,
3122            pcntr2::Eidr07,
3123            Pcntr2_SPEC,
3124            crate::common::R,
3125        >::from_register(self, 0)
3126    }
3127
3128    #[doc = "Port Event Input Data"]
3129    #[inline(always)]
3130    pub fn eidr08(
3131        self,
3132    ) -> crate::common::RegisterField<
3133        24,
3134        0x1,
3135        1,
3136        0,
3137        pcntr2::Eidr08,
3138        pcntr2::Eidr08,
3139        Pcntr2_SPEC,
3140        crate::common::R,
3141    > {
3142        crate::common::RegisterField::<
3143            24,
3144            0x1,
3145            1,
3146            0,
3147            pcntr2::Eidr08,
3148            pcntr2::Eidr08,
3149            Pcntr2_SPEC,
3150            crate::common::R,
3151        >::from_register(self, 0)
3152    }
3153
3154    #[doc = "Port Event Input Data"]
3155    #[inline(always)]
3156    pub fn eidr09(
3157        self,
3158    ) -> crate::common::RegisterField<
3159        25,
3160        0x1,
3161        1,
3162        0,
3163        pcntr2::Eidr09,
3164        pcntr2::Eidr09,
3165        Pcntr2_SPEC,
3166        crate::common::R,
3167    > {
3168        crate::common::RegisterField::<
3169            25,
3170            0x1,
3171            1,
3172            0,
3173            pcntr2::Eidr09,
3174            pcntr2::Eidr09,
3175            Pcntr2_SPEC,
3176            crate::common::R,
3177        >::from_register(self, 0)
3178    }
3179
3180    #[doc = "Port Event Input Data"]
3181    #[inline(always)]
3182    pub fn eidr10(
3183        self,
3184    ) -> crate::common::RegisterField<
3185        26,
3186        0x1,
3187        1,
3188        0,
3189        pcntr2::Eidr10,
3190        pcntr2::Eidr10,
3191        Pcntr2_SPEC,
3192        crate::common::R,
3193    > {
3194        crate::common::RegisterField::<
3195            26,
3196            0x1,
3197            1,
3198            0,
3199            pcntr2::Eidr10,
3200            pcntr2::Eidr10,
3201            Pcntr2_SPEC,
3202            crate::common::R,
3203        >::from_register(self, 0)
3204    }
3205
3206    #[doc = "Port Event Input Data"]
3207    #[inline(always)]
3208    pub fn eidr11(
3209        self,
3210    ) -> crate::common::RegisterField<
3211        27,
3212        0x1,
3213        1,
3214        0,
3215        pcntr2::Eidr11,
3216        pcntr2::Eidr11,
3217        Pcntr2_SPEC,
3218        crate::common::R,
3219    > {
3220        crate::common::RegisterField::<
3221            27,
3222            0x1,
3223            1,
3224            0,
3225            pcntr2::Eidr11,
3226            pcntr2::Eidr11,
3227            Pcntr2_SPEC,
3228            crate::common::R,
3229        >::from_register(self, 0)
3230    }
3231
3232    #[doc = "Port Event Input Data"]
3233    #[inline(always)]
3234    pub fn eidr12(
3235        self,
3236    ) -> crate::common::RegisterField<
3237        28,
3238        0x1,
3239        1,
3240        0,
3241        pcntr2::Eidr12,
3242        pcntr2::Eidr12,
3243        Pcntr2_SPEC,
3244        crate::common::R,
3245    > {
3246        crate::common::RegisterField::<
3247            28,
3248            0x1,
3249            1,
3250            0,
3251            pcntr2::Eidr12,
3252            pcntr2::Eidr12,
3253            Pcntr2_SPEC,
3254            crate::common::R,
3255        >::from_register(self, 0)
3256    }
3257
3258    #[doc = "Port Event Input Data"]
3259    #[inline(always)]
3260    pub fn eidr13(
3261        self,
3262    ) -> crate::common::RegisterField<
3263        29,
3264        0x1,
3265        1,
3266        0,
3267        pcntr2::Eidr13,
3268        pcntr2::Eidr13,
3269        Pcntr2_SPEC,
3270        crate::common::R,
3271    > {
3272        crate::common::RegisterField::<
3273            29,
3274            0x1,
3275            1,
3276            0,
3277            pcntr2::Eidr13,
3278            pcntr2::Eidr13,
3279            Pcntr2_SPEC,
3280            crate::common::R,
3281        >::from_register(self, 0)
3282    }
3283
3284    #[doc = "Port Event Input Data"]
3285    #[inline(always)]
3286    pub fn eidr14(
3287        self,
3288    ) -> crate::common::RegisterField<
3289        30,
3290        0x1,
3291        1,
3292        0,
3293        pcntr2::Eidr14,
3294        pcntr2::Eidr14,
3295        Pcntr2_SPEC,
3296        crate::common::R,
3297    > {
3298        crate::common::RegisterField::<
3299            30,
3300            0x1,
3301            1,
3302            0,
3303            pcntr2::Eidr14,
3304            pcntr2::Eidr14,
3305            Pcntr2_SPEC,
3306            crate::common::R,
3307        >::from_register(self, 0)
3308    }
3309
3310    #[doc = "Port Event Input Data"]
3311    #[inline(always)]
3312    pub fn eidr15(
3313        self,
3314    ) -> crate::common::RegisterField<
3315        31,
3316        0x1,
3317        1,
3318        0,
3319        pcntr2::Eidr15,
3320        pcntr2::Eidr15,
3321        Pcntr2_SPEC,
3322        crate::common::R,
3323    > {
3324        crate::common::RegisterField::<
3325            31,
3326            0x1,
3327            1,
3328            0,
3329            pcntr2::Eidr15,
3330            pcntr2::Eidr15,
3331            Pcntr2_SPEC,
3332            crate::common::R,
3333        >::from_register(self, 0)
3334    }
3335}
3336impl ::core::default::Default for Pcntr2 {
3337    #[inline(always)]
3338    fn default() -> Pcntr2 {
3339        <crate::RegValueT<Pcntr2_SPEC> as RegisterValue<_>>::new(0)
3340    }
3341}
3342pub mod pcntr2 {
3343
3344    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3345    pub struct Pidr00_SPEC;
3346    pub type Pidr00 = crate::EnumBitfieldStruct<u8, Pidr00_SPEC>;
3347    impl Pidr00 {
3348        #[doc = "Low level"]
3349        pub const _0: Self = Self::new(0);
3350
3351        #[doc = "High level"]
3352        pub const _1: Self = Self::new(1);
3353    }
3354    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3355    pub struct Pidr01_SPEC;
3356    pub type Pidr01 = crate::EnumBitfieldStruct<u8, Pidr01_SPEC>;
3357    impl Pidr01 {
3358        #[doc = "Low level"]
3359        pub const _0: Self = Self::new(0);
3360
3361        #[doc = "High level"]
3362        pub const _1: Self = Self::new(1);
3363    }
3364    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3365    pub struct Pidr02_SPEC;
3366    pub type Pidr02 = crate::EnumBitfieldStruct<u8, Pidr02_SPEC>;
3367    impl Pidr02 {
3368        #[doc = "Low level"]
3369        pub const _0: Self = Self::new(0);
3370
3371        #[doc = "High level"]
3372        pub const _1: Self = Self::new(1);
3373    }
3374    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3375    pub struct Pidr03_SPEC;
3376    pub type Pidr03 = crate::EnumBitfieldStruct<u8, Pidr03_SPEC>;
3377    impl Pidr03 {
3378        #[doc = "Low level"]
3379        pub const _0: Self = Self::new(0);
3380
3381        #[doc = "High level"]
3382        pub const _1: Self = Self::new(1);
3383    }
3384    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3385    pub struct Pidr04_SPEC;
3386    pub type Pidr04 = crate::EnumBitfieldStruct<u8, Pidr04_SPEC>;
3387    impl Pidr04 {
3388        #[doc = "Low level"]
3389        pub const _0: Self = Self::new(0);
3390
3391        #[doc = "High level"]
3392        pub const _1: Self = Self::new(1);
3393    }
3394    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3395    pub struct Pidr05_SPEC;
3396    pub type Pidr05 = crate::EnumBitfieldStruct<u8, Pidr05_SPEC>;
3397    impl Pidr05 {
3398        #[doc = "Low level"]
3399        pub const _0: Self = Self::new(0);
3400
3401        #[doc = "High level"]
3402        pub const _1: Self = Self::new(1);
3403    }
3404    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3405    pub struct Pidr06_SPEC;
3406    pub type Pidr06 = crate::EnumBitfieldStruct<u8, Pidr06_SPEC>;
3407    impl Pidr06 {
3408        #[doc = "Low level"]
3409        pub const _0: Self = Self::new(0);
3410
3411        #[doc = "High level"]
3412        pub const _1: Self = Self::new(1);
3413    }
3414    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3415    pub struct Pidr07_SPEC;
3416    pub type Pidr07 = crate::EnumBitfieldStruct<u8, Pidr07_SPEC>;
3417    impl Pidr07 {
3418        #[doc = "Low level"]
3419        pub const _0: Self = Self::new(0);
3420
3421        #[doc = "High level"]
3422        pub const _1: Self = Self::new(1);
3423    }
3424    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3425    pub struct Pidr08_SPEC;
3426    pub type Pidr08 = crate::EnumBitfieldStruct<u8, Pidr08_SPEC>;
3427    impl Pidr08 {
3428        #[doc = "Low level"]
3429        pub const _0: Self = Self::new(0);
3430
3431        #[doc = "High level"]
3432        pub const _1: Self = Self::new(1);
3433    }
3434    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3435    pub struct Pidr09_SPEC;
3436    pub type Pidr09 = crate::EnumBitfieldStruct<u8, Pidr09_SPEC>;
3437    impl Pidr09 {
3438        #[doc = "Low level"]
3439        pub const _0: Self = Self::new(0);
3440
3441        #[doc = "High level"]
3442        pub const _1: Self = Self::new(1);
3443    }
3444    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3445    pub struct Pidr10_SPEC;
3446    pub type Pidr10 = crate::EnumBitfieldStruct<u8, Pidr10_SPEC>;
3447    impl Pidr10 {
3448        #[doc = "Low level"]
3449        pub const _0: Self = Self::new(0);
3450
3451        #[doc = "High level"]
3452        pub const _1: Self = Self::new(1);
3453    }
3454    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3455    pub struct Pidr11_SPEC;
3456    pub type Pidr11 = crate::EnumBitfieldStruct<u8, Pidr11_SPEC>;
3457    impl Pidr11 {
3458        #[doc = "Low level"]
3459        pub const _0: Self = Self::new(0);
3460
3461        #[doc = "High level"]
3462        pub const _1: Self = Self::new(1);
3463    }
3464    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3465    pub struct Pidr12_SPEC;
3466    pub type Pidr12 = crate::EnumBitfieldStruct<u8, Pidr12_SPEC>;
3467    impl Pidr12 {
3468        #[doc = "Low level"]
3469        pub const _0: Self = Self::new(0);
3470
3471        #[doc = "High level"]
3472        pub const _1: Self = Self::new(1);
3473    }
3474    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3475    pub struct Pidr13_SPEC;
3476    pub type Pidr13 = crate::EnumBitfieldStruct<u8, Pidr13_SPEC>;
3477    impl Pidr13 {
3478        #[doc = "Low level"]
3479        pub const _0: Self = Self::new(0);
3480
3481        #[doc = "High level"]
3482        pub const _1: Self = Self::new(1);
3483    }
3484    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3485    pub struct Pidr14_SPEC;
3486    pub type Pidr14 = crate::EnumBitfieldStruct<u8, Pidr14_SPEC>;
3487    impl Pidr14 {
3488        #[doc = "Low level"]
3489        pub const _0: Self = Self::new(0);
3490
3491        #[doc = "High level"]
3492        pub const _1: Self = Self::new(1);
3493    }
3494    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3495    pub struct Pidr15_SPEC;
3496    pub type Pidr15 = crate::EnumBitfieldStruct<u8, Pidr15_SPEC>;
3497    impl Pidr15 {
3498        #[doc = "Low level"]
3499        pub const _0: Self = Self::new(0);
3500
3501        #[doc = "High level"]
3502        pub const _1: Self = Self::new(1);
3503    }
3504    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3505    pub struct Eidr00_SPEC;
3506    pub type Eidr00 = crate::EnumBitfieldStruct<u8, Eidr00_SPEC>;
3507    impl Eidr00 {
3508        #[doc = "Low input"]
3509        pub const _0: Self = Self::new(0);
3510
3511        #[doc = "High input"]
3512        pub const _1: Self = Self::new(1);
3513    }
3514    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3515    pub struct Eidr01_SPEC;
3516    pub type Eidr01 = crate::EnumBitfieldStruct<u8, Eidr01_SPEC>;
3517    impl Eidr01 {
3518        #[doc = "Low input"]
3519        pub const _0: Self = Self::new(0);
3520
3521        #[doc = "High input"]
3522        pub const _1: Self = Self::new(1);
3523    }
3524    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3525    pub struct Eidr02_SPEC;
3526    pub type Eidr02 = crate::EnumBitfieldStruct<u8, Eidr02_SPEC>;
3527    impl Eidr02 {
3528        #[doc = "Low input"]
3529        pub const _0: Self = Self::new(0);
3530
3531        #[doc = "High input"]
3532        pub const _1: Self = Self::new(1);
3533    }
3534    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3535    pub struct Eidr03_SPEC;
3536    pub type Eidr03 = crate::EnumBitfieldStruct<u8, Eidr03_SPEC>;
3537    impl Eidr03 {
3538        #[doc = "Low input"]
3539        pub const _0: Self = Self::new(0);
3540
3541        #[doc = "High input"]
3542        pub const _1: Self = Self::new(1);
3543    }
3544    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3545    pub struct Eidr04_SPEC;
3546    pub type Eidr04 = crate::EnumBitfieldStruct<u8, Eidr04_SPEC>;
3547    impl Eidr04 {
3548        #[doc = "Low input"]
3549        pub const _0: Self = Self::new(0);
3550
3551        #[doc = "High input"]
3552        pub const _1: Self = Self::new(1);
3553    }
3554    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3555    pub struct Eidr05_SPEC;
3556    pub type Eidr05 = crate::EnumBitfieldStruct<u8, Eidr05_SPEC>;
3557    impl Eidr05 {
3558        #[doc = "Low input"]
3559        pub const _0: Self = Self::new(0);
3560
3561        #[doc = "High input"]
3562        pub const _1: Self = Self::new(1);
3563    }
3564    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3565    pub struct Eidr06_SPEC;
3566    pub type Eidr06 = crate::EnumBitfieldStruct<u8, Eidr06_SPEC>;
3567    impl Eidr06 {
3568        #[doc = "Low input"]
3569        pub const _0: Self = Self::new(0);
3570
3571        #[doc = "High input"]
3572        pub const _1: Self = Self::new(1);
3573    }
3574    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3575    pub struct Eidr07_SPEC;
3576    pub type Eidr07 = crate::EnumBitfieldStruct<u8, Eidr07_SPEC>;
3577    impl Eidr07 {
3578        #[doc = "Low input"]
3579        pub const _0: Self = Self::new(0);
3580
3581        #[doc = "High input"]
3582        pub const _1: Self = Self::new(1);
3583    }
3584    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3585    pub struct Eidr08_SPEC;
3586    pub type Eidr08 = crate::EnumBitfieldStruct<u8, Eidr08_SPEC>;
3587    impl Eidr08 {
3588        #[doc = "Low input"]
3589        pub const _0: Self = Self::new(0);
3590
3591        #[doc = "High input"]
3592        pub const _1: Self = Self::new(1);
3593    }
3594    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3595    pub struct Eidr09_SPEC;
3596    pub type Eidr09 = crate::EnumBitfieldStruct<u8, Eidr09_SPEC>;
3597    impl Eidr09 {
3598        #[doc = "Low input"]
3599        pub const _0: Self = Self::new(0);
3600
3601        #[doc = "High input"]
3602        pub const _1: Self = Self::new(1);
3603    }
3604    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3605    pub struct Eidr10_SPEC;
3606    pub type Eidr10 = crate::EnumBitfieldStruct<u8, Eidr10_SPEC>;
3607    impl Eidr10 {
3608        #[doc = "Low input"]
3609        pub const _0: Self = Self::new(0);
3610
3611        #[doc = "High input"]
3612        pub const _1: Self = Self::new(1);
3613    }
3614    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3615    pub struct Eidr11_SPEC;
3616    pub type Eidr11 = crate::EnumBitfieldStruct<u8, Eidr11_SPEC>;
3617    impl Eidr11 {
3618        #[doc = "Low input"]
3619        pub const _0: Self = Self::new(0);
3620
3621        #[doc = "High input"]
3622        pub const _1: Self = Self::new(1);
3623    }
3624    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3625    pub struct Eidr12_SPEC;
3626    pub type Eidr12 = crate::EnumBitfieldStruct<u8, Eidr12_SPEC>;
3627    impl Eidr12 {
3628        #[doc = "Low input"]
3629        pub const _0: Self = Self::new(0);
3630
3631        #[doc = "High input"]
3632        pub const _1: Self = Self::new(1);
3633    }
3634    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3635    pub struct Eidr13_SPEC;
3636    pub type Eidr13 = crate::EnumBitfieldStruct<u8, Eidr13_SPEC>;
3637    impl Eidr13 {
3638        #[doc = "Low input"]
3639        pub const _0: Self = Self::new(0);
3640
3641        #[doc = "High input"]
3642        pub const _1: Self = Self::new(1);
3643    }
3644    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3645    pub struct Eidr14_SPEC;
3646    pub type Eidr14 = crate::EnumBitfieldStruct<u8, Eidr14_SPEC>;
3647    impl Eidr14 {
3648        #[doc = "Low input"]
3649        pub const _0: Self = Self::new(0);
3650
3651        #[doc = "High input"]
3652        pub const _1: Self = Self::new(1);
3653    }
3654    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3655    pub struct Eidr15_SPEC;
3656    pub type Eidr15 = crate::EnumBitfieldStruct<u8, Eidr15_SPEC>;
3657    impl Eidr15 {
3658        #[doc = "Low input"]
3659        pub const _0: Self = Self::new(0);
3660
3661        #[doc = "High input"]
3662        pub const _1: Self = Self::new(1);
3663    }
3664}
3665#[doc(hidden)]
3666#[derive(Copy, Clone, Eq, PartialEq)]
3667pub struct Eidr_SPEC;
3668impl crate::sealed::RegSpec for Eidr_SPEC {
3669    type DataType = u16;
3670}
3671
3672#[doc = "Port Control Register 2"]
3673pub type Eidr = crate::RegValueT<Eidr_SPEC>;
3674
3675impl Eidr {
3676    #[doc = "Port Event Input Data"]
3677    #[inline(always)]
3678    pub fn eidr00(
3679        self,
3680    ) -> crate::common::RegisterField<
3681        0,
3682        0x1,
3683        1,
3684        0,
3685        eidr::Eidr00,
3686        eidr::Eidr00,
3687        Eidr_SPEC,
3688        crate::common::R,
3689    > {
3690        crate::common::RegisterField::<
3691            0,
3692            0x1,
3693            1,
3694            0,
3695            eidr::Eidr00,
3696            eidr::Eidr00,
3697            Eidr_SPEC,
3698            crate::common::R,
3699        >::from_register(self, 0)
3700    }
3701
3702    #[doc = "Port Event Input Data"]
3703    #[inline(always)]
3704    pub fn eidr01(
3705        self,
3706    ) -> crate::common::RegisterField<
3707        1,
3708        0x1,
3709        1,
3710        0,
3711        eidr::Eidr01,
3712        eidr::Eidr01,
3713        Eidr_SPEC,
3714        crate::common::R,
3715    > {
3716        crate::common::RegisterField::<
3717            1,
3718            0x1,
3719            1,
3720            0,
3721            eidr::Eidr01,
3722            eidr::Eidr01,
3723            Eidr_SPEC,
3724            crate::common::R,
3725        >::from_register(self, 0)
3726    }
3727
3728    #[doc = "Port Event Input Data"]
3729    #[inline(always)]
3730    pub fn eidr02(
3731        self,
3732    ) -> crate::common::RegisterField<
3733        2,
3734        0x1,
3735        1,
3736        0,
3737        eidr::Eidr02,
3738        eidr::Eidr02,
3739        Eidr_SPEC,
3740        crate::common::R,
3741    > {
3742        crate::common::RegisterField::<
3743            2,
3744            0x1,
3745            1,
3746            0,
3747            eidr::Eidr02,
3748            eidr::Eidr02,
3749            Eidr_SPEC,
3750            crate::common::R,
3751        >::from_register(self, 0)
3752    }
3753
3754    #[doc = "Port Event Input Data"]
3755    #[inline(always)]
3756    pub fn eidr03(
3757        self,
3758    ) -> crate::common::RegisterField<
3759        3,
3760        0x1,
3761        1,
3762        0,
3763        eidr::Eidr03,
3764        eidr::Eidr03,
3765        Eidr_SPEC,
3766        crate::common::R,
3767    > {
3768        crate::common::RegisterField::<
3769            3,
3770            0x1,
3771            1,
3772            0,
3773            eidr::Eidr03,
3774            eidr::Eidr03,
3775            Eidr_SPEC,
3776            crate::common::R,
3777        >::from_register(self, 0)
3778    }
3779
3780    #[doc = "Port Event Input Data"]
3781    #[inline(always)]
3782    pub fn eidr04(
3783        self,
3784    ) -> crate::common::RegisterField<
3785        4,
3786        0x1,
3787        1,
3788        0,
3789        eidr::Eidr04,
3790        eidr::Eidr04,
3791        Eidr_SPEC,
3792        crate::common::R,
3793    > {
3794        crate::common::RegisterField::<
3795            4,
3796            0x1,
3797            1,
3798            0,
3799            eidr::Eidr04,
3800            eidr::Eidr04,
3801            Eidr_SPEC,
3802            crate::common::R,
3803        >::from_register(self, 0)
3804    }
3805
3806    #[doc = "Port Event Input Data"]
3807    #[inline(always)]
3808    pub fn eidr05(
3809        self,
3810    ) -> crate::common::RegisterField<
3811        5,
3812        0x1,
3813        1,
3814        0,
3815        eidr::Eidr05,
3816        eidr::Eidr05,
3817        Eidr_SPEC,
3818        crate::common::R,
3819    > {
3820        crate::common::RegisterField::<
3821            5,
3822            0x1,
3823            1,
3824            0,
3825            eidr::Eidr05,
3826            eidr::Eidr05,
3827            Eidr_SPEC,
3828            crate::common::R,
3829        >::from_register(self, 0)
3830    }
3831
3832    #[doc = "Port Event Input Data"]
3833    #[inline(always)]
3834    pub fn eidr06(
3835        self,
3836    ) -> crate::common::RegisterField<
3837        6,
3838        0x1,
3839        1,
3840        0,
3841        eidr::Eidr06,
3842        eidr::Eidr06,
3843        Eidr_SPEC,
3844        crate::common::R,
3845    > {
3846        crate::common::RegisterField::<
3847            6,
3848            0x1,
3849            1,
3850            0,
3851            eidr::Eidr06,
3852            eidr::Eidr06,
3853            Eidr_SPEC,
3854            crate::common::R,
3855        >::from_register(self, 0)
3856    }
3857
3858    #[doc = "Port Event Input Data"]
3859    #[inline(always)]
3860    pub fn eidr07(
3861        self,
3862    ) -> crate::common::RegisterField<
3863        7,
3864        0x1,
3865        1,
3866        0,
3867        eidr::Eidr07,
3868        eidr::Eidr07,
3869        Eidr_SPEC,
3870        crate::common::R,
3871    > {
3872        crate::common::RegisterField::<
3873            7,
3874            0x1,
3875            1,
3876            0,
3877            eidr::Eidr07,
3878            eidr::Eidr07,
3879            Eidr_SPEC,
3880            crate::common::R,
3881        >::from_register(self, 0)
3882    }
3883
3884    #[doc = "Port Event Input Data"]
3885    #[inline(always)]
3886    pub fn eidr08(
3887        self,
3888    ) -> crate::common::RegisterField<
3889        8,
3890        0x1,
3891        1,
3892        0,
3893        eidr::Eidr08,
3894        eidr::Eidr08,
3895        Eidr_SPEC,
3896        crate::common::R,
3897    > {
3898        crate::common::RegisterField::<
3899            8,
3900            0x1,
3901            1,
3902            0,
3903            eidr::Eidr08,
3904            eidr::Eidr08,
3905            Eidr_SPEC,
3906            crate::common::R,
3907        >::from_register(self, 0)
3908    }
3909
3910    #[doc = "Port Event Input Data"]
3911    #[inline(always)]
3912    pub fn eidr09(
3913        self,
3914    ) -> crate::common::RegisterField<
3915        9,
3916        0x1,
3917        1,
3918        0,
3919        eidr::Eidr09,
3920        eidr::Eidr09,
3921        Eidr_SPEC,
3922        crate::common::R,
3923    > {
3924        crate::common::RegisterField::<
3925            9,
3926            0x1,
3927            1,
3928            0,
3929            eidr::Eidr09,
3930            eidr::Eidr09,
3931            Eidr_SPEC,
3932            crate::common::R,
3933        >::from_register(self, 0)
3934    }
3935
3936    #[doc = "Port Event Input Data"]
3937    #[inline(always)]
3938    pub fn eidr10(
3939        self,
3940    ) -> crate::common::RegisterField<
3941        10,
3942        0x1,
3943        1,
3944        0,
3945        eidr::Eidr10,
3946        eidr::Eidr10,
3947        Eidr_SPEC,
3948        crate::common::R,
3949    > {
3950        crate::common::RegisterField::<
3951            10,
3952            0x1,
3953            1,
3954            0,
3955            eidr::Eidr10,
3956            eidr::Eidr10,
3957            Eidr_SPEC,
3958            crate::common::R,
3959        >::from_register(self, 0)
3960    }
3961
3962    #[doc = "Port Event Input Data"]
3963    #[inline(always)]
3964    pub fn eidr11(
3965        self,
3966    ) -> crate::common::RegisterField<
3967        11,
3968        0x1,
3969        1,
3970        0,
3971        eidr::Eidr11,
3972        eidr::Eidr11,
3973        Eidr_SPEC,
3974        crate::common::R,
3975    > {
3976        crate::common::RegisterField::<
3977            11,
3978            0x1,
3979            1,
3980            0,
3981            eidr::Eidr11,
3982            eidr::Eidr11,
3983            Eidr_SPEC,
3984            crate::common::R,
3985        >::from_register(self, 0)
3986    }
3987
3988    #[doc = "Port Event Input Data"]
3989    #[inline(always)]
3990    pub fn eidr12(
3991        self,
3992    ) -> crate::common::RegisterField<
3993        12,
3994        0x1,
3995        1,
3996        0,
3997        eidr::Eidr12,
3998        eidr::Eidr12,
3999        Eidr_SPEC,
4000        crate::common::R,
4001    > {
4002        crate::common::RegisterField::<
4003            12,
4004            0x1,
4005            1,
4006            0,
4007            eidr::Eidr12,
4008            eidr::Eidr12,
4009            Eidr_SPEC,
4010            crate::common::R,
4011        >::from_register(self, 0)
4012    }
4013
4014    #[doc = "Port Event Input Data"]
4015    #[inline(always)]
4016    pub fn eidr13(
4017        self,
4018    ) -> crate::common::RegisterField<
4019        13,
4020        0x1,
4021        1,
4022        0,
4023        eidr::Eidr13,
4024        eidr::Eidr13,
4025        Eidr_SPEC,
4026        crate::common::R,
4027    > {
4028        crate::common::RegisterField::<
4029            13,
4030            0x1,
4031            1,
4032            0,
4033            eidr::Eidr13,
4034            eidr::Eidr13,
4035            Eidr_SPEC,
4036            crate::common::R,
4037        >::from_register(self, 0)
4038    }
4039
4040    #[doc = "Port Event Input Data"]
4041    #[inline(always)]
4042    pub fn eidr14(
4043        self,
4044    ) -> crate::common::RegisterField<
4045        14,
4046        0x1,
4047        1,
4048        0,
4049        eidr::Eidr14,
4050        eidr::Eidr14,
4051        Eidr_SPEC,
4052        crate::common::R,
4053    > {
4054        crate::common::RegisterField::<
4055            14,
4056            0x1,
4057            1,
4058            0,
4059            eidr::Eidr14,
4060            eidr::Eidr14,
4061            Eidr_SPEC,
4062            crate::common::R,
4063        >::from_register(self, 0)
4064    }
4065
4066    #[doc = "Port Event Input Data"]
4067    #[inline(always)]
4068    pub fn eidr15(
4069        self,
4070    ) -> crate::common::RegisterField<
4071        15,
4072        0x1,
4073        1,
4074        0,
4075        eidr::Eidr15,
4076        eidr::Eidr15,
4077        Eidr_SPEC,
4078        crate::common::R,
4079    > {
4080        crate::common::RegisterField::<
4081            15,
4082            0x1,
4083            1,
4084            0,
4085            eidr::Eidr15,
4086            eidr::Eidr15,
4087            Eidr_SPEC,
4088            crate::common::R,
4089        >::from_register(self, 0)
4090    }
4091}
4092impl ::core::default::Default for Eidr {
4093    #[inline(always)]
4094    fn default() -> Eidr {
4095        <crate::RegValueT<Eidr_SPEC> as RegisterValue<_>>::new(0)
4096    }
4097}
4098pub mod eidr {
4099
4100    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4101    pub struct Eidr00_SPEC;
4102    pub type Eidr00 = crate::EnumBitfieldStruct<u8, Eidr00_SPEC>;
4103    impl Eidr00 {
4104        #[doc = "Low input"]
4105        pub const _0: Self = Self::new(0);
4106
4107        #[doc = "High input"]
4108        pub const _1: Self = Self::new(1);
4109    }
4110    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4111    pub struct Eidr01_SPEC;
4112    pub type Eidr01 = crate::EnumBitfieldStruct<u8, Eidr01_SPEC>;
4113    impl Eidr01 {
4114        #[doc = "Low input"]
4115        pub const _0: Self = Self::new(0);
4116
4117        #[doc = "High input"]
4118        pub const _1: Self = Self::new(1);
4119    }
4120    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4121    pub struct Eidr02_SPEC;
4122    pub type Eidr02 = crate::EnumBitfieldStruct<u8, Eidr02_SPEC>;
4123    impl Eidr02 {
4124        #[doc = "Low input"]
4125        pub const _0: Self = Self::new(0);
4126
4127        #[doc = "High input"]
4128        pub const _1: Self = Self::new(1);
4129    }
4130    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4131    pub struct Eidr03_SPEC;
4132    pub type Eidr03 = crate::EnumBitfieldStruct<u8, Eidr03_SPEC>;
4133    impl Eidr03 {
4134        #[doc = "Low input"]
4135        pub const _0: Self = Self::new(0);
4136
4137        #[doc = "High input"]
4138        pub const _1: Self = Self::new(1);
4139    }
4140    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4141    pub struct Eidr04_SPEC;
4142    pub type Eidr04 = crate::EnumBitfieldStruct<u8, Eidr04_SPEC>;
4143    impl Eidr04 {
4144        #[doc = "Low input"]
4145        pub const _0: Self = Self::new(0);
4146
4147        #[doc = "High input"]
4148        pub const _1: Self = Self::new(1);
4149    }
4150    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4151    pub struct Eidr05_SPEC;
4152    pub type Eidr05 = crate::EnumBitfieldStruct<u8, Eidr05_SPEC>;
4153    impl Eidr05 {
4154        #[doc = "Low input"]
4155        pub const _0: Self = Self::new(0);
4156
4157        #[doc = "High input"]
4158        pub const _1: Self = Self::new(1);
4159    }
4160    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4161    pub struct Eidr06_SPEC;
4162    pub type Eidr06 = crate::EnumBitfieldStruct<u8, Eidr06_SPEC>;
4163    impl Eidr06 {
4164        #[doc = "Low input"]
4165        pub const _0: Self = Self::new(0);
4166
4167        #[doc = "High input"]
4168        pub const _1: Self = Self::new(1);
4169    }
4170    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4171    pub struct Eidr07_SPEC;
4172    pub type Eidr07 = crate::EnumBitfieldStruct<u8, Eidr07_SPEC>;
4173    impl Eidr07 {
4174        #[doc = "Low input"]
4175        pub const _0: Self = Self::new(0);
4176
4177        #[doc = "High input"]
4178        pub const _1: Self = Self::new(1);
4179    }
4180    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4181    pub struct Eidr08_SPEC;
4182    pub type Eidr08 = crate::EnumBitfieldStruct<u8, Eidr08_SPEC>;
4183    impl Eidr08 {
4184        #[doc = "Low input"]
4185        pub const _0: Self = Self::new(0);
4186
4187        #[doc = "High input"]
4188        pub const _1: Self = Self::new(1);
4189    }
4190    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4191    pub struct Eidr09_SPEC;
4192    pub type Eidr09 = crate::EnumBitfieldStruct<u8, Eidr09_SPEC>;
4193    impl Eidr09 {
4194        #[doc = "Low input"]
4195        pub const _0: Self = Self::new(0);
4196
4197        #[doc = "High input"]
4198        pub const _1: Self = Self::new(1);
4199    }
4200    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4201    pub struct Eidr10_SPEC;
4202    pub type Eidr10 = crate::EnumBitfieldStruct<u8, Eidr10_SPEC>;
4203    impl Eidr10 {
4204        #[doc = "Low input"]
4205        pub const _0: Self = Self::new(0);
4206
4207        #[doc = "High input"]
4208        pub const _1: Self = Self::new(1);
4209    }
4210    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4211    pub struct Eidr11_SPEC;
4212    pub type Eidr11 = crate::EnumBitfieldStruct<u8, Eidr11_SPEC>;
4213    impl Eidr11 {
4214        #[doc = "Low input"]
4215        pub const _0: Self = Self::new(0);
4216
4217        #[doc = "High input"]
4218        pub const _1: Self = Self::new(1);
4219    }
4220    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4221    pub struct Eidr12_SPEC;
4222    pub type Eidr12 = crate::EnumBitfieldStruct<u8, Eidr12_SPEC>;
4223    impl Eidr12 {
4224        #[doc = "Low input"]
4225        pub const _0: Self = Self::new(0);
4226
4227        #[doc = "High input"]
4228        pub const _1: Self = Self::new(1);
4229    }
4230    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4231    pub struct Eidr13_SPEC;
4232    pub type Eidr13 = crate::EnumBitfieldStruct<u8, Eidr13_SPEC>;
4233    impl Eidr13 {
4234        #[doc = "Low input"]
4235        pub const _0: Self = Self::new(0);
4236
4237        #[doc = "High input"]
4238        pub const _1: Self = Self::new(1);
4239    }
4240    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4241    pub struct Eidr14_SPEC;
4242    pub type Eidr14 = crate::EnumBitfieldStruct<u8, Eidr14_SPEC>;
4243    impl Eidr14 {
4244        #[doc = "Low input"]
4245        pub const _0: Self = Self::new(0);
4246
4247        #[doc = "High input"]
4248        pub const _1: Self = Self::new(1);
4249    }
4250    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4251    pub struct Eidr15_SPEC;
4252    pub type Eidr15 = crate::EnumBitfieldStruct<u8, Eidr15_SPEC>;
4253    impl Eidr15 {
4254        #[doc = "Low input"]
4255        pub const _0: Self = Self::new(0);
4256
4257        #[doc = "High input"]
4258        pub const _1: Self = Self::new(1);
4259    }
4260}
4261#[doc(hidden)]
4262#[derive(Copy, Clone, Eq, PartialEq)]
4263pub struct Pidr_SPEC;
4264impl crate::sealed::RegSpec for Pidr_SPEC {
4265    type DataType = u16;
4266}
4267
4268#[doc = "Port Control Register 2"]
4269pub type Pidr = crate::RegValueT<Pidr_SPEC>;
4270
4271impl Pidr {
4272    #[doc = "Pmn State"]
4273    #[inline(always)]
4274    pub fn pidr00(
4275        self,
4276    ) -> crate::common::RegisterField<
4277        0,
4278        0x1,
4279        1,
4280        0,
4281        pidr::Pidr00,
4282        pidr::Pidr00,
4283        Pidr_SPEC,
4284        crate::common::R,
4285    > {
4286        crate::common::RegisterField::<
4287            0,
4288            0x1,
4289            1,
4290            0,
4291            pidr::Pidr00,
4292            pidr::Pidr00,
4293            Pidr_SPEC,
4294            crate::common::R,
4295        >::from_register(self, 0)
4296    }
4297
4298    #[doc = "Pmn State"]
4299    #[inline(always)]
4300    pub fn pidr01(
4301        self,
4302    ) -> crate::common::RegisterField<
4303        1,
4304        0x1,
4305        1,
4306        0,
4307        pidr::Pidr01,
4308        pidr::Pidr01,
4309        Pidr_SPEC,
4310        crate::common::R,
4311    > {
4312        crate::common::RegisterField::<
4313            1,
4314            0x1,
4315            1,
4316            0,
4317            pidr::Pidr01,
4318            pidr::Pidr01,
4319            Pidr_SPEC,
4320            crate::common::R,
4321        >::from_register(self, 0)
4322    }
4323
4324    #[doc = "Pmn State"]
4325    #[inline(always)]
4326    pub fn pidr02(
4327        self,
4328    ) -> crate::common::RegisterField<
4329        2,
4330        0x1,
4331        1,
4332        0,
4333        pidr::Pidr02,
4334        pidr::Pidr02,
4335        Pidr_SPEC,
4336        crate::common::R,
4337    > {
4338        crate::common::RegisterField::<
4339            2,
4340            0x1,
4341            1,
4342            0,
4343            pidr::Pidr02,
4344            pidr::Pidr02,
4345            Pidr_SPEC,
4346            crate::common::R,
4347        >::from_register(self, 0)
4348    }
4349
4350    #[doc = "Pmn State"]
4351    #[inline(always)]
4352    pub fn pidr03(
4353        self,
4354    ) -> crate::common::RegisterField<
4355        3,
4356        0x1,
4357        1,
4358        0,
4359        pidr::Pidr03,
4360        pidr::Pidr03,
4361        Pidr_SPEC,
4362        crate::common::R,
4363    > {
4364        crate::common::RegisterField::<
4365            3,
4366            0x1,
4367            1,
4368            0,
4369            pidr::Pidr03,
4370            pidr::Pidr03,
4371            Pidr_SPEC,
4372            crate::common::R,
4373        >::from_register(self, 0)
4374    }
4375
4376    #[doc = "Pmn State"]
4377    #[inline(always)]
4378    pub fn pidr04(
4379        self,
4380    ) -> crate::common::RegisterField<
4381        4,
4382        0x1,
4383        1,
4384        0,
4385        pidr::Pidr04,
4386        pidr::Pidr04,
4387        Pidr_SPEC,
4388        crate::common::R,
4389    > {
4390        crate::common::RegisterField::<
4391            4,
4392            0x1,
4393            1,
4394            0,
4395            pidr::Pidr04,
4396            pidr::Pidr04,
4397            Pidr_SPEC,
4398            crate::common::R,
4399        >::from_register(self, 0)
4400    }
4401
4402    #[doc = "Pmn State"]
4403    #[inline(always)]
4404    pub fn pidr05(
4405        self,
4406    ) -> crate::common::RegisterField<
4407        5,
4408        0x1,
4409        1,
4410        0,
4411        pidr::Pidr05,
4412        pidr::Pidr05,
4413        Pidr_SPEC,
4414        crate::common::R,
4415    > {
4416        crate::common::RegisterField::<
4417            5,
4418            0x1,
4419            1,
4420            0,
4421            pidr::Pidr05,
4422            pidr::Pidr05,
4423            Pidr_SPEC,
4424            crate::common::R,
4425        >::from_register(self, 0)
4426    }
4427
4428    #[doc = "Pmn State"]
4429    #[inline(always)]
4430    pub fn pidr06(
4431        self,
4432    ) -> crate::common::RegisterField<
4433        6,
4434        0x1,
4435        1,
4436        0,
4437        pidr::Pidr06,
4438        pidr::Pidr06,
4439        Pidr_SPEC,
4440        crate::common::R,
4441    > {
4442        crate::common::RegisterField::<
4443            6,
4444            0x1,
4445            1,
4446            0,
4447            pidr::Pidr06,
4448            pidr::Pidr06,
4449            Pidr_SPEC,
4450            crate::common::R,
4451        >::from_register(self, 0)
4452    }
4453
4454    #[doc = "Pmn State"]
4455    #[inline(always)]
4456    pub fn pidr07(
4457        self,
4458    ) -> crate::common::RegisterField<
4459        7,
4460        0x1,
4461        1,
4462        0,
4463        pidr::Pidr07,
4464        pidr::Pidr07,
4465        Pidr_SPEC,
4466        crate::common::R,
4467    > {
4468        crate::common::RegisterField::<
4469            7,
4470            0x1,
4471            1,
4472            0,
4473            pidr::Pidr07,
4474            pidr::Pidr07,
4475            Pidr_SPEC,
4476            crate::common::R,
4477        >::from_register(self, 0)
4478    }
4479
4480    #[doc = "Pmn State"]
4481    #[inline(always)]
4482    pub fn pidr08(
4483        self,
4484    ) -> crate::common::RegisterField<
4485        8,
4486        0x1,
4487        1,
4488        0,
4489        pidr::Pidr08,
4490        pidr::Pidr08,
4491        Pidr_SPEC,
4492        crate::common::R,
4493    > {
4494        crate::common::RegisterField::<
4495            8,
4496            0x1,
4497            1,
4498            0,
4499            pidr::Pidr08,
4500            pidr::Pidr08,
4501            Pidr_SPEC,
4502            crate::common::R,
4503        >::from_register(self, 0)
4504    }
4505
4506    #[doc = "Pmn State"]
4507    #[inline(always)]
4508    pub fn pidr09(
4509        self,
4510    ) -> crate::common::RegisterField<
4511        9,
4512        0x1,
4513        1,
4514        0,
4515        pidr::Pidr09,
4516        pidr::Pidr09,
4517        Pidr_SPEC,
4518        crate::common::R,
4519    > {
4520        crate::common::RegisterField::<
4521            9,
4522            0x1,
4523            1,
4524            0,
4525            pidr::Pidr09,
4526            pidr::Pidr09,
4527            Pidr_SPEC,
4528            crate::common::R,
4529        >::from_register(self, 0)
4530    }
4531
4532    #[doc = "Pmn State"]
4533    #[inline(always)]
4534    pub fn pidr10(
4535        self,
4536    ) -> crate::common::RegisterField<
4537        10,
4538        0x1,
4539        1,
4540        0,
4541        pidr::Pidr10,
4542        pidr::Pidr10,
4543        Pidr_SPEC,
4544        crate::common::R,
4545    > {
4546        crate::common::RegisterField::<
4547            10,
4548            0x1,
4549            1,
4550            0,
4551            pidr::Pidr10,
4552            pidr::Pidr10,
4553            Pidr_SPEC,
4554            crate::common::R,
4555        >::from_register(self, 0)
4556    }
4557
4558    #[doc = "Pmn State"]
4559    #[inline(always)]
4560    pub fn pidr11(
4561        self,
4562    ) -> crate::common::RegisterField<
4563        11,
4564        0x1,
4565        1,
4566        0,
4567        pidr::Pidr11,
4568        pidr::Pidr11,
4569        Pidr_SPEC,
4570        crate::common::R,
4571    > {
4572        crate::common::RegisterField::<
4573            11,
4574            0x1,
4575            1,
4576            0,
4577            pidr::Pidr11,
4578            pidr::Pidr11,
4579            Pidr_SPEC,
4580            crate::common::R,
4581        >::from_register(self, 0)
4582    }
4583
4584    #[doc = "Pmn State"]
4585    #[inline(always)]
4586    pub fn pidr12(
4587        self,
4588    ) -> crate::common::RegisterField<
4589        12,
4590        0x1,
4591        1,
4592        0,
4593        pidr::Pidr12,
4594        pidr::Pidr12,
4595        Pidr_SPEC,
4596        crate::common::R,
4597    > {
4598        crate::common::RegisterField::<
4599            12,
4600            0x1,
4601            1,
4602            0,
4603            pidr::Pidr12,
4604            pidr::Pidr12,
4605            Pidr_SPEC,
4606            crate::common::R,
4607        >::from_register(self, 0)
4608    }
4609
4610    #[doc = "Pmn State"]
4611    #[inline(always)]
4612    pub fn pidr13(
4613        self,
4614    ) -> crate::common::RegisterField<
4615        13,
4616        0x1,
4617        1,
4618        0,
4619        pidr::Pidr13,
4620        pidr::Pidr13,
4621        Pidr_SPEC,
4622        crate::common::R,
4623    > {
4624        crate::common::RegisterField::<
4625            13,
4626            0x1,
4627            1,
4628            0,
4629            pidr::Pidr13,
4630            pidr::Pidr13,
4631            Pidr_SPEC,
4632            crate::common::R,
4633        >::from_register(self, 0)
4634    }
4635
4636    #[doc = "Pmn State"]
4637    #[inline(always)]
4638    pub fn pidr14(
4639        self,
4640    ) -> crate::common::RegisterField<
4641        14,
4642        0x1,
4643        1,
4644        0,
4645        pidr::Pidr14,
4646        pidr::Pidr14,
4647        Pidr_SPEC,
4648        crate::common::R,
4649    > {
4650        crate::common::RegisterField::<
4651            14,
4652            0x1,
4653            1,
4654            0,
4655            pidr::Pidr14,
4656            pidr::Pidr14,
4657            Pidr_SPEC,
4658            crate::common::R,
4659        >::from_register(self, 0)
4660    }
4661
4662    #[doc = "Pmn State"]
4663    #[inline(always)]
4664    pub fn pidr15(
4665        self,
4666    ) -> crate::common::RegisterField<
4667        15,
4668        0x1,
4669        1,
4670        0,
4671        pidr::Pidr15,
4672        pidr::Pidr15,
4673        Pidr_SPEC,
4674        crate::common::R,
4675    > {
4676        crate::common::RegisterField::<
4677            15,
4678            0x1,
4679            1,
4680            0,
4681            pidr::Pidr15,
4682            pidr::Pidr15,
4683            Pidr_SPEC,
4684            crate::common::R,
4685        >::from_register(self, 0)
4686    }
4687}
4688impl ::core::default::Default for Pidr {
4689    #[inline(always)]
4690    fn default() -> Pidr {
4691        <crate::RegValueT<Pidr_SPEC> as RegisterValue<_>>::new(0)
4692    }
4693}
4694pub mod pidr {
4695
4696    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4697    pub struct Pidr00_SPEC;
4698    pub type Pidr00 = crate::EnumBitfieldStruct<u8, Pidr00_SPEC>;
4699    impl Pidr00 {
4700        #[doc = "Low level"]
4701        pub const _0: Self = Self::new(0);
4702
4703        #[doc = "High level"]
4704        pub const _1: Self = Self::new(1);
4705    }
4706    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4707    pub struct Pidr01_SPEC;
4708    pub type Pidr01 = crate::EnumBitfieldStruct<u8, Pidr01_SPEC>;
4709    impl Pidr01 {
4710        #[doc = "Low level"]
4711        pub const _0: Self = Self::new(0);
4712
4713        #[doc = "High level"]
4714        pub const _1: Self = Self::new(1);
4715    }
4716    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4717    pub struct Pidr02_SPEC;
4718    pub type Pidr02 = crate::EnumBitfieldStruct<u8, Pidr02_SPEC>;
4719    impl Pidr02 {
4720        #[doc = "Low level"]
4721        pub const _0: Self = Self::new(0);
4722
4723        #[doc = "High level"]
4724        pub const _1: Self = Self::new(1);
4725    }
4726    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4727    pub struct Pidr03_SPEC;
4728    pub type Pidr03 = crate::EnumBitfieldStruct<u8, Pidr03_SPEC>;
4729    impl Pidr03 {
4730        #[doc = "Low level"]
4731        pub const _0: Self = Self::new(0);
4732
4733        #[doc = "High level"]
4734        pub const _1: Self = Self::new(1);
4735    }
4736    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4737    pub struct Pidr04_SPEC;
4738    pub type Pidr04 = crate::EnumBitfieldStruct<u8, Pidr04_SPEC>;
4739    impl Pidr04 {
4740        #[doc = "Low level"]
4741        pub const _0: Self = Self::new(0);
4742
4743        #[doc = "High level"]
4744        pub const _1: Self = Self::new(1);
4745    }
4746    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4747    pub struct Pidr05_SPEC;
4748    pub type Pidr05 = crate::EnumBitfieldStruct<u8, Pidr05_SPEC>;
4749    impl Pidr05 {
4750        #[doc = "Low level"]
4751        pub const _0: Self = Self::new(0);
4752
4753        #[doc = "High level"]
4754        pub const _1: Self = Self::new(1);
4755    }
4756    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4757    pub struct Pidr06_SPEC;
4758    pub type Pidr06 = crate::EnumBitfieldStruct<u8, Pidr06_SPEC>;
4759    impl Pidr06 {
4760        #[doc = "Low level"]
4761        pub const _0: Self = Self::new(0);
4762
4763        #[doc = "High level"]
4764        pub const _1: Self = Self::new(1);
4765    }
4766    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4767    pub struct Pidr07_SPEC;
4768    pub type Pidr07 = crate::EnumBitfieldStruct<u8, Pidr07_SPEC>;
4769    impl Pidr07 {
4770        #[doc = "Low level"]
4771        pub const _0: Self = Self::new(0);
4772
4773        #[doc = "High level"]
4774        pub const _1: Self = Self::new(1);
4775    }
4776    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4777    pub struct Pidr08_SPEC;
4778    pub type Pidr08 = crate::EnumBitfieldStruct<u8, Pidr08_SPEC>;
4779    impl Pidr08 {
4780        #[doc = "Low level"]
4781        pub const _0: Self = Self::new(0);
4782
4783        #[doc = "High level"]
4784        pub const _1: Self = Self::new(1);
4785    }
4786    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4787    pub struct Pidr09_SPEC;
4788    pub type Pidr09 = crate::EnumBitfieldStruct<u8, Pidr09_SPEC>;
4789    impl Pidr09 {
4790        #[doc = "Low level"]
4791        pub const _0: Self = Self::new(0);
4792
4793        #[doc = "High level"]
4794        pub const _1: Self = Self::new(1);
4795    }
4796    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4797    pub struct Pidr10_SPEC;
4798    pub type Pidr10 = crate::EnumBitfieldStruct<u8, Pidr10_SPEC>;
4799    impl Pidr10 {
4800        #[doc = "Low level"]
4801        pub const _0: Self = Self::new(0);
4802
4803        #[doc = "High level"]
4804        pub const _1: Self = Self::new(1);
4805    }
4806    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4807    pub struct Pidr11_SPEC;
4808    pub type Pidr11 = crate::EnumBitfieldStruct<u8, Pidr11_SPEC>;
4809    impl Pidr11 {
4810        #[doc = "Low level"]
4811        pub const _0: Self = Self::new(0);
4812
4813        #[doc = "High level"]
4814        pub const _1: Self = Self::new(1);
4815    }
4816    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4817    pub struct Pidr12_SPEC;
4818    pub type Pidr12 = crate::EnumBitfieldStruct<u8, Pidr12_SPEC>;
4819    impl Pidr12 {
4820        #[doc = "Low level"]
4821        pub const _0: Self = Self::new(0);
4822
4823        #[doc = "High level"]
4824        pub const _1: Self = Self::new(1);
4825    }
4826    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4827    pub struct Pidr13_SPEC;
4828    pub type Pidr13 = crate::EnumBitfieldStruct<u8, Pidr13_SPEC>;
4829    impl Pidr13 {
4830        #[doc = "Low level"]
4831        pub const _0: Self = Self::new(0);
4832
4833        #[doc = "High level"]
4834        pub const _1: Self = Self::new(1);
4835    }
4836    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4837    pub struct Pidr14_SPEC;
4838    pub type Pidr14 = crate::EnumBitfieldStruct<u8, Pidr14_SPEC>;
4839    impl Pidr14 {
4840        #[doc = "Low level"]
4841        pub const _0: Self = Self::new(0);
4842
4843        #[doc = "High level"]
4844        pub const _1: Self = Self::new(1);
4845    }
4846    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4847    pub struct Pidr15_SPEC;
4848    pub type Pidr15 = crate::EnumBitfieldStruct<u8, Pidr15_SPEC>;
4849    impl Pidr15 {
4850        #[doc = "Low level"]
4851        pub const _0: Self = Self::new(0);
4852
4853        #[doc = "High level"]
4854        pub const _1: Self = Self::new(1);
4855    }
4856}
4857#[doc(hidden)]
4858#[derive(Copy, Clone, Eq, PartialEq)]
4859pub struct Pcntr3_SPEC;
4860impl crate::sealed::RegSpec for Pcntr3_SPEC {
4861    type DataType = u32;
4862}
4863
4864#[doc = "Port Control Register 3"]
4865pub type Pcntr3 = crate::RegValueT<Pcntr3_SPEC>;
4866
4867impl Pcntr3 {
4868    #[doc = "Pmn Output Set"]
4869    #[inline(always)]
4870    pub fn posr00(
4871        self,
4872    ) -> crate::common::RegisterField<
4873        0,
4874        0x1,
4875        1,
4876        0,
4877        pcntr3::Posr00,
4878        pcntr3::Posr00,
4879        Pcntr3_SPEC,
4880        crate::common::W,
4881    > {
4882        crate::common::RegisterField::<
4883            0,
4884            0x1,
4885            1,
4886            0,
4887            pcntr3::Posr00,
4888            pcntr3::Posr00,
4889            Pcntr3_SPEC,
4890            crate::common::W,
4891        >::from_register(self, 0)
4892    }
4893
4894    #[doc = "Pmn Output Set"]
4895    #[inline(always)]
4896    pub fn posr01(
4897        self,
4898    ) -> crate::common::RegisterField<
4899        1,
4900        0x1,
4901        1,
4902        0,
4903        pcntr3::Posr01,
4904        pcntr3::Posr01,
4905        Pcntr3_SPEC,
4906        crate::common::W,
4907    > {
4908        crate::common::RegisterField::<
4909            1,
4910            0x1,
4911            1,
4912            0,
4913            pcntr3::Posr01,
4914            pcntr3::Posr01,
4915            Pcntr3_SPEC,
4916            crate::common::W,
4917        >::from_register(self, 0)
4918    }
4919
4920    #[doc = "Pmn Output Set"]
4921    #[inline(always)]
4922    pub fn posr02(
4923        self,
4924    ) -> crate::common::RegisterField<
4925        2,
4926        0x1,
4927        1,
4928        0,
4929        pcntr3::Posr02,
4930        pcntr3::Posr02,
4931        Pcntr3_SPEC,
4932        crate::common::W,
4933    > {
4934        crate::common::RegisterField::<
4935            2,
4936            0x1,
4937            1,
4938            0,
4939            pcntr3::Posr02,
4940            pcntr3::Posr02,
4941            Pcntr3_SPEC,
4942            crate::common::W,
4943        >::from_register(self, 0)
4944    }
4945
4946    #[doc = "Pmn Output Set"]
4947    #[inline(always)]
4948    pub fn posr03(
4949        self,
4950    ) -> crate::common::RegisterField<
4951        3,
4952        0x1,
4953        1,
4954        0,
4955        pcntr3::Posr03,
4956        pcntr3::Posr03,
4957        Pcntr3_SPEC,
4958        crate::common::W,
4959    > {
4960        crate::common::RegisterField::<
4961            3,
4962            0x1,
4963            1,
4964            0,
4965            pcntr3::Posr03,
4966            pcntr3::Posr03,
4967            Pcntr3_SPEC,
4968            crate::common::W,
4969        >::from_register(self, 0)
4970    }
4971
4972    #[doc = "Pmn Output Set"]
4973    #[inline(always)]
4974    pub fn posr04(
4975        self,
4976    ) -> crate::common::RegisterField<
4977        4,
4978        0x1,
4979        1,
4980        0,
4981        pcntr3::Posr04,
4982        pcntr3::Posr04,
4983        Pcntr3_SPEC,
4984        crate::common::W,
4985    > {
4986        crate::common::RegisterField::<
4987            4,
4988            0x1,
4989            1,
4990            0,
4991            pcntr3::Posr04,
4992            pcntr3::Posr04,
4993            Pcntr3_SPEC,
4994            crate::common::W,
4995        >::from_register(self, 0)
4996    }
4997
4998    #[doc = "Pmn Output Set"]
4999    #[inline(always)]
5000    pub fn posr05(
5001        self,
5002    ) -> crate::common::RegisterField<
5003        5,
5004        0x1,
5005        1,
5006        0,
5007        pcntr3::Posr05,
5008        pcntr3::Posr05,
5009        Pcntr3_SPEC,
5010        crate::common::W,
5011    > {
5012        crate::common::RegisterField::<
5013            5,
5014            0x1,
5015            1,
5016            0,
5017            pcntr3::Posr05,
5018            pcntr3::Posr05,
5019            Pcntr3_SPEC,
5020            crate::common::W,
5021        >::from_register(self, 0)
5022    }
5023
5024    #[doc = "Pmn Output Set"]
5025    #[inline(always)]
5026    pub fn posr06(
5027        self,
5028    ) -> crate::common::RegisterField<
5029        6,
5030        0x1,
5031        1,
5032        0,
5033        pcntr3::Posr06,
5034        pcntr3::Posr06,
5035        Pcntr3_SPEC,
5036        crate::common::W,
5037    > {
5038        crate::common::RegisterField::<
5039            6,
5040            0x1,
5041            1,
5042            0,
5043            pcntr3::Posr06,
5044            pcntr3::Posr06,
5045            Pcntr3_SPEC,
5046            crate::common::W,
5047        >::from_register(self, 0)
5048    }
5049
5050    #[doc = "Pmn Output Set"]
5051    #[inline(always)]
5052    pub fn posr07(
5053        self,
5054    ) -> crate::common::RegisterField<
5055        7,
5056        0x1,
5057        1,
5058        0,
5059        pcntr3::Posr07,
5060        pcntr3::Posr07,
5061        Pcntr3_SPEC,
5062        crate::common::W,
5063    > {
5064        crate::common::RegisterField::<
5065            7,
5066            0x1,
5067            1,
5068            0,
5069            pcntr3::Posr07,
5070            pcntr3::Posr07,
5071            Pcntr3_SPEC,
5072            crate::common::W,
5073        >::from_register(self, 0)
5074    }
5075
5076    #[doc = "Pmn Output Set"]
5077    #[inline(always)]
5078    pub fn posr08(
5079        self,
5080    ) -> crate::common::RegisterField<
5081        8,
5082        0x1,
5083        1,
5084        0,
5085        pcntr3::Posr08,
5086        pcntr3::Posr08,
5087        Pcntr3_SPEC,
5088        crate::common::W,
5089    > {
5090        crate::common::RegisterField::<
5091            8,
5092            0x1,
5093            1,
5094            0,
5095            pcntr3::Posr08,
5096            pcntr3::Posr08,
5097            Pcntr3_SPEC,
5098            crate::common::W,
5099        >::from_register(self, 0)
5100    }
5101
5102    #[doc = "Pmn Output Set"]
5103    #[inline(always)]
5104    pub fn posr09(
5105        self,
5106    ) -> crate::common::RegisterField<
5107        9,
5108        0x1,
5109        1,
5110        0,
5111        pcntr3::Posr09,
5112        pcntr3::Posr09,
5113        Pcntr3_SPEC,
5114        crate::common::W,
5115    > {
5116        crate::common::RegisterField::<
5117            9,
5118            0x1,
5119            1,
5120            0,
5121            pcntr3::Posr09,
5122            pcntr3::Posr09,
5123            Pcntr3_SPEC,
5124            crate::common::W,
5125        >::from_register(self, 0)
5126    }
5127
5128    #[doc = "Pmn Output Set"]
5129    #[inline(always)]
5130    pub fn posr10(
5131        self,
5132    ) -> crate::common::RegisterField<
5133        10,
5134        0x1,
5135        1,
5136        0,
5137        pcntr3::Posr10,
5138        pcntr3::Posr10,
5139        Pcntr3_SPEC,
5140        crate::common::W,
5141    > {
5142        crate::common::RegisterField::<
5143            10,
5144            0x1,
5145            1,
5146            0,
5147            pcntr3::Posr10,
5148            pcntr3::Posr10,
5149            Pcntr3_SPEC,
5150            crate::common::W,
5151        >::from_register(self, 0)
5152    }
5153
5154    #[doc = "Pmn Output Set"]
5155    #[inline(always)]
5156    pub fn posr11(
5157        self,
5158    ) -> crate::common::RegisterField<
5159        11,
5160        0x1,
5161        1,
5162        0,
5163        pcntr3::Posr11,
5164        pcntr3::Posr11,
5165        Pcntr3_SPEC,
5166        crate::common::W,
5167    > {
5168        crate::common::RegisterField::<
5169            11,
5170            0x1,
5171            1,
5172            0,
5173            pcntr3::Posr11,
5174            pcntr3::Posr11,
5175            Pcntr3_SPEC,
5176            crate::common::W,
5177        >::from_register(self, 0)
5178    }
5179
5180    #[doc = "Pmn Output Set"]
5181    #[inline(always)]
5182    pub fn posr12(
5183        self,
5184    ) -> crate::common::RegisterField<
5185        12,
5186        0x1,
5187        1,
5188        0,
5189        pcntr3::Posr12,
5190        pcntr3::Posr12,
5191        Pcntr3_SPEC,
5192        crate::common::W,
5193    > {
5194        crate::common::RegisterField::<
5195            12,
5196            0x1,
5197            1,
5198            0,
5199            pcntr3::Posr12,
5200            pcntr3::Posr12,
5201            Pcntr3_SPEC,
5202            crate::common::W,
5203        >::from_register(self, 0)
5204    }
5205
5206    #[doc = "Pmn Output Set"]
5207    #[inline(always)]
5208    pub fn posr13(
5209        self,
5210    ) -> crate::common::RegisterField<
5211        13,
5212        0x1,
5213        1,
5214        0,
5215        pcntr3::Posr13,
5216        pcntr3::Posr13,
5217        Pcntr3_SPEC,
5218        crate::common::W,
5219    > {
5220        crate::common::RegisterField::<
5221            13,
5222            0x1,
5223            1,
5224            0,
5225            pcntr3::Posr13,
5226            pcntr3::Posr13,
5227            Pcntr3_SPEC,
5228            crate::common::W,
5229        >::from_register(self, 0)
5230    }
5231
5232    #[doc = "Pmn Output Set"]
5233    #[inline(always)]
5234    pub fn posr14(
5235        self,
5236    ) -> crate::common::RegisterField<
5237        14,
5238        0x1,
5239        1,
5240        0,
5241        pcntr3::Posr14,
5242        pcntr3::Posr14,
5243        Pcntr3_SPEC,
5244        crate::common::W,
5245    > {
5246        crate::common::RegisterField::<
5247            14,
5248            0x1,
5249            1,
5250            0,
5251            pcntr3::Posr14,
5252            pcntr3::Posr14,
5253            Pcntr3_SPEC,
5254            crate::common::W,
5255        >::from_register(self, 0)
5256    }
5257
5258    #[doc = "Pmn Output Set"]
5259    #[inline(always)]
5260    pub fn posr15(
5261        self,
5262    ) -> crate::common::RegisterField<
5263        15,
5264        0x1,
5265        1,
5266        0,
5267        pcntr3::Posr15,
5268        pcntr3::Posr15,
5269        Pcntr3_SPEC,
5270        crate::common::W,
5271    > {
5272        crate::common::RegisterField::<
5273            15,
5274            0x1,
5275            1,
5276            0,
5277            pcntr3::Posr15,
5278            pcntr3::Posr15,
5279            Pcntr3_SPEC,
5280            crate::common::W,
5281        >::from_register(self, 0)
5282    }
5283
5284    #[doc = "Pmn Output Reset"]
5285    #[inline(always)]
5286    pub fn porr00(
5287        self,
5288    ) -> crate::common::RegisterField<
5289        16,
5290        0x1,
5291        1,
5292        0,
5293        pcntr3::Porr00,
5294        pcntr3::Porr00,
5295        Pcntr3_SPEC,
5296        crate::common::W,
5297    > {
5298        crate::common::RegisterField::<
5299            16,
5300            0x1,
5301            1,
5302            0,
5303            pcntr3::Porr00,
5304            pcntr3::Porr00,
5305            Pcntr3_SPEC,
5306            crate::common::W,
5307        >::from_register(self, 0)
5308    }
5309
5310    #[doc = "Pmn Output Reset"]
5311    #[inline(always)]
5312    pub fn porr01(
5313        self,
5314    ) -> crate::common::RegisterField<
5315        17,
5316        0x1,
5317        1,
5318        0,
5319        pcntr3::Porr01,
5320        pcntr3::Porr01,
5321        Pcntr3_SPEC,
5322        crate::common::W,
5323    > {
5324        crate::common::RegisterField::<
5325            17,
5326            0x1,
5327            1,
5328            0,
5329            pcntr3::Porr01,
5330            pcntr3::Porr01,
5331            Pcntr3_SPEC,
5332            crate::common::W,
5333        >::from_register(self, 0)
5334    }
5335
5336    #[doc = "Pmn Output Reset"]
5337    #[inline(always)]
5338    pub fn porr02(
5339        self,
5340    ) -> crate::common::RegisterField<
5341        18,
5342        0x1,
5343        1,
5344        0,
5345        pcntr3::Porr02,
5346        pcntr3::Porr02,
5347        Pcntr3_SPEC,
5348        crate::common::W,
5349    > {
5350        crate::common::RegisterField::<
5351            18,
5352            0x1,
5353            1,
5354            0,
5355            pcntr3::Porr02,
5356            pcntr3::Porr02,
5357            Pcntr3_SPEC,
5358            crate::common::W,
5359        >::from_register(self, 0)
5360    }
5361
5362    #[doc = "Pmn Output Reset"]
5363    #[inline(always)]
5364    pub fn porr03(
5365        self,
5366    ) -> crate::common::RegisterField<
5367        19,
5368        0x1,
5369        1,
5370        0,
5371        pcntr3::Porr03,
5372        pcntr3::Porr03,
5373        Pcntr3_SPEC,
5374        crate::common::W,
5375    > {
5376        crate::common::RegisterField::<
5377            19,
5378            0x1,
5379            1,
5380            0,
5381            pcntr3::Porr03,
5382            pcntr3::Porr03,
5383            Pcntr3_SPEC,
5384            crate::common::W,
5385        >::from_register(self, 0)
5386    }
5387
5388    #[doc = "Pmn Output Reset"]
5389    #[inline(always)]
5390    pub fn porr04(
5391        self,
5392    ) -> crate::common::RegisterField<
5393        20,
5394        0x1,
5395        1,
5396        0,
5397        pcntr3::Porr04,
5398        pcntr3::Porr04,
5399        Pcntr3_SPEC,
5400        crate::common::W,
5401    > {
5402        crate::common::RegisterField::<
5403            20,
5404            0x1,
5405            1,
5406            0,
5407            pcntr3::Porr04,
5408            pcntr3::Porr04,
5409            Pcntr3_SPEC,
5410            crate::common::W,
5411        >::from_register(self, 0)
5412    }
5413
5414    #[doc = "Pmn Output Reset"]
5415    #[inline(always)]
5416    pub fn porr05(
5417        self,
5418    ) -> crate::common::RegisterField<
5419        21,
5420        0x1,
5421        1,
5422        0,
5423        pcntr3::Porr05,
5424        pcntr3::Porr05,
5425        Pcntr3_SPEC,
5426        crate::common::W,
5427    > {
5428        crate::common::RegisterField::<
5429            21,
5430            0x1,
5431            1,
5432            0,
5433            pcntr3::Porr05,
5434            pcntr3::Porr05,
5435            Pcntr3_SPEC,
5436            crate::common::W,
5437        >::from_register(self, 0)
5438    }
5439
5440    #[doc = "Pmn Output Reset"]
5441    #[inline(always)]
5442    pub fn porr06(
5443        self,
5444    ) -> crate::common::RegisterField<
5445        22,
5446        0x1,
5447        1,
5448        0,
5449        pcntr3::Porr06,
5450        pcntr3::Porr06,
5451        Pcntr3_SPEC,
5452        crate::common::W,
5453    > {
5454        crate::common::RegisterField::<
5455            22,
5456            0x1,
5457            1,
5458            0,
5459            pcntr3::Porr06,
5460            pcntr3::Porr06,
5461            Pcntr3_SPEC,
5462            crate::common::W,
5463        >::from_register(self, 0)
5464    }
5465
5466    #[doc = "Pmn Output Reset"]
5467    #[inline(always)]
5468    pub fn porr07(
5469        self,
5470    ) -> crate::common::RegisterField<
5471        23,
5472        0x1,
5473        1,
5474        0,
5475        pcntr3::Porr07,
5476        pcntr3::Porr07,
5477        Pcntr3_SPEC,
5478        crate::common::W,
5479    > {
5480        crate::common::RegisterField::<
5481            23,
5482            0x1,
5483            1,
5484            0,
5485            pcntr3::Porr07,
5486            pcntr3::Porr07,
5487            Pcntr3_SPEC,
5488            crate::common::W,
5489        >::from_register(self, 0)
5490    }
5491
5492    #[doc = "Pmn Output Reset"]
5493    #[inline(always)]
5494    pub fn porr08(
5495        self,
5496    ) -> crate::common::RegisterField<
5497        24,
5498        0x1,
5499        1,
5500        0,
5501        pcntr3::Porr08,
5502        pcntr3::Porr08,
5503        Pcntr3_SPEC,
5504        crate::common::W,
5505    > {
5506        crate::common::RegisterField::<
5507            24,
5508            0x1,
5509            1,
5510            0,
5511            pcntr3::Porr08,
5512            pcntr3::Porr08,
5513            Pcntr3_SPEC,
5514            crate::common::W,
5515        >::from_register(self, 0)
5516    }
5517
5518    #[doc = "Pmn Output Reset"]
5519    #[inline(always)]
5520    pub fn porr09(
5521        self,
5522    ) -> crate::common::RegisterField<
5523        25,
5524        0x1,
5525        1,
5526        0,
5527        pcntr3::Porr09,
5528        pcntr3::Porr09,
5529        Pcntr3_SPEC,
5530        crate::common::W,
5531    > {
5532        crate::common::RegisterField::<
5533            25,
5534            0x1,
5535            1,
5536            0,
5537            pcntr3::Porr09,
5538            pcntr3::Porr09,
5539            Pcntr3_SPEC,
5540            crate::common::W,
5541        >::from_register(self, 0)
5542    }
5543
5544    #[doc = "Pmn Output Reset"]
5545    #[inline(always)]
5546    pub fn porr10(
5547        self,
5548    ) -> crate::common::RegisterField<
5549        26,
5550        0x1,
5551        1,
5552        0,
5553        pcntr3::Porr10,
5554        pcntr3::Porr10,
5555        Pcntr3_SPEC,
5556        crate::common::W,
5557    > {
5558        crate::common::RegisterField::<
5559            26,
5560            0x1,
5561            1,
5562            0,
5563            pcntr3::Porr10,
5564            pcntr3::Porr10,
5565            Pcntr3_SPEC,
5566            crate::common::W,
5567        >::from_register(self, 0)
5568    }
5569
5570    #[doc = "Pmn Output Reset"]
5571    #[inline(always)]
5572    pub fn porr11(
5573        self,
5574    ) -> crate::common::RegisterField<
5575        27,
5576        0x1,
5577        1,
5578        0,
5579        pcntr3::Porr11,
5580        pcntr3::Porr11,
5581        Pcntr3_SPEC,
5582        crate::common::W,
5583    > {
5584        crate::common::RegisterField::<
5585            27,
5586            0x1,
5587            1,
5588            0,
5589            pcntr3::Porr11,
5590            pcntr3::Porr11,
5591            Pcntr3_SPEC,
5592            crate::common::W,
5593        >::from_register(self, 0)
5594    }
5595
5596    #[doc = "Pmn Output Reset"]
5597    #[inline(always)]
5598    pub fn porr12(
5599        self,
5600    ) -> crate::common::RegisterField<
5601        28,
5602        0x1,
5603        1,
5604        0,
5605        pcntr3::Porr12,
5606        pcntr3::Porr12,
5607        Pcntr3_SPEC,
5608        crate::common::W,
5609    > {
5610        crate::common::RegisterField::<
5611            28,
5612            0x1,
5613            1,
5614            0,
5615            pcntr3::Porr12,
5616            pcntr3::Porr12,
5617            Pcntr3_SPEC,
5618            crate::common::W,
5619        >::from_register(self, 0)
5620    }
5621
5622    #[doc = "Pmn Output Reset"]
5623    #[inline(always)]
5624    pub fn porr13(
5625        self,
5626    ) -> crate::common::RegisterField<
5627        29,
5628        0x1,
5629        1,
5630        0,
5631        pcntr3::Porr13,
5632        pcntr3::Porr13,
5633        Pcntr3_SPEC,
5634        crate::common::W,
5635    > {
5636        crate::common::RegisterField::<
5637            29,
5638            0x1,
5639            1,
5640            0,
5641            pcntr3::Porr13,
5642            pcntr3::Porr13,
5643            Pcntr3_SPEC,
5644            crate::common::W,
5645        >::from_register(self, 0)
5646    }
5647
5648    #[doc = "Pmn Output Reset"]
5649    #[inline(always)]
5650    pub fn porr14(
5651        self,
5652    ) -> crate::common::RegisterField<
5653        30,
5654        0x1,
5655        1,
5656        0,
5657        pcntr3::Porr14,
5658        pcntr3::Porr14,
5659        Pcntr3_SPEC,
5660        crate::common::W,
5661    > {
5662        crate::common::RegisterField::<
5663            30,
5664            0x1,
5665            1,
5666            0,
5667            pcntr3::Porr14,
5668            pcntr3::Porr14,
5669            Pcntr3_SPEC,
5670            crate::common::W,
5671        >::from_register(self, 0)
5672    }
5673
5674    #[doc = "Pmn Output Reset"]
5675    #[inline(always)]
5676    pub fn porr15(
5677        self,
5678    ) -> crate::common::RegisterField<
5679        31,
5680        0x1,
5681        1,
5682        0,
5683        pcntr3::Porr15,
5684        pcntr3::Porr15,
5685        Pcntr3_SPEC,
5686        crate::common::W,
5687    > {
5688        crate::common::RegisterField::<
5689            31,
5690            0x1,
5691            1,
5692            0,
5693            pcntr3::Porr15,
5694            pcntr3::Porr15,
5695            Pcntr3_SPEC,
5696            crate::common::W,
5697        >::from_register(self, 0)
5698    }
5699}
5700impl ::core::default::Default for Pcntr3 {
5701    #[inline(always)]
5702    fn default() -> Pcntr3 {
5703        <crate::RegValueT<Pcntr3_SPEC> as RegisterValue<_>>::new(0)
5704    }
5705}
5706pub mod pcntr3 {
5707
5708    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5709    pub struct Posr00_SPEC;
5710    pub type Posr00 = crate::EnumBitfieldStruct<u8, Posr00_SPEC>;
5711    impl Posr00 {
5712        #[doc = "No effect on output"]
5713        pub const _0: Self = Self::new(0);
5714
5715        #[doc = "High output"]
5716        pub const _1: Self = Self::new(1);
5717    }
5718    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5719    pub struct Posr01_SPEC;
5720    pub type Posr01 = crate::EnumBitfieldStruct<u8, Posr01_SPEC>;
5721    impl Posr01 {
5722        #[doc = "No effect on output"]
5723        pub const _0: Self = Self::new(0);
5724
5725        #[doc = "High output"]
5726        pub const _1: Self = Self::new(1);
5727    }
5728    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5729    pub struct Posr02_SPEC;
5730    pub type Posr02 = crate::EnumBitfieldStruct<u8, Posr02_SPEC>;
5731    impl Posr02 {
5732        #[doc = "No effect on output"]
5733        pub const _0: Self = Self::new(0);
5734
5735        #[doc = "High output"]
5736        pub const _1: Self = Self::new(1);
5737    }
5738    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5739    pub struct Posr03_SPEC;
5740    pub type Posr03 = crate::EnumBitfieldStruct<u8, Posr03_SPEC>;
5741    impl Posr03 {
5742        #[doc = "No effect on output"]
5743        pub const _0: Self = Self::new(0);
5744
5745        #[doc = "High output"]
5746        pub const _1: Self = Self::new(1);
5747    }
5748    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5749    pub struct Posr04_SPEC;
5750    pub type Posr04 = crate::EnumBitfieldStruct<u8, Posr04_SPEC>;
5751    impl Posr04 {
5752        #[doc = "No effect on output"]
5753        pub const _0: Self = Self::new(0);
5754
5755        #[doc = "High output"]
5756        pub const _1: Self = Self::new(1);
5757    }
5758    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5759    pub struct Posr05_SPEC;
5760    pub type Posr05 = crate::EnumBitfieldStruct<u8, Posr05_SPEC>;
5761    impl Posr05 {
5762        #[doc = "No effect on output"]
5763        pub const _0: Self = Self::new(0);
5764
5765        #[doc = "High output"]
5766        pub const _1: Self = Self::new(1);
5767    }
5768    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5769    pub struct Posr06_SPEC;
5770    pub type Posr06 = crate::EnumBitfieldStruct<u8, Posr06_SPEC>;
5771    impl Posr06 {
5772        #[doc = "No effect on output"]
5773        pub const _0: Self = Self::new(0);
5774
5775        #[doc = "High output"]
5776        pub const _1: Self = Self::new(1);
5777    }
5778    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5779    pub struct Posr07_SPEC;
5780    pub type Posr07 = crate::EnumBitfieldStruct<u8, Posr07_SPEC>;
5781    impl Posr07 {
5782        #[doc = "No effect on output"]
5783        pub const _0: Self = Self::new(0);
5784
5785        #[doc = "High output"]
5786        pub const _1: Self = Self::new(1);
5787    }
5788    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5789    pub struct Posr08_SPEC;
5790    pub type Posr08 = crate::EnumBitfieldStruct<u8, Posr08_SPEC>;
5791    impl Posr08 {
5792        #[doc = "No effect on output"]
5793        pub const _0: Self = Self::new(0);
5794
5795        #[doc = "High output"]
5796        pub const _1: Self = Self::new(1);
5797    }
5798    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5799    pub struct Posr09_SPEC;
5800    pub type Posr09 = crate::EnumBitfieldStruct<u8, Posr09_SPEC>;
5801    impl Posr09 {
5802        #[doc = "No effect on output"]
5803        pub const _0: Self = Self::new(0);
5804
5805        #[doc = "High output"]
5806        pub const _1: Self = Self::new(1);
5807    }
5808    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5809    pub struct Posr10_SPEC;
5810    pub type Posr10 = crate::EnumBitfieldStruct<u8, Posr10_SPEC>;
5811    impl Posr10 {
5812        #[doc = "No effect on output"]
5813        pub const _0: Self = Self::new(0);
5814
5815        #[doc = "High output"]
5816        pub const _1: Self = Self::new(1);
5817    }
5818    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5819    pub struct Posr11_SPEC;
5820    pub type Posr11 = crate::EnumBitfieldStruct<u8, Posr11_SPEC>;
5821    impl Posr11 {
5822        #[doc = "No effect on output"]
5823        pub const _0: Self = Self::new(0);
5824
5825        #[doc = "High output"]
5826        pub const _1: Self = Self::new(1);
5827    }
5828    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5829    pub struct Posr12_SPEC;
5830    pub type Posr12 = crate::EnumBitfieldStruct<u8, Posr12_SPEC>;
5831    impl Posr12 {
5832        #[doc = "No effect on output"]
5833        pub const _0: Self = Self::new(0);
5834
5835        #[doc = "High output"]
5836        pub const _1: Self = Self::new(1);
5837    }
5838    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5839    pub struct Posr13_SPEC;
5840    pub type Posr13 = crate::EnumBitfieldStruct<u8, Posr13_SPEC>;
5841    impl Posr13 {
5842        #[doc = "No effect on output"]
5843        pub const _0: Self = Self::new(0);
5844
5845        #[doc = "High output"]
5846        pub const _1: Self = Self::new(1);
5847    }
5848    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5849    pub struct Posr14_SPEC;
5850    pub type Posr14 = crate::EnumBitfieldStruct<u8, Posr14_SPEC>;
5851    impl Posr14 {
5852        #[doc = "No effect on output"]
5853        pub const _0: Self = Self::new(0);
5854
5855        #[doc = "High output"]
5856        pub const _1: Self = Self::new(1);
5857    }
5858    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5859    pub struct Posr15_SPEC;
5860    pub type Posr15 = crate::EnumBitfieldStruct<u8, Posr15_SPEC>;
5861    impl Posr15 {
5862        #[doc = "No effect on output"]
5863        pub const _0: Self = Self::new(0);
5864
5865        #[doc = "High output"]
5866        pub const _1: Self = Self::new(1);
5867    }
5868    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5869    pub struct Porr00_SPEC;
5870    pub type Porr00 = crate::EnumBitfieldStruct<u8, Porr00_SPEC>;
5871    impl Porr00 {
5872        #[doc = "No effect on output"]
5873        pub const _0: Self = Self::new(0);
5874
5875        #[doc = "Low output"]
5876        pub const _1: Self = Self::new(1);
5877    }
5878    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5879    pub struct Porr01_SPEC;
5880    pub type Porr01 = crate::EnumBitfieldStruct<u8, Porr01_SPEC>;
5881    impl Porr01 {
5882        #[doc = "No effect on output"]
5883        pub const _0: Self = Self::new(0);
5884
5885        #[doc = "Low output"]
5886        pub const _1: Self = Self::new(1);
5887    }
5888    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5889    pub struct Porr02_SPEC;
5890    pub type Porr02 = crate::EnumBitfieldStruct<u8, Porr02_SPEC>;
5891    impl Porr02 {
5892        #[doc = "No effect on output"]
5893        pub const _0: Self = Self::new(0);
5894
5895        #[doc = "Low output"]
5896        pub const _1: Self = Self::new(1);
5897    }
5898    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5899    pub struct Porr03_SPEC;
5900    pub type Porr03 = crate::EnumBitfieldStruct<u8, Porr03_SPEC>;
5901    impl Porr03 {
5902        #[doc = "No effect on output"]
5903        pub const _0: Self = Self::new(0);
5904
5905        #[doc = "Low output"]
5906        pub const _1: Self = Self::new(1);
5907    }
5908    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5909    pub struct Porr04_SPEC;
5910    pub type Porr04 = crate::EnumBitfieldStruct<u8, Porr04_SPEC>;
5911    impl Porr04 {
5912        #[doc = "No effect on output"]
5913        pub const _0: Self = Self::new(0);
5914
5915        #[doc = "Low output"]
5916        pub const _1: Self = Self::new(1);
5917    }
5918    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5919    pub struct Porr05_SPEC;
5920    pub type Porr05 = crate::EnumBitfieldStruct<u8, Porr05_SPEC>;
5921    impl Porr05 {
5922        #[doc = "No effect on output"]
5923        pub const _0: Self = Self::new(0);
5924
5925        #[doc = "Low output"]
5926        pub const _1: Self = Self::new(1);
5927    }
5928    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5929    pub struct Porr06_SPEC;
5930    pub type Porr06 = crate::EnumBitfieldStruct<u8, Porr06_SPEC>;
5931    impl Porr06 {
5932        #[doc = "No effect on output"]
5933        pub const _0: Self = Self::new(0);
5934
5935        #[doc = "Low output"]
5936        pub const _1: Self = Self::new(1);
5937    }
5938    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5939    pub struct Porr07_SPEC;
5940    pub type Porr07 = crate::EnumBitfieldStruct<u8, Porr07_SPEC>;
5941    impl Porr07 {
5942        #[doc = "No effect on output"]
5943        pub const _0: Self = Self::new(0);
5944
5945        #[doc = "Low output"]
5946        pub const _1: Self = Self::new(1);
5947    }
5948    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5949    pub struct Porr08_SPEC;
5950    pub type Porr08 = crate::EnumBitfieldStruct<u8, Porr08_SPEC>;
5951    impl Porr08 {
5952        #[doc = "No effect on output"]
5953        pub const _0: Self = Self::new(0);
5954
5955        #[doc = "Low output"]
5956        pub const _1: Self = Self::new(1);
5957    }
5958    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5959    pub struct Porr09_SPEC;
5960    pub type Porr09 = crate::EnumBitfieldStruct<u8, Porr09_SPEC>;
5961    impl Porr09 {
5962        #[doc = "No effect on output"]
5963        pub const _0: Self = Self::new(0);
5964
5965        #[doc = "Low output"]
5966        pub const _1: Self = Self::new(1);
5967    }
5968    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5969    pub struct Porr10_SPEC;
5970    pub type Porr10 = crate::EnumBitfieldStruct<u8, Porr10_SPEC>;
5971    impl Porr10 {
5972        #[doc = "No effect on output"]
5973        pub const _0: Self = Self::new(0);
5974
5975        #[doc = "Low output"]
5976        pub const _1: Self = Self::new(1);
5977    }
5978    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5979    pub struct Porr11_SPEC;
5980    pub type Porr11 = crate::EnumBitfieldStruct<u8, Porr11_SPEC>;
5981    impl Porr11 {
5982        #[doc = "No effect on output"]
5983        pub const _0: Self = Self::new(0);
5984
5985        #[doc = "Low output"]
5986        pub const _1: Self = Self::new(1);
5987    }
5988    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5989    pub struct Porr12_SPEC;
5990    pub type Porr12 = crate::EnumBitfieldStruct<u8, Porr12_SPEC>;
5991    impl Porr12 {
5992        #[doc = "No effect on output"]
5993        pub const _0: Self = Self::new(0);
5994
5995        #[doc = "Low output"]
5996        pub const _1: Self = Self::new(1);
5997    }
5998    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5999    pub struct Porr13_SPEC;
6000    pub type Porr13 = crate::EnumBitfieldStruct<u8, Porr13_SPEC>;
6001    impl Porr13 {
6002        #[doc = "No effect on output"]
6003        pub const _0: Self = Self::new(0);
6004
6005        #[doc = "Low output"]
6006        pub const _1: Self = Self::new(1);
6007    }
6008    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6009    pub struct Porr14_SPEC;
6010    pub type Porr14 = crate::EnumBitfieldStruct<u8, Porr14_SPEC>;
6011    impl Porr14 {
6012        #[doc = "No effect on output"]
6013        pub const _0: Self = Self::new(0);
6014
6015        #[doc = "Low output"]
6016        pub const _1: Self = Self::new(1);
6017    }
6018    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6019    pub struct Porr15_SPEC;
6020    pub type Porr15 = crate::EnumBitfieldStruct<u8, Porr15_SPEC>;
6021    impl Porr15 {
6022        #[doc = "No effect on output"]
6023        pub const _0: Self = Self::new(0);
6024
6025        #[doc = "Low output"]
6026        pub const _1: Self = Self::new(1);
6027    }
6028}
6029#[doc(hidden)]
6030#[derive(Copy, Clone, Eq, PartialEq)]
6031pub struct Porr_SPEC;
6032impl crate::sealed::RegSpec for Porr_SPEC {
6033    type DataType = u16;
6034}
6035
6036#[doc = "Port Control Register 3"]
6037pub type Porr = crate::RegValueT<Porr_SPEC>;
6038
6039impl Porr {
6040    #[doc = "Pmn Output Reset"]
6041    #[inline(always)]
6042    pub fn porr00(
6043        self,
6044    ) -> crate::common::RegisterField<
6045        0,
6046        0x1,
6047        1,
6048        0,
6049        porr::Porr00,
6050        porr::Porr00,
6051        Porr_SPEC,
6052        crate::common::W,
6053    > {
6054        crate::common::RegisterField::<
6055            0,
6056            0x1,
6057            1,
6058            0,
6059            porr::Porr00,
6060            porr::Porr00,
6061            Porr_SPEC,
6062            crate::common::W,
6063        >::from_register(self, 0)
6064    }
6065
6066    #[doc = "Pmn Output Reset"]
6067    #[inline(always)]
6068    pub fn porr01(
6069        self,
6070    ) -> crate::common::RegisterField<
6071        1,
6072        0x1,
6073        1,
6074        0,
6075        porr::Porr01,
6076        porr::Porr01,
6077        Porr_SPEC,
6078        crate::common::W,
6079    > {
6080        crate::common::RegisterField::<
6081            1,
6082            0x1,
6083            1,
6084            0,
6085            porr::Porr01,
6086            porr::Porr01,
6087            Porr_SPEC,
6088            crate::common::W,
6089        >::from_register(self, 0)
6090    }
6091
6092    #[doc = "Pmn Output Reset"]
6093    #[inline(always)]
6094    pub fn porr02(
6095        self,
6096    ) -> crate::common::RegisterField<
6097        2,
6098        0x1,
6099        1,
6100        0,
6101        porr::Porr02,
6102        porr::Porr02,
6103        Porr_SPEC,
6104        crate::common::W,
6105    > {
6106        crate::common::RegisterField::<
6107            2,
6108            0x1,
6109            1,
6110            0,
6111            porr::Porr02,
6112            porr::Porr02,
6113            Porr_SPEC,
6114            crate::common::W,
6115        >::from_register(self, 0)
6116    }
6117
6118    #[doc = "Pmn Output Reset"]
6119    #[inline(always)]
6120    pub fn porr03(
6121        self,
6122    ) -> crate::common::RegisterField<
6123        3,
6124        0x1,
6125        1,
6126        0,
6127        porr::Porr03,
6128        porr::Porr03,
6129        Porr_SPEC,
6130        crate::common::W,
6131    > {
6132        crate::common::RegisterField::<
6133            3,
6134            0x1,
6135            1,
6136            0,
6137            porr::Porr03,
6138            porr::Porr03,
6139            Porr_SPEC,
6140            crate::common::W,
6141        >::from_register(self, 0)
6142    }
6143
6144    #[doc = "Pmn Output Reset"]
6145    #[inline(always)]
6146    pub fn porr04(
6147        self,
6148    ) -> crate::common::RegisterField<
6149        4,
6150        0x1,
6151        1,
6152        0,
6153        porr::Porr04,
6154        porr::Porr04,
6155        Porr_SPEC,
6156        crate::common::W,
6157    > {
6158        crate::common::RegisterField::<
6159            4,
6160            0x1,
6161            1,
6162            0,
6163            porr::Porr04,
6164            porr::Porr04,
6165            Porr_SPEC,
6166            crate::common::W,
6167        >::from_register(self, 0)
6168    }
6169
6170    #[doc = "Pmn Output Reset"]
6171    #[inline(always)]
6172    pub fn porr05(
6173        self,
6174    ) -> crate::common::RegisterField<
6175        5,
6176        0x1,
6177        1,
6178        0,
6179        porr::Porr05,
6180        porr::Porr05,
6181        Porr_SPEC,
6182        crate::common::W,
6183    > {
6184        crate::common::RegisterField::<
6185            5,
6186            0x1,
6187            1,
6188            0,
6189            porr::Porr05,
6190            porr::Porr05,
6191            Porr_SPEC,
6192            crate::common::W,
6193        >::from_register(self, 0)
6194    }
6195
6196    #[doc = "Pmn Output Reset"]
6197    #[inline(always)]
6198    pub fn porr06(
6199        self,
6200    ) -> crate::common::RegisterField<
6201        6,
6202        0x1,
6203        1,
6204        0,
6205        porr::Porr06,
6206        porr::Porr06,
6207        Porr_SPEC,
6208        crate::common::W,
6209    > {
6210        crate::common::RegisterField::<
6211            6,
6212            0x1,
6213            1,
6214            0,
6215            porr::Porr06,
6216            porr::Porr06,
6217            Porr_SPEC,
6218            crate::common::W,
6219        >::from_register(self, 0)
6220    }
6221
6222    #[doc = "Pmn Output Reset"]
6223    #[inline(always)]
6224    pub fn porr07(
6225        self,
6226    ) -> crate::common::RegisterField<
6227        7,
6228        0x1,
6229        1,
6230        0,
6231        porr::Porr07,
6232        porr::Porr07,
6233        Porr_SPEC,
6234        crate::common::W,
6235    > {
6236        crate::common::RegisterField::<
6237            7,
6238            0x1,
6239            1,
6240            0,
6241            porr::Porr07,
6242            porr::Porr07,
6243            Porr_SPEC,
6244            crate::common::W,
6245        >::from_register(self, 0)
6246    }
6247
6248    #[doc = "Pmn Output Reset"]
6249    #[inline(always)]
6250    pub fn porr08(
6251        self,
6252    ) -> crate::common::RegisterField<
6253        8,
6254        0x1,
6255        1,
6256        0,
6257        porr::Porr08,
6258        porr::Porr08,
6259        Porr_SPEC,
6260        crate::common::W,
6261    > {
6262        crate::common::RegisterField::<
6263            8,
6264            0x1,
6265            1,
6266            0,
6267            porr::Porr08,
6268            porr::Porr08,
6269            Porr_SPEC,
6270            crate::common::W,
6271        >::from_register(self, 0)
6272    }
6273
6274    #[doc = "Pmn Output Reset"]
6275    #[inline(always)]
6276    pub fn porr09(
6277        self,
6278    ) -> crate::common::RegisterField<
6279        9,
6280        0x1,
6281        1,
6282        0,
6283        porr::Porr09,
6284        porr::Porr09,
6285        Porr_SPEC,
6286        crate::common::W,
6287    > {
6288        crate::common::RegisterField::<
6289            9,
6290            0x1,
6291            1,
6292            0,
6293            porr::Porr09,
6294            porr::Porr09,
6295            Porr_SPEC,
6296            crate::common::W,
6297        >::from_register(self, 0)
6298    }
6299
6300    #[doc = "Pmn Output Reset"]
6301    #[inline(always)]
6302    pub fn porr10(
6303        self,
6304    ) -> crate::common::RegisterField<
6305        10,
6306        0x1,
6307        1,
6308        0,
6309        porr::Porr10,
6310        porr::Porr10,
6311        Porr_SPEC,
6312        crate::common::W,
6313    > {
6314        crate::common::RegisterField::<
6315            10,
6316            0x1,
6317            1,
6318            0,
6319            porr::Porr10,
6320            porr::Porr10,
6321            Porr_SPEC,
6322            crate::common::W,
6323        >::from_register(self, 0)
6324    }
6325
6326    #[doc = "Pmn Output Reset"]
6327    #[inline(always)]
6328    pub fn porr11(
6329        self,
6330    ) -> crate::common::RegisterField<
6331        11,
6332        0x1,
6333        1,
6334        0,
6335        porr::Porr11,
6336        porr::Porr11,
6337        Porr_SPEC,
6338        crate::common::W,
6339    > {
6340        crate::common::RegisterField::<
6341            11,
6342            0x1,
6343            1,
6344            0,
6345            porr::Porr11,
6346            porr::Porr11,
6347            Porr_SPEC,
6348            crate::common::W,
6349        >::from_register(self, 0)
6350    }
6351
6352    #[doc = "Pmn Output Reset"]
6353    #[inline(always)]
6354    pub fn porr12(
6355        self,
6356    ) -> crate::common::RegisterField<
6357        12,
6358        0x1,
6359        1,
6360        0,
6361        porr::Porr12,
6362        porr::Porr12,
6363        Porr_SPEC,
6364        crate::common::W,
6365    > {
6366        crate::common::RegisterField::<
6367            12,
6368            0x1,
6369            1,
6370            0,
6371            porr::Porr12,
6372            porr::Porr12,
6373            Porr_SPEC,
6374            crate::common::W,
6375        >::from_register(self, 0)
6376    }
6377
6378    #[doc = "Pmn Output Reset"]
6379    #[inline(always)]
6380    pub fn porr13(
6381        self,
6382    ) -> crate::common::RegisterField<
6383        13,
6384        0x1,
6385        1,
6386        0,
6387        porr::Porr13,
6388        porr::Porr13,
6389        Porr_SPEC,
6390        crate::common::W,
6391    > {
6392        crate::common::RegisterField::<
6393            13,
6394            0x1,
6395            1,
6396            0,
6397            porr::Porr13,
6398            porr::Porr13,
6399            Porr_SPEC,
6400            crate::common::W,
6401        >::from_register(self, 0)
6402    }
6403
6404    #[doc = "Pmn Output Reset"]
6405    #[inline(always)]
6406    pub fn porr14(
6407        self,
6408    ) -> crate::common::RegisterField<
6409        14,
6410        0x1,
6411        1,
6412        0,
6413        porr::Porr14,
6414        porr::Porr14,
6415        Porr_SPEC,
6416        crate::common::W,
6417    > {
6418        crate::common::RegisterField::<
6419            14,
6420            0x1,
6421            1,
6422            0,
6423            porr::Porr14,
6424            porr::Porr14,
6425            Porr_SPEC,
6426            crate::common::W,
6427        >::from_register(self, 0)
6428    }
6429
6430    #[doc = "Pmn Output Reset"]
6431    #[inline(always)]
6432    pub fn porr15(
6433        self,
6434    ) -> crate::common::RegisterField<
6435        15,
6436        0x1,
6437        1,
6438        0,
6439        porr::Porr15,
6440        porr::Porr15,
6441        Porr_SPEC,
6442        crate::common::W,
6443    > {
6444        crate::common::RegisterField::<
6445            15,
6446            0x1,
6447            1,
6448            0,
6449            porr::Porr15,
6450            porr::Porr15,
6451            Porr_SPEC,
6452            crate::common::W,
6453        >::from_register(self, 0)
6454    }
6455}
6456impl ::core::default::Default for Porr {
6457    #[inline(always)]
6458    fn default() -> Porr {
6459        <crate::RegValueT<Porr_SPEC> as RegisterValue<_>>::new(0)
6460    }
6461}
6462pub mod porr {
6463
6464    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6465    pub struct Porr00_SPEC;
6466    pub type Porr00 = crate::EnumBitfieldStruct<u8, Porr00_SPEC>;
6467    impl Porr00 {
6468        #[doc = "No effect on output"]
6469        pub const _0: Self = Self::new(0);
6470
6471        #[doc = "Low output"]
6472        pub const _1: Self = Self::new(1);
6473    }
6474    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6475    pub struct Porr01_SPEC;
6476    pub type Porr01 = crate::EnumBitfieldStruct<u8, Porr01_SPEC>;
6477    impl Porr01 {
6478        #[doc = "No effect on output"]
6479        pub const _0: Self = Self::new(0);
6480
6481        #[doc = "Low output"]
6482        pub const _1: Self = Self::new(1);
6483    }
6484    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6485    pub struct Porr02_SPEC;
6486    pub type Porr02 = crate::EnumBitfieldStruct<u8, Porr02_SPEC>;
6487    impl Porr02 {
6488        #[doc = "No effect on output"]
6489        pub const _0: Self = Self::new(0);
6490
6491        #[doc = "Low output"]
6492        pub const _1: Self = Self::new(1);
6493    }
6494    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6495    pub struct Porr03_SPEC;
6496    pub type Porr03 = crate::EnumBitfieldStruct<u8, Porr03_SPEC>;
6497    impl Porr03 {
6498        #[doc = "No effect on output"]
6499        pub const _0: Self = Self::new(0);
6500
6501        #[doc = "Low output"]
6502        pub const _1: Self = Self::new(1);
6503    }
6504    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6505    pub struct Porr04_SPEC;
6506    pub type Porr04 = crate::EnumBitfieldStruct<u8, Porr04_SPEC>;
6507    impl Porr04 {
6508        #[doc = "No effect on output"]
6509        pub const _0: Self = Self::new(0);
6510
6511        #[doc = "Low output"]
6512        pub const _1: Self = Self::new(1);
6513    }
6514    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6515    pub struct Porr05_SPEC;
6516    pub type Porr05 = crate::EnumBitfieldStruct<u8, Porr05_SPEC>;
6517    impl Porr05 {
6518        #[doc = "No effect on output"]
6519        pub const _0: Self = Self::new(0);
6520
6521        #[doc = "Low output"]
6522        pub const _1: Self = Self::new(1);
6523    }
6524    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6525    pub struct Porr06_SPEC;
6526    pub type Porr06 = crate::EnumBitfieldStruct<u8, Porr06_SPEC>;
6527    impl Porr06 {
6528        #[doc = "No effect on output"]
6529        pub const _0: Self = Self::new(0);
6530
6531        #[doc = "Low output"]
6532        pub const _1: Self = Self::new(1);
6533    }
6534    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6535    pub struct Porr07_SPEC;
6536    pub type Porr07 = crate::EnumBitfieldStruct<u8, Porr07_SPEC>;
6537    impl Porr07 {
6538        #[doc = "No effect on output"]
6539        pub const _0: Self = Self::new(0);
6540
6541        #[doc = "Low output"]
6542        pub const _1: Self = Self::new(1);
6543    }
6544    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6545    pub struct Porr08_SPEC;
6546    pub type Porr08 = crate::EnumBitfieldStruct<u8, Porr08_SPEC>;
6547    impl Porr08 {
6548        #[doc = "No effect on output"]
6549        pub const _0: Self = Self::new(0);
6550
6551        #[doc = "Low output"]
6552        pub const _1: Self = Self::new(1);
6553    }
6554    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6555    pub struct Porr09_SPEC;
6556    pub type Porr09 = crate::EnumBitfieldStruct<u8, Porr09_SPEC>;
6557    impl Porr09 {
6558        #[doc = "No effect on output"]
6559        pub const _0: Self = Self::new(0);
6560
6561        #[doc = "Low output"]
6562        pub const _1: Self = Self::new(1);
6563    }
6564    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6565    pub struct Porr10_SPEC;
6566    pub type Porr10 = crate::EnumBitfieldStruct<u8, Porr10_SPEC>;
6567    impl Porr10 {
6568        #[doc = "No effect on output"]
6569        pub const _0: Self = Self::new(0);
6570
6571        #[doc = "Low output"]
6572        pub const _1: Self = Self::new(1);
6573    }
6574    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6575    pub struct Porr11_SPEC;
6576    pub type Porr11 = crate::EnumBitfieldStruct<u8, Porr11_SPEC>;
6577    impl Porr11 {
6578        #[doc = "No effect on output"]
6579        pub const _0: Self = Self::new(0);
6580
6581        #[doc = "Low output"]
6582        pub const _1: Self = Self::new(1);
6583    }
6584    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6585    pub struct Porr12_SPEC;
6586    pub type Porr12 = crate::EnumBitfieldStruct<u8, Porr12_SPEC>;
6587    impl Porr12 {
6588        #[doc = "No effect on output"]
6589        pub const _0: Self = Self::new(0);
6590
6591        #[doc = "Low output"]
6592        pub const _1: Self = Self::new(1);
6593    }
6594    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6595    pub struct Porr13_SPEC;
6596    pub type Porr13 = crate::EnumBitfieldStruct<u8, Porr13_SPEC>;
6597    impl Porr13 {
6598        #[doc = "No effect on output"]
6599        pub const _0: Self = Self::new(0);
6600
6601        #[doc = "Low output"]
6602        pub const _1: Self = Self::new(1);
6603    }
6604    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6605    pub struct Porr14_SPEC;
6606    pub type Porr14 = crate::EnumBitfieldStruct<u8, Porr14_SPEC>;
6607    impl Porr14 {
6608        #[doc = "No effect on output"]
6609        pub const _0: Self = Self::new(0);
6610
6611        #[doc = "Low output"]
6612        pub const _1: Self = Self::new(1);
6613    }
6614    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6615    pub struct Porr15_SPEC;
6616    pub type Porr15 = crate::EnumBitfieldStruct<u8, Porr15_SPEC>;
6617    impl Porr15 {
6618        #[doc = "No effect on output"]
6619        pub const _0: Self = Self::new(0);
6620
6621        #[doc = "Low output"]
6622        pub const _1: Self = Self::new(1);
6623    }
6624}
6625#[doc(hidden)]
6626#[derive(Copy, Clone, Eq, PartialEq)]
6627pub struct Posr_SPEC;
6628impl crate::sealed::RegSpec for Posr_SPEC {
6629    type DataType = u16;
6630}
6631
6632#[doc = "Port Control Register 3"]
6633pub type Posr = crate::RegValueT<Posr_SPEC>;
6634
6635impl Posr {
6636    #[doc = "Pmn Output Set"]
6637    #[inline(always)]
6638    pub fn posr00(
6639        self,
6640    ) -> crate::common::RegisterField<
6641        0,
6642        0x1,
6643        1,
6644        0,
6645        posr::Posr00,
6646        posr::Posr00,
6647        Posr_SPEC,
6648        crate::common::W,
6649    > {
6650        crate::common::RegisterField::<
6651            0,
6652            0x1,
6653            1,
6654            0,
6655            posr::Posr00,
6656            posr::Posr00,
6657            Posr_SPEC,
6658            crate::common::W,
6659        >::from_register(self, 0)
6660    }
6661
6662    #[doc = "Pmn Output Set"]
6663    #[inline(always)]
6664    pub fn posr01(
6665        self,
6666    ) -> crate::common::RegisterField<
6667        1,
6668        0x1,
6669        1,
6670        0,
6671        posr::Posr01,
6672        posr::Posr01,
6673        Posr_SPEC,
6674        crate::common::W,
6675    > {
6676        crate::common::RegisterField::<
6677            1,
6678            0x1,
6679            1,
6680            0,
6681            posr::Posr01,
6682            posr::Posr01,
6683            Posr_SPEC,
6684            crate::common::W,
6685        >::from_register(self, 0)
6686    }
6687
6688    #[doc = "Pmn Output Set"]
6689    #[inline(always)]
6690    pub fn posr02(
6691        self,
6692    ) -> crate::common::RegisterField<
6693        2,
6694        0x1,
6695        1,
6696        0,
6697        posr::Posr02,
6698        posr::Posr02,
6699        Posr_SPEC,
6700        crate::common::W,
6701    > {
6702        crate::common::RegisterField::<
6703            2,
6704            0x1,
6705            1,
6706            0,
6707            posr::Posr02,
6708            posr::Posr02,
6709            Posr_SPEC,
6710            crate::common::W,
6711        >::from_register(self, 0)
6712    }
6713
6714    #[doc = "Pmn Output Set"]
6715    #[inline(always)]
6716    pub fn posr03(
6717        self,
6718    ) -> crate::common::RegisterField<
6719        3,
6720        0x1,
6721        1,
6722        0,
6723        posr::Posr03,
6724        posr::Posr03,
6725        Posr_SPEC,
6726        crate::common::W,
6727    > {
6728        crate::common::RegisterField::<
6729            3,
6730            0x1,
6731            1,
6732            0,
6733            posr::Posr03,
6734            posr::Posr03,
6735            Posr_SPEC,
6736            crate::common::W,
6737        >::from_register(self, 0)
6738    }
6739
6740    #[doc = "Pmn Output Set"]
6741    #[inline(always)]
6742    pub fn posr04(
6743        self,
6744    ) -> crate::common::RegisterField<
6745        4,
6746        0x1,
6747        1,
6748        0,
6749        posr::Posr04,
6750        posr::Posr04,
6751        Posr_SPEC,
6752        crate::common::W,
6753    > {
6754        crate::common::RegisterField::<
6755            4,
6756            0x1,
6757            1,
6758            0,
6759            posr::Posr04,
6760            posr::Posr04,
6761            Posr_SPEC,
6762            crate::common::W,
6763        >::from_register(self, 0)
6764    }
6765
6766    #[doc = "Pmn Output Set"]
6767    #[inline(always)]
6768    pub fn posr05(
6769        self,
6770    ) -> crate::common::RegisterField<
6771        5,
6772        0x1,
6773        1,
6774        0,
6775        posr::Posr05,
6776        posr::Posr05,
6777        Posr_SPEC,
6778        crate::common::W,
6779    > {
6780        crate::common::RegisterField::<
6781            5,
6782            0x1,
6783            1,
6784            0,
6785            posr::Posr05,
6786            posr::Posr05,
6787            Posr_SPEC,
6788            crate::common::W,
6789        >::from_register(self, 0)
6790    }
6791
6792    #[doc = "Pmn Output Set"]
6793    #[inline(always)]
6794    pub fn posr06(
6795        self,
6796    ) -> crate::common::RegisterField<
6797        6,
6798        0x1,
6799        1,
6800        0,
6801        posr::Posr06,
6802        posr::Posr06,
6803        Posr_SPEC,
6804        crate::common::W,
6805    > {
6806        crate::common::RegisterField::<
6807            6,
6808            0x1,
6809            1,
6810            0,
6811            posr::Posr06,
6812            posr::Posr06,
6813            Posr_SPEC,
6814            crate::common::W,
6815        >::from_register(self, 0)
6816    }
6817
6818    #[doc = "Pmn Output Set"]
6819    #[inline(always)]
6820    pub fn posr07(
6821        self,
6822    ) -> crate::common::RegisterField<
6823        7,
6824        0x1,
6825        1,
6826        0,
6827        posr::Posr07,
6828        posr::Posr07,
6829        Posr_SPEC,
6830        crate::common::W,
6831    > {
6832        crate::common::RegisterField::<
6833            7,
6834            0x1,
6835            1,
6836            0,
6837            posr::Posr07,
6838            posr::Posr07,
6839            Posr_SPEC,
6840            crate::common::W,
6841        >::from_register(self, 0)
6842    }
6843
6844    #[doc = "Pmn Output Set"]
6845    #[inline(always)]
6846    pub fn posr08(
6847        self,
6848    ) -> crate::common::RegisterField<
6849        8,
6850        0x1,
6851        1,
6852        0,
6853        posr::Posr08,
6854        posr::Posr08,
6855        Posr_SPEC,
6856        crate::common::W,
6857    > {
6858        crate::common::RegisterField::<
6859            8,
6860            0x1,
6861            1,
6862            0,
6863            posr::Posr08,
6864            posr::Posr08,
6865            Posr_SPEC,
6866            crate::common::W,
6867        >::from_register(self, 0)
6868    }
6869
6870    #[doc = "Pmn Output Set"]
6871    #[inline(always)]
6872    pub fn posr09(
6873        self,
6874    ) -> crate::common::RegisterField<
6875        9,
6876        0x1,
6877        1,
6878        0,
6879        posr::Posr09,
6880        posr::Posr09,
6881        Posr_SPEC,
6882        crate::common::W,
6883    > {
6884        crate::common::RegisterField::<
6885            9,
6886            0x1,
6887            1,
6888            0,
6889            posr::Posr09,
6890            posr::Posr09,
6891            Posr_SPEC,
6892            crate::common::W,
6893        >::from_register(self, 0)
6894    }
6895
6896    #[doc = "Pmn Output Set"]
6897    #[inline(always)]
6898    pub fn posr10(
6899        self,
6900    ) -> crate::common::RegisterField<
6901        10,
6902        0x1,
6903        1,
6904        0,
6905        posr::Posr10,
6906        posr::Posr10,
6907        Posr_SPEC,
6908        crate::common::W,
6909    > {
6910        crate::common::RegisterField::<
6911            10,
6912            0x1,
6913            1,
6914            0,
6915            posr::Posr10,
6916            posr::Posr10,
6917            Posr_SPEC,
6918            crate::common::W,
6919        >::from_register(self, 0)
6920    }
6921
6922    #[doc = "Pmn Output Set"]
6923    #[inline(always)]
6924    pub fn posr11(
6925        self,
6926    ) -> crate::common::RegisterField<
6927        11,
6928        0x1,
6929        1,
6930        0,
6931        posr::Posr11,
6932        posr::Posr11,
6933        Posr_SPEC,
6934        crate::common::W,
6935    > {
6936        crate::common::RegisterField::<
6937            11,
6938            0x1,
6939            1,
6940            0,
6941            posr::Posr11,
6942            posr::Posr11,
6943            Posr_SPEC,
6944            crate::common::W,
6945        >::from_register(self, 0)
6946    }
6947
6948    #[doc = "Pmn Output Set"]
6949    #[inline(always)]
6950    pub fn posr12(
6951        self,
6952    ) -> crate::common::RegisterField<
6953        12,
6954        0x1,
6955        1,
6956        0,
6957        posr::Posr12,
6958        posr::Posr12,
6959        Posr_SPEC,
6960        crate::common::W,
6961    > {
6962        crate::common::RegisterField::<
6963            12,
6964            0x1,
6965            1,
6966            0,
6967            posr::Posr12,
6968            posr::Posr12,
6969            Posr_SPEC,
6970            crate::common::W,
6971        >::from_register(self, 0)
6972    }
6973
6974    #[doc = "Pmn Output Set"]
6975    #[inline(always)]
6976    pub fn posr13(
6977        self,
6978    ) -> crate::common::RegisterField<
6979        13,
6980        0x1,
6981        1,
6982        0,
6983        posr::Posr13,
6984        posr::Posr13,
6985        Posr_SPEC,
6986        crate::common::W,
6987    > {
6988        crate::common::RegisterField::<
6989            13,
6990            0x1,
6991            1,
6992            0,
6993            posr::Posr13,
6994            posr::Posr13,
6995            Posr_SPEC,
6996            crate::common::W,
6997        >::from_register(self, 0)
6998    }
6999
7000    #[doc = "Pmn Output Set"]
7001    #[inline(always)]
7002    pub fn posr14(
7003        self,
7004    ) -> crate::common::RegisterField<
7005        14,
7006        0x1,
7007        1,
7008        0,
7009        posr::Posr14,
7010        posr::Posr14,
7011        Posr_SPEC,
7012        crate::common::W,
7013    > {
7014        crate::common::RegisterField::<
7015            14,
7016            0x1,
7017            1,
7018            0,
7019            posr::Posr14,
7020            posr::Posr14,
7021            Posr_SPEC,
7022            crate::common::W,
7023        >::from_register(self, 0)
7024    }
7025
7026    #[doc = "Pmn Output Set"]
7027    #[inline(always)]
7028    pub fn posr15(
7029        self,
7030    ) -> crate::common::RegisterField<
7031        15,
7032        0x1,
7033        1,
7034        0,
7035        posr::Posr15,
7036        posr::Posr15,
7037        Posr_SPEC,
7038        crate::common::W,
7039    > {
7040        crate::common::RegisterField::<
7041            15,
7042            0x1,
7043            1,
7044            0,
7045            posr::Posr15,
7046            posr::Posr15,
7047            Posr_SPEC,
7048            crate::common::W,
7049        >::from_register(self, 0)
7050    }
7051}
7052impl ::core::default::Default for Posr {
7053    #[inline(always)]
7054    fn default() -> Posr {
7055        <crate::RegValueT<Posr_SPEC> as RegisterValue<_>>::new(0)
7056    }
7057}
7058pub mod posr {
7059
7060    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7061    pub struct Posr00_SPEC;
7062    pub type Posr00 = crate::EnumBitfieldStruct<u8, Posr00_SPEC>;
7063    impl Posr00 {
7064        #[doc = "No effect on output"]
7065        pub const _0: Self = Self::new(0);
7066
7067        #[doc = "High output"]
7068        pub const _1: Self = Self::new(1);
7069    }
7070    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7071    pub struct Posr01_SPEC;
7072    pub type Posr01 = crate::EnumBitfieldStruct<u8, Posr01_SPEC>;
7073    impl Posr01 {
7074        #[doc = "No effect on output"]
7075        pub const _0: Self = Self::new(0);
7076
7077        #[doc = "High output"]
7078        pub const _1: Self = Self::new(1);
7079    }
7080    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7081    pub struct Posr02_SPEC;
7082    pub type Posr02 = crate::EnumBitfieldStruct<u8, Posr02_SPEC>;
7083    impl Posr02 {
7084        #[doc = "No effect on output"]
7085        pub const _0: Self = Self::new(0);
7086
7087        #[doc = "High output"]
7088        pub const _1: Self = Self::new(1);
7089    }
7090    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7091    pub struct Posr03_SPEC;
7092    pub type Posr03 = crate::EnumBitfieldStruct<u8, Posr03_SPEC>;
7093    impl Posr03 {
7094        #[doc = "No effect on output"]
7095        pub const _0: Self = Self::new(0);
7096
7097        #[doc = "High output"]
7098        pub const _1: Self = Self::new(1);
7099    }
7100    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7101    pub struct Posr04_SPEC;
7102    pub type Posr04 = crate::EnumBitfieldStruct<u8, Posr04_SPEC>;
7103    impl Posr04 {
7104        #[doc = "No effect on output"]
7105        pub const _0: Self = Self::new(0);
7106
7107        #[doc = "High output"]
7108        pub const _1: Self = Self::new(1);
7109    }
7110    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7111    pub struct Posr05_SPEC;
7112    pub type Posr05 = crate::EnumBitfieldStruct<u8, Posr05_SPEC>;
7113    impl Posr05 {
7114        #[doc = "No effect on output"]
7115        pub const _0: Self = Self::new(0);
7116
7117        #[doc = "High output"]
7118        pub const _1: Self = Self::new(1);
7119    }
7120    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7121    pub struct Posr06_SPEC;
7122    pub type Posr06 = crate::EnumBitfieldStruct<u8, Posr06_SPEC>;
7123    impl Posr06 {
7124        #[doc = "No effect on output"]
7125        pub const _0: Self = Self::new(0);
7126
7127        #[doc = "High output"]
7128        pub const _1: Self = Self::new(1);
7129    }
7130    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7131    pub struct Posr07_SPEC;
7132    pub type Posr07 = crate::EnumBitfieldStruct<u8, Posr07_SPEC>;
7133    impl Posr07 {
7134        #[doc = "No effect on output"]
7135        pub const _0: Self = Self::new(0);
7136
7137        #[doc = "High output"]
7138        pub const _1: Self = Self::new(1);
7139    }
7140    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7141    pub struct Posr08_SPEC;
7142    pub type Posr08 = crate::EnumBitfieldStruct<u8, Posr08_SPEC>;
7143    impl Posr08 {
7144        #[doc = "No effect on output"]
7145        pub const _0: Self = Self::new(0);
7146
7147        #[doc = "High output"]
7148        pub const _1: Self = Self::new(1);
7149    }
7150    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7151    pub struct Posr09_SPEC;
7152    pub type Posr09 = crate::EnumBitfieldStruct<u8, Posr09_SPEC>;
7153    impl Posr09 {
7154        #[doc = "No effect on output"]
7155        pub const _0: Self = Self::new(0);
7156
7157        #[doc = "High output"]
7158        pub const _1: Self = Self::new(1);
7159    }
7160    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7161    pub struct Posr10_SPEC;
7162    pub type Posr10 = crate::EnumBitfieldStruct<u8, Posr10_SPEC>;
7163    impl Posr10 {
7164        #[doc = "No effect on output"]
7165        pub const _0: Self = Self::new(0);
7166
7167        #[doc = "High output"]
7168        pub const _1: Self = Self::new(1);
7169    }
7170    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7171    pub struct Posr11_SPEC;
7172    pub type Posr11 = crate::EnumBitfieldStruct<u8, Posr11_SPEC>;
7173    impl Posr11 {
7174        #[doc = "No effect on output"]
7175        pub const _0: Self = Self::new(0);
7176
7177        #[doc = "High output"]
7178        pub const _1: Self = Self::new(1);
7179    }
7180    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7181    pub struct Posr12_SPEC;
7182    pub type Posr12 = crate::EnumBitfieldStruct<u8, Posr12_SPEC>;
7183    impl Posr12 {
7184        #[doc = "No effect on output"]
7185        pub const _0: Self = Self::new(0);
7186
7187        #[doc = "High output"]
7188        pub const _1: Self = Self::new(1);
7189    }
7190    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7191    pub struct Posr13_SPEC;
7192    pub type Posr13 = crate::EnumBitfieldStruct<u8, Posr13_SPEC>;
7193    impl Posr13 {
7194        #[doc = "No effect on output"]
7195        pub const _0: Self = Self::new(0);
7196
7197        #[doc = "High output"]
7198        pub const _1: Self = Self::new(1);
7199    }
7200    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7201    pub struct Posr14_SPEC;
7202    pub type Posr14 = crate::EnumBitfieldStruct<u8, Posr14_SPEC>;
7203    impl Posr14 {
7204        #[doc = "No effect on output"]
7205        pub const _0: Self = Self::new(0);
7206
7207        #[doc = "High output"]
7208        pub const _1: Self = Self::new(1);
7209    }
7210    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7211    pub struct Posr15_SPEC;
7212    pub type Posr15 = crate::EnumBitfieldStruct<u8, Posr15_SPEC>;
7213    impl Posr15 {
7214        #[doc = "No effect on output"]
7215        pub const _0: Self = Self::new(0);
7216
7217        #[doc = "High output"]
7218        pub const _1: Self = Self::new(1);
7219    }
7220}
ra2a2_pac/port0.rs

ra2a2_pac/
port0.rs
