1#[doc = "Register `OUTMASK` reader"]
2pub struct R(crate::R<OUTMASK_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<OUTMASK_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<OUTMASK_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<OUTMASK_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `OUTMASK` writer"]
17pub struct W(crate::W<OUTMASK_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<OUTMASK_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<OUTMASK_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<OUTMASK_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Channel 0 Output Mask\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum CH0OM_A {
40 #[doc = "0: Channel output is not masked. It continues to operate normally."]
41 _0 = 0,
42 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
43 _1 = 1,
44}
45impl From<CH0OM_A> for bool {
46 #[inline(always)]
47 fn from(variant: CH0OM_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `CH0OM` reader - Channel 0 Output Mask"]
52pub struct CH0OM_R(crate::FieldReader<bool, CH0OM_A>);
53impl CH0OM_R {
54 #[inline(always)]
55 pub(crate) fn new(bits: bool) -> Self {
56 CH0OM_R(crate::FieldReader::new(bits))
57 }
58 #[doc = r"Get enumerated values variant"]
59 #[inline(always)]
60 pub fn variant(&self) -> CH0OM_A {
61 match self.bits {
62 false => CH0OM_A::_0,
63 true => CH0OM_A::_1,
64 }
65 }
66 #[doc = "Checks if the value of the field is `_0`"]
67 #[inline(always)]
68 pub fn is_0(&self) -> bool {
69 **self == CH0OM_A::_0
70 }
71 #[doc = "Checks if the value of the field is `_1`"]
72 #[inline(always)]
73 pub fn is_1(&self) -> bool {
74 **self == CH0OM_A::_1
75 }
76}
77impl core::ops::Deref for CH0OM_R {
78 type Target = crate::FieldReader<bool, CH0OM_A>;
79 #[inline(always)]
80 fn deref(&self) -> &Self::Target {
81 &self.0
82 }
83}
84#[doc = "Field `CH0OM` writer - Channel 0 Output Mask"]
85pub struct CH0OM_W<'a> {
86 w: &'a mut W,
87}
88impl<'a> CH0OM_W<'a> {
89 #[doc = r"Writes `variant` to the field"]
90 #[inline(always)]
91 pub fn variant(self, variant: CH0OM_A) -> &'a mut W {
92 self.bit(variant.into())
93 }
94 #[doc = "Channel output is not masked. It continues to operate normally."]
95 #[inline(always)]
96 pub fn _0(self) -> &'a mut W {
97 self.variant(CH0OM_A::_0)
98 }
99 #[doc = "Channel output is masked. It is forced to its inactive state."]
100 #[inline(always)]
101 pub fn _1(self) -> &'a mut W {
102 self.variant(CH0OM_A::_1)
103 }
104 #[doc = r"Sets the field bit"]
105 #[inline(always)]
106 pub fn set_bit(self) -> &'a mut W {
107 self.bit(true)
108 }
109 #[doc = r"Clears the field bit"]
110 #[inline(always)]
111 pub fn clear_bit(self) -> &'a mut W {
112 self.bit(false)
113 }
114 #[doc = r"Writes raw bits to the field"]
115 #[inline(always)]
116 pub fn bit(self, value: bool) -> &'a mut W {
117 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
118 self.w
119 }
120}
121#[doc = "Channel 1 Output Mask\n\nValue on reset: 0"]
122#[derive(Clone, Copy, Debug, PartialEq)]
123pub enum CH1OM_A {
124 #[doc = "0: Channel output is not masked. It continues to operate normally."]
125 _0 = 0,
126 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
127 _1 = 1,
128}
129impl From<CH1OM_A> for bool {
130 #[inline(always)]
131 fn from(variant: CH1OM_A) -> Self {
132 variant as u8 != 0
133 }
134}
135#[doc = "Field `CH1OM` reader - Channel 1 Output Mask"]
136pub struct CH1OM_R(crate::FieldReader<bool, CH1OM_A>);
137impl CH1OM_R {
138 #[inline(always)]
139 pub(crate) fn new(bits: bool) -> Self {
140 CH1OM_R(crate::FieldReader::new(bits))
141 }
142 #[doc = r"Get enumerated values variant"]
143 #[inline(always)]
144 pub fn variant(&self) -> CH1OM_A {
145 match self.bits {
146 false => CH1OM_A::_0,
147 true => CH1OM_A::_1,
148 }
149 }
150 #[doc = "Checks if the value of the field is `_0`"]
151 #[inline(always)]
152 pub fn is_0(&self) -> bool {
153 **self == CH1OM_A::_0
154 }
155 #[doc = "Checks if the value of the field is `_1`"]
156 #[inline(always)]
157 pub fn is_1(&self) -> bool {
158 **self == CH1OM_A::_1
159 }
160}
161impl core::ops::Deref for CH1OM_R {
162 type Target = crate::FieldReader<bool, CH1OM_A>;
163 #[inline(always)]
164 fn deref(&self) -> &Self::Target {
165 &self.0
166 }
167}
168#[doc = "Field `CH1OM` writer - Channel 1 Output Mask"]
169pub struct CH1OM_W<'a> {
170 w: &'a mut W,
171}
172impl<'a> CH1OM_W<'a> {
173 #[doc = r"Writes `variant` to the field"]
174 #[inline(always)]
175 pub fn variant(self, variant: CH1OM_A) -> &'a mut W {
176 self.bit(variant.into())
177 }
178 #[doc = "Channel output is not masked. It continues to operate normally."]
179 #[inline(always)]
180 pub fn _0(self) -> &'a mut W {
181 self.variant(CH1OM_A::_0)
182 }
183 #[doc = "Channel output is masked. It is forced to its inactive state."]
184 #[inline(always)]
185 pub fn _1(self) -> &'a mut W {
186 self.variant(CH1OM_A::_1)
187 }
188 #[doc = r"Sets the field bit"]
189 #[inline(always)]
190 pub fn set_bit(self) -> &'a mut W {
191 self.bit(true)
192 }
193 #[doc = r"Clears the field bit"]
194 #[inline(always)]
195 pub fn clear_bit(self) -> &'a mut W {
196 self.bit(false)
197 }
198 #[doc = r"Writes raw bits to the field"]
199 #[inline(always)]
200 pub fn bit(self, value: bool) -> &'a mut W {
201 self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
202 self.w
203 }
204}
205#[doc = "Channel 2 Output Mask\n\nValue on reset: 0"]
206#[derive(Clone, Copy, Debug, PartialEq)]
207pub enum CH2OM_A {
208 #[doc = "0: Channel output is not masked. It continues to operate normally."]
209 _0 = 0,
210 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
211 _1 = 1,
212}
213impl From<CH2OM_A> for bool {
214 #[inline(always)]
215 fn from(variant: CH2OM_A) -> Self {
216 variant as u8 != 0
217 }
218}
219#[doc = "Field `CH2OM` reader - Channel 2 Output Mask"]
220pub struct CH2OM_R(crate::FieldReader<bool, CH2OM_A>);
221impl CH2OM_R {
222 #[inline(always)]
223 pub(crate) fn new(bits: bool) -> Self {
224 CH2OM_R(crate::FieldReader::new(bits))
225 }
226 #[doc = r"Get enumerated values variant"]
227 #[inline(always)]
228 pub fn variant(&self) -> CH2OM_A {
229 match self.bits {
230 false => CH2OM_A::_0,
231 true => CH2OM_A::_1,
232 }
233 }
234 #[doc = "Checks if the value of the field is `_0`"]
235 #[inline(always)]
236 pub fn is_0(&self) -> bool {
237 **self == CH2OM_A::_0
238 }
239 #[doc = "Checks if the value of the field is `_1`"]
240 #[inline(always)]
241 pub fn is_1(&self) -> bool {
242 **self == CH2OM_A::_1
243 }
244}
245impl core::ops::Deref for CH2OM_R {
246 type Target = crate::FieldReader<bool, CH2OM_A>;
247 #[inline(always)]
248 fn deref(&self) -> &Self::Target {
249 &self.0
250 }
251}
252#[doc = "Field `CH2OM` writer - Channel 2 Output Mask"]
253pub struct CH2OM_W<'a> {
254 w: &'a mut W,
255}
256impl<'a> CH2OM_W<'a> {
257 #[doc = r"Writes `variant` to the field"]
258 #[inline(always)]
259 pub fn variant(self, variant: CH2OM_A) -> &'a mut W {
260 self.bit(variant.into())
261 }
262 #[doc = "Channel output is not masked. It continues to operate normally."]
263 #[inline(always)]
264 pub fn _0(self) -> &'a mut W {
265 self.variant(CH2OM_A::_0)
266 }
267 #[doc = "Channel output is masked. It is forced to its inactive state."]
268 #[inline(always)]
269 pub fn _1(self) -> &'a mut W {
270 self.variant(CH2OM_A::_1)
271 }
272 #[doc = r"Sets the field bit"]
273 #[inline(always)]
274 pub fn set_bit(self) -> &'a mut W {
275 self.bit(true)
276 }
277 #[doc = r"Clears the field bit"]
278 #[inline(always)]
279 pub fn clear_bit(self) -> &'a mut W {
280 self.bit(false)
281 }
282 #[doc = r"Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn bit(self, value: bool) -> &'a mut W {
285 self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
286 self.w
287 }
288}
289#[doc = "Channel 3 Output Mask\n\nValue on reset: 0"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum CH3OM_A {
292 #[doc = "0: Channel output is not masked. It continues to operate normally."]
293 _0 = 0,
294 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
295 _1 = 1,
296}
297impl From<CH3OM_A> for bool {
298 #[inline(always)]
299 fn from(variant: CH3OM_A) -> Self {
300 variant as u8 != 0
301 }
302}
303#[doc = "Field `CH3OM` reader - Channel 3 Output Mask"]
304pub struct CH3OM_R(crate::FieldReader<bool, CH3OM_A>);
305impl CH3OM_R {
306 #[inline(always)]
307 pub(crate) fn new(bits: bool) -> Self {
308 CH3OM_R(crate::FieldReader::new(bits))
309 }
310 #[doc = r"Get enumerated values variant"]
311 #[inline(always)]
312 pub fn variant(&self) -> CH3OM_A {
313 match self.bits {
314 false => CH3OM_A::_0,
315 true => CH3OM_A::_1,
316 }
317 }
318 #[doc = "Checks if the value of the field is `_0`"]
319 #[inline(always)]
320 pub fn is_0(&self) -> bool {
321 **self == CH3OM_A::_0
322 }
323 #[doc = "Checks if the value of the field is `_1`"]
324 #[inline(always)]
325 pub fn is_1(&self) -> bool {
326 **self == CH3OM_A::_1
327 }
328}
329impl core::ops::Deref for CH3OM_R {
330 type Target = crate::FieldReader<bool, CH3OM_A>;
331 #[inline(always)]
332 fn deref(&self) -> &Self::Target {
333 &self.0
334 }
335}
336#[doc = "Field `CH3OM` writer - Channel 3 Output Mask"]
337pub struct CH3OM_W<'a> {
338 w: &'a mut W,
339}
340impl<'a> CH3OM_W<'a> {
341 #[doc = r"Writes `variant` to the field"]
342 #[inline(always)]
343 pub fn variant(self, variant: CH3OM_A) -> &'a mut W {
344 self.bit(variant.into())
345 }
346 #[doc = "Channel output is not masked. It continues to operate normally."]
347 #[inline(always)]
348 pub fn _0(self) -> &'a mut W {
349 self.variant(CH3OM_A::_0)
350 }
351 #[doc = "Channel output is masked. It is forced to its inactive state."]
352 #[inline(always)]
353 pub fn _1(self) -> &'a mut W {
354 self.variant(CH3OM_A::_1)
355 }
356 #[doc = r"Sets the field bit"]
357 #[inline(always)]
358 pub fn set_bit(self) -> &'a mut W {
359 self.bit(true)
360 }
361 #[doc = r"Clears the field bit"]
362 #[inline(always)]
363 pub fn clear_bit(self) -> &'a mut W {
364 self.bit(false)
365 }
366 #[doc = r"Writes raw bits to the field"]
367 #[inline(always)]
368 pub fn bit(self, value: bool) -> &'a mut W {
369 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
370 self.w
371 }
372}
373#[doc = "Channel 4 Output Mask\n\nValue on reset: 0"]
374#[derive(Clone, Copy, Debug, PartialEq)]
375pub enum CH4OM_A {
376 #[doc = "0: Channel output is not masked. It continues to operate normally."]
377 _0 = 0,
378 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
379 _1 = 1,
380}
381impl From<CH4OM_A> for bool {
382 #[inline(always)]
383 fn from(variant: CH4OM_A) -> Self {
384 variant as u8 != 0
385 }
386}
387#[doc = "Field `CH4OM` reader - Channel 4 Output Mask"]
388pub struct CH4OM_R(crate::FieldReader<bool, CH4OM_A>);
389impl CH4OM_R {
390 #[inline(always)]
391 pub(crate) fn new(bits: bool) -> Self {
392 CH4OM_R(crate::FieldReader::new(bits))
393 }
394 #[doc = r"Get enumerated values variant"]
395 #[inline(always)]
396 pub fn variant(&self) -> CH4OM_A {
397 match self.bits {
398 false => CH4OM_A::_0,
399 true => CH4OM_A::_1,
400 }
401 }
402 #[doc = "Checks if the value of the field is `_0`"]
403 #[inline(always)]
404 pub fn is_0(&self) -> bool {
405 **self == CH4OM_A::_0
406 }
407 #[doc = "Checks if the value of the field is `_1`"]
408 #[inline(always)]
409 pub fn is_1(&self) -> bool {
410 **self == CH4OM_A::_1
411 }
412}
413impl core::ops::Deref for CH4OM_R {
414 type Target = crate::FieldReader<bool, CH4OM_A>;
415 #[inline(always)]
416 fn deref(&self) -> &Self::Target {
417 &self.0
418 }
419}
420#[doc = "Field `CH4OM` writer - Channel 4 Output Mask"]
421pub struct CH4OM_W<'a> {
422 w: &'a mut W,
423}
424impl<'a> CH4OM_W<'a> {
425 #[doc = r"Writes `variant` to the field"]
426 #[inline(always)]
427 pub fn variant(self, variant: CH4OM_A) -> &'a mut W {
428 self.bit(variant.into())
429 }
430 #[doc = "Channel output is not masked. It continues to operate normally."]
431 #[inline(always)]
432 pub fn _0(self) -> &'a mut W {
433 self.variant(CH4OM_A::_0)
434 }
435 #[doc = "Channel output is masked. It is forced to its inactive state."]
436 #[inline(always)]
437 pub fn _1(self) -> &'a mut W {
438 self.variant(CH4OM_A::_1)
439 }
440 #[doc = r"Sets the field bit"]
441 #[inline(always)]
442 pub fn set_bit(self) -> &'a mut W {
443 self.bit(true)
444 }
445 #[doc = r"Clears the field bit"]
446 #[inline(always)]
447 pub fn clear_bit(self) -> &'a mut W {
448 self.bit(false)
449 }
450 #[doc = r"Writes raw bits to the field"]
451 #[inline(always)]
452 pub fn bit(self, value: bool) -> &'a mut W {
453 self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
454 self.w
455 }
456}
457#[doc = "Channel 5 Output Mask\n\nValue on reset: 0"]
458#[derive(Clone, Copy, Debug, PartialEq)]
459pub enum CH5OM_A {
460 #[doc = "0: Channel output is not masked. It continues to operate normally."]
461 _0 = 0,
462 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
463 _1 = 1,
464}
465impl From<CH5OM_A> for bool {
466 #[inline(always)]
467 fn from(variant: CH5OM_A) -> Self {
468 variant as u8 != 0
469 }
470}
471#[doc = "Field `CH5OM` reader - Channel 5 Output Mask"]
472pub struct CH5OM_R(crate::FieldReader<bool, CH5OM_A>);
473impl CH5OM_R {
474 #[inline(always)]
475 pub(crate) fn new(bits: bool) -> Self {
476 CH5OM_R(crate::FieldReader::new(bits))
477 }
478 #[doc = r"Get enumerated values variant"]
479 #[inline(always)]
480 pub fn variant(&self) -> CH5OM_A {
481 match self.bits {
482 false => CH5OM_A::_0,
483 true => CH5OM_A::_1,
484 }
485 }
486 #[doc = "Checks if the value of the field is `_0`"]
487 #[inline(always)]
488 pub fn is_0(&self) -> bool {
489 **self == CH5OM_A::_0
490 }
491 #[doc = "Checks if the value of the field is `_1`"]
492 #[inline(always)]
493 pub fn is_1(&self) -> bool {
494 **self == CH5OM_A::_1
495 }
496}
497impl core::ops::Deref for CH5OM_R {
498 type Target = crate::FieldReader<bool, CH5OM_A>;
499 #[inline(always)]
500 fn deref(&self) -> &Self::Target {
501 &self.0
502 }
503}
504#[doc = "Field `CH5OM` writer - Channel 5 Output Mask"]
505pub struct CH5OM_W<'a> {
506 w: &'a mut W,
507}
508impl<'a> CH5OM_W<'a> {
509 #[doc = r"Writes `variant` to the field"]
510 #[inline(always)]
511 pub fn variant(self, variant: CH5OM_A) -> &'a mut W {
512 self.bit(variant.into())
513 }
514 #[doc = "Channel output is not masked. It continues to operate normally."]
515 #[inline(always)]
516 pub fn _0(self) -> &'a mut W {
517 self.variant(CH5OM_A::_0)
518 }
519 #[doc = "Channel output is masked. It is forced to its inactive state."]
520 #[inline(always)]
521 pub fn _1(self) -> &'a mut W {
522 self.variant(CH5OM_A::_1)
523 }
524 #[doc = r"Sets the field bit"]
525 #[inline(always)]
526 pub fn set_bit(self) -> &'a mut W {
527 self.bit(true)
528 }
529 #[doc = r"Clears the field bit"]
530 #[inline(always)]
531 pub fn clear_bit(self) -> &'a mut W {
532 self.bit(false)
533 }
534 #[doc = r"Writes raw bits to the field"]
535 #[inline(always)]
536 pub fn bit(self, value: bool) -> &'a mut W {
537 self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
538 self.w
539 }
540}
541#[doc = "Channel 6 Output Mask\n\nValue on reset: 0"]
542#[derive(Clone, Copy, Debug, PartialEq)]
543pub enum CH6OM_A {
544 #[doc = "0: Channel output is not masked. It continues to operate normally."]
545 _0 = 0,
546 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
547 _1 = 1,
548}
549impl From<CH6OM_A> for bool {
550 #[inline(always)]
551 fn from(variant: CH6OM_A) -> Self {
552 variant as u8 != 0
553 }
554}
555#[doc = "Field `CH6OM` reader - Channel 6 Output Mask"]
556pub struct CH6OM_R(crate::FieldReader<bool, CH6OM_A>);
557impl CH6OM_R {
558 #[inline(always)]
559 pub(crate) fn new(bits: bool) -> Self {
560 CH6OM_R(crate::FieldReader::new(bits))
561 }
562 #[doc = r"Get enumerated values variant"]
563 #[inline(always)]
564 pub fn variant(&self) -> CH6OM_A {
565 match self.bits {
566 false => CH6OM_A::_0,
567 true => CH6OM_A::_1,
568 }
569 }
570 #[doc = "Checks if the value of the field is `_0`"]
571 #[inline(always)]
572 pub fn is_0(&self) -> bool {
573 **self == CH6OM_A::_0
574 }
575 #[doc = "Checks if the value of the field is `_1`"]
576 #[inline(always)]
577 pub fn is_1(&self) -> bool {
578 **self == CH6OM_A::_1
579 }
580}
581impl core::ops::Deref for CH6OM_R {
582 type Target = crate::FieldReader<bool, CH6OM_A>;
583 #[inline(always)]
584 fn deref(&self) -> &Self::Target {
585 &self.0
586 }
587}
588#[doc = "Field `CH6OM` writer - Channel 6 Output Mask"]
589pub struct CH6OM_W<'a> {
590 w: &'a mut W,
591}
592impl<'a> CH6OM_W<'a> {
593 #[doc = r"Writes `variant` to the field"]
594 #[inline(always)]
595 pub fn variant(self, variant: CH6OM_A) -> &'a mut W {
596 self.bit(variant.into())
597 }
598 #[doc = "Channel output is not masked. It continues to operate normally."]
599 #[inline(always)]
600 pub fn _0(self) -> &'a mut W {
601 self.variant(CH6OM_A::_0)
602 }
603 #[doc = "Channel output is masked. It is forced to its inactive state."]
604 #[inline(always)]
605 pub fn _1(self) -> &'a mut W {
606 self.variant(CH6OM_A::_1)
607 }
608 #[doc = r"Sets the field bit"]
609 #[inline(always)]
610 pub fn set_bit(self) -> &'a mut W {
611 self.bit(true)
612 }
613 #[doc = r"Clears the field bit"]
614 #[inline(always)]
615 pub fn clear_bit(self) -> &'a mut W {
616 self.bit(false)
617 }
618 #[doc = r"Writes raw bits to the field"]
619 #[inline(always)]
620 pub fn bit(self, value: bool) -> &'a mut W {
621 self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
622 self.w
623 }
624}
625#[doc = "Channel 7 Output Mask\n\nValue on reset: 0"]
626#[derive(Clone, Copy, Debug, PartialEq)]
627pub enum CH7OM_A {
628 #[doc = "0: Channel output is not masked. It continues to operate normally."]
629 _0 = 0,
630 #[doc = "1: Channel output is masked. It is forced to its inactive state."]
631 _1 = 1,
632}
633impl From<CH7OM_A> for bool {
634 #[inline(always)]
635 fn from(variant: CH7OM_A) -> Self {
636 variant as u8 != 0
637 }
638}
639#[doc = "Field `CH7OM` reader - Channel 7 Output Mask"]
640pub struct CH7OM_R(crate::FieldReader<bool, CH7OM_A>);
641impl CH7OM_R {
642 #[inline(always)]
643 pub(crate) fn new(bits: bool) -> Self {
644 CH7OM_R(crate::FieldReader::new(bits))
645 }
646 #[doc = r"Get enumerated values variant"]
647 #[inline(always)]
648 pub fn variant(&self) -> CH7OM_A {
649 match self.bits {
650 false => CH7OM_A::_0,
651 true => CH7OM_A::_1,
652 }
653 }
654 #[doc = "Checks if the value of the field is `_0`"]
655 #[inline(always)]
656 pub fn is_0(&self) -> bool {
657 **self == CH7OM_A::_0
658 }
659 #[doc = "Checks if the value of the field is `_1`"]
660 #[inline(always)]
661 pub fn is_1(&self) -> bool {
662 **self == CH7OM_A::_1
663 }
664}
665impl core::ops::Deref for CH7OM_R {
666 type Target = crate::FieldReader<bool, CH7OM_A>;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 &self.0
670 }
671}
672#[doc = "Field `CH7OM` writer - Channel 7 Output Mask"]
673pub struct CH7OM_W<'a> {
674 w: &'a mut W,
675}
676impl<'a> CH7OM_W<'a> {
677 #[doc = r"Writes `variant` to the field"]
678 #[inline(always)]
679 pub fn variant(self, variant: CH7OM_A) -> &'a mut W {
680 self.bit(variant.into())
681 }
682 #[doc = "Channel output is not masked. It continues to operate normally."]
683 #[inline(always)]
684 pub fn _0(self) -> &'a mut W {
685 self.variant(CH7OM_A::_0)
686 }
687 #[doc = "Channel output is masked. It is forced to its inactive state."]
688 #[inline(always)]
689 pub fn _1(self) -> &'a mut W {
690 self.variant(CH7OM_A::_1)
691 }
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 = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
706 self.w
707 }
708}
709impl R {
710 #[doc = "Bit 0 - Channel 0 Output Mask"]
711 #[inline(always)]
712 pub fn ch0om(&self) -> CH0OM_R {
713 CH0OM_R::new((self.bits & 0x01) != 0)
714 }
715 #[doc = "Bit 1 - Channel 1 Output Mask"]
716 #[inline(always)]
717 pub fn ch1om(&self) -> CH1OM_R {
718 CH1OM_R::new(((self.bits >> 1) & 0x01) != 0)
719 }
720 #[doc = "Bit 2 - Channel 2 Output Mask"]
721 #[inline(always)]
722 pub fn ch2om(&self) -> CH2OM_R {
723 CH2OM_R::new(((self.bits >> 2) & 0x01) != 0)
724 }
725 #[doc = "Bit 3 - Channel 3 Output Mask"]
726 #[inline(always)]
727 pub fn ch3om(&self) -> CH3OM_R {
728 CH3OM_R::new(((self.bits >> 3) & 0x01) != 0)
729 }
730 #[doc = "Bit 4 - Channel 4 Output Mask"]
731 #[inline(always)]
732 pub fn ch4om(&self) -> CH4OM_R {
733 CH4OM_R::new(((self.bits >> 4) & 0x01) != 0)
734 }
735 #[doc = "Bit 5 - Channel 5 Output Mask"]
736 #[inline(always)]
737 pub fn ch5om(&self) -> CH5OM_R {
738 CH5OM_R::new(((self.bits >> 5) & 0x01) != 0)
739 }
740 #[doc = "Bit 6 - Channel 6 Output Mask"]
741 #[inline(always)]
742 pub fn ch6om(&self) -> CH6OM_R {
743 CH6OM_R::new(((self.bits >> 6) & 0x01) != 0)
744 }
745 #[doc = "Bit 7 - Channel 7 Output Mask"]
746 #[inline(always)]
747 pub fn ch7om(&self) -> CH7OM_R {
748 CH7OM_R::new(((self.bits >> 7) & 0x01) != 0)
749 }
750}
751impl W {
752 #[doc = "Bit 0 - Channel 0 Output Mask"]
753 #[inline(always)]
754 pub fn ch0om(&mut self) -> CH0OM_W {
755 CH0OM_W { w: self }
756 }
757 #[doc = "Bit 1 - Channel 1 Output Mask"]
758 #[inline(always)]
759 pub fn ch1om(&mut self) -> CH1OM_W {
760 CH1OM_W { w: self }
761 }
762 #[doc = "Bit 2 - Channel 2 Output Mask"]
763 #[inline(always)]
764 pub fn ch2om(&mut self) -> CH2OM_W {
765 CH2OM_W { w: self }
766 }
767 #[doc = "Bit 3 - Channel 3 Output Mask"]
768 #[inline(always)]
769 pub fn ch3om(&mut self) -> CH3OM_W {
770 CH3OM_W { w: self }
771 }
772 #[doc = "Bit 4 - Channel 4 Output Mask"]
773 #[inline(always)]
774 pub fn ch4om(&mut self) -> CH4OM_W {
775 CH4OM_W { w: self }
776 }
777 #[doc = "Bit 5 - Channel 5 Output Mask"]
778 #[inline(always)]
779 pub fn ch5om(&mut self) -> CH5OM_W {
780 CH5OM_W { w: self }
781 }
782 #[doc = "Bit 6 - Channel 6 Output Mask"]
783 #[inline(always)]
784 pub fn ch6om(&mut self) -> CH6OM_W {
785 CH6OM_W { w: self }
786 }
787 #[doc = "Bit 7 - Channel 7 Output Mask"]
788 #[inline(always)]
789 pub fn ch7om(&mut self) -> CH7OM_W {
790 CH7OM_W { w: self }
791 }
792 #[doc = "Writes raw bits to the register."]
793 #[inline(always)]
794 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
795 self.0.bits(bits);
796 self
797 }
798}
799#[doc = "Output Mask\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [outmask](index.html) module"]
800pub struct OUTMASK_SPEC;
801impl crate::RegisterSpec for OUTMASK_SPEC {
802 type Ux = u32;
803}
804#[doc = "`read()` method returns [outmask::R](R) reader structure"]
805impl crate::Readable for OUTMASK_SPEC {
806 type Reader = R;
807}
808#[doc = "`write(|w| ..)` method takes [outmask::W](W) writer structure"]
809impl crate::Writable for OUTMASK_SPEC {
810 type Writer = W;
811}
812#[doc = "`reset()` method sets OUTMASK to value 0"]
813impl crate::Resettable for OUTMASK_SPEC {
814 #[inline(always)]
815 fn reset_value() -> Self::Ux {
816 0
817 }
818}