mcxa_pac/tdet0/
pgfr.rs

1#[doc = "Register `PGFR[%s]` reader"]
2pub type R = crate::R<PgfrSpec>;
3#[doc = "Register `PGFR[%s]` writer"]
4pub type W = crate::W<PgfrSpec>;
5#[doc = "Field `GFW` reader - Glitch Filter Width"]
6pub type GfwR = crate::FieldReader;
7#[doc = "Field `GFW` writer - Glitch Filter Width"]
8pub type GfwW<'a, REG> = crate::FieldWriter<'a, REG, 6>;
9#[doc = "Glitch Filter Prescaler\n\nValue on reset: 0"]
10#[cfg_attr(feature = "defmt", derive(defmt::Format))]
11#[derive(Clone, Copy, Debug, PartialEq, Eq)]
12pub enum Gfp {
13    #[doc = "0: 512 Hz prescaler clock"]
14    Freq512Hz = 0,
15    #[doc = "1: 32.768 kHz clock"]
16    Freq32Khz = 1,
17}
18impl From<Gfp> for bool {
19    #[inline(always)]
20    fn from(variant: Gfp) -> Self {
21        variant as u8 != 0
22    }
23}
24#[doc = "Field `GFP` reader - Glitch Filter Prescaler"]
25pub type GfpR = crate::BitReader<Gfp>;
26impl GfpR {
27    #[doc = "Get enumerated values variant"]
28    #[inline(always)]
29    pub const fn variant(&self) -> Gfp {
30        match self.bits {
31            false => Gfp::Freq512Hz,
32            true => Gfp::Freq32Khz,
33        }
34    }
35    #[doc = "512 Hz prescaler clock"]
36    #[inline(always)]
37    pub fn is_freq_512_hz(&self) -> bool {
38        *self == Gfp::Freq512Hz
39    }
40    #[doc = "32.768 kHz clock"]
41    #[inline(always)]
42    pub fn is_freq_32_khz(&self) -> bool {
43        *self == Gfp::Freq32Khz
44    }
45}
46#[doc = "Field `GFP` writer - Glitch Filter Prescaler"]
47pub type GfpW<'a, REG> = crate::BitWriter<'a, REG, Gfp>;
48impl<'a, REG> GfpW<'a, REG>
49where
50    REG: crate::Writable + crate::RegisterSpec,
51{
52    #[doc = "512 Hz prescaler clock"]
53    #[inline(always)]
54    pub fn freq_512_hz(self) -> &'a mut crate::W<REG> {
55        self.variant(Gfp::Freq512Hz)
56    }
57    #[doc = "32.768 kHz clock"]
58    #[inline(always)]
59    pub fn freq_32_khz(self) -> &'a mut crate::W<REG> {
60        self.variant(Gfp::Freq32Khz)
61    }
62}
63#[doc = "Glitch Filter Enable\n\nValue on reset: 0"]
64#[cfg_attr(feature = "defmt", derive(defmt::Format))]
65#[derive(Clone, Copy, Debug, PartialEq, Eq)]
66pub enum Gfe {
67    #[doc = "0: Bypasses"]
68    Bypass = 0,
69    #[doc = "1: Enables"]
70    Enable = 1,
71}
72impl From<Gfe> for bool {
73    #[inline(always)]
74    fn from(variant: Gfe) -> Self {
75        variant as u8 != 0
76    }
77}
78#[doc = "Field `GFE` reader - Glitch Filter Enable"]
79pub type GfeR = crate::BitReader<Gfe>;
80impl GfeR {
81    #[doc = "Get enumerated values variant"]
82    #[inline(always)]
83    pub const fn variant(&self) -> Gfe {
84        match self.bits {
85            false => Gfe::Bypass,
86            true => Gfe::Enable,
87        }
88    }
89    #[doc = "Bypasses"]
90    #[inline(always)]
91    pub fn is_bypass(&self) -> bool {
92        *self == Gfe::Bypass
93    }
94    #[doc = "Enables"]
95    #[inline(always)]
96    pub fn is_enable(&self) -> bool {
97        *self == Gfe::Enable
98    }
99}
100#[doc = "Field `GFE` writer - Glitch Filter Enable"]
101pub type GfeW<'a, REG> = crate::BitWriter<'a, REG, Gfe>;
102impl<'a, REG> GfeW<'a, REG>
103where
104    REG: crate::Writable + crate::RegisterSpec,
105{
106    #[doc = "Bypasses"]
107    #[inline(always)]
108    pub fn bypass(self) -> &'a mut crate::W<REG> {
109        self.variant(Gfe::Bypass)
110    }
111    #[doc = "Enables"]
112    #[inline(always)]
113    pub fn enable(self) -> &'a mut crate::W<REG> {
114        self.variant(Gfe::Enable)
115    }
116}
117#[doc = "Tamper Pin Sample Width\n\nValue on reset: 0"]
118#[cfg_attr(feature = "defmt", derive(defmt::Format))]
119#[derive(Clone, Copy, Debug, PartialEq, Eq)]
120#[repr(u8)]
121pub enum Tpsw {
122    #[doc = "0: Continuous monitoring, pin sampling disabled"]
123    Disable = 0,
124    #[doc = "1: 2 cycles for pull enable and 1 cycle for input buffer enable"]
125    Cycles2 = 1,
126    #[doc = "2: 4 cycles for pull enable and 2 cycles for input buffer enable"]
127    Cycles4 = 2,
128    #[doc = "3: 8 cycles for pull enable and 4 cycles for input buffer enable"]
129    Cycles8 = 3,
130}
131impl From<Tpsw> for u8 {
132    #[inline(always)]
133    fn from(variant: Tpsw) -> Self {
134        variant as _
135    }
136}
137impl crate::FieldSpec for Tpsw {
138    type Ux = u8;
139}
140impl crate::IsEnum for Tpsw {}
141#[doc = "Field `TPSW` reader - Tamper Pin Sample Width"]
142pub type TpswR = crate::FieldReader<Tpsw>;
143impl TpswR {
144    #[doc = "Get enumerated values variant"]
145    #[inline(always)]
146    pub const fn variant(&self) -> Tpsw {
147        match self.bits {
148            0 => Tpsw::Disable,
149            1 => Tpsw::Cycles2,
150            2 => Tpsw::Cycles4,
151            3 => Tpsw::Cycles8,
152            _ => unreachable!(),
153        }
154    }
155    #[doc = "Continuous monitoring, pin sampling disabled"]
156    #[inline(always)]
157    pub fn is_disable(&self) -> bool {
158        *self == Tpsw::Disable
159    }
160    #[doc = "2 cycles for pull enable and 1 cycle for input buffer enable"]
161    #[inline(always)]
162    pub fn is_cycles_2(&self) -> bool {
163        *self == Tpsw::Cycles2
164    }
165    #[doc = "4 cycles for pull enable and 2 cycles for input buffer enable"]
166    #[inline(always)]
167    pub fn is_cycles_4(&self) -> bool {
168        *self == Tpsw::Cycles4
169    }
170    #[doc = "8 cycles for pull enable and 4 cycles for input buffer enable"]
171    #[inline(always)]
172    pub fn is_cycles_8(&self) -> bool {
173        *self == Tpsw::Cycles8
174    }
175}
176#[doc = "Field `TPSW` writer - Tamper Pin Sample Width"]
177pub type TpswW<'a, REG> = crate::FieldWriter<'a, REG, 2, Tpsw, crate::Safe>;
178impl<'a, REG> TpswW<'a, REG>
179where
180    REG: crate::Writable + crate::RegisterSpec,
181    REG::Ux: From<u8>,
182{
183    #[doc = "Continuous monitoring, pin sampling disabled"]
184    #[inline(always)]
185    pub fn disable(self) -> &'a mut crate::W<REG> {
186        self.variant(Tpsw::Disable)
187    }
188    #[doc = "2 cycles for pull enable and 1 cycle for input buffer enable"]
189    #[inline(always)]
190    pub fn cycles_2(self) -> &'a mut crate::W<REG> {
191        self.variant(Tpsw::Cycles2)
192    }
193    #[doc = "4 cycles for pull enable and 2 cycles for input buffer enable"]
194    #[inline(always)]
195    pub fn cycles_4(self) -> &'a mut crate::W<REG> {
196        self.variant(Tpsw::Cycles4)
197    }
198    #[doc = "8 cycles for pull enable and 4 cycles for input buffer enable"]
199    #[inline(always)]
200    pub fn cycles_8(self) -> &'a mut crate::W<REG> {
201        self.variant(Tpsw::Cycles8)
202    }
203}
204#[doc = "Tamper Pin Sample Frequency\n\nValue on reset: 0"]
205#[cfg_attr(feature = "defmt", derive(defmt::Format))]
206#[derive(Clone, Copy, Debug, PartialEq, Eq)]
207#[repr(u8)]
208pub enum Tpsf {
209    #[doc = "0: Every 8 cycles"]
210    Cycles8 = 0,
211    #[doc = "1: Every 32 cycles"]
212    Cycles32 = 1,
213    #[doc = "2: Every 128 cycles"]
214    Cycles128 = 2,
215    #[doc = "3: Every 512 cycles"]
216    Cycles512 = 3,
217}
218impl From<Tpsf> for u8 {
219    #[inline(always)]
220    fn from(variant: Tpsf) -> Self {
221        variant as _
222    }
223}
224impl crate::FieldSpec for Tpsf {
225    type Ux = u8;
226}
227impl crate::IsEnum for Tpsf {}
228#[doc = "Field `TPSF` reader - Tamper Pin Sample Frequency"]
229pub type TpsfR = crate::FieldReader<Tpsf>;
230impl TpsfR {
231    #[doc = "Get enumerated values variant"]
232    #[inline(always)]
233    pub const fn variant(&self) -> Tpsf {
234        match self.bits {
235            0 => Tpsf::Cycles8,
236            1 => Tpsf::Cycles32,
237            2 => Tpsf::Cycles128,
238            3 => Tpsf::Cycles512,
239            _ => unreachable!(),
240        }
241    }
242    #[doc = "Every 8 cycles"]
243    #[inline(always)]
244    pub fn is_cycles_8(&self) -> bool {
245        *self == Tpsf::Cycles8
246    }
247    #[doc = "Every 32 cycles"]
248    #[inline(always)]
249    pub fn is_cycles_32(&self) -> bool {
250        *self == Tpsf::Cycles32
251    }
252    #[doc = "Every 128 cycles"]
253    #[inline(always)]
254    pub fn is_cycles_128(&self) -> bool {
255        *self == Tpsf::Cycles128
256    }
257    #[doc = "Every 512 cycles"]
258    #[inline(always)]
259    pub fn is_cycles_512(&self) -> bool {
260        *self == Tpsf::Cycles512
261    }
262}
263#[doc = "Field `TPSF` writer - Tamper Pin Sample Frequency"]
264pub type TpsfW<'a, REG> = crate::FieldWriter<'a, REG, 2, Tpsf, crate::Safe>;
265impl<'a, REG> TpsfW<'a, REG>
266where
267    REG: crate::Writable + crate::RegisterSpec,
268    REG::Ux: From<u8>,
269{
270    #[doc = "Every 8 cycles"]
271    #[inline(always)]
272    pub fn cycles_8(self) -> &'a mut crate::W<REG> {
273        self.variant(Tpsf::Cycles8)
274    }
275    #[doc = "Every 32 cycles"]
276    #[inline(always)]
277    pub fn cycles_32(self) -> &'a mut crate::W<REG> {
278        self.variant(Tpsf::Cycles32)
279    }
280    #[doc = "Every 128 cycles"]
281    #[inline(always)]
282    pub fn cycles_128(self) -> &'a mut crate::W<REG> {
283        self.variant(Tpsf::Cycles128)
284    }
285    #[doc = "Every 512 cycles"]
286    #[inline(always)]
287    pub fn cycles_512(self) -> &'a mut crate::W<REG> {
288        self.variant(Tpsf::Cycles512)
289    }
290}
291#[doc = "Tamper Pull Enable\n\nValue on reset: 0"]
292#[cfg_attr(feature = "defmt", derive(defmt::Format))]
293#[derive(Clone, Copy, Debug, PartialEq, Eq)]
294pub enum Tpe {
295    #[doc = "0: Disables"]
296    Disable = 0,
297    #[doc = "1: Enables"]
298    Enable = 1,
299}
300impl From<Tpe> for bool {
301    #[inline(always)]
302    fn from(variant: Tpe) -> Self {
303        variant as u8 != 0
304    }
305}
306#[doc = "Field `TPE` reader - Tamper Pull Enable"]
307pub type TpeR = crate::BitReader<Tpe>;
308impl TpeR {
309    #[doc = "Get enumerated values variant"]
310    #[inline(always)]
311    pub const fn variant(&self) -> Tpe {
312        match self.bits {
313            false => Tpe::Disable,
314            true => Tpe::Enable,
315        }
316    }
317    #[doc = "Disables"]
318    #[inline(always)]
319    pub fn is_disable(&self) -> bool {
320        *self == Tpe::Disable
321    }
322    #[doc = "Enables"]
323    #[inline(always)]
324    pub fn is_enable(&self) -> bool {
325        *self == Tpe::Enable
326    }
327}
328#[doc = "Field `TPE` writer - Tamper Pull Enable"]
329pub type TpeW<'a, REG> = crate::BitWriter<'a, REG, Tpe>;
330impl<'a, REG> TpeW<'a, REG>
331where
332    REG: crate::Writable + crate::RegisterSpec,
333{
334    #[doc = "Disables"]
335    #[inline(always)]
336    pub fn disable(self) -> &'a mut crate::W<REG> {
337        self.variant(Tpe::Disable)
338    }
339    #[doc = "Enables"]
340    #[inline(always)]
341    pub fn enable(self) -> &'a mut crate::W<REG> {
342        self.variant(Tpe::Enable)
343    }
344}
345#[doc = "Tamper Pull Select\n\nValue on reset: 0"]
346#[cfg_attr(feature = "defmt", derive(defmt::Format))]
347#[derive(Clone, Copy, Debug, PartialEq, Eq)]
348pub enum Tps {
349    #[doc = "0: Asserts"]
350    Assert = 0,
351    #[doc = "1: Negates"]
352    Negate = 1,
353}
354impl From<Tps> for bool {
355    #[inline(always)]
356    fn from(variant: Tps) -> Self {
357        variant as u8 != 0
358    }
359}
360#[doc = "Field `TPS` reader - Tamper Pull Select"]
361pub type TpsR = crate::BitReader<Tps>;
362impl TpsR {
363    #[doc = "Get enumerated values variant"]
364    #[inline(always)]
365    pub const fn variant(&self) -> Tps {
366        match self.bits {
367            false => Tps::Assert,
368            true => Tps::Negate,
369        }
370    }
371    #[doc = "Asserts"]
372    #[inline(always)]
373    pub fn is_assert(&self) -> bool {
374        *self == Tps::Assert
375    }
376    #[doc = "Negates"]
377    #[inline(always)]
378    pub fn is_negate(&self) -> bool {
379        *self == Tps::Negate
380    }
381}
382#[doc = "Field `TPS` writer - Tamper Pull Select"]
383pub type TpsW<'a, REG> = crate::BitWriter<'a, REG, Tps>;
384impl<'a, REG> TpsW<'a, REG>
385where
386    REG: crate::Writable + crate::RegisterSpec,
387{
388    #[doc = "Asserts"]
389    #[inline(always)]
390    pub fn assert(self) -> &'a mut crate::W<REG> {
391        self.variant(Tps::Assert)
392    }
393    #[doc = "Negates"]
394    #[inline(always)]
395    pub fn negate(self) -> &'a mut crate::W<REG> {
396        self.variant(Tps::Negate)
397    }
398}
399#[doc = "Tamper Pull Value\n\nValue on reset: 0"]
400#[cfg_attr(feature = "defmt", derive(defmt::Format))]
401#[derive(Clone, Copy, Debug, PartialEq, Eq)]
402pub enum Tpv {
403    #[doc = "0: Low"]
404    Low = 0,
405    #[doc = "1: High"]
406    High = 1,
407}
408impl From<Tpv> for bool {
409    #[inline(always)]
410    fn from(variant: Tpv) -> Self {
411        variant as u8 != 0
412    }
413}
414#[doc = "Field `TPV` reader - Tamper Pull Value"]
415pub type TpvR = crate::BitReader<Tpv>;
416impl TpvR {
417    #[doc = "Get enumerated values variant"]
418    #[inline(always)]
419    pub const fn variant(&self) -> Tpv {
420        match self.bits {
421            false => Tpv::Low,
422            true => Tpv::High,
423        }
424    }
425    #[doc = "Low"]
426    #[inline(always)]
427    pub fn is_low(&self) -> bool {
428        *self == Tpv::Low
429    }
430    #[doc = "High"]
431    #[inline(always)]
432    pub fn is_high(&self) -> bool {
433        *self == Tpv::High
434    }
435}
436#[doc = "Field `TPV` writer - Tamper Pull Value"]
437pub type TpvW<'a, REG> = crate::BitWriter<'a, REG, Tpv>;
438impl<'a, REG> TpvW<'a, REG>
439where
440    REG: crate::Writable + crate::RegisterSpec,
441{
442    #[doc = "Low"]
443    #[inline(always)]
444    pub fn low(self) -> &'a mut crate::W<REG> {
445        self.variant(Tpv::Low)
446    }
447    #[doc = "High"]
448    #[inline(always)]
449    pub fn high(self) -> &'a mut crate::W<REG> {
450        self.variant(Tpv::High)
451    }
452}
453#[doc = "Tamper Passive Filter\n\nValue on reset: 0"]
454#[cfg_attr(feature = "defmt", derive(defmt::Format))]
455#[derive(Clone, Copy, Debug, PartialEq, Eq)]
456pub enum Tpf {
457    #[doc = "0: Disables"]
458    Disable = 0,
459    #[doc = "1: Enables"]
460    Enable = 1,
461}
462impl From<Tpf> for bool {
463    #[inline(always)]
464    fn from(variant: Tpf) -> Self {
465        variant as u8 != 0
466    }
467}
468#[doc = "Field `TPF` reader - Tamper Passive Filter"]
469pub type TpfR = crate::BitReader<Tpf>;
470impl TpfR {
471    #[doc = "Get enumerated values variant"]
472    #[inline(always)]
473    pub const fn variant(&self) -> Tpf {
474        match self.bits {
475            false => Tpf::Disable,
476            true => Tpf::Enable,
477        }
478    }
479    #[doc = "Disables"]
480    #[inline(always)]
481    pub fn is_disable(&self) -> bool {
482        *self == Tpf::Disable
483    }
484    #[doc = "Enables"]
485    #[inline(always)]
486    pub fn is_enable(&self) -> bool {
487        *self == Tpf::Enable
488    }
489}
490#[doc = "Field `TPF` writer - Tamper Passive Filter"]
491pub type TpfW<'a, REG> = crate::BitWriter<'a, REG, Tpf>;
492impl<'a, REG> TpfW<'a, REG>
493where
494    REG: crate::Writable + crate::RegisterSpec,
495{
496    #[doc = "Disables"]
497    #[inline(always)]
498    pub fn disable(self) -> &'a mut crate::W<REG> {
499        self.variant(Tpf::Disable)
500    }
501    #[doc = "Enables"]
502    #[inline(always)]
503    pub fn enable(self) -> &'a mut crate::W<REG> {
504        self.variant(Tpf::Enable)
505    }
506}
507#[doc = "Input Buffer Enable\n\nValue on reset: 0"]
508#[cfg_attr(feature = "defmt", derive(defmt::Format))]
509#[derive(Clone, Copy, Debug, PartialEq, Eq)]
510pub enum Ibe {
511    #[doc = "0: Disables"]
512    Disable = 0,
513    #[doc = "1: Enables"]
514    Enable = 1,
515}
516impl From<Ibe> for bool {
517    #[inline(always)]
518    fn from(variant: Ibe) -> Self {
519        variant as u8 != 0
520    }
521}
522#[doc = "Field `IBE` reader - Input Buffer Enable"]
523pub type IbeR = crate::BitReader<Ibe>;
524impl IbeR {
525    #[doc = "Get enumerated values variant"]
526    #[inline(always)]
527    pub const fn variant(&self) -> Ibe {
528        match self.bits {
529            false => Ibe::Disable,
530            true => Ibe::Enable,
531        }
532    }
533    #[doc = "Disables"]
534    #[inline(always)]
535    pub fn is_disable(&self) -> bool {
536        *self == Ibe::Disable
537    }
538    #[doc = "Enables"]
539    #[inline(always)]
540    pub fn is_enable(&self) -> bool {
541        *self == Ibe::Enable
542    }
543}
544#[doc = "Field `IBE` writer - Input Buffer Enable"]
545pub type IbeW<'a, REG> = crate::BitWriter<'a, REG, Ibe>;
546impl<'a, REG> IbeW<'a, REG>
547where
548    REG: crate::Writable + crate::RegisterSpec,
549{
550    #[doc = "Disables"]
551    #[inline(always)]
552    pub fn disable(self) -> &'a mut crate::W<REG> {
553        self.variant(Ibe::Disable)
554    }
555    #[doc = "Enables"]
556    #[inline(always)]
557    pub fn enable(self) -> &'a mut crate::W<REG> {
558        self.variant(Ibe::Enable)
559    }
560}
561impl R {
562    #[doc = "Bits 0:5 - Glitch Filter Width"]
563    #[inline(always)]
564    pub fn gfw(&self) -> GfwR {
565        GfwR::new((self.bits & 0x3f) as u8)
566    }
567    #[doc = "Bit 6 - Glitch Filter Prescaler"]
568    #[inline(always)]
569    pub fn gfp(&self) -> GfpR {
570        GfpR::new(((self.bits >> 6) & 1) != 0)
571    }
572    #[doc = "Bit 7 - Glitch Filter Enable"]
573    #[inline(always)]
574    pub fn gfe(&self) -> GfeR {
575        GfeR::new(((self.bits >> 7) & 1) != 0)
576    }
577    #[doc = "Bits 8:9 - Tamper Pin Sample Width"]
578    #[inline(always)]
579    pub fn tpsw(&self) -> TpswR {
580        TpswR::new(((self.bits >> 8) & 3) as u8)
581    }
582    #[doc = "Bits 10:11 - Tamper Pin Sample Frequency"]
583    #[inline(always)]
584    pub fn tpsf(&self) -> TpsfR {
585        TpsfR::new(((self.bits >> 10) & 3) as u8)
586    }
587    #[doc = "Bit 24 - Tamper Pull Enable"]
588    #[inline(always)]
589    pub fn tpe(&self) -> TpeR {
590        TpeR::new(((self.bits >> 24) & 1) != 0)
591    }
592    #[doc = "Bit 25 - Tamper Pull Select"]
593    #[inline(always)]
594    pub fn tps(&self) -> TpsR {
595        TpsR::new(((self.bits >> 25) & 1) != 0)
596    }
597    #[doc = "Bit 26 - Tamper Pull Value"]
598    #[inline(always)]
599    pub fn tpv(&self) -> TpvR {
600        TpvR::new(((self.bits >> 26) & 1) != 0)
601    }
602    #[doc = "Bit 27 - Tamper Passive Filter"]
603    #[inline(always)]
604    pub fn tpf(&self) -> TpfR {
605        TpfR::new(((self.bits >> 27) & 1) != 0)
606    }
607    #[doc = "Bit 31 - Input Buffer Enable"]
608    #[inline(always)]
609    pub fn ibe(&self) -> IbeR {
610        IbeR::new(((self.bits >> 31) & 1) != 0)
611    }
612}
613#[cfg(feature = "debug")]
614impl core::fmt::Debug for R {
615    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
616        f.debug_struct("PGFR")
617            .field("gfw", &self.gfw())
618            .field("gfp", &self.gfp())
619            .field("gfe", &self.gfe())
620            .field("tpsw", &self.tpsw())
621            .field("tpsf", &self.tpsf())
622            .field("tpe", &self.tpe())
623            .field("tps", &self.tps())
624            .field("tpv", &self.tpv())
625            .field("tpf", &self.tpf())
626            .field("ibe", &self.ibe())
627            .finish()
628    }
629}
630impl W {
631    #[doc = "Bits 0:5 - Glitch Filter Width"]
632    #[inline(always)]
633    pub fn gfw(&mut self) -> GfwW<'_, PgfrSpec> {
634        GfwW::new(self, 0)
635    }
636    #[doc = "Bit 6 - Glitch Filter Prescaler"]
637    #[inline(always)]
638    pub fn gfp(&mut self) -> GfpW<'_, PgfrSpec> {
639        GfpW::new(self, 6)
640    }
641    #[doc = "Bit 7 - Glitch Filter Enable"]
642    #[inline(always)]
643    pub fn gfe(&mut self) -> GfeW<'_, PgfrSpec> {
644        GfeW::new(self, 7)
645    }
646    #[doc = "Bits 8:9 - Tamper Pin Sample Width"]
647    #[inline(always)]
648    pub fn tpsw(&mut self) -> TpswW<'_, PgfrSpec> {
649        TpswW::new(self, 8)
650    }
651    #[doc = "Bits 10:11 - Tamper Pin Sample Frequency"]
652    #[inline(always)]
653    pub fn tpsf(&mut self) -> TpsfW<'_, PgfrSpec> {
654        TpsfW::new(self, 10)
655    }
656    #[doc = "Bit 24 - Tamper Pull Enable"]
657    #[inline(always)]
658    pub fn tpe(&mut self) -> TpeW<'_, PgfrSpec> {
659        TpeW::new(self, 24)
660    }
661    #[doc = "Bit 25 - Tamper Pull Select"]
662    #[inline(always)]
663    pub fn tps(&mut self) -> TpsW<'_, PgfrSpec> {
664        TpsW::new(self, 25)
665    }
666    #[doc = "Bit 26 - Tamper Pull Value"]
667    #[inline(always)]
668    pub fn tpv(&mut self) -> TpvW<'_, PgfrSpec> {
669        TpvW::new(self, 26)
670    }
671    #[doc = "Bit 27 - Tamper Passive Filter"]
672    #[inline(always)]
673    pub fn tpf(&mut self) -> TpfW<'_, PgfrSpec> {
674        TpfW::new(self, 27)
675    }
676    #[doc = "Bit 31 - Input Buffer Enable"]
677    #[inline(always)]
678    pub fn ibe(&mut self) -> IbeW<'_, PgfrSpec> {
679        IbeW::new(self, 31)
680    }
681}
682#[doc = "Pin Glitch Filter\n\nYou can [`read`](crate::Reg::read) this register and get [`pgfr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pgfr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
683pub struct PgfrSpec;
684impl crate::RegisterSpec for PgfrSpec {
685    type Ux = u32;
686}
687#[doc = "`read()` method returns [`pgfr::R`](R) reader structure"]
688impl crate::Readable for PgfrSpec {}
689#[doc = "`write(|w| ..)` method takes [`pgfr::W`](W) writer structure"]
690impl crate::Writable for PgfrSpec {
691    type Safety = crate::Unsafe;
692}
693#[doc = "`reset()` method sets PGFR[%s] to value 0"]
694impl crate::Resettable for PgfrSpec {}
mcxa_pac/tdet0/pgfr.rs

mcxa_pac/tdet0/
pgfr.rs
