1#[doc = "Reader of register SWOCTRL"]
2pub type R = crate::R<u32, super::SWOCTRL>;
3#[doc = "Writer for register SWOCTRL"]
4pub type W = crate::W<u32, super::SWOCTRL>;
5#[doc = "Register SWOCTRL `reset()`'s with value 0"]
6impl crate::ResetValue for super::SWOCTRL {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Channel 0 Software Output Control Enable\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum CH0OC_A {
16 #[doc = "0: The channel output is not affected by software output control."]
17 _0 = 0,
18 #[doc = "1: The channel output is affected by software output control."]
19 _1 = 1,
20}
21impl From<CH0OC_A> for bool {
22 #[inline(always)]
23 fn from(variant: CH0OC_A) -> Self {
24 variant as u8 != 0
25 }
26}
27#[doc = "Reader of field `CH0OC`"]
28pub type CH0OC_R = crate::R<bool, CH0OC_A>;
29impl CH0OC_R {
30 #[doc = r"Get enumerated values variant"]
31 #[inline(always)]
32 pub fn variant(&self) -> CH0OC_A {
33 match self.bits {
34 false => CH0OC_A::_0,
35 true => CH0OC_A::_1,
36 }
37 }
38 #[doc = "Checks if the value of the field is `_0`"]
39 #[inline(always)]
40 pub fn is_0(&self) -> bool {
41 *self == CH0OC_A::_0
42 }
43 #[doc = "Checks if the value of the field is `_1`"]
44 #[inline(always)]
45 pub fn is_1(&self) -> bool {
46 *self == CH0OC_A::_1
47 }
48}
49#[doc = "Write proxy for field `CH0OC`"]
50pub struct CH0OC_W<'a> {
51 w: &'a mut W,
52}
53impl<'a> CH0OC_W<'a> {
54 #[doc = r"Writes `variant` to the field"]
55 #[inline(always)]
56 pub fn variant(self, variant: CH0OC_A) -> &'a mut W {
57 {
58 self.bit(variant.into())
59 }
60 }
61 #[doc = "The channel output is not affected by software output control."]
62 #[inline(always)]
63 pub fn _0(self) -> &'a mut W {
64 self.variant(CH0OC_A::_0)
65 }
66 #[doc = "The channel output is affected by software output control."]
67 #[inline(always)]
68 pub fn _1(self) -> &'a mut W {
69 self.variant(CH0OC_A::_1)
70 }
71 #[doc = r"Sets the field bit"]
72 #[inline(always)]
73 pub fn set_bit(self) -> &'a mut W {
74 self.bit(true)
75 }
76 #[doc = r"Clears the field bit"]
77 #[inline(always)]
78 pub fn clear_bit(self) -> &'a mut W {
79 self.bit(false)
80 }
81 #[doc = r"Writes raw bits to the field"]
82 #[inline(always)]
83 pub fn bit(self, value: bool) -> &'a mut W {
84 self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
85 self.w
86 }
87}
88#[doc = "Channel 1 Software Output Control Enable\n\nValue on reset: 0"]
89#[derive(Clone, Copy, Debug, PartialEq)]
90pub enum CH1OC_A {
91 #[doc = "0: The channel output is not affected by software output control."]
92 _0 = 0,
93 #[doc = "1: The channel output is affected by software output control."]
94 _1 = 1,
95}
96impl From<CH1OC_A> for bool {
97 #[inline(always)]
98 fn from(variant: CH1OC_A) -> Self {
99 variant as u8 != 0
100 }
101}
102#[doc = "Reader of field `CH1OC`"]
103pub type CH1OC_R = crate::R<bool, CH1OC_A>;
104impl CH1OC_R {
105 #[doc = r"Get enumerated values variant"]
106 #[inline(always)]
107 pub fn variant(&self) -> CH1OC_A {
108 match self.bits {
109 false => CH1OC_A::_0,
110 true => CH1OC_A::_1,
111 }
112 }
113 #[doc = "Checks if the value of the field is `_0`"]
114 #[inline(always)]
115 pub fn is_0(&self) -> bool {
116 *self == CH1OC_A::_0
117 }
118 #[doc = "Checks if the value of the field is `_1`"]
119 #[inline(always)]
120 pub fn is_1(&self) -> bool {
121 *self == CH1OC_A::_1
122 }
123}
124#[doc = "Write proxy for field `CH1OC`"]
125pub struct CH1OC_W<'a> {
126 w: &'a mut W,
127}
128impl<'a> CH1OC_W<'a> {
129 #[doc = r"Writes `variant` to the field"]
130 #[inline(always)]
131 pub fn variant(self, variant: CH1OC_A) -> &'a mut W {
132 {
133 self.bit(variant.into())
134 }
135 }
136 #[doc = "The channel output is not affected by software output control."]
137 #[inline(always)]
138 pub fn _0(self) -> &'a mut W {
139 self.variant(CH1OC_A::_0)
140 }
141 #[doc = "The channel output is affected by software output control."]
142 #[inline(always)]
143 pub fn _1(self) -> &'a mut W {
144 self.variant(CH1OC_A::_1)
145 }
146 #[doc = r"Sets the field bit"]
147 #[inline(always)]
148 pub fn set_bit(self) -> &'a mut W {
149 self.bit(true)
150 }
151 #[doc = r"Clears the field bit"]
152 #[inline(always)]
153 pub fn clear_bit(self) -> &'a mut W {
154 self.bit(false)
155 }
156 #[doc = r"Writes raw bits to the field"]
157 #[inline(always)]
158 pub fn bit(self, value: bool) -> &'a mut W {
159 self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
160 self.w
161 }
162}
163#[doc = "Channel 2 Software Output Control Enable\n\nValue on reset: 0"]
164#[derive(Clone, Copy, Debug, PartialEq)]
165pub enum CH2OC_A {
166 #[doc = "0: The channel output is not affected by software output control."]
167 _0 = 0,
168 #[doc = "1: The channel output is affected by software output control."]
169 _1 = 1,
170}
171impl From<CH2OC_A> for bool {
172 #[inline(always)]
173 fn from(variant: CH2OC_A) -> Self {
174 variant as u8 != 0
175 }
176}
177#[doc = "Reader of field `CH2OC`"]
178pub type CH2OC_R = crate::R<bool, CH2OC_A>;
179impl CH2OC_R {
180 #[doc = r"Get enumerated values variant"]
181 #[inline(always)]
182 pub fn variant(&self) -> CH2OC_A {
183 match self.bits {
184 false => CH2OC_A::_0,
185 true => CH2OC_A::_1,
186 }
187 }
188 #[doc = "Checks if the value of the field is `_0`"]
189 #[inline(always)]
190 pub fn is_0(&self) -> bool {
191 *self == CH2OC_A::_0
192 }
193 #[doc = "Checks if the value of the field is `_1`"]
194 #[inline(always)]
195 pub fn is_1(&self) -> bool {
196 *self == CH2OC_A::_1
197 }
198}
199#[doc = "Write proxy for field `CH2OC`"]
200pub struct CH2OC_W<'a> {
201 w: &'a mut W,
202}
203impl<'a> CH2OC_W<'a> {
204 #[doc = r"Writes `variant` to the field"]
205 #[inline(always)]
206 pub fn variant(self, variant: CH2OC_A) -> &'a mut W {
207 {
208 self.bit(variant.into())
209 }
210 }
211 #[doc = "The channel output is not affected by software output control."]
212 #[inline(always)]
213 pub fn _0(self) -> &'a mut W {
214 self.variant(CH2OC_A::_0)
215 }
216 #[doc = "The channel output is affected by software output control."]
217 #[inline(always)]
218 pub fn _1(self) -> &'a mut W {
219 self.variant(CH2OC_A::_1)
220 }
221 #[doc = r"Sets the field bit"]
222 #[inline(always)]
223 pub fn set_bit(self) -> &'a mut W {
224 self.bit(true)
225 }
226 #[doc = r"Clears the field bit"]
227 #[inline(always)]
228 pub fn clear_bit(self) -> &'a mut W {
229 self.bit(false)
230 }
231 #[doc = r"Writes raw bits to the field"]
232 #[inline(always)]
233 pub fn bit(self, value: bool) -> &'a mut W {
234 self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
235 self.w
236 }
237}
238#[doc = "Channel 3 Software Output Control Enable\n\nValue on reset: 0"]
239#[derive(Clone, Copy, Debug, PartialEq)]
240pub enum CH3OC_A {
241 #[doc = "0: The channel output is not affected by software output control."]
242 _0 = 0,
243 #[doc = "1: The channel output is affected by software output control."]
244 _1 = 1,
245}
246impl From<CH3OC_A> for bool {
247 #[inline(always)]
248 fn from(variant: CH3OC_A) -> Self {
249 variant as u8 != 0
250 }
251}
252#[doc = "Reader of field `CH3OC`"]
253pub type CH3OC_R = crate::R<bool, CH3OC_A>;
254impl CH3OC_R {
255 #[doc = r"Get enumerated values variant"]
256 #[inline(always)]
257 pub fn variant(&self) -> CH3OC_A {
258 match self.bits {
259 false => CH3OC_A::_0,
260 true => CH3OC_A::_1,
261 }
262 }
263 #[doc = "Checks if the value of the field is `_0`"]
264 #[inline(always)]
265 pub fn is_0(&self) -> bool {
266 *self == CH3OC_A::_0
267 }
268 #[doc = "Checks if the value of the field is `_1`"]
269 #[inline(always)]
270 pub fn is_1(&self) -> bool {
271 *self == CH3OC_A::_1
272 }
273}
274#[doc = "Write proxy for field `CH3OC`"]
275pub struct CH3OC_W<'a> {
276 w: &'a mut W,
277}
278impl<'a> CH3OC_W<'a> {
279 #[doc = r"Writes `variant` to the field"]
280 #[inline(always)]
281 pub fn variant(self, variant: CH3OC_A) -> &'a mut W {
282 {
283 self.bit(variant.into())
284 }
285 }
286 #[doc = "The channel output is not affected by software output control."]
287 #[inline(always)]
288 pub fn _0(self) -> &'a mut W {
289 self.variant(CH3OC_A::_0)
290 }
291 #[doc = "The channel output is affected by software output control."]
292 #[inline(always)]
293 pub fn _1(self) -> &'a mut W {
294 self.variant(CH3OC_A::_1)
295 }
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 = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
310 self.w
311 }
312}
313#[doc = "Channel 4 Software Output Control Enable\n\nValue on reset: 0"]
314#[derive(Clone, Copy, Debug, PartialEq)]
315pub enum CH4OC_A {
316 #[doc = "0: The channel output is not affected by software output control."]
317 _0 = 0,
318 #[doc = "1: The channel output is affected by software output control."]
319 _1 = 1,
320}
321impl From<CH4OC_A> for bool {
322 #[inline(always)]
323 fn from(variant: CH4OC_A) -> Self {
324 variant as u8 != 0
325 }
326}
327#[doc = "Reader of field `CH4OC`"]
328pub type CH4OC_R = crate::R<bool, CH4OC_A>;
329impl CH4OC_R {
330 #[doc = r"Get enumerated values variant"]
331 #[inline(always)]
332 pub fn variant(&self) -> CH4OC_A {
333 match self.bits {
334 false => CH4OC_A::_0,
335 true => CH4OC_A::_1,
336 }
337 }
338 #[doc = "Checks if the value of the field is `_0`"]
339 #[inline(always)]
340 pub fn is_0(&self) -> bool {
341 *self == CH4OC_A::_0
342 }
343 #[doc = "Checks if the value of the field is `_1`"]
344 #[inline(always)]
345 pub fn is_1(&self) -> bool {
346 *self == CH4OC_A::_1
347 }
348}
349#[doc = "Write proxy for field `CH4OC`"]
350pub struct CH4OC_W<'a> {
351 w: &'a mut W,
352}
353impl<'a> CH4OC_W<'a> {
354 #[doc = r"Writes `variant` to the field"]
355 #[inline(always)]
356 pub fn variant(self, variant: CH4OC_A) -> &'a mut W {
357 {
358 self.bit(variant.into())
359 }
360 }
361 #[doc = "The channel output is not affected by software output control."]
362 #[inline(always)]
363 pub fn _0(self) -> &'a mut W {
364 self.variant(CH4OC_A::_0)
365 }
366 #[doc = "The channel output is affected by software output control."]
367 #[inline(always)]
368 pub fn _1(self) -> &'a mut W {
369 self.variant(CH4OC_A::_1)
370 }
371 #[doc = r"Sets the field bit"]
372 #[inline(always)]
373 pub fn set_bit(self) -> &'a mut W {
374 self.bit(true)
375 }
376 #[doc = r"Clears the field bit"]
377 #[inline(always)]
378 pub fn clear_bit(self) -> &'a mut W {
379 self.bit(false)
380 }
381 #[doc = r"Writes raw bits to the field"]
382 #[inline(always)]
383 pub fn bit(self, value: bool) -> &'a mut W {
384 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
385 self.w
386 }
387}
388#[doc = "Channel 5 Software Output Control Enable\n\nValue on reset: 0"]
389#[derive(Clone, Copy, Debug, PartialEq)]
390pub enum CH5OC_A {
391 #[doc = "0: The channel output is not affected by software output control."]
392 _0 = 0,
393 #[doc = "1: The channel output is affected by software output control."]
394 _1 = 1,
395}
396impl From<CH5OC_A> for bool {
397 #[inline(always)]
398 fn from(variant: CH5OC_A) -> Self {
399 variant as u8 != 0
400 }
401}
402#[doc = "Reader of field `CH5OC`"]
403pub type CH5OC_R = crate::R<bool, CH5OC_A>;
404impl CH5OC_R {
405 #[doc = r"Get enumerated values variant"]
406 #[inline(always)]
407 pub fn variant(&self) -> CH5OC_A {
408 match self.bits {
409 false => CH5OC_A::_0,
410 true => CH5OC_A::_1,
411 }
412 }
413 #[doc = "Checks if the value of the field is `_0`"]
414 #[inline(always)]
415 pub fn is_0(&self) -> bool {
416 *self == CH5OC_A::_0
417 }
418 #[doc = "Checks if the value of the field is `_1`"]
419 #[inline(always)]
420 pub fn is_1(&self) -> bool {
421 *self == CH5OC_A::_1
422 }
423}
424#[doc = "Write proxy for field `CH5OC`"]
425pub struct CH5OC_W<'a> {
426 w: &'a mut W,
427}
428impl<'a> CH5OC_W<'a> {
429 #[doc = r"Writes `variant` to the field"]
430 #[inline(always)]
431 pub fn variant(self, variant: CH5OC_A) -> &'a mut W {
432 {
433 self.bit(variant.into())
434 }
435 }
436 #[doc = "The channel output is not affected by software output control."]
437 #[inline(always)]
438 pub fn _0(self) -> &'a mut W {
439 self.variant(CH5OC_A::_0)
440 }
441 #[doc = "The channel output is affected by software output control."]
442 #[inline(always)]
443 pub fn _1(self) -> &'a mut W {
444 self.variant(CH5OC_A::_1)
445 }
446 #[doc = r"Sets the field bit"]
447 #[inline(always)]
448 pub fn set_bit(self) -> &'a mut W {
449 self.bit(true)
450 }
451 #[doc = r"Clears the field bit"]
452 #[inline(always)]
453 pub fn clear_bit(self) -> &'a mut W {
454 self.bit(false)
455 }
456 #[doc = r"Writes raw bits to the field"]
457 #[inline(always)]
458 pub fn bit(self, value: bool) -> &'a mut W {
459 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
460 self.w
461 }
462}
463#[doc = "Channel 6 Software Output Control Enable\n\nValue on reset: 0"]
464#[derive(Clone, Copy, Debug, PartialEq)]
465pub enum CH6OC_A {
466 #[doc = "0: The channel output is not affected by software output control."]
467 _0 = 0,
468 #[doc = "1: The channel output is affected by software output control."]
469 _1 = 1,
470}
471impl From<CH6OC_A> for bool {
472 #[inline(always)]
473 fn from(variant: CH6OC_A) -> Self {
474 variant as u8 != 0
475 }
476}
477#[doc = "Reader of field `CH6OC`"]
478pub type CH6OC_R = crate::R<bool, CH6OC_A>;
479impl CH6OC_R {
480 #[doc = r"Get enumerated values variant"]
481 #[inline(always)]
482 pub fn variant(&self) -> CH6OC_A {
483 match self.bits {
484 false => CH6OC_A::_0,
485 true => CH6OC_A::_1,
486 }
487 }
488 #[doc = "Checks if the value of the field is `_0`"]
489 #[inline(always)]
490 pub fn is_0(&self) -> bool {
491 *self == CH6OC_A::_0
492 }
493 #[doc = "Checks if the value of the field is `_1`"]
494 #[inline(always)]
495 pub fn is_1(&self) -> bool {
496 *self == CH6OC_A::_1
497 }
498}
499#[doc = "Write proxy for field `CH6OC`"]
500pub struct CH6OC_W<'a> {
501 w: &'a mut W,
502}
503impl<'a> CH6OC_W<'a> {
504 #[doc = r"Writes `variant` to the field"]
505 #[inline(always)]
506 pub fn variant(self, variant: CH6OC_A) -> &'a mut W {
507 {
508 self.bit(variant.into())
509 }
510 }
511 #[doc = "The channel output is not affected by software output control."]
512 #[inline(always)]
513 pub fn _0(self) -> &'a mut W {
514 self.variant(CH6OC_A::_0)
515 }
516 #[doc = "The channel output is affected by software output control."]
517 #[inline(always)]
518 pub fn _1(self) -> &'a mut W {
519 self.variant(CH6OC_A::_1)
520 }
521 #[doc = r"Sets the field bit"]
522 #[inline(always)]
523 pub fn set_bit(self) -> &'a mut W {
524 self.bit(true)
525 }
526 #[doc = r"Clears the field bit"]
527 #[inline(always)]
528 pub fn clear_bit(self) -> &'a mut W {
529 self.bit(false)
530 }
531 #[doc = r"Writes raw bits to the field"]
532 #[inline(always)]
533 pub fn bit(self, value: bool) -> &'a mut W {
534 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
535 self.w
536 }
537}
538#[doc = "Channel 7 Software Output Control Enable\n\nValue on reset: 0"]
539#[derive(Clone, Copy, Debug, PartialEq)]
540pub enum CH7OC_A {
541 #[doc = "0: The channel output is not affected by software output control."]
542 _0 = 0,
543 #[doc = "1: The channel output is affected by software output control."]
544 _1 = 1,
545}
546impl From<CH7OC_A> for bool {
547 #[inline(always)]
548 fn from(variant: CH7OC_A) -> Self {
549 variant as u8 != 0
550 }
551}
552#[doc = "Reader of field `CH7OC`"]
553pub type CH7OC_R = crate::R<bool, CH7OC_A>;
554impl CH7OC_R {
555 #[doc = r"Get enumerated values variant"]
556 #[inline(always)]
557 pub fn variant(&self) -> CH7OC_A {
558 match self.bits {
559 false => CH7OC_A::_0,
560 true => CH7OC_A::_1,
561 }
562 }
563 #[doc = "Checks if the value of the field is `_0`"]
564 #[inline(always)]
565 pub fn is_0(&self) -> bool {
566 *self == CH7OC_A::_0
567 }
568 #[doc = "Checks if the value of the field is `_1`"]
569 #[inline(always)]
570 pub fn is_1(&self) -> bool {
571 *self == CH7OC_A::_1
572 }
573}
574#[doc = "Write proxy for field `CH7OC`"]
575pub struct CH7OC_W<'a> {
576 w: &'a mut W,
577}
578impl<'a> CH7OC_W<'a> {
579 #[doc = r"Writes `variant` to the field"]
580 #[inline(always)]
581 pub fn variant(self, variant: CH7OC_A) -> &'a mut W {
582 {
583 self.bit(variant.into())
584 }
585 }
586 #[doc = "The channel output is not affected by software output control."]
587 #[inline(always)]
588 pub fn _0(self) -> &'a mut W {
589 self.variant(CH7OC_A::_0)
590 }
591 #[doc = "The channel output is affected by software output control."]
592 #[inline(always)]
593 pub fn _1(self) -> &'a mut W {
594 self.variant(CH7OC_A::_1)
595 }
596 #[doc = r"Sets the field bit"]
597 #[inline(always)]
598 pub fn set_bit(self) -> &'a mut W {
599 self.bit(true)
600 }
601 #[doc = r"Clears the field bit"]
602 #[inline(always)]
603 pub fn clear_bit(self) -> &'a mut W {
604 self.bit(false)
605 }
606 #[doc = r"Writes raw bits to the field"]
607 #[inline(always)]
608 pub fn bit(self, value: bool) -> &'a mut W {
609 self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
610 self.w
611 }
612}
613#[doc = "Channel 0 Software Output Control Value\n\nValue on reset: 0"]
614#[derive(Clone, Copy, Debug, PartialEq)]
615pub enum CH0OCV_A {
616 #[doc = "0: The software output control forces 0 to the channel output."]
617 _0 = 0,
618 #[doc = "1: The software output control forces 1 to the channel output."]
619 _1 = 1,
620}
621impl From<CH0OCV_A> for bool {
622 #[inline(always)]
623 fn from(variant: CH0OCV_A) -> Self {
624 variant as u8 != 0
625 }
626}
627#[doc = "Reader of field `CH0OCV`"]
628pub type CH0OCV_R = crate::R<bool, CH0OCV_A>;
629impl CH0OCV_R {
630 #[doc = r"Get enumerated values variant"]
631 #[inline(always)]
632 pub fn variant(&self) -> CH0OCV_A {
633 match self.bits {
634 false => CH0OCV_A::_0,
635 true => CH0OCV_A::_1,
636 }
637 }
638 #[doc = "Checks if the value of the field is `_0`"]
639 #[inline(always)]
640 pub fn is_0(&self) -> bool {
641 *self == CH0OCV_A::_0
642 }
643 #[doc = "Checks if the value of the field is `_1`"]
644 #[inline(always)]
645 pub fn is_1(&self) -> bool {
646 *self == CH0OCV_A::_1
647 }
648}
649#[doc = "Write proxy for field `CH0OCV`"]
650pub struct CH0OCV_W<'a> {
651 w: &'a mut W,
652}
653impl<'a> CH0OCV_W<'a> {
654 #[doc = r"Writes `variant` to the field"]
655 #[inline(always)]
656 pub fn variant(self, variant: CH0OCV_A) -> &'a mut W {
657 {
658 self.bit(variant.into())
659 }
660 }
661 #[doc = "The software output control forces 0 to the channel output."]
662 #[inline(always)]
663 pub fn _0(self) -> &'a mut W {
664 self.variant(CH0OCV_A::_0)
665 }
666 #[doc = "The software output control forces 1 to the channel output."]
667 #[inline(always)]
668 pub fn _1(self) -> &'a mut W {
669 self.variant(CH0OCV_A::_1)
670 }
671 #[doc = r"Sets the field bit"]
672 #[inline(always)]
673 pub fn set_bit(self) -> &'a mut W {
674 self.bit(true)
675 }
676 #[doc = r"Clears the field bit"]
677 #[inline(always)]
678 pub fn clear_bit(self) -> &'a mut W {
679 self.bit(false)
680 }
681 #[doc = r"Writes raw bits to the field"]
682 #[inline(always)]
683 pub fn bit(self, value: bool) -> &'a mut W {
684 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
685 self.w
686 }
687}
688#[doc = "Channel 1 Software Output Control Value\n\nValue on reset: 0"]
689#[derive(Clone, Copy, Debug, PartialEq)]
690pub enum CH1OCV_A {
691 #[doc = "0: The software output control forces 0 to the channel output."]
692 _0 = 0,
693 #[doc = "1: The software output control forces 1 to the channel output."]
694 _1 = 1,
695}
696impl From<CH1OCV_A> for bool {
697 #[inline(always)]
698 fn from(variant: CH1OCV_A) -> Self {
699 variant as u8 != 0
700 }
701}
702#[doc = "Reader of field `CH1OCV`"]
703pub type CH1OCV_R = crate::R<bool, CH1OCV_A>;
704impl CH1OCV_R {
705 #[doc = r"Get enumerated values variant"]
706 #[inline(always)]
707 pub fn variant(&self) -> CH1OCV_A {
708 match self.bits {
709 false => CH1OCV_A::_0,
710 true => CH1OCV_A::_1,
711 }
712 }
713 #[doc = "Checks if the value of the field is `_0`"]
714 #[inline(always)]
715 pub fn is_0(&self) -> bool {
716 *self == CH1OCV_A::_0
717 }
718 #[doc = "Checks if the value of the field is `_1`"]
719 #[inline(always)]
720 pub fn is_1(&self) -> bool {
721 *self == CH1OCV_A::_1
722 }
723}
724#[doc = "Write proxy for field `CH1OCV`"]
725pub struct CH1OCV_W<'a> {
726 w: &'a mut W,
727}
728impl<'a> CH1OCV_W<'a> {
729 #[doc = r"Writes `variant` to the field"]
730 #[inline(always)]
731 pub fn variant(self, variant: CH1OCV_A) -> &'a mut W {
732 {
733 self.bit(variant.into())
734 }
735 }
736 #[doc = "The software output control forces 0 to the channel output."]
737 #[inline(always)]
738 pub fn _0(self) -> &'a mut W {
739 self.variant(CH1OCV_A::_0)
740 }
741 #[doc = "The software output control forces 1 to the channel output."]
742 #[inline(always)]
743 pub fn _1(self) -> &'a mut W {
744 self.variant(CH1OCV_A::_1)
745 }
746 #[doc = r"Sets the field bit"]
747 #[inline(always)]
748 pub fn set_bit(self) -> &'a mut W {
749 self.bit(true)
750 }
751 #[doc = r"Clears the field bit"]
752 #[inline(always)]
753 pub fn clear_bit(self) -> &'a mut W {
754 self.bit(false)
755 }
756 #[doc = r"Writes raw bits to the field"]
757 #[inline(always)]
758 pub fn bit(self, value: bool) -> &'a mut W {
759 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
760 self.w
761 }
762}
763#[doc = "Channel 2 Software Output Control Value\n\nValue on reset: 0"]
764#[derive(Clone, Copy, Debug, PartialEq)]
765pub enum CH2OCV_A {
766 #[doc = "0: The software output control forces 0 to the channel output."]
767 _0 = 0,
768 #[doc = "1: The software output control forces 1 to the channel output."]
769 _1 = 1,
770}
771impl From<CH2OCV_A> for bool {
772 #[inline(always)]
773 fn from(variant: CH2OCV_A) -> Self {
774 variant as u8 != 0
775 }
776}
777#[doc = "Reader of field `CH2OCV`"]
778pub type CH2OCV_R = crate::R<bool, CH2OCV_A>;
779impl CH2OCV_R {
780 #[doc = r"Get enumerated values variant"]
781 #[inline(always)]
782 pub fn variant(&self) -> CH2OCV_A {
783 match self.bits {
784 false => CH2OCV_A::_0,
785 true => CH2OCV_A::_1,
786 }
787 }
788 #[doc = "Checks if the value of the field is `_0`"]
789 #[inline(always)]
790 pub fn is_0(&self) -> bool {
791 *self == CH2OCV_A::_0
792 }
793 #[doc = "Checks if the value of the field is `_1`"]
794 #[inline(always)]
795 pub fn is_1(&self) -> bool {
796 *self == CH2OCV_A::_1
797 }
798}
799#[doc = "Write proxy for field `CH2OCV`"]
800pub struct CH2OCV_W<'a> {
801 w: &'a mut W,
802}
803impl<'a> CH2OCV_W<'a> {
804 #[doc = r"Writes `variant` to the field"]
805 #[inline(always)]
806 pub fn variant(self, variant: CH2OCV_A) -> &'a mut W {
807 {
808 self.bit(variant.into())
809 }
810 }
811 #[doc = "The software output control forces 0 to the channel output."]
812 #[inline(always)]
813 pub fn _0(self) -> &'a mut W {
814 self.variant(CH2OCV_A::_0)
815 }
816 #[doc = "The software output control forces 1 to the channel output."]
817 #[inline(always)]
818 pub fn _1(self) -> &'a mut W {
819 self.variant(CH2OCV_A::_1)
820 }
821 #[doc = r"Sets the field bit"]
822 #[inline(always)]
823 pub fn set_bit(self) -> &'a mut W {
824 self.bit(true)
825 }
826 #[doc = r"Clears the field bit"]
827 #[inline(always)]
828 pub fn clear_bit(self) -> &'a mut W {
829 self.bit(false)
830 }
831 #[doc = r"Writes raw bits to the field"]
832 #[inline(always)]
833 pub fn bit(self, value: bool) -> &'a mut W {
834 self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
835 self.w
836 }
837}
838#[doc = "Channel 3 Software Output Control Value\n\nValue on reset: 0"]
839#[derive(Clone, Copy, Debug, PartialEq)]
840pub enum CH3OCV_A {
841 #[doc = "0: The software output control forces 0 to the channel output."]
842 _0 = 0,
843 #[doc = "1: The software output control forces 1 to the channel output."]
844 _1 = 1,
845}
846impl From<CH3OCV_A> for bool {
847 #[inline(always)]
848 fn from(variant: CH3OCV_A) -> Self {
849 variant as u8 != 0
850 }
851}
852#[doc = "Reader of field `CH3OCV`"]
853pub type CH3OCV_R = crate::R<bool, CH3OCV_A>;
854impl CH3OCV_R {
855 #[doc = r"Get enumerated values variant"]
856 #[inline(always)]
857 pub fn variant(&self) -> CH3OCV_A {
858 match self.bits {
859 false => CH3OCV_A::_0,
860 true => CH3OCV_A::_1,
861 }
862 }
863 #[doc = "Checks if the value of the field is `_0`"]
864 #[inline(always)]
865 pub fn is_0(&self) -> bool {
866 *self == CH3OCV_A::_0
867 }
868 #[doc = "Checks if the value of the field is `_1`"]
869 #[inline(always)]
870 pub fn is_1(&self) -> bool {
871 *self == CH3OCV_A::_1
872 }
873}
874#[doc = "Write proxy for field `CH3OCV`"]
875pub struct CH3OCV_W<'a> {
876 w: &'a mut W,
877}
878impl<'a> CH3OCV_W<'a> {
879 #[doc = r"Writes `variant` to the field"]
880 #[inline(always)]
881 pub fn variant(self, variant: CH3OCV_A) -> &'a mut W {
882 {
883 self.bit(variant.into())
884 }
885 }
886 #[doc = "The software output control forces 0 to the channel output."]
887 #[inline(always)]
888 pub fn _0(self) -> &'a mut W {
889 self.variant(CH3OCV_A::_0)
890 }
891 #[doc = "The software output control forces 1 to the channel output."]
892 #[inline(always)]
893 pub fn _1(self) -> &'a mut W {
894 self.variant(CH3OCV_A::_1)
895 }
896 #[doc = r"Sets the field bit"]
897 #[inline(always)]
898 pub fn set_bit(self) -> &'a mut W {
899 self.bit(true)
900 }
901 #[doc = r"Clears the field bit"]
902 #[inline(always)]
903 pub fn clear_bit(self) -> &'a mut W {
904 self.bit(false)
905 }
906 #[doc = r"Writes raw bits to the field"]
907 #[inline(always)]
908 pub fn bit(self, value: bool) -> &'a mut W {
909 self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
910 self.w
911 }
912}
913#[doc = "Channel 4 Software Output Control Value\n\nValue on reset: 0"]
914#[derive(Clone, Copy, Debug, PartialEq)]
915pub enum CH4OCV_A {
916 #[doc = "0: The software output control forces 0 to the channel output."]
917 _0 = 0,
918 #[doc = "1: The software output control forces 1 to the channel output."]
919 _1 = 1,
920}
921impl From<CH4OCV_A> for bool {
922 #[inline(always)]
923 fn from(variant: CH4OCV_A) -> Self {
924 variant as u8 != 0
925 }
926}
927#[doc = "Reader of field `CH4OCV`"]
928pub type CH4OCV_R = crate::R<bool, CH4OCV_A>;
929impl CH4OCV_R {
930 #[doc = r"Get enumerated values variant"]
931 #[inline(always)]
932 pub fn variant(&self) -> CH4OCV_A {
933 match self.bits {
934 false => CH4OCV_A::_0,
935 true => CH4OCV_A::_1,
936 }
937 }
938 #[doc = "Checks if the value of the field is `_0`"]
939 #[inline(always)]
940 pub fn is_0(&self) -> bool {
941 *self == CH4OCV_A::_0
942 }
943 #[doc = "Checks if the value of the field is `_1`"]
944 #[inline(always)]
945 pub fn is_1(&self) -> bool {
946 *self == CH4OCV_A::_1
947 }
948}
949#[doc = "Write proxy for field `CH4OCV`"]
950pub struct CH4OCV_W<'a> {
951 w: &'a mut W,
952}
953impl<'a> CH4OCV_W<'a> {
954 #[doc = r"Writes `variant` to the field"]
955 #[inline(always)]
956 pub fn variant(self, variant: CH4OCV_A) -> &'a mut W {
957 {
958 self.bit(variant.into())
959 }
960 }
961 #[doc = "The software output control forces 0 to the channel output."]
962 #[inline(always)]
963 pub fn _0(self) -> &'a mut W {
964 self.variant(CH4OCV_A::_0)
965 }
966 #[doc = "The software output control forces 1 to the channel output."]
967 #[inline(always)]
968 pub fn _1(self) -> &'a mut W {
969 self.variant(CH4OCV_A::_1)
970 }
971 #[doc = r"Sets the field bit"]
972 #[inline(always)]
973 pub fn set_bit(self) -> &'a mut W {
974 self.bit(true)
975 }
976 #[doc = r"Clears the field bit"]
977 #[inline(always)]
978 pub fn clear_bit(self) -> &'a mut W {
979 self.bit(false)
980 }
981 #[doc = r"Writes raw bits to the field"]
982 #[inline(always)]
983 pub fn bit(self, value: bool) -> &'a mut W {
984 self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
985 self.w
986 }
987}
988#[doc = "Channel 5 Software Output Control Value\n\nValue on reset: 0"]
989#[derive(Clone, Copy, Debug, PartialEq)]
990pub enum CH5OCV_A {
991 #[doc = "0: The software output control forces 0 to the channel output."]
992 _0 = 0,
993 #[doc = "1: The software output control forces 1 to the channel output."]
994 _1 = 1,
995}
996impl From<CH5OCV_A> for bool {
997 #[inline(always)]
998 fn from(variant: CH5OCV_A) -> Self {
999 variant as u8 != 0
1000 }
1001}
1002#[doc = "Reader of field `CH5OCV`"]
1003pub type CH5OCV_R = crate::R<bool, CH5OCV_A>;
1004impl CH5OCV_R {
1005 #[doc = r"Get enumerated values variant"]
1006 #[inline(always)]
1007 pub fn variant(&self) -> CH5OCV_A {
1008 match self.bits {
1009 false => CH5OCV_A::_0,
1010 true => CH5OCV_A::_1,
1011 }
1012 }
1013 #[doc = "Checks if the value of the field is `_0`"]
1014 #[inline(always)]
1015 pub fn is_0(&self) -> bool {
1016 *self == CH5OCV_A::_0
1017 }
1018 #[doc = "Checks if the value of the field is `_1`"]
1019 #[inline(always)]
1020 pub fn is_1(&self) -> bool {
1021 *self == CH5OCV_A::_1
1022 }
1023}
1024#[doc = "Write proxy for field `CH5OCV`"]
1025pub struct CH5OCV_W<'a> {
1026 w: &'a mut W,
1027}
1028impl<'a> CH5OCV_W<'a> {
1029 #[doc = r"Writes `variant` to the field"]
1030 #[inline(always)]
1031 pub fn variant(self, variant: CH5OCV_A) -> &'a mut W {
1032 {
1033 self.bit(variant.into())
1034 }
1035 }
1036 #[doc = "The software output control forces 0 to the channel output."]
1037 #[inline(always)]
1038 pub fn _0(self) -> &'a mut W {
1039 self.variant(CH5OCV_A::_0)
1040 }
1041 #[doc = "The software output control forces 1 to the channel output."]
1042 #[inline(always)]
1043 pub fn _1(self) -> &'a mut W {
1044 self.variant(CH5OCV_A::_1)
1045 }
1046 #[doc = r"Sets the field bit"]
1047 #[inline(always)]
1048 pub fn set_bit(self) -> &'a mut W {
1049 self.bit(true)
1050 }
1051 #[doc = r"Clears the field bit"]
1052 #[inline(always)]
1053 pub fn clear_bit(self) -> &'a mut W {
1054 self.bit(false)
1055 }
1056 #[doc = r"Writes raw bits to the field"]
1057 #[inline(always)]
1058 pub fn bit(self, value: bool) -> &'a mut W {
1059 self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
1060 self.w
1061 }
1062}
1063#[doc = "Channel 6 Software Output Control Value\n\nValue on reset: 0"]
1064#[derive(Clone, Copy, Debug, PartialEq)]
1065pub enum CH6OCV_A {
1066 #[doc = "0: The software output control forces 0 to the channel output."]
1067 _0 = 0,
1068 #[doc = "1: The software output control forces 1 to the channel output."]
1069 _1 = 1,
1070}
1071impl From<CH6OCV_A> for bool {
1072 #[inline(always)]
1073 fn from(variant: CH6OCV_A) -> Self {
1074 variant as u8 != 0
1075 }
1076}
1077#[doc = "Reader of field `CH6OCV`"]
1078pub type CH6OCV_R = crate::R<bool, CH6OCV_A>;
1079impl CH6OCV_R {
1080 #[doc = r"Get enumerated values variant"]
1081 #[inline(always)]
1082 pub fn variant(&self) -> CH6OCV_A {
1083 match self.bits {
1084 false => CH6OCV_A::_0,
1085 true => CH6OCV_A::_1,
1086 }
1087 }
1088 #[doc = "Checks if the value of the field is `_0`"]
1089 #[inline(always)]
1090 pub fn is_0(&self) -> bool {
1091 *self == CH6OCV_A::_0
1092 }
1093 #[doc = "Checks if the value of the field is `_1`"]
1094 #[inline(always)]
1095 pub fn is_1(&self) -> bool {
1096 *self == CH6OCV_A::_1
1097 }
1098}
1099#[doc = "Write proxy for field `CH6OCV`"]
1100pub struct CH6OCV_W<'a> {
1101 w: &'a mut W,
1102}
1103impl<'a> CH6OCV_W<'a> {
1104 #[doc = r"Writes `variant` to the field"]
1105 #[inline(always)]
1106 pub fn variant(self, variant: CH6OCV_A) -> &'a mut W {
1107 {
1108 self.bit(variant.into())
1109 }
1110 }
1111 #[doc = "The software output control forces 0 to the channel output."]
1112 #[inline(always)]
1113 pub fn _0(self) -> &'a mut W {
1114 self.variant(CH6OCV_A::_0)
1115 }
1116 #[doc = "The software output control forces 1 to the channel output."]
1117 #[inline(always)]
1118 pub fn _1(self) -> &'a mut W {
1119 self.variant(CH6OCV_A::_1)
1120 }
1121 #[doc = r"Sets the field bit"]
1122 #[inline(always)]
1123 pub fn set_bit(self) -> &'a mut W {
1124 self.bit(true)
1125 }
1126 #[doc = r"Clears the field bit"]
1127 #[inline(always)]
1128 pub fn clear_bit(self) -> &'a mut W {
1129 self.bit(false)
1130 }
1131 #[doc = r"Writes raw bits to the field"]
1132 #[inline(always)]
1133 pub fn bit(self, value: bool) -> &'a mut W {
1134 self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
1135 self.w
1136 }
1137}
1138#[doc = "Channel 7 Software Output Control Value\n\nValue on reset: 0"]
1139#[derive(Clone, Copy, Debug, PartialEq)]
1140pub enum CH7OCV_A {
1141 #[doc = "0: The software output control forces 0 to the channel output."]
1142 _0 = 0,
1143 #[doc = "1: The software output control forces 1 to the channel output."]
1144 _1 = 1,
1145}
1146impl From<CH7OCV_A> for bool {
1147 #[inline(always)]
1148 fn from(variant: CH7OCV_A) -> Self {
1149 variant as u8 != 0
1150 }
1151}
1152#[doc = "Reader of field `CH7OCV`"]
1153pub type CH7OCV_R = crate::R<bool, CH7OCV_A>;
1154impl CH7OCV_R {
1155 #[doc = r"Get enumerated values variant"]
1156 #[inline(always)]
1157 pub fn variant(&self) -> CH7OCV_A {
1158 match self.bits {
1159 false => CH7OCV_A::_0,
1160 true => CH7OCV_A::_1,
1161 }
1162 }
1163 #[doc = "Checks if the value of the field is `_0`"]
1164 #[inline(always)]
1165 pub fn is_0(&self) -> bool {
1166 *self == CH7OCV_A::_0
1167 }
1168 #[doc = "Checks if the value of the field is `_1`"]
1169 #[inline(always)]
1170 pub fn is_1(&self) -> bool {
1171 *self == CH7OCV_A::_1
1172 }
1173}
1174#[doc = "Write proxy for field `CH7OCV`"]
1175pub struct CH7OCV_W<'a> {
1176 w: &'a mut W,
1177}
1178impl<'a> CH7OCV_W<'a> {
1179 #[doc = r"Writes `variant` to the field"]
1180 #[inline(always)]
1181 pub fn variant(self, variant: CH7OCV_A) -> &'a mut W {
1182 {
1183 self.bit(variant.into())
1184 }
1185 }
1186 #[doc = "The software output control forces 0 to the channel output."]
1187 #[inline(always)]
1188 pub fn _0(self) -> &'a mut W {
1189 self.variant(CH7OCV_A::_0)
1190 }
1191 #[doc = "The software output control forces 1 to the channel output."]
1192 #[inline(always)]
1193 pub fn _1(self) -> &'a mut W {
1194 self.variant(CH7OCV_A::_1)
1195 }
1196 #[doc = r"Sets the field bit"]
1197 #[inline(always)]
1198 pub fn set_bit(self) -> &'a mut W {
1199 self.bit(true)
1200 }
1201 #[doc = r"Clears the field bit"]
1202 #[inline(always)]
1203 pub fn clear_bit(self) -> &'a mut W {
1204 self.bit(false)
1205 }
1206 #[doc = r"Writes raw bits to the field"]
1207 #[inline(always)]
1208 pub fn bit(self, value: bool) -> &'a mut W {
1209 self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
1210 self.w
1211 }
1212}
1213impl R {
1214 #[doc = "Bit 0 - Channel 0 Software Output Control Enable"]
1215 #[inline(always)]
1216 pub fn ch0oc(&self) -> CH0OC_R {
1217 CH0OC_R::new((self.bits & 0x01) != 0)
1218 }
1219 #[doc = "Bit 1 - Channel 1 Software Output Control Enable"]
1220 #[inline(always)]
1221 pub fn ch1oc(&self) -> CH1OC_R {
1222 CH1OC_R::new(((self.bits >> 1) & 0x01) != 0)
1223 }
1224 #[doc = "Bit 2 - Channel 2 Software Output Control Enable"]
1225 #[inline(always)]
1226 pub fn ch2oc(&self) -> CH2OC_R {
1227 CH2OC_R::new(((self.bits >> 2) & 0x01) != 0)
1228 }
1229 #[doc = "Bit 3 - Channel 3 Software Output Control Enable"]
1230 #[inline(always)]
1231 pub fn ch3oc(&self) -> CH3OC_R {
1232 CH3OC_R::new(((self.bits >> 3) & 0x01) != 0)
1233 }
1234 #[doc = "Bit 4 - Channel 4 Software Output Control Enable"]
1235 #[inline(always)]
1236 pub fn ch4oc(&self) -> CH4OC_R {
1237 CH4OC_R::new(((self.bits >> 4) & 0x01) != 0)
1238 }
1239 #[doc = "Bit 5 - Channel 5 Software Output Control Enable"]
1240 #[inline(always)]
1241 pub fn ch5oc(&self) -> CH5OC_R {
1242 CH5OC_R::new(((self.bits >> 5) & 0x01) != 0)
1243 }
1244 #[doc = "Bit 6 - Channel 6 Software Output Control Enable"]
1245 #[inline(always)]
1246 pub fn ch6oc(&self) -> CH6OC_R {
1247 CH6OC_R::new(((self.bits >> 6) & 0x01) != 0)
1248 }
1249 #[doc = "Bit 7 - Channel 7 Software Output Control Enable"]
1250 #[inline(always)]
1251 pub fn ch7oc(&self) -> CH7OC_R {
1252 CH7OC_R::new(((self.bits >> 7) & 0x01) != 0)
1253 }
1254 #[doc = "Bit 8 - Channel 0 Software Output Control Value"]
1255 #[inline(always)]
1256 pub fn ch0ocv(&self) -> CH0OCV_R {
1257 CH0OCV_R::new(((self.bits >> 8) & 0x01) != 0)
1258 }
1259 #[doc = "Bit 9 - Channel 1 Software Output Control Value"]
1260 #[inline(always)]
1261 pub fn ch1ocv(&self) -> CH1OCV_R {
1262 CH1OCV_R::new(((self.bits >> 9) & 0x01) != 0)
1263 }
1264 #[doc = "Bit 10 - Channel 2 Software Output Control Value"]
1265 #[inline(always)]
1266 pub fn ch2ocv(&self) -> CH2OCV_R {
1267 CH2OCV_R::new(((self.bits >> 10) & 0x01) != 0)
1268 }
1269 #[doc = "Bit 11 - Channel 3 Software Output Control Value"]
1270 #[inline(always)]
1271 pub fn ch3ocv(&self) -> CH3OCV_R {
1272 CH3OCV_R::new(((self.bits >> 11) & 0x01) != 0)
1273 }
1274 #[doc = "Bit 12 - Channel 4 Software Output Control Value"]
1275 #[inline(always)]
1276 pub fn ch4ocv(&self) -> CH4OCV_R {
1277 CH4OCV_R::new(((self.bits >> 12) & 0x01) != 0)
1278 }
1279 #[doc = "Bit 13 - Channel 5 Software Output Control Value"]
1280 #[inline(always)]
1281 pub fn ch5ocv(&self) -> CH5OCV_R {
1282 CH5OCV_R::new(((self.bits >> 13) & 0x01) != 0)
1283 }
1284 #[doc = "Bit 14 - Channel 6 Software Output Control Value"]
1285 #[inline(always)]
1286 pub fn ch6ocv(&self) -> CH6OCV_R {
1287 CH6OCV_R::new(((self.bits >> 14) & 0x01) != 0)
1288 }
1289 #[doc = "Bit 15 - Channel 7 Software Output Control Value"]
1290 #[inline(always)]
1291 pub fn ch7ocv(&self) -> CH7OCV_R {
1292 CH7OCV_R::new(((self.bits >> 15) & 0x01) != 0)
1293 }
1294}
1295impl W {
1296 #[doc = "Bit 0 - Channel 0 Software Output Control Enable"]
1297 #[inline(always)]
1298 pub fn ch0oc(&mut self) -> CH0OC_W {
1299 CH0OC_W { w: self }
1300 }
1301 #[doc = "Bit 1 - Channel 1 Software Output Control Enable"]
1302 #[inline(always)]
1303 pub fn ch1oc(&mut self) -> CH1OC_W {
1304 CH1OC_W { w: self }
1305 }
1306 #[doc = "Bit 2 - Channel 2 Software Output Control Enable"]
1307 #[inline(always)]
1308 pub fn ch2oc(&mut self) -> CH2OC_W {
1309 CH2OC_W { w: self }
1310 }
1311 #[doc = "Bit 3 - Channel 3 Software Output Control Enable"]
1312 #[inline(always)]
1313 pub fn ch3oc(&mut self) -> CH3OC_W {
1314 CH3OC_W { w: self }
1315 }
1316 #[doc = "Bit 4 - Channel 4 Software Output Control Enable"]
1317 #[inline(always)]
1318 pub fn ch4oc(&mut self) -> CH4OC_W {
1319 CH4OC_W { w: self }
1320 }
1321 #[doc = "Bit 5 - Channel 5 Software Output Control Enable"]
1322 #[inline(always)]
1323 pub fn ch5oc(&mut self) -> CH5OC_W {
1324 CH5OC_W { w: self }
1325 }
1326 #[doc = "Bit 6 - Channel 6 Software Output Control Enable"]
1327 #[inline(always)]
1328 pub fn ch6oc(&mut self) -> CH6OC_W {
1329 CH6OC_W { w: self }
1330 }
1331 #[doc = "Bit 7 - Channel 7 Software Output Control Enable"]
1332 #[inline(always)]
1333 pub fn ch7oc(&mut self) -> CH7OC_W {
1334 CH7OC_W { w: self }
1335 }
1336 #[doc = "Bit 8 - Channel 0 Software Output Control Value"]
1337 #[inline(always)]
1338 pub fn ch0ocv(&mut self) -> CH0OCV_W {
1339 CH0OCV_W { w: self }
1340 }
1341 #[doc = "Bit 9 - Channel 1 Software Output Control Value"]
1342 #[inline(always)]
1343 pub fn ch1ocv(&mut self) -> CH1OCV_W {
1344 CH1OCV_W { w: self }
1345 }
1346 #[doc = "Bit 10 - Channel 2 Software Output Control Value"]
1347 #[inline(always)]
1348 pub fn ch2ocv(&mut self) -> CH2OCV_W {
1349 CH2OCV_W { w: self }
1350 }
1351 #[doc = "Bit 11 - Channel 3 Software Output Control Value"]
1352 #[inline(always)]
1353 pub fn ch3ocv(&mut self) -> CH3OCV_W {
1354 CH3OCV_W { w: self }
1355 }
1356 #[doc = "Bit 12 - Channel 4 Software Output Control Value"]
1357 #[inline(always)]
1358 pub fn ch4ocv(&mut self) -> CH4OCV_W {
1359 CH4OCV_W { w: self }
1360 }
1361 #[doc = "Bit 13 - Channel 5 Software Output Control Value"]
1362 #[inline(always)]
1363 pub fn ch5ocv(&mut self) -> CH5OCV_W {
1364 CH5OCV_W { w: self }
1365 }
1366 #[doc = "Bit 14 - Channel 6 Software Output Control Value"]
1367 #[inline(always)]
1368 pub fn ch6ocv(&mut self) -> CH6OCV_W {
1369 CH6OCV_W { w: self }
1370 }
1371 #[doc = "Bit 15 - Channel 7 Software Output Control Value"]
1372 #[inline(always)]
1373 pub fn ch7ocv(&mut self) -> CH7OCV_W {
1374 CH7OCV_W { w: self }
1375 }
1376}