1#[doc = "Reader of register STATUS"]
2pub type R = crate::R<u32, super::STATUS>;
3#[doc = "Writer for register STATUS"]
4pub type W = crate::W<u32, super::STATUS>;
5#[doc = "Register STATUS `reset()`'s with value 0"]
6impl crate::ResetValue for super::STATUS {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Channel 0 Flag\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum CH0F_A {
16 #[doc = "0: No channel event has occurred."]
17 _0,
18 #[doc = "1: A channel event has occurred."]
19 _1,
20}
21impl From<CH0F_A> for bool {
22 #[inline(always)]
23 fn from(variant: CH0F_A) -> Self {
24 match variant {
25 CH0F_A::_0 => false,
26 CH0F_A::_1 => true,
27 }
28 }
29}
30#[doc = "Reader of field `CH0F`"]
31pub type CH0F_R = crate::R<bool, CH0F_A>;
32impl CH0F_R {
33 #[doc = r"Get enumerated values variant"]
34 #[inline(always)]
35 pub fn variant(&self) -> CH0F_A {
36 match self.bits {
37 false => CH0F_A::_0,
38 true => CH0F_A::_1,
39 }
40 }
41 #[doc = "Checks if the value of the field is `_0`"]
42 #[inline(always)]
43 pub fn is_0(&self) -> bool {
44 *self == CH0F_A::_0
45 }
46 #[doc = "Checks if the value of the field is `_1`"]
47 #[inline(always)]
48 pub fn is_1(&self) -> bool {
49 *self == CH0F_A::_1
50 }
51}
52#[doc = "Write proxy for field `CH0F`"]
53pub struct CH0F_W<'a> {
54 w: &'a mut W,
55}
56impl<'a> CH0F_W<'a> {
57 #[doc = r"Writes `variant` to the field"]
58 #[inline(always)]
59 pub fn variant(self, variant: CH0F_A) -> &'a mut W {
60 {
61 self.bit(variant.into())
62 }
63 }
64 #[doc = "No channel event has occurred."]
65 #[inline(always)]
66 pub fn _0(self) -> &'a mut W {
67 self.variant(CH0F_A::_0)
68 }
69 #[doc = "A channel event has occurred."]
70 #[inline(always)]
71 pub fn _1(self) -> &'a mut W {
72 self.variant(CH0F_A::_1)
73 }
74 #[doc = r"Sets the field bit"]
75 #[inline(always)]
76 pub fn set_bit(self) -> &'a mut W {
77 self.bit(true)
78 }
79 #[doc = r"Clears the field bit"]
80 #[inline(always)]
81 pub fn clear_bit(self) -> &'a mut W {
82 self.bit(false)
83 }
84 #[doc = r"Writes raw bits to the field"]
85 #[inline(always)]
86 pub fn bit(self, value: bool) -> &'a mut W {
87 self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
88 self.w
89 }
90}
91#[doc = "Channel 1 Flag\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq)]
93pub enum CH1F_A {
94 #[doc = "0: No channel event has occurred."]
95 _0,
96 #[doc = "1: A channel event has occurred."]
97 _1,
98}
99impl From<CH1F_A> for bool {
100 #[inline(always)]
101 fn from(variant: CH1F_A) -> Self {
102 match variant {
103 CH1F_A::_0 => false,
104 CH1F_A::_1 => true,
105 }
106 }
107}
108#[doc = "Reader of field `CH1F`"]
109pub type CH1F_R = crate::R<bool, CH1F_A>;
110impl CH1F_R {
111 #[doc = r"Get enumerated values variant"]
112 #[inline(always)]
113 pub fn variant(&self) -> CH1F_A {
114 match self.bits {
115 false => CH1F_A::_0,
116 true => CH1F_A::_1,
117 }
118 }
119 #[doc = "Checks if the value of the field is `_0`"]
120 #[inline(always)]
121 pub fn is_0(&self) -> bool {
122 *self == CH1F_A::_0
123 }
124 #[doc = "Checks if the value of the field is `_1`"]
125 #[inline(always)]
126 pub fn is_1(&self) -> bool {
127 *self == CH1F_A::_1
128 }
129}
130#[doc = "Write proxy for field `CH1F`"]
131pub struct CH1F_W<'a> {
132 w: &'a mut W,
133}
134impl<'a> CH1F_W<'a> {
135 #[doc = r"Writes `variant` to the field"]
136 #[inline(always)]
137 pub fn variant(self, variant: CH1F_A) -> &'a mut W {
138 {
139 self.bit(variant.into())
140 }
141 }
142 #[doc = "No channel event has occurred."]
143 #[inline(always)]
144 pub fn _0(self) -> &'a mut W {
145 self.variant(CH1F_A::_0)
146 }
147 #[doc = "A channel event has occurred."]
148 #[inline(always)]
149 pub fn _1(self) -> &'a mut W {
150 self.variant(CH1F_A::_1)
151 }
152 #[doc = r"Sets the field bit"]
153 #[inline(always)]
154 pub fn set_bit(self) -> &'a mut W {
155 self.bit(true)
156 }
157 #[doc = r"Clears the field bit"]
158 #[inline(always)]
159 pub fn clear_bit(self) -> &'a mut W {
160 self.bit(false)
161 }
162 #[doc = r"Writes raw bits to the field"]
163 #[inline(always)]
164 pub fn bit(self, value: bool) -> &'a mut W {
165 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
166 self.w
167 }
168}
169#[doc = "Channel 2 Flag\n\nValue on reset: 0"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum CH2F_A {
172 #[doc = "0: No channel event has occurred."]
173 _0,
174 #[doc = "1: A channel event has occurred."]
175 _1,
176}
177impl From<CH2F_A> for bool {
178 #[inline(always)]
179 fn from(variant: CH2F_A) -> Self {
180 match variant {
181 CH2F_A::_0 => false,
182 CH2F_A::_1 => true,
183 }
184 }
185}
186#[doc = "Reader of field `CH2F`"]
187pub type CH2F_R = crate::R<bool, CH2F_A>;
188impl CH2F_R {
189 #[doc = r"Get enumerated values variant"]
190 #[inline(always)]
191 pub fn variant(&self) -> CH2F_A {
192 match self.bits {
193 false => CH2F_A::_0,
194 true => CH2F_A::_1,
195 }
196 }
197 #[doc = "Checks if the value of the field is `_0`"]
198 #[inline(always)]
199 pub fn is_0(&self) -> bool {
200 *self == CH2F_A::_0
201 }
202 #[doc = "Checks if the value of the field is `_1`"]
203 #[inline(always)]
204 pub fn is_1(&self) -> bool {
205 *self == CH2F_A::_1
206 }
207}
208#[doc = "Write proxy for field `CH2F`"]
209pub struct CH2F_W<'a> {
210 w: &'a mut W,
211}
212impl<'a> CH2F_W<'a> {
213 #[doc = r"Writes `variant` to the field"]
214 #[inline(always)]
215 pub fn variant(self, variant: CH2F_A) -> &'a mut W {
216 {
217 self.bit(variant.into())
218 }
219 }
220 #[doc = "No channel event has occurred."]
221 #[inline(always)]
222 pub fn _0(self) -> &'a mut W {
223 self.variant(CH2F_A::_0)
224 }
225 #[doc = "A channel event has occurred."]
226 #[inline(always)]
227 pub fn _1(self) -> &'a mut W {
228 self.variant(CH2F_A::_1)
229 }
230 #[doc = r"Sets the field bit"]
231 #[inline(always)]
232 pub fn set_bit(self) -> &'a mut W {
233 self.bit(true)
234 }
235 #[doc = r"Clears the field bit"]
236 #[inline(always)]
237 pub fn clear_bit(self) -> &'a mut W {
238 self.bit(false)
239 }
240 #[doc = r"Writes raw bits to the field"]
241 #[inline(always)]
242 pub fn bit(self, value: bool) -> &'a mut W {
243 self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
244 self.w
245 }
246}
247#[doc = "Channel 3 Flag\n\nValue on reset: 0"]
248#[derive(Clone, Copy, Debug, PartialEq)]
249pub enum CH3F_A {
250 #[doc = "0: No channel event has occurred."]
251 _0,
252 #[doc = "1: A channel event has occurred."]
253 _1,
254}
255impl From<CH3F_A> for bool {
256 #[inline(always)]
257 fn from(variant: CH3F_A) -> Self {
258 match variant {
259 CH3F_A::_0 => false,
260 CH3F_A::_1 => true,
261 }
262 }
263}
264#[doc = "Reader of field `CH3F`"]
265pub type CH3F_R = crate::R<bool, CH3F_A>;
266impl CH3F_R {
267 #[doc = r"Get enumerated values variant"]
268 #[inline(always)]
269 pub fn variant(&self) -> CH3F_A {
270 match self.bits {
271 false => CH3F_A::_0,
272 true => CH3F_A::_1,
273 }
274 }
275 #[doc = "Checks if the value of the field is `_0`"]
276 #[inline(always)]
277 pub fn is_0(&self) -> bool {
278 *self == CH3F_A::_0
279 }
280 #[doc = "Checks if the value of the field is `_1`"]
281 #[inline(always)]
282 pub fn is_1(&self) -> bool {
283 *self == CH3F_A::_1
284 }
285}
286#[doc = "Write proxy for field `CH3F`"]
287pub struct CH3F_W<'a> {
288 w: &'a mut W,
289}
290impl<'a> CH3F_W<'a> {
291 #[doc = r"Writes `variant` to the field"]
292 #[inline(always)]
293 pub fn variant(self, variant: CH3F_A) -> &'a mut W {
294 {
295 self.bit(variant.into())
296 }
297 }
298 #[doc = "No channel event has occurred."]
299 #[inline(always)]
300 pub fn _0(self) -> &'a mut W {
301 self.variant(CH3F_A::_0)
302 }
303 #[doc = "A channel event has occurred."]
304 #[inline(always)]
305 pub fn _1(self) -> &'a mut W {
306 self.variant(CH3F_A::_1)
307 }
308 #[doc = r"Sets the field bit"]
309 #[inline(always)]
310 pub fn set_bit(self) -> &'a mut W {
311 self.bit(true)
312 }
313 #[doc = r"Clears the field bit"]
314 #[inline(always)]
315 pub fn clear_bit(self) -> &'a mut W {
316 self.bit(false)
317 }
318 #[doc = r"Writes raw bits to the field"]
319 #[inline(always)]
320 pub fn bit(self, value: bool) -> &'a mut W {
321 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
322 self.w
323 }
324}
325#[doc = "Channel 4 Flag\n\nValue on reset: 0"]
326#[derive(Clone, Copy, Debug, PartialEq)]
327pub enum CH4F_A {
328 #[doc = "0: No channel event has occurred."]
329 _0,
330 #[doc = "1: A channel event has occurred."]
331 _1,
332}
333impl From<CH4F_A> for bool {
334 #[inline(always)]
335 fn from(variant: CH4F_A) -> Self {
336 match variant {
337 CH4F_A::_0 => false,
338 CH4F_A::_1 => true,
339 }
340 }
341}
342#[doc = "Reader of field `CH4F`"]
343pub type CH4F_R = crate::R<bool, CH4F_A>;
344impl CH4F_R {
345 #[doc = r"Get enumerated values variant"]
346 #[inline(always)]
347 pub fn variant(&self) -> CH4F_A {
348 match self.bits {
349 false => CH4F_A::_0,
350 true => CH4F_A::_1,
351 }
352 }
353 #[doc = "Checks if the value of the field is `_0`"]
354 #[inline(always)]
355 pub fn is_0(&self) -> bool {
356 *self == CH4F_A::_0
357 }
358 #[doc = "Checks if the value of the field is `_1`"]
359 #[inline(always)]
360 pub fn is_1(&self) -> bool {
361 *self == CH4F_A::_1
362 }
363}
364#[doc = "Write proxy for field `CH4F`"]
365pub struct CH4F_W<'a> {
366 w: &'a mut W,
367}
368impl<'a> CH4F_W<'a> {
369 #[doc = r"Writes `variant` to the field"]
370 #[inline(always)]
371 pub fn variant(self, variant: CH4F_A) -> &'a mut W {
372 {
373 self.bit(variant.into())
374 }
375 }
376 #[doc = "No channel event has occurred."]
377 #[inline(always)]
378 pub fn _0(self) -> &'a mut W {
379 self.variant(CH4F_A::_0)
380 }
381 #[doc = "A channel event has occurred."]
382 #[inline(always)]
383 pub fn _1(self) -> &'a mut W {
384 self.variant(CH4F_A::_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 << 4)) | (((value as u32) & 0x01) << 4);
400 self.w
401 }
402}
403#[doc = "Channel 5 Flag\n\nValue on reset: 0"]
404#[derive(Clone, Copy, Debug, PartialEq)]
405pub enum CH5F_A {
406 #[doc = "0: No channel event has occurred."]
407 _0,
408 #[doc = "1: A channel event has occurred."]
409 _1,
410}
411impl From<CH5F_A> for bool {
412 #[inline(always)]
413 fn from(variant: CH5F_A) -> Self {
414 match variant {
415 CH5F_A::_0 => false,
416 CH5F_A::_1 => true,
417 }
418 }
419}
420#[doc = "Reader of field `CH5F`"]
421pub type CH5F_R = crate::R<bool, CH5F_A>;
422impl CH5F_R {
423 #[doc = r"Get enumerated values variant"]
424 #[inline(always)]
425 pub fn variant(&self) -> CH5F_A {
426 match self.bits {
427 false => CH5F_A::_0,
428 true => CH5F_A::_1,
429 }
430 }
431 #[doc = "Checks if the value of the field is `_0`"]
432 #[inline(always)]
433 pub fn is_0(&self) -> bool {
434 *self == CH5F_A::_0
435 }
436 #[doc = "Checks if the value of the field is `_1`"]
437 #[inline(always)]
438 pub fn is_1(&self) -> bool {
439 *self == CH5F_A::_1
440 }
441}
442#[doc = "Write proxy for field `CH5F`"]
443pub struct CH5F_W<'a> {
444 w: &'a mut W,
445}
446impl<'a> CH5F_W<'a> {
447 #[doc = r"Writes `variant` to the field"]
448 #[inline(always)]
449 pub fn variant(self, variant: CH5F_A) -> &'a mut W {
450 {
451 self.bit(variant.into())
452 }
453 }
454 #[doc = "No channel event has occurred."]
455 #[inline(always)]
456 pub fn _0(self) -> &'a mut W {
457 self.variant(CH5F_A::_0)
458 }
459 #[doc = "A channel event has occurred."]
460 #[inline(always)]
461 pub fn _1(self) -> &'a mut W {
462 self.variant(CH5F_A::_1)
463 }
464 #[doc = r"Sets the field bit"]
465 #[inline(always)]
466 pub fn set_bit(self) -> &'a mut W {
467 self.bit(true)
468 }
469 #[doc = r"Clears the field bit"]
470 #[inline(always)]
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(always)]
476 pub fn bit(self, value: bool) -> &'a mut W {
477 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
478 self.w
479 }
480}
481#[doc = "Channel 6 Flag\n\nValue on reset: 0"]
482#[derive(Clone, Copy, Debug, PartialEq)]
483pub enum CH6F_A {
484 #[doc = "0: No channel event has occurred."]
485 _0,
486 #[doc = "1: A channel event has occurred."]
487 _1,
488}
489impl From<CH6F_A> for bool {
490 #[inline(always)]
491 fn from(variant: CH6F_A) -> Self {
492 match variant {
493 CH6F_A::_0 => false,
494 CH6F_A::_1 => true,
495 }
496 }
497}
498#[doc = "Reader of field `CH6F`"]
499pub type CH6F_R = crate::R<bool, CH6F_A>;
500impl CH6F_R {
501 #[doc = r"Get enumerated values variant"]
502 #[inline(always)]
503 pub fn variant(&self) -> CH6F_A {
504 match self.bits {
505 false => CH6F_A::_0,
506 true => CH6F_A::_1,
507 }
508 }
509 #[doc = "Checks if the value of the field is `_0`"]
510 #[inline(always)]
511 pub fn is_0(&self) -> bool {
512 *self == CH6F_A::_0
513 }
514 #[doc = "Checks if the value of the field is `_1`"]
515 #[inline(always)]
516 pub fn is_1(&self) -> bool {
517 *self == CH6F_A::_1
518 }
519}
520#[doc = "Write proxy for field `CH6F`"]
521pub struct CH6F_W<'a> {
522 w: &'a mut W,
523}
524impl<'a> CH6F_W<'a> {
525 #[doc = r"Writes `variant` to the field"]
526 #[inline(always)]
527 pub fn variant(self, variant: CH6F_A) -> &'a mut W {
528 {
529 self.bit(variant.into())
530 }
531 }
532 #[doc = "No channel event has occurred."]
533 #[inline(always)]
534 pub fn _0(self) -> &'a mut W {
535 self.variant(CH6F_A::_0)
536 }
537 #[doc = "A channel event has occurred."]
538 #[inline(always)]
539 pub fn _1(self) -> &'a mut W {
540 self.variant(CH6F_A::_1)
541 }
542 #[doc = r"Sets the field bit"]
543 #[inline(always)]
544 pub fn set_bit(self) -> &'a mut W {
545 self.bit(true)
546 }
547 #[doc = r"Clears the field bit"]
548 #[inline(always)]
549 pub fn clear_bit(self) -> &'a mut W {
550 self.bit(false)
551 }
552 #[doc = r"Writes raw bits to the field"]
553 #[inline(always)]
554 pub fn bit(self, value: bool) -> &'a mut W {
555 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
556 self.w
557 }
558}
559#[doc = "Channel 7 Flag\n\nValue on reset: 0"]
560#[derive(Clone, Copy, Debug, PartialEq)]
561pub enum CH7F_A {
562 #[doc = "0: No channel event has occurred."]
563 _0,
564 #[doc = "1: A channel event has occurred."]
565 _1,
566}
567impl From<CH7F_A> for bool {
568 #[inline(always)]
569 fn from(variant: CH7F_A) -> Self {
570 match variant {
571 CH7F_A::_0 => false,
572 CH7F_A::_1 => true,
573 }
574 }
575}
576#[doc = "Reader of field `CH7F`"]
577pub type CH7F_R = crate::R<bool, CH7F_A>;
578impl CH7F_R {
579 #[doc = r"Get enumerated values variant"]
580 #[inline(always)]
581 pub fn variant(&self) -> CH7F_A {
582 match self.bits {
583 false => CH7F_A::_0,
584 true => CH7F_A::_1,
585 }
586 }
587 #[doc = "Checks if the value of the field is `_0`"]
588 #[inline(always)]
589 pub fn is_0(&self) -> bool {
590 *self == CH7F_A::_0
591 }
592 #[doc = "Checks if the value of the field is `_1`"]
593 #[inline(always)]
594 pub fn is_1(&self) -> bool {
595 *self == CH7F_A::_1
596 }
597}
598#[doc = "Write proxy for field `CH7F`"]
599pub struct CH7F_W<'a> {
600 w: &'a mut W,
601}
602impl<'a> CH7F_W<'a> {
603 #[doc = r"Writes `variant` to the field"]
604 #[inline(always)]
605 pub fn variant(self, variant: CH7F_A) -> &'a mut W {
606 {
607 self.bit(variant.into())
608 }
609 }
610 #[doc = "No channel event has occurred."]
611 #[inline(always)]
612 pub fn _0(self) -> &'a mut W {
613 self.variant(CH7F_A::_0)
614 }
615 #[doc = "A channel event has occurred."]
616 #[inline(always)]
617 pub fn _1(self) -> &'a mut W {
618 self.variant(CH7F_A::_1)
619 }
620 #[doc = r"Sets the field bit"]
621 #[inline(always)]
622 pub fn set_bit(self) -> &'a mut W {
623 self.bit(true)
624 }
625 #[doc = r"Clears the field bit"]
626 #[inline(always)]
627 pub fn clear_bit(self) -> &'a mut W {
628 self.bit(false)
629 }
630 #[doc = r"Writes raw bits to the field"]
631 #[inline(always)]
632 pub fn bit(self, value: bool) -> &'a mut W {
633 self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
634 self.w
635 }
636}
637impl R {
638 #[doc = "Bit 0 - Channel 0 Flag"]
639 #[inline(always)]
640 pub fn ch0f(&self) -> CH0F_R {
641 CH0F_R::new((self.bits & 0x01) != 0)
642 }
643 #[doc = "Bit 1 - Channel 1 Flag"]
644 #[inline(always)]
645 pub fn ch1f(&self) -> CH1F_R {
646 CH1F_R::new(((self.bits >> 1) & 0x01) != 0)
647 }
648 #[doc = "Bit 2 - Channel 2 Flag"]
649 #[inline(always)]
650 pub fn ch2f(&self) -> CH2F_R {
651 CH2F_R::new(((self.bits >> 2) & 0x01) != 0)
652 }
653 #[doc = "Bit 3 - Channel 3 Flag"]
654 #[inline(always)]
655 pub fn ch3f(&self) -> CH3F_R {
656 CH3F_R::new(((self.bits >> 3) & 0x01) != 0)
657 }
658 #[doc = "Bit 4 - Channel 4 Flag"]
659 #[inline(always)]
660 pub fn ch4f(&self) -> CH4F_R {
661 CH4F_R::new(((self.bits >> 4) & 0x01) != 0)
662 }
663 #[doc = "Bit 5 - Channel 5 Flag"]
664 #[inline(always)]
665 pub fn ch5f(&self) -> CH5F_R {
666 CH5F_R::new(((self.bits >> 5) & 0x01) != 0)
667 }
668 #[doc = "Bit 6 - Channel 6 Flag"]
669 #[inline(always)]
670 pub fn ch6f(&self) -> CH6F_R {
671 CH6F_R::new(((self.bits >> 6) & 0x01) != 0)
672 }
673 #[doc = "Bit 7 - Channel 7 Flag"]
674 #[inline(always)]
675 pub fn ch7f(&self) -> CH7F_R {
676 CH7F_R::new(((self.bits >> 7) & 0x01) != 0)
677 }
678}
679impl W {
680 #[doc = "Bit 0 - Channel 0 Flag"]
681 #[inline(always)]
682 pub fn ch0f(&mut self) -> CH0F_W {
683 CH0F_W { w: self }
684 }
685 #[doc = "Bit 1 - Channel 1 Flag"]
686 #[inline(always)]
687 pub fn ch1f(&mut self) -> CH1F_W {
688 CH1F_W { w: self }
689 }
690 #[doc = "Bit 2 - Channel 2 Flag"]
691 #[inline(always)]
692 pub fn ch2f(&mut self) -> CH2F_W {
693 CH2F_W { w: self }
694 }
695 #[doc = "Bit 3 - Channel 3 Flag"]
696 #[inline(always)]
697 pub fn ch3f(&mut self) -> CH3F_W {
698 CH3F_W { w: self }
699 }
700 #[doc = "Bit 4 - Channel 4 Flag"]
701 #[inline(always)]
702 pub fn ch4f(&mut self) -> CH4F_W {
703 CH4F_W { w: self }
704 }
705 #[doc = "Bit 5 - Channel 5 Flag"]
706 #[inline(always)]
707 pub fn ch5f(&mut self) -> CH5F_W {
708 CH5F_W { w: self }
709 }
710 #[doc = "Bit 6 - Channel 6 Flag"]
711 #[inline(always)]
712 pub fn ch6f(&mut self) -> CH6F_W {
713 CH6F_W { w: self }
714 }
715 #[doc = "Bit 7 - Channel 7 Flag"]
716 #[inline(always)]
717 pub fn ch7f(&mut self) -> CH7F_W {
718 CH7F_W { w: self }
719 }
720}