efm32wg280_pac/lesense/
idleconf.rs

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

efm32wg280_pac/lesense/
idleconf.rs
