mcxa_pac/tdet0/
ier.rs

1#[doc = "Register `IER` reader"]
2pub type R = crate::R<IerSpec>;
3#[doc = "Register `IER` writer"]
4pub type W = crate::W<IerSpec>;
5#[doc = "Digital Tamper Interrupt Enable\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Dtie {
9    #[doc = "0: Disables"]
10    Disable = 0,
11    #[doc = "1: Enables"]
12    Enable = 1,
13}
14impl From<Dtie> for bool {
15    #[inline(always)]
16    fn from(variant: Dtie) -> Self {
17        variant as u8 != 0
18    }
19}
20#[doc = "Field `DTIE` reader - Digital Tamper Interrupt Enable"]
21pub type DtieR = crate::BitReader<Dtie>;
22impl DtieR {
23    #[doc = "Get enumerated values variant"]
24    #[inline(always)]
25    pub const fn variant(&self) -> Dtie {
26        match self.bits {
27            false => Dtie::Disable,
28            true => Dtie::Enable,
29        }
30    }
31    #[doc = "Disables"]
32    #[inline(always)]
33    pub fn is_disable(&self) -> bool {
34        *self == Dtie::Disable
35    }
36    #[doc = "Enables"]
37    #[inline(always)]
38    pub fn is_enable(&self) -> bool {
39        *self == Dtie::Enable
40    }
41}
42#[doc = "Field `DTIE` writer - Digital Tamper Interrupt Enable"]
43pub type DtieW<'a, REG> = crate::BitWriter<'a, REG, Dtie>;
44impl<'a, REG> DtieW<'a, REG>
45where
46    REG: crate::Writable + crate::RegisterSpec,
47{
48    #[doc = "Disables"]
49    #[inline(always)]
50    pub fn disable(self) -> &'a mut crate::W<REG> {
51        self.variant(Dtie::Disable)
52    }
53    #[doc = "Enables"]
54    #[inline(always)]
55    pub fn enable(self) -> &'a mut crate::W<REG> {
56        self.variant(Dtie::Enable)
57    }
58}
59#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Tiie0 {
63    #[doc = "0: Disables"]
64    Disable = 0,
65    #[doc = "1: Enables"]
66    Enable = 1,
67}
68impl From<Tiie0> for bool {
69    #[inline(always)]
70    fn from(variant: Tiie0) -> Self {
71        variant as u8 != 0
72    }
73}
74#[doc = "Field `TIIE0` reader - Tamper Input n Interrupt Enable"]
75pub type Tiie0R = crate::BitReader<Tiie0>;
76impl Tiie0R {
77    #[doc = "Get enumerated values variant"]
78    #[inline(always)]
79    pub const fn variant(&self) -> Tiie0 {
80        match self.bits {
81            false => Tiie0::Disable,
82            true => Tiie0::Enable,
83        }
84    }
85    #[doc = "Disables"]
86    #[inline(always)]
87    pub fn is_disable(&self) -> bool {
88        *self == Tiie0::Disable
89    }
90    #[doc = "Enables"]
91    #[inline(always)]
92    pub fn is_enable(&self) -> bool {
93        *self == Tiie0::Enable
94    }
95}
96#[doc = "Field `TIIE0` writer - Tamper Input n Interrupt Enable"]
97pub type Tiie0W<'a, REG> = crate::BitWriter<'a, REG, Tiie0>;
98impl<'a, REG> Tiie0W<'a, REG>
99where
100    REG: crate::Writable + crate::RegisterSpec,
101{
102    #[doc = "Disables"]
103    #[inline(always)]
104    pub fn disable(self) -> &'a mut crate::W<REG> {
105        self.variant(Tiie0::Disable)
106    }
107    #[doc = "Enables"]
108    #[inline(always)]
109    pub fn enable(self) -> &'a mut crate::W<REG> {
110        self.variant(Tiie0::Enable)
111    }
112}
113#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Tiie1 {
117    #[doc = "0: Disables"]
118    Disable = 0,
119    #[doc = "1: Enables"]
120    Enable = 1,
121}
122impl From<Tiie1> for bool {
123    #[inline(always)]
124    fn from(variant: Tiie1) -> Self {
125        variant as u8 != 0
126    }
127}
128#[doc = "Field `TIIE1` reader - Tamper Input n Interrupt Enable"]
129pub type Tiie1R = crate::BitReader<Tiie1>;
130impl Tiie1R {
131    #[doc = "Get enumerated values variant"]
132    #[inline(always)]
133    pub const fn variant(&self) -> Tiie1 {
134        match self.bits {
135            false => Tiie1::Disable,
136            true => Tiie1::Enable,
137        }
138    }
139    #[doc = "Disables"]
140    #[inline(always)]
141    pub fn is_disable(&self) -> bool {
142        *self == Tiie1::Disable
143    }
144    #[doc = "Enables"]
145    #[inline(always)]
146    pub fn is_enable(&self) -> bool {
147        *self == Tiie1::Enable
148    }
149}
150#[doc = "Field `TIIE1` writer - Tamper Input n Interrupt Enable"]
151pub type Tiie1W<'a, REG> = crate::BitWriter<'a, REG, Tiie1>;
152impl<'a, REG> Tiie1W<'a, REG>
153where
154    REG: crate::Writable + crate::RegisterSpec,
155{
156    #[doc = "Disables"]
157    #[inline(always)]
158    pub fn disable(self) -> &'a mut crate::W<REG> {
159        self.variant(Tiie1::Disable)
160    }
161    #[doc = "Enables"]
162    #[inline(always)]
163    pub fn enable(self) -> &'a mut crate::W<REG> {
164        self.variant(Tiie1::Enable)
165    }
166}
167#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Tiie2 {
171    #[doc = "0: Disables"]
172    Disable = 0,
173    #[doc = "1: Enables"]
174    Enable = 1,
175}
176impl From<Tiie2> for bool {
177    #[inline(always)]
178    fn from(variant: Tiie2) -> Self {
179        variant as u8 != 0
180    }
181}
182#[doc = "Field `TIIE2` reader - Tamper Input n Interrupt Enable"]
183pub type Tiie2R = crate::BitReader<Tiie2>;
184impl Tiie2R {
185    #[doc = "Get enumerated values variant"]
186    #[inline(always)]
187    pub const fn variant(&self) -> Tiie2 {
188        match self.bits {
189            false => Tiie2::Disable,
190            true => Tiie2::Enable,
191        }
192    }
193    #[doc = "Disables"]
194    #[inline(always)]
195    pub fn is_disable(&self) -> bool {
196        *self == Tiie2::Disable
197    }
198    #[doc = "Enables"]
199    #[inline(always)]
200    pub fn is_enable(&self) -> bool {
201        *self == Tiie2::Enable
202    }
203}
204#[doc = "Field `TIIE2` writer - Tamper Input n Interrupt Enable"]
205pub type Tiie2W<'a, REG> = crate::BitWriter<'a, REG, Tiie2>;
206impl<'a, REG> Tiie2W<'a, REG>
207where
208    REG: crate::Writable + crate::RegisterSpec,
209{
210    #[doc = "Disables"]
211    #[inline(always)]
212    pub fn disable(self) -> &'a mut crate::W<REG> {
213        self.variant(Tiie2::Disable)
214    }
215    #[doc = "Enables"]
216    #[inline(always)]
217    pub fn enable(self) -> &'a mut crate::W<REG> {
218        self.variant(Tiie2::Enable)
219    }
220}
221#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Tiie3 {
225    #[doc = "0: Disables"]
226    Disable = 0,
227    #[doc = "1: Enables"]
228    Enable = 1,
229}
230impl From<Tiie3> for bool {
231    #[inline(always)]
232    fn from(variant: Tiie3) -> Self {
233        variant as u8 != 0
234    }
235}
236#[doc = "Field `TIIE3` reader - Tamper Input n Interrupt Enable"]
237pub type Tiie3R = crate::BitReader<Tiie3>;
238impl Tiie3R {
239    #[doc = "Get enumerated values variant"]
240    #[inline(always)]
241    pub const fn variant(&self) -> Tiie3 {
242        match self.bits {
243            false => Tiie3::Disable,
244            true => Tiie3::Enable,
245        }
246    }
247    #[doc = "Disables"]
248    #[inline(always)]
249    pub fn is_disable(&self) -> bool {
250        *self == Tiie3::Disable
251    }
252    #[doc = "Enables"]
253    #[inline(always)]
254    pub fn is_enable(&self) -> bool {
255        *self == Tiie3::Enable
256    }
257}
258#[doc = "Field `TIIE3` writer - Tamper Input n Interrupt Enable"]
259pub type Tiie3W<'a, REG> = crate::BitWriter<'a, REG, Tiie3>;
260impl<'a, REG> Tiie3W<'a, REG>
261where
262    REG: crate::Writable + crate::RegisterSpec,
263{
264    #[doc = "Disables"]
265    #[inline(always)]
266    pub fn disable(self) -> &'a mut crate::W<REG> {
267        self.variant(Tiie3::Disable)
268    }
269    #[doc = "Enables"]
270    #[inline(always)]
271    pub fn enable(self) -> &'a mut crate::W<REG> {
272        self.variant(Tiie3::Enable)
273    }
274}
275#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Tiie4 {
279    #[doc = "0: Disables"]
280    Disable = 0,
281    #[doc = "1: Enables"]
282    Enable = 1,
283}
284impl From<Tiie4> for bool {
285    #[inline(always)]
286    fn from(variant: Tiie4) -> Self {
287        variant as u8 != 0
288    }
289}
290#[doc = "Field `TIIE4` reader - Tamper Input n Interrupt Enable"]
291pub type Tiie4R = crate::BitReader<Tiie4>;
292impl Tiie4R {
293    #[doc = "Get enumerated values variant"]
294    #[inline(always)]
295    pub const fn variant(&self) -> Tiie4 {
296        match self.bits {
297            false => Tiie4::Disable,
298            true => Tiie4::Enable,
299        }
300    }
301    #[doc = "Disables"]
302    #[inline(always)]
303    pub fn is_disable(&self) -> bool {
304        *self == Tiie4::Disable
305    }
306    #[doc = "Enables"]
307    #[inline(always)]
308    pub fn is_enable(&self) -> bool {
309        *self == Tiie4::Enable
310    }
311}
312#[doc = "Field `TIIE4` writer - Tamper Input n Interrupt Enable"]
313pub type Tiie4W<'a, REG> = crate::BitWriter<'a, REG, Tiie4>;
314impl<'a, REG> Tiie4W<'a, REG>
315where
316    REG: crate::Writable + crate::RegisterSpec,
317{
318    #[doc = "Disables"]
319    #[inline(always)]
320    pub fn disable(self) -> &'a mut crate::W<REG> {
321        self.variant(Tiie4::Disable)
322    }
323    #[doc = "Enables"]
324    #[inline(always)]
325    pub fn enable(self) -> &'a mut crate::W<REG> {
326        self.variant(Tiie4::Enable)
327    }
328}
329#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Tiie5 {
333    #[doc = "0: Disables"]
334    Disable = 0,
335    #[doc = "1: Enables"]
336    Enable = 1,
337}
338impl From<Tiie5> for bool {
339    #[inline(always)]
340    fn from(variant: Tiie5) -> Self {
341        variant as u8 != 0
342    }
343}
344#[doc = "Field `TIIE5` reader - Tamper Input n Interrupt Enable"]
345pub type Tiie5R = crate::BitReader<Tiie5>;
346impl Tiie5R {
347    #[doc = "Get enumerated values variant"]
348    #[inline(always)]
349    pub const fn variant(&self) -> Tiie5 {
350        match self.bits {
351            false => Tiie5::Disable,
352            true => Tiie5::Enable,
353        }
354    }
355    #[doc = "Disables"]
356    #[inline(always)]
357    pub fn is_disable(&self) -> bool {
358        *self == Tiie5::Disable
359    }
360    #[doc = "Enables"]
361    #[inline(always)]
362    pub fn is_enable(&self) -> bool {
363        *self == Tiie5::Enable
364    }
365}
366#[doc = "Field `TIIE5` writer - Tamper Input n Interrupt Enable"]
367pub type Tiie5W<'a, REG> = crate::BitWriter<'a, REG, Tiie5>;
368impl<'a, REG> Tiie5W<'a, REG>
369where
370    REG: crate::Writable + crate::RegisterSpec,
371{
372    #[doc = "Disables"]
373    #[inline(always)]
374    pub fn disable(self) -> &'a mut crate::W<REG> {
375        self.variant(Tiie5::Disable)
376    }
377    #[doc = "Enables"]
378    #[inline(always)]
379    pub fn enable(self) -> &'a mut crate::W<REG> {
380        self.variant(Tiie5::Enable)
381    }
382}
383#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum Tiie6 {
387    #[doc = "0: Disables"]
388    Disable = 0,
389    #[doc = "1: Enables"]
390    Enable = 1,
391}
392impl From<Tiie6> for bool {
393    #[inline(always)]
394    fn from(variant: Tiie6) -> Self {
395        variant as u8 != 0
396    }
397}
398#[doc = "Field `TIIE6` reader - Tamper Input n Interrupt Enable"]
399pub type Tiie6R = crate::BitReader<Tiie6>;
400impl Tiie6R {
401    #[doc = "Get enumerated values variant"]
402    #[inline(always)]
403    pub const fn variant(&self) -> Tiie6 {
404        match self.bits {
405            false => Tiie6::Disable,
406            true => Tiie6::Enable,
407        }
408    }
409    #[doc = "Disables"]
410    #[inline(always)]
411    pub fn is_disable(&self) -> bool {
412        *self == Tiie6::Disable
413    }
414    #[doc = "Enables"]
415    #[inline(always)]
416    pub fn is_enable(&self) -> bool {
417        *self == Tiie6::Enable
418    }
419}
420#[doc = "Field `TIIE6` writer - Tamper Input n Interrupt Enable"]
421pub type Tiie6W<'a, REG> = crate::BitWriter<'a, REG, Tiie6>;
422impl<'a, REG> Tiie6W<'a, REG>
423where
424    REG: crate::Writable + crate::RegisterSpec,
425{
426    #[doc = "Disables"]
427    #[inline(always)]
428    pub fn disable(self) -> &'a mut crate::W<REG> {
429        self.variant(Tiie6::Disable)
430    }
431    #[doc = "Enables"]
432    #[inline(always)]
433    pub fn enable(self) -> &'a mut crate::W<REG> {
434        self.variant(Tiie6::Enable)
435    }
436}
437#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum Tiie7 {
441    #[doc = "0: Disables"]
442    Disable = 0,
443    #[doc = "1: Enables"]
444    Enable = 1,
445}
446impl From<Tiie7> for bool {
447    #[inline(always)]
448    fn from(variant: Tiie7) -> Self {
449        variant as u8 != 0
450    }
451}
452#[doc = "Field `TIIE7` reader - Tamper Input n Interrupt Enable"]
453pub type Tiie7R = crate::BitReader<Tiie7>;
454impl Tiie7R {
455    #[doc = "Get enumerated values variant"]
456    #[inline(always)]
457    pub const fn variant(&self) -> Tiie7 {
458        match self.bits {
459            false => Tiie7::Disable,
460            true => Tiie7::Enable,
461        }
462    }
463    #[doc = "Disables"]
464    #[inline(always)]
465    pub fn is_disable(&self) -> bool {
466        *self == Tiie7::Disable
467    }
468    #[doc = "Enables"]
469    #[inline(always)]
470    pub fn is_enable(&self) -> bool {
471        *self == Tiie7::Enable
472    }
473}
474#[doc = "Field `TIIE7` writer - Tamper Input n Interrupt Enable"]
475pub type Tiie7W<'a, REG> = crate::BitWriter<'a, REG, Tiie7>;
476impl<'a, REG> Tiie7W<'a, REG>
477where
478    REG: crate::Writable + crate::RegisterSpec,
479{
480    #[doc = "Disables"]
481    #[inline(always)]
482    pub fn disable(self) -> &'a mut crate::W<REG> {
483        self.variant(Tiie7::Disable)
484    }
485    #[doc = "Enables"]
486    #[inline(always)]
487    pub fn enable(self) -> &'a mut crate::W<REG> {
488        self.variant(Tiie7::Enable)
489    }
490}
491#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum Tiie8 {
495    #[doc = "0: Disables"]
496    Disable = 0,
497    #[doc = "1: Enables"]
498    Enable = 1,
499}
500impl From<Tiie8> for bool {
501    #[inline(always)]
502    fn from(variant: Tiie8) -> Self {
503        variant as u8 != 0
504    }
505}
506#[doc = "Field `TIIE8` reader - Tamper Input n Interrupt Enable"]
507pub type Tiie8R = crate::BitReader<Tiie8>;
508impl Tiie8R {
509    #[doc = "Get enumerated values variant"]
510    #[inline(always)]
511    pub const fn variant(&self) -> Tiie8 {
512        match self.bits {
513            false => Tiie8::Disable,
514            true => Tiie8::Enable,
515        }
516    }
517    #[doc = "Disables"]
518    #[inline(always)]
519    pub fn is_disable(&self) -> bool {
520        *self == Tiie8::Disable
521    }
522    #[doc = "Enables"]
523    #[inline(always)]
524    pub fn is_enable(&self) -> bool {
525        *self == Tiie8::Enable
526    }
527}
528#[doc = "Field `TIIE8` writer - Tamper Input n Interrupt Enable"]
529pub type Tiie8W<'a, REG> = crate::BitWriter<'a, REG, Tiie8>;
530impl<'a, REG> Tiie8W<'a, REG>
531where
532    REG: crate::Writable + crate::RegisterSpec,
533{
534    #[doc = "Disables"]
535    #[inline(always)]
536    pub fn disable(self) -> &'a mut crate::W<REG> {
537        self.variant(Tiie8::Disable)
538    }
539    #[doc = "Enables"]
540    #[inline(always)]
541    pub fn enable(self) -> &'a mut crate::W<REG> {
542        self.variant(Tiie8::Enable)
543    }
544}
545#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Tiie9 {
549    #[doc = "0: Disables"]
550    Disable = 0,
551    #[doc = "1: Enables"]
552    Enable = 1,
553}
554impl From<Tiie9> for bool {
555    #[inline(always)]
556    fn from(variant: Tiie9) -> Self {
557        variant as u8 != 0
558    }
559}
560#[doc = "Field `TIIE9` reader - Tamper Input n Interrupt Enable"]
561pub type Tiie9R = crate::BitReader<Tiie9>;
562impl Tiie9R {
563    #[doc = "Get enumerated values variant"]
564    #[inline(always)]
565    pub const fn variant(&self) -> Tiie9 {
566        match self.bits {
567            false => Tiie9::Disable,
568            true => Tiie9::Enable,
569        }
570    }
571    #[doc = "Disables"]
572    #[inline(always)]
573    pub fn is_disable(&self) -> bool {
574        *self == Tiie9::Disable
575    }
576    #[doc = "Enables"]
577    #[inline(always)]
578    pub fn is_enable(&self) -> bool {
579        *self == Tiie9::Enable
580    }
581}
582#[doc = "Field `TIIE9` writer - Tamper Input n Interrupt Enable"]
583pub type Tiie9W<'a, REG> = crate::BitWriter<'a, REG, Tiie9>;
584impl<'a, REG> Tiie9W<'a, REG>
585where
586    REG: crate::Writable + crate::RegisterSpec,
587{
588    #[doc = "Disables"]
589    #[inline(always)]
590    pub fn disable(self) -> &'a mut crate::W<REG> {
591        self.variant(Tiie9::Disable)
592    }
593    #[doc = "Enables"]
594    #[inline(always)]
595    pub fn enable(self) -> &'a mut crate::W<REG> {
596        self.variant(Tiie9::Enable)
597    }
598}
599#[doc = "Tamper Input n Interrupt Enable\n\nValue on reset: 0"]
600#[cfg_attr(feature = "defmt", derive(defmt::Format))]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum Tiie10 {
603    #[doc = "0: Disables"]
604    Disable = 0,
605    #[doc = "1: Enables"]
606    Enable = 1,
607}
608impl From<Tiie10> for bool {
609    #[inline(always)]
610    fn from(variant: Tiie10) -> Self {
611        variant as u8 != 0
612    }
613}
614#[doc = "Field `TIIE10` reader - Tamper Input n Interrupt Enable"]
615pub type Tiie10R = crate::BitReader<Tiie10>;
616impl Tiie10R {
617    #[doc = "Get enumerated values variant"]
618    #[inline(always)]
619    pub const fn variant(&self) -> Tiie10 {
620        match self.bits {
621            false => Tiie10::Disable,
622            true => Tiie10::Enable,
623        }
624    }
625    #[doc = "Disables"]
626    #[inline(always)]
627    pub fn is_disable(&self) -> bool {
628        *self == Tiie10::Disable
629    }
630    #[doc = "Enables"]
631    #[inline(always)]
632    pub fn is_enable(&self) -> bool {
633        *self == Tiie10::Enable
634    }
635}
636#[doc = "Field `TIIE10` writer - Tamper Input n Interrupt Enable"]
637pub type Tiie10W<'a, REG> = crate::BitWriter<'a, REG, Tiie10>;
638impl<'a, REG> Tiie10W<'a, REG>
639where
640    REG: crate::Writable + crate::RegisterSpec,
641{
642    #[doc = "Disables"]
643    #[inline(always)]
644    pub fn disable(self) -> &'a mut crate::W<REG> {
645        self.variant(Tiie10::Disable)
646    }
647    #[doc = "Enables"]
648    #[inline(always)]
649    pub fn enable(self) -> &'a mut crate::W<REG> {
650        self.variant(Tiie10::Enable)
651    }
652}
653#[doc = "Tamper Pin n Interrupt Enable\n\nValue on reset: 0"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum Tpie0 {
657    #[doc = "0: Disables"]
658    Disable = 0,
659    #[doc = "1: Enables"]
660    Enable = 1,
661}
662impl From<Tpie0> for bool {
663    #[inline(always)]
664    fn from(variant: Tpie0) -> Self {
665        variant as u8 != 0
666    }
667}
668#[doc = "Field `TPIE0` reader - Tamper Pin n Interrupt Enable"]
669pub type Tpie0R = crate::BitReader<Tpie0>;
670impl Tpie0R {
671    #[doc = "Get enumerated values variant"]
672    #[inline(always)]
673    pub const fn variant(&self) -> Tpie0 {
674        match self.bits {
675            false => Tpie0::Disable,
676            true => Tpie0::Enable,
677        }
678    }
679    #[doc = "Disables"]
680    #[inline(always)]
681    pub fn is_disable(&self) -> bool {
682        *self == Tpie0::Disable
683    }
684    #[doc = "Enables"]
685    #[inline(always)]
686    pub fn is_enable(&self) -> bool {
687        *self == Tpie0::Enable
688    }
689}
690#[doc = "Field `TPIE0` writer - Tamper Pin n Interrupt Enable"]
691pub type Tpie0W<'a, REG> = crate::BitWriter<'a, REG, Tpie0>;
692impl<'a, REG> Tpie0W<'a, REG>
693where
694    REG: crate::Writable + crate::RegisterSpec,
695{
696    #[doc = "Disables"]
697    #[inline(always)]
698    pub fn disable(self) -> &'a mut crate::W<REG> {
699        self.variant(Tpie0::Disable)
700    }
701    #[doc = "Enables"]
702    #[inline(always)]
703    pub fn enable(self) -> &'a mut crate::W<REG> {
704        self.variant(Tpie0::Enable)
705    }
706}
707#[doc = "Tamper Pin n Interrupt Enable\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum Tpie1 {
711    #[doc = "0: Disables"]
712    Disable = 0,
713    #[doc = "1: Enables"]
714    Enable = 1,
715}
716impl From<Tpie1> for bool {
717    #[inline(always)]
718    fn from(variant: Tpie1) -> Self {
719        variant as u8 != 0
720    }
721}
722#[doc = "Field `TPIE1` reader - Tamper Pin n Interrupt Enable"]
723pub type Tpie1R = crate::BitReader<Tpie1>;
724impl Tpie1R {
725    #[doc = "Get enumerated values variant"]
726    #[inline(always)]
727    pub const fn variant(&self) -> Tpie1 {
728        match self.bits {
729            false => Tpie1::Disable,
730            true => Tpie1::Enable,
731        }
732    }
733    #[doc = "Disables"]
734    #[inline(always)]
735    pub fn is_disable(&self) -> bool {
736        *self == Tpie1::Disable
737    }
738    #[doc = "Enables"]
739    #[inline(always)]
740    pub fn is_enable(&self) -> bool {
741        *self == Tpie1::Enable
742    }
743}
744#[doc = "Field `TPIE1` writer - Tamper Pin n Interrupt Enable"]
745pub type Tpie1W<'a, REG> = crate::BitWriter<'a, REG, Tpie1>;
746impl<'a, REG> Tpie1W<'a, REG>
747where
748    REG: crate::Writable + crate::RegisterSpec,
749{
750    #[doc = "Disables"]
751    #[inline(always)]
752    pub fn disable(self) -> &'a mut crate::W<REG> {
753        self.variant(Tpie1::Disable)
754    }
755    #[doc = "Enables"]
756    #[inline(always)]
757    pub fn enable(self) -> &'a mut crate::W<REG> {
758        self.variant(Tpie1::Enable)
759    }
760}
761#[doc = "Tamper Pin n Interrupt Enable\n\nValue on reset: 0"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum Tpie2 {
765    #[doc = "0: Disables"]
766    Disable = 0,
767    #[doc = "1: Enables"]
768    Enable = 1,
769}
770impl From<Tpie2> for bool {
771    #[inline(always)]
772    fn from(variant: Tpie2) -> Self {
773        variant as u8 != 0
774    }
775}
776#[doc = "Field `TPIE2` reader - Tamper Pin n Interrupt Enable"]
777pub type Tpie2R = crate::BitReader<Tpie2>;
778impl Tpie2R {
779    #[doc = "Get enumerated values variant"]
780    #[inline(always)]
781    pub const fn variant(&self) -> Tpie2 {
782        match self.bits {
783            false => Tpie2::Disable,
784            true => Tpie2::Enable,
785        }
786    }
787    #[doc = "Disables"]
788    #[inline(always)]
789    pub fn is_disable(&self) -> bool {
790        *self == Tpie2::Disable
791    }
792    #[doc = "Enables"]
793    #[inline(always)]
794    pub fn is_enable(&self) -> bool {
795        *self == Tpie2::Enable
796    }
797}
798#[doc = "Field `TPIE2` writer - Tamper Pin n Interrupt Enable"]
799pub type Tpie2W<'a, REG> = crate::BitWriter<'a, REG, Tpie2>;
800impl<'a, REG> Tpie2W<'a, REG>
801where
802    REG: crate::Writable + crate::RegisterSpec,
803{
804    #[doc = "Disables"]
805    #[inline(always)]
806    pub fn disable(self) -> &'a mut crate::W<REG> {
807        self.variant(Tpie2::Disable)
808    }
809    #[doc = "Enables"]
810    #[inline(always)]
811    pub fn enable(self) -> &'a mut crate::W<REG> {
812        self.variant(Tpie2::Enable)
813    }
814}
815#[doc = "Tamper Pin n Interrupt Enable\n\nValue on reset: 0"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum Tpie3 {
819    #[doc = "0: Disables"]
820    Disable = 0,
821    #[doc = "1: Enables"]
822    Enable = 1,
823}
824impl From<Tpie3> for bool {
825    #[inline(always)]
826    fn from(variant: Tpie3) -> Self {
827        variant as u8 != 0
828    }
829}
830#[doc = "Field `TPIE3` reader - Tamper Pin n Interrupt Enable"]
831pub type Tpie3R = crate::BitReader<Tpie3>;
832impl Tpie3R {
833    #[doc = "Get enumerated values variant"]
834    #[inline(always)]
835    pub const fn variant(&self) -> Tpie3 {
836        match self.bits {
837            false => Tpie3::Disable,
838            true => Tpie3::Enable,
839        }
840    }
841    #[doc = "Disables"]
842    #[inline(always)]
843    pub fn is_disable(&self) -> bool {
844        *self == Tpie3::Disable
845    }
846    #[doc = "Enables"]
847    #[inline(always)]
848    pub fn is_enable(&self) -> bool {
849        *self == Tpie3::Enable
850    }
851}
852#[doc = "Field `TPIE3` writer - Tamper Pin n Interrupt Enable"]
853pub type Tpie3W<'a, REG> = crate::BitWriter<'a, REG, Tpie3>;
854impl<'a, REG> Tpie3W<'a, REG>
855where
856    REG: crate::Writable + crate::RegisterSpec,
857{
858    #[doc = "Disables"]
859    #[inline(always)]
860    pub fn disable(self) -> &'a mut crate::W<REG> {
861        self.variant(Tpie3::Disable)
862    }
863    #[doc = "Enables"]
864    #[inline(always)]
865    pub fn enable(self) -> &'a mut crate::W<REG> {
866        self.variant(Tpie3::Enable)
867    }
868}
869#[doc = "Tamper Pin n Interrupt Enable\n\nValue on reset: 0"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum Tpie4 {
873    #[doc = "0: Disables"]
874    Disable = 0,
875    #[doc = "1: Enables"]
876    Enable = 1,
877}
878impl From<Tpie4> for bool {
879    #[inline(always)]
880    fn from(variant: Tpie4) -> Self {
881        variant as u8 != 0
882    }
883}
884#[doc = "Field `TPIE4` reader - Tamper Pin n Interrupt Enable"]
885pub type Tpie4R = crate::BitReader<Tpie4>;
886impl Tpie4R {
887    #[doc = "Get enumerated values variant"]
888    #[inline(always)]
889    pub const fn variant(&self) -> Tpie4 {
890        match self.bits {
891            false => Tpie4::Disable,
892            true => Tpie4::Enable,
893        }
894    }
895    #[doc = "Disables"]
896    #[inline(always)]
897    pub fn is_disable(&self) -> bool {
898        *self == Tpie4::Disable
899    }
900    #[doc = "Enables"]
901    #[inline(always)]
902    pub fn is_enable(&self) -> bool {
903        *self == Tpie4::Enable
904    }
905}
906#[doc = "Field `TPIE4` writer - Tamper Pin n Interrupt Enable"]
907pub type Tpie4W<'a, REG> = crate::BitWriter<'a, REG, Tpie4>;
908impl<'a, REG> Tpie4W<'a, REG>
909where
910    REG: crate::Writable + crate::RegisterSpec,
911{
912    #[doc = "Disables"]
913    #[inline(always)]
914    pub fn disable(self) -> &'a mut crate::W<REG> {
915        self.variant(Tpie4::Disable)
916    }
917    #[doc = "Enables"]
918    #[inline(always)]
919    pub fn enable(self) -> &'a mut crate::W<REG> {
920        self.variant(Tpie4::Enable)
921    }
922}
923#[doc = "Tamper Pin n Interrupt Enable\n\nValue on reset: 0"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum Tpie5 {
927    #[doc = "0: Disables"]
928    Disable = 0,
929    #[doc = "1: Enables"]
930    Enable = 1,
931}
932impl From<Tpie5> for bool {
933    #[inline(always)]
934    fn from(variant: Tpie5) -> Self {
935        variant as u8 != 0
936    }
937}
938#[doc = "Field `TPIE5` reader - Tamper Pin n Interrupt Enable"]
939pub type Tpie5R = crate::BitReader<Tpie5>;
940impl Tpie5R {
941    #[doc = "Get enumerated values variant"]
942    #[inline(always)]
943    pub const fn variant(&self) -> Tpie5 {
944        match self.bits {
945            false => Tpie5::Disable,
946            true => Tpie5::Enable,
947        }
948    }
949    #[doc = "Disables"]
950    #[inline(always)]
951    pub fn is_disable(&self) -> bool {
952        *self == Tpie5::Disable
953    }
954    #[doc = "Enables"]
955    #[inline(always)]
956    pub fn is_enable(&self) -> bool {
957        *self == Tpie5::Enable
958    }
959}
960#[doc = "Field `TPIE5` writer - Tamper Pin n Interrupt Enable"]
961pub type Tpie5W<'a, REG> = crate::BitWriter<'a, REG, Tpie5>;
962impl<'a, REG> Tpie5W<'a, REG>
963where
964    REG: crate::Writable + crate::RegisterSpec,
965{
966    #[doc = "Disables"]
967    #[inline(always)]
968    pub fn disable(self) -> &'a mut crate::W<REG> {
969        self.variant(Tpie5::Disable)
970    }
971    #[doc = "Enables"]
972    #[inline(always)]
973    pub fn enable(self) -> &'a mut crate::W<REG> {
974        self.variant(Tpie5::Enable)
975    }
976}
977impl R {
978    #[doc = "Bit 0 - Digital Tamper Interrupt Enable"]
979    #[inline(always)]
980    pub fn dtie(&self) -> DtieR {
981        DtieR::new((self.bits & 1) != 0)
982    }
983    #[doc = "Bit 2 - Tamper Input n Interrupt Enable"]
984    #[inline(always)]
985    pub fn tiie0(&self) -> Tiie0R {
986        Tiie0R::new(((self.bits >> 2) & 1) != 0)
987    }
988    #[doc = "Bit 3 - Tamper Input n Interrupt Enable"]
989    #[inline(always)]
990    pub fn tiie1(&self) -> Tiie1R {
991        Tiie1R::new(((self.bits >> 3) & 1) != 0)
992    }
993    #[doc = "Bit 4 - Tamper Input n Interrupt Enable"]
994    #[inline(always)]
995    pub fn tiie2(&self) -> Tiie2R {
996        Tiie2R::new(((self.bits >> 4) & 1) != 0)
997    }
998    #[doc = "Bit 5 - Tamper Input n Interrupt Enable"]
999    #[inline(always)]
1000    pub fn tiie3(&self) -> Tiie3R {
1001        Tiie3R::new(((self.bits >> 5) & 1) != 0)
1002    }
1003    #[doc = "Bit 6 - Tamper Input n Interrupt Enable"]
1004    #[inline(always)]
1005    pub fn tiie4(&self) -> Tiie4R {
1006        Tiie4R::new(((self.bits >> 6) & 1) != 0)
1007    }
1008    #[doc = "Bit 7 - Tamper Input n Interrupt Enable"]
1009    #[inline(always)]
1010    pub fn tiie5(&self) -> Tiie5R {
1011        Tiie5R::new(((self.bits >> 7) & 1) != 0)
1012    }
1013    #[doc = "Bit 8 - Tamper Input n Interrupt Enable"]
1014    #[inline(always)]
1015    pub fn tiie6(&self) -> Tiie6R {
1016        Tiie6R::new(((self.bits >> 8) & 1) != 0)
1017    }
1018    #[doc = "Bit 9 - Tamper Input n Interrupt Enable"]
1019    #[inline(always)]
1020    pub fn tiie7(&self) -> Tiie7R {
1021        Tiie7R::new(((self.bits >> 9) & 1) != 0)
1022    }
1023    #[doc = "Bit 10 - Tamper Input n Interrupt Enable"]
1024    #[inline(always)]
1025    pub fn tiie8(&self) -> Tiie8R {
1026        Tiie8R::new(((self.bits >> 10) & 1) != 0)
1027    }
1028    #[doc = "Bit 11 - Tamper Input n Interrupt Enable"]
1029    #[inline(always)]
1030    pub fn tiie9(&self) -> Tiie9R {
1031        Tiie9R::new(((self.bits >> 11) & 1) != 0)
1032    }
1033    #[doc = "Bit 12 - Tamper Input n Interrupt Enable"]
1034    #[inline(always)]
1035    pub fn tiie10(&self) -> Tiie10R {
1036        Tiie10R::new(((self.bits >> 12) & 1) != 0)
1037    }
1038    #[doc = "Bit 16 - Tamper Pin n Interrupt Enable"]
1039    #[inline(always)]
1040    pub fn tpie0(&self) -> Tpie0R {
1041        Tpie0R::new(((self.bits >> 16) & 1) != 0)
1042    }
1043    #[doc = "Bit 17 - Tamper Pin n Interrupt Enable"]
1044    #[inline(always)]
1045    pub fn tpie1(&self) -> Tpie1R {
1046        Tpie1R::new(((self.bits >> 17) & 1) != 0)
1047    }
1048    #[doc = "Bit 18 - Tamper Pin n Interrupt Enable"]
1049    #[inline(always)]
1050    pub fn tpie2(&self) -> Tpie2R {
1051        Tpie2R::new(((self.bits >> 18) & 1) != 0)
1052    }
1053    #[doc = "Bit 19 - Tamper Pin n Interrupt Enable"]
1054    #[inline(always)]
1055    pub fn tpie3(&self) -> Tpie3R {
1056        Tpie3R::new(((self.bits >> 19) & 1) != 0)
1057    }
1058    #[doc = "Bit 20 - Tamper Pin n Interrupt Enable"]
1059    #[inline(always)]
1060    pub fn tpie4(&self) -> Tpie4R {
1061        Tpie4R::new(((self.bits >> 20) & 1) != 0)
1062    }
1063    #[doc = "Bit 21 - Tamper Pin n Interrupt Enable"]
1064    #[inline(always)]
1065    pub fn tpie5(&self) -> Tpie5R {
1066        Tpie5R::new(((self.bits >> 21) & 1) != 0)
1067    }
1068}
1069#[cfg(feature = "debug")]
1070impl core::fmt::Debug for R {
1071    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1072        f.debug_struct("IER")
1073            .field("dtie", &self.dtie())
1074            .field("tiie0", &self.tiie0())
1075            .field("tiie1", &self.tiie1())
1076            .field("tiie2", &self.tiie2())
1077            .field("tiie3", &self.tiie3())
1078            .field("tiie4", &self.tiie4())
1079            .field("tiie5", &self.tiie5())
1080            .field("tiie6", &self.tiie6())
1081            .field("tiie7", &self.tiie7())
1082            .field("tiie8", &self.tiie8())
1083            .field("tiie9", &self.tiie9())
1084            .field("tiie10", &self.tiie10())
1085            .field("tpie0", &self.tpie0())
1086            .field("tpie1", &self.tpie1())
1087            .field("tpie2", &self.tpie2())
1088            .field("tpie3", &self.tpie3())
1089            .field("tpie4", &self.tpie4())
1090            .field("tpie5", &self.tpie5())
1091            .finish()
1092    }
1093}
1094impl W {
1095    #[doc = "Bit 0 - Digital Tamper Interrupt Enable"]
1096    #[inline(always)]
1097    pub fn dtie(&mut self) -> DtieW<'_, IerSpec> {
1098        DtieW::new(self, 0)
1099    }
1100    #[doc = "Bit 2 - Tamper Input n Interrupt Enable"]
1101    #[inline(always)]
1102    pub fn tiie0(&mut self) -> Tiie0W<'_, IerSpec> {
1103        Tiie0W::new(self, 2)
1104    }
1105    #[doc = "Bit 3 - Tamper Input n Interrupt Enable"]
1106    #[inline(always)]
1107    pub fn tiie1(&mut self) -> Tiie1W<'_, IerSpec> {
1108        Tiie1W::new(self, 3)
1109    }
1110    #[doc = "Bit 4 - Tamper Input n Interrupt Enable"]
1111    #[inline(always)]
1112    pub fn tiie2(&mut self) -> Tiie2W<'_, IerSpec> {
1113        Tiie2W::new(self, 4)
1114    }
1115    #[doc = "Bit 5 - Tamper Input n Interrupt Enable"]
1116    #[inline(always)]
1117    pub fn tiie3(&mut self) -> Tiie3W<'_, IerSpec> {
1118        Tiie3W::new(self, 5)
1119    }
1120    #[doc = "Bit 6 - Tamper Input n Interrupt Enable"]
1121    #[inline(always)]
1122    pub fn tiie4(&mut self) -> Tiie4W<'_, IerSpec> {
1123        Tiie4W::new(self, 6)
1124    }
1125    #[doc = "Bit 7 - Tamper Input n Interrupt Enable"]
1126    #[inline(always)]
1127    pub fn tiie5(&mut self) -> Tiie5W<'_, IerSpec> {
1128        Tiie5W::new(self, 7)
1129    }
1130    #[doc = "Bit 8 - Tamper Input n Interrupt Enable"]
1131    #[inline(always)]
1132    pub fn tiie6(&mut self) -> Tiie6W<'_, IerSpec> {
1133        Tiie6W::new(self, 8)
1134    }
1135    #[doc = "Bit 9 - Tamper Input n Interrupt Enable"]
1136    #[inline(always)]
1137    pub fn tiie7(&mut self) -> Tiie7W<'_, IerSpec> {
1138        Tiie7W::new(self, 9)
1139    }
1140    #[doc = "Bit 10 - Tamper Input n Interrupt Enable"]
1141    #[inline(always)]
1142    pub fn tiie8(&mut self) -> Tiie8W<'_, IerSpec> {
1143        Tiie8W::new(self, 10)
1144    }
1145    #[doc = "Bit 11 - Tamper Input n Interrupt Enable"]
1146    #[inline(always)]
1147    pub fn tiie9(&mut self) -> Tiie9W<'_, IerSpec> {
1148        Tiie9W::new(self, 11)
1149    }
1150    #[doc = "Bit 12 - Tamper Input n Interrupt Enable"]
1151    #[inline(always)]
1152    pub fn tiie10(&mut self) -> Tiie10W<'_, IerSpec> {
1153        Tiie10W::new(self, 12)
1154    }
1155    #[doc = "Bit 16 - Tamper Pin n Interrupt Enable"]
1156    #[inline(always)]
1157    pub fn tpie0(&mut self) -> Tpie0W<'_, IerSpec> {
1158        Tpie0W::new(self, 16)
1159    }
1160    #[doc = "Bit 17 - Tamper Pin n Interrupt Enable"]
1161    #[inline(always)]
1162    pub fn tpie1(&mut self) -> Tpie1W<'_, IerSpec> {
1163        Tpie1W::new(self, 17)
1164    }
1165    #[doc = "Bit 18 - Tamper Pin n Interrupt Enable"]
1166    #[inline(always)]
1167    pub fn tpie2(&mut self) -> Tpie2W<'_, IerSpec> {
1168        Tpie2W::new(self, 18)
1169    }
1170    #[doc = "Bit 19 - Tamper Pin n Interrupt Enable"]
1171    #[inline(always)]
1172    pub fn tpie3(&mut self) -> Tpie3W<'_, IerSpec> {
1173        Tpie3W::new(self, 19)
1174    }
1175    #[doc = "Bit 20 - Tamper Pin n Interrupt Enable"]
1176    #[inline(always)]
1177    pub fn tpie4(&mut self) -> Tpie4W<'_, IerSpec> {
1178        Tpie4W::new(self, 20)
1179    }
1180    #[doc = "Bit 21 - Tamper Pin n Interrupt Enable"]
1181    #[inline(always)]
1182    pub fn tpie5(&mut self) -> Tpie5W<'_, IerSpec> {
1183        Tpie5W::new(self, 21)
1184    }
1185}
1186#[doc = "Interrupt Enable\n\nYou can [`read`](crate::Reg::read) this register and get [`ier::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`ier::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
1187pub struct IerSpec;
1188impl crate::RegisterSpec for IerSpec {
1189    type Ux = u32;
1190}
1191#[doc = "`read()` method returns [`ier::R`](R) reader structure"]
1192impl crate::Readable for IerSpec {}
1193#[doc = "`write(|w| ..)` method takes [`ier::W`](W) writer structure"]
1194impl crate::Writable for IerSpec {
1195    type Safety = crate::Unsafe;
1196}
1197#[doc = "`reset()` method sets IER to value 0"]
1198impl crate::Resettable for IerSpec {}
mcxa_pac/tdet0/ier.rs

mcxa_pac/tdet0/
ier.rs
