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