mimxrt595s/dma0/
active0.rs

1#[doc = "Register `ACTIVE0` reader"]
2pub struct R(crate::R<ACTIVE0_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<ACTIVE0_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<ACTIVE0_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<ACTIVE0_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Field `ACTIVE0` reader - Active flag for DMA channel."]
17pub type ACTIVE0_R = crate::BitReader<ACTIVE0_A>;
18#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
19#[derive(Clone, Copy, Debug, PartialEq, Eq)]
20pub enum ACTIVE0_A {
21    #[doc = "0: DMA channel is not active."]
22    NOT_ACTIVE = 0,
23    #[doc = "1: DMA channel is active."]
24    ACTIVE = 1,
25}
26impl From<ACTIVE0_A> for bool {
27    #[inline(always)]
28    fn from(variant: ACTIVE0_A) -> Self {
29        variant as u8 != 0
30    }
31}
32impl ACTIVE0_R {
33    #[doc = "Get enumerated values variant"]
34    #[inline(always)]
35    pub fn variant(&self) -> ACTIVE0_A {
36        match self.bits {
37            false => ACTIVE0_A::NOT_ACTIVE,
38            true => ACTIVE0_A::ACTIVE,
39        }
40    }
41    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
42    #[inline(always)]
43    pub fn is_not_active(&self) -> bool {
44        *self == ACTIVE0_A::NOT_ACTIVE
45    }
46    #[doc = "Checks if the value of the field is `ACTIVE`"]
47    #[inline(always)]
48    pub fn is_active(&self) -> bool {
49        *self == ACTIVE0_A::ACTIVE
50    }
51}
52#[doc = "Field `ACTIVE1` reader - Active flag for DMA channel."]
53pub type ACTIVE1_R = crate::BitReader<ACTIVE1_A>;
54#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
55#[derive(Clone, Copy, Debug, PartialEq, Eq)]
56pub enum ACTIVE1_A {
57    #[doc = "0: DMA channel is not active."]
58    NOT_ACTIVE = 0,
59    #[doc = "1: DMA channel is active."]
60    ACTIVE = 1,
61}
62impl From<ACTIVE1_A> for bool {
63    #[inline(always)]
64    fn from(variant: ACTIVE1_A) -> Self {
65        variant as u8 != 0
66    }
67}
68impl ACTIVE1_R {
69    #[doc = "Get enumerated values variant"]
70    #[inline(always)]
71    pub fn variant(&self) -> ACTIVE1_A {
72        match self.bits {
73            false => ACTIVE1_A::NOT_ACTIVE,
74            true => ACTIVE1_A::ACTIVE,
75        }
76    }
77    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
78    #[inline(always)]
79    pub fn is_not_active(&self) -> bool {
80        *self == ACTIVE1_A::NOT_ACTIVE
81    }
82    #[doc = "Checks if the value of the field is `ACTIVE`"]
83    #[inline(always)]
84    pub fn is_active(&self) -> bool {
85        *self == ACTIVE1_A::ACTIVE
86    }
87}
88#[doc = "Field `ACTIVE2` reader - Active flag for DMA channel."]
89pub type ACTIVE2_R = crate::BitReader<ACTIVE2_A>;
90#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
91#[derive(Clone, Copy, Debug, PartialEq, Eq)]
92pub enum ACTIVE2_A {
93    #[doc = "0: DMA channel is not active."]
94    NOT_ACTIVE = 0,
95    #[doc = "1: DMA channel is active."]
96    ACTIVE = 1,
97}
98impl From<ACTIVE2_A> for bool {
99    #[inline(always)]
100    fn from(variant: ACTIVE2_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl ACTIVE2_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> ACTIVE2_A {
108        match self.bits {
109            false => ACTIVE2_A::NOT_ACTIVE,
110            true => ACTIVE2_A::ACTIVE,
111        }
112    }
113    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
114    #[inline(always)]
115    pub fn is_not_active(&self) -> bool {
116        *self == ACTIVE2_A::NOT_ACTIVE
117    }
118    #[doc = "Checks if the value of the field is `ACTIVE`"]
119    #[inline(always)]
120    pub fn is_active(&self) -> bool {
121        *self == ACTIVE2_A::ACTIVE
122    }
123}
124#[doc = "Field `ACTIVE3` reader - Active flag for DMA channel."]
125pub type ACTIVE3_R = crate::BitReader<ACTIVE3_A>;
126#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
127#[derive(Clone, Copy, Debug, PartialEq, Eq)]
128pub enum ACTIVE3_A {
129    #[doc = "0: DMA channel is not active."]
130    NOT_ACTIVE = 0,
131    #[doc = "1: DMA channel is active."]
132    ACTIVE = 1,
133}
134impl From<ACTIVE3_A> for bool {
135    #[inline(always)]
136    fn from(variant: ACTIVE3_A) -> Self {
137        variant as u8 != 0
138    }
139}
140impl ACTIVE3_R {
141    #[doc = "Get enumerated values variant"]
142    #[inline(always)]
143    pub fn variant(&self) -> ACTIVE3_A {
144        match self.bits {
145            false => ACTIVE3_A::NOT_ACTIVE,
146            true => ACTIVE3_A::ACTIVE,
147        }
148    }
149    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
150    #[inline(always)]
151    pub fn is_not_active(&self) -> bool {
152        *self == ACTIVE3_A::NOT_ACTIVE
153    }
154    #[doc = "Checks if the value of the field is `ACTIVE`"]
155    #[inline(always)]
156    pub fn is_active(&self) -> bool {
157        *self == ACTIVE3_A::ACTIVE
158    }
159}
160#[doc = "Field `ACTIVE4` reader - Active flag for DMA channel."]
161pub type ACTIVE4_R = crate::BitReader<ACTIVE4_A>;
162#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
163#[derive(Clone, Copy, Debug, PartialEq, Eq)]
164pub enum ACTIVE4_A {
165    #[doc = "0: DMA channel is not active."]
166    NOT_ACTIVE = 0,
167    #[doc = "1: DMA channel is active."]
168    ACTIVE = 1,
169}
170impl From<ACTIVE4_A> for bool {
171    #[inline(always)]
172    fn from(variant: ACTIVE4_A) -> Self {
173        variant as u8 != 0
174    }
175}
176impl ACTIVE4_R {
177    #[doc = "Get enumerated values variant"]
178    #[inline(always)]
179    pub fn variant(&self) -> ACTIVE4_A {
180        match self.bits {
181            false => ACTIVE4_A::NOT_ACTIVE,
182            true => ACTIVE4_A::ACTIVE,
183        }
184    }
185    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
186    #[inline(always)]
187    pub fn is_not_active(&self) -> bool {
188        *self == ACTIVE4_A::NOT_ACTIVE
189    }
190    #[doc = "Checks if the value of the field is `ACTIVE`"]
191    #[inline(always)]
192    pub fn is_active(&self) -> bool {
193        *self == ACTIVE4_A::ACTIVE
194    }
195}
196#[doc = "Field `ACTIVE5` reader - Active flag for DMA channel."]
197pub type ACTIVE5_R = crate::BitReader<ACTIVE5_A>;
198#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
199#[derive(Clone, Copy, Debug, PartialEq, Eq)]
200pub enum ACTIVE5_A {
201    #[doc = "0: DMA channel is not active."]
202    NOT_ACTIVE = 0,
203    #[doc = "1: DMA channel is active."]
204    ACTIVE = 1,
205}
206impl From<ACTIVE5_A> for bool {
207    #[inline(always)]
208    fn from(variant: ACTIVE5_A) -> Self {
209        variant as u8 != 0
210    }
211}
212impl ACTIVE5_R {
213    #[doc = "Get enumerated values variant"]
214    #[inline(always)]
215    pub fn variant(&self) -> ACTIVE5_A {
216        match self.bits {
217            false => ACTIVE5_A::NOT_ACTIVE,
218            true => ACTIVE5_A::ACTIVE,
219        }
220    }
221    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
222    #[inline(always)]
223    pub fn is_not_active(&self) -> bool {
224        *self == ACTIVE5_A::NOT_ACTIVE
225    }
226    #[doc = "Checks if the value of the field is `ACTIVE`"]
227    #[inline(always)]
228    pub fn is_active(&self) -> bool {
229        *self == ACTIVE5_A::ACTIVE
230    }
231}
232#[doc = "Field `ACTIVE6` reader - Active flag for DMA channel."]
233pub type ACTIVE6_R = crate::BitReader<ACTIVE6_A>;
234#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
235#[derive(Clone, Copy, Debug, PartialEq, Eq)]
236pub enum ACTIVE6_A {
237    #[doc = "0: DMA channel is not active."]
238    NOT_ACTIVE = 0,
239    #[doc = "1: DMA channel is active."]
240    ACTIVE = 1,
241}
242impl From<ACTIVE6_A> for bool {
243    #[inline(always)]
244    fn from(variant: ACTIVE6_A) -> Self {
245        variant as u8 != 0
246    }
247}
248impl ACTIVE6_R {
249    #[doc = "Get enumerated values variant"]
250    #[inline(always)]
251    pub fn variant(&self) -> ACTIVE6_A {
252        match self.bits {
253            false => ACTIVE6_A::NOT_ACTIVE,
254            true => ACTIVE6_A::ACTIVE,
255        }
256    }
257    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
258    #[inline(always)]
259    pub fn is_not_active(&self) -> bool {
260        *self == ACTIVE6_A::NOT_ACTIVE
261    }
262    #[doc = "Checks if the value of the field is `ACTIVE`"]
263    #[inline(always)]
264    pub fn is_active(&self) -> bool {
265        *self == ACTIVE6_A::ACTIVE
266    }
267}
268#[doc = "Field `ACTIVE7` reader - Active flag for DMA channel."]
269pub type ACTIVE7_R = crate::BitReader<ACTIVE7_A>;
270#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
271#[derive(Clone, Copy, Debug, PartialEq, Eq)]
272pub enum ACTIVE7_A {
273    #[doc = "0: DMA channel is not active."]
274    NOT_ACTIVE = 0,
275    #[doc = "1: DMA channel is active."]
276    ACTIVE = 1,
277}
278impl From<ACTIVE7_A> for bool {
279    #[inline(always)]
280    fn from(variant: ACTIVE7_A) -> Self {
281        variant as u8 != 0
282    }
283}
284impl ACTIVE7_R {
285    #[doc = "Get enumerated values variant"]
286    #[inline(always)]
287    pub fn variant(&self) -> ACTIVE7_A {
288        match self.bits {
289            false => ACTIVE7_A::NOT_ACTIVE,
290            true => ACTIVE7_A::ACTIVE,
291        }
292    }
293    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
294    #[inline(always)]
295    pub fn is_not_active(&self) -> bool {
296        *self == ACTIVE7_A::NOT_ACTIVE
297    }
298    #[doc = "Checks if the value of the field is `ACTIVE`"]
299    #[inline(always)]
300    pub fn is_active(&self) -> bool {
301        *self == ACTIVE7_A::ACTIVE
302    }
303}
304#[doc = "Field `ACTIVE8` reader - Active flag for DMA channel."]
305pub type ACTIVE8_R = crate::BitReader<ACTIVE8_A>;
306#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
307#[derive(Clone, Copy, Debug, PartialEq, Eq)]
308pub enum ACTIVE8_A {
309    #[doc = "0: DMA channel is not active."]
310    NOT_ACTIVE = 0,
311    #[doc = "1: DMA channel is active."]
312    ACTIVE = 1,
313}
314impl From<ACTIVE8_A> for bool {
315    #[inline(always)]
316    fn from(variant: ACTIVE8_A) -> Self {
317        variant as u8 != 0
318    }
319}
320impl ACTIVE8_R {
321    #[doc = "Get enumerated values variant"]
322    #[inline(always)]
323    pub fn variant(&self) -> ACTIVE8_A {
324        match self.bits {
325            false => ACTIVE8_A::NOT_ACTIVE,
326            true => ACTIVE8_A::ACTIVE,
327        }
328    }
329    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
330    #[inline(always)]
331    pub fn is_not_active(&self) -> bool {
332        *self == ACTIVE8_A::NOT_ACTIVE
333    }
334    #[doc = "Checks if the value of the field is `ACTIVE`"]
335    #[inline(always)]
336    pub fn is_active(&self) -> bool {
337        *self == ACTIVE8_A::ACTIVE
338    }
339}
340#[doc = "Field `ACTIVE9` reader - Active flag for DMA channel."]
341pub type ACTIVE9_R = crate::BitReader<ACTIVE9_A>;
342#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
343#[derive(Clone, Copy, Debug, PartialEq, Eq)]
344pub enum ACTIVE9_A {
345    #[doc = "0: DMA channel is not active."]
346    NOT_ACTIVE = 0,
347    #[doc = "1: DMA channel is active."]
348    ACTIVE = 1,
349}
350impl From<ACTIVE9_A> for bool {
351    #[inline(always)]
352    fn from(variant: ACTIVE9_A) -> Self {
353        variant as u8 != 0
354    }
355}
356impl ACTIVE9_R {
357    #[doc = "Get enumerated values variant"]
358    #[inline(always)]
359    pub fn variant(&self) -> ACTIVE9_A {
360        match self.bits {
361            false => ACTIVE9_A::NOT_ACTIVE,
362            true => ACTIVE9_A::ACTIVE,
363        }
364    }
365    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
366    #[inline(always)]
367    pub fn is_not_active(&self) -> bool {
368        *self == ACTIVE9_A::NOT_ACTIVE
369    }
370    #[doc = "Checks if the value of the field is `ACTIVE`"]
371    #[inline(always)]
372    pub fn is_active(&self) -> bool {
373        *self == ACTIVE9_A::ACTIVE
374    }
375}
376#[doc = "Field `ACTIVE10` reader - Active flag for DMA channel."]
377pub type ACTIVE10_R = crate::BitReader<ACTIVE10_A>;
378#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
379#[derive(Clone, Copy, Debug, PartialEq, Eq)]
380pub enum ACTIVE10_A {
381    #[doc = "0: DMA channel is not active."]
382    NOT_ACTIVE = 0,
383    #[doc = "1: DMA channel is active."]
384    ACTIVE = 1,
385}
386impl From<ACTIVE10_A> for bool {
387    #[inline(always)]
388    fn from(variant: ACTIVE10_A) -> Self {
389        variant as u8 != 0
390    }
391}
392impl ACTIVE10_R {
393    #[doc = "Get enumerated values variant"]
394    #[inline(always)]
395    pub fn variant(&self) -> ACTIVE10_A {
396        match self.bits {
397            false => ACTIVE10_A::NOT_ACTIVE,
398            true => ACTIVE10_A::ACTIVE,
399        }
400    }
401    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
402    #[inline(always)]
403    pub fn is_not_active(&self) -> bool {
404        *self == ACTIVE10_A::NOT_ACTIVE
405    }
406    #[doc = "Checks if the value of the field is `ACTIVE`"]
407    #[inline(always)]
408    pub fn is_active(&self) -> bool {
409        *self == ACTIVE10_A::ACTIVE
410    }
411}
412#[doc = "Field `ACTIVE11` reader - Active flag for DMA channel."]
413pub type ACTIVE11_R = crate::BitReader<ACTIVE11_A>;
414#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
415#[derive(Clone, Copy, Debug, PartialEq, Eq)]
416pub enum ACTIVE11_A {
417    #[doc = "0: DMA channel is not active."]
418    NOT_ACTIVE = 0,
419    #[doc = "1: DMA channel is active."]
420    ACTIVE = 1,
421}
422impl From<ACTIVE11_A> for bool {
423    #[inline(always)]
424    fn from(variant: ACTIVE11_A) -> Self {
425        variant as u8 != 0
426    }
427}
428impl ACTIVE11_R {
429    #[doc = "Get enumerated values variant"]
430    #[inline(always)]
431    pub fn variant(&self) -> ACTIVE11_A {
432        match self.bits {
433            false => ACTIVE11_A::NOT_ACTIVE,
434            true => ACTIVE11_A::ACTIVE,
435        }
436    }
437    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
438    #[inline(always)]
439    pub fn is_not_active(&self) -> bool {
440        *self == ACTIVE11_A::NOT_ACTIVE
441    }
442    #[doc = "Checks if the value of the field is `ACTIVE`"]
443    #[inline(always)]
444    pub fn is_active(&self) -> bool {
445        *self == ACTIVE11_A::ACTIVE
446    }
447}
448#[doc = "Field `ACTIVE12` reader - Active flag for DMA channel."]
449pub type ACTIVE12_R = crate::BitReader<ACTIVE12_A>;
450#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
451#[derive(Clone, Copy, Debug, PartialEq, Eq)]
452pub enum ACTIVE12_A {
453    #[doc = "0: DMA channel is not active."]
454    NOT_ACTIVE = 0,
455    #[doc = "1: DMA channel is active."]
456    ACTIVE = 1,
457}
458impl From<ACTIVE12_A> for bool {
459    #[inline(always)]
460    fn from(variant: ACTIVE12_A) -> Self {
461        variant as u8 != 0
462    }
463}
464impl ACTIVE12_R {
465    #[doc = "Get enumerated values variant"]
466    #[inline(always)]
467    pub fn variant(&self) -> ACTIVE12_A {
468        match self.bits {
469            false => ACTIVE12_A::NOT_ACTIVE,
470            true => ACTIVE12_A::ACTIVE,
471        }
472    }
473    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
474    #[inline(always)]
475    pub fn is_not_active(&self) -> bool {
476        *self == ACTIVE12_A::NOT_ACTIVE
477    }
478    #[doc = "Checks if the value of the field is `ACTIVE`"]
479    #[inline(always)]
480    pub fn is_active(&self) -> bool {
481        *self == ACTIVE12_A::ACTIVE
482    }
483}
484#[doc = "Field `ACTIVE13` reader - Active flag for DMA channel."]
485pub type ACTIVE13_R = crate::BitReader<ACTIVE13_A>;
486#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
487#[derive(Clone, Copy, Debug, PartialEq, Eq)]
488pub enum ACTIVE13_A {
489    #[doc = "0: DMA channel is not active."]
490    NOT_ACTIVE = 0,
491    #[doc = "1: DMA channel is active."]
492    ACTIVE = 1,
493}
494impl From<ACTIVE13_A> for bool {
495    #[inline(always)]
496    fn from(variant: ACTIVE13_A) -> Self {
497        variant as u8 != 0
498    }
499}
500impl ACTIVE13_R {
501    #[doc = "Get enumerated values variant"]
502    #[inline(always)]
503    pub fn variant(&self) -> ACTIVE13_A {
504        match self.bits {
505            false => ACTIVE13_A::NOT_ACTIVE,
506            true => ACTIVE13_A::ACTIVE,
507        }
508    }
509    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
510    #[inline(always)]
511    pub fn is_not_active(&self) -> bool {
512        *self == ACTIVE13_A::NOT_ACTIVE
513    }
514    #[doc = "Checks if the value of the field is `ACTIVE`"]
515    #[inline(always)]
516    pub fn is_active(&self) -> bool {
517        *self == ACTIVE13_A::ACTIVE
518    }
519}
520#[doc = "Field `ACTIVE14` reader - Active flag for DMA channel."]
521pub type ACTIVE14_R = crate::BitReader<ACTIVE14_A>;
522#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
523#[derive(Clone, Copy, Debug, PartialEq, Eq)]
524pub enum ACTIVE14_A {
525    #[doc = "0: DMA channel is not active."]
526    NOT_ACTIVE = 0,
527    #[doc = "1: DMA channel is active."]
528    ACTIVE = 1,
529}
530impl From<ACTIVE14_A> for bool {
531    #[inline(always)]
532    fn from(variant: ACTIVE14_A) -> Self {
533        variant as u8 != 0
534    }
535}
536impl ACTIVE14_R {
537    #[doc = "Get enumerated values variant"]
538    #[inline(always)]
539    pub fn variant(&self) -> ACTIVE14_A {
540        match self.bits {
541            false => ACTIVE14_A::NOT_ACTIVE,
542            true => ACTIVE14_A::ACTIVE,
543        }
544    }
545    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
546    #[inline(always)]
547    pub fn is_not_active(&self) -> bool {
548        *self == ACTIVE14_A::NOT_ACTIVE
549    }
550    #[doc = "Checks if the value of the field is `ACTIVE`"]
551    #[inline(always)]
552    pub fn is_active(&self) -> bool {
553        *self == ACTIVE14_A::ACTIVE
554    }
555}
556#[doc = "Field `ACTIVE15` reader - Active flag for DMA channel."]
557pub type ACTIVE15_R = crate::BitReader<ACTIVE15_A>;
558#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
559#[derive(Clone, Copy, Debug, PartialEq, Eq)]
560pub enum ACTIVE15_A {
561    #[doc = "0: DMA channel is not active."]
562    NOT_ACTIVE = 0,
563    #[doc = "1: DMA channel is active."]
564    ACTIVE = 1,
565}
566impl From<ACTIVE15_A> for bool {
567    #[inline(always)]
568    fn from(variant: ACTIVE15_A) -> Self {
569        variant as u8 != 0
570    }
571}
572impl ACTIVE15_R {
573    #[doc = "Get enumerated values variant"]
574    #[inline(always)]
575    pub fn variant(&self) -> ACTIVE15_A {
576        match self.bits {
577            false => ACTIVE15_A::NOT_ACTIVE,
578            true => ACTIVE15_A::ACTIVE,
579        }
580    }
581    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
582    #[inline(always)]
583    pub fn is_not_active(&self) -> bool {
584        *self == ACTIVE15_A::NOT_ACTIVE
585    }
586    #[doc = "Checks if the value of the field is `ACTIVE`"]
587    #[inline(always)]
588    pub fn is_active(&self) -> bool {
589        *self == ACTIVE15_A::ACTIVE
590    }
591}
592#[doc = "Field `ACTIVE16` reader - Active flag for DMA channel."]
593pub type ACTIVE16_R = crate::BitReader<ACTIVE16_A>;
594#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
595#[derive(Clone, Copy, Debug, PartialEq, Eq)]
596pub enum ACTIVE16_A {
597    #[doc = "0: DMA channel is not active."]
598    NOT_ACTIVE = 0,
599    #[doc = "1: DMA channel is active."]
600    ACTIVE = 1,
601}
602impl From<ACTIVE16_A> for bool {
603    #[inline(always)]
604    fn from(variant: ACTIVE16_A) -> Self {
605        variant as u8 != 0
606    }
607}
608impl ACTIVE16_R {
609    #[doc = "Get enumerated values variant"]
610    #[inline(always)]
611    pub fn variant(&self) -> ACTIVE16_A {
612        match self.bits {
613            false => ACTIVE16_A::NOT_ACTIVE,
614            true => ACTIVE16_A::ACTIVE,
615        }
616    }
617    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
618    #[inline(always)]
619    pub fn is_not_active(&self) -> bool {
620        *self == ACTIVE16_A::NOT_ACTIVE
621    }
622    #[doc = "Checks if the value of the field is `ACTIVE`"]
623    #[inline(always)]
624    pub fn is_active(&self) -> bool {
625        *self == ACTIVE16_A::ACTIVE
626    }
627}
628#[doc = "Field `ACTIVE17` reader - Active flag for DMA channel."]
629pub type ACTIVE17_R = crate::BitReader<ACTIVE17_A>;
630#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
631#[derive(Clone, Copy, Debug, PartialEq, Eq)]
632pub enum ACTIVE17_A {
633    #[doc = "0: DMA channel is not active."]
634    NOT_ACTIVE = 0,
635    #[doc = "1: DMA channel is active."]
636    ACTIVE = 1,
637}
638impl From<ACTIVE17_A> for bool {
639    #[inline(always)]
640    fn from(variant: ACTIVE17_A) -> Self {
641        variant as u8 != 0
642    }
643}
644impl ACTIVE17_R {
645    #[doc = "Get enumerated values variant"]
646    #[inline(always)]
647    pub fn variant(&self) -> ACTIVE17_A {
648        match self.bits {
649            false => ACTIVE17_A::NOT_ACTIVE,
650            true => ACTIVE17_A::ACTIVE,
651        }
652    }
653    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
654    #[inline(always)]
655    pub fn is_not_active(&self) -> bool {
656        *self == ACTIVE17_A::NOT_ACTIVE
657    }
658    #[doc = "Checks if the value of the field is `ACTIVE`"]
659    #[inline(always)]
660    pub fn is_active(&self) -> bool {
661        *self == ACTIVE17_A::ACTIVE
662    }
663}
664#[doc = "Field `ACTIVE18` reader - Active flag for DMA channel."]
665pub type ACTIVE18_R = crate::BitReader<ACTIVE18_A>;
666#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
667#[derive(Clone, Copy, Debug, PartialEq, Eq)]
668pub enum ACTIVE18_A {
669    #[doc = "0: DMA channel is not active."]
670    NOT_ACTIVE = 0,
671    #[doc = "1: DMA channel is active."]
672    ACTIVE = 1,
673}
674impl From<ACTIVE18_A> for bool {
675    #[inline(always)]
676    fn from(variant: ACTIVE18_A) -> Self {
677        variant as u8 != 0
678    }
679}
680impl ACTIVE18_R {
681    #[doc = "Get enumerated values variant"]
682    #[inline(always)]
683    pub fn variant(&self) -> ACTIVE18_A {
684        match self.bits {
685            false => ACTIVE18_A::NOT_ACTIVE,
686            true => ACTIVE18_A::ACTIVE,
687        }
688    }
689    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
690    #[inline(always)]
691    pub fn is_not_active(&self) -> bool {
692        *self == ACTIVE18_A::NOT_ACTIVE
693    }
694    #[doc = "Checks if the value of the field is `ACTIVE`"]
695    #[inline(always)]
696    pub fn is_active(&self) -> bool {
697        *self == ACTIVE18_A::ACTIVE
698    }
699}
700#[doc = "Field `ACTIVE19` reader - Active flag for DMA channel."]
701pub type ACTIVE19_R = crate::BitReader<ACTIVE19_A>;
702#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
703#[derive(Clone, Copy, Debug, PartialEq, Eq)]
704pub enum ACTIVE19_A {
705    #[doc = "0: DMA channel is not active."]
706    NOT_ACTIVE = 0,
707    #[doc = "1: DMA channel is active."]
708    ACTIVE = 1,
709}
710impl From<ACTIVE19_A> for bool {
711    #[inline(always)]
712    fn from(variant: ACTIVE19_A) -> Self {
713        variant as u8 != 0
714    }
715}
716impl ACTIVE19_R {
717    #[doc = "Get enumerated values variant"]
718    #[inline(always)]
719    pub fn variant(&self) -> ACTIVE19_A {
720        match self.bits {
721            false => ACTIVE19_A::NOT_ACTIVE,
722            true => ACTIVE19_A::ACTIVE,
723        }
724    }
725    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
726    #[inline(always)]
727    pub fn is_not_active(&self) -> bool {
728        *self == ACTIVE19_A::NOT_ACTIVE
729    }
730    #[doc = "Checks if the value of the field is `ACTIVE`"]
731    #[inline(always)]
732    pub fn is_active(&self) -> bool {
733        *self == ACTIVE19_A::ACTIVE
734    }
735}
736#[doc = "Field `ACTIVE20` reader - Active flag for DMA channel."]
737pub type ACTIVE20_R = crate::BitReader<ACTIVE20_A>;
738#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
739#[derive(Clone, Copy, Debug, PartialEq, Eq)]
740pub enum ACTIVE20_A {
741    #[doc = "0: DMA channel is not active."]
742    NOT_ACTIVE = 0,
743    #[doc = "1: DMA channel is active."]
744    ACTIVE = 1,
745}
746impl From<ACTIVE20_A> for bool {
747    #[inline(always)]
748    fn from(variant: ACTIVE20_A) -> Self {
749        variant as u8 != 0
750    }
751}
752impl ACTIVE20_R {
753    #[doc = "Get enumerated values variant"]
754    #[inline(always)]
755    pub fn variant(&self) -> ACTIVE20_A {
756        match self.bits {
757            false => ACTIVE20_A::NOT_ACTIVE,
758            true => ACTIVE20_A::ACTIVE,
759        }
760    }
761    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
762    #[inline(always)]
763    pub fn is_not_active(&self) -> bool {
764        *self == ACTIVE20_A::NOT_ACTIVE
765    }
766    #[doc = "Checks if the value of the field is `ACTIVE`"]
767    #[inline(always)]
768    pub fn is_active(&self) -> bool {
769        *self == ACTIVE20_A::ACTIVE
770    }
771}
772#[doc = "Field `ACTIVE21` reader - Active flag for DMA channel."]
773pub type ACTIVE21_R = crate::BitReader<ACTIVE21_A>;
774#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
775#[derive(Clone, Copy, Debug, PartialEq, Eq)]
776pub enum ACTIVE21_A {
777    #[doc = "0: DMA channel is not active."]
778    NOT_ACTIVE = 0,
779    #[doc = "1: DMA channel is active."]
780    ACTIVE = 1,
781}
782impl From<ACTIVE21_A> for bool {
783    #[inline(always)]
784    fn from(variant: ACTIVE21_A) -> Self {
785        variant as u8 != 0
786    }
787}
788impl ACTIVE21_R {
789    #[doc = "Get enumerated values variant"]
790    #[inline(always)]
791    pub fn variant(&self) -> ACTIVE21_A {
792        match self.bits {
793            false => ACTIVE21_A::NOT_ACTIVE,
794            true => ACTIVE21_A::ACTIVE,
795        }
796    }
797    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
798    #[inline(always)]
799    pub fn is_not_active(&self) -> bool {
800        *self == ACTIVE21_A::NOT_ACTIVE
801    }
802    #[doc = "Checks if the value of the field is `ACTIVE`"]
803    #[inline(always)]
804    pub fn is_active(&self) -> bool {
805        *self == ACTIVE21_A::ACTIVE
806    }
807}
808#[doc = "Field `ACTIVE22` reader - Active flag for DMA channel."]
809pub type ACTIVE22_R = crate::BitReader<ACTIVE22_A>;
810#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
811#[derive(Clone, Copy, Debug, PartialEq, Eq)]
812pub enum ACTIVE22_A {
813    #[doc = "0: DMA channel is not active."]
814    NOT_ACTIVE = 0,
815    #[doc = "1: DMA channel is active."]
816    ACTIVE = 1,
817}
818impl From<ACTIVE22_A> for bool {
819    #[inline(always)]
820    fn from(variant: ACTIVE22_A) -> Self {
821        variant as u8 != 0
822    }
823}
824impl ACTIVE22_R {
825    #[doc = "Get enumerated values variant"]
826    #[inline(always)]
827    pub fn variant(&self) -> ACTIVE22_A {
828        match self.bits {
829            false => ACTIVE22_A::NOT_ACTIVE,
830            true => ACTIVE22_A::ACTIVE,
831        }
832    }
833    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
834    #[inline(always)]
835    pub fn is_not_active(&self) -> bool {
836        *self == ACTIVE22_A::NOT_ACTIVE
837    }
838    #[doc = "Checks if the value of the field is `ACTIVE`"]
839    #[inline(always)]
840    pub fn is_active(&self) -> bool {
841        *self == ACTIVE22_A::ACTIVE
842    }
843}
844#[doc = "Field `ACTIVE23` reader - Active flag for DMA channel."]
845pub type ACTIVE23_R = crate::BitReader<ACTIVE23_A>;
846#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
847#[derive(Clone, Copy, Debug, PartialEq, Eq)]
848pub enum ACTIVE23_A {
849    #[doc = "0: DMA channel is not active."]
850    NOT_ACTIVE = 0,
851    #[doc = "1: DMA channel is active."]
852    ACTIVE = 1,
853}
854impl From<ACTIVE23_A> for bool {
855    #[inline(always)]
856    fn from(variant: ACTIVE23_A) -> Self {
857        variant as u8 != 0
858    }
859}
860impl ACTIVE23_R {
861    #[doc = "Get enumerated values variant"]
862    #[inline(always)]
863    pub fn variant(&self) -> ACTIVE23_A {
864        match self.bits {
865            false => ACTIVE23_A::NOT_ACTIVE,
866            true => ACTIVE23_A::ACTIVE,
867        }
868    }
869    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
870    #[inline(always)]
871    pub fn is_not_active(&self) -> bool {
872        *self == ACTIVE23_A::NOT_ACTIVE
873    }
874    #[doc = "Checks if the value of the field is `ACTIVE`"]
875    #[inline(always)]
876    pub fn is_active(&self) -> bool {
877        *self == ACTIVE23_A::ACTIVE
878    }
879}
880#[doc = "Field `ACTIVE24` reader - Active flag for DMA channel."]
881pub type ACTIVE24_R = crate::BitReader<ACTIVE24_A>;
882#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
883#[derive(Clone, Copy, Debug, PartialEq, Eq)]
884pub enum ACTIVE24_A {
885    #[doc = "0: DMA channel is not active."]
886    NOT_ACTIVE = 0,
887    #[doc = "1: DMA channel is active."]
888    ACTIVE = 1,
889}
890impl From<ACTIVE24_A> for bool {
891    #[inline(always)]
892    fn from(variant: ACTIVE24_A) -> Self {
893        variant as u8 != 0
894    }
895}
896impl ACTIVE24_R {
897    #[doc = "Get enumerated values variant"]
898    #[inline(always)]
899    pub fn variant(&self) -> ACTIVE24_A {
900        match self.bits {
901            false => ACTIVE24_A::NOT_ACTIVE,
902            true => ACTIVE24_A::ACTIVE,
903        }
904    }
905    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
906    #[inline(always)]
907    pub fn is_not_active(&self) -> bool {
908        *self == ACTIVE24_A::NOT_ACTIVE
909    }
910    #[doc = "Checks if the value of the field is `ACTIVE`"]
911    #[inline(always)]
912    pub fn is_active(&self) -> bool {
913        *self == ACTIVE24_A::ACTIVE
914    }
915}
916#[doc = "Field `ACTIVE25` reader - Active flag for DMA channel."]
917pub type ACTIVE25_R = crate::BitReader<ACTIVE25_A>;
918#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
919#[derive(Clone, Copy, Debug, PartialEq, Eq)]
920pub enum ACTIVE25_A {
921    #[doc = "0: DMA channel is not active."]
922    NOT_ACTIVE = 0,
923    #[doc = "1: DMA channel is active."]
924    ACTIVE = 1,
925}
926impl From<ACTIVE25_A> for bool {
927    #[inline(always)]
928    fn from(variant: ACTIVE25_A) -> Self {
929        variant as u8 != 0
930    }
931}
932impl ACTIVE25_R {
933    #[doc = "Get enumerated values variant"]
934    #[inline(always)]
935    pub fn variant(&self) -> ACTIVE25_A {
936        match self.bits {
937            false => ACTIVE25_A::NOT_ACTIVE,
938            true => ACTIVE25_A::ACTIVE,
939        }
940    }
941    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
942    #[inline(always)]
943    pub fn is_not_active(&self) -> bool {
944        *self == ACTIVE25_A::NOT_ACTIVE
945    }
946    #[doc = "Checks if the value of the field is `ACTIVE`"]
947    #[inline(always)]
948    pub fn is_active(&self) -> bool {
949        *self == ACTIVE25_A::ACTIVE
950    }
951}
952#[doc = "Field `ACTIVE26` reader - Active flag for DMA channel."]
953pub type ACTIVE26_R = crate::BitReader<ACTIVE26_A>;
954#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
955#[derive(Clone, Copy, Debug, PartialEq, Eq)]
956pub enum ACTIVE26_A {
957    #[doc = "0: DMA channel is not active."]
958    NOT_ACTIVE = 0,
959    #[doc = "1: DMA channel is active."]
960    ACTIVE = 1,
961}
962impl From<ACTIVE26_A> for bool {
963    #[inline(always)]
964    fn from(variant: ACTIVE26_A) -> Self {
965        variant as u8 != 0
966    }
967}
968impl ACTIVE26_R {
969    #[doc = "Get enumerated values variant"]
970    #[inline(always)]
971    pub fn variant(&self) -> ACTIVE26_A {
972        match self.bits {
973            false => ACTIVE26_A::NOT_ACTIVE,
974            true => ACTIVE26_A::ACTIVE,
975        }
976    }
977    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
978    #[inline(always)]
979    pub fn is_not_active(&self) -> bool {
980        *self == ACTIVE26_A::NOT_ACTIVE
981    }
982    #[doc = "Checks if the value of the field is `ACTIVE`"]
983    #[inline(always)]
984    pub fn is_active(&self) -> bool {
985        *self == ACTIVE26_A::ACTIVE
986    }
987}
988#[doc = "Field `ACTIVE27` reader - Active flag for DMA channel."]
989pub type ACTIVE27_R = crate::BitReader<ACTIVE27_A>;
990#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
991#[derive(Clone, Copy, Debug, PartialEq, Eq)]
992pub enum ACTIVE27_A {
993    #[doc = "0: DMA channel is not active."]
994    NOT_ACTIVE = 0,
995    #[doc = "1: DMA channel is active."]
996    ACTIVE = 1,
997}
998impl From<ACTIVE27_A> for bool {
999    #[inline(always)]
1000    fn from(variant: ACTIVE27_A) -> Self {
1001        variant as u8 != 0
1002    }
1003}
1004impl ACTIVE27_R {
1005    #[doc = "Get enumerated values variant"]
1006    #[inline(always)]
1007    pub fn variant(&self) -> ACTIVE27_A {
1008        match self.bits {
1009            false => ACTIVE27_A::NOT_ACTIVE,
1010            true => ACTIVE27_A::ACTIVE,
1011        }
1012    }
1013    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
1014    #[inline(always)]
1015    pub fn is_not_active(&self) -> bool {
1016        *self == ACTIVE27_A::NOT_ACTIVE
1017    }
1018    #[doc = "Checks if the value of the field is `ACTIVE`"]
1019    #[inline(always)]
1020    pub fn is_active(&self) -> bool {
1021        *self == ACTIVE27_A::ACTIVE
1022    }
1023}
1024#[doc = "Field `ACTIVE28` reader - Active flag for DMA channel."]
1025pub type ACTIVE28_R = crate::BitReader<ACTIVE28_A>;
1026#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
1027#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1028pub enum ACTIVE28_A {
1029    #[doc = "0: DMA channel is not active."]
1030    NOT_ACTIVE = 0,
1031    #[doc = "1: DMA channel is active."]
1032    ACTIVE = 1,
1033}
1034impl From<ACTIVE28_A> for bool {
1035    #[inline(always)]
1036    fn from(variant: ACTIVE28_A) -> Self {
1037        variant as u8 != 0
1038    }
1039}
1040impl ACTIVE28_R {
1041    #[doc = "Get enumerated values variant"]
1042    #[inline(always)]
1043    pub fn variant(&self) -> ACTIVE28_A {
1044        match self.bits {
1045            false => ACTIVE28_A::NOT_ACTIVE,
1046            true => ACTIVE28_A::ACTIVE,
1047        }
1048    }
1049    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
1050    #[inline(always)]
1051    pub fn is_not_active(&self) -> bool {
1052        *self == ACTIVE28_A::NOT_ACTIVE
1053    }
1054    #[doc = "Checks if the value of the field is `ACTIVE`"]
1055    #[inline(always)]
1056    pub fn is_active(&self) -> bool {
1057        *self == ACTIVE28_A::ACTIVE
1058    }
1059}
1060#[doc = "Field `ACTIVE29` reader - Active flag for DMA channel."]
1061pub type ACTIVE29_R = crate::BitReader<ACTIVE29_A>;
1062#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
1063#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1064pub enum ACTIVE29_A {
1065    #[doc = "0: DMA channel is not active."]
1066    NOT_ACTIVE = 0,
1067    #[doc = "1: DMA channel is active."]
1068    ACTIVE = 1,
1069}
1070impl From<ACTIVE29_A> for bool {
1071    #[inline(always)]
1072    fn from(variant: ACTIVE29_A) -> Self {
1073        variant as u8 != 0
1074    }
1075}
1076impl ACTIVE29_R {
1077    #[doc = "Get enumerated values variant"]
1078    #[inline(always)]
1079    pub fn variant(&self) -> ACTIVE29_A {
1080        match self.bits {
1081            false => ACTIVE29_A::NOT_ACTIVE,
1082            true => ACTIVE29_A::ACTIVE,
1083        }
1084    }
1085    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
1086    #[inline(always)]
1087    pub fn is_not_active(&self) -> bool {
1088        *self == ACTIVE29_A::NOT_ACTIVE
1089    }
1090    #[doc = "Checks if the value of the field is `ACTIVE`"]
1091    #[inline(always)]
1092    pub fn is_active(&self) -> bool {
1093        *self == ACTIVE29_A::ACTIVE
1094    }
1095}
1096#[doc = "Field `ACTIVE30` reader - Active flag for DMA channel."]
1097pub type ACTIVE30_R = crate::BitReader<ACTIVE30_A>;
1098#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
1099#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1100pub enum ACTIVE30_A {
1101    #[doc = "0: DMA channel is not active."]
1102    NOT_ACTIVE = 0,
1103    #[doc = "1: DMA channel is active."]
1104    ACTIVE = 1,
1105}
1106impl From<ACTIVE30_A> for bool {
1107    #[inline(always)]
1108    fn from(variant: ACTIVE30_A) -> Self {
1109        variant as u8 != 0
1110    }
1111}
1112impl ACTIVE30_R {
1113    #[doc = "Get enumerated values variant"]
1114    #[inline(always)]
1115    pub fn variant(&self) -> ACTIVE30_A {
1116        match self.bits {
1117            false => ACTIVE30_A::NOT_ACTIVE,
1118            true => ACTIVE30_A::ACTIVE,
1119        }
1120    }
1121    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
1122    #[inline(always)]
1123    pub fn is_not_active(&self) -> bool {
1124        *self == ACTIVE30_A::NOT_ACTIVE
1125    }
1126    #[doc = "Checks if the value of the field is `ACTIVE`"]
1127    #[inline(always)]
1128    pub fn is_active(&self) -> bool {
1129        *self == ACTIVE30_A::ACTIVE
1130    }
1131}
1132#[doc = "Field `ACTIVE31` reader - Active flag for DMA channel."]
1133pub type ACTIVE31_R = crate::BitReader<ACTIVE31_A>;
1134#[doc = "Active flag for DMA channel.\n\nValue on reset: 0"]
1135#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1136pub enum ACTIVE31_A {
1137    #[doc = "0: DMA channel is not active."]
1138    NOT_ACTIVE = 0,
1139    #[doc = "1: DMA channel is active."]
1140    ACTIVE = 1,
1141}
1142impl From<ACTIVE31_A> for bool {
1143    #[inline(always)]
1144    fn from(variant: ACTIVE31_A) -> Self {
1145        variant as u8 != 0
1146    }
1147}
1148impl ACTIVE31_R {
1149    #[doc = "Get enumerated values variant"]
1150    #[inline(always)]
1151    pub fn variant(&self) -> ACTIVE31_A {
1152        match self.bits {
1153            false => ACTIVE31_A::NOT_ACTIVE,
1154            true => ACTIVE31_A::ACTIVE,
1155        }
1156    }
1157    #[doc = "Checks if the value of the field is `NOT_ACTIVE`"]
1158    #[inline(always)]
1159    pub fn is_not_active(&self) -> bool {
1160        *self == ACTIVE31_A::NOT_ACTIVE
1161    }
1162    #[doc = "Checks if the value of the field is `ACTIVE`"]
1163    #[inline(always)]
1164    pub fn is_active(&self) -> bool {
1165        *self == ACTIVE31_A::ACTIVE
1166    }
1167}
1168impl R {
1169    #[doc = "Bit 0 - Active flag for DMA channel."]
1170    #[inline(always)]
1171    pub fn active0(&self) -> ACTIVE0_R {
1172        ACTIVE0_R::new((self.bits & 1) != 0)
1173    }
1174    #[doc = "Bit 1 - Active flag for DMA channel."]
1175    #[inline(always)]
1176    pub fn active1(&self) -> ACTIVE1_R {
1177        ACTIVE1_R::new(((self.bits >> 1) & 1) != 0)
1178    }
1179    #[doc = "Bit 2 - Active flag for DMA channel."]
1180    #[inline(always)]
1181    pub fn active2(&self) -> ACTIVE2_R {
1182        ACTIVE2_R::new(((self.bits >> 2) & 1) != 0)
1183    }
1184    #[doc = "Bit 3 - Active flag for DMA channel."]
1185    #[inline(always)]
1186    pub fn active3(&self) -> ACTIVE3_R {
1187        ACTIVE3_R::new(((self.bits >> 3) & 1) != 0)
1188    }
1189    #[doc = "Bit 4 - Active flag for DMA channel."]
1190    #[inline(always)]
1191    pub fn active4(&self) -> ACTIVE4_R {
1192        ACTIVE4_R::new(((self.bits >> 4) & 1) != 0)
1193    }
1194    #[doc = "Bit 5 - Active flag for DMA channel."]
1195    #[inline(always)]
1196    pub fn active5(&self) -> ACTIVE5_R {
1197        ACTIVE5_R::new(((self.bits >> 5) & 1) != 0)
1198    }
1199    #[doc = "Bit 6 - Active flag for DMA channel."]
1200    #[inline(always)]
1201    pub fn active6(&self) -> ACTIVE6_R {
1202        ACTIVE6_R::new(((self.bits >> 6) & 1) != 0)
1203    }
1204    #[doc = "Bit 7 - Active flag for DMA channel."]
1205    #[inline(always)]
1206    pub fn active7(&self) -> ACTIVE7_R {
1207        ACTIVE7_R::new(((self.bits >> 7) & 1) != 0)
1208    }
1209    #[doc = "Bit 8 - Active flag for DMA channel."]
1210    #[inline(always)]
1211    pub fn active8(&self) -> ACTIVE8_R {
1212        ACTIVE8_R::new(((self.bits >> 8) & 1) != 0)
1213    }
1214    #[doc = "Bit 9 - Active flag for DMA channel."]
1215    #[inline(always)]
1216    pub fn active9(&self) -> ACTIVE9_R {
1217        ACTIVE9_R::new(((self.bits >> 9) & 1) != 0)
1218    }
1219    #[doc = "Bit 10 - Active flag for DMA channel."]
1220    #[inline(always)]
1221    pub fn active10(&self) -> ACTIVE10_R {
1222        ACTIVE10_R::new(((self.bits >> 10) & 1) != 0)
1223    }
1224    #[doc = "Bit 11 - Active flag for DMA channel."]
1225    #[inline(always)]
1226    pub fn active11(&self) -> ACTIVE11_R {
1227        ACTIVE11_R::new(((self.bits >> 11) & 1) != 0)
1228    }
1229    #[doc = "Bit 12 - Active flag for DMA channel."]
1230    #[inline(always)]
1231    pub fn active12(&self) -> ACTIVE12_R {
1232        ACTIVE12_R::new(((self.bits >> 12) & 1) != 0)
1233    }
1234    #[doc = "Bit 13 - Active flag for DMA channel."]
1235    #[inline(always)]
1236    pub fn active13(&self) -> ACTIVE13_R {
1237        ACTIVE13_R::new(((self.bits >> 13) & 1) != 0)
1238    }
1239    #[doc = "Bit 14 - Active flag for DMA channel."]
1240    #[inline(always)]
1241    pub fn active14(&self) -> ACTIVE14_R {
1242        ACTIVE14_R::new(((self.bits >> 14) & 1) != 0)
1243    }
1244    #[doc = "Bit 15 - Active flag for DMA channel."]
1245    #[inline(always)]
1246    pub fn active15(&self) -> ACTIVE15_R {
1247        ACTIVE15_R::new(((self.bits >> 15) & 1) != 0)
1248    }
1249    #[doc = "Bit 16 - Active flag for DMA channel."]
1250    #[inline(always)]
1251    pub fn active16(&self) -> ACTIVE16_R {
1252        ACTIVE16_R::new(((self.bits >> 16) & 1) != 0)
1253    }
1254    #[doc = "Bit 17 - Active flag for DMA channel."]
1255    #[inline(always)]
1256    pub fn active17(&self) -> ACTIVE17_R {
1257        ACTIVE17_R::new(((self.bits >> 17) & 1) != 0)
1258    }
1259    #[doc = "Bit 18 - Active flag for DMA channel."]
1260    #[inline(always)]
1261    pub fn active18(&self) -> ACTIVE18_R {
1262        ACTIVE18_R::new(((self.bits >> 18) & 1) != 0)
1263    }
1264    #[doc = "Bit 19 - Active flag for DMA channel."]
1265    #[inline(always)]
1266    pub fn active19(&self) -> ACTIVE19_R {
1267        ACTIVE19_R::new(((self.bits >> 19) & 1) != 0)
1268    }
1269    #[doc = "Bit 20 - Active flag for DMA channel."]
1270    #[inline(always)]
1271    pub fn active20(&self) -> ACTIVE20_R {
1272        ACTIVE20_R::new(((self.bits >> 20) & 1) != 0)
1273    }
1274    #[doc = "Bit 21 - Active flag for DMA channel."]
1275    #[inline(always)]
1276    pub fn active21(&self) -> ACTIVE21_R {
1277        ACTIVE21_R::new(((self.bits >> 21) & 1) != 0)
1278    }
1279    #[doc = "Bit 22 - Active flag for DMA channel."]
1280    #[inline(always)]
1281    pub fn active22(&self) -> ACTIVE22_R {
1282        ACTIVE22_R::new(((self.bits >> 22) & 1) != 0)
1283    }
1284    #[doc = "Bit 23 - Active flag for DMA channel."]
1285    #[inline(always)]
1286    pub fn active23(&self) -> ACTIVE23_R {
1287        ACTIVE23_R::new(((self.bits >> 23) & 1) != 0)
1288    }
1289    #[doc = "Bit 24 - Active flag for DMA channel."]
1290    #[inline(always)]
1291    pub fn active24(&self) -> ACTIVE24_R {
1292        ACTIVE24_R::new(((self.bits >> 24) & 1) != 0)
1293    }
1294    #[doc = "Bit 25 - Active flag for DMA channel."]
1295    #[inline(always)]
1296    pub fn active25(&self) -> ACTIVE25_R {
1297        ACTIVE25_R::new(((self.bits >> 25) & 1) != 0)
1298    }
1299    #[doc = "Bit 26 - Active flag for DMA channel."]
1300    #[inline(always)]
1301    pub fn active26(&self) -> ACTIVE26_R {
1302        ACTIVE26_R::new(((self.bits >> 26) & 1) != 0)
1303    }
1304    #[doc = "Bit 27 - Active flag for DMA channel."]
1305    #[inline(always)]
1306    pub fn active27(&self) -> ACTIVE27_R {
1307        ACTIVE27_R::new(((self.bits >> 27) & 1) != 0)
1308    }
1309    #[doc = "Bit 28 - Active flag for DMA channel."]
1310    #[inline(always)]
1311    pub fn active28(&self) -> ACTIVE28_R {
1312        ACTIVE28_R::new(((self.bits >> 28) & 1) != 0)
1313    }
1314    #[doc = "Bit 29 - Active flag for DMA channel."]
1315    #[inline(always)]
1316    pub fn active29(&self) -> ACTIVE29_R {
1317        ACTIVE29_R::new(((self.bits >> 29) & 1) != 0)
1318    }
1319    #[doc = "Bit 30 - Active flag for DMA channel."]
1320    #[inline(always)]
1321    pub fn active30(&self) -> ACTIVE30_R {
1322        ACTIVE30_R::new(((self.bits >> 30) & 1) != 0)
1323    }
1324    #[doc = "Bit 31 - Active flag for DMA channel."]
1325    #[inline(always)]
1326    pub fn active31(&self) -> ACTIVE31_R {
1327        ACTIVE31_R::new(((self.bits >> 31) & 1) != 0)
1328    }
1329}
1330#[doc = "Channel Active status for all DMA channels\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [active0](index.html) module"]
1331pub struct ACTIVE0_SPEC;
1332impl crate::RegisterSpec for ACTIVE0_SPEC {
1333    type Ux = u32;
1334}
1335#[doc = "`read()` method returns [active0::R](R) reader structure"]
1336impl crate::Readable for ACTIVE0_SPEC {
1337    type Reader = R;
1338}
1339#[doc = "`reset()` method sets ACTIVE0 to value 0"]
1340impl crate::Resettable for ACTIVE0_SPEC {
1341    const RESET_VALUE: Self::Ux = 0;
1342}
mimxrt595s/dma0/active0.rs

mimxrt595s/dma0/
active0.rs
