mcxa_pac/tdet0/
sr.rs

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

mcxa_pac/tdet0/
sr.rs
