1#[doc = r" Value to write to the register"]
2pub struct W {
3 bits: u32,
4}
5impl super::PSOR {
6 #[doc = r" Writes to the register"]
7 #[inline]
8 pub fn write<F>(&self, f: F)
9 where
10 F: FnOnce(&mut W) -> &mut W,
11 {
12 let mut w = W::reset_value();
13 f(&mut w);
14 self.register.set(w.bits);
15 }
16}
17#[doc = "Values that can be written to the field `PTSO0`"]
18pub enum PTSO0W {
19 #[doc = "Corresponding bit in PDORn does not change."]
20 _0,
21 #[doc = "Corresponding bit in PDORn is set to logic 1."]
22 _1,
23}
24impl PTSO0W {
25 #[allow(missing_docs)]
26 #[doc(hidden)]
27 #[inline]
28 pub fn _bits(&self) -> bool {
29 match *self {
30 PTSO0W::_0 => false,
31 PTSO0W::_1 => true,
32 }
33 }
34}
35#[doc = r" Proxy"]
36pub struct _PTSO0W<'a> {
37 w: &'a mut W,
38}
39impl<'a> _PTSO0W<'a> {
40 #[doc = r" Writes `variant` to the field"]
41 #[inline]
42 pub fn variant(self, variant: PTSO0W) -> &'a mut W {
43 {
44 self.bit(variant._bits())
45 }
46 }
47 #[doc = "Corresponding bit in PDORn does not change."]
48 #[inline]
49 pub fn _0(self) -> &'a mut W {
50 self.variant(PTSO0W::_0)
51 }
52 #[doc = "Corresponding bit in PDORn is set to logic 1."]
53 #[inline]
54 pub fn _1(self) -> &'a mut W {
55 self.variant(PTSO0W::_1)
56 }
57 #[doc = r" Sets the field bit"]
58 pub fn set_bit(self) -> &'a mut W {
59 self.bit(true)
60 }
61 #[doc = r" Clears the field bit"]
62 pub fn clear_bit(self) -> &'a mut W {
63 self.bit(false)
64 }
65 #[doc = r" Writes raw bits to the field"]
66 #[inline]
67 pub fn bit(self, value: bool) -> &'a mut W {
68 const MASK: bool = true;
69 const OFFSET: u8 = 0;
70 self.w.bits &= !((MASK as u32) << OFFSET);
71 self.w.bits |= ((value & MASK) as u32) << OFFSET;
72 self.w
73 }
74}
75#[doc = "Values that can be written to the field `PTSO1`"]
76pub enum PTSO1W {
77 #[doc = "Corresponding bit in PDORn does not change."]
78 _0,
79 #[doc = "Corresponding bit in PDORn is set to logic 1."]
80 _1,
81}
82impl PTSO1W {
83 #[allow(missing_docs)]
84 #[doc(hidden)]
85 #[inline]
86 pub fn _bits(&self) -> bool {
87 match *self {
88 PTSO1W::_0 => false,
89 PTSO1W::_1 => true,
90 }
91 }
92}
93#[doc = r" Proxy"]
94pub struct _PTSO1W<'a> {
95 w: &'a mut W,
96}
97impl<'a> _PTSO1W<'a> {
98 #[doc = r" Writes `variant` to the field"]
99 #[inline]
100 pub fn variant(self, variant: PTSO1W) -> &'a mut W {
101 {
102 self.bit(variant._bits())
103 }
104 }
105 #[doc = "Corresponding bit in PDORn does not change."]
106 #[inline]
107 pub fn _0(self) -> &'a mut W {
108 self.variant(PTSO1W::_0)
109 }
110 #[doc = "Corresponding bit in PDORn is set to logic 1."]
111 #[inline]
112 pub fn _1(self) -> &'a mut W {
113 self.variant(PTSO1W::_1)
114 }
115 #[doc = r" Sets the field bit"]
116 pub fn set_bit(self) -> &'a mut W {
117 self.bit(true)
118 }
119 #[doc = r" Clears the field bit"]
120 pub fn clear_bit(self) -> &'a mut W {
121 self.bit(false)
122 }
123 #[doc = r" Writes raw bits to the field"]
124 #[inline]
125 pub fn bit(self, value: bool) -> &'a mut W {
126 const MASK: bool = true;
127 const OFFSET: u8 = 1;
128 self.w.bits &= !((MASK as u32) << OFFSET);
129 self.w.bits |= ((value & MASK) as u32) << OFFSET;
130 self.w
131 }
132}
133#[doc = "Values that can be written to the field `PTSO2`"]
134pub enum PTSO2W {
135 #[doc = "Corresponding bit in PDORn does not change."]
136 _0,
137 #[doc = "Corresponding bit in PDORn is set to logic 1."]
138 _1,
139}
140impl PTSO2W {
141 #[allow(missing_docs)]
142 #[doc(hidden)]
143 #[inline]
144 pub fn _bits(&self) -> bool {
145 match *self {
146 PTSO2W::_0 => false,
147 PTSO2W::_1 => true,
148 }
149 }
150}
151#[doc = r" Proxy"]
152pub struct _PTSO2W<'a> {
153 w: &'a mut W,
154}
155impl<'a> _PTSO2W<'a> {
156 #[doc = r" Writes `variant` to the field"]
157 #[inline]
158 pub fn variant(self, variant: PTSO2W) -> &'a mut W {
159 {
160 self.bit(variant._bits())
161 }
162 }
163 #[doc = "Corresponding bit in PDORn does not change."]
164 #[inline]
165 pub fn _0(self) -> &'a mut W {
166 self.variant(PTSO2W::_0)
167 }
168 #[doc = "Corresponding bit in PDORn is set to logic 1."]
169 #[inline]
170 pub fn _1(self) -> &'a mut W {
171 self.variant(PTSO2W::_1)
172 }
173 #[doc = r" Sets the field bit"]
174 pub fn set_bit(self) -> &'a mut W {
175 self.bit(true)
176 }
177 #[doc = r" Clears the field bit"]
178 pub fn clear_bit(self) -> &'a mut W {
179 self.bit(false)
180 }
181 #[doc = r" Writes raw bits to the field"]
182 #[inline]
183 pub fn bit(self, value: bool) -> &'a mut W {
184 const MASK: bool = true;
185 const OFFSET: u8 = 2;
186 self.w.bits &= !((MASK as u32) << OFFSET);
187 self.w.bits |= ((value & MASK) as u32) << OFFSET;
188 self.w
189 }
190}
191#[doc = "Values that can be written to the field `PTSO3`"]
192pub enum PTSO3W {
193 #[doc = "Corresponding bit in PDORn does not change."]
194 _0,
195 #[doc = "Corresponding bit in PDORn is set to logic 1."]
196 _1,
197}
198impl PTSO3W {
199 #[allow(missing_docs)]
200 #[doc(hidden)]
201 #[inline]
202 pub fn _bits(&self) -> bool {
203 match *self {
204 PTSO3W::_0 => false,
205 PTSO3W::_1 => true,
206 }
207 }
208}
209#[doc = r" Proxy"]
210pub struct _PTSO3W<'a> {
211 w: &'a mut W,
212}
213impl<'a> _PTSO3W<'a> {
214 #[doc = r" Writes `variant` to the field"]
215 #[inline]
216 pub fn variant(self, variant: PTSO3W) -> &'a mut W {
217 {
218 self.bit(variant._bits())
219 }
220 }
221 #[doc = "Corresponding bit in PDORn does not change."]
222 #[inline]
223 pub fn _0(self) -> &'a mut W {
224 self.variant(PTSO3W::_0)
225 }
226 #[doc = "Corresponding bit in PDORn is set to logic 1."]
227 #[inline]
228 pub fn _1(self) -> &'a mut W {
229 self.variant(PTSO3W::_1)
230 }
231 #[doc = r" Sets the field bit"]
232 pub fn set_bit(self) -> &'a mut W {
233 self.bit(true)
234 }
235 #[doc = r" Clears the field bit"]
236 pub fn clear_bit(self) -> &'a mut W {
237 self.bit(false)
238 }
239 #[doc = r" Writes raw bits to the field"]
240 #[inline]
241 pub fn bit(self, value: bool) -> &'a mut W {
242 const MASK: bool = true;
243 const OFFSET: u8 = 3;
244 self.w.bits &= !((MASK as u32) << OFFSET);
245 self.w.bits |= ((value & MASK) as u32) << OFFSET;
246 self.w
247 }
248}
249#[doc = "Values that can be written to the field `PTSO4`"]
250pub enum PTSO4W {
251 #[doc = "Corresponding bit in PDORn does not change."]
252 _0,
253 #[doc = "Corresponding bit in PDORn is set to logic 1."]
254 _1,
255}
256impl PTSO4W {
257 #[allow(missing_docs)]
258 #[doc(hidden)]
259 #[inline]
260 pub fn _bits(&self) -> bool {
261 match *self {
262 PTSO4W::_0 => false,
263 PTSO4W::_1 => true,
264 }
265 }
266}
267#[doc = r" Proxy"]
268pub struct _PTSO4W<'a> {
269 w: &'a mut W,
270}
271impl<'a> _PTSO4W<'a> {
272 #[doc = r" Writes `variant` to the field"]
273 #[inline]
274 pub fn variant(self, variant: PTSO4W) -> &'a mut W {
275 {
276 self.bit(variant._bits())
277 }
278 }
279 #[doc = "Corresponding bit in PDORn does not change."]
280 #[inline]
281 pub fn _0(self) -> &'a mut W {
282 self.variant(PTSO4W::_0)
283 }
284 #[doc = "Corresponding bit in PDORn is set to logic 1."]
285 #[inline]
286 pub fn _1(self) -> &'a mut W {
287 self.variant(PTSO4W::_1)
288 }
289 #[doc = r" Sets the field bit"]
290 pub fn set_bit(self) -> &'a mut W {
291 self.bit(true)
292 }
293 #[doc = r" Clears the field bit"]
294 pub fn clear_bit(self) -> &'a mut W {
295 self.bit(false)
296 }
297 #[doc = r" Writes raw bits to the field"]
298 #[inline]
299 pub fn bit(self, value: bool) -> &'a mut W {
300 const MASK: bool = true;
301 const OFFSET: u8 = 4;
302 self.w.bits &= !((MASK as u32) << OFFSET);
303 self.w.bits |= ((value & MASK) as u32) << OFFSET;
304 self.w
305 }
306}
307#[doc = "Values that can be written to the field `PTSO5`"]
308pub enum PTSO5W {
309 #[doc = "Corresponding bit in PDORn does not change."]
310 _0,
311 #[doc = "Corresponding bit in PDORn is set to logic 1."]
312 _1,
313}
314impl PTSO5W {
315 #[allow(missing_docs)]
316 #[doc(hidden)]
317 #[inline]
318 pub fn _bits(&self) -> bool {
319 match *self {
320 PTSO5W::_0 => false,
321 PTSO5W::_1 => true,
322 }
323 }
324}
325#[doc = r" Proxy"]
326pub struct _PTSO5W<'a> {
327 w: &'a mut W,
328}
329impl<'a> _PTSO5W<'a> {
330 #[doc = r" Writes `variant` to the field"]
331 #[inline]
332 pub fn variant(self, variant: PTSO5W) -> &'a mut W {
333 {
334 self.bit(variant._bits())
335 }
336 }
337 #[doc = "Corresponding bit in PDORn does not change."]
338 #[inline]
339 pub fn _0(self) -> &'a mut W {
340 self.variant(PTSO5W::_0)
341 }
342 #[doc = "Corresponding bit in PDORn is set to logic 1."]
343 #[inline]
344 pub fn _1(self) -> &'a mut W {
345 self.variant(PTSO5W::_1)
346 }
347 #[doc = r" Sets the field bit"]
348 pub fn set_bit(self) -> &'a mut W {
349 self.bit(true)
350 }
351 #[doc = r" Clears the field bit"]
352 pub fn clear_bit(self) -> &'a mut W {
353 self.bit(false)
354 }
355 #[doc = r" Writes raw bits to the field"]
356 #[inline]
357 pub fn bit(self, value: bool) -> &'a mut W {
358 const MASK: bool = true;
359 const OFFSET: u8 = 5;
360 self.w.bits &= !((MASK as u32) << OFFSET);
361 self.w.bits |= ((value & MASK) as u32) << OFFSET;
362 self.w
363 }
364}
365#[doc = "Values that can be written to the field `PTSO6`"]
366pub enum PTSO6W {
367 #[doc = "Corresponding bit in PDORn does not change."]
368 _0,
369 #[doc = "Corresponding bit in PDORn is set to logic 1."]
370 _1,
371}
372impl PTSO6W {
373 #[allow(missing_docs)]
374 #[doc(hidden)]
375 #[inline]
376 pub fn _bits(&self) -> bool {
377 match *self {
378 PTSO6W::_0 => false,
379 PTSO6W::_1 => true,
380 }
381 }
382}
383#[doc = r" Proxy"]
384pub struct _PTSO6W<'a> {
385 w: &'a mut W,
386}
387impl<'a> _PTSO6W<'a> {
388 #[doc = r" Writes `variant` to the field"]
389 #[inline]
390 pub fn variant(self, variant: PTSO6W) -> &'a mut W {
391 {
392 self.bit(variant._bits())
393 }
394 }
395 #[doc = "Corresponding bit in PDORn does not change."]
396 #[inline]
397 pub fn _0(self) -> &'a mut W {
398 self.variant(PTSO6W::_0)
399 }
400 #[doc = "Corresponding bit in PDORn is set to logic 1."]
401 #[inline]
402 pub fn _1(self) -> &'a mut W {
403 self.variant(PTSO6W::_1)
404 }
405 #[doc = r" Sets the field bit"]
406 pub fn set_bit(self) -> &'a mut W {
407 self.bit(true)
408 }
409 #[doc = r" Clears the field bit"]
410 pub fn clear_bit(self) -> &'a mut W {
411 self.bit(false)
412 }
413 #[doc = r" Writes raw bits to the field"]
414 #[inline]
415 pub fn bit(self, value: bool) -> &'a mut W {
416 const MASK: bool = true;
417 const OFFSET: u8 = 6;
418 self.w.bits &= !((MASK as u32) << OFFSET);
419 self.w.bits |= ((value & MASK) as u32) << OFFSET;
420 self.w
421 }
422}
423#[doc = "Values that can be written to the field `PTSO7`"]
424pub enum PTSO7W {
425 #[doc = "Corresponding bit in PDORn does not change."]
426 _0,
427 #[doc = "Corresponding bit in PDORn is set to logic 1."]
428 _1,
429}
430impl PTSO7W {
431 #[allow(missing_docs)]
432 #[doc(hidden)]
433 #[inline]
434 pub fn _bits(&self) -> bool {
435 match *self {
436 PTSO7W::_0 => false,
437 PTSO7W::_1 => true,
438 }
439 }
440}
441#[doc = r" Proxy"]
442pub struct _PTSO7W<'a> {
443 w: &'a mut W,
444}
445impl<'a> _PTSO7W<'a> {
446 #[doc = r" Writes `variant` to the field"]
447 #[inline]
448 pub fn variant(self, variant: PTSO7W) -> &'a mut W {
449 {
450 self.bit(variant._bits())
451 }
452 }
453 #[doc = "Corresponding bit in PDORn does not change."]
454 #[inline]
455 pub fn _0(self) -> &'a mut W {
456 self.variant(PTSO7W::_0)
457 }
458 #[doc = "Corresponding bit in PDORn is set to logic 1."]
459 #[inline]
460 pub fn _1(self) -> &'a mut W {
461 self.variant(PTSO7W::_1)
462 }
463 #[doc = r" Sets the field bit"]
464 pub fn set_bit(self) -> &'a mut W {
465 self.bit(true)
466 }
467 #[doc = r" Clears the field bit"]
468 pub fn clear_bit(self) -> &'a mut W {
469 self.bit(false)
470 }
471 #[doc = r" Writes raw bits to the field"]
472 #[inline]
473 pub fn bit(self, value: bool) -> &'a mut W {
474 const MASK: bool = true;
475 const OFFSET: u8 = 7;
476 self.w.bits &= !((MASK as u32) << OFFSET);
477 self.w.bits |= ((value & MASK) as u32) << OFFSET;
478 self.w
479 }
480}
481#[doc = "Values that can be written to the field `PTSO8`"]
482pub enum PTSO8W {
483 #[doc = "Corresponding bit in PDORn does not change."]
484 _0,
485 #[doc = "Corresponding bit in PDORn is set to logic 1."]
486 _1,
487}
488impl PTSO8W {
489 #[allow(missing_docs)]
490 #[doc(hidden)]
491 #[inline]
492 pub fn _bits(&self) -> bool {
493 match *self {
494 PTSO8W::_0 => false,
495 PTSO8W::_1 => true,
496 }
497 }
498}
499#[doc = r" Proxy"]
500pub struct _PTSO8W<'a> {
501 w: &'a mut W,
502}
503impl<'a> _PTSO8W<'a> {
504 #[doc = r" Writes `variant` to the field"]
505 #[inline]
506 pub fn variant(self, variant: PTSO8W) -> &'a mut W {
507 {
508 self.bit(variant._bits())
509 }
510 }
511 #[doc = "Corresponding bit in PDORn does not change."]
512 #[inline]
513 pub fn _0(self) -> &'a mut W {
514 self.variant(PTSO8W::_0)
515 }
516 #[doc = "Corresponding bit in PDORn is set to logic 1."]
517 #[inline]
518 pub fn _1(self) -> &'a mut W {
519 self.variant(PTSO8W::_1)
520 }
521 #[doc = r" Sets the field bit"]
522 pub fn set_bit(self) -> &'a mut W {
523 self.bit(true)
524 }
525 #[doc = r" Clears the field bit"]
526 pub fn clear_bit(self) -> &'a mut W {
527 self.bit(false)
528 }
529 #[doc = r" Writes raw bits to the field"]
530 #[inline]
531 pub fn bit(self, value: bool) -> &'a mut W {
532 const MASK: bool = true;
533 const OFFSET: u8 = 8;
534 self.w.bits &= !((MASK as u32) << OFFSET);
535 self.w.bits |= ((value & MASK) as u32) << OFFSET;
536 self.w
537 }
538}
539#[doc = "Values that can be written to the field `PTSO9`"]
540pub enum PTSO9W {
541 #[doc = "Corresponding bit in PDORn does not change."]
542 _0,
543 #[doc = "Corresponding bit in PDORn is set to logic 1."]
544 _1,
545}
546impl PTSO9W {
547 #[allow(missing_docs)]
548 #[doc(hidden)]
549 #[inline]
550 pub fn _bits(&self) -> bool {
551 match *self {
552 PTSO9W::_0 => false,
553 PTSO9W::_1 => true,
554 }
555 }
556}
557#[doc = r" Proxy"]
558pub struct _PTSO9W<'a> {
559 w: &'a mut W,
560}
561impl<'a> _PTSO9W<'a> {
562 #[doc = r" Writes `variant` to the field"]
563 #[inline]
564 pub fn variant(self, variant: PTSO9W) -> &'a mut W {
565 {
566 self.bit(variant._bits())
567 }
568 }
569 #[doc = "Corresponding bit in PDORn does not change."]
570 #[inline]
571 pub fn _0(self) -> &'a mut W {
572 self.variant(PTSO9W::_0)
573 }
574 #[doc = "Corresponding bit in PDORn is set to logic 1."]
575 #[inline]
576 pub fn _1(self) -> &'a mut W {
577 self.variant(PTSO9W::_1)
578 }
579 #[doc = r" Sets the field bit"]
580 pub fn set_bit(self) -> &'a mut W {
581 self.bit(true)
582 }
583 #[doc = r" Clears the field bit"]
584 pub fn clear_bit(self) -> &'a mut W {
585 self.bit(false)
586 }
587 #[doc = r" Writes raw bits to the field"]
588 #[inline]
589 pub fn bit(self, value: bool) -> &'a mut W {
590 const MASK: bool = true;
591 const OFFSET: u8 = 9;
592 self.w.bits &= !((MASK as u32) << OFFSET);
593 self.w.bits |= ((value & MASK) as u32) << OFFSET;
594 self.w
595 }
596}
597#[doc = "Values that can be written to the field `PTSO10`"]
598pub enum PTSO10W {
599 #[doc = "Corresponding bit in PDORn does not change."]
600 _0,
601 #[doc = "Corresponding bit in PDORn is set to logic 1."]
602 _1,
603}
604impl PTSO10W {
605 #[allow(missing_docs)]
606 #[doc(hidden)]
607 #[inline]
608 pub fn _bits(&self) -> bool {
609 match *self {
610 PTSO10W::_0 => false,
611 PTSO10W::_1 => true,
612 }
613 }
614}
615#[doc = r" Proxy"]
616pub struct _PTSO10W<'a> {
617 w: &'a mut W,
618}
619impl<'a> _PTSO10W<'a> {
620 #[doc = r" Writes `variant` to the field"]
621 #[inline]
622 pub fn variant(self, variant: PTSO10W) -> &'a mut W {
623 {
624 self.bit(variant._bits())
625 }
626 }
627 #[doc = "Corresponding bit in PDORn does not change."]
628 #[inline]
629 pub fn _0(self) -> &'a mut W {
630 self.variant(PTSO10W::_0)
631 }
632 #[doc = "Corresponding bit in PDORn is set to logic 1."]
633 #[inline]
634 pub fn _1(self) -> &'a mut W {
635 self.variant(PTSO10W::_1)
636 }
637 #[doc = r" Sets the field bit"]
638 pub fn set_bit(self) -> &'a mut W {
639 self.bit(true)
640 }
641 #[doc = r" Clears the field bit"]
642 pub fn clear_bit(self) -> &'a mut W {
643 self.bit(false)
644 }
645 #[doc = r" Writes raw bits to the field"]
646 #[inline]
647 pub fn bit(self, value: bool) -> &'a mut W {
648 const MASK: bool = true;
649 const OFFSET: u8 = 10;
650 self.w.bits &= !((MASK as u32) << OFFSET);
651 self.w.bits |= ((value & MASK) as u32) << OFFSET;
652 self.w
653 }
654}
655#[doc = "Values that can be written to the field `PTSO11`"]
656pub enum PTSO11W {
657 #[doc = "Corresponding bit in PDORn does not change."]
658 _0,
659 #[doc = "Corresponding bit in PDORn is set to logic 1."]
660 _1,
661}
662impl PTSO11W {
663 #[allow(missing_docs)]
664 #[doc(hidden)]
665 #[inline]
666 pub fn _bits(&self) -> bool {
667 match *self {
668 PTSO11W::_0 => false,
669 PTSO11W::_1 => true,
670 }
671 }
672}
673#[doc = r" Proxy"]
674pub struct _PTSO11W<'a> {
675 w: &'a mut W,
676}
677impl<'a> _PTSO11W<'a> {
678 #[doc = r" Writes `variant` to the field"]
679 #[inline]
680 pub fn variant(self, variant: PTSO11W) -> &'a mut W {
681 {
682 self.bit(variant._bits())
683 }
684 }
685 #[doc = "Corresponding bit in PDORn does not change."]
686 #[inline]
687 pub fn _0(self) -> &'a mut W {
688 self.variant(PTSO11W::_0)
689 }
690 #[doc = "Corresponding bit in PDORn is set to logic 1."]
691 #[inline]
692 pub fn _1(self) -> &'a mut W {
693 self.variant(PTSO11W::_1)
694 }
695 #[doc = r" Sets the field bit"]
696 pub fn set_bit(self) -> &'a mut W {
697 self.bit(true)
698 }
699 #[doc = r" Clears the field bit"]
700 pub fn clear_bit(self) -> &'a mut W {
701 self.bit(false)
702 }
703 #[doc = r" Writes raw bits to the field"]
704 #[inline]
705 pub fn bit(self, value: bool) -> &'a mut W {
706 const MASK: bool = true;
707 const OFFSET: u8 = 11;
708 self.w.bits &= !((MASK as u32) << OFFSET);
709 self.w.bits |= ((value & MASK) as u32) << OFFSET;
710 self.w
711 }
712}
713#[doc = "Values that can be written to the field `PTSO12`"]
714pub enum PTSO12W {
715 #[doc = "Corresponding bit in PDORn does not change."]
716 _0,
717 #[doc = "Corresponding bit in PDORn is set to logic 1."]
718 _1,
719}
720impl PTSO12W {
721 #[allow(missing_docs)]
722 #[doc(hidden)]
723 #[inline]
724 pub fn _bits(&self) -> bool {
725 match *self {
726 PTSO12W::_0 => false,
727 PTSO12W::_1 => true,
728 }
729 }
730}
731#[doc = r" Proxy"]
732pub struct _PTSO12W<'a> {
733 w: &'a mut W,
734}
735impl<'a> _PTSO12W<'a> {
736 #[doc = r" Writes `variant` to the field"]
737 #[inline]
738 pub fn variant(self, variant: PTSO12W) -> &'a mut W {
739 {
740 self.bit(variant._bits())
741 }
742 }
743 #[doc = "Corresponding bit in PDORn does not change."]
744 #[inline]
745 pub fn _0(self) -> &'a mut W {
746 self.variant(PTSO12W::_0)
747 }
748 #[doc = "Corresponding bit in PDORn is set to logic 1."]
749 #[inline]
750 pub fn _1(self) -> &'a mut W {
751 self.variant(PTSO12W::_1)
752 }
753 #[doc = r" Sets the field bit"]
754 pub fn set_bit(self) -> &'a mut W {
755 self.bit(true)
756 }
757 #[doc = r" Clears the field bit"]
758 pub fn clear_bit(self) -> &'a mut W {
759 self.bit(false)
760 }
761 #[doc = r" Writes raw bits to the field"]
762 #[inline]
763 pub fn bit(self, value: bool) -> &'a mut W {
764 const MASK: bool = true;
765 const OFFSET: u8 = 12;
766 self.w.bits &= !((MASK as u32) << OFFSET);
767 self.w.bits |= ((value & MASK) as u32) << OFFSET;
768 self.w
769 }
770}
771#[doc = "Values that can be written to the field `PTSO13`"]
772pub enum PTSO13W {
773 #[doc = "Corresponding bit in PDORn does not change."]
774 _0,
775 #[doc = "Corresponding bit in PDORn is set to logic 1."]
776 _1,
777}
778impl PTSO13W {
779 #[allow(missing_docs)]
780 #[doc(hidden)]
781 #[inline]
782 pub fn _bits(&self) -> bool {
783 match *self {
784 PTSO13W::_0 => false,
785 PTSO13W::_1 => true,
786 }
787 }
788}
789#[doc = r" Proxy"]
790pub struct _PTSO13W<'a> {
791 w: &'a mut W,
792}
793impl<'a> _PTSO13W<'a> {
794 #[doc = r" Writes `variant` to the field"]
795 #[inline]
796 pub fn variant(self, variant: PTSO13W) -> &'a mut W {
797 {
798 self.bit(variant._bits())
799 }
800 }
801 #[doc = "Corresponding bit in PDORn does not change."]
802 #[inline]
803 pub fn _0(self) -> &'a mut W {
804 self.variant(PTSO13W::_0)
805 }
806 #[doc = "Corresponding bit in PDORn is set to logic 1."]
807 #[inline]
808 pub fn _1(self) -> &'a mut W {
809 self.variant(PTSO13W::_1)
810 }
811 #[doc = r" Sets the field bit"]
812 pub fn set_bit(self) -> &'a mut W {
813 self.bit(true)
814 }
815 #[doc = r" Clears the field bit"]
816 pub fn clear_bit(self) -> &'a mut W {
817 self.bit(false)
818 }
819 #[doc = r" Writes raw bits to the field"]
820 #[inline]
821 pub fn bit(self, value: bool) -> &'a mut W {
822 const MASK: bool = true;
823 const OFFSET: u8 = 13;
824 self.w.bits &= !((MASK as u32) << OFFSET);
825 self.w.bits |= ((value & MASK) as u32) << OFFSET;
826 self.w
827 }
828}
829#[doc = "Values that can be written to the field `PTSO14`"]
830pub enum PTSO14W {
831 #[doc = "Corresponding bit in PDORn does not change."]
832 _0,
833 #[doc = "Corresponding bit in PDORn is set to logic 1."]
834 _1,
835}
836impl PTSO14W {
837 #[allow(missing_docs)]
838 #[doc(hidden)]
839 #[inline]
840 pub fn _bits(&self) -> bool {
841 match *self {
842 PTSO14W::_0 => false,
843 PTSO14W::_1 => true,
844 }
845 }
846}
847#[doc = r" Proxy"]
848pub struct _PTSO14W<'a> {
849 w: &'a mut W,
850}
851impl<'a> _PTSO14W<'a> {
852 #[doc = r" Writes `variant` to the field"]
853 #[inline]
854 pub fn variant(self, variant: PTSO14W) -> &'a mut W {
855 {
856 self.bit(variant._bits())
857 }
858 }
859 #[doc = "Corresponding bit in PDORn does not change."]
860 #[inline]
861 pub fn _0(self) -> &'a mut W {
862 self.variant(PTSO14W::_0)
863 }
864 #[doc = "Corresponding bit in PDORn is set to logic 1."]
865 #[inline]
866 pub fn _1(self) -> &'a mut W {
867 self.variant(PTSO14W::_1)
868 }
869 #[doc = r" Sets the field bit"]
870 pub fn set_bit(self) -> &'a mut W {
871 self.bit(true)
872 }
873 #[doc = r" Clears the field bit"]
874 pub fn clear_bit(self) -> &'a mut W {
875 self.bit(false)
876 }
877 #[doc = r" Writes raw bits to the field"]
878 #[inline]
879 pub fn bit(self, value: bool) -> &'a mut W {
880 const MASK: bool = true;
881 const OFFSET: u8 = 14;
882 self.w.bits &= !((MASK as u32) << OFFSET);
883 self.w.bits |= ((value & MASK) as u32) << OFFSET;
884 self.w
885 }
886}
887#[doc = "Values that can be written to the field `PTSO15`"]
888pub enum PTSO15W {
889 #[doc = "Corresponding bit in PDORn does not change."]
890 _0,
891 #[doc = "Corresponding bit in PDORn is set to logic 1."]
892 _1,
893}
894impl PTSO15W {
895 #[allow(missing_docs)]
896 #[doc(hidden)]
897 #[inline]
898 pub fn _bits(&self) -> bool {
899 match *self {
900 PTSO15W::_0 => false,
901 PTSO15W::_1 => true,
902 }
903 }
904}
905#[doc = r" Proxy"]
906pub struct _PTSO15W<'a> {
907 w: &'a mut W,
908}
909impl<'a> _PTSO15W<'a> {
910 #[doc = r" Writes `variant` to the field"]
911 #[inline]
912 pub fn variant(self, variant: PTSO15W) -> &'a mut W {
913 {
914 self.bit(variant._bits())
915 }
916 }
917 #[doc = "Corresponding bit in PDORn does not change."]
918 #[inline]
919 pub fn _0(self) -> &'a mut W {
920 self.variant(PTSO15W::_0)
921 }
922 #[doc = "Corresponding bit in PDORn is set to logic 1."]
923 #[inline]
924 pub fn _1(self) -> &'a mut W {
925 self.variant(PTSO15W::_1)
926 }
927 #[doc = r" Sets the field bit"]
928 pub fn set_bit(self) -> &'a mut W {
929 self.bit(true)
930 }
931 #[doc = r" Clears the field bit"]
932 pub fn clear_bit(self) -> &'a mut W {
933 self.bit(false)
934 }
935 #[doc = r" Writes raw bits to the field"]
936 #[inline]
937 pub fn bit(self, value: bool) -> &'a mut W {
938 const MASK: bool = true;
939 const OFFSET: u8 = 15;
940 self.w.bits &= !((MASK as u32) << OFFSET);
941 self.w.bits |= ((value & MASK) as u32) << OFFSET;
942 self.w
943 }
944}
945#[doc = "Values that can be written to the field `PTSO16`"]
946pub enum PTSO16W {
947 #[doc = "Corresponding bit in PDORn does not change."]
948 _0,
949 #[doc = "Corresponding bit in PDORn is set to logic 1."]
950 _1,
951}
952impl PTSO16W {
953 #[allow(missing_docs)]
954 #[doc(hidden)]
955 #[inline]
956 pub fn _bits(&self) -> bool {
957 match *self {
958 PTSO16W::_0 => false,
959 PTSO16W::_1 => true,
960 }
961 }
962}
963#[doc = r" Proxy"]
964pub struct _PTSO16W<'a> {
965 w: &'a mut W,
966}
967impl<'a> _PTSO16W<'a> {
968 #[doc = r" Writes `variant` to the field"]
969 #[inline]
970 pub fn variant(self, variant: PTSO16W) -> &'a mut W {
971 {
972 self.bit(variant._bits())
973 }
974 }
975 #[doc = "Corresponding bit in PDORn does not change."]
976 #[inline]
977 pub fn _0(self) -> &'a mut W {
978 self.variant(PTSO16W::_0)
979 }
980 #[doc = "Corresponding bit in PDORn is set to logic 1."]
981 #[inline]
982 pub fn _1(self) -> &'a mut W {
983 self.variant(PTSO16W::_1)
984 }
985 #[doc = r" Sets the field bit"]
986 pub fn set_bit(self) -> &'a mut W {
987 self.bit(true)
988 }
989 #[doc = r" Clears the field bit"]
990 pub fn clear_bit(self) -> &'a mut W {
991 self.bit(false)
992 }
993 #[doc = r" Writes raw bits to the field"]
994 #[inline]
995 pub fn bit(self, value: bool) -> &'a mut W {
996 const MASK: bool = true;
997 const OFFSET: u8 = 16;
998 self.w.bits &= !((MASK as u32) << OFFSET);
999 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1000 self.w
1001 }
1002}
1003#[doc = "Values that can be written to the field `PTSO17`"]
1004pub enum PTSO17W {
1005 #[doc = "Corresponding bit in PDORn does not change."]
1006 _0,
1007 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1008 _1,
1009}
1010impl PTSO17W {
1011 #[allow(missing_docs)]
1012 #[doc(hidden)]
1013 #[inline]
1014 pub fn _bits(&self) -> bool {
1015 match *self {
1016 PTSO17W::_0 => false,
1017 PTSO17W::_1 => true,
1018 }
1019 }
1020}
1021#[doc = r" Proxy"]
1022pub struct _PTSO17W<'a> {
1023 w: &'a mut W,
1024}
1025impl<'a> _PTSO17W<'a> {
1026 #[doc = r" Writes `variant` to the field"]
1027 #[inline]
1028 pub fn variant(self, variant: PTSO17W) -> &'a mut W {
1029 {
1030 self.bit(variant._bits())
1031 }
1032 }
1033 #[doc = "Corresponding bit in PDORn does not change."]
1034 #[inline]
1035 pub fn _0(self) -> &'a mut W {
1036 self.variant(PTSO17W::_0)
1037 }
1038 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1039 #[inline]
1040 pub fn _1(self) -> &'a mut W {
1041 self.variant(PTSO17W::_1)
1042 }
1043 #[doc = r" Sets the field bit"]
1044 pub fn set_bit(self) -> &'a mut W {
1045 self.bit(true)
1046 }
1047 #[doc = r" Clears the field bit"]
1048 pub fn clear_bit(self) -> &'a mut W {
1049 self.bit(false)
1050 }
1051 #[doc = r" Writes raw bits to the field"]
1052 #[inline]
1053 pub fn bit(self, value: bool) -> &'a mut W {
1054 const MASK: bool = true;
1055 const OFFSET: u8 = 17;
1056 self.w.bits &= !((MASK as u32) << OFFSET);
1057 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1058 self.w
1059 }
1060}
1061#[doc = "Values that can be written to the field `PTSO18`"]
1062pub enum PTSO18W {
1063 #[doc = "Corresponding bit in PDORn does not change."]
1064 _0,
1065 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1066 _1,
1067}
1068impl PTSO18W {
1069 #[allow(missing_docs)]
1070 #[doc(hidden)]
1071 #[inline]
1072 pub fn _bits(&self) -> bool {
1073 match *self {
1074 PTSO18W::_0 => false,
1075 PTSO18W::_1 => true,
1076 }
1077 }
1078}
1079#[doc = r" Proxy"]
1080pub struct _PTSO18W<'a> {
1081 w: &'a mut W,
1082}
1083impl<'a> _PTSO18W<'a> {
1084 #[doc = r" Writes `variant` to the field"]
1085 #[inline]
1086 pub fn variant(self, variant: PTSO18W) -> &'a mut W {
1087 {
1088 self.bit(variant._bits())
1089 }
1090 }
1091 #[doc = "Corresponding bit in PDORn does not change."]
1092 #[inline]
1093 pub fn _0(self) -> &'a mut W {
1094 self.variant(PTSO18W::_0)
1095 }
1096 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1097 #[inline]
1098 pub fn _1(self) -> &'a mut W {
1099 self.variant(PTSO18W::_1)
1100 }
1101 #[doc = r" Sets the field bit"]
1102 pub fn set_bit(self) -> &'a mut W {
1103 self.bit(true)
1104 }
1105 #[doc = r" Clears the field bit"]
1106 pub fn clear_bit(self) -> &'a mut W {
1107 self.bit(false)
1108 }
1109 #[doc = r" Writes raw bits to the field"]
1110 #[inline]
1111 pub fn bit(self, value: bool) -> &'a mut W {
1112 const MASK: bool = true;
1113 const OFFSET: u8 = 18;
1114 self.w.bits &= !((MASK as u32) << OFFSET);
1115 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1116 self.w
1117 }
1118}
1119#[doc = "Values that can be written to the field `PTSO19`"]
1120pub enum PTSO19W {
1121 #[doc = "Corresponding bit in PDORn does not change."]
1122 _0,
1123 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1124 _1,
1125}
1126impl PTSO19W {
1127 #[allow(missing_docs)]
1128 #[doc(hidden)]
1129 #[inline]
1130 pub fn _bits(&self) -> bool {
1131 match *self {
1132 PTSO19W::_0 => false,
1133 PTSO19W::_1 => true,
1134 }
1135 }
1136}
1137#[doc = r" Proxy"]
1138pub struct _PTSO19W<'a> {
1139 w: &'a mut W,
1140}
1141impl<'a> _PTSO19W<'a> {
1142 #[doc = r" Writes `variant` to the field"]
1143 #[inline]
1144 pub fn variant(self, variant: PTSO19W) -> &'a mut W {
1145 {
1146 self.bit(variant._bits())
1147 }
1148 }
1149 #[doc = "Corresponding bit in PDORn does not change."]
1150 #[inline]
1151 pub fn _0(self) -> &'a mut W {
1152 self.variant(PTSO19W::_0)
1153 }
1154 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1155 #[inline]
1156 pub fn _1(self) -> &'a mut W {
1157 self.variant(PTSO19W::_1)
1158 }
1159 #[doc = r" Sets the field bit"]
1160 pub fn set_bit(self) -> &'a mut W {
1161 self.bit(true)
1162 }
1163 #[doc = r" Clears the field bit"]
1164 pub fn clear_bit(self) -> &'a mut W {
1165 self.bit(false)
1166 }
1167 #[doc = r" Writes raw bits to the field"]
1168 #[inline]
1169 pub fn bit(self, value: bool) -> &'a mut W {
1170 const MASK: bool = true;
1171 const OFFSET: u8 = 19;
1172 self.w.bits &= !((MASK as u32) << OFFSET);
1173 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1174 self.w
1175 }
1176}
1177#[doc = "Values that can be written to the field `PTSO20`"]
1178pub enum PTSO20W {
1179 #[doc = "Corresponding bit in PDORn does not change."]
1180 _0,
1181 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1182 _1,
1183}
1184impl PTSO20W {
1185 #[allow(missing_docs)]
1186 #[doc(hidden)]
1187 #[inline]
1188 pub fn _bits(&self) -> bool {
1189 match *self {
1190 PTSO20W::_0 => false,
1191 PTSO20W::_1 => true,
1192 }
1193 }
1194}
1195#[doc = r" Proxy"]
1196pub struct _PTSO20W<'a> {
1197 w: &'a mut W,
1198}
1199impl<'a> _PTSO20W<'a> {
1200 #[doc = r" Writes `variant` to the field"]
1201 #[inline]
1202 pub fn variant(self, variant: PTSO20W) -> &'a mut W {
1203 {
1204 self.bit(variant._bits())
1205 }
1206 }
1207 #[doc = "Corresponding bit in PDORn does not change."]
1208 #[inline]
1209 pub fn _0(self) -> &'a mut W {
1210 self.variant(PTSO20W::_0)
1211 }
1212 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1213 #[inline]
1214 pub fn _1(self) -> &'a mut W {
1215 self.variant(PTSO20W::_1)
1216 }
1217 #[doc = r" Sets the field bit"]
1218 pub fn set_bit(self) -> &'a mut W {
1219 self.bit(true)
1220 }
1221 #[doc = r" Clears the field bit"]
1222 pub fn clear_bit(self) -> &'a mut W {
1223 self.bit(false)
1224 }
1225 #[doc = r" Writes raw bits to the field"]
1226 #[inline]
1227 pub fn bit(self, value: bool) -> &'a mut W {
1228 const MASK: bool = true;
1229 const OFFSET: u8 = 20;
1230 self.w.bits &= !((MASK as u32) << OFFSET);
1231 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1232 self.w
1233 }
1234}
1235#[doc = "Values that can be written to the field `PTSO21`"]
1236pub enum PTSO21W {
1237 #[doc = "Corresponding bit in PDORn does not change."]
1238 _0,
1239 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1240 _1,
1241}
1242impl PTSO21W {
1243 #[allow(missing_docs)]
1244 #[doc(hidden)]
1245 #[inline]
1246 pub fn _bits(&self) -> bool {
1247 match *self {
1248 PTSO21W::_0 => false,
1249 PTSO21W::_1 => true,
1250 }
1251 }
1252}
1253#[doc = r" Proxy"]
1254pub struct _PTSO21W<'a> {
1255 w: &'a mut W,
1256}
1257impl<'a> _PTSO21W<'a> {
1258 #[doc = r" Writes `variant` to the field"]
1259 #[inline]
1260 pub fn variant(self, variant: PTSO21W) -> &'a mut W {
1261 {
1262 self.bit(variant._bits())
1263 }
1264 }
1265 #[doc = "Corresponding bit in PDORn does not change."]
1266 #[inline]
1267 pub fn _0(self) -> &'a mut W {
1268 self.variant(PTSO21W::_0)
1269 }
1270 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1271 #[inline]
1272 pub fn _1(self) -> &'a mut W {
1273 self.variant(PTSO21W::_1)
1274 }
1275 #[doc = r" Sets the field bit"]
1276 pub fn set_bit(self) -> &'a mut W {
1277 self.bit(true)
1278 }
1279 #[doc = r" Clears the field bit"]
1280 pub fn clear_bit(self) -> &'a mut W {
1281 self.bit(false)
1282 }
1283 #[doc = r" Writes raw bits to the field"]
1284 #[inline]
1285 pub fn bit(self, value: bool) -> &'a mut W {
1286 const MASK: bool = true;
1287 const OFFSET: u8 = 21;
1288 self.w.bits &= !((MASK as u32) << OFFSET);
1289 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1290 self.w
1291 }
1292}
1293#[doc = "Values that can be written to the field `PTSO22`"]
1294pub enum PTSO22W {
1295 #[doc = "Corresponding bit in PDORn does not change."]
1296 _0,
1297 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1298 _1,
1299}
1300impl PTSO22W {
1301 #[allow(missing_docs)]
1302 #[doc(hidden)]
1303 #[inline]
1304 pub fn _bits(&self) -> bool {
1305 match *self {
1306 PTSO22W::_0 => false,
1307 PTSO22W::_1 => true,
1308 }
1309 }
1310}
1311#[doc = r" Proxy"]
1312pub struct _PTSO22W<'a> {
1313 w: &'a mut W,
1314}
1315impl<'a> _PTSO22W<'a> {
1316 #[doc = r" Writes `variant` to the field"]
1317 #[inline]
1318 pub fn variant(self, variant: PTSO22W) -> &'a mut W {
1319 {
1320 self.bit(variant._bits())
1321 }
1322 }
1323 #[doc = "Corresponding bit in PDORn does not change."]
1324 #[inline]
1325 pub fn _0(self) -> &'a mut W {
1326 self.variant(PTSO22W::_0)
1327 }
1328 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1329 #[inline]
1330 pub fn _1(self) -> &'a mut W {
1331 self.variant(PTSO22W::_1)
1332 }
1333 #[doc = r" Sets the field bit"]
1334 pub fn set_bit(self) -> &'a mut W {
1335 self.bit(true)
1336 }
1337 #[doc = r" Clears the field bit"]
1338 pub fn clear_bit(self) -> &'a mut W {
1339 self.bit(false)
1340 }
1341 #[doc = r" Writes raw bits to the field"]
1342 #[inline]
1343 pub fn bit(self, value: bool) -> &'a mut W {
1344 const MASK: bool = true;
1345 const OFFSET: u8 = 22;
1346 self.w.bits &= !((MASK as u32) << OFFSET);
1347 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1348 self.w
1349 }
1350}
1351#[doc = "Values that can be written to the field `PTSO23`"]
1352pub enum PTSO23W {
1353 #[doc = "Corresponding bit in PDORn does not change."]
1354 _0,
1355 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1356 _1,
1357}
1358impl PTSO23W {
1359 #[allow(missing_docs)]
1360 #[doc(hidden)]
1361 #[inline]
1362 pub fn _bits(&self) -> bool {
1363 match *self {
1364 PTSO23W::_0 => false,
1365 PTSO23W::_1 => true,
1366 }
1367 }
1368}
1369#[doc = r" Proxy"]
1370pub struct _PTSO23W<'a> {
1371 w: &'a mut W,
1372}
1373impl<'a> _PTSO23W<'a> {
1374 #[doc = r" Writes `variant` to the field"]
1375 #[inline]
1376 pub fn variant(self, variant: PTSO23W) -> &'a mut W {
1377 {
1378 self.bit(variant._bits())
1379 }
1380 }
1381 #[doc = "Corresponding bit in PDORn does not change."]
1382 #[inline]
1383 pub fn _0(self) -> &'a mut W {
1384 self.variant(PTSO23W::_0)
1385 }
1386 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1387 #[inline]
1388 pub fn _1(self) -> &'a mut W {
1389 self.variant(PTSO23W::_1)
1390 }
1391 #[doc = r" Sets the field bit"]
1392 pub fn set_bit(self) -> &'a mut W {
1393 self.bit(true)
1394 }
1395 #[doc = r" Clears the field bit"]
1396 pub fn clear_bit(self) -> &'a mut W {
1397 self.bit(false)
1398 }
1399 #[doc = r" Writes raw bits to the field"]
1400 #[inline]
1401 pub fn bit(self, value: bool) -> &'a mut W {
1402 const MASK: bool = true;
1403 const OFFSET: u8 = 23;
1404 self.w.bits &= !((MASK as u32) << OFFSET);
1405 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1406 self.w
1407 }
1408}
1409#[doc = "Values that can be written to the field `PTSO24`"]
1410pub enum PTSO24W {
1411 #[doc = "Corresponding bit in PDORn does not change."]
1412 _0,
1413 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1414 _1,
1415}
1416impl PTSO24W {
1417 #[allow(missing_docs)]
1418 #[doc(hidden)]
1419 #[inline]
1420 pub fn _bits(&self) -> bool {
1421 match *self {
1422 PTSO24W::_0 => false,
1423 PTSO24W::_1 => true,
1424 }
1425 }
1426}
1427#[doc = r" Proxy"]
1428pub struct _PTSO24W<'a> {
1429 w: &'a mut W,
1430}
1431impl<'a> _PTSO24W<'a> {
1432 #[doc = r" Writes `variant` to the field"]
1433 #[inline]
1434 pub fn variant(self, variant: PTSO24W) -> &'a mut W {
1435 {
1436 self.bit(variant._bits())
1437 }
1438 }
1439 #[doc = "Corresponding bit in PDORn does not change."]
1440 #[inline]
1441 pub fn _0(self) -> &'a mut W {
1442 self.variant(PTSO24W::_0)
1443 }
1444 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1445 #[inline]
1446 pub fn _1(self) -> &'a mut W {
1447 self.variant(PTSO24W::_1)
1448 }
1449 #[doc = r" Sets the field bit"]
1450 pub fn set_bit(self) -> &'a mut W {
1451 self.bit(true)
1452 }
1453 #[doc = r" Clears the field bit"]
1454 pub fn clear_bit(self) -> &'a mut W {
1455 self.bit(false)
1456 }
1457 #[doc = r" Writes raw bits to the field"]
1458 #[inline]
1459 pub fn bit(self, value: bool) -> &'a mut W {
1460 const MASK: bool = true;
1461 const OFFSET: u8 = 24;
1462 self.w.bits &= !((MASK as u32) << OFFSET);
1463 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1464 self.w
1465 }
1466}
1467#[doc = "Values that can be written to the field `PTSO25`"]
1468pub enum PTSO25W {
1469 #[doc = "Corresponding bit in PDORn does not change."]
1470 _0,
1471 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1472 _1,
1473}
1474impl PTSO25W {
1475 #[allow(missing_docs)]
1476 #[doc(hidden)]
1477 #[inline]
1478 pub fn _bits(&self) -> bool {
1479 match *self {
1480 PTSO25W::_0 => false,
1481 PTSO25W::_1 => true,
1482 }
1483 }
1484}
1485#[doc = r" Proxy"]
1486pub struct _PTSO25W<'a> {
1487 w: &'a mut W,
1488}
1489impl<'a> _PTSO25W<'a> {
1490 #[doc = r" Writes `variant` to the field"]
1491 #[inline]
1492 pub fn variant(self, variant: PTSO25W) -> &'a mut W {
1493 {
1494 self.bit(variant._bits())
1495 }
1496 }
1497 #[doc = "Corresponding bit in PDORn does not change."]
1498 #[inline]
1499 pub fn _0(self) -> &'a mut W {
1500 self.variant(PTSO25W::_0)
1501 }
1502 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1503 #[inline]
1504 pub fn _1(self) -> &'a mut W {
1505 self.variant(PTSO25W::_1)
1506 }
1507 #[doc = r" Sets the field bit"]
1508 pub fn set_bit(self) -> &'a mut W {
1509 self.bit(true)
1510 }
1511 #[doc = r" Clears the field bit"]
1512 pub fn clear_bit(self) -> &'a mut W {
1513 self.bit(false)
1514 }
1515 #[doc = r" Writes raw bits to the field"]
1516 #[inline]
1517 pub fn bit(self, value: bool) -> &'a mut W {
1518 const MASK: bool = true;
1519 const OFFSET: u8 = 25;
1520 self.w.bits &= !((MASK as u32) << OFFSET);
1521 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1522 self.w
1523 }
1524}
1525#[doc = "Values that can be written to the field `PTSO26`"]
1526pub enum PTSO26W {
1527 #[doc = "Corresponding bit in PDORn does not change."]
1528 _0,
1529 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1530 _1,
1531}
1532impl PTSO26W {
1533 #[allow(missing_docs)]
1534 #[doc(hidden)]
1535 #[inline]
1536 pub fn _bits(&self) -> bool {
1537 match *self {
1538 PTSO26W::_0 => false,
1539 PTSO26W::_1 => true,
1540 }
1541 }
1542}
1543#[doc = r" Proxy"]
1544pub struct _PTSO26W<'a> {
1545 w: &'a mut W,
1546}
1547impl<'a> _PTSO26W<'a> {
1548 #[doc = r" Writes `variant` to the field"]
1549 #[inline]
1550 pub fn variant(self, variant: PTSO26W) -> &'a mut W {
1551 {
1552 self.bit(variant._bits())
1553 }
1554 }
1555 #[doc = "Corresponding bit in PDORn does not change."]
1556 #[inline]
1557 pub fn _0(self) -> &'a mut W {
1558 self.variant(PTSO26W::_0)
1559 }
1560 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1561 #[inline]
1562 pub fn _1(self) -> &'a mut W {
1563 self.variant(PTSO26W::_1)
1564 }
1565 #[doc = r" Sets the field bit"]
1566 pub fn set_bit(self) -> &'a mut W {
1567 self.bit(true)
1568 }
1569 #[doc = r" Clears the field bit"]
1570 pub fn clear_bit(self) -> &'a mut W {
1571 self.bit(false)
1572 }
1573 #[doc = r" Writes raw bits to the field"]
1574 #[inline]
1575 pub fn bit(self, value: bool) -> &'a mut W {
1576 const MASK: bool = true;
1577 const OFFSET: u8 = 26;
1578 self.w.bits &= !((MASK as u32) << OFFSET);
1579 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1580 self.w
1581 }
1582}
1583#[doc = "Values that can be written to the field `PTSO27`"]
1584pub enum PTSO27W {
1585 #[doc = "Corresponding bit in PDORn does not change."]
1586 _0,
1587 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1588 _1,
1589}
1590impl PTSO27W {
1591 #[allow(missing_docs)]
1592 #[doc(hidden)]
1593 #[inline]
1594 pub fn _bits(&self) -> bool {
1595 match *self {
1596 PTSO27W::_0 => false,
1597 PTSO27W::_1 => true,
1598 }
1599 }
1600}
1601#[doc = r" Proxy"]
1602pub struct _PTSO27W<'a> {
1603 w: &'a mut W,
1604}
1605impl<'a> _PTSO27W<'a> {
1606 #[doc = r" Writes `variant` to the field"]
1607 #[inline]
1608 pub fn variant(self, variant: PTSO27W) -> &'a mut W {
1609 {
1610 self.bit(variant._bits())
1611 }
1612 }
1613 #[doc = "Corresponding bit in PDORn does not change."]
1614 #[inline]
1615 pub fn _0(self) -> &'a mut W {
1616 self.variant(PTSO27W::_0)
1617 }
1618 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1619 #[inline]
1620 pub fn _1(self) -> &'a mut W {
1621 self.variant(PTSO27W::_1)
1622 }
1623 #[doc = r" Sets the field bit"]
1624 pub fn set_bit(self) -> &'a mut W {
1625 self.bit(true)
1626 }
1627 #[doc = r" Clears the field bit"]
1628 pub fn clear_bit(self) -> &'a mut W {
1629 self.bit(false)
1630 }
1631 #[doc = r" Writes raw bits to the field"]
1632 #[inline]
1633 pub fn bit(self, value: bool) -> &'a mut W {
1634 const MASK: bool = true;
1635 const OFFSET: u8 = 27;
1636 self.w.bits &= !((MASK as u32) << OFFSET);
1637 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1638 self.w
1639 }
1640}
1641#[doc = "Values that can be written to the field `PTSO28`"]
1642pub enum PTSO28W {
1643 #[doc = "Corresponding bit in PDORn does not change."]
1644 _0,
1645 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1646 _1,
1647}
1648impl PTSO28W {
1649 #[allow(missing_docs)]
1650 #[doc(hidden)]
1651 #[inline]
1652 pub fn _bits(&self) -> bool {
1653 match *self {
1654 PTSO28W::_0 => false,
1655 PTSO28W::_1 => true,
1656 }
1657 }
1658}
1659#[doc = r" Proxy"]
1660pub struct _PTSO28W<'a> {
1661 w: &'a mut W,
1662}
1663impl<'a> _PTSO28W<'a> {
1664 #[doc = r" Writes `variant` to the field"]
1665 #[inline]
1666 pub fn variant(self, variant: PTSO28W) -> &'a mut W {
1667 {
1668 self.bit(variant._bits())
1669 }
1670 }
1671 #[doc = "Corresponding bit in PDORn does not change."]
1672 #[inline]
1673 pub fn _0(self) -> &'a mut W {
1674 self.variant(PTSO28W::_0)
1675 }
1676 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1677 #[inline]
1678 pub fn _1(self) -> &'a mut W {
1679 self.variant(PTSO28W::_1)
1680 }
1681 #[doc = r" Sets the field bit"]
1682 pub fn set_bit(self) -> &'a mut W {
1683 self.bit(true)
1684 }
1685 #[doc = r" Clears the field bit"]
1686 pub fn clear_bit(self) -> &'a mut W {
1687 self.bit(false)
1688 }
1689 #[doc = r" Writes raw bits to the field"]
1690 #[inline]
1691 pub fn bit(self, value: bool) -> &'a mut W {
1692 const MASK: bool = true;
1693 const OFFSET: u8 = 28;
1694 self.w.bits &= !((MASK as u32) << OFFSET);
1695 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1696 self.w
1697 }
1698}
1699#[doc = "Values that can be written to the field `PTSO29`"]
1700pub enum PTSO29W {
1701 #[doc = "Corresponding bit in PDORn does not change."]
1702 _0,
1703 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1704 _1,
1705}
1706impl PTSO29W {
1707 #[allow(missing_docs)]
1708 #[doc(hidden)]
1709 #[inline]
1710 pub fn _bits(&self) -> bool {
1711 match *self {
1712 PTSO29W::_0 => false,
1713 PTSO29W::_1 => true,
1714 }
1715 }
1716}
1717#[doc = r" Proxy"]
1718pub struct _PTSO29W<'a> {
1719 w: &'a mut W,
1720}
1721impl<'a> _PTSO29W<'a> {
1722 #[doc = r" Writes `variant` to the field"]
1723 #[inline]
1724 pub fn variant(self, variant: PTSO29W) -> &'a mut W {
1725 {
1726 self.bit(variant._bits())
1727 }
1728 }
1729 #[doc = "Corresponding bit in PDORn does not change."]
1730 #[inline]
1731 pub fn _0(self) -> &'a mut W {
1732 self.variant(PTSO29W::_0)
1733 }
1734 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1735 #[inline]
1736 pub fn _1(self) -> &'a mut W {
1737 self.variant(PTSO29W::_1)
1738 }
1739 #[doc = r" Sets the field bit"]
1740 pub fn set_bit(self) -> &'a mut W {
1741 self.bit(true)
1742 }
1743 #[doc = r" Clears the field bit"]
1744 pub fn clear_bit(self) -> &'a mut W {
1745 self.bit(false)
1746 }
1747 #[doc = r" Writes raw bits to the field"]
1748 #[inline]
1749 pub fn bit(self, value: bool) -> &'a mut W {
1750 const MASK: bool = true;
1751 const OFFSET: u8 = 29;
1752 self.w.bits &= !((MASK as u32) << OFFSET);
1753 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1754 self.w
1755 }
1756}
1757#[doc = "Values that can be written to the field `PTSO30`"]
1758pub enum PTSO30W {
1759 #[doc = "Corresponding bit in PDORn does not change."]
1760 _0,
1761 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1762 _1,
1763}
1764impl PTSO30W {
1765 #[allow(missing_docs)]
1766 #[doc(hidden)]
1767 #[inline]
1768 pub fn _bits(&self) -> bool {
1769 match *self {
1770 PTSO30W::_0 => false,
1771 PTSO30W::_1 => true,
1772 }
1773 }
1774}
1775#[doc = r" Proxy"]
1776pub struct _PTSO30W<'a> {
1777 w: &'a mut W,
1778}
1779impl<'a> _PTSO30W<'a> {
1780 #[doc = r" Writes `variant` to the field"]
1781 #[inline]
1782 pub fn variant(self, variant: PTSO30W) -> &'a mut W {
1783 {
1784 self.bit(variant._bits())
1785 }
1786 }
1787 #[doc = "Corresponding bit in PDORn does not change."]
1788 #[inline]
1789 pub fn _0(self) -> &'a mut W {
1790 self.variant(PTSO30W::_0)
1791 }
1792 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1793 #[inline]
1794 pub fn _1(self) -> &'a mut W {
1795 self.variant(PTSO30W::_1)
1796 }
1797 #[doc = r" Sets the field bit"]
1798 pub fn set_bit(self) -> &'a mut W {
1799 self.bit(true)
1800 }
1801 #[doc = r" Clears the field bit"]
1802 pub fn clear_bit(self) -> &'a mut W {
1803 self.bit(false)
1804 }
1805 #[doc = r" Writes raw bits to the field"]
1806 #[inline]
1807 pub fn bit(self, value: bool) -> &'a mut W {
1808 const MASK: bool = true;
1809 const OFFSET: u8 = 30;
1810 self.w.bits &= !((MASK as u32) << OFFSET);
1811 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1812 self.w
1813 }
1814}
1815#[doc = "Values that can be written to the field `PTSO31`"]
1816pub enum PTSO31W {
1817 #[doc = "Corresponding bit in PDORn does not change."]
1818 _0,
1819 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1820 _1,
1821}
1822impl PTSO31W {
1823 #[allow(missing_docs)]
1824 #[doc(hidden)]
1825 #[inline]
1826 pub fn _bits(&self) -> bool {
1827 match *self {
1828 PTSO31W::_0 => false,
1829 PTSO31W::_1 => true,
1830 }
1831 }
1832}
1833#[doc = r" Proxy"]
1834pub struct _PTSO31W<'a> {
1835 w: &'a mut W,
1836}
1837impl<'a> _PTSO31W<'a> {
1838 #[doc = r" Writes `variant` to the field"]
1839 #[inline]
1840 pub fn variant(self, variant: PTSO31W) -> &'a mut W {
1841 {
1842 self.bit(variant._bits())
1843 }
1844 }
1845 #[doc = "Corresponding bit in PDORn does not change."]
1846 #[inline]
1847 pub fn _0(self) -> &'a mut W {
1848 self.variant(PTSO31W::_0)
1849 }
1850 #[doc = "Corresponding bit in PDORn is set to logic 1."]
1851 #[inline]
1852 pub fn _1(self) -> &'a mut W {
1853 self.variant(PTSO31W::_1)
1854 }
1855 #[doc = r" Sets the field bit"]
1856 pub fn set_bit(self) -> &'a mut W {
1857 self.bit(true)
1858 }
1859 #[doc = r" Clears the field bit"]
1860 pub fn clear_bit(self) -> &'a mut W {
1861 self.bit(false)
1862 }
1863 #[doc = r" Writes raw bits to the field"]
1864 #[inline]
1865 pub fn bit(self, value: bool) -> &'a mut W {
1866 const MASK: bool = true;
1867 const OFFSET: u8 = 31;
1868 self.w.bits &= !((MASK as u32) << OFFSET);
1869 self.w.bits |= ((value & MASK) as u32) << OFFSET;
1870 self.w
1871 }
1872}
1873impl W {
1874 #[doc = r" Reset value of the register"]
1875 #[inline]
1876 pub fn reset_value() -> W {
1877 W { bits: 0 }
1878 }
1879 #[doc = r" Writes raw bits to the register"]
1880 #[inline]
1881 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1882 self.bits = bits;
1883 self
1884 }
1885 #[doc = "Bit 0 - Port Set Output"]
1886 #[inline]
1887 pub fn ptso0(&mut self) -> _PTSO0W {
1888 _PTSO0W { w: self }
1889 }
1890 #[doc = "Bit 1 - Port Set Output"]
1891 #[inline]
1892 pub fn ptso1(&mut self) -> _PTSO1W {
1893 _PTSO1W { w: self }
1894 }
1895 #[doc = "Bit 2 - Port Set Output"]
1896 #[inline]
1897 pub fn ptso2(&mut self) -> _PTSO2W {
1898 _PTSO2W { w: self }
1899 }
1900 #[doc = "Bit 3 - Port Set Output"]
1901 #[inline]
1902 pub fn ptso3(&mut self) -> _PTSO3W {
1903 _PTSO3W { w: self }
1904 }
1905 #[doc = "Bit 4 - Port Set Output"]
1906 #[inline]
1907 pub fn ptso4(&mut self) -> _PTSO4W {
1908 _PTSO4W { w: self }
1909 }
1910 #[doc = "Bit 5 - Port Set Output"]
1911 #[inline]
1912 pub fn ptso5(&mut self) -> _PTSO5W {
1913 _PTSO5W { w: self }
1914 }
1915 #[doc = "Bit 6 - Port Set Output"]
1916 #[inline]
1917 pub fn ptso6(&mut self) -> _PTSO6W {
1918 _PTSO6W { w: self }
1919 }
1920 #[doc = "Bit 7 - Port Set Output"]
1921 #[inline]
1922 pub fn ptso7(&mut self) -> _PTSO7W {
1923 _PTSO7W { w: self }
1924 }
1925 #[doc = "Bit 8 - Port Set Output"]
1926 #[inline]
1927 pub fn ptso8(&mut self) -> _PTSO8W {
1928 _PTSO8W { w: self }
1929 }
1930 #[doc = "Bit 9 - Port Set Output"]
1931 #[inline]
1932 pub fn ptso9(&mut self) -> _PTSO9W {
1933 _PTSO9W { w: self }
1934 }
1935 #[doc = "Bit 10 - Port Set Output"]
1936 #[inline]
1937 pub fn ptso10(&mut self) -> _PTSO10W {
1938 _PTSO10W { w: self }
1939 }
1940 #[doc = "Bit 11 - Port Set Output"]
1941 #[inline]
1942 pub fn ptso11(&mut self) -> _PTSO11W {
1943 _PTSO11W { w: self }
1944 }
1945 #[doc = "Bit 12 - Port Set Output"]
1946 #[inline]
1947 pub fn ptso12(&mut self) -> _PTSO12W {
1948 _PTSO12W { w: self }
1949 }
1950 #[doc = "Bit 13 - Port Set Output"]
1951 #[inline]
1952 pub fn ptso13(&mut self) -> _PTSO13W {
1953 _PTSO13W { w: self }
1954 }
1955 #[doc = "Bit 14 - Port Set Output"]
1956 #[inline]
1957 pub fn ptso14(&mut self) -> _PTSO14W {
1958 _PTSO14W { w: self }
1959 }
1960 #[doc = "Bit 15 - Port Set Output"]
1961 #[inline]
1962 pub fn ptso15(&mut self) -> _PTSO15W {
1963 _PTSO15W { w: self }
1964 }
1965 #[doc = "Bit 16 - Port Set Output"]
1966 #[inline]
1967 pub fn ptso16(&mut self) -> _PTSO16W {
1968 _PTSO16W { w: self }
1969 }
1970 #[doc = "Bit 17 - Port Set Output"]
1971 #[inline]
1972 pub fn ptso17(&mut self) -> _PTSO17W {
1973 _PTSO17W { w: self }
1974 }
1975 #[doc = "Bit 18 - Port Set Output"]
1976 #[inline]
1977 pub fn ptso18(&mut self) -> _PTSO18W {
1978 _PTSO18W { w: self }
1979 }
1980 #[doc = "Bit 19 - Port Set Output"]
1981 #[inline]
1982 pub fn ptso19(&mut self) -> _PTSO19W {
1983 _PTSO19W { w: self }
1984 }
1985 #[doc = "Bit 20 - Port Set Output"]
1986 #[inline]
1987 pub fn ptso20(&mut self) -> _PTSO20W {
1988 _PTSO20W { w: self }
1989 }
1990 #[doc = "Bit 21 - Port Set Output"]
1991 #[inline]
1992 pub fn ptso21(&mut self) -> _PTSO21W {
1993 _PTSO21W { w: self }
1994 }
1995 #[doc = "Bit 22 - Port Set Output"]
1996 #[inline]
1997 pub fn ptso22(&mut self) -> _PTSO22W {
1998 _PTSO22W { w: self }
1999 }
2000 #[doc = "Bit 23 - Port Set Output"]
2001 #[inline]
2002 pub fn ptso23(&mut self) -> _PTSO23W {
2003 _PTSO23W { w: self }
2004 }
2005 #[doc = "Bit 24 - Port Set Output"]
2006 #[inline]
2007 pub fn ptso24(&mut self) -> _PTSO24W {
2008 _PTSO24W { w: self }
2009 }
2010 #[doc = "Bit 25 - Port Set Output"]
2011 #[inline]
2012 pub fn ptso25(&mut self) -> _PTSO25W {
2013 _PTSO25W { w: self }
2014 }
2015 #[doc = "Bit 26 - Port Set Output"]
2016 #[inline]
2017 pub fn ptso26(&mut self) -> _PTSO26W {
2018 _PTSO26W { w: self }
2019 }
2020 #[doc = "Bit 27 - Port Set Output"]
2021 #[inline]
2022 pub fn ptso27(&mut self) -> _PTSO27W {
2023 _PTSO27W { w: self }
2024 }
2025 #[doc = "Bit 28 - Port Set Output"]
2026 #[inline]
2027 pub fn ptso28(&mut self) -> _PTSO28W {
2028 _PTSO28W { w: self }
2029 }
2030 #[doc = "Bit 29 - Port Set Output"]
2031 #[inline]
2032 pub fn ptso29(&mut self) -> _PTSO29W {
2033 _PTSO29W { w: self }
2034 }
2035 #[doc = "Bit 30 - Port Set Output"]
2036 #[inline]
2037 pub fn ptso30(&mut self) -> _PTSO30W {
2038 _PTSO30W { w: self }
2039 }
2040 #[doc = "Bit 31 - Port Set Output"]
2041 #[inline]
2042 pub fn ptso31(&mut self) -> _PTSO31W {
2043 _PTSO31W { w: self }
2044 }
2045}