nrf52840_pac/nfct/
intenclr.rs

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

nrf52840_pac/nfct/
intenclr.rs
