1#[doc = "Register `PPR` reader"]
2pub type R = crate::R<PprSpec>;
3#[doc = "Register `PPR` writer"]
4pub type W = crate::W<PprSpec>;
5#[doc = "Tamper Pin n Polarity\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Tpp0 {
9 #[doc = "0: Not inverted"]
10 NoInvert = 0,
11 #[doc = "1: Inverted"]
12 Invert = 1,
13}
14impl From<Tpp0> for bool {
15 #[inline(always)]
16 fn from(variant: Tpp0) -> Self {
17 variant as u8 != 0
18 }
19}
20#[doc = "Field `TPP0` reader - Tamper Pin n Polarity"]
21pub type Tpp0R = crate::BitReader<Tpp0>;
22impl Tpp0R {
23 #[doc = "Get enumerated values variant"]
24 #[inline(always)]
25 pub const fn variant(&self) -> Tpp0 {
26 match self.bits {
27 false => Tpp0::NoInvert,
28 true => Tpp0::Invert,
29 }
30 }
31 #[doc = "Not inverted"]
32 #[inline(always)]
33 pub fn is_no_invert(&self) -> bool {
34 *self == Tpp0::NoInvert
35 }
36 #[doc = "Inverted"]
37 #[inline(always)]
38 pub fn is_invert(&self) -> bool {
39 *self == Tpp0::Invert
40 }
41}
42#[doc = "Field `TPP0` writer - Tamper Pin n Polarity"]
43pub type Tpp0W<'a, REG> = crate::BitWriter<'a, REG, Tpp0>;
44impl<'a, REG> Tpp0W<'a, REG>
45where
46 REG: crate::Writable + crate::RegisterSpec,
47{
48 #[doc = "Not inverted"]
49 #[inline(always)]
50 pub fn no_invert(self) -> &'a mut crate::W<REG> {
51 self.variant(Tpp0::NoInvert)
52 }
53 #[doc = "Inverted"]
54 #[inline(always)]
55 pub fn invert(self) -> &'a mut crate::W<REG> {
56 self.variant(Tpp0::Invert)
57 }
58}
59#[doc = "Tamper Pin n Polarity\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Tpp1 {
63 #[doc = "0: Not inverted"]
64 NoInvert = 0,
65 #[doc = "1: Inverted"]
66 Invert = 1,
67}
68impl From<Tpp1> for bool {
69 #[inline(always)]
70 fn from(variant: Tpp1) -> Self {
71 variant as u8 != 0
72 }
73}
74#[doc = "Field `TPP1` reader - Tamper Pin n Polarity"]
75pub type Tpp1R = crate::BitReader<Tpp1>;
76impl Tpp1R {
77 #[doc = "Get enumerated values variant"]
78 #[inline(always)]
79 pub const fn variant(&self) -> Tpp1 {
80 match self.bits {
81 false => Tpp1::NoInvert,
82 true => Tpp1::Invert,
83 }
84 }
85 #[doc = "Not inverted"]
86 #[inline(always)]
87 pub fn is_no_invert(&self) -> bool {
88 *self == Tpp1::NoInvert
89 }
90 #[doc = "Inverted"]
91 #[inline(always)]
92 pub fn is_invert(&self) -> bool {
93 *self == Tpp1::Invert
94 }
95}
96#[doc = "Field `TPP1` writer - Tamper Pin n Polarity"]
97pub type Tpp1W<'a, REG> = crate::BitWriter<'a, REG, Tpp1>;
98impl<'a, REG> Tpp1W<'a, REG>
99where
100 REG: crate::Writable + crate::RegisterSpec,
101{
102 #[doc = "Not inverted"]
103 #[inline(always)]
104 pub fn no_invert(self) -> &'a mut crate::W<REG> {
105 self.variant(Tpp1::NoInvert)
106 }
107 #[doc = "Inverted"]
108 #[inline(always)]
109 pub fn invert(self) -> &'a mut crate::W<REG> {
110 self.variant(Tpp1::Invert)
111 }
112}
113#[doc = "Tamper Pin n Polarity\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Tpp2 {
117 #[doc = "0: Not inverted"]
118 NoInvert = 0,
119 #[doc = "1: Inverted"]
120 Invert = 1,
121}
122impl From<Tpp2> for bool {
123 #[inline(always)]
124 fn from(variant: Tpp2) -> Self {
125 variant as u8 != 0
126 }
127}
128#[doc = "Field `TPP2` reader - Tamper Pin n Polarity"]
129pub type Tpp2R = crate::BitReader<Tpp2>;
130impl Tpp2R {
131 #[doc = "Get enumerated values variant"]
132 #[inline(always)]
133 pub const fn variant(&self) -> Tpp2 {
134 match self.bits {
135 false => Tpp2::NoInvert,
136 true => Tpp2::Invert,
137 }
138 }
139 #[doc = "Not inverted"]
140 #[inline(always)]
141 pub fn is_no_invert(&self) -> bool {
142 *self == Tpp2::NoInvert
143 }
144 #[doc = "Inverted"]
145 #[inline(always)]
146 pub fn is_invert(&self) -> bool {
147 *self == Tpp2::Invert
148 }
149}
150#[doc = "Field `TPP2` writer - Tamper Pin n Polarity"]
151pub type Tpp2W<'a, REG> = crate::BitWriter<'a, REG, Tpp2>;
152impl<'a, REG> Tpp2W<'a, REG>
153where
154 REG: crate::Writable + crate::RegisterSpec,
155{
156 #[doc = "Not inverted"]
157 #[inline(always)]
158 pub fn no_invert(self) -> &'a mut crate::W<REG> {
159 self.variant(Tpp2::NoInvert)
160 }
161 #[doc = "Inverted"]
162 #[inline(always)]
163 pub fn invert(self) -> &'a mut crate::W<REG> {
164 self.variant(Tpp2::Invert)
165 }
166}
167#[doc = "Tamper Pin n Polarity\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Tpp3 {
171 #[doc = "0: Not inverted"]
172 NoInvert = 0,
173 #[doc = "1: Inverted"]
174 Invert = 1,
175}
176impl From<Tpp3> for bool {
177 #[inline(always)]
178 fn from(variant: Tpp3) -> Self {
179 variant as u8 != 0
180 }
181}
182#[doc = "Field `TPP3` reader - Tamper Pin n Polarity"]
183pub type Tpp3R = crate::BitReader<Tpp3>;
184impl Tpp3R {
185 #[doc = "Get enumerated values variant"]
186 #[inline(always)]
187 pub const fn variant(&self) -> Tpp3 {
188 match self.bits {
189 false => Tpp3::NoInvert,
190 true => Tpp3::Invert,
191 }
192 }
193 #[doc = "Not inverted"]
194 #[inline(always)]
195 pub fn is_no_invert(&self) -> bool {
196 *self == Tpp3::NoInvert
197 }
198 #[doc = "Inverted"]
199 #[inline(always)]
200 pub fn is_invert(&self) -> bool {
201 *self == Tpp3::Invert
202 }
203}
204#[doc = "Field `TPP3` writer - Tamper Pin n Polarity"]
205pub type Tpp3W<'a, REG> = crate::BitWriter<'a, REG, Tpp3>;
206impl<'a, REG> Tpp3W<'a, REG>
207where
208 REG: crate::Writable + crate::RegisterSpec,
209{
210 #[doc = "Not inverted"]
211 #[inline(always)]
212 pub fn no_invert(self) -> &'a mut crate::W<REG> {
213 self.variant(Tpp3::NoInvert)
214 }
215 #[doc = "Inverted"]
216 #[inline(always)]
217 pub fn invert(self) -> &'a mut crate::W<REG> {
218 self.variant(Tpp3::Invert)
219 }
220}
221#[doc = "Tamper Pin n Polarity\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Tpp4 {
225 #[doc = "0: Not inverted"]
226 NoInvert = 0,
227 #[doc = "1: Inverted"]
228 Invert = 1,
229}
230impl From<Tpp4> for bool {
231 #[inline(always)]
232 fn from(variant: Tpp4) -> Self {
233 variant as u8 != 0
234 }
235}
236#[doc = "Field `TPP4` reader - Tamper Pin n Polarity"]
237pub type Tpp4R = crate::BitReader<Tpp4>;
238impl Tpp4R {
239 #[doc = "Get enumerated values variant"]
240 #[inline(always)]
241 pub const fn variant(&self) -> Tpp4 {
242 match self.bits {
243 false => Tpp4::NoInvert,
244 true => Tpp4::Invert,
245 }
246 }
247 #[doc = "Not inverted"]
248 #[inline(always)]
249 pub fn is_no_invert(&self) -> bool {
250 *self == Tpp4::NoInvert
251 }
252 #[doc = "Inverted"]
253 #[inline(always)]
254 pub fn is_invert(&self) -> bool {
255 *self == Tpp4::Invert
256 }
257}
258#[doc = "Field `TPP4` writer - Tamper Pin n Polarity"]
259pub type Tpp4W<'a, REG> = crate::BitWriter<'a, REG, Tpp4>;
260impl<'a, REG> Tpp4W<'a, REG>
261where
262 REG: crate::Writable + crate::RegisterSpec,
263{
264 #[doc = "Not inverted"]
265 #[inline(always)]
266 pub fn no_invert(self) -> &'a mut crate::W<REG> {
267 self.variant(Tpp4::NoInvert)
268 }
269 #[doc = "Inverted"]
270 #[inline(always)]
271 pub fn invert(self) -> &'a mut crate::W<REG> {
272 self.variant(Tpp4::Invert)
273 }
274}
275#[doc = "Tamper Pin n Polarity\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Tpp5 {
279 #[doc = "0: Not inverted"]
280 NoInvert = 0,
281 #[doc = "1: Inverted"]
282 Invert = 1,
283}
284impl From<Tpp5> for bool {
285 #[inline(always)]
286 fn from(variant: Tpp5) -> Self {
287 variant as u8 != 0
288 }
289}
290#[doc = "Field `TPP5` reader - Tamper Pin n Polarity"]
291pub type Tpp5R = crate::BitReader<Tpp5>;
292impl Tpp5R {
293 #[doc = "Get enumerated values variant"]
294 #[inline(always)]
295 pub const fn variant(&self) -> Tpp5 {
296 match self.bits {
297 false => Tpp5::NoInvert,
298 true => Tpp5::Invert,
299 }
300 }
301 #[doc = "Not inverted"]
302 #[inline(always)]
303 pub fn is_no_invert(&self) -> bool {
304 *self == Tpp5::NoInvert
305 }
306 #[doc = "Inverted"]
307 #[inline(always)]
308 pub fn is_invert(&self) -> bool {
309 *self == Tpp5::Invert
310 }
311}
312#[doc = "Field `TPP5` writer - Tamper Pin n Polarity"]
313pub type Tpp5W<'a, REG> = crate::BitWriter<'a, REG, Tpp5>;
314impl<'a, REG> Tpp5W<'a, REG>
315where
316 REG: crate::Writable + crate::RegisterSpec,
317{
318 #[doc = "Not inverted"]
319 #[inline(always)]
320 pub fn no_invert(self) -> &'a mut crate::W<REG> {
321 self.variant(Tpp5::NoInvert)
322 }
323 #[doc = "Inverted"]
324 #[inline(always)]
325 pub fn invert(self) -> &'a mut crate::W<REG> {
326 self.variant(Tpp5::Invert)
327 }
328}
329#[doc = "Tamper Pin n Input Data\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Tpid0 {
333 #[doc = "0: Zero"]
334 Zero = 0,
335 #[doc = "1: One"]
336 One = 1,
337}
338impl From<Tpid0> for bool {
339 #[inline(always)]
340 fn from(variant: Tpid0) -> Self {
341 variant as u8 != 0
342 }
343}
344#[doc = "Field `TPID0` reader - Tamper Pin n Input Data"]
345pub type Tpid0R = crate::BitReader<Tpid0>;
346impl Tpid0R {
347 #[doc = "Get enumerated values variant"]
348 #[inline(always)]
349 pub const fn variant(&self) -> Tpid0 {
350 match self.bits {
351 false => Tpid0::Zero,
352 true => Tpid0::One,
353 }
354 }
355 #[doc = "Zero"]
356 #[inline(always)]
357 pub fn is_zero(&self) -> bool {
358 *self == Tpid0::Zero
359 }
360 #[doc = "One"]
361 #[inline(always)]
362 pub fn is_one(&self) -> bool {
363 *self == Tpid0::One
364 }
365}
366#[doc = "Tamper Pin n Input Data\n\nValue on reset: 0"]
367#[cfg_attr(feature = "defmt", derive(defmt::Format))]
368#[derive(Clone, Copy, Debug, PartialEq, Eq)]
369pub enum Tpid1 {
370 #[doc = "0: Zero"]
371 Zero = 0,
372 #[doc = "1: One"]
373 One = 1,
374}
375impl From<Tpid1> for bool {
376 #[inline(always)]
377 fn from(variant: Tpid1) -> Self {
378 variant as u8 != 0
379 }
380}
381#[doc = "Field `TPID1` reader - Tamper Pin n Input Data"]
382pub type Tpid1R = crate::BitReader<Tpid1>;
383impl Tpid1R {
384 #[doc = "Get enumerated values variant"]
385 #[inline(always)]
386 pub const fn variant(&self) -> Tpid1 {
387 match self.bits {
388 false => Tpid1::Zero,
389 true => Tpid1::One,
390 }
391 }
392 #[doc = "Zero"]
393 #[inline(always)]
394 pub fn is_zero(&self) -> bool {
395 *self == Tpid1::Zero
396 }
397 #[doc = "One"]
398 #[inline(always)]
399 pub fn is_one(&self) -> bool {
400 *self == Tpid1::One
401 }
402}
403#[doc = "Tamper Pin n Input Data\n\nValue on reset: 0"]
404#[cfg_attr(feature = "defmt", derive(defmt::Format))]
405#[derive(Clone, Copy, Debug, PartialEq, Eq)]
406pub enum Tpid2 {
407 #[doc = "0: Zero"]
408 Zero = 0,
409 #[doc = "1: One"]
410 One = 1,
411}
412impl From<Tpid2> for bool {
413 #[inline(always)]
414 fn from(variant: Tpid2) -> Self {
415 variant as u8 != 0
416 }
417}
418#[doc = "Field `TPID2` reader - Tamper Pin n Input Data"]
419pub type Tpid2R = crate::BitReader<Tpid2>;
420impl Tpid2R {
421 #[doc = "Get enumerated values variant"]
422 #[inline(always)]
423 pub const fn variant(&self) -> Tpid2 {
424 match self.bits {
425 false => Tpid2::Zero,
426 true => Tpid2::One,
427 }
428 }
429 #[doc = "Zero"]
430 #[inline(always)]
431 pub fn is_zero(&self) -> bool {
432 *self == Tpid2::Zero
433 }
434 #[doc = "One"]
435 #[inline(always)]
436 pub fn is_one(&self) -> bool {
437 *self == Tpid2::One
438 }
439}
440#[doc = "Tamper Pin n Input Data\n\nValue on reset: 0"]
441#[cfg_attr(feature = "defmt", derive(defmt::Format))]
442#[derive(Clone, Copy, Debug, PartialEq, Eq)]
443pub enum Tpid3 {
444 #[doc = "0: Zero"]
445 Zero = 0,
446 #[doc = "1: One"]
447 One = 1,
448}
449impl From<Tpid3> for bool {
450 #[inline(always)]
451 fn from(variant: Tpid3) -> Self {
452 variant as u8 != 0
453 }
454}
455#[doc = "Field `TPID3` reader - Tamper Pin n Input Data"]
456pub type Tpid3R = crate::BitReader<Tpid3>;
457impl Tpid3R {
458 #[doc = "Get enumerated values variant"]
459 #[inline(always)]
460 pub const fn variant(&self) -> Tpid3 {
461 match self.bits {
462 false => Tpid3::Zero,
463 true => Tpid3::One,
464 }
465 }
466 #[doc = "Zero"]
467 #[inline(always)]
468 pub fn is_zero(&self) -> bool {
469 *self == Tpid3::Zero
470 }
471 #[doc = "One"]
472 #[inline(always)]
473 pub fn is_one(&self) -> bool {
474 *self == Tpid3::One
475 }
476}
477#[doc = "Tamper Pin n Input Data\n\nValue on reset: 0"]
478#[cfg_attr(feature = "defmt", derive(defmt::Format))]
479#[derive(Clone, Copy, Debug, PartialEq, Eq)]
480pub enum Tpid4 {
481 #[doc = "0: Zero"]
482 Zero = 0,
483 #[doc = "1: One"]
484 One = 1,
485}
486impl From<Tpid4> for bool {
487 #[inline(always)]
488 fn from(variant: Tpid4) -> Self {
489 variant as u8 != 0
490 }
491}
492#[doc = "Field `TPID4` reader - Tamper Pin n Input Data"]
493pub type Tpid4R = crate::BitReader<Tpid4>;
494impl Tpid4R {
495 #[doc = "Get enumerated values variant"]
496 #[inline(always)]
497 pub const fn variant(&self) -> Tpid4 {
498 match self.bits {
499 false => Tpid4::Zero,
500 true => Tpid4::One,
501 }
502 }
503 #[doc = "Zero"]
504 #[inline(always)]
505 pub fn is_zero(&self) -> bool {
506 *self == Tpid4::Zero
507 }
508 #[doc = "One"]
509 #[inline(always)]
510 pub fn is_one(&self) -> bool {
511 *self == Tpid4::One
512 }
513}
514#[doc = "Tamper Pin n Input Data\n\nValue on reset: 0"]
515#[cfg_attr(feature = "defmt", derive(defmt::Format))]
516#[derive(Clone, Copy, Debug, PartialEq, Eq)]
517pub enum Tpid5 {
518 #[doc = "0: Zero"]
519 Zero = 0,
520 #[doc = "1: One"]
521 One = 1,
522}
523impl From<Tpid5> for bool {
524 #[inline(always)]
525 fn from(variant: Tpid5) -> Self {
526 variant as u8 != 0
527 }
528}
529#[doc = "Field `TPID5` reader - Tamper Pin n Input Data"]
530pub type Tpid5R = crate::BitReader<Tpid5>;
531impl Tpid5R {
532 #[doc = "Get enumerated values variant"]
533 #[inline(always)]
534 pub const fn variant(&self) -> Tpid5 {
535 match self.bits {
536 false => Tpid5::Zero,
537 true => Tpid5::One,
538 }
539 }
540 #[doc = "Zero"]
541 #[inline(always)]
542 pub fn is_zero(&self) -> bool {
543 *self == Tpid5::Zero
544 }
545 #[doc = "One"]
546 #[inline(always)]
547 pub fn is_one(&self) -> bool {
548 *self == Tpid5::One
549 }
550}
551impl R {
552 #[doc = "Bit 0 - Tamper Pin n Polarity"]
553 #[inline(always)]
554 pub fn tpp0(&self) -> Tpp0R {
555 Tpp0R::new((self.bits & 1) != 0)
556 }
557 #[doc = "Bit 1 - Tamper Pin n Polarity"]
558 #[inline(always)]
559 pub fn tpp1(&self) -> Tpp1R {
560 Tpp1R::new(((self.bits >> 1) & 1) != 0)
561 }
562 #[doc = "Bit 2 - Tamper Pin n Polarity"]
563 #[inline(always)]
564 pub fn tpp2(&self) -> Tpp2R {
565 Tpp2R::new(((self.bits >> 2) & 1) != 0)
566 }
567 #[doc = "Bit 3 - Tamper Pin n Polarity"]
568 #[inline(always)]
569 pub fn tpp3(&self) -> Tpp3R {
570 Tpp3R::new(((self.bits >> 3) & 1) != 0)
571 }
572 #[doc = "Bit 4 - Tamper Pin n Polarity"]
573 #[inline(always)]
574 pub fn tpp4(&self) -> Tpp4R {
575 Tpp4R::new(((self.bits >> 4) & 1) != 0)
576 }
577 #[doc = "Bit 5 - Tamper Pin n Polarity"]
578 #[inline(always)]
579 pub fn tpp5(&self) -> Tpp5R {
580 Tpp5R::new(((self.bits >> 5) & 1) != 0)
581 }
582 #[doc = "Bit 16 - Tamper Pin n Input Data"]
583 #[inline(always)]
584 pub fn tpid0(&self) -> Tpid0R {
585 Tpid0R::new(((self.bits >> 16) & 1) != 0)
586 }
587 #[doc = "Bit 17 - Tamper Pin n Input Data"]
588 #[inline(always)]
589 pub fn tpid1(&self) -> Tpid1R {
590 Tpid1R::new(((self.bits >> 17) & 1) != 0)
591 }
592 #[doc = "Bit 18 - Tamper Pin n Input Data"]
593 #[inline(always)]
594 pub fn tpid2(&self) -> Tpid2R {
595 Tpid2R::new(((self.bits >> 18) & 1) != 0)
596 }
597 #[doc = "Bit 19 - Tamper Pin n Input Data"]
598 #[inline(always)]
599 pub fn tpid3(&self) -> Tpid3R {
600 Tpid3R::new(((self.bits >> 19) & 1) != 0)
601 }
602 #[doc = "Bit 20 - Tamper Pin n Input Data"]
603 #[inline(always)]
604 pub fn tpid4(&self) -> Tpid4R {
605 Tpid4R::new(((self.bits >> 20) & 1) != 0)
606 }
607 #[doc = "Bit 21 - Tamper Pin n Input Data"]
608 #[inline(always)]
609 pub fn tpid5(&self) -> Tpid5R {
610 Tpid5R::new(((self.bits >> 21) & 1) != 0)
611 }
612}
613#[cfg(feature = "debug")]
614impl core::fmt::Debug for R {
615 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
616 f.debug_struct("PPR")
617 .field("tpp0", &self.tpp0())
618 .field("tpp1", &self.tpp1())
619 .field("tpp2", &self.tpp2())
620 .field("tpp3", &self.tpp3())
621 .field("tpp4", &self.tpp4())
622 .field("tpp5", &self.tpp5())
623 .field("tpid0", &self.tpid0())
624 .field("tpid1", &self.tpid1())
625 .field("tpid2", &self.tpid2())
626 .field("tpid3", &self.tpid3())
627 .field("tpid4", &self.tpid4())
628 .field("tpid5", &self.tpid5())
629 .finish()
630 }
631}
632impl W {
633 #[doc = "Bit 0 - Tamper Pin n Polarity"]
634 #[inline(always)]
635 pub fn tpp0(&mut self) -> Tpp0W<'_, PprSpec> {
636 Tpp0W::new(self, 0)
637 }
638 #[doc = "Bit 1 - Tamper Pin n Polarity"]
639 #[inline(always)]
640 pub fn tpp1(&mut self) -> Tpp1W<'_, PprSpec> {
641 Tpp1W::new(self, 1)
642 }
643 #[doc = "Bit 2 - Tamper Pin n Polarity"]
644 #[inline(always)]
645 pub fn tpp2(&mut self) -> Tpp2W<'_, PprSpec> {
646 Tpp2W::new(self, 2)
647 }
648 #[doc = "Bit 3 - Tamper Pin n Polarity"]
649 #[inline(always)]
650 pub fn tpp3(&mut self) -> Tpp3W<'_, PprSpec> {
651 Tpp3W::new(self, 3)
652 }
653 #[doc = "Bit 4 - Tamper Pin n Polarity"]
654 #[inline(always)]
655 pub fn tpp4(&mut self) -> Tpp4W<'_, PprSpec> {
656 Tpp4W::new(self, 4)
657 }
658 #[doc = "Bit 5 - Tamper Pin n Polarity"]
659 #[inline(always)]
660 pub fn tpp5(&mut self) -> Tpp5W<'_, PprSpec> {
661 Tpp5W::new(self, 5)
662 }
663}
664#[doc = "Pin Polarity\n\nYou can [`read`](crate::Reg::read) this register and get [`ppr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`ppr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
665pub struct PprSpec;
666impl crate::RegisterSpec for PprSpec {
667 type Ux = u32;
668}
669#[doc = "`read()` method returns [`ppr::R`](R) reader structure"]
670impl crate::Readable for PprSpec {}
671#[doc = "`write(|w| ..)` method takes [`ppr::W`](W) writer structure"]
672impl crate::Writable for PprSpec {
673 type Safety = crate::Unsafe;
674}
675#[doc = "`reset()` method sets PPR to value 0"]
676impl crate::Resettable for PprSpec {}