1#[doc = r" Value read from the register"]
2pub struct R {
3 bits: u16,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7 bits: u16,
8}
9impl super::PIPC8 {
10 #[doc = r" Modifies the contents of the register"]
11 #[inline]
12 pub fn modify<F>(&self, f: F)
13 where
14 for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15 {
16 let bits = self.register.get();
17 let r = R { bits: bits };
18 let mut w = W { bits: bits };
19 f(&r, &mut w);
20 self.register.set(w.bits);
21 }
22 #[doc = r" Reads the contents of the register"]
23 #[inline]
24 pub fn read(&self) -> R {
25 R {
26 bits: self.register.get(),
27 }
28 }
29 #[doc = r" Writes to the register"]
30 #[inline]
31 pub fn write<F>(&self, f: F)
32 where
33 F: FnOnce(&mut W) -> &mut W,
34 {
35 let mut w = W::reset_value();
36 f(&mut w);
37 self.register.set(w.bits);
38 }
39 #[doc = r" Writes the reset value to the register"]
40 #[inline]
41 pub fn reset(&self) {
42 self.write(|w| w)
43 }
44}
45#[doc = r" Value of the field"]
46pub struct PIPC80R {
47 bits: bool,
48}
49impl PIPC80R {
50 #[doc = r" Value of the field as raw bits"]
51 #[inline]
52 pub fn bit(&self) -> bool {
53 self.bits
54 }
55 #[doc = r" Returns `true` if the bit is clear (0)"]
56 #[inline]
57 pub fn bit_is_clear(&self) -> bool {
58 !self.bit()
59 }
60 #[doc = r" Returns `true` if the bit is set (1)"]
61 #[inline]
62 pub fn bit_is_set(&self) -> bool {
63 self.bit()
64 }
65}
66#[doc = r" Value of the field"]
67pub struct PIPC81R {
68 bits: bool,
69}
70impl PIPC81R {
71 #[doc = r" Value of the field as raw bits"]
72 #[inline]
73 pub fn bit(&self) -> bool {
74 self.bits
75 }
76 #[doc = r" Returns `true` if the bit is clear (0)"]
77 #[inline]
78 pub fn bit_is_clear(&self) -> bool {
79 !self.bit()
80 }
81 #[doc = r" Returns `true` if the bit is set (1)"]
82 #[inline]
83 pub fn bit_is_set(&self) -> bool {
84 self.bit()
85 }
86}
87#[doc = r" Value of the field"]
88pub struct PIPC82R {
89 bits: bool,
90}
91impl PIPC82R {
92 #[doc = r" Value of the field as raw bits"]
93 #[inline]
94 pub fn bit(&self) -> bool {
95 self.bits
96 }
97 #[doc = r" Returns `true` if the bit is clear (0)"]
98 #[inline]
99 pub fn bit_is_clear(&self) -> bool {
100 !self.bit()
101 }
102 #[doc = r" Returns `true` if the bit is set (1)"]
103 #[inline]
104 pub fn bit_is_set(&self) -> bool {
105 self.bit()
106 }
107}
108#[doc = r" Value of the field"]
109pub struct PIPC83R {
110 bits: bool,
111}
112impl PIPC83R {
113 #[doc = r" Value of the field as raw bits"]
114 #[inline]
115 pub fn bit(&self) -> bool {
116 self.bits
117 }
118 #[doc = r" Returns `true` if the bit is clear (0)"]
119 #[inline]
120 pub fn bit_is_clear(&self) -> bool {
121 !self.bit()
122 }
123 #[doc = r" Returns `true` if the bit is set (1)"]
124 #[inline]
125 pub fn bit_is_set(&self) -> bool {
126 self.bit()
127 }
128}
129#[doc = r" Value of the field"]
130pub struct PIPC84R {
131 bits: bool,
132}
133impl PIPC84R {
134 #[doc = r" Value of the field as raw bits"]
135 #[inline]
136 pub fn bit(&self) -> bool {
137 self.bits
138 }
139 #[doc = r" Returns `true` if the bit is clear (0)"]
140 #[inline]
141 pub fn bit_is_clear(&self) -> bool {
142 !self.bit()
143 }
144 #[doc = r" Returns `true` if the bit is set (1)"]
145 #[inline]
146 pub fn bit_is_set(&self) -> bool {
147 self.bit()
148 }
149}
150#[doc = r" Value of the field"]
151pub struct PIPC85R {
152 bits: bool,
153}
154impl PIPC85R {
155 #[doc = r" Value of the field as raw bits"]
156 #[inline]
157 pub fn bit(&self) -> bool {
158 self.bits
159 }
160 #[doc = r" Returns `true` if the bit is clear (0)"]
161 #[inline]
162 pub fn bit_is_clear(&self) -> bool {
163 !self.bit()
164 }
165 #[doc = r" Returns `true` if the bit is set (1)"]
166 #[inline]
167 pub fn bit_is_set(&self) -> bool {
168 self.bit()
169 }
170}
171#[doc = r" Value of the field"]
172pub struct PIPC86R {
173 bits: bool,
174}
175impl PIPC86R {
176 #[doc = r" Value of the field as raw bits"]
177 #[inline]
178 pub fn bit(&self) -> bool {
179 self.bits
180 }
181 #[doc = r" Returns `true` if the bit is clear (0)"]
182 #[inline]
183 pub fn bit_is_clear(&self) -> bool {
184 !self.bit()
185 }
186 #[doc = r" Returns `true` if the bit is set (1)"]
187 #[inline]
188 pub fn bit_is_set(&self) -> bool {
189 self.bit()
190 }
191}
192#[doc = r" Value of the field"]
193pub struct PIPC87R {
194 bits: bool,
195}
196impl PIPC87R {
197 #[doc = r" Value of the field as raw bits"]
198 #[inline]
199 pub fn bit(&self) -> bool {
200 self.bits
201 }
202 #[doc = r" Returns `true` if the bit is clear (0)"]
203 #[inline]
204 pub fn bit_is_clear(&self) -> bool {
205 !self.bit()
206 }
207 #[doc = r" Returns `true` if the bit is set (1)"]
208 #[inline]
209 pub fn bit_is_set(&self) -> bool {
210 self.bit()
211 }
212}
213#[doc = r" Value of the field"]
214pub struct PIPC88R {
215 bits: bool,
216}
217impl PIPC88R {
218 #[doc = r" Value of the field as raw bits"]
219 #[inline]
220 pub fn bit(&self) -> bool {
221 self.bits
222 }
223 #[doc = r" Returns `true` if the bit is clear (0)"]
224 #[inline]
225 pub fn bit_is_clear(&self) -> bool {
226 !self.bit()
227 }
228 #[doc = r" Returns `true` if the bit is set (1)"]
229 #[inline]
230 pub fn bit_is_set(&self) -> bool {
231 self.bit()
232 }
233}
234#[doc = r" Value of the field"]
235pub struct PIPC89R {
236 bits: bool,
237}
238impl PIPC89R {
239 #[doc = r" Value of the field as raw bits"]
240 #[inline]
241 pub fn bit(&self) -> bool {
242 self.bits
243 }
244 #[doc = r" Returns `true` if the bit is clear (0)"]
245 #[inline]
246 pub fn bit_is_clear(&self) -> bool {
247 !self.bit()
248 }
249 #[doc = r" Returns `true` if the bit is set (1)"]
250 #[inline]
251 pub fn bit_is_set(&self) -> bool {
252 self.bit()
253 }
254}
255#[doc = r" Value of the field"]
256pub struct PIPC810R {
257 bits: bool,
258}
259impl PIPC810R {
260 #[doc = r" Value of the field as raw bits"]
261 #[inline]
262 pub fn bit(&self) -> bool {
263 self.bits
264 }
265 #[doc = r" Returns `true` if the bit is clear (0)"]
266 #[inline]
267 pub fn bit_is_clear(&self) -> bool {
268 !self.bit()
269 }
270 #[doc = r" Returns `true` if the bit is set (1)"]
271 #[inline]
272 pub fn bit_is_set(&self) -> bool {
273 self.bit()
274 }
275}
276#[doc = r" Value of the field"]
277pub struct PIPC811R {
278 bits: bool,
279}
280impl PIPC811R {
281 #[doc = r" Value of the field as raw bits"]
282 #[inline]
283 pub fn bit(&self) -> bool {
284 self.bits
285 }
286 #[doc = r" Returns `true` if the bit is clear (0)"]
287 #[inline]
288 pub fn bit_is_clear(&self) -> bool {
289 !self.bit()
290 }
291 #[doc = r" Returns `true` if the bit is set (1)"]
292 #[inline]
293 pub fn bit_is_set(&self) -> bool {
294 self.bit()
295 }
296}
297#[doc = r" Value of the field"]
298pub struct PIPC812R {
299 bits: bool,
300}
301impl PIPC812R {
302 #[doc = r" Value of the field as raw bits"]
303 #[inline]
304 pub fn bit(&self) -> bool {
305 self.bits
306 }
307 #[doc = r" Returns `true` if the bit is clear (0)"]
308 #[inline]
309 pub fn bit_is_clear(&self) -> bool {
310 !self.bit()
311 }
312 #[doc = r" Returns `true` if the bit is set (1)"]
313 #[inline]
314 pub fn bit_is_set(&self) -> bool {
315 self.bit()
316 }
317}
318#[doc = r" Value of the field"]
319pub struct PIPC813R {
320 bits: bool,
321}
322impl PIPC813R {
323 #[doc = r" Value of the field as raw bits"]
324 #[inline]
325 pub fn bit(&self) -> bool {
326 self.bits
327 }
328 #[doc = r" Returns `true` if the bit is clear (0)"]
329 #[inline]
330 pub fn bit_is_clear(&self) -> bool {
331 !self.bit()
332 }
333 #[doc = r" Returns `true` if the bit is set (1)"]
334 #[inline]
335 pub fn bit_is_set(&self) -> bool {
336 self.bit()
337 }
338}
339#[doc = r" Value of the field"]
340pub struct PIPC814R {
341 bits: bool,
342}
343impl PIPC814R {
344 #[doc = r" Value of the field as raw bits"]
345 #[inline]
346 pub fn bit(&self) -> bool {
347 self.bits
348 }
349 #[doc = r" Returns `true` if the bit is clear (0)"]
350 #[inline]
351 pub fn bit_is_clear(&self) -> bool {
352 !self.bit()
353 }
354 #[doc = r" Returns `true` if the bit is set (1)"]
355 #[inline]
356 pub fn bit_is_set(&self) -> bool {
357 self.bit()
358 }
359}
360#[doc = r" Value of the field"]
361pub struct PIPC815R {
362 bits: bool,
363}
364impl PIPC815R {
365 #[doc = r" Value of the field as raw bits"]
366 #[inline]
367 pub fn bit(&self) -> bool {
368 self.bits
369 }
370 #[doc = r" Returns `true` if the bit is clear (0)"]
371 #[inline]
372 pub fn bit_is_clear(&self) -> bool {
373 !self.bit()
374 }
375 #[doc = r" Returns `true` if the bit is set (1)"]
376 #[inline]
377 pub fn bit_is_set(&self) -> bool {
378 self.bit()
379 }
380}
381#[doc = r" Proxy"]
382pub struct _PIPC80W<'a> {
383 w: &'a mut W,
384}
385impl<'a> _PIPC80W<'a> {
386 #[doc = r" Sets the field bit"]
387 pub fn set_bit(self) -> &'a mut W {
388 self.bit(true)
389 }
390 #[doc = r" Clears the field bit"]
391 pub fn clear_bit(self) -> &'a mut W {
392 self.bit(false)
393 }
394 #[doc = r" Writes raw bits to the field"]
395 #[inline]
396 pub fn bit(self, value: bool) -> &'a mut W {
397 const MASK: bool = true;
398 const OFFSET: u8 = 0;
399 self.w.bits &= !((MASK as u16) << OFFSET);
400 self.w.bits |= ((value & MASK) as u16) << OFFSET;
401 self.w
402 }
403}
404#[doc = r" Proxy"]
405pub struct _PIPC81W<'a> {
406 w: &'a mut W,
407}
408impl<'a> _PIPC81W<'a> {
409 #[doc = r" Sets the field bit"]
410 pub fn set_bit(self) -> &'a mut W {
411 self.bit(true)
412 }
413 #[doc = r" Clears the field bit"]
414 pub fn clear_bit(self) -> &'a mut W {
415 self.bit(false)
416 }
417 #[doc = r" Writes raw bits to the field"]
418 #[inline]
419 pub fn bit(self, value: bool) -> &'a mut W {
420 const MASK: bool = true;
421 const OFFSET: u8 = 1;
422 self.w.bits &= !((MASK as u16) << OFFSET);
423 self.w.bits |= ((value & MASK) as u16) << OFFSET;
424 self.w
425 }
426}
427#[doc = r" Proxy"]
428pub struct _PIPC82W<'a> {
429 w: &'a mut W,
430}
431impl<'a> _PIPC82W<'a> {
432 #[doc = r" Sets the field bit"]
433 pub fn set_bit(self) -> &'a mut W {
434 self.bit(true)
435 }
436 #[doc = r" Clears the field bit"]
437 pub fn clear_bit(self) -> &'a mut W {
438 self.bit(false)
439 }
440 #[doc = r" Writes raw bits to the field"]
441 #[inline]
442 pub fn bit(self, value: bool) -> &'a mut W {
443 const MASK: bool = true;
444 const OFFSET: u8 = 2;
445 self.w.bits &= !((MASK as u16) << OFFSET);
446 self.w.bits |= ((value & MASK) as u16) << OFFSET;
447 self.w
448 }
449}
450#[doc = r" Proxy"]
451pub struct _PIPC83W<'a> {
452 w: &'a mut W,
453}
454impl<'a> _PIPC83W<'a> {
455 #[doc = r" Sets the field bit"]
456 pub fn set_bit(self) -> &'a mut W {
457 self.bit(true)
458 }
459 #[doc = r" Clears the field bit"]
460 pub fn clear_bit(self) -> &'a mut W {
461 self.bit(false)
462 }
463 #[doc = r" Writes raw bits to the field"]
464 #[inline]
465 pub fn bit(self, value: bool) -> &'a mut W {
466 const MASK: bool = true;
467 const OFFSET: u8 = 3;
468 self.w.bits &= !((MASK as u16) << OFFSET);
469 self.w.bits |= ((value & MASK) as u16) << OFFSET;
470 self.w
471 }
472}
473#[doc = r" Proxy"]
474pub struct _PIPC84W<'a> {
475 w: &'a mut W,
476}
477impl<'a> _PIPC84W<'a> {
478 #[doc = r" Sets the field bit"]
479 pub fn set_bit(self) -> &'a mut W {
480 self.bit(true)
481 }
482 #[doc = r" Clears the field bit"]
483 pub fn clear_bit(self) -> &'a mut W {
484 self.bit(false)
485 }
486 #[doc = r" Writes raw bits to the field"]
487 #[inline]
488 pub fn bit(self, value: bool) -> &'a mut W {
489 const MASK: bool = true;
490 const OFFSET: u8 = 4;
491 self.w.bits &= !((MASK as u16) << OFFSET);
492 self.w.bits |= ((value & MASK) as u16) << OFFSET;
493 self.w
494 }
495}
496#[doc = r" Proxy"]
497pub struct _PIPC85W<'a> {
498 w: &'a mut W,
499}
500impl<'a> _PIPC85W<'a> {
501 #[doc = r" Sets the field bit"]
502 pub fn set_bit(self) -> &'a mut W {
503 self.bit(true)
504 }
505 #[doc = r" Clears the field bit"]
506 pub fn clear_bit(self) -> &'a mut W {
507 self.bit(false)
508 }
509 #[doc = r" Writes raw bits to the field"]
510 #[inline]
511 pub fn bit(self, value: bool) -> &'a mut W {
512 const MASK: bool = true;
513 const OFFSET: u8 = 5;
514 self.w.bits &= !((MASK as u16) << OFFSET);
515 self.w.bits |= ((value & MASK) as u16) << OFFSET;
516 self.w
517 }
518}
519#[doc = r" Proxy"]
520pub struct _PIPC86W<'a> {
521 w: &'a mut W,
522}
523impl<'a> _PIPC86W<'a> {
524 #[doc = r" Sets the field bit"]
525 pub fn set_bit(self) -> &'a mut W {
526 self.bit(true)
527 }
528 #[doc = r" Clears the field bit"]
529 pub fn clear_bit(self) -> &'a mut W {
530 self.bit(false)
531 }
532 #[doc = r" Writes raw bits to the field"]
533 #[inline]
534 pub fn bit(self, value: bool) -> &'a mut W {
535 const MASK: bool = true;
536 const OFFSET: u8 = 6;
537 self.w.bits &= !((MASK as u16) << OFFSET);
538 self.w.bits |= ((value & MASK) as u16) << OFFSET;
539 self.w
540 }
541}
542#[doc = r" Proxy"]
543pub struct _PIPC87W<'a> {
544 w: &'a mut W,
545}
546impl<'a> _PIPC87W<'a> {
547 #[doc = r" Sets the field bit"]
548 pub fn set_bit(self) -> &'a mut W {
549 self.bit(true)
550 }
551 #[doc = r" Clears the field bit"]
552 pub fn clear_bit(self) -> &'a mut W {
553 self.bit(false)
554 }
555 #[doc = r" Writes raw bits to the field"]
556 #[inline]
557 pub fn bit(self, value: bool) -> &'a mut W {
558 const MASK: bool = true;
559 const OFFSET: u8 = 7;
560 self.w.bits &= !((MASK as u16) << OFFSET);
561 self.w.bits |= ((value & MASK) as u16) << OFFSET;
562 self.w
563 }
564}
565#[doc = r" Proxy"]
566pub struct _PIPC88W<'a> {
567 w: &'a mut W,
568}
569impl<'a> _PIPC88W<'a> {
570 #[doc = r" Sets the field bit"]
571 pub fn set_bit(self) -> &'a mut W {
572 self.bit(true)
573 }
574 #[doc = r" Clears the field bit"]
575 pub fn clear_bit(self) -> &'a mut W {
576 self.bit(false)
577 }
578 #[doc = r" Writes raw bits to the field"]
579 #[inline]
580 pub fn bit(self, value: bool) -> &'a mut W {
581 const MASK: bool = true;
582 const OFFSET: u8 = 8;
583 self.w.bits &= !((MASK as u16) << OFFSET);
584 self.w.bits |= ((value & MASK) as u16) << OFFSET;
585 self.w
586 }
587}
588#[doc = r" Proxy"]
589pub struct _PIPC89W<'a> {
590 w: &'a mut W,
591}
592impl<'a> _PIPC89W<'a> {
593 #[doc = r" Sets the field bit"]
594 pub fn set_bit(self) -> &'a mut W {
595 self.bit(true)
596 }
597 #[doc = r" Clears the field bit"]
598 pub fn clear_bit(self) -> &'a mut W {
599 self.bit(false)
600 }
601 #[doc = r" Writes raw bits to the field"]
602 #[inline]
603 pub fn bit(self, value: bool) -> &'a mut W {
604 const MASK: bool = true;
605 const OFFSET: u8 = 9;
606 self.w.bits &= !((MASK as u16) << OFFSET);
607 self.w.bits |= ((value & MASK) as u16) << OFFSET;
608 self.w
609 }
610}
611#[doc = r" Proxy"]
612pub struct _PIPC810W<'a> {
613 w: &'a mut W,
614}
615impl<'a> _PIPC810W<'a> {
616 #[doc = r" Sets the field bit"]
617 pub fn set_bit(self) -> &'a mut W {
618 self.bit(true)
619 }
620 #[doc = r" Clears the field bit"]
621 pub fn clear_bit(self) -> &'a mut W {
622 self.bit(false)
623 }
624 #[doc = r" Writes raw bits to the field"]
625 #[inline]
626 pub fn bit(self, value: bool) -> &'a mut W {
627 const MASK: bool = true;
628 const OFFSET: u8 = 10;
629 self.w.bits &= !((MASK as u16) << OFFSET);
630 self.w.bits |= ((value & MASK) as u16) << OFFSET;
631 self.w
632 }
633}
634#[doc = r" Proxy"]
635pub struct _PIPC811W<'a> {
636 w: &'a mut W,
637}
638impl<'a> _PIPC811W<'a> {
639 #[doc = r" Sets the field bit"]
640 pub fn set_bit(self) -> &'a mut W {
641 self.bit(true)
642 }
643 #[doc = r" Clears the field bit"]
644 pub fn clear_bit(self) -> &'a mut W {
645 self.bit(false)
646 }
647 #[doc = r" Writes raw bits to the field"]
648 #[inline]
649 pub fn bit(self, value: bool) -> &'a mut W {
650 const MASK: bool = true;
651 const OFFSET: u8 = 11;
652 self.w.bits &= !((MASK as u16) << OFFSET);
653 self.w.bits |= ((value & MASK) as u16) << OFFSET;
654 self.w
655 }
656}
657#[doc = r" Proxy"]
658pub struct _PIPC812W<'a> {
659 w: &'a mut W,
660}
661impl<'a> _PIPC812W<'a> {
662 #[doc = r" Sets the field bit"]
663 pub fn set_bit(self) -> &'a mut W {
664 self.bit(true)
665 }
666 #[doc = r" Clears the field bit"]
667 pub fn clear_bit(self) -> &'a mut W {
668 self.bit(false)
669 }
670 #[doc = r" Writes raw bits to the field"]
671 #[inline]
672 pub fn bit(self, value: bool) -> &'a mut W {
673 const MASK: bool = true;
674 const OFFSET: u8 = 12;
675 self.w.bits &= !((MASK as u16) << OFFSET);
676 self.w.bits |= ((value & MASK) as u16) << OFFSET;
677 self.w
678 }
679}
680#[doc = r" Proxy"]
681pub struct _PIPC813W<'a> {
682 w: &'a mut W,
683}
684impl<'a> _PIPC813W<'a> {
685 #[doc = r" Sets the field bit"]
686 pub fn set_bit(self) -> &'a mut W {
687 self.bit(true)
688 }
689 #[doc = r" Clears the field bit"]
690 pub fn clear_bit(self) -> &'a mut W {
691 self.bit(false)
692 }
693 #[doc = r" Writes raw bits to the field"]
694 #[inline]
695 pub fn bit(self, value: bool) -> &'a mut W {
696 const MASK: bool = true;
697 const OFFSET: u8 = 13;
698 self.w.bits &= !((MASK as u16) << OFFSET);
699 self.w.bits |= ((value & MASK) as u16) << OFFSET;
700 self.w
701 }
702}
703#[doc = r" Proxy"]
704pub struct _PIPC814W<'a> {
705 w: &'a mut W,
706}
707impl<'a> _PIPC814W<'a> {
708 #[doc = r" Sets the field bit"]
709 pub fn set_bit(self) -> &'a mut W {
710 self.bit(true)
711 }
712 #[doc = r" Clears the field bit"]
713 pub fn clear_bit(self) -> &'a mut W {
714 self.bit(false)
715 }
716 #[doc = r" Writes raw bits to the field"]
717 #[inline]
718 pub fn bit(self, value: bool) -> &'a mut W {
719 const MASK: bool = true;
720 const OFFSET: u8 = 14;
721 self.w.bits &= !((MASK as u16) << OFFSET);
722 self.w.bits |= ((value & MASK) as u16) << OFFSET;
723 self.w
724 }
725}
726#[doc = r" Proxy"]
727pub struct _PIPC815W<'a> {
728 w: &'a mut W,
729}
730impl<'a> _PIPC815W<'a> {
731 #[doc = r" Sets the field bit"]
732 pub fn set_bit(self) -> &'a mut W {
733 self.bit(true)
734 }
735 #[doc = r" Clears the field bit"]
736 pub fn clear_bit(self) -> &'a mut W {
737 self.bit(false)
738 }
739 #[doc = r" Writes raw bits to the field"]
740 #[inline]
741 pub fn bit(self, value: bool) -> &'a mut W {
742 const MASK: bool = true;
743 const OFFSET: u8 = 15;
744 self.w.bits &= !((MASK as u16) << OFFSET);
745 self.w.bits |= ((value & MASK) as u16) << OFFSET;
746 self.w
747 }
748}
749impl R {
750 #[doc = r" Value of the register as raw bits"]
751 #[inline]
752 pub fn bits(&self) -> u16 {
753 self.bits
754 }
755 #[doc = "Bit 0"]
756 #[inline]
757 pub fn pipc80(&self) -> PIPC80R {
758 let bits = {
759 const MASK: bool = true;
760 const OFFSET: u8 = 0;
761 ((self.bits >> OFFSET) & MASK as u16) != 0
762 };
763 PIPC80R { bits }
764 }
765 #[doc = "Bit 1"]
766 #[inline]
767 pub fn pipc81(&self) -> PIPC81R {
768 let bits = {
769 const MASK: bool = true;
770 const OFFSET: u8 = 1;
771 ((self.bits >> OFFSET) & MASK as u16) != 0
772 };
773 PIPC81R { bits }
774 }
775 #[doc = "Bit 2"]
776 #[inline]
777 pub fn pipc82(&self) -> PIPC82R {
778 let bits = {
779 const MASK: bool = true;
780 const OFFSET: u8 = 2;
781 ((self.bits >> OFFSET) & MASK as u16) != 0
782 };
783 PIPC82R { bits }
784 }
785 #[doc = "Bit 3"]
786 #[inline]
787 pub fn pipc83(&self) -> PIPC83R {
788 let bits = {
789 const MASK: bool = true;
790 const OFFSET: u8 = 3;
791 ((self.bits >> OFFSET) & MASK as u16) != 0
792 };
793 PIPC83R { bits }
794 }
795 #[doc = "Bit 4"]
796 #[inline]
797 pub fn pipc84(&self) -> PIPC84R {
798 let bits = {
799 const MASK: bool = true;
800 const OFFSET: u8 = 4;
801 ((self.bits >> OFFSET) & MASK as u16) != 0
802 };
803 PIPC84R { bits }
804 }
805 #[doc = "Bit 5"]
806 #[inline]
807 pub fn pipc85(&self) -> PIPC85R {
808 let bits = {
809 const MASK: bool = true;
810 const OFFSET: u8 = 5;
811 ((self.bits >> OFFSET) & MASK as u16) != 0
812 };
813 PIPC85R { bits }
814 }
815 #[doc = "Bit 6"]
816 #[inline]
817 pub fn pipc86(&self) -> PIPC86R {
818 let bits = {
819 const MASK: bool = true;
820 const OFFSET: u8 = 6;
821 ((self.bits >> OFFSET) & MASK as u16) != 0
822 };
823 PIPC86R { bits }
824 }
825 #[doc = "Bit 7"]
826 #[inline]
827 pub fn pipc87(&self) -> PIPC87R {
828 let bits = {
829 const MASK: bool = true;
830 const OFFSET: u8 = 7;
831 ((self.bits >> OFFSET) & MASK as u16) != 0
832 };
833 PIPC87R { bits }
834 }
835 #[doc = "Bit 8"]
836 #[inline]
837 pub fn pipc88(&self) -> PIPC88R {
838 let bits = {
839 const MASK: bool = true;
840 const OFFSET: u8 = 8;
841 ((self.bits >> OFFSET) & MASK as u16) != 0
842 };
843 PIPC88R { bits }
844 }
845 #[doc = "Bit 9"]
846 #[inline]
847 pub fn pipc89(&self) -> PIPC89R {
848 let bits = {
849 const MASK: bool = true;
850 const OFFSET: u8 = 9;
851 ((self.bits >> OFFSET) & MASK as u16) != 0
852 };
853 PIPC89R { bits }
854 }
855 #[doc = "Bit 10"]
856 #[inline]
857 pub fn pipc810(&self) -> PIPC810R {
858 let bits = {
859 const MASK: bool = true;
860 const OFFSET: u8 = 10;
861 ((self.bits >> OFFSET) & MASK as u16) != 0
862 };
863 PIPC810R { bits }
864 }
865 #[doc = "Bit 11"]
866 #[inline]
867 pub fn pipc811(&self) -> PIPC811R {
868 let bits = {
869 const MASK: bool = true;
870 const OFFSET: u8 = 11;
871 ((self.bits >> OFFSET) & MASK as u16) != 0
872 };
873 PIPC811R { bits }
874 }
875 #[doc = "Bit 12"]
876 #[inline]
877 pub fn pipc812(&self) -> PIPC812R {
878 let bits = {
879 const MASK: bool = true;
880 const OFFSET: u8 = 12;
881 ((self.bits >> OFFSET) & MASK as u16) != 0
882 };
883 PIPC812R { bits }
884 }
885 #[doc = "Bit 13"]
886 #[inline]
887 pub fn pipc813(&self) -> PIPC813R {
888 let bits = {
889 const MASK: bool = true;
890 const OFFSET: u8 = 13;
891 ((self.bits >> OFFSET) & MASK as u16) != 0
892 };
893 PIPC813R { bits }
894 }
895 #[doc = "Bit 14"]
896 #[inline]
897 pub fn pipc814(&self) -> PIPC814R {
898 let bits = {
899 const MASK: bool = true;
900 const OFFSET: u8 = 14;
901 ((self.bits >> OFFSET) & MASK as u16) != 0
902 };
903 PIPC814R { bits }
904 }
905 #[doc = "Bit 15"]
906 #[inline]
907 pub fn pipc815(&self) -> PIPC815R {
908 let bits = {
909 const MASK: bool = true;
910 const OFFSET: u8 = 15;
911 ((self.bits >> OFFSET) & MASK as u16) != 0
912 };
913 PIPC815R { bits }
914 }
915}
916impl W {
917 #[doc = r" Reset value of the register"]
918 #[inline]
919 pub fn reset_value() -> W {
920 W { bits: 0 }
921 }
922 #[doc = r" Writes raw bits to the register"]
923 #[inline]
924 pub unsafe fn bits(&mut self, bits: u16) -> &mut Self {
925 self.bits = bits;
926 self
927 }
928 #[doc = "Bit 0"]
929 #[inline]
930 pub fn pipc80(&mut self) -> _PIPC80W {
931 _PIPC80W { w: self }
932 }
933 #[doc = "Bit 1"]
934 #[inline]
935 pub fn pipc81(&mut self) -> _PIPC81W {
936 _PIPC81W { w: self }
937 }
938 #[doc = "Bit 2"]
939 #[inline]
940 pub fn pipc82(&mut self) -> _PIPC82W {
941 _PIPC82W { w: self }
942 }
943 #[doc = "Bit 3"]
944 #[inline]
945 pub fn pipc83(&mut self) -> _PIPC83W {
946 _PIPC83W { w: self }
947 }
948 #[doc = "Bit 4"]
949 #[inline]
950 pub fn pipc84(&mut self) -> _PIPC84W {
951 _PIPC84W { w: self }
952 }
953 #[doc = "Bit 5"]
954 #[inline]
955 pub fn pipc85(&mut self) -> _PIPC85W {
956 _PIPC85W { w: self }
957 }
958 #[doc = "Bit 6"]
959 #[inline]
960 pub fn pipc86(&mut self) -> _PIPC86W {
961 _PIPC86W { w: self }
962 }
963 #[doc = "Bit 7"]
964 #[inline]
965 pub fn pipc87(&mut self) -> _PIPC87W {
966 _PIPC87W { w: self }
967 }
968 #[doc = "Bit 8"]
969 #[inline]
970 pub fn pipc88(&mut self) -> _PIPC88W {
971 _PIPC88W { w: self }
972 }
973 #[doc = "Bit 9"]
974 #[inline]
975 pub fn pipc89(&mut self) -> _PIPC89W {
976 _PIPC89W { w: self }
977 }
978 #[doc = "Bit 10"]
979 #[inline]
980 pub fn pipc810(&mut self) -> _PIPC810W {
981 _PIPC810W { w: self }
982 }
983 #[doc = "Bit 11"]
984 #[inline]
985 pub fn pipc811(&mut self) -> _PIPC811W {
986 _PIPC811W { w: self }
987 }
988 #[doc = "Bit 12"]
989 #[inline]
990 pub fn pipc812(&mut self) -> _PIPC812W {
991 _PIPC812W { w: self }
992 }
993 #[doc = "Bit 13"]
994 #[inline]
995 pub fn pipc813(&mut self) -> _PIPC813W {
996 _PIPC813W { w: self }
997 }
998 #[doc = "Bit 14"]
999 #[inline]
1000 pub fn pipc814(&mut self) -> _PIPC814W {
1001 _PIPC814W { w: self }
1002 }
1003 #[doc = "Bit 15"]
1004 #[inline]
1005 pub fn pipc815(&mut self) -> _PIPC815W {
1006 _PIPC815W { w: self }
1007 }
1008}