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::SR {
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 CC4OFR {
47 bits: bool,
48}
49impl CC4OFR {
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 CC3OFR {
68 bits: bool,
69}
70impl CC3OFR {
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 CC2OFR {
89 bits: bool,
90}
91impl CC2OFR {
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 CC1OFR {
110 bits: bool,
111}
112impl CC1OFR {
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 BIFR {
131 bits: bool,
132}
133impl BIFR {
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 TIFR {
152 bits: bool,
153}
154impl TIFR {
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 COMIFR {
173 bits: bool,
174}
175impl COMIFR {
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 CC4IFR {
194 bits: bool,
195}
196impl CC4IFR {
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 CC3IFR {
215 bits: bool,
216}
217impl CC3IFR {
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 CC2IFR {
236 bits: bool,
237}
238impl CC2IFR {
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 CC1IFR {
257 bits: bool,
258}
259impl CC1IFR {
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 = "Possible values of the field `UIF`"]
277#[derive(Clone, Copy, Debug, PartialEq)]
278pub enum UIFR {
279 #[doc = "No update occurred"]
280 CLEAR,
281 #[doc = "Update interrupt pending."]
282 UPDATEPENDING,
283}
284impl UIFR {
285 #[doc = r" Returns `true` if the bit is clear (0)"]
286 #[inline]
287 pub fn bit_is_clear(&self) -> bool {
288 !self.bit()
289 }
290 #[doc = r" Returns `true` if the bit is set (1)"]
291 #[inline]
292 pub fn bit_is_set(&self) -> bool {
293 self.bit()
294 }
295 #[doc = r" Value of the field as raw bits"]
296 #[inline]
297 pub fn bit(&self) -> bool {
298 match *self {
299 UIFR::CLEAR => false,
300 UIFR::UPDATEPENDING => true,
301 }
302 }
303 #[allow(missing_docs)]
304 #[doc(hidden)]
305 #[inline]
306 pub fn _from(value: bool) -> UIFR {
307 match value {
308 false => UIFR::CLEAR,
309 true => UIFR::UPDATEPENDING,
310 }
311 }
312 #[doc = "Checks if the value of the field is `CLEAR`"]
313 #[inline]
314 pub fn is_clear(&self) -> bool {
315 *self == UIFR::CLEAR
316 }
317 #[doc = "Checks if the value of the field is `UPDATEPENDING`"]
318 #[inline]
319 pub fn is_update_pending(&self) -> bool {
320 *self == UIFR::UPDATEPENDING
321 }
322}
323#[doc = r" Proxy"]
324pub struct _CC4OFW<'a> {
325 w: &'a mut W,
326}
327impl<'a> _CC4OFW<'a> {
328 #[doc = r" Sets the field bit"]
329 pub fn set_bit(self) -> &'a mut W {
330 self.bit(true)
331 }
332 #[doc = r" Clears the field bit"]
333 pub fn clear_bit(self) -> &'a mut W {
334 self.bit(false)
335 }
336 #[doc = r" Writes raw bits to the field"]
337 #[inline]
338 pub fn bit(self, value: bool) -> &'a mut W {
339 const MASK: bool = true;
340 const OFFSET: u8 = 12;
341 self.w.bits &= !((MASK as u32) << OFFSET);
342 self.w.bits |= ((value & MASK) as u32) << OFFSET;
343 self.w
344 }
345}
346#[doc = r" Proxy"]
347pub struct _CC3OFW<'a> {
348 w: &'a mut W,
349}
350impl<'a> _CC3OFW<'a> {
351 #[doc = r" Sets the field bit"]
352 pub fn set_bit(self) -> &'a mut W {
353 self.bit(true)
354 }
355 #[doc = r" Clears the field bit"]
356 pub fn clear_bit(self) -> &'a mut W {
357 self.bit(false)
358 }
359 #[doc = r" Writes raw bits to the field"]
360 #[inline]
361 pub fn bit(self, value: bool) -> &'a mut W {
362 const MASK: bool = true;
363 const OFFSET: u8 = 11;
364 self.w.bits &= !((MASK as u32) << OFFSET);
365 self.w.bits |= ((value & MASK) as u32) << OFFSET;
366 self.w
367 }
368}
369#[doc = r" Proxy"]
370pub struct _CC2OFW<'a> {
371 w: &'a mut W,
372}
373impl<'a> _CC2OFW<'a> {
374 #[doc = r" Sets the field bit"]
375 pub fn set_bit(self) -> &'a mut W {
376 self.bit(true)
377 }
378 #[doc = r" Clears the field bit"]
379 pub fn clear_bit(self) -> &'a mut W {
380 self.bit(false)
381 }
382 #[doc = r" Writes raw bits to the field"]
383 #[inline]
384 pub fn bit(self, value: bool) -> &'a mut W {
385 const MASK: bool = true;
386 const OFFSET: u8 = 10;
387 self.w.bits &= !((MASK as u32) << OFFSET);
388 self.w.bits |= ((value & MASK) as u32) << OFFSET;
389 self.w
390 }
391}
392#[doc = r" Proxy"]
393pub struct _CC1OFW<'a> {
394 w: &'a mut W,
395}
396impl<'a> _CC1OFW<'a> {
397 #[doc = r" Sets the field bit"]
398 pub fn set_bit(self) -> &'a mut W {
399 self.bit(true)
400 }
401 #[doc = r" Clears the field bit"]
402 pub fn clear_bit(self) -> &'a mut W {
403 self.bit(false)
404 }
405 #[doc = r" Writes raw bits to the field"]
406 #[inline]
407 pub fn bit(self, value: bool) -> &'a mut W {
408 const MASK: bool = true;
409 const OFFSET: u8 = 9;
410 self.w.bits &= !((MASK as u32) << OFFSET);
411 self.w.bits |= ((value & MASK) as u32) << OFFSET;
412 self.w
413 }
414}
415#[doc = r" Proxy"]
416pub struct _BIFW<'a> {
417 w: &'a mut W,
418}
419impl<'a> _BIFW<'a> {
420 #[doc = r" Sets the field bit"]
421 pub fn set_bit(self) -> &'a mut W {
422 self.bit(true)
423 }
424 #[doc = r" Clears the field bit"]
425 pub fn clear_bit(self) -> &'a mut W {
426 self.bit(false)
427 }
428 #[doc = r" Writes raw bits to the field"]
429 #[inline]
430 pub fn bit(self, value: bool) -> &'a mut W {
431 const MASK: bool = true;
432 const OFFSET: u8 = 7;
433 self.w.bits &= !((MASK as u32) << OFFSET);
434 self.w.bits |= ((value & MASK) as u32) << OFFSET;
435 self.w
436 }
437}
438#[doc = r" Proxy"]
439pub struct _TIFW<'a> {
440 w: &'a mut W,
441}
442impl<'a> _TIFW<'a> {
443 #[doc = r" Sets the field bit"]
444 pub fn set_bit(self) -> &'a mut W {
445 self.bit(true)
446 }
447 #[doc = r" Clears the field bit"]
448 pub fn clear_bit(self) -> &'a mut W {
449 self.bit(false)
450 }
451 #[doc = r" Writes raw bits to the field"]
452 #[inline]
453 pub fn bit(self, value: bool) -> &'a mut W {
454 const MASK: bool = true;
455 const OFFSET: u8 = 6;
456 self.w.bits &= !((MASK as u32) << OFFSET);
457 self.w.bits |= ((value & MASK) as u32) << OFFSET;
458 self.w
459 }
460}
461#[doc = r" Proxy"]
462pub struct _COMIFW<'a> {
463 w: &'a mut W,
464}
465impl<'a> _COMIFW<'a> {
466 #[doc = r" Sets the field bit"]
467 pub fn set_bit(self) -> &'a mut W {
468 self.bit(true)
469 }
470 #[doc = r" Clears the field bit"]
471 pub fn clear_bit(self) -> &'a mut W {
472 self.bit(false)
473 }
474 #[doc = r" Writes raw bits to the field"]
475 #[inline]
476 pub fn bit(self, value: bool) -> &'a mut W {
477 const MASK: bool = true;
478 const OFFSET: u8 = 5;
479 self.w.bits &= !((MASK as u32) << OFFSET);
480 self.w.bits |= ((value & MASK) as u32) << OFFSET;
481 self.w
482 }
483}
484#[doc = r" Proxy"]
485pub struct _CC4IFW<'a> {
486 w: &'a mut W,
487}
488impl<'a> _CC4IFW<'a> {
489 #[doc = r" Sets the field bit"]
490 pub fn set_bit(self) -> &'a mut W {
491 self.bit(true)
492 }
493 #[doc = r" Clears the field bit"]
494 pub fn clear_bit(self) -> &'a mut W {
495 self.bit(false)
496 }
497 #[doc = r" Writes raw bits to the field"]
498 #[inline]
499 pub fn bit(self, value: bool) -> &'a mut W {
500 const MASK: bool = true;
501 const OFFSET: u8 = 4;
502 self.w.bits &= !((MASK as u32) << OFFSET);
503 self.w.bits |= ((value & MASK) as u32) << OFFSET;
504 self.w
505 }
506}
507#[doc = r" Proxy"]
508pub struct _CC3IFW<'a> {
509 w: &'a mut W,
510}
511impl<'a> _CC3IFW<'a> {
512 #[doc = r" Sets the field bit"]
513 pub fn set_bit(self) -> &'a mut W {
514 self.bit(true)
515 }
516 #[doc = r" Clears the field bit"]
517 pub fn clear_bit(self) -> &'a mut W {
518 self.bit(false)
519 }
520 #[doc = r" Writes raw bits to the field"]
521 #[inline]
522 pub fn bit(self, value: bool) -> &'a mut W {
523 const MASK: bool = true;
524 const OFFSET: u8 = 3;
525 self.w.bits &= !((MASK as u32) << OFFSET);
526 self.w.bits |= ((value & MASK) as u32) << OFFSET;
527 self.w
528 }
529}
530#[doc = r" Proxy"]
531pub struct _CC2IFW<'a> {
532 w: &'a mut W,
533}
534impl<'a> _CC2IFW<'a> {
535 #[doc = r" Sets the field bit"]
536 pub fn set_bit(self) -> &'a mut W {
537 self.bit(true)
538 }
539 #[doc = r" Clears the field bit"]
540 pub fn clear_bit(self) -> &'a mut W {
541 self.bit(false)
542 }
543 #[doc = r" Writes raw bits to the field"]
544 #[inline]
545 pub fn bit(self, value: bool) -> &'a mut W {
546 const MASK: bool = true;
547 const OFFSET: u8 = 2;
548 self.w.bits &= !((MASK as u32) << OFFSET);
549 self.w.bits |= ((value & MASK) as u32) << OFFSET;
550 self.w
551 }
552}
553#[doc = r" Proxy"]
554pub struct _CC1IFW<'a> {
555 w: &'a mut W,
556}
557impl<'a> _CC1IFW<'a> {
558 #[doc = r" Sets the field bit"]
559 pub fn set_bit(self) -> &'a mut W {
560 self.bit(true)
561 }
562 #[doc = r" Clears the field bit"]
563 pub fn clear_bit(self) -> &'a mut W {
564 self.bit(false)
565 }
566 #[doc = r" Writes raw bits to the field"]
567 #[inline]
568 pub fn bit(self, value: bool) -> &'a mut W {
569 const MASK: bool = true;
570 const OFFSET: u8 = 1;
571 self.w.bits &= !((MASK as u32) << OFFSET);
572 self.w.bits |= ((value & MASK) as u32) << OFFSET;
573 self.w
574 }
575}
576#[doc = "Values that can be written to the field `UIF`"]
577pub enum UIFW {
578 #[doc = "No update occurred"]
579 CLEAR,
580 #[doc = "Update interrupt pending."]
581 UPDATEPENDING,
582}
583impl UIFW {
584 #[allow(missing_docs)]
585 #[doc(hidden)]
586 #[inline]
587 pub fn _bits(&self) -> bool {
588 match *self {
589 UIFW::CLEAR => false,
590 UIFW::UPDATEPENDING => true,
591 }
592 }
593}
594#[doc = r" Proxy"]
595pub struct _UIFW<'a> {
596 w: &'a mut W,
597}
598impl<'a> _UIFW<'a> {
599 #[doc = r" Writes `variant` to the field"]
600 #[inline]
601 pub fn variant(self, variant: UIFW) -> &'a mut W {
602 {
603 self.bit(variant._bits())
604 }
605 }
606 #[doc = "No update occurred"]
607 #[inline]
608 pub fn clear(self) -> &'a mut W {
609 self.variant(UIFW::CLEAR)
610 }
611 #[doc = "Update interrupt pending."]
612 #[inline]
613 pub fn update_pending(self) -> &'a mut W {
614 self.variant(UIFW::UPDATEPENDING)
615 }
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 = 0;
629 self.w.bits &= !((MASK as u32) << OFFSET);
630 self.w.bits |= ((value & MASK) as u32) << OFFSET;
631 self.w
632 }
633}
634impl R {
635 #[doc = r" Value of the register as raw bits"]
636 #[inline]
637 pub fn bits(&self) -> u32 {
638 self.bits
639 }
640 #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"]
641 #[inline]
642 pub fn cc4of(&self) -> CC4OFR {
643 let bits = {
644 const MASK: bool = true;
645 const OFFSET: u8 = 12;
646 ((self.bits >> OFFSET) & MASK as u32) != 0
647 };
648 CC4OFR { bits }
649 }
650 #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
651 #[inline]
652 pub fn cc3of(&self) -> CC3OFR {
653 let bits = {
654 const MASK: bool = true;
655 const OFFSET: u8 = 11;
656 ((self.bits >> OFFSET) & MASK as u32) != 0
657 };
658 CC3OFR { bits }
659 }
660 #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
661 #[inline]
662 pub fn cc2of(&self) -> CC2OFR {
663 let bits = {
664 const MASK: bool = true;
665 const OFFSET: u8 = 10;
666 ((self.bits >> OFFSET) & MASK as u32) != 0
667 };
668 CC2OFR { bits }
669 }
670 #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
671 #[inline]
672 pub fn cc1of(&self) -> CC1OFR {
673 let bits = {
674 const MASK: bool = true;
675 const OFFSET: u8 = 9;
676 ((self.bits >> OFFSET) & MASK as u32) != 0
677 };
678 CC1OFR { bits }
679 }
680 #[doc = "Bit 7 - Break interrupt flag"]
681 #[inline]
682 pub fn bif(&self) -> BIFR {
683 let bits = {
684 const MASK: bool = true;
685 const OFFSET: u8 = 7;
686 ((self.bits >> OFFSET) & MASK as u32) != 0
687 };
688 BIFR { bits }
689 }
690 #[doc = "Bit 6 - Trigger interrupt flag"]
691 #[inline]
692 pub fn tif(&self) -> TIFR {
693 let bits = {
694 const MASK: bool = true;
695 const OFFSET: u8 = 6;
696 ((self.bits >> OFFSET) & MASK as u32) != 0
697 };
698 TIFR { bits }
699 }
700 #[doc = "Bit 5 - COM interrupt flag"]
701 #[inline]
702 pub fn comif(&self) -> COMIFR {
703 let bits = {
704 const MASK: bool = true;
705 const OFFSET: u8 = 5;
706 ((self.bits >> OFFSET) & MASK as u32) != 0
707 };
708 COMIFR { bits }
709 }
710 #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
711 #[inline]
712 pub fn cc4if(&self) -> CC4IFR {
713 let bits = {
714 const MASK: bool = true;
715 const OFFSET: u8 = 4;
716 ((self.bits >> OFFSET) & MASK as u32) != 0
717 };
718 CC4IFR { bits }
719 }
720 #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
721 #[inline]
722 pub fn cc3if(&self) -> CC3IFR {
723 let bits = {
724 const MASK: bool = true;
725 const OFFSET: u8 = 3;
726 ((self.bits >> OFFSET) & MASK as u32) != 0
727 };
728 CC3IFR { bits }
729 }
730 #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
731 #[inline]
732 pub fn cc2if(&self) -> CC2IFR {
733 let bits = {
734 const MASK: bool = true;
735 const OFFSET: u8 = 2;
736 ((self.bits >> OFFSET) & MASK as u32) != 0
737 };
738 CC2IFR { bits }
739 }
740 #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
741 #[inline]
742 pub fn cc1if(&self) -> CC1IFR {
743 let bits = {
744 const MASK: bool = true;
745 const OFFSET: u8 = 1;
746 ((self.bits >> OFFSET) & MASK as u32) != 0
747 };
748 CC1IFR { bits }
749 }
750 #[doc = "Bit 0 - Update interrupt flag"]
751 #[inline]
752 pub fn uif(&self) -> UIFR {
753 UIFR::_from({
754 const MASK: bool = true;
755 const OFFSET: u8 = 0;
756 ((self.bits >> OFFSET) & MASK as u32) != 0
757 })
758 }
759}
760impl W {
761 #[doc = r" Reset value of the register"]
762 #[inline]
763 pub fn reset_value() -> W {
764 W { bits: 0 }
765 }
766 #[doc = r" Writes raw bits to the register"]
767 #[inline]
768 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
769 self.bits = bits;
770 self
771 }
772 #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"]
773 #[inline]
774 pub fn cc4of(&mut self) -> _CC4OFW {
775 _CC4OFW { w: self }
776 }
777 #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"]
778 #[inline]
779 pub fn cc3of(&mut self) -> _CC3OFW {
780 _CC3OFW { w: self }
781 }
782 #[doc = "Bit 10 - Capture/compare 2 overcapture flag"]
783 #[inline]
784 pub fn cc2of(&mut self) -> _CC2OFW {
785 _CC2OFW { w: self }
786 }
787 #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"]
788 #[inline]
789 pub fn cc1of(&mut self) -> _CC1OFW {
790 _CC1OFW { w: self }
791 }
792 #[doc = "Bit 7 - Break interrupt flag"]
793 #[inline]
794 pub fn bif(&mut self) -> _BIFW {
795 _BIFW { w: self }
796 }
797 #[doc = "Bit 6 - Trigger interrupt flag"]
798 #[inline]
799 pub fn tif(&mut self) -> _TIFW {
800 _TIFW { w: self }
801 }
802 #[doc = "Bit 5 - COM interrupt flag"]
803 #[inline]
804 pub fn comif(&mut self) -> _COMIFW {
805 _COMIFW { w: self }
806 }
807 #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"]
808 #[inline]
809 pub fn cc4if(&mut self) -> _CC4IFW {
810 _CC4IFW { w: self }
811 }
812 #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"]
813 #[inline]
814 pub fn cc3if(&mut self) -> _CC3IFW {
815 _CC3IFW { w: self }
816 }
817 #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"]
818 #[inline]
819 pub fn cc2if(&mut self) -> _CC2IFW {
820 _CC2IFW { w: self }
821 }
822 #[doc = "Bit 1 - Capture/compare 1 interrupt flag"]
823 #[inline]
824 pub fn cc1if(&mut self) -> _CC1IFW {
825 _CC1IFW { w: self }
826 }
827 #[doc = "Bit 0 - Update interrupt flag"]
828 #[inline]
829 pub fn uif(&mut self) -> _UIFW {
830 _UIFW { w: self }
831 }
832}