xmc4200/port3/
pps.rs

1#[doc = "Register `PPS` reader"]
2pub type R = crate::R<PPS_SPEC>;
3#[doc = "Register `PPS` writer"]
4pub type W = crate::W<PPS_SPEC>;
5#[doc = "Port n Pin Power Save Bit 0\n\nValue on reset: 0"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7pub enum PPS0_A {
8    #[doc = "0: Pin Power Save of Pn.x is disabled."]
9    VALUE1 = 0,
10    #[doc = "1: Pin Power Save of Pn.x is enabled."]
11    VALUE2 = 1,
12}
13impl From<PPS0_A> for bool {
14    #[inline(always)]
15    fn from(variant: PPS0_A) -> Self {
16        variant as u8 != 0
17    }
18}
19#[doc = "Field `PPS0` reader - Port n Pin Power Save Bit 0"]
20pub type PPS0_R = crate::BitReader<PPS0_A>;
21impl PPS0_R {
22    #[doc = "Get enumerated values variant"]
23    #[inline(always)]
24    pub const fn variant(&self) -> PPS0_A {
25        match self.bits {
26            false => PPS0_A::VALUE1,
27            true => PPS0_A::VALUE2,
28        }
29    }
30    #[doc = "Pin Power Save of Pn.x is disabled."]
31    #[inline(always)]
32    pub fn is_value1(&self) -> bool {
33        *self == PPS0_A::VALUE1
34    }
35    #[doc = "Pin Power Save of Pn.x is enabled."]
36    #[inline(always)]
37    pub fn is_value2(&self) -> bool {
38        *self == PPS0_A::VALUE2
39    }
40}
41#[doc = "Field `PPS0` writer - Port n Pin Power Save Bit 0"]
42pub type PPS0_W<'a, REG> = crate::BitWriter<'a, REG, PPS0_A>;
43impl<'a, REG> PPS0_W<'a, REG>
44where
45    REG: crate::Writable + crate::RegisterSpec,
46{
47    #[doc = "Pin Power Save of Pn.x is disabled."]
48    #[inline(always)]
49    pub fn value1(self) -> &'a mut crate::W<REG> {
50        self.variant(PPS0_A::VALUE1)
51    }
52    #[doc = "Pin Power Save of Pn.x is enabled."]
53    #[inline(always)]
54    pub fn value2(self) -> &'a mut crate::W<REG> {
55        self.variant(PPS0_A::VALUE2)
56    }
57}
58#[doc = "Port n Pin Power Save Bit 1\n\nValue on reset: 0"]
59#[derive(Clone, Copy, Debug, PartialEq, Eq)]
60pub enum PPS1_A {
61    #[doc = "0: Pin Power Save of Pn.x is disabled."]
62    VALUE1 = 0,
63    #[doc = "1: Pin Power Save of Pn.x is enabled."]
64    VALUE2 = 1,
65}
66impl From<PPS1_A> for bool {
67    #[inline(always)]
68    fn from(variant: PPS1_A) -> Self {
69        variant as u8 != 0
70    }
71}
72#[doc = "Field `PPS1` reader - Port n Pin Power Save Bit 1"]
73pub type PPS1_R = crate::BitReader<PPS1_A>;
74impl PPS1_R {
75    #[doc = "Get enumerated values variant"]
76    #[inline(always)]
77    pub const fn variant(&self) -> PPS1_A {
78        match self.bits {
79            false => PPS1_A::VALUE1,
80            true => PPS1_A::VALUE2,
81        }
82    }
83    #[doc = "Pin Power Save of Pn.x is disabled."]
84    #[inline(always)]
85    pub fn is_value1(&self) -> bool {
86        *self == PPS1_A::VALUE1
87    }
88    #[doc = "Pin Power Save of Pn.x is enabled."]
89    #[inline(always)]
90    pub fn is_value2(&self) -> bool {
91        *self == PPS1_A::VALUE2
92    }
93}
94#[doc = "Field `PPS1` writer - Port n Pin Power Save Bit 1"]
95pub type PPS1_W<'a, REG> = crate::BitWriter<'a, REG, PPS1_A>;
96impl<'a, REG> PPS1_W<'a, REG>
97where
98    REG: crate::Writable + crate::RegisterSpec,
99{
100    #[doc = "Pin Power Save of Pn.x is disabled."]
101    #[inline(always)]
102    pub fn value1(self) -> &'a mut crate::W<REG> {
103        self.variant(PPS1_A::VALUE1)
104    }
105    #[doc = "Pin Power Save of Pn.x is enabled."]
106    #[inline(always)]
107    pub fn value2(self) -> &'a mut crate::W<REG> {
108        self.variant(PPS1_A::VALUE2)
109    }
110}
111#[doc = "Port n Pin Power Save Bit 2\n\nValue on reset: 0"]
112#[derive(Clone, Copy, Debug, PartialEq, Eq)]
113pub enum PPS2_A {
114    #[doc = "0: Pin Power Save of Pn.x is disabled."]
115    VALUE1 = 0,
116    #[doc = "1: Pin Power Save of Pn.x is enabled."]
117    VALUE2 = 1,
118}
119impl From<PPS2_A> for bool {
120    #[inline(always)]
121    fn from(variant: PPS2_A) -> Self {
122        variant as u8 != 0
123    }
124}
125#[doc = "Field `PPS2` reader - Port n Pin Power Save Bit 2"]
126pub type PPS2_R = crate::BitReader<PPS2_A>;
127impl PPS2_R {
128    #[doc = "Get enumerated values variant"]
129    #[inline(always)]
130    pub const fn variant(&self) -> PPS2_A {
131        match self.bits {
132            false => PPS2_A::VALUE1,
133            true => PPS2_A::VALUE2,
134        }
135    }
136    #[doc = "Pin Power Save of Pn.x is disabled."]
137    #[inline(always)]
138    pub fn is_value1(&self) -> bool {
139        *self == PPS2_A::VALUE1
140    }
141    #[doc = "Pin Power Save of Pn.x is enabled."]
142    #[inline(always)]
143    pub fn is_value2(&self) -> bool {
144        *self == PPS2_A::VALUE2
145    }
146}
147#[doc = "Field `PPS2` writer - Port n Pin Power Save Bit 2"]
148pub type PPS2_W<'a, REG> = crate::BitWriter<'a, REG, PPS2_A>;
149impl<'a, REG> PPS2_W<'a, REG>
150where
151    REG: crate::Writable + crate::RegisterSpec,
152{
153    #[doc = "Pin Power Save of Pn.x is disabled."]
154    #[inline(always)]
155    pub fn value1(self) -> &'a mut crate::W<REG> {
156        self.variant(PPS2_A::VALUE1)
157    }
158    #[doc = "Pin Power Save of Pn.x is enabled."]
159    #[inline(always)]
160    pub fn value2(self) -> &'a mut crate::W<REG> {
161        self.variant(PPS2_A::VALUE2)
162    }
163}
164#[doc = "Port n Pin Power Save Bit 3\n\nValue on reset: 0"]
165#[derive(Clone, Copy, Debug, PartialEq, Eq)]
166pub enum PPS3_A {
167    #[doc = "0: Pin Power Save of Pn.x is disabled."]
168    VALUE1 = 0,
169    #[doc = "1: Pin Power Save of Pn.x is enabled."]
170    VALUE2 = 1,
171}
172impl From<PPS3_A> for bool {
173    #[inline(always)]
174    fn from(variant: PPS3_A) -> Self {
175        variant as u8 != 0
176    }
177}
178#[doc = "Field `PPS3` reader - Port n Pin Power Save Bit 3"]
179pub type PPS3_R = crate::BitReader<PPS3_A>;
180impl PPS3_R {
181    #[doc = "Get enumerated values variant"]
182    #[inline(always)]
183    pub const fn variant(&self) -> PPS3_A {
184        match self.bits {
185            false => PPS3_A::VALUE1,
186            true => PPS3_A::VALUE2,
187        }
188    }
189    #[doc = "Pin Power Save of Pn.x is disabled."]
190    #[inline(always)]
191    pub fn is_value1(&self) -> bool {
192        *self == PPS3_A::VALUE1
193    }
194    #[doc = "Pin Power Save of Pn.x is enabled."]
195    #[inline(always)]
196    pub fn is_value2(&self) -> bool {
197        *self == PPS3_A::VALUE2
198    }
199}
200#[doc = "Field `PPS3` writer - Port n Pin Power Save Bit 3"]
201pub type PPS3_W<'a, REG> = crate::BitWriter<'a, REG, PPS3_A>;
202impl<'a, REG> PPS3_W<'a, REG>
203where
204    REG: crate::Writable + crate::RegisterSpec,
205{
206    #[doc = "Pin Power Save of Pn.x is disabled."]
207    #[inline(always)]
208    pub fn value1(self) -> &'a mut crate::W<REG> {
209        self.variant(PPS3_A::VALUE1)
210    }
211    #[doc = "Pin Power Save of Pn.x is enabled."]
212    #[inline(always)]
213    pub fn value2(self) -> &'a mut crate::W<REG> {
214        self.variant(PPS3_A::VALUE2)
215    }
216}
217#[doc = "Port n Pin Power Save Bit 4\n\nValue on reset: 0"]
218#[derive(Clone, Copy, Debug, PartialEq, Eq)]
219pub enum PPS4_A {
220    #[doc = "0: Pin Power Save of Pn.x is disabled."]
221    VALUE1 = 0,
222    #[doc = "1: Pin Power Save of Pn.x is enabled."]
223    VALUE2 = 1,
224}
225impl From<PPS4_A> for bool {
226    #[inline(always)]
227    fn from(variant: PPS4_A) -> Self {
228        variant as u8 != 0
229    }
230}
231#[doc = "Field `PPS4` reader - Port n Pin Power Save Bit 4"]
232pub type PPS4_R = crate::BitReader<PPS4_A>;
233impl PPS4_R {
234    #[doc = "Get enumerated values variant"]
235    #[inline(always)]
236    pub const fn variant(&self) -> PPS4_A {
237        match self.bits {
238            false => PPS4_A::VALUE1,
239            true => PPS4_A::VALUE2,
240        }
241    }
242    #[doc = "Pin Power Save of Pn.x is disabled."]
243    #[inline(always)]
244    pub fn is_value1(&self) -> bool {
245        *self == PPS4_A::VALUE1
246    }
247    #[doc = "Pin Power Save of Pn.x is enabled."]
248    #[inline(always)]
249    pub fn is_value2(&self) -> bool {
250        *self == PPS4_A::VALUE2
251    }
252}
253#[doc = "Field `PPS4` writer - Port n Pin Power Save Bit 4"]
254pub type PPS4_W<'a, REG> = crate::BitWriter<'a, REG, PPS4_A>;
255impl<'a, REG> PPS4_W<'a, REG>
256where
257    REG: crate::Writable + crate::RegisterSpec,
258{
259    #[doc = "Pin Power Save of Pn.x is disabled."]
260    #[inline(always)]
261    pub fn value1(self) -> &'a mut crate::W<REG> {
262        self.variant(PPS4_A::VALUE1)
263    }
264    #[doc = "Pin Power Save of Pn.x is enabled."]
265    #[inline(always)]
266    pub fn value2(self) -> &'a mut crate::W<REG> {
267        self.variant(PPS4_A::VALUE2)
268    }
269}
270#[doc = "Port n Pin Power Save Bit 5\n\nValue on reset: 0"]
271#[derive(Clone, Copy, Debug, PartialEq, Eq)]
272pub enum PPS5_A {
273    #[doc = "0: Pin Power Save of Pn.x is disabled."]
274    VALUE1 = 0,
275    #[doc = "1: Pin Power Save of Pn.x is enabled."]
276    VALUE2 = 1,
277}
278impl From<PPS5_A> for bool {
279    #[inline(always)]
280    fn from(variant: PPS5_A) -> Self {
281        variant as u8 != 0
282    }
283}
284#[doc = "Field `PPS5` reader - Port n Pin Power Save Bit 5"]
285pub type PPS5_R = crate::BitReader<PPS5_A>;
286impl PPS5_R {
287    #[doc = "Get enumerated values variant"]
288    #[inline(always)]
289    pub const fn variant(&self) -> PPS5_A {
290        match self.bits {
291            false => PPS5_A::VALUE1,
292            true => PPS5_A::VALUE2,
293        }
294    }
295    #[doc = "Pin Power Save of Pn.x is disabled."]
296    #[inline(always)]
297    pub fn is_value1(&self) -> bool {
298        *self == PPS5_A::VALUE1
299    }
300    #[doc = "Pin Power Save of Pn.x is enabled."]
301    #[inline(always)]
302    pub fn is_value2(&self) -> bool {
303        *self == PPS5_A::VALUE2
304    }
305}
306#[doc = "Field `PPS5` writer - Port n Pin Power Save Bit 5"]
307pub type PPS5_W<'a, REG> = crate::BitWriter<'a, REG, PPS5_A>;
308impl<'a, REG> PPS5_W<'a, REG>
309where
310    REG: crate::Writable + crate::RegisterSpec,
311{
312    #[doc = "Pin Power Save of Pn.x is disabled."]
313    #[inline(always)]
314    pub fn value1(self) -> &'a mut crate::W<REG> {
315        self.variant(PPS5_A::VALUE1)
316    }
317    #[doc = "Pin Power Save of Pn.x is enabled."]
318    #[inline(always)]
319    pub fn value2(self) -> &'a mut crate::W<REG> {
320        self.variant(PPS5_A::VALUE2)
321    }
322}
323#[doc = "Port n Pin Power Save Bit 6\n\nValue on reset: 0"]
324#[derive(Clone, Copy, Debug, PartialEq, Eq)]
325pub enum PPS6_A {
326    #[doc = "0: Pin Power Save of Pn.x is disabled."]
327    VALUE1 = 0,
328    #[doc = "1: Pin Power Save of Pn.x is enabled."]
329    VALUE2 = 1,
330}
331impl From<PPS6_A> for bool {
332    #[inline(always)]
333    fn from(variant: PPS6_A) -> Self {
334        variant as u8 != 0
335    }
336}
337#[doc = "Field `PPS6` reader - Port n Pin Power Save Bit 6"]
338pub type PPS6_R = crate::BitReader<PPS6_A>;
339impl PPS6_R {
340    #[doc = "Get enumerated values variant"]
341    #[inline(always)]
342    pub const fn variant(&self) -> PPS6_A {
343        match self.bits {
344            false => PPS6_A::VALUE1,
345            true => PPS6_A::VALUE2,
346        }
347    }
348    #[doc = "Pin Power Save of Pn.x is disabled."]
349    #[inline(always)]
350    pub fn is_value1(&self) -> bool {
351        *self == PPS6_A::VALUE1
352    }
353    #[doc = "Pin Power Save of Pn.x is enabled."]
354    #[inline(always)]
355    pub fn is_value2(&self) -> bool {
356        *self == PPS6_A::VALUE2
357    }
358}
359#[doc = "Field `PPS6` writer - Port n Pin Power Save Bit 6"]
360pub type PPS6_W<'a, REG> = crate::BitWriter<'a, REG, PPS6_A>;
361impl<'a, REG> PPS6_W<'a, REG>
362where
363    REG: crate::Writable + crate::RegisterSpec,
364{
365    #[doc = "Pin Power Save of Pn.x is disabled."]
366    #[inline(always)]
367    pub fn value1(self) -> &'a mut crate::W<REG> {
368        self.variant(PPS6_A::VALUE1)
369    }
370    #[doc = "Pin Power Save of Pn.x is enabled."]
371    #[inline(always)]
372    pub fn value2(self) -> &'a mut crate::W<REG> {
373        self.variant(PPS6_A::VALUE2)
374    }
375}
376#[doc = "Port n Pin Power Save Bit 7\n\nValue on reset: 0"]
377#[derive(Clone, Copy, Debug, PartialEq, Eq)]
378pub enum PPS7_A {
379    #[doc = "0: Pin Power Save of Pn.x is disabled."]
380    VALUE1 = 0,
381    #[doc = "1: Pin Power Save of Pn.x is enabled."]
382    VALUE2 = 1,
383}
384impl From<PPS7_A> for bool {
385    #[inline(always)]
386    fn from(variant: PPS7_A) -> Self {
387        variant as u8 != 0
388    }
389}
390#[doc = "Field `PPS7` reader - Port n Pin Power Save Bit 7"]
391pub type PPS7_R = crate::BitReader<PPS7_A>;
392impl PPS7_R {
393    #[doc = "Get enumerated values variant"]
394    #[inline(always)]
395    pub const fn variant(&self) -> PPS7_A {
396        match self.bits {
397            false => PPS7_A::VALUE1,
398            true => PPS7_A::VALUE2,
399        }
400    }
401    #[doc = "Pin Power Save of Pn.x is disabled."]
402    #[inline(always)]
403    pub fn is_value1(&self) -> bool {
404        *self == PPS7_A::VALUE1
405    }
406    #[doc = "Pin Power Save of Pn.x is enabled."]
407    #[inline(always)]
408    pub fn is_value2(&self) -> bool {
409        *self == PPS7_A::VALUE2
410    }
411}
412#[doc = "Field `PPS7` writer - Port n Pin Power Save Bit 7"]
413pub type PPS7_W<'a, REG> = crate::BitWriter<'a, REG, PPS7_A>;
414impl<'a, REG> PPS7_W<'a, REG>
415where
416    REG: crate::Writable + crate::RegisterSpec,
417{
418    #[doc = "Pin Power Save of Pn.x is disabled."]
419    #[inline(always)]
420    pub fn value1(self) -> &'a mut crate::W<REG> {
421        self.variant(PPS7_A::VALUE1)
422    }
423    #[doc = "Pin Power Save of Pn.x is enabled."]
424    #[inline(always)]
425    pub fn value2(self) -> &'a mut crate::W<REG> {
426        self.variant(PPS7_A::VALUE2)
427    }
428}
429#[doc = "Port n Pin Power Save Bit 8\n\nValue on reset: 0"]
430#[derive(Clone, Copy, Debug, PartialEq, Eq)]
431pub enum PPS8_A {
432    #[doc = "0: Pin Power Save of Pn.x is disabled."]
433    VALUE1 = 0,
434    #[doc = "1: Pin Power Save of Pn.x is enabled."]
435    VALUE2 = 1,
436}
437impl From<PPS8_A> for bool {
438    #[inline(always)]
439    fn from(variant: PPS8_A) -> Self {
440        variant as u8 != 0
441    }
442}
443#[doc = "Field `PPS8` reader - Port n Pin Power Save Bit 8"]
444pub type PPS8_R = crate::BitReader<PPS8_A>;
445impl PPS8_R {
446    #[doc = "Get enumerated values variant"]
447    #[inline(always)]
448    pub const fn variant(&self) -> PPS8_A {
449        match self.bits {
450            false => PPS8_A::VALUE1,
451            true => PPS8_A::VALUE2,
452        }
453    }
454    #[doc = "Pin Power Save of Pn.x is disabled."]
455    #[inline(always)]
456    pub fn is_value1(&self) -> bool {
457        *self == PPS8_A::VALUE1
458    }
459    #[doc = "Pin Power Save of Pn.x is enabled."]
460    #[inline(always)]
461    pub fn is_value2(&self) -> bool {
462        *self == PPS8_A::VALUE2
463    }
464}
465#[doc = "Field `PPS8` writer - Port n Pin Power Save Bit 8"]
466pub type PPS8_W<'a, REG> = crate::BitWriter<'a, REG, PPS8_A>;
467impl<'a, REG> PPS8_W<'a, REG>
468where
469    REG: crate::Writable + crate::RegisterSpec,
470{
471    #[doc = "Pin Power Save of Pn.x is disabled."]
472    #[inline(always)]
473    pub fn value1(self) -> &'a mut crate::W<REG> {
474        self.variant(PPS8_A::VALUE1)
475    }
476    #[doc = "Pin Power Save of Pn.x is enabled."]
477    #[inline(always)]
478    pub fn value2(self) -> &'a mut crate::W<REG> {
479        self.variant(PPS8_A::VALUE2)
480    }
481}
482#[doc = "Port n Pin Power Save Bit 9\n\nValue on reset: 0"]
483#[derive(Clone, Copy, Debug, PartialEq, Eq)]
484pub enum PPS9_A {
485    #[doc = "0: Pin Power Save of Pn.x is disabled."]
486    VALUE1 = 0,
487    #[doc = "1: Pin Power Save of Pn.x is enabled."]
488    VALUE2 = 1,
489}
490impl From<PPS9_A> for bool {
491    #[inline(always)]
492    fn from(variant: PPS9_A) -> Self {
493        variant as u8 != 0
494    }
495}
496#[doc = "Field `PPS9` reader - Port n Pin Power Save Bit 9"]
497pub type PPS9_R = crate::BitReader<PPS9_A>;
498impl PPS9_R {
499    #[doc = "Get enumerated values variant"]
500    #[inline(always)]
501    pub const fn variant(&self) -> PPS9_A {
502        match self.bits {
503            false => PPS9_A::VALUE1,
504            true => PPS9_A::VALUE2,
505        }
506    }
507    #[doc = "Pin Power Save of Pn.x is disabled."]
508    #[inline(always)]
509    pub fn is_value1(&self) -> bool {
510        *self == PPS9_A::VALUE1
511    }
512    #[doc = "Pin Power Save of Pn.x is enabled."]
513    #[inline(always)]
514    pub fn is_value2(&self) -> bool {
515        *self == PPS9_A::VALUE2
516    }
517}
518#[doc = "Field `PPS9` writer - Port n Pin Power Save Bit 9"]
519pub type PPS9_W<'a, REG> = crate::BitWriter<'a, REG, PPS9_A>;
520impl<'a, REG> PPS9_W<'a, REG>
521where
522    REG: crate::Writable + crate::RegisterSpec,
523{
524    #[doc = "Pin Power Save of Pn.x is disabled."]
525    #[inline(always)]
526    pub fn value1(self) -> &'a mut crate::W<REG> {
527        self.variant(PPS9_A::VALUE1)
528    }
529    #[doc = "Pin Power Save of Pn.x is enabled."]
530    #[inline(always)]
531    pub fn value2(self) -> &'a mut crate::W<REG> {
532        self.variant(PPS9_A::VALUE2)
533    }
534}
535#[doc = "Port n Pin Power Save Bit 10\n\nValue on reset: 0"]
536#[derive(Clone, Copy, Debug, PartialEq, Eq)]
537pub enum PPS10_A {
538    #[doc = "0: Pin Power Save of Pn.x is disabled."]
539    VALUE1 = 0,
540    #[doc = "1: Pin Power Save of Pn.x is enabled."]
541    VALUE2 = 1,
542}
543impl From<PPS10_A> for bool {
544    #[inline(always)]
545    fn from(variant: PPS10_A) -> Self {
546        variant as u8 != 0
547    }
548}
549#[doc = "Field `PPS10` reader - Port n Pin Power Save Bit 10"]
550pub type PPS10_R = crate::BitReader<PPS10_A>;
551impl PPS10_R {
552    #[doc = "Get enumerated values variant"]
553    #[inline(always)]
554    pub const fn variant(&self) -> PPS10_A {
555        match self.bits {
556            false => PPS10_A::VALUE1,
557            true => PPS10_A::VALUE2,
558        }
559    }
560    #[doc = "Pin Power Save of Pn.x is disabled."]
561    #[inline(always)]
562    pub fn is_value1(&self) -> bool {
563        *self == PPS10_A::VALUE1
564    }
565    #[doc = "Pin Power Save of Pn.x is enabled."]
566    #[inline(always)]
567    pub fn is_value2(&self) -> bool {
568        *self == PPS10_A::VALUE2
569    }
570}
571#[doc = "Field `PPS10` writer - Port n Pin Power Save Bit 10"]
572pub type PPS10_W<'a, REG> = crate::BitWriter<'a, REG, PPS10_A>;
573impl<'a, REG> PPS10_W<'a, REG>
574where
575    REG: crate::Writable + crate::RegisterSpec,
576{
577    #[doc = "Pin Power Save of Pn.x is disabled."]
578    #[inline(always)]
579    pub fn value1(self) -> &'a mut crate::W<REG> {
580        self.variant(PPS10_A::VALUE1)
581    }
582    #[doc = "Pin Power Save of Pn.x is enabled."]
583    #[inline(always)]
584    pub fn value2(self) -> &'a mut crate::W<REG> {
585        self.variant(PPS10_A::VALUE2)
586    }
587}
588#[doc = "Port n Pin Power Save Bit 11\n\nValue on reset: 0"]
589#[derive(Clone, Copy, Debug, PartialEq, Eq)]
590pub enum PPS11_A {
591    #[doc = "0: Pin Power Save of Pn.x is disabled."]
592    VALUE1 = 0,
593    #[doc = "1: Pin Power Save of Pn.x is enabled."]
594    VALUE2 = 1,
595}
596impl From<PPS11_A> for bool {
597    #[inline(always)]
598    fn from(variant: PPS11_A) -> Self {
599        variant as u8 != 0
600    }
601}
602#[doc = "Field `PPS11` reader - Port n Pin Power Save Bit 11"]
603pub type PPS11_R = crate::BitReader<PPS11_A>;
604impl PPS11_R {
605    #[doc = "Get enumerated values variant"]
606    #[inline(always)]
607    pub const fn variant(&self) -> PPS11_A {
608        match self.bits {
609            false => PPS11_A::VALUE1,
610            true => PPS11_A::VALUE2,
611        }
612    }
613    #[doc = "Pin Power Save of Pn.x is disabled."]
614    #[inline(always)]
615    pub fn is_value1(&self) -> bool {
616        *self == PPS11_A::VALUE1
617    }
618    #[doc = "Pin Power Save of Pn.x is enabled."]
619    #[inline(always)]
620    pub fn is_value2(&self) -> bool {
621        *self == PPS11_A::VALUE2
622    }
623}
624#[doc = "Field `PPS11` writer - Port n Pin Power Save Bit 11"]
625pub type PPS11_W<'a, REG> = crate::BitWriter<'a, REG, PPS11_A>;
626impl<'a, REG> PPS11_W<'a, REG>
627where
628    REG: crate::Writable + crate::RegisterSpec,
629{
630    #[doc = "Pin Power Save of Pn.x is disabled."]
631    #[inline(always)]
632    pub fn value1(self) -> &'a mut crate::W<REG> {
633        self.variant(PPS11_A::VALUE1)
634    }
635    #[doc = "Pin Power Save of Pn.x is enabled."]
636    #[inline(always)]
637    pub fn value2(self) -> &'a mut crate::W<REG> {
638        self.variant(PPS11_A::VALUE2)
639    }
640}
641#[doc = "Port n Pin Power Save Bit 12\n\nValue on reset: 0"]
642#[derive(Clone, Copy, Debug, PartialEq, Eq)]
643pub enum PPS12_A {
644    #[doc = "0: Pin Power Save of Pn.x is disabled."]
645    VALUE1 = 0,
646    #[doc = "1: Pin Power Save of Pn.x is enabled."]
647    VALUE2 = 1,
648}
649impl From<PPS12_A> for bool {
650    #[inline(always)]
651    fn from(variant: PPS12_A) -> Self {
652        variant as u8 != 0
653    }
654}
655#[doc = "Field `PPS12` reader - Port n Pin Power Save Bit 12"]
656pub type PPS12_R = crate::BitReader<PPS12_A>;
657impl PPS12_R {
658    #[doc = "Get enumerated values variant"]
659    #[inline(always)]
660    pub const fn variant(&self) -> PPS12_A {
661        match self.bits {
662            false => PPS12_A::VALUE1,
663            true => PPS12_A::VALUE2,
664        }
665    }
666    #[doc = "Pin Power Save of Pn.x is disabled."]
667    #[inline(always)]
668    pub fn is_value1(&self) -> bool {
669        *self == PPS12_A::VALUE1
670    }
671    #[doc = "Pin Power Save of Pn.x is enabled."]
672    #[inline(always)]
673    pub fn is_value2(&self) -> bool {
674        *self == PPS12_A::VALUE2
675    }
676}
677#[doc = "Field `PPS12` writer - Port n Pin Power Save Bit 12"]
678pub type PPS12_W<'a, REG> = crate::BitWriter<'a, REG, PPS12_A>;
679impl<'a, REG> PPS12_W<'a, REG>
680where
681    REG: crate::Writable + crate::RegisterSpec,
682{
683    #[doc = "Pin Power Save of Pn.x is disabled."]
684    #[inline(always)]
685    pub fn value1(self) -> &'a mut crate::W<REG> {
686        self.variant(PPS12_A::VALUE1)
687    }
688    #[doc = "Pin Power Save of Pn.x is enabled."]
689    #[inline(always)]
690    pub fn value2(self) -> &'a mut crate::W<REG> {
691        self.variant(PPS12_A::VALUE2)
692    }
693}
694#[doc = "Port n Pin Power Save Bit 13\n\nValue on reset: 0"]
695#[derive(Clone, Copy, Debug, PartialEq, Eq)]
696pub enum PPS13_A {
697    #[doc = "0: Pin Power Save of Pn.x is disabled."]
698    VALUE1 = 0,
699    #[doc = "1: Pin Power Save of Pn.x is enabled."]
700    VALUE2 = 1,
701}
702impl From<PPS13_A> for bool {
703    #[inline(always)]
704    fn from(variant: PPS13_A) -> Self {
705        variant as u8 != 0
706    }
707}
708#[doc = "Field `PPS13` reader - Port n Pin Power Save Bit 13"]
709pub type PPS13_R = crate::BitReader<PPS13_A>;
710impl PPS13_R {
711    #[doc = "Get enumerated values variant"]
712    #[inline(always)]
713    pub const fn variant(&self) -> PPS13_A {
714        match self.bits {
715            false => PPS13_A::VALUE1,
716            true => PPS13_A::VALUE2,
717        }
718    }
719    #[doc = "Pin Power Save of Pn.x is disabled."]
720    #[inline(always)]
721    pub fn is_value1(&self) -> bool {
722        *self == PPS13_A::VALUE1
723    }
724    #[doc = "Pin Power Save of Pn.x is enabled."]
725    #[inline(always)]
726    pub fn is_value2(&self) -> bool {
727        *self == PPS13_A::VALUE2
728    }
729}
730#[doc = "Field `PPS13` writer - Port n Pin Power Save Bit 13"]
731pub type PPS13_W<'a, REG> = crate::BitWriter<'a, REG, PPS13_A>;
732impl<'a, REG> PPS13_W<'a, REG>
733where
734    REG: crate::Writable + crate::RegisterSpec,
735{
736    #[doc = "Pin Power Save of Pn.x is disabled."]
737    #[inline(always)]
738    pub fn value1(self) -> &'a mut crate::W<REG> {
739        self.variant(PPS13_A::VALUE1)
740    }
741    #[doc = "Pin Power Save of Pn.x is enabled."]
742    #[inline(always)]
743    pub fn value2(self) -> &'a mut crate::W<REG> {
744        self.variant(PPS13_A::VALUE2)
745    }
746}
747#[doc = "Port n Pin Power Save Bit 14\n\nValue on reset: 0"]
748#[derive(Clone, Copy, Debug, PartialEq, Eq)]
749pub enum PPS14_A {
750    #[doc = "0: Pin Power Save of Pn.x is disabled."]
751    VALUE1 = 0,
752    #[doc = "1: Pin Power Save of Pn.x is enabled."]
753    VALUE2 = 1,
754}
755impl From<PPS14_A> for bool {
756    #[inline(always)]
757    fn from(variant: PPS14_A) -> Self {
758        variant as u8 != 0
759    }
760}
761#[doc = "Field `PPS14` reader - Port n Pin Power Save Bit 14"]
762pub type PPS14_R = crate::BitReader<PPS14_A>;
763impl PPS14_R {
764    #[doc = "Get enumerated values variant"]
765    #[inline(always)]
766    pub const fn variant(&self) -> PPS14_A {
767        match self.bits {
768            false => PPS14_A::VALUE1,
769            true => PPS14_A::VALUE2,
770        }
771    }
772    #[doc = "Pin Power Save of Pn.x is disabled."]
773    #[inline(always)]
774    pub fn is_value1(&self) -> bool {
775        *self == PPS14_A::VALUE1
776    }
777    #[doc = "Pin Power Save of Pn.x is enabled."]
778    #[inline(always)]
779    pub fn is_value2(&self) -> bool {
780        *self == PPS14_A::VALUE2
781    }
782}
783#[doc = "Field `PPS14` writer - Port n Pin Power Save Bit 14"]
784pub type PPS14_W<'a, REG> = crate::BitWriter<'a, REG, PPS14_A>;
785impl<'a, REG> PPS14_W<'a, REG>
786where
787    REG: crate::Writable + crate::RegisterSpec,
788{
789    #[doc = "Pin Power Save of Pn.x is disabled."]
790    #[inline(always)]
791    pub fn value1(self) -> &'a mut crate::W<REG> {
792        self.variant(PPS14_A::VALUE1)
793    }
794    #[doc = "Pin Power Save of Pn.x is enabled."]
795    #[inline(always)]
796    pub fn value2(self) -> &'a mut crate::W<REG> {
797        self.variant(PPS14_A::VALUE2)
798    }
799}
800#[doc = "Port n Pin Power Save Bit 15\n\nValue on reset: 0"]
801#[derive(Clone, Copy, Debug, PartialEq, Eq)]
802pub enum PPS15_A {
803    #[doc = "0: Pin Power Save of Pn.x is disabled."]
804    VALUE1 = 0,
805    #[doc = "1: Pin Power Save of Pn.x is enabled."]
806    VALUE2 = 1,
807}
808impl From<PPS15_A> for bool {
809    #[inline(always)]
810    fn from(variant: PPS15_A) -> Self {
811        variant as u8 != 0
812    }
813}
814#[doc = "Field `PPS15` reader - Port n Pin Power Save Bit 15"]
815pub type PPS15_R = crate::BitReader<PPS15_A>;
816impl PPS15_R {
817    #[doc = "Get enumerated values variant"]
818    #[inline(always)]
819    pub const fn variant(&self) -> PPS15_A {
820        match self.bits {
821            false => PPS15_A::VALUE1,
822            true => PPS15_A::VALUE2,
823        }
824    }
825    #[doc = "Pin Power Save of Pn.x is disabled."]
826    #[inline(always)]
827    pub fn is_value1(&self) -> bool {
828        *self == PPS15_A::VALUE1
829    }
830    #[doc = "Pin Power Save of Pn.x is enabled."]
831    #[inline(always)]
832    pub fn is_value2(&self) -> bool {
833        *self == PPS15_A::VALUE2
834    }
835}
836#[doc = "Field `PPS15` writer - Port n Pin Power Save Bit 15"]
837pub type PPS15_W<'a, REG> = crate::BitWriter<'a, REG, PPS15_A>;
838impl<'a, REG> PPS15_W<'a, REG>
839where
840    REG: crate::Writable + crate::RegisterSpec,
841{
842    #[doc = "Pin Power Save of Pn.x is disabled."]
843    #[inline(always)]
844    pub fn value1(self) -> &'a mut crate::W<REG> {
845        self.variant(PPS15_A::VALUE1)
846    }
847    #[doc = "Pin Power Save of Pn.x is enabled."]
848    #[inline(always)]
849    pub fn value2(self) -> &'a mut crate::W<REG> {
850        self.variant(PPS15_A::VALUE2)
851    }
852}
853impl R {
854    #[doc = "Bit 0 - Port n Pin Power Save Bit 0"]
855    #[inline(always)]
856    pub fn pps0(&self) -> PPS0_R {
857        PPS0_R::new((self.bits & 1) != 0)
858    }
859    #[doc = "Bit 1 - Port n Pin Power Save Bit 1"]
860    #[inline(always)]
861    pub fn pps1(&self) -> PPS1_R {
862        PPS1_R::new(((self.bits >> 1) & 1) != 0)
863    }
864    #[doc = "Bit 2 - Port n Pin Power Save Bit 2"]
865    #[inline(always)]
866    pub fn pps2(&self) -> PPS2_R {
867        PPS2_R::new(((self.bits >> 2) & 1) != 0)
868    }
869    #[doc = "Bit 3 - Port n Pin Power Save Bit 3"]
870    #[inline(always)]
871    pub fn pps3(&self) -> PPS3_R {
872        PPS3_R::new(((self.bits >> 3) & 1) != 0)
873    }
874    #[doc = "Bit 4 - Port n Pin Power Save Bit 4"]
875    #[inline(always)]
876    pub fn pps4(&self) -> PPS4_R {
877        PPS4_R::new(((self.bits >> 4) & 1) != 0)
878    }
879    #[doc = "Bit 5 - Port n Pin Power Save Bit 5"]
880    #[inline(always)]
881    pub fn pps5(&self) -> PPS5_R {
882        PPS5_R::new(((self.bits >> 5) & 1) != 0)
883    }
884    #[doc = "Bit 6 - Port n Pin Power Save Bit 6"]
885    #[inline(always)]
886    pub fn pps6(&self) -> PPS6_R {
887        PPS6_R::new(((self.bits >> 6) & 1) != 0)
888    }
889    #[doc = "Bit 7 - Port n Pin Power Save Bit 7"]
890    #[inline(always)]
891    pub fn pps7(&self) -> PPS7_R {
892        PPS7_R::new(((self.bits >> 7) & 1) != 0)
893    }
894    #[doc = "Bit 8 - Port n Pin Power Save Bit 8"]
895    #[inline(always)]
896    pub fn pps8(&self) -> PPS8_R {
897        PPS8_R::new(((self.bits >> 8) & 1) != 0)
898    }
899    #[doc = "Bit 9 - Port n Pin Power Save Bit 9"]
900    #[inline(always)]
901    pub fn pps9(&self) -> PPS9_R {
902        PPS9_R::new(((self.bits >> 9) & 1) != 0)
903    }
904    #[doc = "Bit 10 - Port n Pin Power Save Bit 10"]
905    #[inline(always)]
906    pub fn pps10(&self) -> PPS10_R {
907        PPS10_R::new(((self.bits >> 10) & 1) != 0)
908    }
909    #[doc = "Bit 11 - Port n Pin Power Save Bit 11"]
910    #[inline(always)]
911    pub fn pps11(&self) -> PPS11_R {
912        PPS11_R::new(((self.bits >> 11) & 1) != 0)
913    }
914    #[doc = "Bit 12 - Port n Pin Power Save Bit 12"]
915    #[inline(always)]
916    pub fn pps12(&self) -> PPS12_R {
917        PPS12_R::new(((self.bits >> 12) & 1) != 0)
918    }
919    #[doc = "Bit 13 - Port n Pin Power Save Bit 13"]
920    #[inline(always)]
921    pub fn pps13(&self) -> PPS13_R {
922        PPS13_R::new(((self.bits >> 13) & 1) != 0)
923    }
924    #[doc = "Bit 14 - Port n Pin Power Save Bit 14"]
925    #[inline(always)]
926    pub fn pps14(&self) -> PPS14_R {
927        PPS14_R::new(((self.bits >> 14) & 1) != 0)
928    }
929    #[doc = "Bit 15 - Port n Pin Power Save Bit 15"]
930    #[inline(always)]
931    pub fn pps15(&self) -> PPS15_R {
932        PPS15_R::new(((self.bits >> 15) & 1) != 0)
933    }
934}
935impl W {
936    #[doc = "Bit 0 - Port n Pin Power Save Bit 0"]
937    #[inline(always)]
938    pub fn pps0(&mut self) -> PPS0_W<PPS_SPEC> {
939        PPS0_W::new(self, 0)
940    }
941    #[doc = "Bit 1 - Port n Pin Power Save Bit 1"]
942    #[inline(always)]
943    pub fn pps1(&mut self) -> PPS1_W<PPS_SPEC> {
944        PPS1_W::new(self, 1)
945    }
946    #[doc = "Bit 2 - Port n Pin Power Save Bit 2"]
947    #[inline(always)]
948    pub fn pps2(&mut self) -> PPS2_W<PPS_SPEC> {
949        PPS2_W::new(self, 2)
950    }
951    #[doc = "Bit 3 - Port n Pin Power Save Bit 3"]
952    #[inline(always)]
953    pub fn pps3(&mut self) -> PPS3_W<PPS_SPEC> {
954        PPS3_W::new(self, 3)
955    }
956    #[doc = "Bit 4 - Port n Pin Power Save Bit 4"]
957    #[inline(always)]
958    pub fn pps4(&mut self) -> PPS4_W<PPS_SPEC> {
959        PPS4_W::new(self, 4)
960    }
961    #[doc = "Bit 5 - Port n Pin Power Save Bit 5"]
962    #[inline(always)]
963    pub fn pps5(&mut self) -> PPS5_W<PPS_SPEC> {
964        PPS5_W::new(self, 5)
965    }
966    #[doc = "Bit 6 - Port n Pin Power Save Bit 6"]
967    #[inline(always)]
968    pub fn pps6(&mut self) -> PPS6_W<PPS_SPEC> {
969        PPS6_W::new(self, 6)
970    }
971    #[doc = "Bit 7 - Port n Pin Power Save Bit 7"]
972    #[inline(always)]
973    pub fn pps7(&mut self) -> PPS7_W<PPS_SPEC> {
974        PPS7_W::new(self, 7)
975    }
976    #[doc = "Bit 8 - Port n Pin Power Save Bit 8"]
977    #[inline(always)]
978    pub fn pps8(&mut self) -> PPS8_W<PPS_SPEC> {
979        PPS8_W::new(self, 8)
980    }
981    #[doc = "Bit 9 - Port n Pin Power Save Bit 9"]
982    #[inline(always)]
983    pub fn pps9(&mut self) -> PPS9_W<PPS_SPEC> {
984        PPS9_W::new(self, 9)
985    }
986    #[doc = "Bit 10 - Port n Pin Power Save Bit 10"]
987    #[inline(always)]
988    pub fn pps10(&mut self) -> PPS10_W<PPS_SPEC> {
989        PPS10_W::new(self, 10)
990    }
991    #[doc = "Bit 11 - Port n Pin Power Save Bit 11"]
992    #[inline(always)]
993    pub fn pps11(&mut self) -> PPS11_W<PPS_SPEC> {
994        PPS11_W::new(self, 11)
995    }
996    #[doc = "Bit 12 - Port n Pin Power Save Bit 12"]
997    #[inline(always)]
998    pub fn pps12(&mut self) -> PPS12_W<PPS_SPEC> {
999        PPS12_W::new(self, 12)
1000    }
1001    #[doc = "Bit 13 - Port n Pin Power Save Bit 13"]
1002    #[inline(always)]
1003    pub fn pps13(&mut self) -> PPS13_W<PPS_SPEC> {
1004        PPS13_W::new(self, 13)
1005    }
1006    #[doc = "Bit 14 - Port n Pin Power Save Bit 14"]
1007    #[inline(always)]
1008    pub fn pps14(&mut self) -> PPS14_W<PPS_SPEC> {
1009        PPS14_W::new(self, 14)
1010    }
1011    #[doc = "Bit 15 - Port n Pin Power Save Bit 15"]
1012    #[inline(always)]
1013    pub fn pps15(&mut self) -> PPS15_W<PPS_SPEC> {
1014        PPS15_W::new(self, 15)
1015    }
1016}
1017#[doc = "Port 3 Pin Power Save Register\n\nYou can [`read`](crate::Reg::read) this register and get [`pps::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pps::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1018pub struct PPS_SPEC;
1019impl crate::RegisterSpec for PPS_SPEC {
1020    type Ux = u32;
1021}
1022#[doc = "`read()` method returns [`pps::R`](R) reader structure"]
1023impl crate::Readable for PPS_SPEC {}
1024#[doc = "`write(|w| ..)` method takes [`pps::W`](W) writer structure"]
1025impl crate::Writable for PPS_SPEC {
1026    type Safety = crate::Unsafe;
1027    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1028    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
1029}
1030#[doc = "`reset()` method sets PPS to value 0"]
1031impl crate::Resettable for PPS_SPEC {
1032    const RESET_VALUE: u32 = 0;
1033}
xmc4200/port3/pps.rs

xmc4200/port3/
pps.rs
