efm32gg12b_pac/efm32gg12b830/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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
50    DAC = 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::DAC,
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 `DAC`"]
86    #[inline(always)]
87    pub fn is_dac(&self) -> bool {
88        *self == CH0_A::DAC
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
110    #[inline(always)]
111    pub fn dac(self) -> &'a mut W {
112        self.variant(CH0_A::DAC)
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
128    DAC = 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::DAC,
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 `DAC`"]
164    #[inline(always)]
165    pub fn is_dac(&self) -> bool {
166        *self == CH1_A::DAC
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
188    #[inline(always)]
189    pub fn dac(self) -> &'a mut W {
190        self.variant(CH1_A::DAC)
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
206    DAC = 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::DAC,
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 `DAC`"]
242    #[inline(always)]
243    pub fn is_dac(&self) -> bool {
244        *self == CH2_A::DAC
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
266    #[inline(always)]
267    pub fn dac(self) -> &'a mut W {
268        self.variant(CH2_A::DAC)
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
284    DAC = 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::DAC,
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 `DAC`"]
320    #[inline(always)]
321    pub fn is_dac(&self) -> bool {
322        *self == CH3_A::DAC
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 VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
344    #[inline(always)]
345    pub fn dac(self) -> &'a mut W {
346        self.variant(CH3_A::DAC)
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    #[doc = "3: CH4 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
362    DAC = 3,
363}
364impl From<CH4_A> for u8 {
365    #[inline(always)]
366    fn from(variant: CH4_A) -> Self {
367        variant as _
368    }
369}
370impl CH4_R {
371    #[doc = "Get enumerated values variant"]
372    #[inline(always)]
373    pub fn variant(&self) -> CH4_A {
374        match self.bits {
375            0 => CH4_A::DISABLE,
376            1 => CH4_A::HIGH,
377            2 => CH4_A::LOW,
378            3 => CH4_A::DAC,
379            _ => unreachable!(),
380        }
381    }
382    #[doc = "Checks if the value of the field is `DISABLE`"]
383    #[inline(always)]
384    pub fn is_disable(&self) -> bool {
385        *self == CH4_A::DISABLE
386    }
387    #[doc = "Checks if the value of the field is `HIGH`"]
388    #[inline(always)]
389    pub fn is_high(&self) -> bool {
390        *self == CH4_A::HIGH
391    }
392    #[doc = "Checks if the value of the field is `LOW`"]
393    #[inline(always)]
394    pub fn is_low(&self) -> bool {
395        *self == CH4_A::LOW
396    }
397    #[doc = "Checks if the value of the field is `DAC`"]
398    #[inline(always)]
399    pub fn is_dac(&self) -> bool {
400        *self == CH4_A::DAC
401    }
402}
403#[doc = "Field `CH4` writer - Channel 4 Idle Phase Configuration"]
404pub type CH4_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH4_A, 2, O>;
405impl<'a, const O: u8> CH4_W<'a, O> {
406    #[doc = "CH4 output is disabled in idle phase"]
407    #[inline(always)]
408    pub fn disable(self) -> &'a mut W {
409        self.variant(CH4_A::DISABLE)
410    }
411    #[doc = "CH4 output is high in idle phase"]
412    #[inline(always)]
413    pub fn high(self) -> &'a mut W {
414        self.variant(CH4_A::HIGH)
415    }
416    #[doc = "CH4 output is low in idle phase"]
417    #[inline(always)]
418    pub fn low(self) -> &'a mut W {
419        self.variant(CH4_A::LOW)
420    }
421    #[doc = "CH4 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
422    #[inline(always)]
423    pub fn dac(self) -> &'a mut W {
424        self.variant(CH4_A::DAC)
425    }
426}
427#[doc = "Field `CH5` reader - Channel 5 Idle Phase Configuration"]
428pub type CH5_R = crate::FieldReader<u8, CH5_A>;
429#[doc = "Channel 5 Idle Phase Configuration\n\nValue on reset: 0"]
430#[derive(Clone, Copy, Debug, PartialEq, Eq)]
431#[repr(u8)]
432pub enum CH5_A {
433    #[doc = "0: CH5 output is disabled in idle phase"]
434    DISABLE = 0,
435    #[doc = "1: CH5 output is high in idle phase"]
436    HIGH = 1,
437    #[doc = "2: CH5 output is low in idle phase"]
438    LOW = 2,
439    #[doc = "3: CH5 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
440    DAC = 3,
441}
442impl From<CH5_A> for u8 {
443    #[inline(always)]
444    fn from(variant: CH5_A) -> Self {
445        variant as _
446    }
447}
448impl CH5_R {
449    #[doc = "Get enumerated values variant"]
450    #[inline(always)]
451    pub fn variant(&self) -> CH5_A {
452        match self.bits {
453            0 => CH5_A::DISABLE,
454            1 => CH5_A::HIGH,
455            2 => CH5_A::LOW,
456            3 => CH5_A::DAC,
457            _ => unreachable!(),
458        }
459    }
460    #[doc = "Checks if the value of the field is `DISABLE`"]
461    #[inline(always)]
462    pub fn is_disable(&self) -> bool {
463        *self == CH5_A::DISABLE
464    }
465    #[doc = "Checks if the value of the field is `HIGH`"]
466    #[inline(always)]
467    pub fn is_high(&self) -> bool {
468        *self == CH5_A::HIGH
469    }
470    #[doc = "Checks if the value of the field is `LOW`"]
471    #[inline(always)]
472    pub fn is_low(&self) -> bool {
473        *self == CH5_A::LOW
474    }
475    #[doc = "Checks if the value of the field is `DAC`"]
476    #[inline(always)]
477    pub fn is_dac(&self) -> bool {
478        *self == CH5_A::DAC
479    }
480}
481#[doc = "Field `CH5` writer - Channel 5 Idle Phase Configuration"]
482pub type CH5_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH5_A, 2, O>;
483impl<'a, const O: u8> CH5_W<'a, O> {
484    #[doc = "CH5 output is disabled in idle phase"]
485    #[inline(always)]
486    pub fn disable(self) -> &'a mut W {
487        self.variant(CH5_A::DISABLE)
488    }
489    #[doc = "CH5 output is high in idle phase"]
490    #[inline(always)]
491    pub fn high(self) -> &'a mut W {
492        self.variant(CH5_A::HIGH)
493    }
494    #[doc = "CH5 output is low in idle phase"]
495    #[inline(always)]
496    pub fn low(self) -> &'a mut W {
497        self.variant(CH5_A::LOW)
498    }
499    #[doc = "CH5 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
500    #[inline(always)]
501    pub fn dac(self) -> &'a mut W {
502        self.variant(CH5_A::DAC)
503    }
504}
505#[doc = "Field `CH6` reader - Channel 6 Idle Phase Configuration"]
506pub type CH6_R = crate::FieldReader<u8, CH6_A>;
507#[doc = "Channel 6 Idle Phase Configuration\n\nValue on reset: 0"]
508#[derive(Clone, Copy, Debug, PartialEq, Eq)]
509#[repr(u8)]
510pub enum CH6_A {
511    #[doc = "0: CH6 output is disabled in idle phase"]
512    DISABLE = 0,
513    #[doc = "1: CH6 output is high in idle phase"]
514    HIGH = 1,
515    #[doc = "2: CH6 output is low in idle phase"]
516    LOW = 2,
517    #[doc = "3: CH6 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
518    DAC = 3,
519}
520impl From<CH6_A> for u8 {
521    #[inline(always)]
522    fn from(variant: CH6_A) -> Self {
523        variant as _
524    }
525}
526impl CH6_R {
527    #[doc = "Get enumerated values variant"]
528    #[inline(always)]
529    pub fn variant(&self) -> CH6_A {
530        match self.bits {
531            0 => CH6_A::DISABLE,
532            1 => CH6_A::HIGH,
533            2 => CH6_A::LOW,
534            3 => CH6_A::DAC,
535            _ => unreachable!(),
536        }
537    }
538    #[doc = "Checks if the value of the field is `DISABLE`"]
539    #[inline(always)]
540    pub fn is_disable(&self) -> bool {
541        *self == CH6_A::DISABLE
542    }
543    #[doc = "Checks if the value of the field is `HIGH`"]
544    #[inline(always)]
545    pub fn is_high(&self) -> bool {
546        *self == CH6_A::HIGH
547    }
548    #[doc = "Checks if the value of the field is `LOW`"]
549    #[inline(always)]
550    pub fn is_low(&self) -> bool {
551        *self == CH6_A::LOW
552    }
553    #[doc = "Checks if the value of the field is `DAC`"]
554    #[inline(always)]
555    pub fn is_dac(&self) -> bool {
556        *self == CH6_A::DAC
557    }
558}
559#[doc = "Field `CH6` writer - Channel 6 Idle Phase Configuration"]
560pub type CH6_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH6_A, 2, O>;
561impl<'a, const O: u8> CH6_W<'a, O> {
562    #[doc = "CH6 output is disabled in idle phase"]
563    #[inline(always)]
564    pub fn disable(self) -> &'a mut W {
565        self.variant(CH6_A::DISABLE)
566    }
567    #[doc = "CH6 output is high in idle phase"]
568    #[inline(always)]
569    pub fn high(self) -> &'a mut W {
570        self.variant(CH6_A::HIGH)
571    }
572    #[doc = "CH6 output is low in idle phase"]
573    #[inline(always)]
574    pub fn low(self) -> &'a mut W {
575        self.variant(CH6_A::LOW)
576    }
577    #[doc = "CH6 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
578    #[inline(always)]
579    pub fn dac(self) -> &'a mut W {
580        self.variant(CH6_A::DAC)
581    }
582}
583#[doc = "Field `CH7` reader - Channel 7 Idle Phase Configuration"]
584pub type CH7_R = crate::FieldReader<u8, CH7_A>;
585#[doc = "Channel 7 Idle Phase Configuration\n\nValue on reset: 0"]
586#[derive(Clone, Copy, Debug, PartialEq, Eq)]
587#[repr(u8)]
588pub enum CH7_A {
589    #[doc = "0: CH7 output is disabled in idle phase"]
590    DISABLE = 0,
591    #[doc = "1: CH7 output is high in idle phase"]
592    HIGH = 1,
593    #[doc = "2: CH7 output is low in idle phase"]
594    LOW = 2,
595    #[doc = "3: CH7 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
596    DAC = 3,
597}
598impl From<CH7_A> for u8 {
599    #[inline(always)]
600    fn from(variant: CH7_A) -> Self {
601        variant as _
602    }
603}
604impl CH7_R {
605    #[doc = "Get enumerated values variant"]
606    #[inline(always)]
607    pub fn variant(&self) -> CH7_A {
608        match self.bits {
609            0 => CH7_A::DISABLE,
610            1 => CH7_A::HIGH,
611            2 => CH7_A::LOW,
612            3 => CH7_A::DAC,
613            _ => unreachable!(),
614        }
615    }
616    #[doc = "Checks if the value of the field is `DISABLE`"]
617    #[inline(always)]
618    pub fn is_disable(&self) -> bool {
619        *self == CH7_A::DISABLE
620    }
621    #[doc = "Checks if the value of the field is `HIGH`"]
622    #[inline(always)]
623    pub fn is_high(&self) -> bool {
624        *self == CH7_A::HIGH
625    }
626    #[doc = "Checks if the value of the field is `LOW`"]
627    #[inline(always)]
628    pub fn is_low(&self) -> bool {
629        *self == CH7_A::LOW
630    }
631    #[doc = "Checks if the value of the field is `DAC`"]
632    #[inline(always)]
633    pub fn is_dac(&self) -> bool {
634        *self == CH7_A::DAC
635    }
636}
637#[doc = "Field `CH7` writer - Channel 7 Idle Phase Configuration"]
638pub type CH7_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH7_A, 2, O>;
639impl<'a, const O: u8> CH7_W<'a, O> {
640    #[doc = "CH7 output is disabled in idle phase"]
641    #[inline(always)]
642    pub fn disable(self) -> &'a mut W {
643        self.variant(CH7_A::DISABLE)
644    }
645    #[doc = "CH7 output is high in idle phase"]
646    #[inline(always)]
647    pub fn high(self) -> &'a mut W {
648        self.variant(CH7_A::HIGH)
649    }
650    #[doc = "CH7 output is low in idle phase"]
651    #[inline(always)]
652    pub fn low(self) -> &'a mut W {
653        self.variant(CH7_A::LOW)
654    }
655    #[doc = "CH7 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
656    #[inline(always)]
657    pub fn dac(self) -> &'a mut W {
658        self.variant(CH7_A::DAC)
659    }
660}
661#[doc = "Field `CH8` reader - Channel 8 Idle Phase Configuration"]
662pub type CH8_R = crate::FieldReader<u8, CH8_A>;
663#[doc = "Channel 8 Idle Phase Configuration\n\nValue on reset: 0"]
664#[derive(Clone, Copy, Debug, PartialEq, Eq)]
665#[repr(u8)]
666pub enum CH8_A {
667    #[doc = "0: CH8 output is disabled in idle phase"]
668    DISABLE = 0,
669    #[doc = "1: CH8 output is high in idle phase"]
670    HIGH = 1,
671    #[doc = "2: CH8 output is low in idle phase"]
672    LOW = 2,
673    #[doc = "3: CH8 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
674    DAC = 3,
675}
676impl From<CH8_A> for u8 {
677    #[inline(always)]
678    fn from(variant: CH8_A) -> Self {
679        variant as _
680    }
681}
682impl CH8_R {
683    #[doc = "Get enumerated values variant"]
684    #[inline(always)]
685    pub fn variant(&self) -> CH8_A {
686        match self.bits {
687            0 => CH8_A::DISABLE,
688            1 => CH8_A::HIGH,
689            2 => CH8_A::LOW,
690            3 => CH8_A::DAC,
691            _ => unreachable!(),
692        }
693    }
694    #[doc = "Checks if the value of the field is `DISABLE`"]
695    #[inline(always)]
696    pub fn is_disable(&self) -> bool {
697        *self == CH8_A::DISABLE
698    }
699    #[doc = "Checks if the value of the field is `HIGH`"]
700    #[inline(always)]
701    pub fn is_high(&self) -> bool {
702        *self == CH8_A::HIGH
703    }
704    #[doc = "Checks if the value of the field is `LOW`"]
705    #[inline(always)]
706    pub fn is_low(&self) -> bool {
707        *self == CH8_A::LOW
708    }
709    #[doc = "Checks if the value of the field is `DAC`"]
710    #[inline(always)]
711    pub fn is_dac(&self) -> bool {
712        *self == CH8_A::DAC
713    }
714}
715#[doc = "Field `CH8` writer - Channel 8 Idle Phase Configuration"]
716pub type CH8_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH8_A, 2, O>;
717impl<'a, const O: u8> CH8_W<'a, O> {
718    #[doc = "CH8 output is disabled in idle phase"]
719    #[inline(always)]
720    pub fn disable(self) -> &'a mut W {
721        self.variant(CH8_A::DISABLE)
722    }
723    #[doc = "CH8 output is high in idle phase"]
724    #[inline(always)]
725    pub fn high(self) -> &'a mut W {
726        self.variant(CH8_A::HIGH)
727    }
728    #[doc = "CH8 output is low in idle phase"]
729    #[inline(always)]
730    pub fn low(self) -> &'a mut W {
731        self.variant(CH8_A::LOW)
732    }
733    #[doc = "CH8 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
734    #[inline(always)]
735    pub fn dac(self) -> &'a mut W {
736        self.variant(CH8_A::DAC)
737    }
738}
739#[doc = "Field `CH9` reader - Channel 9 Idle Phase Configuration"]
740pub type CH9_R = crate::FieldReader<u8, CH9_A>;
741#[doc = "Channel 9 Idle Phase Configuration\n\nValue on reset: 0"]
742#[derive(Clone, Copy, Debug, PartialEq, Eq)]
743#[repr(u8)]
744pub enum CH9_A {
745    #[doc = "0: CH9 output is disabled in idle phase"]
746    DISABLE = 0,
747    #[doc = "1: CH9 output is high in idle phase"]
748    HIGH = 1,
749    #[doc = "2: CH9 output is low in idle phase"]
750    LOW = 2,
751    #[doc = "3: CH9 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
752    DAC = 3,
753}
754impl From<CH9_A> for u8 {
755    #[inline(always)]
756    fn from(variant: CH9_A) -> Self {
757        variant as _
758    }
759}
760impl CH9_R {
761    #[doc = "Get enumerated values variant"]
762    #[inline(always)]
763    pub fn variant(&self) -> CH9_A {
764        match self.bits {
765            0 => CH9_A::DISABLE,
766            1 => CH9_A::HIGH,
767            2 => CH9_A::LOW,
768            3 => CH9_A::DAC,
769            _ => unreachable!(),
770        }
771    }
772    #[doc = "Checks if the value of the field is `DISABLE`"]
773    #[inline(always)]
774    pub fn is_disable(&self) -> bool {
775        *self == CH9_A::DISABLE
776    }
777    #[doc = "Checks if the value of the field is `HIGH`"]
778    #[inline(always)]
779    pub fn is_high(&self) -> bool {
780        *self == CH9_A::HIGH
781    }
782    #[doc = "Checks if the value of the field is `LOW`"]
783    #[inline(always)]
784    pub fn is_low(&self) -> bool {
785        *self == CH9_A::LOW
786    }
787    #[doc = "Checks if the value of the field is `DAC`"]
788    #[inline(always)]
789    pub fn is_dac(&self) -> bool {
790        *self == CH9_A::DAC
791    }
792}
793#[doc = "Field `CH9` writer - Channel 9 Idle Phase Configuration"]
794pub type CH9_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH9_A, 2, O>;
795impl<'a, const O: u8> CH9_W<'a, O> {
796    #[doc = "CH9 output is disabled in idle phase"]
797    #[inline(always)]
798    pub fn disable(self) -> &'a mut W {
799        self.variant(CH9_A::DISABLE)
800    }
801    #[doc = "CH9 output is high in idle phase"]
802    #[inline(always)]
803    pub fn high(self) -> &'a mut W {
804        self.variant(CH9_A::HIGH)
805    }
806    #[doc = "CH9 output is low in idle phase"]
807    #[inline(always)]
808    pub fn low(self) -> &'a mut W {
809        self.variant(CH9_A::LOW)
810    }
811    #[doc = "CH9 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
812    #[inline(always)]
813    pub fn dac(self) -> &'a mut W {
814        self.variant(CH9_A::DAC)
815    }
816}
817#[doc = "Field `CH10` reader - Channel 10 Idle Phase Configuration"]
818pub type CH10_R = crate::FieldReader<u8, CH10_A>;
819#[doc = "Channel 10 Idle Phase Configuration\n\nValue on reset: 0"]
820#[derive(Clone, Copy, Debug, PartialEq, Eq)]
821#[repr(u8)]
822pub enum CH10_A {
823    #[doc = "0: CH10 output is disabled in idle phase"]
824    DISABLE = 0,
825    #[doc = "1: CH10 output is high in idle phase"]
826    HIGH = 1,
827    #[doc = "2: CH10 output is low in idle phase"]
828    LOW = 2,
829    #[doc = "3: CH10 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
830    DAC = 3,
831}
832impl From<CH10_A> for u8 {
833    #[inline(always)]
834    fn from(variant: CH10_A) -> Self {
835        variant as _
836    }
837}
838impl CH10_R {
839    #[doc = "Get enumerated values variant"]
840    #[inline(always)]
841    pub fn variant(&self) -> CH10_A {
842        match self.bits {
843            0 => CH10_A::DISABLE,
844            1 => CH10_A::HIGH,
845            2 => CH10_A::LOW,
846            3 => CH10_A::DAC,
847            _ => unreachable!(),
848        }
849    }
850    #[doc = "Checks if the value of the field is `DISABLE`"]
851    #[inline(always)]
852    pub fn is_disable(&self) -> bool {
853        *self == CH10_A::DISABLE
854    }
855    #[doc = "Checks if the value of the field is `HIGH`"]
856    #[inline(always)]
857    pub fn is_high(&self) -> bool {
858        *self == CH10_A::HIGH
859    }
860    #[doc = "Checks if the value of the field is `LOW`"]
861    #[inline(always)]
862    pub fn is_low(&self) -> bool {
863        *self == CH10_A::LOW
864    }
865    #[doc = "Checks if the value of the field is `DAC`"]
866    #[inline(always)]
867    pub fn is_dac(&self) -> bool {
868        *self == CH10_A::DAC
869    }
870}
871#[doc = "Field `CH10` writer - Channel 10 Idle Phase Configuration"]
872pub type CH10_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH10_A, 2, O>;
873impl<'a, const O: u8> CH10_W<'a, O> {
874    #[doc = "CH10 output is disabled in idle phase"]
875    #[inline(always)]
876    pub fn disable(self) -> &'a mut W {
877        self.variant(CH10_A::DISABLE)
878    }
879    #[doc = "CH10 output is high in idle phase"]
880    #[inline(always)]
881    pub fn high(self) -> &'a mut W {
882        self.variant(CH10_A::HIGH)
883    }
884    #[doc = "CH10 output is low in idle phase"]
885    #[inline(always)]
886    pub fn low(self) -> &'a mut W {
887        self.variant(CH10_A::LOW)
888    }
889    #[doc = "CH10 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
890    #[inline(always)]
891    pub fn dac(self) -> &'a mut W {
892        self.variant(CH10_A::DAC)
893    }
894}
895#[doc = "Field `CH11` reader - Channel 11 Idle Phase Configuration"]
896pub type CH11_R = crate::FieldReader<u8, CH11_A>;
897#[doc = "Channel 11 Idle Phase Configuration\n\nValue on reset: 0"]
898#[derive(Clone, Copy, Debug, PartialEq, Eq)]
899#[repr(u8)]
900pub enum CH11_A {
901    #[doc = "0: CH11 output is disabled in idle phase"]
902    DISABLE = 0,
903    #[doc = "1: CH11 output is high in idle phase"]
904    HIGH = 1,
905    #[doc = "2: CH11 output is low in idle phase"]
906    LOW = 2,
907    #[doc = "3: CH11 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
908    DAC = 3,
909}
910impl From<CH11_A> for u8 {
911    #[inline(always)]
912    fn from(variant: CH11_A) -> Self {
913        variant as _
914    }
915}
916impl CH11_R {
917    #[doc = "Get enumerated values variant"]
918    #[inline(always)]
919    pub fn variant(&self) -> CH11_A {
920        match self.bits {
921            0 => CH11_A::DISABLE,
922            1 => CH11_A::HIGH,
923            2 => CH11_A::LOW,
924            3 => CH11_A::DAC,
925            _ => unreachable!(),
926        }
927    }
928    #[doc = "Checks if the value of the field is `DISABLE`"]
929    #[inline(always)]
930    pub fn is_disable(&self) -> bool {
931        *self == CH11_A::DISABLE
932    }
933    #[doc = "Checks if the value of the field is `HIGH`"]
934    #[inline(always)]
935    pub fn is_high(&self) -> bool {
936        *self == CH11_A::HIGH
937    }
938    #[doc = "Checks if the value of the field is `LOW`"]
939    #[inline(always)]
940    pub fn is_low(&self) -> bool {
941        *self == CH11_A::LOW
942    }
943    #[doc = "Checks if the value of the field is `DAC`"]
944    #[inline(always)]
945    pub fn is_dac(&self) -> bool {
946        *self == CH11_A::DAC
947    }
948}
949#[doc = "Field `CH11` writer - Channel 11 Idle Phase Configuration"]
950pub type CH11_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH11_A, 2, O>;
951impl<'a, const O: u8> CH11_W<'a, O> {
952    #[doc = "CH11 output is disabled in idle phase"]
953    #[inline(always)]
954    pub fn disable(self) -> &'a mut W {
955        self.variant(CH11_A::DISABLE)
956    }
957    #[doc = "CH11 output is high in idle phase"]
958    #[inline(always)]
959    pub fn high(self) -> &'a mut W {
960        self.variant(CH11_A::HIGH)
961    }
962    #[doc = "CH11 output is low in idle phase"]
963    #[inline(always)]
964    pub fn low(self) -> &'a mut W {
965        self.variant(CH11_A::LOW)
966    }
967    #[doc = "CH11 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
968    #[inline(always)]
969    pub fn dac(self) -> &'a mut W {
970        self.variant(CH11_A::DAC)
971    }
972}
973#[doc = "Field `CH12` reader - Channel 12 Idle Phase Configuration"]
974pub type CH12_R = crate::FieldReader<u8, CH12_A>;
975#[doc = "Channel 12 Idle Phase Configuration\n\nValue on reset: 0"]
976#[derive(Clone, Copy, Debug, PartialEq, Eq)]
977#[repr(u8)]
978pub enum CH12_A {
979    #[doc = "0: CH12 output is disabled in idle phase"]
980    DISABLE = 0,
981    #[doc = "1: CH12 output is high in idle phase"]
982    HIGH = 1,
983    #[doc = "2: CH12 output is low in idle phase"]
984    LOW = 2,
985    #[doc = "3: CH12 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
986    DAC = 3,
987}
988impl From<CH12_A> for u8 {
989    #[inline(always)]
990    fn from(variant: CH12_A) -> Self {
991        variant as _
992    }
993}
994impl CH12_R {
995    #[doc = "Get enumerated values variant"]
996    #[inline(always)]
997    pub fn variant(&self) -> CH12_A {
998        match self.bits {
999            0 => CH12_A::DISABLE,
1000            1 => CH12_A::HIGH,
1001            2 => CH12_A::LOW,
1002            3 => CH12_A::DAC,
1003            _ => unreachable!(),
1004        }
1005    }
1006    #[doc = "Checks if the value of the field is `DISABLE`"]
1007    #[inline(always)]
1008    pub fn is_disable(&self) -> bool {
1009        *self == CH12_A::DISABLE
1010    }
1011    #[doc = "Checks if the value of the field is `HIGH`"]
1012    #[inline(always)]
1013    pub fn is_high(&self) -> bool {
1014        *self == CH12_A::HIGH
1015    }
1016    #[doc = "Checks if the value of the field is `LOW`"]
1017    #[inline(always)]
1018    pub fn is_low(&self) -> bool {
1019        *self == CH12_A::LOW
1020    }
1021    #[doc = "Checks if the value of the field is `DAC`"]
1022    #[inline(always)]
1023    pub fn is_dac(&self) -> bool {
1024        *self == CH12_A::DAC
1025    }
1026}
1027#[doc = "Field `CH12` writer - Channel 12 Idle Phase Configuration"]
1028pub type CH12_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH12_A, 2, O>;
1029impl<'a, const O: u8> CH12_W<'a, O> {
1030    #[doc = "CH12 output is disabled in idle phase"]
1031    #[inline(always)]
1032    pub fn disable(self) -> &'a mut W {
1033        self.variant(CH12_A::DISABLE)
1034    }
1035    #[doc = "CH12 output is high in idle phase"]
1036    #[inline(always)]
1037    pub fn high(self) -> &'a mut W {
1038        self.variant(CH12_A::HIGH)
1039    }
1040    #[doc = "CH12 output is low in idle phase"]
1041    #[inline(always)]
1042    pub fn low(self) -> &'a mut W {
1043        self.variant(CH12_A::LOW)
1044    }
1045    #[doc = "CH12 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1046    #[inline(always)]
1047    pub fn dac(self) -> &'a mut W {
1048        self.variant(CH12_A::DAC)
1049    }
1050}
1051#[doc = "Field `CH13` reader - Channel 13 Idle Phase Configuration"]
1052pub type CH13_R = crate::FieldReader<u8, CH13_A>;
1053#[doc = "Channel 13 Idle Phase Configuration\n\nValue on reset: 0"]
1054#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1055#[repr(u8)]
1056pub enum CH13_A {
1057    #[doc = "0: CH13 output is disabled in idle phase"]
1058    DISABLE = 0,
1059    #[doc = "1: CH13 output is high in idle phase"]
1060    HIGH = 1,
1061    #[doc = "2: CH13 output is low in idle phase"]
1062    LOW = 2,
1063    #[doc = "3: CH13 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1064    DAC = 3,
1065}
1066impl From<CH13_A> for u8 {
1067    #[inline(always)]
1068    fn from(variant: CH13_A) -> Self {
1069        variant as _
1070    }
1071}
1072impl CH13_R {
1073    #[doc = "Get enumerated values variant"]
1074    #[inline(always)]
1075    pub fn variant(&self) -> CH13_A {
1076        match self.bits {
1077            0 => CH13_A::DISABLE,
1078            1 => CH13_A::HIGH,
1079            2 => CH13_A::LOW,
1080            3 => CH13_A::DAC,
1081            _ => unreachable!(),
1082        }
1083    }
1084    #[doc = "Checks if the value of the field is `DISABLE`"]
1085    #[inline(always)]
1086    pub fn is_disable(&self) -> bool {
1087        *self == CH13_A::DISABLE
1088    }
1089    #[doc = "Checks if the value of the field is `HIGH`"]
1090    #[inline(always)]
1091    pub fn is_high(&self) -> bool {
1092        *self == CH13_A::HIGH
1093    }
1094    #[doc = "Checks if the value of the field is `LOW`"]
1095    #[inline(always)]
1096    pub fn is_low(&self) -> bool {
1097        *self == CH13_A::LOW
1098    }
1099    #[doc = "Checks if the value of the field is `DAC`"]
1100    #[inline(always)]
1101    pub fn is_dac(&self) -> bool {
1102        *self == CH13_A::DAC
1103    }
1104}
1105#[doc = "Field `CH13` writer - Channel 13 Idle Phase Configuration"]
1106pub type CH13_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH13_A, 2, O>;
1107impl<'a, const O: u8> CH13_W<'a, O> {
1108    #[doc = "CH13 output is disabled in idle phase"]
1109    #[inline(always)]
1110    pub fn disable(self) -> &'a mut W {
1111        self.variant(CH13_A::DISABLE)
1112    }
1113    #[doc = "CH13 output is high in idle phase"]
1114    #[inline(always)]
1115    pub fn high(self) -> &'a mut W {
1116        self.variant(CH13_A::HIGH)
1117    }
1118    #[doc = "CH13 output is low in idle phase"]
1119    #[inline(always)]
1120    pub fn low(self) -> &'a mut W {
1121        self.variant(CH13_A::LOW)
1122    }
1123    #[doc = "CH13 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1124    #[inline(always)]
1125    pub fn dac(self) -> &'a mut W {
1126        self.variant(CH13_A::DAC)
1127    }
1128}
1129#[doc = "Field `CH14` reader - Channel 14 Idle Phase Configuration"]
1130pub type CH14_R = crate::FieldReader<u8, CH14_A>;
1131#[doc = "Channel 14 Idle Phase Configuration\n\nValue on reset: 0"]
1132#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1133#[repr(u8)]
1134pub enum CH14_A {
1135    #[doc = "0: CH14 output is disabled in idle phase"]
1136    DISABLE = 0,
1137    #[doc = "1: CH14 output is high in idle phase"]
1138    HIGH = 1,
1139    #[doc = "2: CH14 output is low in idle phase"]
1140    LOW = 2,
1141    #[doc = "3: CH14 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1142    DAC = 3,
1143}
1144impl From<CH14_A> for u8 {
1145    #[inline(always)]
1146    fn from(variant: CH14_A) -> Self {
1147        variant as _
1148    }
1149}
1150impl CH14_R {
1151    #[doc = "Get enumerated values variant"]
1152    #[inline(always)]
1153    pub fn variant(&self) -> CH14_A {
1154        match self.bits {
1155            0 => CH14_A::DISABLE,
1156            1 => CH14_A::HIGH,
1157            2 => CH14_A::LOW,
1158            3 => CH14_A::DAC,
1159            _ => unreachable!(),
1160        }
1161    }
1162    #[doc = "Checks if the value of the field is `DISABLE`"]
1163    #[inline(always)]
1164    pub fn is_disable(&self) -> bool {
1165        *self == CH14_A::DISABLE
1166    }
1167    #[doc = "Checks if the value of the field is `HIGH`"]
1168    #[inline(always)]
1169    pub fn is_high(&self) -> bool {
1170        *self == CH14_A::HIGH
1171    }
1172    #[doc = "Checks if the value of the field is `LOW`"]
1173    #[inline(always)]
1174    pub fn is_low(&self) -> bool {
1175        *self == CH14_A::LOW
1176    }
1177    #[doc = "Checks if the value of the field is `DAC`"]
1178    #[inline(always)]
1179    pub fn is_dac(&self) -> bool {
1180        *self == CH14_A::DAC
1181    }
1182}
1183#[doc = "Field `CH14` writer - Channel 14 Idle Phase Configuration"]
1184pub type CH14_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH14_A, 2, O>;
1185impl<'a, const O: u8> CH14_W<'a, O> {
1186    #[doc = "CH14 output is disabled in idle phase"]
1187    #[inline(always)]
1188    pub fn disable(self) -> &'a mut W {
1189        self.variant(CH14_A::DISABLE)
1190    }
1191    #[doc = "CH14 output is high in idle phase"]
1192    #[inline(always)]
1193    pub fn high(self) -> &'a mut W {
1194        self.variant(CH14_A::HIGH)
1195    }
1196    #[doc = "CH14 output is low in idle phase"]
1197    #[inline(always)]
1198    pub fn low(self) -> &'a mut W {
1199        self.variant(CH14_A::LOW)
1200    }
1201    #[doc = "CH14 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1202    #[inline(always)]
1203    pub fn dac(self) -> &'a mut W {
1204        self.variant(CH14_A::DAC)
1205    }
1206}
1207#[doc = "Field `CH15` reader - Channel 15 Idle Phase Configuration"]
1208pub type CH15_R = crate::FieldReader<u8, CH15_A>;
1209#[doc = "Channel 15 Idle Phase Configuration\n\nValue on reset: 0"]
1210#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1211#[repr(u8)]
1212pub enum CH15_A {
1213    #[doc = "0: CH15 output is disabled in idle phase"]
1214    DISABLE = 0,
1215    #[doc = "1: CH15 output is high in idle phase"]
1216    HIGH = 1,
1217    #[doc = "2: CH15 output is low in idle phase"]
1218    LOW = 2,
1219    #[doc = "3: CH15 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1220    DAC = 3,
1221}
1222impl From<CH15_A> for u8 {
1223    #[inline(always)]
1224    fn from(variant: CH15_A) -> Self {
1225        variant as _
1226    }
1227}
1228impl CH15_R {
1229    #[doc = "Get enumerated values variant"]
1230    #[inline(always)]
1231    pub fn variant(&self) -> CH15_A {
1232        match self.bits {
1233            0 => CH15_A::DISABLE,
1234            1 => CH15_A::HIGH,
1235            2 => CH15_A::LOW,
1236            3 => CH15_A::DAC,
1237            _ => unreachable!(),
1238        }
1239    }
1240    #[doc = "Checks if the value of the field is `DISABLE`"]
1241    #[inline(always)]
1242    pub fn is_disable(&self) -> bool {
1243        *self == CH15_A::DISABLE
1244    }
1245    #[doc = "Checks if the value of the field is `HIGH`"]
1246    #[inline(always)]
1247    pub fn is_high(&self) -> bool {
1248        *self == CH15_A::HIGH
1249    }
1250    #[doc = "Checks if the value of the field is `LOW`"]
1251    #[inline(always)]
1252    pub fn is_low(&self) -> bool {
1253        *self == CH15_A::LOW
1254    }
1255    #[doc = "Checks if the value of the field is `DAC`"]
1256    #[inline(always)]
1257    pub fn is_dac(&self) -> bool {
1258        *self == CH15_A::DAC
1259    }
1260}
1261#[doc = "Field `CH15` writer - Channel 15 Idle Phase Configuration"]
1262pub type CH15_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, IDLECONF_SPEC, u8, CH15_A, 2, O>;
1263impl<'a, const O: u8> CH15_W<'a, O> {
1264    #[doc = "CH15 output is disabled in idle phase"]
1265    #[inline(always)]
1266    pub fn disable(self) -> &'a mut W {
1267        self.variant(CH15_A::DISABLE)
1268    }
1269    #[doc = "CH15 output is high in idle phase"]
1270    #[inline(always)]
1271    pub fn high(self) -> &'a mut W {
1272        self.variant(CH15_A::HIGH)
1273    }
1274    #[doc = "CH15 output is low in idle phase"]
1275    #[inline(always)]
1276    pub fn low(self) -> &'a mut W {
1277        self.variant(CH15_A::LOW)
1278    }
1279    #[doc = "CH15 output is connected to VDAC output in idle phase. Note that this mode is only available on channels 0, 1, 2, 3, 12, 13, 14, 15"]
1280    #[inline(always)]
1281    pub fn dac(self) -> &'a mut W {
1282        self.variant(CH15_A::DAC)
1283    }
1284}
1285impl R {
1286    #[doc = "Bits 0:1 - Channel 0 Idle Phase Configuration"]
1287    #[inline(always)]
1288    pub fn ch0(&self) -> CH0_R {
1289        CH0_R::new((self.bits & 3) as u8)
1290    }
1291    #[doc = "Bits 2:3 - Channel 1 Idle Phase Configuration"]
1292    #[inline(always)]
1293    pub fn ch1(&self) -> CH1_R {
1294        CH1_R::new(((self.bits >> 2) & 3) as u8)
1295    }
1296    #[doc = "Bits 4:5 - Channel 2 Idle Phase Configuration"]
1297    #[inline(always)]
1298    pub fn ch2(&self) -> CH2_R {
1299        CH2_R::new(((self.bits >> 4) & 3) as u8)
1300    }
1301    #[doc = "Bits 6:7 - Channel 3 Idle Phase Configuration"]
1302    #[inline(always)]
1303    pub fn ch3(&self) -> CH3_R {
1304        CH3_R::new(((self.bits >> 6) & 3) as u8)
1305    }
1306    #[doc = "Bits 8:9 - Channel 4 Idle Phase Configuration"]
1307    #[inline(always)]
1308    pub fn ch4(&self) -> CH4_R {
1309        CH4_R::new(((self.bits >> 8) & 3) as u8)
1310    }
1311    #[doc = "Bits 10:11 - Channel 5 Idle Phase Configuration"]
1312    #[inline(always)]
1313    pub fn ch5(&self) -> CH5_R {
1314        CH5_R::new(((self.bits >> 10) & 3) as u8)
1315    }
1316    #[doc = "Bits 12:13 - Channel 6 Idle Phase Configuration"]
1317    #[inline(always)]
1318    pub fn ch6(&self) -> CH6_R {
1319        CH6_R::new(((self.bits >> 12) & 3) as u8)
1320    }
1321    #[doc = "Bits 14:15 - Channel 7 Idle Phase Configuration"]
1322    #[inline(always)]
1323    pub fn ch7(&self) -> CH7_R {
1324        CH7_R::new(((self.bits >> 14) & 3) as u8)
1325    }
1326    #[doc = "Bits 16:17 - Channel 8 Idle Phase Configuration"]
1327    #[inline(always)]
1328    pub fn ch8(&self) -> CH8_R {
1329        CH8_R::new(((self.bits >> 16) & 3) as u8)
1330    }
1331    #[doc = "Bits 18:19 - Channel 9 Idle Phase Configuration"]
1332    #[inline(always)]
1333    pub fn ch9(&self) -> CH9_R {
1334        CH9_R::new(((self.bits >> 18) & 3) as u8)
1335    }
1336    #[doc = "Bits 20:21 - Channel 10 Idle Phase Configuration"]
1337    #[inline(always)]
1338    pub fn ch10(&self) -> CH10_R {
1339        CH10_R::new(((self.bits >> 20) & 3) as u8)
1340    }
1341    #[doc = "Bits 22:23 - Channel 11 Idle Phase Configuration"]
1342    #[inline(always)]
1343    pub fn ch11(&self) -> CH11_R {
1344        CH11_R::new(((self.bits >> 22) & 3) as u8)
1345    }
1346    #[doc = "Bits 24:25 - Channel 12 Idle Phase Configuration"]
1347    #[inline(always)]
1348    pub fn ch12(&self) -> CH12_R {
1349        CH12_R::new(((self.bits >> 24) & 3) as u8)
1350    }
1351    #[doc = "Bits 26:27 - Channel 13 Idle Phase Configuration"]
1352    #[inline(always)]
1353    pub fn ch13(&self) -> CH13_R {
1354        CH13_R::new(((self.bits >> 26) & 3) as u8)
1355    }
1356    #[doc = "Bits 28:29 - Channel 14 Idle Phase Configuration"]
1357    #[inline(always)]
1358    pub fn ch14(&self) -> CH14_R {
1359        CH14_R::new(((self.bits >> 28) & 3) as u8)
1360    }
1361    #[doc = "Bits 30:31 - Channel 15 Idle Phase Configuration"]
1362    #[inline(always)]
1363    pub fn ch15(&self) -> CH15_R {
1364        CH15_R::new(((self.bits >> 30) & 3) as u8)
1365    }
1366}
1367impl W {
1368    #[doc = "Bits 0:1 - Channel 0 Idle Phase Configuration"]
1369    #[inline(always)]
1370    #[must_use]
1371    pub fn ch0(&mut self) -> CH0_W<0> {
1372        CH0_W::new(self)
1373    }
1374    #[doc = "Bits 2:3 - Channel 1 Idle Phase Configuration"]
1375    #[inline(always)]
1376    #[must_use]
1377    pub fn ch1(&mut self) -> CH1_W<2> {
1378        CH1_W::new(self)
1379    }
1380    #[doc = "Bits 4:5 - Channel 2 Idle Phase Configuration"]
1381    #[inline(always)]
1382    #[must_use]
1383    pub fn ch2(&mut self) -> CH2_W<4> {
1384        CH2_W::new(self)
1385    }
1386    #[doc = "Bits 6:7 - Channel 3 Idle Phase Configuration"]
1387    #[inline(always)]
1388    #[must_use]
1389    pub fn ch3(&mut self) -> CH3_W<6> {
1390        CH3_W::new(self)
1391    }
1392    #[doc = "Bits 8:9 - Channel 4 Idle Phase Configuration"]
1393    #[inline(always)]
1394    #[must_use]
1395    pub fn ch4(&mut self) -> CH4_W<8> {
1396        CH4_W::new(self)
1397    }
1398    #[doc = "Bits 10:11 - Channel 5 Idle Phase Configuration"]
1399    #[inline(always)]
1400    #[must_use]
1401    pub fn ch5(&mut self) -> CH5_W<10> {
1402        CH5_W::new(self)
1403    }
1404    #[doc = "Bits 12:13 - Channel 6 Idle Phase Configuration"]
1405    #[inline(always)]
1406    #[must_use]
1407    pub fn ch6(&mut self) -> CH6_W<12> {
1408        CH6_W::new(self)
1409    }
1410    #[doc = "Bits 14:15 - Channel 7 Idle Phase Configuration"]
1411    #[inline(always)]
1412    #[must_use]
1413    pub fn ch7(&mut self) -> CH7_W<14> {
1414        CH7_W::new(self)
1415    }
1416    #[doc = "Bits 16:17 - Channel 8 Idle Phase Configuration"]
1417    #[inline(always)]
1418    #[must_use]
1419    pub fn ch8(&mut self) -> CH8_W<16> {
1420        CH8_W::new(self)
1421    }
1422    #[doc = "Bits 18:19 - Channel 9 Idle Phase Configuration"]
1423    #[inline(always)]
1424    #[must_use]
1425    pub fn ch9(&mut self) -> CH9_W<18> {
1426        CH9_W::new(self)
1427    }
1428    #[doc = "Bits 20:21 - Channel 10 Idle Phase Configuration"]
1429    #[inline(always)]
1430    #[must_use]
1431    pub fn ch10(&mut self) -> CH10_W<20> {
1432        CH10_W::new(self)
1433    }
1434    #[doc = "Bits 22:23 - Channel 11 Idle Phase Configuration"]
1435    #[inline(always)]
1436    #[must_use]
1437    pub fn ch11(&mut self) -> CH11_W<22> {
1438        CH11_W::new(self)
1439    }
1440    #[doc = "Bits 24:25 - Channel 12 Idle Phase Configuration"]
1441    #[inline(always)]
1442    #[must_use]
1443    pub fn ch12(&mut self) -> CH12_W<24> {
1444        CH12_W::new(self)
1445    }
1446    #[doc = "Bits 26:27 - Channel 13 Idle Phase Configuration"]
1447    #[inline(always)]
1448    #[must_use]
1449    pub fn ch13(&mut self) -> CH13_W<26> {
1450        CH13_W::new(self)
1451    }
1452    #[doc = "Bits 28:29 - Channel 14 Idle Phase Configuration"]
1453    #[inline(always)]
1454    #[must_use]
1455    pub fn ch14(&mut self) -> CH14_W<28> {
1456        CH14_W::new(self)
1457    }
1458    #[doc = "Bits 30:31 - Channel 15 Idle Phase Configuration"]
1459    #[inline(always)]
1460    #[must_use]
1461    pub fn ch15(&mut self) -> CH15_W<30> {
1462        CH15_W::new(self)
1463    }
1464    #[doc = "Writes raw bits to the register."]
1465    #[inline(always)]
1466    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1467        self.0.bits(bits);
1468        self
1469    }
1470}
1471#[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"]
1472pub struct IDLECONF_SPEC;
1473impl crate::RegisterSpec for IDLECONF_SPEC {
1474    type Ux = u32;
1475}
1476#[doc = "`read()` method returns [idleconf::R](R) reader structure"]
1477impl crate::Readable for IDLECONF_SPEC {
1478    type Reader = R;
1479}
1480#[doc = "`write(|w| ..)` method takes [idleconf::W](W) writer structure"]
1481impl crate::Writable for IDLECONF_SPEC {
1482    type Writer = W;
1483    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1484    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1485}
1486#[doc = "`reset()` method sets IDLECONF to value 0"]
1487impl crate::Resettable for IDLECONF_SPEC {
1488    const RESET_VALUE: Self::Ux = 0;
1489}
efm32gg12b_pac/efm32gg12b830/lesense/idleconf.rs

efm32gg12b_pac/efm32gg12b830/lesense/
idleconf.rs
