nrf52840_pac/saadc/
inten.rs

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

nrf52840_pac/saadc/
inten.rs
