nrf52840_pac/ppi/
chenclr.rs

Help
1#[doc = "Register `CHENCLR` reader"]
2pub struct R(crate::R<CHENCLR_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<CHENCLR_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<CHENCLR_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<CHENCLR_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `CHENCLR` writer"]
17pub struct W(crate::W<CHENCLR_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<CHENCLR_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<CHENCLR_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<CHENCLR_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `CH0` reader - Channel 0 enable clear register. Writing '0' has no effect"]
38pub type CH0_R = crate::BitReader<CH0_A>;
39#[doc = "Channel 0 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq)]
41pub enum CH0_A {
42    #[doc = "0: Read: channel disabled"]
43    DISABLED = 0,
44    #[doc = "1: Read: channel enabled"]
45    ENABLED = 1,
46}
47impl From<CH0_A> for bool {
48    #[inline(always)]
49    fn from(variant: CH0_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl CH0_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> CH0_A {
57        match self.bits {
58            false => CH0_A::DISABLED,
59            true => CH0_A::ENABLED,
60        }
61    }
62    #[doc = "Checks if the value of the field is `DISABLED`"]
63    #[inline(always)]
64    pub fn is_disabled(&self) -> bool {
65        *self == CH0_A::DISABLED
66    }
67    #[doc = "Checks if the value of the field is `ENABLED`"]
68    #[inline(always)]
69    pub fn is_enabled(&self) -> bool {
70        *self == CH0_A::ENABLED
71    }
72}
73#[doc = "Channel 0 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
74#[derive(Clone, Copy, Debug, PartialEq)]
75pub enum CH0_AW {
76    #[doc = "1: Write: disable channel"]
77    CLEAR = 1,
78}
79impl From<CH0_AW> for bool {
80    #[inline(always)]
81    fn from(variant: CH0_AW) -> Self {
82        variant as u8 != 0
83    }
84}
85#[doc = "Field `CH0` writer - Channel 0 enable clear register. Writing '0' has no effect"]
86pub type CH0_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH0_AW, O>;
87impl<'a, const O: u8> CH0_W<'a, O> {
88    #[doc = "Write: disable channel"]
89    #[inline(always)]
90    pub fn clear(self) -> &'a mut W {
91        self.variant(CH0_AW::CLEAR)
92    }
93}
94#[doc = "Field `CH1` reader - Channel 1 enable clear register. Writing '0' has no effect"]
95pub type CH1_R = crate::BitReader<CH1_A>;
96#[doc = "Channel 1 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
97#[derive(Clone, Copy, Debug, PartialEq)]
98pub enum CH1_A {
99    #[doc = "0: Read: channel disabled"]
100    DISABLED = 0,
101    #[doc = "1: Read: channel enabled"]
102    ENABLED = 1,
103}
104impl From<CH1_A> for bool {
105    #[inline(always)]
106    fn from(variant: CH1_A) -> Self {
107        variant as u8 != 0
108    }
109}
110impl CH1_R {
111    #[doc = "Get enumerated values variant"]
112    #[inline(always)]
113    pub fn variant(&self) -> CH1_A {
114        match self.bits {
115            false => CH1_A::DISABLED,
116            true => CH1_A::ENABLED,
117        }
118    }
119    #[doc = "Checks if the value of the field is `DISABLED`"]
120    #[inline(always)]
121    pub fn is_disabled(&self) -> bool {
122        *self == CH1_A::DISABLED
123    }
124    #[doc = "Checks if the value of the field is `ENABLED`"]
125    #[inline(always)]
126    pub fn is_enabled(&self) -> bool {
127        *self == CH1_A::ENABLED
128    }
129}
130#[doc = "Channel 1 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
131#[derive(Clone, Copy, Debug, PartialEq)]
132pub enum CH1_AW {
133    #[doc = "1: Write: disable channel"]
134    CLEAR = 1,
135}
136impl From<CH1_AW> for bool {
137    #[inline(always)]
138    fn from(variant: CH1_AW) -> Self {
139        variant as u8 != 0
140    }
141}
142#[doc = "Field `CH1` writer - Channel 1 enable clear register. Writing '0' has no effect"]
143pub type CH1_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH1_AW, O>;
144impl<'a, const O: u8> CH1_W<'a, O> {
145    #[doc = "Write: disable channel"]
146    #[inline(always)]
147    pub fn clear(self) -> &'a mut W {
148        self.variant(CH1_AW::CLEAR)
149    }
150}
151#[doc = "Field `CH2` reader - Channel 2 enable clear register. Writing '0' has no effect"]
152pub type CH2_R = crate::BitReader<CH2_A>;
153#[doc = "Channel 2 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
154#[derive(Clone, Copy, Debug, PartialEq)]
155pub enum CH2_A {
156    #[doc = "0: Read: channel disabled"]
157    DISABLED = 0,
158    #[doc = "1: Read: channel enabled"]
159    ENABLED = 1,
160}
161impl From<CH2_A> for bool {
162    #[inline(always)]
163    fn from(variant: CH2_A) -> Self {
164        variant as u8 != 0
165    }
166}
167impl CH2_R {
168    #[doc = "Get enumerated values variant"]
169    #[inline(always)]
170    pub fn variant(&self) -> CH2_A {
171        match self.bits {
172            false => CH2_A::DISABLED,
173            true => CH2_A::ENABLED,
174        }
175    }
176    #[doc = "Checks if the value of the field is `DISABLED`"]
177    #[inline(always)]
178    pub fn is_disabled(&self) -> bool {
179        *self == CH2_A::DISABLED
180    }
181    #[doc = "Checks if the value of the field is `ENABLED`"]
182    #[inline(always)]
183    pub fn is_enabled(&self) -> bool {
184        *self == CH2_A::ENABLED
185    }
186}
187#[doc = "Channel 2 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
188#[derive(Clone, Copy, Debug, PartialEq)]
189pub enum CH2_AW {
190    #[doc = "1: Write: disable channel"]
191    CLEAR = 1,
192}
193impl From<CH2_AW> for bool {
194    #[inline(always)]
195    fn from(variant: CH2_AW) -> Self {
196        variant as u8 != 0
197    }
198}
199#[doc = "Field `CH2` writer - Channel 2 enable clear register. Writing '0' has no effect"]
200pub type CH2_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH2_AW, O>;
201impl<'a, const O: u8> CH2_W<'a, O> {
202    #[doc = "Write: disable channel"]
203    #[inline(always)]
204    pub fn clear(self) -> &'a mut W {
205        self.variant(CH2_AW::CLEAR)
206    }
207}
208#[doc = "Field `CH3` reader - Channel 3 enable clear register. Writing '0' has no effect"]
209pub type CH3_R = crate::BitReader<CH3_A>;
210#[doc = "Channel 3 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
211#[derive(Clone, Copy, Debug, PartialEq)]
212pub enum CH3_A {
213    #[doc = "0: Read: channel disabled"]
214    DISABLED = 0,
215    #[doc = "1: Read: channel enabled"]
216    ENABLED = 1,
217}
218impl From<CH3_A> for bool {
219    #[inline(always)]
220    fn from(variant: CH3_A) -> Self {
221        variant as u8 != 0
222    }
223}
224impl CH3_R {
225    #[doc = "Get enumerated values variant"]
226    #[inline(always)]
227    pub fn variant(&self) -> CH3_A {
228        match self.bits {
229            false => CH3_A::DISABLED,
230            true => CH3_A::ENABLED,
231        }
232    }
233    #[doc = "Checks if the value of the field is `DISABLED`"]
234    #[inline(always)]
235    pub fn is_disabled(&self) -> bool {
236        *self == CH3_A::DISABLED
237    }
238    #[doc = "Checks if the value of the field is `ENABLED`"]
239    #[inline(always)]
240    pub fn is_enabled(&self) -> bool {
241        *self == CH3_A::ENABLED
242    }
243}
244#[doc = "Channel 3 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
245#[derive(Clone, Copy, Debug, PartialEq)]
246pub enum CH3_AW {
247    #[doc = "1: Write: disable channel"]
248    CLEAR = 1,
249}
250impl From<CH3_AW> for bool {
251    #[inline(always)]
252    fn from(variant: CH3_AW) -> Self {
253        variant as u8 != 0
254    }
255}
256#[doc = "Field `CH3` writer - Channel 3 enable clear register. Writing '0' has no effect"]
257pub type CH3_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH3_AW, O>;
258impl<'a, const O: u8> CH3_W<'a, O> {
259    #[doc = "Write: disable channel"]
260    #[inline(always)]
261    pub fn clear(self) -> &'a mut W {
262        self.variant(CH3_AW::CLEAR)
263    }
264}
265#[doc = "Field `CH4` reader - Channel 4 enable clear register. Writing '0' has no effect"]
266pub type CH4_R = crate::BitReader<CH4_A>;
267#[doc = "Channel 4 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
268#[derive(Clone, Copy, Debug, PartialEq)]
269pub enum CH4_A {
270    #[doc = "0: Read: channel disabled"]
271    DISABLED = 0,
272    #[doc = "1: Read: channel enabled"]
273    ENABLED = 1,
274}
275impl From<CH4_A> for bool {
276    #[inline(always)]
277    fn from(variant: CH4_A) -> Self {
278        variant as u8 != 0
279    }
280}
281impl CH4_R {
282    #[doc = "Get enumerated values variant"]
283    #[inline(always)]
284    pub fn variant(&self) -> CH4_A {
285        match self.bits {
286            false => CH4_A::DISABLED,
287            true => CH4_A::ENABLED,
288        }
289    }
290    #[doc = "Checks if the value of the field is `DISABLED`"]
291    #[inline(always)]
292    pub fn is_disabled(&self) -> bool {
293        *self == CH4_A::DISABLED
294    }
295    #[doc = "Checks if the value of the field is `ENABLED`"]
296    #[inline(always)]
297    pub fn is_enabled(&self) -> bool {
298        *self == CH4_A::ENABLED
299    }
300}
301#[doc = "Channel 4 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
302#[derive(Clone, Copy, Debug, PartialEq)]
303pub enum CH4_AW {
304    #[doc = "1: Write: disable channel"]
305    CLEAR = 1,
306}
307impl From<CH4_AW> for bool {
308    #[inline(always)]
309    fn from(variant: CH4_AW) -> Self {
310        variant as u8 != 0
311    }
312}
313#[doc = "Field `CH4` writer - Channel 4 enable clear register. Writing '0' has no effect"]
314pub type CH4_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH4_AW, O>;
315impl<'a, const O: u8> CH4_W<'a, O> {
316    #[doc = "Write: disable channel"]
317    #[inline(always)]
318    pub fn clear(self) -> &'a mut W {
319        self.variant(CH4_AW::CLEAR)
320    }
321}
322#[doc = "Field `CH5` reader - Channel 5 enable clear register. Writing '0' has no effect"]
323pub type CH5_R = crate::BitReader<CH5_A>;
324#[doc = "Channel 5 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
325#[derive(Clone, Copy, Debug, PartialEq)]
326pub enum CH5_A {
327    #[doc = "0: Read: channel disabled"]
328    DISABLED = 0,
329    #[doc = "1: Read: channel enabled"]
330    ENABLED = 1,
331}
332impl From<CH5_A> for bool {
333    #[inline(always)]
334    fn from(variant: CH5_A) -> Self {
335        variant as u8 != 0
336    }
337}
338impl CH5_R {
339    #[doc = "Get enumerated values variant"]
340    #[inline(always)]
341    pub fn variant(&self) -> CH5_A {
342        match self.bits {
343            false => CH5_A::DISABLED,
344            true => CH5_A::ENABLED,
345        }
346    }
347    #[doc = "Checks if the value of the field is `DISABLED`"]
348    #[inline(always)]
349    pub fn is_disabled(&self) -> bool {
350        *self == CH5_A::DISABLED
351    }
352    #[doc = "Checks if the value of the field is `ENABLED`"]
353    #[inline(always)]
354    pub fn is_enabled(&self) -> bool {
355        *self == CH5_A::ENABLED
356    }
357}
358#[doc = "Channel 5 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
359#[derive(Clone, Copy, Debug, PartialEq)]
360pub enum CH5_AW {
361    #[doc = "1: Write: disable channel"]
362    CLEAR = 1,
363}
364impl From<CH5_AW> for bool {
365    #[inline(always)]
366    fn from(variant: CH5_AW) -> Self {
367        variant as u8 != 0
368    }
369}
370#[doc = "Field `CH5` writer - Channel 5 enable clear register. Writing '0' has no effect"]
371pub type CH5_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH5_AW, O>;
372impl<'a, const O: u8> CH5_W<'a, O> {
373    #[doc = "Write: disable channel"]
374    #[inline(always)]
375    pub fn clear(self) -> &'a mut W {
376        self.variant(CH5_AW::CLEAR)
377    }
378}
379#[doc = "Field `CH6` reader - Channel 6 enable clear register. Writing '0' has no effect"]
380pub type CH6_R = crate::BitReader<CH6_A>;
381#[doc = "Channel 6 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
382#[derive(Clone, Copy, Debug, PartialEq)]
383pub enum CH6_A {
384    #[doc = "0: Read: channel disabled"]
385    DISABLED = 0,
386    #[doc = "1: Read: channel enabled"]
387    ENABLED = 1,
388}
389impl From<CH6_A> for bool {
390    #[inline(always)]
391    fn from(variant: CH6_A) -> Self {
392        variant as u8 != 0
393    }
394}
395impl CH6_R {
396    #[doc = "Get enumerated values variant"]
397    #[inline(always)]
398    pub fn variant(&self) -> CH6_A {
399        match self.bits {
400            false => CH6_A::DISABLED,
401            true => CH6_A::ENABLED,
402        }
403    }
404    #[doc = "Checks if the value of the field is `DISABLED`"]
405    #[inline(always)]
406    pub fn is_disabled(&self) -> bool {
407        *self == CH6_A::DISABLED
408    }
409    #[doc = "Checks if the value of the field is `ENABLED`"]
410    #[inline(always)]
411    pub fn is_enabled(&self) -> bool {
412        *self == CH6_A::ENABLED
413    }
414}
415#[doc = "Channel 6 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
416#[derive(Clone, Copy, Debug, PartialEq)]
417pub enum CH6_AW {
418    #[doc = "1: Write: disable channel"]
419    CLEAR = 1,
420}
421impl From<CH6_AW> for bool {
422    #[inline(always)]
423    fn from(variant: CH6_AW) -> Self {
424        variant as u8 != 0
425    }
426}
427#[doc = "Field `CH6` writer - Channel 6 enable clear register. Writing '0' has no effect"]
428pub type CH6_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH6_AW, O>;
429impl<'a, const O: u8> CH6_W<'a, O> {
430    #[doc = "Write: disable channel"]
431    #[inline(always)]
432    pub fn clear(self) -> &'a mut W {
433        self.variant(CH6_AW::CLEAR)
434    }
435}
436#[doc = "Field `CH7` reader - Channel 7 enable clear register. Writing '0' has no effect"]
437pub type CH7_R = crate::BitReader<CH7_A>;
438#[doc = "Channel 7 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
439#[derive(Clone, Copy, Debug, PartialEq)]
440pub enum CH7_A {
441    #[doc = "0: Read: channel disabled"]
442    DISABLED = 0,
443    #[doc = "1: Read: channel enabled"]
444    ENABLED = 1,
445}
446impl From<CH7_A> for bool {
447    #[inline(always)]
448    fn from(variant: CH7_A) -> Self {
449        variant as u8 != 0
450    }
451}
452impl CH7_R {
453    #[doc = "Get enumerated values variant"]
454    #[inline(always)]
455    pub fn variant(&self) -> CH7_A {
456        match self.bits {
457            false => CH7_A::DISABLED,
458            true => CH7_A::ENABLED,
459        }
460    }
461    #[doc = "Checks if the value of the field is `DISABLED`"]
462    #[inline(always)]
463    pub fn is_disabled(&self) -> bool {
464        *self == CH7_A::DISABLED
465    }
466    #[doc = "Checks if the value of the field is `ENABLED`"]
467    #[inline(always)]
468    pub fn is_enabled(&self) -> bool {
469        *self == CH7_A::ENABLED
470    }
471}
472#[doc = "Channel 7 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
473#[derive(Clone, Copy, Debug, PartialEq)]
474pub enum CH7_AW {
475    #[doc = "1: Write: disable channel"]
476    CLEAR = 1,
477}
478impl From<CH7_AW> for bool {
479    #[inline(always)]
480    fn from(variant: CH7_AW) -> Self {
481        variant as u8 != 0
482    }
483}
484#[doc = "Field `CH7` writer - Channel 7 enable clear register. Writing '0' has no effect"]
485pub type CH7_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH7_AW, O>;
486impl<'a, const O: u8> CH7_W<'a, O> {
487    #[doc = "Write: disable channel"]
488    #[inline(always)]
489    pub fn clear(self) -> &'a mut W {
490        self.variant(CH7_AW::CLEAR)
491    }
492}
493#[doc = "Field `CH8` reader - Channel 8 enable clear register. Writing '0' has no effect"]
494pub type CH8_R = crate::BitReader<CH8_A>;
495#[doc = "Channel 8 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
496#[derive(Clone, Copy, Debug, PartialEq)]
497pub enum CH8_A {
498    #[doc = "0: Read: channel disabled"]
499    DISABLED = 0,
500    #[doc = "1: Read: channel enabled"]
501    ENABLED = 1,
502}
503impl From<CH8_A> for bool {
504    #[inline(always)]
505    fn from(variant: CH8_A) -> Self {
506        variant as u8 != 0
507    }
508}
509impl CH8_R {
510    #[doc = "Get enumerated values variant"]
511    #[inline(always)]
512    pub fn variant(&self) -> CH8_A {
513        match self.bits {
514            false => CH8_A::DISABLED,
515            true => CH8_A::ENABLED,
516        }
517    }
518    #[doc = "Checks if the value of the field is `DISABLED`"]
519    #[inline(always)]
520    pub fn is_disabled(&self) -> bool {
521        *self == CH8_A::DISABLED
522    }
523    #[doc = "Checks if the value of the field is `ENABLED`"]
524    #[inline(always)]
525    pub fn is_enabled(&self) -> bool {
526        *self == CH8_A::ENABLED
527    }
528}
529#[doc = "Channel 8 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
530#[derive(Clone, Copy, Debug, PartialEq)]
531pub enum CH8_AW {
532    #[doc = "1: Write: disable channel"]
533    CLEAR = 1,
534}
535impl From<CH8_AW> for bool {
536    #[inline(always)]
537    fn from(variant: CH8_AW) -> Self {
538        variant as u8 != 0
539    }
540}
541#[doc = "Field `CH8` writer - Channel 8 enable clear register. Writing '0' has no effect"]
542pub type CH8_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH8_AW, O>;
543impl<'a, const O: u8> CH8_W<'a, O> {
544    #[doc = "Write: disable channel"]
545    #[inline(always)]
546    pub fn clear(self) -> &'a mut W {
547        self.variant(CH8_AW::CLEAR)
548    }
549}
550#[doc = "Field `CH9` reader - Channel 9 enable clear register. Writing '0' has no effect"]
551pub type CH9_R = crate::BitReader<CH9_A>;
552#[doc = "Channel 9 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
553#[derive(Clone, Copy, Debug, PartialEq)]
554pub enum CH9_A {
555    #[doc = "0: Read: channel disabled"]
556    DISABLED = 0,
557    #[doc = "1: Read: channel enabled"]
558    ENABLED = 1,
559}
560impl From<CH9_A> for bool {
561    #[inline(always)]
562    fn from(variant: CH9_A) -> Self {
563        variant as u8 != 0
564    }
565}
566impl CH9_R {
567    #[doc = "Get enumerated values variant"]
568    #[inline(always)]
569    pub fn variant(&self) -> CH9_A {
570        match self.bits {
571            false => CH9_A::DISABLED,
572            true => CH9_A::ENABLED,
573        }
574    }
575    #[doc = "Checks if the value of the field is `DISABLED`"]
576    #[inline(always)]
577    pub fn is_disabled(&self) -> bool {
578        *self == CH9_A::DISABLED
579    }
580    #[doc = "Checks if the value of the field is `ENABLED`"]
581    #[inline(always)]
582    pub fn is_enabled(&self) -> bool {
583        *self == CH9_A::ENABLED
584    }
585}
586#[doc = "Channel 9 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
587#[derive(Clone, Copy, Debug, PartialEq)]
588pub enum CH9_AW {
589    #[doc = "1: Write: disable channel"]
590    CLEAR = 1,
591}
592impl From<CH9_AW> for bool {
593    #[inline(always)]
594    fn from(variant: CH9_AW) -> Self {
595        variant as u8 != 0
596    }
597}
598#[doc = "Field `CH9` writer - Channel 9 enable clear register. Writing '0' has no effect"]
599pub type CH9_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH9_AW, O>;
600impl<'a, const O: u8> CH9_W<'a, O> {
601    #[doc = "Write: disable channel"]
602    #[inline(always)]
603    pub fn clear(self) -> &'a mut W {
604        self.variant(CH9_AW::CLEAR)
605    }
606}
607#[doc = "Field `CH10` reader - Channel 10 enable clear register. Writing '0' has no effect"]
608pub type CH10_R = crate::BitReader<CH10_A>;
609#[doc = "Channel 10 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
610#[derive(Clone, Copy, Debug, PartialEq)]
611pub enum CH10_A {
612    #[doc = "0: Read: channel disabled"]
613    DISABLED = 0,
614    #[doc = "1: Read: channel enabled"]
615    ENABLED = 1,
616}
617impl From<CH10_A> for bool {
618    #[inline(always)]
619    fn from(variant: CH10_A) -> Self {
620        variant as u8 != 0
621    }
622}
623impl CH10_R {
624    #[doc = "Get enumerated values variant"]
625    #[inline(always)]
626    pub fn variant(&self) -> CH10_A {
627        match self.bits {
628            false => CH10_A::DISABLED,
629            true => CH10_A::ENABLED,
630        }
631    }
632    #[doc = "Checks if the value of the field is `DISABLED`"]
633    #[inline(always)]
634    pub fn is_disabled(&self) -> bool {
635        *self == CH10_A::DISABLED
636    }
637    #[doc = "Checks if the value of the field is `ENABLED`"]
638    #[inline(always)]
639    pub fn is_enabled(&self) -> bool {
640        *self == CH10_A::ENABLED
641    }
642}
643#[doc = "Channel 10 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
644#[derive(Clone, Copy, Debug, PartialEq)]
645pub enum CH10_AW {
646    #[doc = "1: Write: disable channel"]
647    CLEAR = 1,
648}
649impl From<CH10_AW> for bool {
650    #[inline(always)]
651    fn from(variant: CH10_AW) -> Self {
652        variant as u8 != 0
653    }
654}
655#[doc = "Field `CH10` writer - Channel 10 enable clear register. Writing '0' has no effect"]
656pub type CH10_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH10_AW, O>;
657impl<'a, const O: u8> CH10_W<'a, O> {
658    #[doc = "Write: disable channel"]
659    #[inline(always)]
660    pub fn clear(self) -> &'a mut W {
661        self.variant(CH10_AW::CLEAR)
662    }
663}
664#[doc = "Field `CH11` reader - Channel 11 enable clear register. Writing '0' has no effect"]
665pub type CH11_R = crate::BitReader<CH11_A>;
666#[doc = "Channel 11 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
667#[derive(Clone, Copy, Debug, PartialEq)]
668pub enum CH11_A {
669    #[doc = "0: Read: channel disabled"]
670    DISABLED = 0,
671    #[doc = "1: Read: channel enabled"]
672    ENABLED = 1,
673}
674impl From<CH11_A> for bool {
675    #[inline(always)]
676    fn from(variant: CH11_A) -> Self {
677        variant as u8 != 0
678    }
679}
680impl CH11_R {
681    #[doc = "Get enumerated values variant"]
682    #[inline(always)]
683    pub fn variant(&self) -> CH11_A {
684        match self.bits {
685            false => CH11_A::DISABLED,
686            true => CH11_A::ENABLED,
687        }
688    }
689    #[doc = "Checks if the value of the field is `DISABLED`"]
690    #[inline(always)]
691    pub fn is_disabled(&self) -> bool {
692        *self == CH11_A::DISABLED
693    }
694    #[doc = "Checks if the value of the field is `ENABLED`"]
695    #[inline(always)]
696    pub fn is_enabled(&self) -> bool {
697        *self == CH11_A::ENABLED
698    }
699}
700#[doc = "Channel 11 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
701#[derive(Clone, Copy, Debug, PartialEq)]
702pub enum CH11_AW {
703    #[doc = "1: Write: disable channel"]
704    CLEAR = 1,
705}
706impl From<CH11_AW> for bool {
707    #[inline(always)]
708    fn from(variant: CH11_AW) -> Self {
709        variant as u8 != 0
710    }
711}
712#[doc = "Field `CH11` writer - Channel 11 enable clear register. Writing '0' has no effect"]
713pub type CH11_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH11_AW, O>;
714impl<'a, const O: u8> CH11_W<'a, O> {
715    #[doc = "Write: disable channel"]
716    #[inline(always)]
717    pub fn clear(self) -> &'a mut W {
718        self.variant(CH11_AW::CLEAR)
719    }
720}
721#[doc = "Field `CH12` reader - Channel 12 enable clear register. Writing '0' has no effect"]
722pub type CH12_R = crate::BitReader<CH12_A>;
723#[doc = "Channel 12 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
724#[derive(Clone, Copy, Debug, PartialEq)]
725pub enum CH12_A {
726    #[doc = "0: Read: channel disabled"]
727    DISABLED = 0,
728    #[doc = "1: Read: channel enabled"]
729    ENABLED = 1,
730}
731impl From<CH12_A> for bool {
732    #[inline(always)]
733    fn from(variant: CH12_A) -> Self {
734        variant as u8 != 0
735    }
736}
737impl CH12_R {
738    #[doc = "Get enumerated values variant"]
739    #[inline(always)]
740    pub fn variant(&self) -> CH12_A {
741        match self.bits {
742            false => CH12_A::DISABLED,
743            true => CH12_A::ENABLED,
744        }
745    }
746    #[doc = "Checks if the value of the field is `DISABLED`"]
747    #[inline(always)]
748    pub fn is_disabled(&self) -> bool {
749        *self == CH12_A::DISABLED
750    }
751    #[doc = "Checks if the value of the field is `ENABLED`"]
752    #[inline(always)]
753    pub fn is_enabled(&self) -> bool {
754        *self == CH12_A::ENABLED
755    }
756}
757#[doc = "Channel 12 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
758#[derive(Clone, Copy, Debug, PartialEq)]
759pub enum CH12_AW {
760    #[doc = "1: Write: disable channel"]
761    CLEAR = 1,
762}
763impl From<CH12_AW> for bool {
764    #[inline(always)]
765    fn from(variant: CH12_AW) -> Self {
766        variant as u8 != 0
767    }
768}
769#[doc = "Field `CH12` writer - Channel 12 enable clear register. Writing '0' has no effect"]
770pub type CH12_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH12_AW, O>;
771impl<'a, const O: u8> CH12_W<'a, O> {
772    #[doc = "Write: disable channel"]
773    #[inline(always)]
774    pub fn clear(self) -> &'a mut W {
775        self.variant(CH12_AW::CLEAR)
776    }
777}
778#[doc = "Field `CH13` reader - Channel 13 enable clear register. Writing '0' has no effect"]
779pub type CH13_R = crate::BitReader<CH13_A>;
780#[doc = "Channel 13 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
781#[derive(Clone, Copy, Debug, PartialEq)]
782pub enum CH13_A {
783    #[doc = "0: Read: channel disabled"]
784    DISABLED = 0,
785    #[doc = "1: Read: channel enabled"]
786    ENABLED = 1,
787}
788impl From<CH13_A> for bool {
789    #[inline(always)]
790    fn from(variant: CH13_A) -> Self {
791        variant as u8 != 0
792    }
793}
794impl CH13_R {
795    #[doc = "Get enumerated values variant"]
796    #[inline(always)]
797    pub fn variant(&self) -> CH13_A {
798        match self.bits {
799            false => CH13_A::DISABLED,
800            true => CH13_A::ENABLED,
801        }
802    }
803    #[doc = "Checks if the value of the field is `DISABLED`"]
804    #[inline(always)]
805    pub fn is_disabled(&self) -> bool {
806        *self == CH13_A::DISABLED
807    }
808    #[doc = "Checks if the value of the field is `ENABLED`"]
809    #[inline(always)]
810    pub fn is_enabled(&self) -> bool {
811        *self == CH13_A::ENABLED
812    }
813}
814#[doc = "Channel 13 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
815#[derive(Clone, Copy, Debug, PartialEq)]
816pub enum CH13_AW {
817    #[doc = "1: Write: disable channel"]
818    CLEAR = 1,
819}
820impl From<CH13_AW> for bool {
821    #[inline(always)]
822    fn from(variant: CH13_AW) -> Self {
823        variant as u8 != 0
824    }
825}
826#[doc = "Field `CH13` writer - Channel 13 enable clear register. Writing '0' has no effect"]
827pub type CH13_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH13_AW, O>;
828impl<'a, const O: u8> CH13_W<'a, O> {
829    #[doc = "Write: disable channel"]
830    #[inline(always)]
831    pub fn clear(self) -> &'a mut W {
832        self.variant(CH13_AW::CLEAR)
833    }
834}
835#[doc = "Field `CH14` reader - Channel 14 enable clear register. Writing '0' has no effect"]
836pub type CH14_R = crate::BitReader<CH14_A>;
837#[doc = "Channel 14 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
838#[derive(Clone, Copy, Debug, PartialEq)]
839pub enum CH14_A {
840    #[doc = "0: Read: channel disabled"]
841    DISABLED = 0,
842    #[doc = "1: Read: channel enabled"]
843    ENABLED = 1,
844}
845impl From<CH14_A> for bool {
846    #[inline(always)]
847    fn from(variant: CH14_A) -> Self {
848        variant as u8 != 0
849    }
850}
851impl CH14_R {
852    #[doc = "Get enumerated values variant"]
853    #[inline(always)]
854    pub fn variant(&self) -> CH14_A {
855        match self.bits {
856            false => CH14_A::DISABLED,
857            true => CH14_A::ENABLED,
858        }
859    }
860    #[doc = "Checks if the value of the field is `DISABLED`"]
861    #[inline(always)]
862    pub fn is_disabled(&self) -> bool {
863        *self == CH14_A::DISABLED
864    }
865    #[doc = "Checks if the value of the field is `ENABLED`"]
866    #[inline(always)]
867    pub fn is_enabled(&self) -> bool {
868        *self == CH14_A::ENABLED
869    }
870}
871#[doc = "Channel 14 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
872#[derive(Clone, Copy, Debug, PartialEq)]
873pub enum CH14_AW {
874    #[doc = "1: Write: disable channel"]
875    CLEAR = 1,
876}
877impl From<CH14_AW> for bool {
878    #[inline(always)]
879    fn from(variant: CH14_AW) -> Self {
880        variant as u8 != 0
881    }
882}
883#[doc = "Field `CH14` writer - Channel 14 enable clear register. Writing '0' has no effect"]
884pub type CH14_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH14_AW, O>;
885impl<'a, const O: u8> CH14_W<'a, O> {
886    #[doc = "Write: disable channel"]
887    #[inline(always)]
888    pub fn clear(self) -> &'a mut W {
889        self.variant(CH14_AW::CLEAR)
890    }
891}
892#[doc = "Field `CH15` reader - Channel 15 enable clear register. Writing '0' has no effect"]
893pub type CH15_R = crate::BitReader<CH15_A>;
894#[doc = "Channel 15 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
895#[derive(Clone, Copy, Debug, PartialEq)]
896pub enum CH15_A {
897    #[doc = "0: Read: channel disabled"]
898    DISABLED = 0,
899    #[doc = "1: Read: channel enabled"]
900    ENABLED = 1,
901}
902impl From<CH15_A> for bool {
903    #[inline(always)]
904    fn from(variant: CH15_A) -> Self {
905        variant as u8 != 0
906    }
907}
908impl CH15_R {
909    #[doc = "Get enumerated values variant"]
910    #[inline(always)]
911    pub fn variant(&self) -> CH15_A {
912        match self.bits {
913            false => CH15_A::DISABLED,
914            true => CH15_A::ENABLED,
915        }
916    }
917    #[doc = "Checks if the value of the field is `DISABLED`"]
918    #[inline(always)]
919    pub fn is_disabled(&self) -> bool {
920        *self == CH15_A::DISABLED
921    }
922    #[doc = "Checks if the value of the field is `ENABLED`"]
923    #[inline(always)]
924    pub fn is_enabled(&self) -> bool {
925        *self == CH15_A::ENABLED
926    }
927}
928#[doc = "Channel 15 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
929#[derive(Clone, Copy, Debug, PartialEq)]
930pub enum CH15_AW {
931    #[doc = "1: Write: disable channel"]
932    CLEAR = 1,
933}
934impl From<CH15_AW> for bool {
935    #[inline(always)]
936    fn from(variant: CH15_AW) -> Self {
937        variant as u8 != 0
938    }
939}
940#[doc = "Field `CH15` writer - Channel 15 enable clear register. Writing '0' has no effect"]
941pub type CH15_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH15_AW, O>;
942impl<'a, const O: u8> CH15_W<'a, O> {
943    #[doc = "Write: disable channel"]
944    #[inline(always)]
945    pub fn clear(self) -> &'a mut W {
946        self.variant(CH15_AW::CLEAR)
947    }
948}
949#[doc = "Field `CH16` reader - Channel 16 enable clear register. Writing '0' has no effect"]
950pub type CH16_R = crate::BitReader<CH16_A>;
951#[doc = "Channel 16 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
952#[derive(Clone, Copy, Debug, PartialEq)]
953pub enum CH16_A {
954    #[doc = "0: Read: channel disabled"]
955    DISABLED = 0,
956    #[doc = "1: Read: channel enabled"]
957    ENABLED = 1,
958}
959impl From<CH16_A> for bool {
960    #[inline(always)]
961    fn from(variant: CH16_A) -> Self {
962        variant as u8 != 0
963    }
964}
965impl CH16_R {
966    #[doc = "Get enumerated values variant"]
967    #[inline(always)]
968    pub fn variant(&self) -> CH16_A {
969        match self.bits {
970            false => CH16_A::DISABLED,
971            true => CH16_A::ENABLED,
972        }
973    }
974    #[doc = "Checks if the value of the field is `DISABLED`"]
975    #[inline(always)]
976    pub fn is_disabled(&self) -> bool {
977        *self == CH16_A::DISABLED
978    }
979    #[doc = "Checks if the value of the field is `ENABLED`"]
980    #[inline(always)]
981    pub fn is_enabled(&self) -> bool {
982        *self == CH16_A::ENABLED
983    }
984}
985#[doc = "Channel 16 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
986#[derive(Clone, Copy, Debug, PartialEq)]
987pub enum CH16_AW {
988    #[doc = "1: Write: disable channel"]
989    CLEAR = 1,
990}
991impl From<CH16_AW> for bool {
992    #[inline(always)]
993    fn from(variant: CH16_AW) -> Self {
994        variant as u8 != 0
995    }
996}
997#[doc = "Field `CH16` writer - Channel 16 enable clear register. Writing '0' has no effect"]
998pub type CH16_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH16_AW, O>;
999impl<'a, const O: u8> CH16_W<'a, O> {
1000    #[doc = "Write: disable channel"]
1001    #[inline(always)]
1002    pub fn clear(self) -> &'a mut W {
1003        self.variant(CH16_AW::CLEAR)
1004    }
1005}
1006#[doc = "Field `CH17` reader - Channel 17 enable clear register. Writing '0' has no effect"]
1007pub type CH17_R = crate::BitReader<CH17_A>;
1008#[doc = "Channel 17 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1009#[derive(Clone, Copy, Debug, PartialEq)]
1010pub enum CH17_A {
1011    #[doc = "0: Read: channel disabled"]
1012    DISABLED = 0,
1013    #[doc = "1: Read: channel enabled"]
1014    ENABLED = 1,
1015}
1016impl From<CH17_A> for bool {
1017    #[inline(always)]
1018    fn from(variant: CH17_A) -> Self {
1019        variant as u8 != 0
1020    }
1021}
1022impl CH17_R {
1023    #[doc = "Get enumerated values variant"]
1024    #[inline(always)]
1025    pub fn variant(&self) -> CH17_A {
1026        match self.bits {
1027            false => CH17_A::DISABLED,
1028            true => CH17_A::ENABLED,
1029        }
1030    }
1031    #[doc = "Checks if the value of the field is `DISABLED`"]
1032    #[inline(always)]
1033    pub fn is_disabled(&self) -> bool {
1034        *self == CH17_A::DISABLED
1035    }
1036    #[doc = "Checks if the value of the field is `ENABLED`"]
1037    #[inline(always)]
1038    pub fn is_enabled(&self) -> bool {
1039        *self == CH17_A::ENABLED
1040    }
1041}
1042#[doc = "Channel 17 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1043#[derive(Clone, Copy, Debug, PartialEq)]
1044pub enum CH17_AW {
1045    #[doc = "1: Write: disable channel"]
1046    CLEAR = 1,
1047}
1048impl From<CH17_AW> for bool {
1049    #[inline(always)]
1050    fn from(variant: CH17_AW) -> Self {
1051        variant as u8 != 0
1052    }
1053}
1054#[doc = "Field `CH17` writer - Channel 17 enable clear register. Writing '0' has no effect"]
1055pub type CH17_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH17_AW, O>;
1056impl<'a, const O: u8> CH17_W<'a, O> {
1057    #[doc = "Write: disable channel"]
1058    #[inline(always)]
1059    pub fn clear(self) -> &'a mut W {
1060        self.variant(CH17_AW::CLEAR)
1061    }
1062}
1063#[doc = "Field `CH18` reader - Channel 18 enable clear register. Writing '0' has no effect"]
1064pub type CH18_R = crate::BitReader<CH18_A>;
1065#[doc = "Channel 18 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1066#[derive(Clone, Copy, Debug, PartialEq)]
1067pub enum CH18_A {
1068    #[doc = "0: Read: channel disabled"]
1069    DISABLED = 0,
1070    #[doc = "1: Read: channel enabled"]
1071    ENABLED = 1,
1072}
1073impl From<CH18_A> for bool {
1074    #[inline(always)]
1075    fn from(variant: CH18_A) -> Self {
1076        variant as u8 != 0
1077    }
1078}
1079impl CH18_R {
1080    #[doc = "Get enumerated values variant"]
1081    #[inline(always)]
1082    pub fn variant(&self) -> CH18_A {
1083        match self.bits {
1084            false => CH18_A::DISABLED,
1085            true => CH18_A::ENABLED,
1086        }
1087    }
1088    #[doc = "Checks if the value of the field is `DISABLED`"]
1089    #[inline(always)]
1090    pub fn is_disabled(&self) -> bool {
1091        *self == CH18_A::DISABLED
1092    }
1093    #[doc = "Checks if the value of the field is `ENABLED`"]
1094    #[inline(always)]
1095    pub fn is_enabled(&self) -> bool {
1096        *self == CH18_A::ENABLED
1097    }
1098}
1099#[doc = "Channel 18 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1100#[derive(Clone, Copy, Debug, PartialEq)]
1101pub enum CH18_AW {
1102    #[doc = "1: Write: disable channel"]
1103    CLEAR = 1,
1104}
1105impl From<CH18_AW> for bool {
1106    #[inline(always)]
1107    fn from(variant: CH18_AW) -> Self {
1108        variant as u8 != 0
1109    }
1110}
1111#[doc = "Field `CH18` writer - Channel 18 enable clear register. Writing '0' has no effect"]
1112pub type CH18_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH18_AW, O>;
1113impl<'a, const O: u8> CH18_W<'a, O> {
1114    #[doc = "Write: disable channel"]
1115    #[inline(always)]
1116    pub fn clear(self) -> &'a mut W {
1117        self.variant(CH18_AW::CLEAR)
1118    }
1119}
1120#[doc = "Field `CH19` reader - Channel 19 enable clear register. Writing '0' has no effect"]
1121pub type CH19_R = crate::BitReader<CH19_A>;
1122#[doc = "Channel 19 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1123#[derive(Clone, Copy, Debug, PartialEq)]
1124pub enum CH19_A {
1125    #[doc = "0: Read: channel disabled"]
1126    DISABLED = 0,
1127    #[doc = "1: Read: channel enabled"]
1128    ENABLED = 1,
1129}
1130impl From<CH19_A> for bool {
1131    #[inline(always)]
1132    fn from(variant: CH19_A) -> Self {
1133        variant as u8 != 0
1134    }
1135}
1136impl CH19_R {
1137    #[doc = "Get enumerated values variant"]
1138    #[inline(always)]
1139    pub fn variant(&self) -> CH19_A {
1140        match self.bits {
1141            false => CH19_A::DISABLED,
1142            true => CH19_A::ENABLED,
1143        }
1144    }
1145    #[doc = "Checks if the value of the field is `DISABLED`"]
1146    #[inline(always)]
1147    pub fn is_disabled(&self) -> bool {
1148        *self == CH19_A::DISABLED
1149    }
1150    #[doc = "Checks if the value of the field is `ENABLED`"]
1151    #[inline(always)]
1152    pub fn is_enabled(&self) -> bool {
1153        *self == CH19_A::ENABLED
1154    }
1155}
1156#[doc = "Channel 19 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1157#[derive(Clone, Copy, Debug, PartialEq)]
1158pub enum CH19_AW {
1159    #[doc = "1: Write: disable channel"]
1160    CLEAR = 1,
1161}
1162impl From<CH19_AW> for bool {
1163    #[inline(always)]
1164    fn from(variant: CH19_AW) -> Self {
1165        variant as u8 != 0
1166    }
1167}
1168#[doc = "Field `CH19` writer - Channel 19 enable clear register. Writing '0' has no effect"]
1169pub type CH19_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH19_AW, O>;
1170impl<'a, const O: u8> CH19_W<'a, O> {
1171    #[doc = "Write: disable channel"]
1172    #[inline(always)]
1173    pub fn clear(self) -> &'a mut W {
1174        self.variant(CH19_AW::CLEAR)
1175    }
1176}
1177#[doc = "Field `CH20` reader - Channel 20 enable clear register. Writing '0' has no effect"]
1178pub type CH20_R = crate::BitReader<CH20_A>;
1179#[doc = "Channel 20 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1180#[derive(Clone, Copy, Debug, PartialEq)]
1181pub enum CH20_A {
1182    #[doc = "0: Read: channel disabled"]
1183    DISABLED = 0,
1184    #[doc = "1: Read: channel enabled"]
1185    ENABLED = 1,
1186}
1187impl From<CH20_A> for bool {
1188    #[inline(always)]
1189    fn from(variant: CH20_A) -> Self {
1190        variant as u8 != 0
1191    }
1192}
1193impl CH20_R {
1194    #[doc = "Get enumerated values variant"]
1195    #[inline(always)]
1196    pub fn variant(&self) -> CH20_A {
1197        match self.bits {
1198            false => CH20_A::DISABLED,
1199            true => CH20_A::ENABLED,
1200        }
1201    }
1202    #[doc = "Checks if the value of the field is `DISABLED`"]
1203    #[inline(always)]
1204    pub fn is_disabled(&self) -> bool {
1205        *self == CH20_A::DISABLED
1206    }
1207    #[doc = "Checks if the value of the field is `ENABLED`"]
1208    #[inline(always)]
1209    pub fn is_enabled(&self) -> bool {
1210        *self == CH20_A::ENABLED
1211    }
1212}
1213#[doc = "Channel 20 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1214#[derive(Clone, Copy, Debug, PartialEq)]
1215pub enum CH20_AW {
1216    #[doc = "1: Write: disable channel"]
1217    CLEAR = 1,
1218}
1219impl From<CH20_AW> for bool {
1220    #[inline(always)]
1221    fn from(variant: CH20_AW) -> Self {
1222        variant as u8 != 0
1223    }
1224}
1225#[doc = "Field `CH20` writer - Channel 20 enable clear register. Writing '0' has no effect"]
1226pub type CH20_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH20_AW, O>;
1227impl<'a, const O: u8> CH20_W<'a, O> {
1228    #[doc = "Write: disable channel"]
1229    #[inline(always)]
1230    pub fn clear(self) -> &'a mut W {
1231        self.variant(CH20_AW::CLEAR)
1232    }
1233}
1234#[doc = "Field `CH21` reader - Channel 21 enable clear register. Writing '0' has no effect"]
1235pub type CH21_R = crate::BitReader<CH21_A>;
1236#[doc = "Channel 21 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1237#[derive(Clone, Copy, Debug, PartialEq)]
1238pub enum CH21_A {
1239    #[doc = "0: Read: channel disabled"]
1240    DISABLED = 0,
1241    #[doc = "1: Read: channel enabled"]
1242    ENABLED = 1,
1243}
1244impl From<CH21_A> for bool {
1245    #[inline(always)]
1246    fn from(variant: CH21_A) -> Self {
1247        variant as u8 != 0
1248    }
1249}
1250impl CH21_R {
1251    #[doc = "Get enumerated values variant"]
1252    #[inline(always)]
1253    pub fn variant(&self) -> CH21_A {
1254        match self.bits {
1255            false => CH21_A::DISABLED,
1256            true => CH21_A::ENABLED,
1257        }
1258    }
1259    #[doc = "Checks if the value of the field is `DISABLED`"]
1260    #[inline(always)]
1261    pub fn is_disabled(&self) -> bool {
1262        *self == CH21_A::DISABLED
1263    }
1264    #[doc = "Checks if the value of the field is `ENABLED`"]
1265    #[inline(always)]
1266    pub fn is_enabled(&self) -> bool {
1267        *self == CH21_A::ENABLED
1268    }
1269}
1270#[doc = "Channel 21 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1271#[derive(Clone, Copy, Debug, PartialEq)]
1272pub enum CH21_AW {
1273    #[doc = "1: Write: disable channel"]
1274    CLEAR = 1,
1275}
1276impl From<CH21_AW> for bool {
1277    #[inline(always)]
1278    fn from(variant: CH21_AW) -> Self {
1279        variant as u8 != 0
1280    }
1281}
1282#[doc = "Field `CH21` writer - Channel 21 enable clear register. Writing '0' has no effect"]
1283pub type CH21_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH21_AW, O>;
1284impl<'a, const O: u8> CH21_W<'a, O> {
1285    #[doc = "Write: disable channel"]
1286    #[inline(always)]
1287    pub fn clear(self) -> &'a mut W {
1288        self.variant(CH21_AW::CLEAR)
1289    }
1290}
1291#[doc = "Field `CH22` reader - Channel 22 enable clear register. Writing '0' has no effect"]
1292pub type CH22_R = crate::BitReader<CH22_A>;
1293#[doc = "Channel 22 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1294#[derive(Clone, Copy, Debug, PartialEq)]
1295pub enum CH22_A {
1296    #[doc = "0: Read: channel disabled"]
1297    DISABLED = 0,
1298    #[doc = "1: Read: channel enabled"]
1299    ENABLED = 1,
1300}
1301impl From<CH22_A> for bool {
1302    #[inline(always)]
1303    fn from(variant: CH22_A) -> Self {
1304        variant as u8 != 0
1305    }
1306}
1307impl CH22_R {
1308    #[doc = "Get enumerated values variant"]
1309    #[inline(always)]
1310    pub fn variant(&self) -> CH22_A {
1311        match self.bits {
1312            false => CH22_A::DISABLED,
1313            true => CH22_A::ENABLED,
1314        }
1315    }
1316    #[doc = "Checks if the value of the field is `DISABLED`"]
1317    #[inline(always)]
1318    pub fn is_disabled(&self) -> bool {
1319        *self == CH22_A::DISABLED
1320    }
1321    #[doc = "Checks if the value of the field is `ENABLED`"]
1322    #[inline(always)]
1323    pub fn is_enabled(&self) -> bool {
1324        *self == CH22_A::ENABLED
1325    }
1326}
1327#[doc = "Channel 22 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1328#[derive(Clone, Copy, Debug, PartialEq)]
1329pub enum CH22_AW {
1330    #[doc = "1: Write: disable channel"]
1331    CLEAR = 1,
1332}
1333impl From<CH22_AW> for bool {
1334    #[inline(always)]
1335    fn from(variant: CH22_AW) -> Self {
1336        variant as u8 != 0
1337    }
1338}
1339#[doc = "Field `CH22` writer - Channel 22 enable clear register. Writing '0' has no effect"]
1340pub type CH22_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH22_AW, O>;
1341impl<'a, const O: u8> CH22_W<'a, O> {
1342    #[doc = "Write: disable channel"]
1343    #[inline(always)]
1344    pub fn clear(self) -> &'a mut W {
1345        self.variant(CH22_AW::CLEAR)
1346    }
1347}
1348#[doc = "Field `CH23` reader - Channel 23 enable clear register. Writing '0' has no effect"]
1349pub type CH23_R = crate::BitReader<CH23_A>;
1350#[doc = "Channel 23 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1351#[derive(Clone, Copy, Debug, PartialEq)]
1352pub enum CH23_A {
1353    #[doc = "0: Read: channel disabled"]
1354    DISABLED = 0,
1355    #[doc = "1: Read: channel enabled"]
1356    ENABLED = 1,
1357}
1358impl From<CH23_A> for bool {
1359    #[inline(always)]
1360    fn from(variant: CH23_A) -> Self {
1361        variant as u8 != 0
1362    }
1363}
1364impl CH23_R {
1365    #[doc = "Get enumerated values variant"]
1366    #[inline(always)]
1367    pub fn variant(&self) -> CH23_A {
1368        match self.bits {
1369            false => CH23_A::DISABLED,
1370            true => CH23_A::ENABLED,
1371        }
1372    }
1373    #[doc = "Checks if the value of the field is `DISABLED`"]
1374    #[inline(always)]
1375    pub fn is_disabled(&self) -> bool {
1376        *self == CH23_A::DISABLED
1377    }
1378    #[doc = "Checks if the value of the field is `ENABLED`"]
1379    #[inline(always)]
1380    pub fn is_enabled(&self) -> bool {
1381        *self == CH23_A::ENABLED
1382    }
1383}
1384#[doc = "Channel 23 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1385#[derive(Clone, Copy, Debug, PartialEq)]
1386pub enum CH23_AW {
1387    #[doc = "1: Write: disable channel"]
1388    CLEAR = 1,
1389}
1390impl From<CH23_AW> for bool {
1391    #[inline(always)]
1392    fn from(variant: CH23_AW) -> Self {
1393        variant as u8 != 0
1394    }
1395}
1396#[doc = "Field `CH23` writer - Channel 23 enable clear register. Writing '0' has no effect"]
1397pub type CH23_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH23_AW, O>;
1398impl<'a, const O: u8> CH23_W<'a, O> {
1399    #[doc = "Write: disable channel"]
1400    #[inline(always)]
1401    pub fn clear(self) -> &'a mut W {
1402        self.variant(CH23_AW::CLEAR)
1403    }
1404}
1405#[doc = "Field `CH24` reader - Channel 24 enable clear register. Writing '0' has no effect"]
1406pub type CH24_R = crate::BitReader<CH24_A>;
1407#[doc = "Channel 24 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1408#[derive(Clone, Copy, Debug, PartialEq)]
1409pub enum CH24_A {
1410    #[doc = "0: Read: channel disabled"]
1411    DISABLED = 0,
1412    #[doc = "1: Read: channel enabled"]
1413    ENABLED = 1,
1414}
1415impl From<CH24_A> for bool {
1416    #[inline(always)]
1417    fn from(variant: CH24_A) -> Self {
1418        variant as u8 != 0
1419    }
1420}
1421impl CH24_R {
1422    #[doc = "Get enumerated values variant"]
1423    #[inline(always)]
1424    pub fn variant(&self) -> CH24_A {
1425        match self.bits {
1426            false => CH24_A::DISABLED,
1427            true => CH24_A::ENABLED,
1428        }
1429    }
1430    #[doc = "Checks if the value of the field is `DISABLED`"]
1431    #[inline(always)]
1432    pub fn is_disabled(&self) -> bool {
1433        *self == CH24_A::DISABLED
1434    }
1435    #[doc = "Checks if the value of the field is `ENABLED`"]
1436    #[inline(always)]
1437    pub fn is_enabled(&self) -> bool {
1438        *self == CH24_A::ENABLED
1439    }
1440}
1441#[doc = "Channel 24 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1442#[derive(Clone, Copy, Debug, PartialEq)]
1443pub enum CH24_AW {
1444    #[doc = "1: Write: disable channel"]
1445    CLEAR = 1,
1446}
1447impl From<CH24_AW> for bool {
1448    #[inline(always)]
1449    fn from(variant: CH24_AW) -> Self {
1450        variant as u8 != 0
1451    }
1452}
1453#[doc = "Field `CH24` writer - Channel 24 enable clear register. Writing '0' has no effect"]
1454pub type CH24_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH24_AW, O>;
1455impl<'a, const O: u8> CH24_W<'a, O> {
1456    #[doc = "Write: disable channel"]
1457    #[inline(always)]
1458    pub fn clear(self) -> &'a mut W {
1459        self.variant(CH24_AW::CLEAR)
1460    }
1461}
1462#[doc = "Field `CH25` reader - Channel 25 enable clear register. Writing '0' has no effect"]
1463pub type CH25_R = crate::BitReader<CH25_A>;
1464#[doc = "Channel 25 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1465#[derive(Clone, Copy, Debug, PartialEq)]
1466pub enum CH25_A {
1467    #[doc = "0: Read: channel disabled"]
1468    DISABLED = 0,
1469    #[doc = "1: Read: channel enabled"]
1470    ENABLED = 1,
1471}
1472impl From<CH25_A> for bool {
1473    #[inline(always)]
1474    fn from(variant: CH25_A) -> Self {
1475        variant as u8 != 0
1476    }
1477}
1478impl CH25_R {
1479    #[doc = "Get enumerated values variant"]
1480    #[inline(always)]
1481    pub fn variant(&self) -> CH25_A {
1482        match self.bits {
1483            false => CH25_A::DISABLED,
1484            true => CH25_A::ENABLED,
1485        }
1486    }
1487    #[doc = "Checks if the value of the field is `DISABLED`"]
1488    #[inline(always)]
1489    pub fn is_disabled(&self) -> bool {
1490        *self == CH25_A::DISABLED
1491    }
1492    #[doc = "Checks if the value of the field is `ENABLED`"]
1493    #[inline(always)]
1494    pub fn is_enabled(&self) -> bool {
1495        *self == CH25_A::ENABLED
1496    }
1497}
1498#[doc = "Channel 25 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1499#[derive(Clone, Copy, Debug, PartialEq)]
1500pub enum CH25_AW {
1501    #[doc = "1: Write: disable channel"]
1502    CLEAR = 1,
1503}
1504impl From<CH25_AW> for bool {
1505    #[inline(always)]
1506    fn from(variant: CH25_AW) -> Self {
1507        variant as u8 != 0
1508    }
1509}
1510#[doc = "Field `CH25` writer - Channel 25 enable clear register. Writing '0' has no effect"]
1511pub type CH25_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH25_AW, O>;
1512impl<'a, const O: u8> CH25_W<'a, O> {
1513    #[doc = "Write: disable channel"]
1514    #[inline(always)]
1515    pub fn clear(self) -> &'a mut W {
1516        self.variant(CH25_AW::CLEAR)
1517    }
1518}
1519#[doc = "Field `CH26` reader - Channel 26 enable clear register. Writing '0' has no effect"]
1520pub type CH26_R = crate::BitReader<CH26_A>;
1521#[doc = "Channel 26 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1522#[derive(Clone, Copy, Debug, PartialEq)]
1523pub enum CH26_A {
1524    #[doc = "0: Read: channel disabled"]
1525    DISABLED = 0,
1526    #[doc = "1: Read: channel enabled"]
1527    ENABLED = 1,
1528}
1529impl From<CH26_A> for bool {
1530    #[inline(always)]
1531    fn from(variant: CH26_A) -> Self {
1532        variant as u8 != 0
1533    }
1534}
1535impl CH26_R {
1536    #[doc = "Get enumerated values variant"]
1537    #[inline(always)]
1538    pub fn variant(&self) -> CH26_A {
1539        match self.bits {
1540            false => CH26_A::DISABLED,
1541            true => CH26_A::ENABLED,
1542        }
1543    }
1544    #[doc = "Checks if the value of the field is `DISABLED`"]
1545    #[inline(always)]
1546    pub fn is_disabled(&self) -> bool {
1547        *self == CH26_A::DISABLED
1548    }
1549    #[doc = "Checks if the value of the field is `ENABLED`"]
1550    #[inline(always)]
1551    pub fn is_enabled(&self) -> bool {
1552        *self == CH26_A::ENABLED
1553    }
1554}
1555#[doc = "Channel 26 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1556#[derive(Clone, Copy, Debug, PartialEq)]
1557pub enum CH26_AW {
1558    #[doc = "1: Write: disable channel"]
1559    CLEAR = 1,
1560}
1561impl From<CH26_AW> for bool {
1562    #[inline(always)]
1563    fn from(variant: CH26_AW) -> Self {
1564        variant as u8 != 0
1565    }
1566}
1567#[doc = "Field `CH26` writer - Channel 26 enable clear register. Writing '0' has no effect"]
1568pub type CH26_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH26_AW, O>;
1569impl<'a, const O: u8> CH26_W<'a, O> {
1570    #[doc = "Write: disable channel"]
1571    #[inline(always)]
1572    pub fn clear(self) -> &'a mut W {
1573        self.variant(CH26_AW::CLEAR)
1574    }
1575}
1576#[doc = "Field `CH27` reader - Channel 27 enable clear register. Writing '0' has no effect"]
1577pub type CH27_R = crate::BitReader<CH27_A>;
1578#[doc = "Channel 27 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1579#[derive(Clone, Copy, Debug, PartialEq)]
1580pub enum CH27_A {
1581    #[doc = "0: Read: channel disabled"]
1582    DISABLED = 0,
1583    #[doc = "1: Read: channel enabled"]
1584    ENABLED = 1,
1585}
1586impl From<CH27_A> for bool {
1587    #[inline(always)]
1588    fn from(variant: CH27_A) -> Self {
1589        variant as u8 != 0
1590    }
1591}
1592impl CH27_R {
1593    #[doc = "Get enumerated values variant"]
1594    #[inline(always)]
1595    pub fn variant(&self) -> CH27_A {
1596        match self.bits {
1597            false => CH27_A::DISABLED,
1598            true => CH27_A::ENABLED,
1599        }
1600    }
1601    #[doc = "Checks if the value of the field is `DISABLED`"]
1602    #[inline(always)]
1603    pub fn is_disabled(&self) -> bool {
1604        *self == CH27_A::DISABLED
1605    }
1606    #[doc = "Checks if the value of the field is `ENABLED`"]
1607    #[inline(always)]
1608    pub fn is_enabled(&self) -> bool {
1609        *self == CH27_A::ENABLED
1610    }
1611}
1612#[doc = "Channel 27 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1613#[derive(Clone, Copy, Debug, PartialEq)]
1614pub enum CH27_AW {
1615    #[doc = "1: Write: disable channel"]
1616    CLEAR = 1,
1617}
1618impl From<CH27_AW> for bool {
1619    #[inline(always)]
1620    fn from(variant: CH27_AW) -> Self {
1621        variant as u8 != 0
1622    }
1623}
1624#[doc = "Field `CH27` writer - Channel 27 enable clear register. Writing '0' has no effect"]
1625pub type CH27_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH27_AW, O>;
1626impl<'a, const O: u8> CH27_W<'a, O> {
1627    #[doc = "Write: disable channel"]
1628    #[inline(always)]
1629    pub fn clear(self) -> &'a mut W {
1630        self.variant(CH27_AW::CLEAR)
1631    }
1632}
1633#[doc = "Field `CH28` reader - Channel 28 enable clear register. Writing '0' has no effect"]
1634pub type CH28_R = crate::BitReader<CH28_A>;
1635#[doc = "Channel 28 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1636#[derive(Clone, Copy, Debug, PartialEq)]
1637pub enum CH28_A {
1638    #[doc = "0: Read: channel disabled"]
1639    DISABLED = 0,
1640    #[doc = "1: Read: channel enabled"]
1641    ENABLED = 1,
1642}
1643impl From<CH28_A> for bool {
1644    #[inline(always)]
1645    fn from(variant: CH28_A) -> Self {
1646        variant as u8 != 0
1647    }
1648}
1649impl CH28_R {
1650    #[doc = "Get enumerated values variant"]
1651    #[inline(always)]
1652    pub fn variant(&self) -> CH28_A {
1653        match self.bits {
1654            false => CH28_A::DISABLED,
1655            true => CH28_A::ENABLED,
1656        }
1657    }
1658    #[doc = "Checks if the value of the field is `DISABLED`"]
1659    #[inline(always)]
1660    pub fn is_disabled(&self) -> bool {
1661        *self == CH28_A::DISABLED
1662    }
1663    #[doc = "Checks if the value of the field is `ENABLED`"]
1664    #[inline(always)]
1665    pub fn is_enabled(&self) -> bool {
1666        *self == CH28_A::ENABLED
1667    }
1668}
1669#[doc = "Channel 28 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1670#[derive(Clone, Copy, Debug, PartialEq)]
1671pub enum CH28_AW {
1672    #[doc = "1: Write: disable channel"]
1673    CLEAR = 1,
1674}
1675impl From<CH28_AW> for bool {
1676    #[inline(always)]
1677    fn from(variant: CH28_AW) -> Self {
1678        variant as u8 != 0
1679    }
1680}
1681#[doc = "Field `CH28` writer - Channel 28 enable clear register. Writing '0' has no effect"]
1682pub type CH28_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH28_AW, O>;
1683impl<'a, const O: u8> CH28_W<'a, O> {
1684    #[doc = "Write: disable channel"]
1685    #[inline(always)]
1686    pub fn clear(self) -> &'a mut W {
1687        self.variant(CH28_AW::CLEAR)
1688    }
1689}
1690#[doc = "Field `CH29` reader - Channel 29 enable clear register. Writing '0' has no effect"]
1691pub type CH29_R = crate::BitReader<CH29_A>;
1692#[doc = "Channel 29 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1693#[derive(Clone, Copy, Debug, PartialEq)]
1694pub enum CH29_A {
1695    #[doc = "0: Read: channel disabled"]
1696    DISABLED = 0,
1697    #[doc = "1: Read: channel enabled"]
1698    ENABLED = 1,
1699}
1700impl From<CH29_A> for bool {
1701    #[inline(always)]
1702    fn from(variant: CH29_A) -> Self {
1703        variant as u8 != 0
1704    }
1705}
1706impl CH29_R {
1707    #[doc = "Get enumerated values variant"]
1708    #[inline(always)]
1709    pub fn variant(&self) -> CH29_A {
1710        match self.bits {
1711            false => CH29_A::DISABLED,
1712            true => CH29_A::ENABLED,
1713        }
1714    }
1715    #[doc = "Checks if the value of the field is `DISABLED`"]
1716    #[inline(always)]
1717    pub fn is_disabled(&self) -> bool {
1718        *self == CH29_A::DISABLED
1719    }
1720    #[doc = "Checks if the value of the field is `ENABLED`"]
1721    #[inline(always)]
1722    pub fn is_enabled(&self) -> bool {
1723        *self == CH29_A::ENABLED
1724    }
1725}
1726#[doc = "Channel 29 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1727#[derive(Clone, Copy, Debug, PartialEq)]
1728pub enum CH29_AW {
1729    #[doc = "1: Write: disable channel"]
1730    CLEAR = 1,
1731}
1732impl From<CH29_AW> for bool {
1733    #[inline(always)]
1734    fn from(variant: CH29_AW) -> Self {
1735        variant as u8 != 0
1736    }
1737}
1738#[doc = "Field `CH29` writer - Channel 29 enable clear register. Writing '0' has no effect"]
1739pub type CH29_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH29_AW, O>;
1740impl<'a, const O: u8> CH29_W<'a, O> {
1741    #[doc = "Write: disable channel"]
1742    #[inline(always)]
1743    pub fn clear(self) -> &'a mut W {
1744        self.variant(CH29_AW::CLEAR)
1745    }
1746}
1747#[doc = "Field `CH30` reader - Channel 30 enable clear register. Writing '0' has no effect"]
1748pub type CH30_R = crate::BitReader<CH30_A>;
1749#[doc = "Channel 30 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1750#[derive(Clone, Copy, Debug, PartialEq)]
1751pub enum CH30_A {
1752    #[doc = "0: Read: channel disabled"]
1753    DISABLED = 0,
1754    #[doc = "1: Read: channel enabled"]
1755    ENABLED = 1,
1756}
1757impl From<CH30_A> for bool {
1758    #[inline(always)]
1759    fn from(variant: CH30_A) -> Self {
1760        variant as u8 != 0
1761    }
1762}
1763impl CH30_R {
1764    #[doc = "Get enumerated values variant"]
1765    #[inline(always)]
1766    pub fn variant(&self) -> CH30_A {
1767        match self.bits {
1768            false => CH30_A::DISABLED,
1769            true => CH30_A::ENABLED,
1770        }
1771    }
1772    #[doc = "Checks if the value of the field is `DISABLED`"]
1773    #[inline(always)]
1774    pub fn is_disabled(&self) -> bool {
1775        *self == CH30_A::DISABLED
1776    }
1777    #[doc = "Checks if the value of the field is `ENABLED`"]
1778    #[inline(always)]
1779    pub fn is_enabled(&self) -> bool {
1780        *self == CH30_A::ENABLED
1781    }
1782}
1783#[doc = "Channel 30 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1784#[derive(Clone, Copy, Debug, PartialEq)]
1785pub enum CH30_AW {
1786    #[doc = "1: Write: disable channel"]
1787    CLEAR = 1,
1788}
1789impl From<CH30_AW> for bool {
1790    #[inline(always)]
1791    fn from(variant: CH30_AW) -> Self {
1792        variant as u8 != 0
1793    }
1794}
1795#[doc = "Field `CH30` writer - Channel 30 enable clear register. Writing '0' has no effect"]
1796pub type CH30_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH30_AW, O>;
1797impl<'a, const O: u8> CH30_W<'a, O> {
1798    #[doc = "Write: disable channel"]
1799    #[inline(always)]
1800    pub fn clear(self) -> &'a mut W {
1801        self.variant(CH30_AW::CLEAR)
1802    }
1803}
1804#[doc = "Field `CH31` reader - Channel 31 enable clear register. Writing '0' has no effect"]
1805pub type CH31_R = crate::BitReader<CH31_A>;
1806#[doc = "Channel 31 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1807#[derive(Clone, Copy, Debug, PartialEq)]
1808pub enum CH31_A {
1809    #[doc = "0: Read: channel disabled"]
1810    DISABLED = 0,
1811    #[doc = "1: Read: channel enabled"]
1812    ENABLED = 1,
1813}
1814impl From<CH31_A> for bool {
1815    #[inline(always)]
1816    fn from(variant: CH31_A) -> Self {
1817        variant as u8 != 0
1818    }
1819}
1820impl CH31_R {
1821    #[doc = "Get enumerated values variant"]
1822    #[inline(always)]
1823    pub fn variant(&self) -> CH31_A {
1824        match self.bits {
1825            false => CH31_A::DISABLED,
1826            true => CH31_A::ENABLED,
1827        }
1828    }
1829    #[doc = "Checks if the value of the field is `DISABLED`"]
1830    #[inline(always)]
1831    pub fn is_disabled(&self) -> bool {
1832        *self == CH31_A::DISABLED
1833    }
1834    #[doc = "Checks if the value of the field is `ENABLED`"]
1835    #[inline(always)]
1836    pub fn is_enabled(&self) -> bool {
1837        *self == CH31_A::ENABLED
1838    }
1839}
1840#[doc = "Channel 31 enable clear register. Writing '0' has no effect\n\nValue on reset: 0"]
1841#[derive(Clone, Copy, Debug, PartialEq)]
1842pub enum CH31_AW {
1843    #[doc = "1: Write: disable channel"]
1844    CLEAR = 1,
1845}
1846impl From<CH31_AW> for bool {
1847    #[inline(always)]
1848    fn from(variant: CH31_AW) -> Self {
1849        variant as u8 != 0
1850    }
1851}
1852#[doc = "Field `CH31` writer - Channel 31 enable clear register. Writing '0' has no effect"]
1853pub type CH31_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, CHENCLR_SPEC, CH31_AW, O>;
1854impl<'a, const O: u8> CH31_W<'a, O> {
1855    #[doc = "Write: disable channel"]
1856    #[inline(always)]
1857    pub fn clear(self) -> &'a mut W {
1858        self.variant(CH31_AW::CLEAR)
1859    }
1860}
1861impl R {
1862    #[doc = "Bit 0 - Channel 0 enable clear register. Writing '0' has no effect"]
1863    #[inline(always)]
1864    pub fn ch0(&self) -> CH0_R {
1865        CH0_R::new((self.bits & 1) != 0)
1866    }
1867    #[doc = "Bit 1 - Channel 1 enable clear register. Writing '0' has no effect"]
1868    #[inline(always)]
1869    pub fn ch1(&self) -> CH1_R {
1870        CH1_R::new(((self.bits >> 1) & 1) != 0)
1871    }
1872    #[doc = "Bit 2 - Channel 2 enable clear register. Writing '0' has no effect"]
1873    #[inline(always)]
1874    pub fn ch2(&self) -> CH2_R {
1875        CH2_R::new(((self.bits >> 2) & 1) != 0)
1876    }
1877    #[doc = "Bit 3 - Channel 3 enable clear register. Writing '0' has no effect"]
1878    #[inline(always)]
1879    pub fn ch3(&self) -> CH3_R {
1880        CH3_R::new(((self.bits >> 3) & 1) != 0)
1881    }
1882    #[doc = "Bit 4 - Channel 4 enable clear register. Writing '0' has no effect"]
1883    #[inline(always)]
1884    pub fn ch4(&self) -> CH4_R {
1885        CH4_R::new(((self.bits >> 4) & 1) != 0)
1886    }
1887    #[doc = "Bit 5 - Channel 5 enable clear register. Writing '0' has no effect"]
1888    #[inline(always)]
1889    pub fn ch5(&self) -> CH5_R {
1890        CH5_R::new(((self.bits >> 5) & 1) != 0)
1891    }
1892    #[doc = "Bit 6 - Channel 6 enable clear register. Writing '0' has no effect"]
1893    #[inline(always)]
1894    pub fn ch6(&self) -> CH6_R {
1895        CH6_R::new(((self.bits >> 6) & 1) != 0)
1896    }
1897    #[doc = "Bit 7 - Channel 7 enable clear register. Writing '0' has no effect"]
1898    #[inline(always)]
1899    pub fn ch7(&self) -> CH7_R {
1900        CH7_R::new(((self.bits >> 7) & 1) != 0)
1901    }
1902    #[doc = "Bit 8 - Channel 8 enable clear register. Writing '0' has no effect"]
1903    #[inline(always)]
1904    pub fn ch8(&self) -> CH8_R {
1905        CH8_R::new(((self.bits >> 8) & 1) != 0)
1906    }
1907    #[doc = "Bit 9 - Channel 9 enable clear register. Writing '0' has no effect"]
1908    #[inline(always)]
1909    pub fn ch9(&self) -> CH9_R {
1910        CH9_R::new(((self.bits >> 9) & 1) != 0)
1911    }
1912    #[doc = "Bit 10 - Channel 10 enable clear register. Writing '0' has no effect"]
1913    #[inline(always)]
1914    pub fn ch10(&self) -> CH10_R {
1915        CH10_R::new(((self.bits >> 10) & 1) != 0)
1916    }
1917    #[doc = "Bit 11 - Channel 11 enable clear register. Writing '0' has no effect"]
1918    #[inline(always)]
1919    pub fn ch11(&self) -> CH11_R {
1920        CH11_R::new(((self.bits >> 11) & 1) != 0)
1921    }
1922    #[doc = "Bit 12 - Channel 12 enable clear register. Writing '0' has no effect"]
1923    #[inline(always)]
1924    pub fn ch12(&self) -> CH12_R {
1925        CH12_R::new(((self.bits >> 12) & 1) != 0)
1926    }
1927    #[doc = "Bit 13 - Channel 13 enable clear register. Writing '0' has no effect"]
1928    #[inline(always)]
1929    pub fn ch13(&self) -> CH13_R {
1930        CH13_R::new(((self.bits >> 13) & 1) != 0)
1931    }
1932    #[doc = "Bit 14 - Channel 14 enable clear register. Writing '0' has no effect"]
1933    #[inline(always)]
1934    pub fn ch14(&self) -> CH14_R {
1935        CH14_R::new(((self.bits >> 14) & 1) != 0)
1936    }
1937    #[doc = "Bit 15 - Channel 15 enable clear register. Writing '0' has no effect"]
1938    #[inline(always)]
1939    pub fn ch15(&self) -> CH15_R {
1940        CH15_R::new(((self.bits >> 15) & 1) != 0)
1941    }
1942    #[doc = "Bit 16 - Channel 16 enable clear register. Writing '0' has no effect"]
1943    #[inline(always)]
1944    pub fn ch16(&self) -> CH16_R {
1945        CH16_R::new(((self.bits >> 16) & 1) != 0)
1946    }
1947    #[doc = "Bit 17 - Channel 17 enable clear register. Writing '0' has no effect"]
1948    #[inline(always)]
1949    pub fn ch17(&self) -> CH17_R {
1950        CH17_R::new(((self.bits >> 17) & 1) != 0)
1951    }
1952    #[doc = "Bit 18 - Channel 18 enable clear register. Writing '0' has no effect"]
1953    #[inline(always)]
1954    pub fn ch18(&self) -> CH18_R {
1955        CH18_R::new(((self.bits >> 18) & 1) != 0)
1956    }
1957    #[doc = "Bit 19 - Channel 19 enable clear register. Writing '0' has no effect"]
1958    #[inline(always)]
1959    pub fn ch19(&self) -> CH19_R {
1960        CH19_R::new(((self.bits >> 19) & 1) != 0)
1961    }
1962    #[doc = "Bit 20 - Channel 20 enable clear register. Writing '0' has no effect"]
1963    #[inline(always)]
1964    pub fn ch20(&self) -> CH20_R {
1965        CH20_R::new(((self.bits >> 20) & 1) != 0)
1966    }
1967    #[doc = "Bit 21 - Channel 21 enable clear register. Writing '0' has no effect"]
1968    #[inline(always)]
1969    pub fn ch21(&self) -> CH21_R {
1970        CH21_R::new(((self.bits >> 21) & 1) != 0)
1971    }
1972    #[doc = "Bit 22 - Channel 22 enable clear register. Writing '0' has no effect"]
1973    #[inline(always)]
1974    pub fn ch22(&self) -> CH22_R {
1975        CH22_R::new(((self.bits >> 22) & 1) != 0)
1976    }
1977    #[doc = "Bit 23 - Channel 23 enable clear register. Writing '0' has no effect"]
1978    #[inline(always)]
1979    pub fn ch23(&self) -> CH23_R {
1980        CH23_R::new(((self.bits >> 23) & 1) != 0)
1981    }
1982    #[doc = "Bit 24 - Channel 24 enable clear register. Writing '0' has no effect"]
1983    #[inline(always)]
1984    pub fn ch24(&self) -> CH24_R {
1985        CH24_R::new(((self.bits >> 24) & 1) != 0)
1986    }
1987    #[doc = "Bit 25 - Channel 25 enable clear register. Writing '0' has no effect"]
1988    #[inline(always)]
1989    pub fn ch25(&self) -> CH25_R {
1990        CH25_R::new(((self.bits >> 25) & 1) != 0)
1991    }
1992    #[doc = "Bit 26 - Channel 26 enable clear register. Writing '0' has no effect"]
1993    #[inline(always)]
1994    pub fn ch26(&self) -> CH26_R {
1995        CH26_R::new(((self.bits >> 26) & 1) != 0)
1996    }
1997    #[doc = "Bit 27 - Channel 27 enable clear register. Writing '0' has no effect"]
1998    #[inline(always)]
1999    pub fn ch27(&self) -> CH27_R {
2000        CH27_R::new(((self.bits >> 27) & 1) != 0)
2001    }
2002    #[doc = "Bit 28 - Channel 28 enable clear register. Writing '0' has no effect"]
2003    #[inline(always)]
2004    pub fn ch28(&self) -> CH28_R {
2005        CH28_R::new(((self.bits >> 28) & 1) != 0)
2006    }
2007    #[doc = "Bit 29 - Channel 29 enable clear register. Writing '0' has no effect"]
2008    #[inline(always)]
2009    pub fn ch29(&self) -> CH29_R {
2010        CH29_R::new(((self.bits >> 29) & 1) != 0)
2011    }
2012    #[doc = "Bit 30 - Channel 30 enable clear register. Writing '0' has no effect"]
2013    #[inline(always)]
2014    pub fn ch30(&self) -> CH30_R {
2015        CH30_R::new(((self.bits >> 30) & 1) != 0)
2016    }
2017    #[doc = "Bit 31 - Channel 31 enable clear register. Writing '0' has no effect"]
2018    #[inline(always)]
2019    pub fn ch31(&self) -> CH31_R {
2020        CH31_R::new(((self.bits >> 31) & 1) != 0)
2021    }
2022}
2023impl W {
2024    #[doc = "Bit 0 - Channel 0 enable clear register. Writing '0' has no effect"]
2025    #[inline(always)]
2026    pub fn ch0(&mut self) -> CH0_W<0> {
2027        CH0_W::new(self)
2028    }
2029    #[doc = "Bit 1 - Channel 1 enable clear register. Writing '0' has no effect"]
2030    #[inline(always)]
2031    pub fn ch1(&mut self) -> CH1_W<1> {
2032        CH1_W::new(self)
2033    }
2034    #[doc = "Bit 2 - Channel 2 enable clear register. Writing '0' has no effect"]
2035    #[inline(always)]
2036    pub fn ch2(&mut self) -> CH2_W<2> {
2037        CH2_W::new(self)
2038    }
2039    #[doc = "Bit 3 - Channel 3 enable clear register. Writing '0' has no effect"]
2040    #[inline(always)]
2041    pub fn ch3(&mut self) -> CH3_W<3> {
2042        CH3_W::new(self)
2043    }
2044    #[doc = "Bit 4 - Channel 4 enable clear register. Writing '0' has no effect"]
2045    #[inline(always)]
2046    pub fn ch4(&mut self) -> CH4_W<4> {
2047        CH4_W::new(self)
2048    }
2049    #[doc = "Bit 5 - Channel 5 enable clear register. Writing '0' has no effect"]
2050    #[inline(always)]
2051    pub fn ch5(&mut self) -> CH5_W<5> {
2052        CH5_W::new(self)
2053    }
2054    #[doc = "Bit 6 - Channel 6 enable clear register. Writing '0' has no effect"]
2055    #[inline(always)]
2056    pub fn ch6(&mut self) -> CH6_W<6> {
2057        CH6_W::new(self)
2058    }
2059    #[doc = "Bit 7 - Channel 7 enable clear register. Writing '0' has no effect"]
2060    #[inline(always)]
2061    pub fn ch7(&mut self) -> CH7_W<7> {
2062        CH7_W::new(self)
2063    }
2064    #[doc = "Bit 8 - Channel 8 enable clear register. Writing '0' has no effect"]
2065    #[inline(always)]
2066    pub fn ch8(&mut self) -> CH8_W<8> {
2067        CH8_W::new(self)
2068    }
2069    #[doc = "Bit 9 - Channel 9 enable clear register. Writing '0' has no effect"]
2070    #[inline(always)]
2071    pub fn ch9(&mut self) -> CH9_W<9> {
2072        CH9_W::new(self)
2073    }
2074    #[doc = "Bit 10 - Channel 10 enable clear register. Writing '0' has no effect"]
2075    #[inline(always)]
2076    pub fn ch10(&mut self) -> CH10_W<10> {
2077        CH10_W::new(self)
2078    }
2079    #[doc = "Bit 11 - Channel 11 enable clear register. Writing '0' has no effect"]
2080    #[inline(always)]
2081    pub fn ch11(&mut self) -> CH11_W<11> {
2082        CH11_W::new(self)
2083    }
2084    #[doc = "Bit 12 - Channel 12 enable clear register. Writing '0' has no effect"]
2085    #[inline(always)]
2086    pub fn ch12(&mut self) -> CH12_W<12> {
2087        CH12_W::new(self)
2088    }
2089    #[doc = "Bit 13 - Channel 13 enable clear register. Writing '0' has no effect"]
2090    #[inline(always)]
2091    pub fn ch13(&mut self) -> CH13_W<13> {
2092        CH13_W::new(self)
2093    }
2094    #[doc = "Bit 14 - Channel 14 enable clear register. Writing '0' has no effect"]
2095    #[inline(always)]
2096    pub fn ch14(&mut self) -> CH14_W<14> {
2097        CH14_W::new(self)
2098    }
2099    #[doc = "Bit 15 - Channel 15 enable clear register. Writing '0' has no effect"]
2100    #[inline(always)]
2101    pub fn ch15(&mut self) -> CH15_W<15> {
2102        CH15_W::new(self)
2103    }
2104    #[doc = "Bit 16 - Channel 16 enable clear register. Writing '0' has no effect"]
2105    #[inline(always)]
2106    pub fn ch16(&mut self) -> CH16_W<16> {
2107        CH16_W::new(self)
2108    }
2109    #[doc = "Bit 17 - Channel 17 enable clear register. Writing '0' has no effect"]
2110    #[inline(always)]
2111    pub fn ch17(&mut self) -> CH17_W<17> {
2112        CH17_W::new(self)
2113    }
2114    #[doc = "Bit 18 - Channel 18 enable clear register. Writing '0' has no effect"]
2115    #[inline(always)]
2116    pub fn ch18(&mut self) -> CH18_W<18> {
2117        CH18_W::new(self)
2118    }
2119    #[doc = "Bit 19 - Channel 19 enable clear register. Writing '0' has no effect"]
2120    #[inline(always)]
2121    pub fn ch19(&mut self) -> CH19_W<19> {
2122        CH19_W::new(self)
2123    }
2124    #[doc = "Bit 20 - Channel 20 enable clear register. Writing '0' has no effect"]
2125    #[inline(always)]
2126    pub fn ch20(&mut self) -> CH20_W<20> {
2127        CH20_W::new(self)
2128    }
2129    #[doc = "Bit 21 - Channel 21 enable clear register. Writing '0' has no effect"]
2130    #[inline(always)]
2131    pub fn ch21(&mut self) -> CH21_W<21> {
2132        CH21_W::new(self)
2133    }
2134    #[doc = "Bit 22 - Channel 22 enable clear register. Writing '0' has no effect"]
2135    #[inline(always)]
2136    pub fn ch22(&mut self) -> CH22_W<22> {
2137        CH22_W::new(self)
2138    }
2139    #[doc = "Bit 23 - Channel 23 enable clear register. Writing '0' has no effect"]
2140    #[inline(always)]
2141    pub fn ch23(&mut self) -> CH23_W<23> {
2142        CH23_W::new(self)
2143    }
2144    #[doc = "Bit 24 - Channel 24 enable clear register. Writing '0' has no effect"]
2145    #[inline(always)]
2146    pub fn ch24(&mut self) -> CH24_W<24> {
2147        CH24_W::new(self)
2148    }
2149    #[doc = "Bit 25 - Channel 25 enable clear register. Writing '0' has no effect"]
2150    #[inline(always)]
2151    pub fn ch25(&mut self) -> CH25_W<25> {
2152        CH25_W::new(self)
2153    }
2154    #[doc = "Bit 26 - Channel 26 enable clear register. Writing '0' has no effect"]
2155    #[inline(always)]
2156    pub fn ch26(&mut self) -> CH26_W<26> {
2157        CH26_W::new(self)
2158    }
2159    #[doc = "Bit 27 - Channel 27 enable clear register. Writing '0' has no effect"]
2160    #[inline(always)]
2161    pub fn ch27(&mut self) -> CH27_W<27> {
2162        CH27_W::new(self)
2163    }
2164    #[doc = "Bit 28 - Channel 28 enable clear register. Writing '0' has no effect"]
2165    #[inline(always)]
2166    pub fn ch28(&mut self) -> CH28_W<28> {
2167        CH28_W::new(self)
2168    }
2169    #[doc = "Bit 29 - Channel 29 enable clear register. Writing '0' has no effect"]
2170    #[inline(always)]
2171    pub fn ch29(&mut self) -> CH29_W<29> {
2172        CH29_W::new(self)
2173    }
2174    #[doc = "Bit 30 - Channel 30 enable clear register. Writing '0' has no effect"]
2175    #[inline(always)]
2176    pub fn ch30(&mut self) -> CH30_W<30> {
2177        CH30_W::new(self)
2178    }
2179    #[doc = "Bit 31 - Channel 31 enable clear register. Writing '0' has no effect"]
2180    #[inline(always)]
2181    pub fn ch31(&mut self) -> CH31_W<31> {
2182        CH31_W::new(self)
2183    }
2184    #[doc = "Writes raw bits to the register."]
2185    #[inline(always)]
2186    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
2187        self.0.bits(bits);
2188        self
2189    }
2190}
2191#[doc = "Channel enable clear register\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 [chenclr](index.html) module"]
2192pub struct CHENCLR_SPEC;
2193impl crate::RegisterSpec for CHENCLR_SPEC {
2194    type Ux = u32;
2195}
2196#[doc = "`read()` method returns [chenclr::R](R) reader structure"]
2197impl crate::Readable for CHENCLR_SPEC {
2198    type Reader = R;
2199}
2200#[doc = "`write(|w| ..)` method takes [chenclr::W](W) writer structure"]
2201impl crate::Writable for CHENCLR_SPEC {
2202    type Writer = W;
2203}
2204#[doc = "`reset()` method sets CHENCLR to value 0"]
2205impl crate::Resettable for CHENCLR_SPEC {
2206    #[inline(always)]
2207    fn reset_value() -> Self::Ux {
2208        0
2209    }
2210}
nrf52840_pac/ppi/chenclr.rs

nrf52840_pac/ppi/
chenclr.rs
