nrf52840_pac/egu0/
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 `TRIGGERED0` reader - Enable or disable interrupt for TRIGGERED\\[0\\]
38event"]
39pub type TRIGGERED0_R = crate::BitReader<TRIGGERED0_A>;
40#[doc = "Enable or disable interrupt for TRIGGERED\\[0\\]
41event\n\nValue on reset: 0"]
42#[derive(Clone, Copy, Debug, PartialEq)]
43pub enum TRIGGERED0_A {
44    #[doc = "0: Disable"]
45    DISABLED = 0,
46    #[doc = "1: Enable"]
47    ENABLED = 1,
48}
49impl From<TRIGGERED0_A> for bool {
50    #[inline(always)]
51    fn from(variant: TRIGGERED0_A) -> Self {
52        variant as u8 != 0
53    }
54}
55impl TRIGGERED0_R {
56    #[doc = "Get enumerated values variant"]
57    #[inline(always)]
58    pub fn variant(&self) -> TRIGGERED0_A {
59        match self.bits {
60            false => TRIGGERED0_A::DISABLED,
61            true => TRIGGERED0_A::ENABLED,
62        }
63    }
64    #[doc = "Checks if the value of the field is `DISABLED`"]
65    #[inline(always)]
66    pub fn is_disabled(&self) -> bool {
67        *self == TRIGGERED0_A::DISABLED
68    }
69    #[doc = "Checks if the value of the field is `ENABLED`"]
70    #[inline(always)]
71    pub fn is_enabled(&self) -> bool {
72        *self == TRIGGERED0_A::ENABLED
73    }
74}
75#[doc = "Field `TRIGGERED0` writer - Enable or disable interrupt for TRIGGERED\\[0\\]
76event"]
77pub type TRIGGERED0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED0_A, O>;
78impl<'a, const O: u8> TRIGGERED0_W<'a, O> {
79    #[doc = "Disable"]
80    #[inline(always)]
81    pub fn disabled(self) -> &'a mut W {
82        self.variant(TRIGGERED0_A::DISABLED)
83    }
84    #[doc = "Enable"]
85    #[inline(always)]
86    pub fn enabled(self) -> &'a mut W {
87        self.variant(TRIGGERED0_A::ENABLED)
88    }
89}
90#[doc = "Field `TRIGGERED1` reader - Enable or disable interrupt for TRIGGERED\\[1\\]
91event"]
92pub type TRIGGERED1_R = crate::BitReader<TRIGGERED1_A>;
93#[doc = "Enable or disable interrupt for TRIGGERED\\[1\\]
94event\n\nValue on reset: 0"]
95#[derive(Clone, Copy, Debug, PartialEq)]
96pub enum TRIGGERED1_A {
97    #[doc = "0: Disable"]
98    DISABLED = 0,
99    #[doc = "1: Enable"]
100    ENABLED = 1,
101}
102impl From<TRIGGERED1_A> for bool {
103    #[inline(always)]
104    fn from(variant: TRIGGERED1_A) -> Self {
105        variant as u8 != 0
106    }
107}
108impl TRIGGERED1_R {
109    #[doc = "Get enumerated values variant"]
110    #[inline(always)]
111    pub fn variant(&self) -> TRIGGERED1_A {
112        match self.bits {
113            false => TRIGGERED1_A::DISABLED,
114            true => TRIGGERED1_A::ENABLED,
115        }
116    }
117    #[doc = "Checks if the value of the field is `DISABLED`"]
118    #[inline(always)]
119    pub fn is_disabled(&self) -> bool {
120        *self == TRIGGERED1_A::DISABLED
121    }
122    #[doc = "Checks if the value of the field is `ENABLED`"]
123    #[inline(always)]
124    pub fn is_enabled(&self) -> bool {
125        *self == TRIGGERED1_A::ENABLED
126    }
127}
128#[doc = "Field `TRIGGERED1` writer - Enable or disable interrupt for TRIGGERED\\[1\\]
129event"]
130pub type TRIGGERED1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED1_A, O>;
131impl<'a, const O: u8> TRIGGERED1_W<'a, O> {
132    #[doc = "Disable"]
133    #[inline(always)]
134    pub fn disabled(self) -> &'a mut W {
135        self.variant(TRIGGERED1_A::DISABLED)
136    }
137    #[doc = "Enable"]
138    #[inline(always)]
139    pub fn enabled(self) -> &'a mut W {
140        self.variant(TRIGGERED1_A::ENABLED)
141    }
142}
143#[doc = "Field `TRIGGERED2` reader - Enable or disable interrupt for TRIGGERED\\[2\\]
144event"]
145pub type TRIGGERED2_R = crate::BitReader<TRIGGERED2_A>;
146#[doc = "Enable or disable interrupt for TRIGGERED\\[2\\]
147event\n\nValue on reset: 0"]
148#[derive(Clone, Copy, Debug, PartialEq)]
149pub enum TRIGGERED2_A {
150    #[doc = "0: Disable"]
151    DISABLED = 0,
152    #[doc = "1: Enable"]
153    ENABLED = 1,
154}
155impl From<TRIGGERED2_A> for bool {
156    #[inline(always)]
157    fn from(variant: TRIGGERED2_A) -> Self {
158        variant as u8 != 0
159    }
160}
161impl TRIGGERED2_R {
162    #[doc = "Get enumerated values variant"]
163    #[inline(always)]
164    pub fn variant(&self) -> TRIGGERED2_A {
165        match self.bits {
166            false => TRIGGERED2_A::DISABLED,
167            true => TRIGGERED2_A::ENABLED,
168        }
169    }
170    #[doc = "Checks if the value of the field is `DISABLED`"]
171    #[inline(always)]
172    pub fn is_disabled(&self) -> bool {
173        *self == TRIGGERED2_A::DISABLED
174    }
175    #[doc = "Checks if the value of the field is `ENABLED`"]
176    #[inline(always)]
177    pub fn is_enabled(&self) -> bool {
178        *self == TRIGGERED2_A::ENABLED
179    }
180}
181#[doc = "Field `TRIGGERED2` writer - Enable or disable interrupt for TRIGGERED\\[2\\]
182event"]
183pub type TRIGGERED2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED2_A, O>;
184impl<'a, const O: u8> TRIGGERED2_W<'a, O> {
185    #[doc = "Disable"]
186    #[inline(always)]
187    pub fn disabled(self) -> &'a mut W {
188        self.variant(TRIGGERED2_A::DISABLED)
189    }
190    #[doc = "Enable"]
191    #[inline(always)]
192    pub fn enabled(self) -> &'a mut W {
193        self.variant(TRIGGERED2_A::ENABLED)
194    }
195}
196#[doc = "Field `TRIGGERED3` reader - Enable or disable interrupt for TRIGGERED\\[3\\]
197event"]
198pub type TRIGGERED3_R = crate::BitReader<TRIGGERED3_A>;
199#[doc = "Enable or disable interrupt for TRIGGERED\\[3\\]
200event\n\nValue on reset: 0"]
201#[derive(Clone, Copy, Debug, PartialEq)]
202pub enum TRIGGERED3_A {
203    #[doc = "0: Disable"]
204    DISABLED = 0,
205    #[doc = "1: Enable"]
206    ENABLED = 1,
207}
208impl From<TRIGGERED3_A> for bool {
209    #[inline(always)]
210    fn from(variant: TRIGGERED3_A) -> Self {
211        variant as u8 != 0
212    }
213}
214impl TRIGGERED3_R {
215    #[doc = "Get enumerated values variant"]
216    #[inline(always)]
217    pub fn variant(&self) -> TRIGGERED3_A {
218        match self.bits {
219            false => TRIGGERED3_A::DISABLED,
220            true => TRIGGERED3_A::ENABLED,
221        }
222    }
223    #[doc = "Checks if the value of the field is `DISABLED`"]
224    #[inline(always)]
225    pub fn is_disabled(&self) -> bool {
226        *self == TRIGGERED3_A::DISABLED
227    }
228    #[doc = "Checks if the value of the field is `ENABLED`"]
229    #[inline(always)]
230    pub fn is_enabled(&self) -> bool {
231        *self == TRIGGERED3_A::ENABLED
232    }
233}
234#[doc = "Field `TRIGGERED3` writer - Enable or disable interrupt for TRIGGERED\\[3\\]
235event"]
236pub type TRIGGERED3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED3_A, O>;
237impl<'a, const O: u8> TRIGGERED3_W<'a, O> {
238    #[doc = "Disable"]
239    #[inline(always)]
240    pub fn disabled(self) -> &'a mut W {
241        self.variant(TRIGGERED3_A::DISABLED)
242    }
243    #[doc = "Enable"]
244    #[inline(always)]
245    pub fn enabled(self) -> &'a mut W {
246        self.variant(TRIGGERED3_A::ENABLED)
247    }
248}
249#[doc = "Field `TRIGGERED4` reader - Enable or disable interrupt for TRIGGERED\\[4\\]
250event"]
251pub type TRIGGERED4_R = crate::BitReader<TRIGGERED4_A>;
252#[doc = "Enable or disable interrupt for TRIGGERED\\[4\\]
253event\n\nValue on reset: 0"]
254#[derive(Clone, Copy, Debug, PartialEq)]
255pub enum TRIGGERED4_A {
256    #[doc = "0: Disable"]
257    DISABLED = 0,
258    #[doc = "1: Enable"]
259    ENABLED = 1,
260}
261impl From<TRIGGERED4_A> for bool {
262    #[inline(always)]
263    fn from(variant: TRIGGERED4_A) -> Self {
264        variant as u8 != 0
265    }
266}
267impl TRIGGERED4_R {
268    #[doc = "Get enumerated values variant"]
269    #[inline(always)]
270    pub fn variant(&self) -> TRIGGERED4_A {
271        match self.bits {
272            false => TRIGGERED4_A::DISABLED,
273            true => TRIGGERED4_A::ENABLED,
274        }
275    }
276    #[doc = "Checks if the value of the field is `DISABLED`"]
277    #[inline(always)]
278    pub fn is_disabled(&self) -> bool {
279        *self == TRIGGERED4_A::DISABLED
280    }
281    #[doc = "Checks if the value of the field is `ENABLED`"]
282    #[inline(always)]
283    pub fn is_enabled(&self) -> bool {
284        *self == TRIGGERED4_A::ENABLED
285    }
286}
287#[doc = "Field `TRIGGERED4` writer - Enable or disable interrupt for TRIGGERED\\[4\\]
288event"]
289pub type TRIGGERED4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED4_A, O>;
290impl<'a, const O: u8> TRIGGERED4_W<'a, O> {
291    #[doc = "Disable"]
292    #[inline(always)]
293    pub fn disabled(self) -> &'a mut W {
294        self.variant(TRIGGERED4_A::DISABLED)
295    }
296    #[doc = "Enable"]
297    #[inline(always)]
298    pub fn enabled(self) -> &'a mut W {
299        self.variant(TRIGGERED4_A::ENABLED)
300    }
301}
302#[doc = "Field `TRIGGERED5` reader - Enable or disable interrupt for TRIGGERED\\[5\\]
303event"]
304pub type TRIGGERED5_R = crate::BitReader<TRIGGERED5_A>;
305#[doc = "Enable or disable interrupt for TRIGGERED\\[5\\]
306event\n\nValue on reset: 0"]
307#[derive(Clone, Copy, Debug, PartialEq)]
308pub enum TRIGGERED5_A {
309    #[doc = "0: Disable"]
310    DISABLED = 0,
311    #[doc = "1: Enable"]
312    ENABLED = 1,
313}
314impl From<TRIGGERED5_A> for bool {
315    #[inline(always)]
316    fn from(variant: TRIGGERED5_A) -> Self {
317        variant as u8 != 0
318    }
319}
320impl TRIGGERED5_R {
321    #[doc = "Get enumerated values variant"]
322    #[inline(always)]
323    pub fn variant(&self) -> TRIGGERED5_A {
324        match self.bits {
325            false => TRIGGERED5_A::DISABLED,
326            true => TRIGGERED5_A::ENABLED,
327        }
328    }
329    #[doc = "Checks if the value of the field is `DISABLED`"]
330    #[inline(always)]
331    pub fn is_disabled(&self) -> bool {
332        *self == TRIGGERED5_A::DISABLED
333    }
334    #[doc = "Checks if the value of the field is `ENABLED`"]
335    #[inline(always)]
336    pub fn is_enabled(&self) -> bool {
337        *self == TRIGGERED5_A::ENABLED
338    }
339}
340#[doc = "Field `TRIGGERED5` writer - Enable or disable interrupt for TRIGGERED\\[5\\]
341event"]
342pub type TRIGGERED5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED5_A, O>;
343impl<'a, const O: u8> TRIGGERED5_W<'a, O> {
344    #[doc = "Disable"]
345    #[inline(always)]
346    pub fn disabled(self) -> &'a mut W {
347        self.variant(TRIGGERED5_A::DISABLED)
348    }
349    #[doc = "Enable"]
350    #[inline(always)]
351    pub fn enabled(self) -> &'a mut W {
352        self.variant(TRIGGERED5_A::ENABLED)
353    }
354}
355#[doc = "Field `TRIGGERED6` reader - Enable or disable interrupt for TRIGGERED\\[6\\]
356event"]
357pub type TRIGGERED6_R = crate::BitReader<TRIGGERED6_A>;
358#[doc = "Enable or disable interrupt for TRIGGERED\\[6\\]
359event\n\nValue on reset: 0"]
360#[derive(Clone, Copy, Debug, PartialEq)]
361pub enum TRIGGERED6_A {
362    #[doc = "0: Disable"]
363    DISABLED = 0,
364    #[doc = "1: Enable"]
365    ENABLED = 1,
366}
367impl From<TRIGGERED6_A> for bool {
368    #[inline(always)]
369    fn from(variant: TRIGGERED6_A) -> Self {
370        variant as u8 != 0
371    }
372}
373impl TRIGGERED6_R {
374    #[doc = "Get enumerated values variant"]
375    #[inline(always)]
376    pub fn variant(&self) -> TRIGGERED6_A {
377        match self.bits {
378            false => TRIGGERED6_A::DISABLED,
379            true => TRIGGERED6_A::ENABLED,
380        }
381    }
382    #[doc = "Checks if the value of the field is `DISABLED`"]
383    #[inline(always)]
384    pub fn is_disabled(&self) -> bool {
385        *self == TRIGGERED6_A::DISABLED
386    }
387    #[doc = "Checks if the value of the field is `ENABLED`"]
388    #[inline(always)]
389    pub fn is_enabled(&self) -> bool {
390        *self == TRIGGERED6_A::ENABLED
391    }
392}
393#[doc = "Field `TRIGGERED6` writer - Enable or disable interrupt for TRIGGERED\\[6\\]
394event"]
395pub type TRIGGERED6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED6_A, O>;
396impl<'a, const O: u8> TRIGGERED6_W<'a, O> {
397    #[doc = "Disable"]
398    #[inline(always)]
399    pub fn disabled(self) -> &'a mut W {
400        self.variant(TRIGGERED6_A::DISABLED)
401    }
402    #[doc = "Enable"]
403    #[inline(always)]
404    pub fn enabled(self) -> &'a mut W {
405        self.variant(TRIGGERED6_A::ENABLED)
406    }
407}
408#[doc = "Field `TRIGGERED7` reader - Enable or disable interrupt for TRIGGERED\\[7\\]
409event"]
410pub type TRIGGERED7_R = crate::BitReader<TRIGGERED7_A>;
411#[doc = "Enable or disable interrupt for TRIGGERED\\[7\\]
412event\n\nValue on reset: 0"]
413#[derive(Clone, Copy, Debug, PartialEq)]
414pub enum TRIGGERED7_A {
415    #[doc = "0: Disable"]
416    DISABLED = 0,
417    #[doc = "1: Enable"]
418    ENABLED = 1,
419}
420impl From<TRIGGERED7_A> for bool {
421    #[inline(always)]
422    fn from(variant: TRIGGERED7_A) -> Self {
423        variant as u8 != 0
424    }
425}
426impl TRIGGERED7_R {
427    #[doc = "Get enumerated values variant"]
428    #[inline(always)]
429    pub fn variant(&self) -> TRIGGERED7_A {
430        match self.bits {
431            false => TRIGGERED7_A::DISABLED,
432            true => TRIGGERED7_A::ENABLED,
433        }
434    }
435    #[doc = "Checks if the value of the field is `DISABLED`"]
436    #[inline(always)]
437    pub fn is_disabled(&self) -> bool {
438        *self == TRIGGERED7_A::DISABLED
439    }
440    #[doc = "Checks if the value of the field is `ENABLED`"]
441    #[inline(always)]
442    pub fn is_enabled(&self) -> bool {
443        *self == TRIGGERED7_A::ENABLED
444    }
445}
446#[doc = "Field `TRIGGERED7` writer - Enable or disable interrupt for TRIGGERED\\[7\\]
447event"]
448pub type TRIGGERED7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED7_A, O>;
449impl<'a, const O: u8> TRIGGERED7_W<'a, O> {
450    #[doc = "Disable"]
451    #[inline(always)]
452    pub fn disabled(self) -> &'a mut W {
453        self.variant(TRIGGERED7_A::DISABLED)
454    }
455    #[doc = "Enable"]
456    #[inline(always)]
457    pub fn enabled(self) -> &'a mut W {
458        self.variant(TRIGGERED7_A::ENABLED)
459    }
460}
461#[doc = "Field `TRIGGERED8` reader - Enable or disable interrupt for TRIGGERED\\[8\\]
462event"]
463pub type TRIGGERED8_R = crate::BitReader<TRIGGERED8_A>;
464#[doc = "Enable or disable interrupt for TRIGGERED\\[8\\]
465event\n\nValue on reset: 0"]
466#[derive(Clone, Copy, Debug, PartialEq)]
467pub enum TRIGGERED8_A {
468    #[doc = "0: Disable"]
469    DISABLED = 0,
470    #[doc = "1: Enable"]
471    ENABLED = 1,
472}
473impl From<TRIGGERED8_A> for bool {
474    #[inline(always)]
475    fn from(variant: TRIGGERED8_A) -> Self {
476        variant as u8 != 0
477    }
478}
479impl TRIGGERED8_R {
480    #[doc = "Get enumerated values variant"]
481    #[inline(always)]
482    pub fn variant(&self) -> TRIGGERED8_A {
483        match self.bits {
484            false => TRIGGERED8_A::DISABLED,
485            true => TRIGGERED8_A::ENABLED,
486        }
487    }
488    #[doc = "Checks if the value of the field is `DISABLED`"]
489    #[inline(always)]
490    pub fn is_disabled(&self) -> bool {
491        *self == TRIGGERED8_A::DISABLED
492    }
493    #[doc = "Checks if the value of the field is `ENABLED`"]
494    #[inline(always)]
495    pub fn is_enabled(&self) -> bool {
496        *self == TRIGGERED8_A::ENABLED
497    }
498}
499#[doc = "Field `TRIGGERED8` writer - Enable or disable interrupt for TRIGGERED\\[8\\]
500event"]
501pub type TRIGGERED8_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED8_A, O>;
502impl<'a, const O: u8> TRIGGERED8_W<'a, O> {
503    #[doc = "Disable"]
504    #[inline(always)]
505    pub fn disabled(self) -> &'a mut W {
506        self.variant(TRIGGERED8_A::DISABLED)
507    }
508    #[doc = "Enable"]
509    #[inline(always)]
510    pub fn enabled(self) -> &'a mut W {
511        self.variant(TRIGGERED8_A::ENABLED)
512    }
513}
514#[doc = "Field `TRIGGERED9` reader - Enable or disable interrupt for TRIGGERED\\[9\\]
515event"]
516pub type TRIGGERED9_R = crate::BitReader<TRIGGERED9_A>;
517#[doc = "Enable or disable interrupt for TRIGGERED\\[9\\]
518event\n\nValue on reset: 0"]
519#[derive(Clone, Copy, Debug, PartialEq)]
520pub enum TRIGGERED9_A {
521    #[doc = "0: Disable"]
522    DISABLED = 0,
523    #[doc = "1: Enable"]
524    ENABLED = 1,
525}
526impl From<TRIGGERED9_A> for bool {
527    #[inline(always)]
528    fn from(variant: TRIGGERED9_A) -> Self {
529        variant as u8 != 0
530    }
531}
532impl TRIGGERED9_R {
533    #[doc = "Get enumerated values variant"]
534    #[inline(always)]
535    pub fn variant(&self) -> TRIGGERED9_A {
536        match self.bits {
537            false => TRIGGERED9_A::DISABLED,
538            true => TRIGGERED9_A::ENABLED,
539        }
540    }
541    #[doc = "Checks if the value of the field is `DISABLED`"]
542    #[inline(always)]
543    pub fn is_disabled(&self) -> bool {
544        *self == TRIGGERED9_A::DISABLED
545    }
546    #[doc = "Checks if the value of the field is `ENABLED`"]
547    #[inline(always)]
548    pub fn is_enabled(&self) -> bool {
549        *self == TRIGGERED9_A::ENABLED
550    }
551}
552#[doc = "Field `TRIGGERED9` writer - Enable or disable interrupt for TRIGGERED\\[9\\]
553event"]
554pub type TRIGGERED9_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED9_A, O>;
555impl<'a, const O: u8> TRIGGERED9_W<'a, O> {
556    #[doc = "Disable"]
557    #[inline(always)]
558    pub fn disabled(self) -> &'a mut W {
559        self.variant(TRIGGERED9_A::DISABLED)
560    }
561    #[doc = "Enable"]
562    #[inline(always)]
563    pub fn enabled(self) -> &'a mut W {
564        self.variant(TRIGGERED9_A::ENABLED)
565    }
566}
567#[doc = "Field `TRIGGERED10` reader - Enable or disable interrupt for TRIGGERED\\[10\\]
568event"]
569pub type TRIGGERED10_R = crate::BitReader<TRIGGERED10_A>;
570#[doc = "Enable or disable interrupt for TRIGGERED\\[10\\]
571event\n\nValue on reset: 0"]
572#[derive(Clone, Copy, Debug, PartialEq)]
573pub enum TRIGGERED10_A {
574    #[doc = "0: Disable"]
575    DISABLED = 0,
576    #[doc = "1: Enable"]
577    ENABLED = 1,
578}
579impl From<TRIGGERED10_A> for bool {
580    #[inline(always)]
581    fn from(variant: TRIGGERED10_A) -> Self {
582        variant as u8 != 0
583    }
584}
585impl TRIGGERED10_R {
586    #[doc = "Get enumerated values variant"]
587    #[inline(always)]
588    pub fn variant(&self) -> TRIGGERED10_A {
589        match self.bits {
590            false => TRIGGERED10_A::DISABLED,
591            true => TRIGGERED10_A::ENABLED,
592        }
593    }
594    #[doc = "Checks if the value of the field is `DISABLED`"]
595    #[inline(always)]
596    pub fn is_disabled(&self) -> bool {
597        *self == TRIGGERED10_A::DISABLED
598    }
599    #[doc = "Checks if the value of the field is `ENABLED`"]
600    #[inline(always)]
601    pub fn is_enabled(&self) -> bool {
602        *self == TRIGGERED10_A::ENABLED
603    }
604}
605#[doc = "Field `TRIGGERED10` writer - Enable or disable interrupt for TRIGGERED\\[10\\]
606event"]
607pub type TRIGGERED10_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED10_A, O>;
608impl<'a, const O: u8> TRIGGERED10_W<'a, O> {
609    #[doc = "Disable"]
610    #[inline(always)]
611    pub fn disabled(self) -> &'a mut W {
612        self.variant(TRIGGERED10_A::DISABLED)
613    }
614    #[doc = "Enable"]
615    #[inline(always)]
616    pub fn enabled(self) -> &'a mut W {
617        self.variant(TRIGGERED10_A::ENABLED)
618    }
619}
620#[doc = "Field `TRIGGERED11` reader - Enable or disable interrupt for TRIGGERED\\[11\\]
621event"]
622pub type TRIGGERED11_R = crate::BitReader<TRIGGERED11_A>;
623#[doc = "Enable or disable interrupt for TRIGGERED\\[11\\]
624event\n\nValue on reset: 0"]
625#[derive(Clone, Copy, Debug, PartialEq)]
626pub enum TRIGGERED11_A {
627    #[doc = "0: Disable"]
628    DISABLED = 0,
629    #[doc = "1: Enable"]
630    ENABLED = 1,
631}
632impl From<TRIGGERED11_A> for bool {
633    #[inline(always)]
634    fn from(variant: TRIGGERED11_A) -> Self {
635        variant as u8 != 0
636    }
637}
638impl TRIGGERED11_R {
639    #[doc = "Get enumerated values variant"]
640    #[inline(always)]
641    pub fn variant(&self) -> TRIGGERED11_A {
642        match self.bits {
643            false => TRIGGERED11_A::DISABLED,
644            true => TRIGGERED11_A::ENABLED,
645        }
646    }
647    #[doc = "Checks if the value of the field is `DISABLED`"]
648    #[inline(always)]
649    pub fn is_disabled(&self) -> bool {
650        *self == TRIGGERED11_A::DISABLED
651    }
652    #[doc = "Checks if the value of the field is `ENABLED`"]
653    #[inline(always)]
654    pub fn is_enabled(&self) -> bool {
655        *self == TRIGGERED11_A::ENABLED
656    }
657}
658#[doc = "Field `TRIGGERED11` writer - Enable or disable interrupt for TRIGGERED\\[11\\]
659event"]
660pub type TRIGGERED11_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED11_A, O>;
661impl<'a, const O: u8> TRIGGERED11_W<'a, O> {
662    #[doc = "Disable"]
663    #[inline(always)]
664    pub fn disabled(self) -> &'a mut W {
665        self.variant(TRIGGERED11_A::DISABLED)
666    }
667    #[doc = "Enable"]
668    #[inline(always)]
669    pub fn enabled(self) -> &'a mut W {
670        self.variant(TRIGGERED11_A::ENABLED)
671    }
672}
673#[doc = "Field `TRIGGERED12` reader - Enable or disable interrupt for TRIGGERED\\[12\\]
674event"]
675pub type TRIGGERED12_R = crate::BitReader<TRIGGERED12_A>;
676#[doc = "Enable or disable interrupt for TRIGGERED\\[12\\]
677event\n\nValue on reset: 0"]
678#[derive(Clone, Copy, Debug, PartialEq)]
679pub enum TRIGGERED12_A {
680    #[doc = "0: Disable"]
681    DISABLED = 0,
682    #[doc = "1: Enable"]
683    ENABLED = 1,
684}
685impl From<TRIGGERED12_A> for bool {
686    #[inline(always)]
687    fn from(variant: TRIGGERED12_A) -> Self {
688        variant as u8 != 0
689    }
690}
691impl TRIGGERED12_R {
692    #[doc = "Get enumerated values variant"]
693    #[inline(always)]
694    pub fn variant(&self) -> TRIGGERED12_A {
695        match self.bits {
696            false => TRIGGERED12_A::DISABLED,
697            true => TRIGGERED12_A::ENABLED,
698        }
699    }
700    #[doc = "Checks if the value of the field is `DISABLED`"]
701    #[inline(always)]
702    pub fn is_disabled(&self) -> bool {
703        *self == TRIGGERED12_A::DISABLED
704    }
705    #[doc = "Checks if the value of the field is `ENABLED`"]
706    #[inline(always)]
707    pub fn is_enabled(&self) -> bool {
708        *self == TRIGGERED12_A::ENABLED
709    }
710}
711#[doc = "Field `TRIGGERED12` writer - Enable or disable interrupt for TRIGGERED\\[12\\]
712event"]
713pub type TRIGGERED12_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED12_A, O>;
714impl<'a, const O: u8> TRIGGERED12_W<'a, O> {
715    #[doc = "Disable"]
716    #[inline(always)]
717    pub fn disabled(self) -> &'a mut W {
718        self.variant(TRIGGERED12_A::DISABLED)
719    }
720    #[doc = "Enable"]
721    #[inline(always)]
722    pub fn enabled(self) -> &'a mut W {
723        self.variant(TRIGGERED12_A::ENABLED)
724    }
725}
726#[doc = "Field `TRIGGERED13` reader - Enable or disable interrupt for TRIGGERED\\[13\\]
727event"]
728pub type TRIGGERED13_R = crate::BitReader<TRIGGERED13_A>;
729#[doc = "Enable or disable interrupt for TRIGGERED\\[13\\]
730event\n\nValue on reset: 0"]
731#[derive(Clone, Copy, Debug, PartialEq)]
732pub enum TRIGGERED13_A {
733    #[doc = "0: Disable"]
734    DISABLED = 0,
735    #[doc = "1: Enable"]
736    ENABLED = 1,
737}
738impl From<TRIGGERED13_A> for bool {
739    #[inline(always)]
740    fn from(variant: TRIGGERED13_A) -> Self {
741        variant as u8 != 0
742    }
743}
744impl TRIGGERED13_R {
745    #[doc = "Get enumerated values variant"]
746    #[inline(always)]
747    pub fn variant(&self) -> TRIGGERED13_A {
748        match self.bits {
749            false => TRIGGERED13_A::DISABLED,
750            true => TRIGGERED13_A::ENABLED,
751        }
752    }
753    #[doc = "Checks if the value of the field is `DISABLED`"]
754    #[inline(always)]
755    pub fn is_disabled(&self) -> bool {
756        *self == TRIGGERED13_A::DISABLED
757    }
758    #[doc = "Checks if the value of the field is `ENABLED`"]
759    #[inline(always)]
760    pub fn is_enabled(&self) -> bool {
761        *self == TRIGGERED13_A::ENABLED
762    }
763}
764#[doc = "Field `TRIGGERED13` writer - Enable or disable interrupt for TRIGGERED\\[13\\]
765event"]
766pub type TRIGGERED13_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED13_A, O>;
767impl<'a, const O: u8> TRIGGERED13_W<'a, O> {
768    #[doc = "Disable"]
769    #[inline(always)]
770    pub fn disabled(self) -> &'a mut W {
771        self.variant(TRIGGERED13_A::DISABLED)
772    }
773    #[doc = "Enable"]
774    #[inline(always)]
775    pub fn enabled(self) -> &'a mut W {
776        self.variant(TRIGGERED13_A::ENABLED)
777    }
778}
779#[doc = "Field `TRIGGERED14` reader - Enable or disable interrupt for TRIGGERED\\[14\\]
780event"]
781pub type TRIGGERED14_R = crate::BitReader<TRIGGERED14_A>;
782#[doc = "Enable or disable interrupt for TRIGGERED\\[14\\]
783event\n\nValue on reset: 0"]
784#[derive(Clone, Copy, Debug, PartialEq)]
785pub enum TRIGGERED14_A {
786    #[doc = "0: Disable"]
787    DISABLED = 0,
788    #[doc = "1: Enable"]
789    ENABLED = 1,
790}
791impl From<TRIGGERED14_A> for bool {
792    #[inline(always)]
793    fn from(variant: TRIGGERED14_A) -> Self {
794        variant as u8 != 0
795    }
796}
797impl TRIGGERED14_R {
798    #[doc = "Get enumerated values variant"]
799    #[inline(always)]
800    pub fn variant(&self) -> TRIGGERED14_A {
801        match self.bits {
802            false => TRIGGERED14_A::DISABLED,
803            true => TRIGGERED14_A::ENABLED,
804        }
805    }
806    #[doc = "Checks if the value of the field is `DISABLED`"]
807    #[inline(always)]
808    pub fn is_disabled(&self) -> bool {
809        *self == TRIGGERED14_A::DISABLED
810    }
811    #[doc = "Checks if the value of the field is `ENABLED`"]
812    #[inline(always)]
813    pub fn is_enabled(&self) -> bool {
814        *self == TRIGGERED14_A::ENABLED
815    }
816}
817#[doc = "Field `TRIGGERED14` writer - Enable or disable interrupt for TRIGGERED\\[14\\]
818event"]
819pub type TRIGGERED14_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED14_A, O>;
820impl<'a, const O: u8> TRIGGERED14_W<'a, O> {
821    #[doc = "Disable"]
822    #[inline(always)]
823    pub fn disabled(self) -> &'a mut W {
824        self.variant(TRIGGERED14_A::DISABLED)
825    }
826    #[doc = "Enable"]
827    #[inline(always)]
828    pub fn enabled(self) -> &'a mut W {
829        self.variant(TRIGGERED14_A::ENABLED)
830    }
831}
832#[doc = "Field `TRIGGERED15` reader - Enable or disable interrupt for TRIGGERED\\[15\\]
833event"]
834pub type TRIGGERED15_R = crate::BitReader<TRIGGERED15_A>;
835#[doc = "Enable or disable interrupt for TRIGGERED\\[15\\]
836event\n\nValue on reset: 0"]
837#[derive(Clone, Copy, Debug, PartialEq)]
838pub enum TRIGGERED15_A {
839    #[doc = "0: Disable"]
840    DISABLED = 0,
841    #[doc = "1: Enable"]
842    ENABLED = 1,
843}
844impl From<TRIGGERED15_A> for bool {
845    #[inline(always)]
846    fn from(variant: TRIGGERED15_A) -> Self {
847        variant as u8 != 0
848    }
849}
850impl TRIGGERED15_R {
851    #[doc = "Get enumerated values variant"]
852    #[inline(always)]
853    pub fn variant(&self) -> TRIGGERED15_A {
854        match self.bits {
855            false => TRIGGERED15_A::DISABLED,
856            true => TRIGGERED15_A::ENABLED,
857        }
858    }
859    #[doc = "Checks if the value of the field is `DISABLED`"]
860    #[inline(always)]
861    pub fn is_disabled(&self) -> bool {
862        *self == TRIGGERED15_A::DISABLED
863    }
864    #[doc = "Checks if the value of the field is `ENABLED`"]
865    #[inline(always)]
866    pub fn is_enabled(&self) -> bool {
867        *self == TRIGGERED15_A::ENABLED
868    }
869}
870#[doc = "Field `TRIGGERED15` writer - Enable or disable interrupt for TRIGGERED\\[15\\]
871event"]
872pub type TRIGGERED15_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTEN_SPEC, TRIGGERED15_A, O>;
873impl<'a, const O: u8> TRIGGERED15_W<'a, O> {
874    #[doc = "Disable"]
875    #[inline(always)]
876    pub fn disabled(self) -> &'a mut W {
877        self.variant(TRIGGERED15_A::DISABLED)
878    }
879    #[doc = "Enable"]
880    #[inline(always)]
881    pub fn enabled(self) -> &'a mut W {
882        self.variant(TRIGGERED15_A::ENABLED)
883    }
884}
885impl R {
886    #[doc = "Bit 0 - Enable or disable interrupt for TRIGGERED\\[0\\]
887event"]
888    #[inline(always)]
889    pub fn triggered0(&self) -> TRIGGERED0_R {
890        TRIGGERED0_R::new((self.bits & 1) != 0)
891    }
892    #[doc = "Bit 1 - Enable or disable interrupt for TRIGGERED\\[1\\]
893event"]
894    #[inline(always)]
895    pub fn triggered1(&self) -> TRIGGERED1_R {
896        TRIGGERED1_R::new(((self.bits >> 1) & 1) != 0)
897    }
898    #[doc = "Bit 2 - Enable or disable interrupt for TRIGGERED\\[2\\]
899event"]
900    #[inline(always)]
901    pub fn triggered2(&self) -> TRIGGERED2_R {
902        TRIGGERED2_R::new(((self.bits >> 2) & 1) != 0)
903    }
904    #[doc = "Bit 3 - Enable or disable interrupt for TRIGGERED\\[3\\]
905event"]
906    #[inline(always)]
907    pub fn triggered3(&self) -> TRIGGERED3_R {
908        TRIGGERED3_R::new(((self.bits >> 3) & 1) != 0)
909    }
910    #[doc = "Bit 4 - Enable or disable interrupt for TRIGGERED\\[4\\]
911event"]
912    #[inline(always)]
913    pub fn triggered4(&self) -> TRIGGERED4_R {
914        TRIGGERED4_R::new(((self.bits >> 4) & 1) != 0)
915    }
916    #[doc = "Bit 5 - Enable or disable interrupt for TRIGGERED\\[5\\]
917event"]
918    #[inline(always)]
919    pub fn triggered5(&self) -> TRIGGERED5_R {
920        TRIGGERED5_R::new(((self.bits >> 5) & 1) != 0)
921    }
922    #[doc = "Bit 6 - Enable or disable interrupt for TRIGGERED\\[6\\]
923event"]
924    #[inline(always)]
925    pub fn triggered6(&self) -> TRIGGERED6_R {
926        TRIGGERED6_R::new(((self.bits >> 6) & 1) != 0)
927    }
928    #[doc = "Bit 7 - Enable or disable interrupt for TRIGGERED\\[7\\]
929event"]
930    #[inline(always)]
931    pub fn triggered7(&self) -> TRIGGERED7_R {
932        TRIGGERED7_R::new(((self.bits >> 7) & 1) != 0)
933    }
934    #[doc = "Bit 8 - Enable or disable interrupt for TRIGGERED\\[8\\]
935event"]
936    #[inline(always)]
937    pub fn triggered8(&self) -> TRIGGERED8_R {
938        TRIGGERED8_R::new(((self.bits >> 8) & 1) != 0)
939    }
940    #[doc = "Bit 9 - Enable or disable interrupt for TRIGGERED\\[9\\]
941event"]
942    #[inline(always)]
943    pub fn triggered9(&self) -> TRIGGERED9_R {
944        TRIGGERED9_R::new(((self.bits >> 9) & 1) != 0)
945    }
946    #[doc = "Bit 10 - Enable or disable interrupt for TRIGGERED\\[10\\]
947event"]
948    #[inline(always)]
949    pub fn triggered10(&self) -> TRIGGERED10_R {
950        TRIGGERED10_R::new(((self.bits >> 10) & 1) != 0)
951    }
952    #[doc = "Bit 11 - Enable or disable interrupt for TRIGGERED\\[11\\]
953event"]
954    #[inline(always)]
955    pub fn triggered11(&self) -> TRIGGERED11_R {
956        TRIGGERED11_R::new(((self.bits >> 11) & 1) != 0)
957    }
958    #[doc = "Bit 12 - Enable or disable interrupt for TRIGGERED\\[12\\]
959event"]
960    #[inline(always)]
961    pub fn triggered12(&self) -> TRIGGERED12_R {
962        TRIGGERED12_R::new(((self.bits >> 12) & 1) != 0)
963    }
964    #[doc = "Bit 13 - Enable or disable interrupt for TRIGGERED\\[13\\]
965event"]
966    #[inline(always)]
967    pub fn triggered13(&self) -> TRIGGERED13_R {
968        TRIGGERED13_R::new(((self.bits >> 13) & 1) != 0)
969    }
970    #[doc = "Bit 14 - Enable or disable interrupt for TRIGGERED\\[14\\]
971event"]
972    #[inline(always)]
973    pub fn triggered14(&self) -> TRIGGERED14_R {
974        TRIGGERED14_R::new(((self.bits >> 14) & 1) != 0)
975    }
976    #[doc = "Bit 15 - Enable or disable interrupt for TRIGGERED\\[15\\]
977event"]
978    #[inline(always)]
979    pub fn triggered15(&self) -> TRIGGERED15_R {
980        TRIGGERED15_R::new(((self.bits >> 15) & 1) != 0)
981    }
982}
983impl W {
984    #[doc = "Bit 0 - Enable or disable interrupt for TRIGGERED\\[0\\]
985event"]
986    #[inline(always)]
987    pub fn triggered0(&mut self) -> TRIGGERED0_W<0> {
988        TRIGGERED0_W::new(self)
989    }
990    #[doc = "Bit 1 - Enable or disable interrupt for TRIGGERED\\[1\\]
991event"]
992    #[inline(always)]
993    pub fn triggered1(&mut self) -> TRIGGERED1_W<1> {
994        TRIGGERED1_W::new(self)
995    }
996    #[doc = "Bit 2 - Enable or disable interrupt for TRIGGERED\\[2\\]
997event"]
998    #[inline(always)]
999    pub fn triggered2(&mut self) -> TRIGGERED2_W<2> {
1000        TRIGGERED2_W::new(self)
1001    }
1002    #[doc = "Bit 3 - Enable or disable interrupt for TRIGGERED\\[3\\]
1003event"]
1004    #[inline(always)]
1005    pub fn triggered3(&mut self) -> TRIGGERED3_W<3> {
1006        TRIGGERED3_W::new(self)
1007    }
1008    #[doc = "Bit 4 - Enable or disable interrupt for TRIGGERED\\[4\\]
1009event"]
1010    #[inline(always)]
1011    pub fn triggered4(&mut self) -> TRIGGERED4_W<4> {
1012        TRIGGERED4_W::new(self)
1013    }
1014    #[doc = "Bit 5 - Enable or disable interrupt for TRIGGERED\\[5\\]
1015event"]
1016    #[inline(always)]
1017    pub fn triggered5(&mut self) -> TRIGGERED5_W<5> {
1018        TRIGGERED5_W::new(self)
1019    }
1020    #[doc = "Bit 6 - Enable or disable interrupt for TRIGGERED\\[6\\]
1021event"]
1022    #[inline(always)]
1023    pub fn triggered6(&mut self) -> TRIGGERED6_W<6> {
1024        TRIGGERED6_W::new(self)
1025    }
1026    #[doc = "Bit 7 - Enable or disable interrupt for TRIGGERED\\[7\\]
1027event"]
1028    #[inline(always)]
1029    pub fn triggered7(&mut self) -> TRIGGERED7_W<7> {
1030        TRIGGERED7_W::new(self)
1031    }
1032    #[doc = "Bit 8 - Enable or disable interrupt for TRIGGERED\\[8\\]
1033event"]
1034    #[inline(always)]
1035    pub fn triggered8(&mut self) -> TRIGGERED8_W<8> {
1036        TRIGGERED8_W::new(self)
1037    }
1038    #[doc = "Bit 9 - Enable or disable interrupt for TRIGGERED\\[9\\]
1039event"]
1040    #[inline(always)]
1041    pub fn triggered9(&mut self) -> TRIGGERED9_W<9> {
1042        TRIGGERED9_W::new(self)
1043    }
1044    #[doc = "Bit 10 - Enable or disable interrupt for TRIGGERED\\[10\\]
1045event"]
1046    #[inline(always)]
1047    pub fn triggered10(&mut self) -> TRIGGERED10_W<10> {
1048        TRIGGERED10_W::new(self)
1049    }
1050    #[doc = "Bit 11 - Enable or disable interrupt for TRIGGERED\\[11\\]
1051event"]
1052    #[inline(always)]
1053    pub fn triggered11(&mut self) -> TRIGGERED11_W<11> {
1054        TRIGGERED11_W::new(self)
1055    }
1056    #[doc = "Bit 12 - Enable or disable interrupt for TRIGGERED\\[12\\]
1057event"]
1058    #[inline(always)]
1059    pub fn triggered12(&mut self) -> TRIGGERED12_W<12> {
1060        TRIGGERED12_W::new(self)
1061    }
1062    #[doc = "Bit 13 - Enable or disable interrupt for TRIGGERED\\[13\\]
1063event"]
1064    #[inline(always)]
1065    pub fn triggered13(&mut self) -> TRIGGERED13_W<13> {
1066        TRIGGERED13_W::new(self)
1067    }
1068    #[doc = "Bit 14 - Enable or disable interrupt for TRIGGERED\\[14\\]
1069event"]
1070    #[inline(always)]
1071    pub fn triggered14(&mut self) -> TRIGGERED14_W<14> {
1072        TRIGGERED14_W::new(self)
1073    }
1074    #[doc = "Bit 15 - Enable or disable interrupt for TRIGGERED\\[15\\]
1075event"]
1076    #[inline(always)]
1077    pub fn triggered15(&mut self) -> TRIGGERED15_W<15> {
1078        TRIGGERED15_W::new(self)
1079    }
1080    #[doc = "Writes raw bits to the register."]
1081    #[inline(always)]
1082    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1083        self.0.bits(bits);
1084        self
1085    }
1086}
1087#[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"]
1088pub struct INTEN_SPEC;
1089impl crate::RegisterSpec for INTEN_SPEC {
1090    type Ux = u32;
1091}
1092#[doc = "`read()` method returns [inten::R](R) reader structure"]
1093impl crate::Readable for INTEN_SPEC {
1094    type Reader = R;
1095}
1096#[doc = "`write(|w| ..)` method takes [inten::W](W) writer structure"]
1097impl crate::Writable for INTEN_SPEC {
1098    type Writer = W;
1099}
1100#[doc = "`reset()` method sets INTEN to value 0"]
1101impl crate::Resettable for INTEN_SPEC {
1102    #[inline(always)]
1103    fn reset_value() -> Self::Ux {
1104        0
1105    }
1106}
nrf52840_pac/egu0/inten.rs

nrf52840_pac/egu0/
inten.rs
