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