efm32gg_pac/efm32gg230/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 = "Field `CH0` reader - Channel 0 idle phase configuration"]
38pub type CH0_R = crate::FieldReader<u8, CH0_A>;
39#[doc = "Channel 0 idle phase configuration\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41#[repr(u8)]
42pub enum CH0_A {
43    #[doc = "0: CH0 output is disabled in idle phase"]
44    DISABLE = 0,
45    #[doc = "1: CH0 output is high in idle phase"]
46    HIGH = 1,
47    #[doc = "2: CH0 output is low in idle phase"]
48    LOW = 2,
49    #[doc = "3: CH0 output is connected to DAC CH0 output in idle phase"]
50    DACCH0 = 3,
51}
52impl From<CH0_A> for u8 {
53    #[inline(always)]
54    fn from(variant: CH0_A) -> Self {
55        variant as _
56    }
57}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH0_A, 2, O>;
93impl<'a, const O: u8> CH0_W<'a, O> {
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 = "Field `CH1` reader - Channel 1 idle phase configuration"]
116pub type CH1_R = crate::FieldReader<u8, CH1_A>;
117#[doc = "Channel 1 idle phase configuration\n\nValue on reset: 0"]
118#[derive(Clone, Copy, Debug, PartialEq, Eq)]
119#[repr(u8)]
120pub enum CH1_A {
121    #[doc = "0: CH1 output is disabled in idle phase"]
122    DISABLE = 0,
123    #[doc = "1: CH1 output is high in idle phase"]
124    HIGH = 1,
125    #[doc = "2: CH1 output is low in idle phase"]
126    LOW = 2,
127    #[doc = "3: CH1 output is connected to DAC CH0 output in idle phase"]
128    DACCH0 = 3,
129}
130impl From<CH1_A> for u8 {
131    #[inline(always)]
132    fn from(variant: CH1_A) -> Self {
133        variant as _
134    }
135}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH1_A, 2, O>;
171impl<'a, const O: u8> CH1_W<'a, O> {
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 = "Field `CH2` reader - Channel 2 idle phase configuration"]
194pub type CH2_R = crate::FieldReader<u8, CH2_A>;
195#[doc = "Channel 2 idle phase configuration\n\nValue on reset: 0"]
196#[derive(Clone, Copy, Debug, PartialEq, Eq)]
197#[repr(u8)]
198pub enum CH2_A {
199    #[doc = "0: CH2 output is disabled in idle phase"]
200    DISABLE = 0,
201    #[doc = "1: CH2 output is high in idle phase"]
202    HIGH = 1,
203    #[doc = "2: CH2 output is low in idle phase"]
204    LOW = 2,
205    #[doc = "3: CH2 output is connected to DAC CH0 output in idle phase"]
206    DACCH0 = 3,
207}
208impl From<CH2_A> for u8 {
209    #[inline(always)]
210    fn from(variant: CH2_A) -> Self {
211        variant as _
212    }
213}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH2_A, 2, O>;
249impl<'a, const O: u8> CH2_W<'a, O> {
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 = "Field `CH3` reader - Channel 3 idle phase configuration"]
272pub type CH3_R = crate::FieldReader<u8, CH3_A>;
273#[doc = "Channel 3 idle phase configuration\n\nValue on reset: 0"]
274#[derive(Clone, Copy, Debug, PartialEq, Eq)]
275#[repr(u8)]
276pub enum CH3_A {
277    #[doc = "0: CH3 output is disabled in idle phase"]
278    DISABLE = 0,
279    #[doc = "1: CH3 output is high in idle phase"]
280    HIGH = 1,
281    #[doc = "2: CH3 output is low in idle phase"]
282    LOW = 2,
283    #[doc = "3: CH3 output is connected to DAC CH0 output in idle phase"]
284    DACCH0 = 3,
285}
286impl From<CH3_A> for u8 {
287    #[inline(always)]
288    fn from(variant: CH3_A) -> Self {
289        variant as _
290    }
291}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH3_A, 2, O>;
327impl<'a, const O: u8> CH3_W<'a, O> {
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 = "Field `CH4` reader - Channel 4 idle phase configuration"]
350pub type CH4_R = crate::FieldReader<u8, CH4_A>;
351#[doc = "Channel 4 idle phase configuration\n\nValue on reset: 0"]
352#[derive(Clone, Copy, Debug, PartialEq, Eq)]
353#[repr(u8)]
354pub enum CH4_A {
355    #[doc = "0: CH4 output is disabled in idle phase"]
356    DISABLE = 0,
357    #[doc = "1: CH4 output is high in idle phase"]
358    HIGH = 1,
359    #[doc = "2: CH4 output is low in idle phase"]
360    LOW = 2,
361}
362impl From<CH4_A> for u8 {
363    #[inline(always)]
364    fn from(variant: CH4_A) -> Self {
365        variant as _
366    }
367}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH4_A, 2, O>;
397impl<'a, const O: u8> CH4_W<'a, O> {
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 = "Field `CH5` reader - Channel 5 idle phase configuration"]
415pub type CH5_R = crate::FieldReader<u8, CH5_A>;
416#[doc = "Channel 5 idle phase configuration\n\nValue on reset: 0"]
417#[derive(Clone, Copy, Debug, PartialEq, Eq)]
418#[repr(u8)]
419pub enum CH5_A {
420    #[doc = "0: CH5 output is disabled in idle phase"]
421    DISABLE = 0,
422    #[doc = "1: CH5 output is high in idle phase"]
423    HIGH = 1,
424    #[doc = "2: CH5 output is low in idle phase"]
425    LOW = 2,
426}
427impl From<CH5_A> for u8 {
428    #[inline(always)]
429    fn from(variant: CH5_A) -> Self {
430        variant as _
431    }
432}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH5_A, 2, O>;
462impl<'a, const O: u8> CH5_W<'a, O> {
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 = "Field `CH6` reader - Channel 6 idle phase configuration"]
480pub type CH6_R = crate::FieldReader<u8, CH6_A>;
481#[doc = "Channel 6 idle phase configuration\n\nValue on reset: 0"]
482#[derive(Clone, Copy, Debug, PartialEq, Eq)]
483#[repr(u8)]
484pub enum CH6_A {
485    #[doc = "0: CH6 output is disabled in idle phase"]
486    DISABLE = 0,
487    #[doc = "1: CH6 output is high in idle phase"]
488    HIGH = 1,
489    #[doc = "2: CH6 output is low in idle phase"]
490    LOW = 2,
491}
492impl From<CH6_A> for u8 {
493    #[inline(always)]
494    fn from(variant: CH6_A) -> Self {
495        variant as _
496    }
497}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH6_A, 2, O>;
527impl<'a, const O: u8> CH6_W<'a, O> {
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 = "Field `CH7` reader - Channel 7 idle phase configuration"]
545pub type CH7_R = crate::FieldReader<u8, CH7_A>;
546#[doc = "Channel 7 idle phase configuration\n\nValue on reset: 0"]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548#[repr(u8)]
549pub enum CH7_A {
550    #[doc = "0: CH7 output is disabled in idle phase"]
551    DISABLE = 0,
552    #[doc = "1: CH7 output is high in idle phase"]
553    HIGH = 1,
554    #[doc = "2: CH7 output is low in idle phase"]
555    LOW = 2,
556}
557impl From<CH7_A> for u8 {
558    #[inline(always)]
559    fn from(variant: CH7_A) -> Self {
560        variant as _
561    }
562}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH7_A, 2, O>;
592impl<'a, const O: u8> CH7_W<'a, O> {
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 = "Field `CH8` reader - Channel 8 idle phase configuration"]
610pub type CH8_R = crate::FieldReader<u8, CH8_A>;
611#[doc = "Channel 8 idle phase configuration\n\nValue on reset: 0"]
612#[derive(Clone, Copy, Debug, PartialEq, Eq)]
613#[repr(u8)]
614pub enum CH8_A {
615    #[doc = "0: CH8 output is disabled in idle phase"]
616    DISABLE = 0,
617    #[doc = "1: CH8 output is high in idle phase"]
618    HIGH = 1,
619    #[doc = "2: CH8 output is low in idle phase"]
620    LOW = 2,
621}
622impl From<CH8_A> for u8 {
623    #[inline(always)]
624    fn from(variant: CH8_A) -> Self {
625        variant as _
626    }
627}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH8_A, 2, O>;
657impl<'a, const O: u8> CH8_W<'a, O> {
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 = "Field `CH9` reader - Channel 9 idle phase configuration"]
675pub type CH9_R = crate::FieldReader<u8, CH9_A>;
676#[doc = "Channel 9 idle phase configuration\n\nValue on reset: 0"]
677#[derive(Clone, Copy, Debug, PartialEq, Eq)]
678#[repr(u8)]
679pub enum CH9_A {
680    #[doc = "0: CH9 output is disabled in idle phase"]
681    DISABLE = 0,
682    #[doc = "1: CH9 output is high in idle phase"]
683    HIGH = 1,
684    #[doc = "2: CH9 output is low in idle phase"]
685    LOW = 2,
686}
687impl From<CH9_A> for u8 {
688    #[inline(always)]
689    fn from(variant: CH9_A) -> Self {
690        variant as _
691    }
692}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH9_A, 2, O>;
722impl<'a, const O: u8> CH9_W<'a, O> {
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 = "Field `CH10` reader - Channel 10 idle phase configuration"]
740pub type CH10_R = crate::FieldReader<u8, CH10_A>;
741#[doc = "Channel 10 idle phase configuration\n\nValue on reset: 0"]
742#[derive(Clone, Copy, Debug, PartialEq, Eq)]
743#[repr(u8)]
744pub enum CH10_A {
745    #[doc = "0: CH10 output is disabled in idle phase"]
746    DISABLE = 0,
747    #[doc = "1: CH10 output is high in idle phase"]
748    HIGH = 1,
749    #[doc = "2: CH10 output is low in idle phase"]
750    LOW = 2,
751}
752impl From<CH10_A> for u8 {
753    #[inline(always)]
754    fn from(variant: CH10_A) -> Self {
755        variant as _
756    }
757}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH10_A, 2, O>;
787impl<'a, const O: u8> CH10_W<'a, O> {
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 = "Field `CH11` reader - Channel 11 idle phase configuration"]
805pub type CH11_R = crate::FieldReader<u8, CH11_A>;
806#[doc = "Channel 11 idle phase configuration\n\nValue on reset: 0"]
807#[derive(Clone, Copy, Debug, PartialEq, Eq)]
808#[repr(u8)]
809pub enum CH11_A {
810    #[doc = "0: CH11 output is disabled in idle phase"]
811    DISABLE = 0,
812    #[doc = "1: CH11 output is high in idle phase"]
813    HIGH = 1,
814    #[doc = "2: CH11 output is low in idle phase"]
815    LOW = 2,
816}
817impl From<CH11_A> for u8 {
818    #[inline(always)]
819    fn from(variant: CH11_A) -> Self {
820        variant as _
821    }
822}
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, const O: u8> = crate::FieldWriter<'a, u32, IDLECONF_SPEC, u8, CH11_A, 2, O>;
852impl<'a, const O: u8> CH11_W<'a, O> {
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 = "Field `CH12` reader - Channel 12 idle phase configuration"]
870pub type CH12_R = crate::FieldReader<u8, CH12_A>;
871#[doc = "Channel 12 idle phase configuration\n\nValue on reset: 0"]
872#[derive(Clone, Copy, Debug, PartialEq, Eq)]
873#[repr(u8)]
874pub enum CH12_A {
875    #[doc = "0: CH12 output is disabled in idle phase"]
876    DISABLE = 0,
877    #[doc = "1: CH12 output is high in idle phase"]
878    HIGH = 1,
879    #[doc = "2: CH12 output is low in idle phase"]
880    LOW = 2,
881    #[doc = "3: CH12 output is connected to DAC CH1 output in idle phase"]
882    DACCH1 = 3,
883}
884impl From<CH12_A> for u8 {
885    #[inline(always)]
886    fn from(variant: CH12_A) -> Self {
887        variant as _
888    }
889}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH12_A, 2, O>;
925impl<'a, const O: u8> CH12_W<'a, O> {
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 = "Field `CH13` reader - Channel 13 idle phase configuration"]
948pub type CH13_R = crate::FieldReader<u8, CH13_A>;
949#[doc = "Channel 13 idle phase configuration\n\nValue on reset: 0"]
950#[derive(Clone, Copy, Debug, PartialEq, Eq)]
951#[repr(u8)]
952pub enum CH13_A {
953    #[doc = "0: CH13 output is disabled in idle phase"]
954    DISABLE = 0,
955    #[doc = "1: CH13 output is high in idle phase"]
956    HIGH = 1,
957    #[doc = "2: CH13 output is low in idle phase"]
958    LOW = 2,
959    #[doc = "3: CH13 output is connected to DAC CH1 output in idle phase"]
960    DACCH1 = 3,
961}
962impl From<CH13_A> for u8 {
963    #[inline(always)]
964    fn from(variant: CH13_A) -> Self {
965        variant as _
966    }
967}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH13_A, 2, O>;
1003impl<'a, const O: u8> CH13_W<'a, O> {
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 = "Field `CH14` reader - Channel 14 idle phase configuration"]
1026pub type CH14_R = crate::FieldReader<u8, CH14_A>;
1027#[doc = "Channel 14 idle phase configuration\n\nValue on reset: 0"]
1028#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1029#[repr(u8)]
1030pub enum CH14_A {
1031    #[doc = "0: CH14 output is disabled in idle phase"]
1032    DISABLE = 0,
1033    #[doc = "1: CH14 output is high in idle phase"]
1034    HIGH = 1,
1035    #[doc = "2: CH14 output is low in idle phase"]
1036    LOW = 2,
1037    #[doc = "3: CH14 output is connected to DAC CH1 output in idle phase"]
1038    DACCH1 = 3,
1039}
1040impl From<CH14_A> for u8 {
1041    #[inline(always)]
1042    fn from(variant: CH14_A) -> Self {
1043        variant as _
1044    }
1045}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH14_A, 2, O>;
1081impl<'a, const O: u8> CH14_W<'a, O> {
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 = "Field `CH15` reader - Channel 15 idle phase configuration"]
1104pub type CH15_R = crate::FieldReader<u8, CH15_A>;
1105#[doc = "Channel 15 idle phase configuration\n\nValue on reset: 0"]
1106#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1107#[repr(u8)]
1108pub enum CH15_A {
1109    #[doc = "0: CH15 output is disabled in idle phase"]
1110    DISABLE = 0,
1111    #[doc = "1: CH15 output is high in idle phase"]
1112    HIGH = 1,
1113    #[doc = "2: CH15 output is low in idle phase"]
1114    LOW = 2,
1115    #[doc = "3: CH15 output is connected to DAC CH1 output in idle phase"]
1116    DACCH1 = 3,
1117}
1118impl From<CH15_A> for u8 {
1119    #[inline(always)]
1120    fn from(variant: CH15_A) -> Self {
1121        variant as _
1122    }
1123}
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, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH15_A, 2, O>;
1159impl<'a, const O: u8> CH15_W<'a, O> {
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    #[must_use]
1267    pub fn ch0(&mut self) -> CH0_W<0> {
1268        CH0_W::new(self)
1269    }
1270    #[doc = "Bits 2:3 - Channel 1 idle phase configuration"]
1271    #[inline(always)]
1272    #[must_use]
1273    pub fn ch1(&mut self) -> CH1_W<2> {
1274        CH1_W::new(self)
1275    }
1276    #[doc = "Bits 4:5 - Channel 2 idle phase configuration"]
1277    #[inline(always)]
1278    #[must_use]
1279    pub fn ch2(&mut self) -> CH2_W<4> {
1280        CH2_W::new(self)
1281    }
1282    #[doc = "Bits 6:7 - Channel 3 idle phase configuration"]
1283    #[inline(always)]
1284    #[must_use]
1285    pub fn ch3(&mut self) -> CH3_W<6> {
1286        CH3_W::new(self)
1287    }
1288    #[doc = "Bits 8:9 - Channel 4 idle phase configuration"]
1289    #[inline(always)]
1290    #[must_use]
1291    pub fn ch4(&mut self) -> CH4_W<8> {
1292        CH4_W::new(self)
1293    }
1294    #[doc = "Bits 10:11 - Channel 5 idle phase configuration"]
1295    #[inline(always)]
1296    #[must_use]
1297    pub fn ch5(&mut self) -> CH5_W<10> {
1298        CH5_W::new(self)
1299    }
1300    #[doc = "Bits 12:13 - Channel 6 idle phase configuration"]
1301    #[inline(always)]
1302    #[must_use]
1303    pub fn ch6(&mut self) -> CH6_W<12> {
1304        CH6_W::new(self)
1305    }
1306    #[doc = "Bits 14:15 - Channel 7 idle phase configuration"]
1307    #[inline(always)]
1308    #[must_use]
1309    pub fn ch7(&mut self) -> CH7_W<14> {
1310        CH7_W::new(self)
1311    }
1312    #[doc = "Bits 16:17 - Channel 8 idle phase configuration"]
1313    #[inline(always)]
1314    #[must_use]
1315    pub fn ch8(&mut self) -> CH8_W<16> {
1316        CH8_W::new(self)
1317    }
1318    #[doc = "Bits 18:19 - Channel 9 idle phase configuration"]
1319    #[inline(always)]
1320    #[must_use]
1321    pub fn ch9(&mut self) -> CH9_W<18> {
1322        CH9_W::new(self)
1323    }
1324    #[doc = "Bits 20:21 - Channel 10 idle phase configuration"]
1325    #[inline(always)]
1326    #[must_use]
1327    pub fn ch10(&mut self) -> CH10_W<20> {
1328        CH10_W::new(self)
1329    }
1330    #[doc = "Bits 22:23 - Channel 11 idle phase configuration"]
1331    #[inline(always)]
1332    #[must_use]
1333    pub fn ch11(&mut self) -> CH11_W<22> {
1334        CH11_W::new(self)
1335    }
1336    #[doc = "Bits 24:25 - Channel 12 idle phase configuration"]
1337    #[inline(always)]
1338    #[must_use]
1339    pub fn ch12(&mut self) -> CH12_W<24> {
1340        CH12_W::new(self)
1341    }
1342    #[doc = "Bits 26:27 - Channel 13 idle phase configuration"]
1343    #[inline(always)]
1344    #[must_use]
1345    pub fn ch13(&mut self) -> CH13_W<26> {
1346        CH13_W::new(self)
1347    }
1348    #[doc = "Bits 28:29 - Channel 14 idle phase configuration"]
1349    #[inline(always)]
1350    #[must_use]
1351    pub fn ch14(&mut self) -> CH14_W<28> {
1352        CH14_W::new(self)
1353    }
1354    #[doc = "Bits 30:31 - Channel 15 idle phase configuration"]
1355    #[inline(always)]
1356    #[must_use]
1357    pub fn ch15(&mut self) -> CH15_W<30> {
1358        CH15_W::new(self)
1359    }
1360    #[doc = "Writes raw bits to the register."]
1361    #[inline(always)]
1362    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1363        self.0.bits(bits);
1364        self
1365    }
1366}
1367#[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"]
1368pub struct IDLECONF_SPEC;
1369impl crate::RegisterSpec for IDLECONF_SPEC {
1370    type Ux = u32;
1371}
1372#[doc = "`read()` method returns [idleconf::R](R) reader structure"]
1373impl crate::Readable for IDLECONF_SPEC {
1374    type Reader = R;
1375}
1376#[doc = "`write(|w| ..)` method takes [idleconf::W](W) writer structure"]
1377impl crate::Writable for IDLECONF_SPEC {
1378    type Writer = W;
1379    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1380    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1381}
1382#[doc = "`reset()` method sets IDLECONF to value 0"]
1383impl crate::Resettable for IDLECONF_SPEC {
1384    const RESET_VALUE: Self::Ux = 0;
1385}
efm32gg_pac/efm32gg230/lesense/idleconf.rs

efm32gg_pac/efm32gg230/lesense/
idleconf.rs
