nrf52840_pac/saadc/
intenset.rs

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

nrf52840_pac/saadc/
intenset.rs
