mcxa_pac/inputmux0/
trigfil_stat0.rs

1#[doc = "Register `TRIGFIL_STAT0` reader"]
2pub type R = crate::R<TrigfilStat0Spec>;
3#[doc = "TRIG_IN value\n\nValue on reset: 0"]
4#[cfg_attr(feature = "defmt", derive(defmt::Format))]
5#[derive(Clone, Copy, Debug, PartialEq, Eq)]
6pub enum TrigIn0Val {
7    #[doc = "0: TRIG_IN0 is 0"]
8    Val0 = 0,
9    #[doc = "1: TRIG_IN0 is 1"]
10    Val1 = 1,
11}
12impl From<TrigIn0Val> for bool {
13    #[inline(always)]
14    fn from(variant: TrigIn0Val) -> Self {
15        variant as u8 != 0
16    }
17}
18#[doc = "Field `TRIG_IN0_VAL` reader - TRIG_IN value"]
19pub type TrigIn0ValR = crate::BitReader<TrigIn0Val>;
20impl TrigIn0ValR {
21    #[doc = "Get enumerated values variant"]
22    #[inline(always)]
23    pub const fn variant(&self) -> TrigIn0Val {
24        match self.bits {
25            false => TrigIn0Val::Val0,
26            true => TrigIn0Val::Val1,
27        }
28    }
29    #[doc = "TRIG_IN0 is 0"]
30    #[inline(always)]
31    pub fn is_val0(&self) -> bool {
32        *self == TrigIn0Val::Val0
33    }
34    #[doc = "TRIG_IN0 is 1"]
35    #[inline(always)]
36    pub fn is_val1(&self) -> bool {
37        *self == TrigIn0Val::Val1
38    }
39}
40#[doc = "TRIG_IN value\n\nValue on reset: 0"]
41#[cfg_attr(feature = "defmt", derive(defmt::Format))]
42#[derive(Clone, Copy, Debug, PartialEq, Eq)]
43pub enum TrigIn1Val {
44    #[doc = "0: TRIG_IN1 is 0"]
45    Val0 = 0,
46    #[doc = "1: TRIG_IN1 is 1"]
47    Val1 = 1,
48}
49impl From<TrigIn1Val> for bool {
50    #[inline(always)]
51    fn from(variant: TrigIn1Val) -> Self {
52        variant as u8 != 0
53    }
54}
55#[doc = "Field `TRIG_IN1_VAL` reader - TRIG_IN value"]
56pub type TrigIn1ValR = crate::BitReader<TrigIn1Val>;
57impl TrigIn1ValR {
58    #[doc = "Get enumerated values variant"]
59    #[inline(always)]
60    pub const fn variant(&self) -> TrigIn1Val {
61        match self.bits {
62            false => TrigIn1Val::Val0,
63            true => TrigIn1Val::Val1,
64        }
65    }
66    #[doc = "TRIG_IN1 is 0"]
67    #[inline(always)]
68    pub fn is_val0(&self) -> bool {
69        *self == TrigIn1Val::Val0
70    }
71    #[doc = "TRIG_IN1 is 1"]
72    #[inline(always)]
73    pub fn is_val1(&self) -> bool {
74        *self == TrigIn1Val::Val1
75    }
76}
77#[doc = "TRIG_IN value\n\nValue on reset: 0"]
78#[cfg_attr(feature = "defmt", derive(defmt::Format))]
79#[derive(Clone, Copy, Debug, PartialEq, Eq)]
80pub enum TrigIn2Val {
81    #[doc = "0: TRIG_IN2 is 0"]
82    Val0 = 0,
83    #[doc = "1: TRIG_IN2 is 1"]
84    Val1 = 1,
85}
86impl From<TrigIn2Val> for bool {
87    #[inline(always)]
88    fn from(variant: TrigIn2Val) -> Self {
89        variant as u8 != 0
90    }
91}
92#[doc = "Field `TRIG_IN2_VAL` reader - TRIG_IN value"]
93pub type TrigIn2ValR = crate::BitReader<TrigIn2Val>;
94impl TrigIn2ValR {
95    #[doc = "Get enumerated values variant"]
96    #[inline(always)]
97    pub const fn variant(&self) -> TrigIn2Val {
98        match self.bits {
99            false => TrigIn2Val::Val0,
100            true => TrigIn2Val::Val1,
101        }
102    }
103    #[doc = "TRIG_IN2 is 0"]
104    #[inline(always)]
105    pub fn is_val0(&self) -> bool {
106        *self == TrigIn2Val::Val0
107    }
108    #[doc = "TRIG_IN2 is 1"]
109    #[inline(always)]
110    pub fn is_val1(&self) -> bool {
111        *self == TrigIn2Val::Val1
112    }
113}
114#[doc = "TRIG_IN value\n\nValue on reset: 0"]
115#[cfg_attr(feature = "defmt", derive(defmt::Format))]
116#[derive(Clone, Copy, Debug, PartialEq, Eq)]
117pub enum TrigIn3Val {
118    #[doc = "0: TRIG_IN3 is 0"]
119    Val0 = 0,
120    #[doc = "1: TRIG_IN3 is 1"]
121    Val1 = 1,
122}
123impl From<TrigIn3Val> for bool {
124    #[inline(always)]
125    fn from(variant: TrigIn3Val) -> Self {
126        variant as u8 != 0
127    }
128}
129#[doc = "Field `TRIG_IN3_VAL` reader - TRIG_IN value"]
130pub type TrigIn3ValR = crate::BitReader<TrigIn3Val>;
131impl TrigIn3ValR {
132    #[doc = "Get enumerated values variant"]
133    #[inline(always)]
134    pub const fn variant(&self) -> TrigIn3Val {
135        match self.bits {
136            false => TrigIn3Val::Val0,
137            true => TrigIn3Val::Val1,
138        }
139    }
140    #[doc = "TRIG_IN3 is 0"]
141    #[inline(always)]
142    pub fn is_val0(&self) -> bool {
143        *self == TrigIn3Val::Val0
144    }
145    #[doc = "TRIG_IN3 is 1"]
146    #[inline(always)]
147    pub fn is_val1(&self) -> bool {
148        *self == TrigIn3Val::Val1
149    }
150}
151#[doc = "TRIG_IN value\n\nValue on reset: 0"]
152#[cfg_attr(feature = "defmt", derive(defmt::Format))]
153#[derive(Clone, Copy, Debug, PartialEq, Eq)]
154pub enum TrigIn4Val {
155    #[doc = "0: TRIG_IN4 is 0"]
156    Val0 = 0,
157    #[doc = "1: TRIG_IN4 is 1"]
158    Val1 = 1,
159}
160impl From<TrigIn4Val> for bool {
161    #[inline(always)]
162    fn from(variant: TrigIn4Val) -> Self {
163        variant as u8 != 0
164    }
165}
166#[doc = "Field `TRIG_IN4_VAL` reader - TRIG_IN value"]
167pub type TrigIn4ValR = crate::BitReader<TrigIn4Val>;
168impl TrigIn4ValR {
169    #[doc = "Get enumerated values variant"]
170    #[inline(always)]
171    pub const fn variant(&self) -> TrigIn4Val {
172        match self.bits {
173            false => TrigIn4Val::Val0,
174            true => TrigIn4Val::Val1,
175        }
176    }
177    #[doc = "TRIG_IN4 is 0"]
178    #[inline(always)]
179    pub fn is_val0(&self) -> bool {
180        *self == TrigIn4Val::Val0
181    }
182    #[doc = "TRIG_IN4 is 1"]
183    #[inline(always)]
184    pub fn is_val1(&self) -> bool {
185        *self == TrigIn4Val::Val1
186    }
187}
188#[doc = "TRIG_IN value\n\nValue on reset: 0"]
189#[cfg_attr(feature = "defmt", derive(defmt::Format))]
190#[derive(Clone, Copy, Debug, PartialEq, Eq)]
191pub enum TrigIn5Val {
192    #[doc = "0: TRIG_IN5 is 0"]
193    Val0 = 0,
194    #[doc = "1: TRIG_IN5 is 1"]
195    Val1 = 1,
196}
197impl From<TrigIn5Val> for bool {
198    #[inline(always)]
199    fn from(variant: TrigIn5Val) -> Self {
200        variant as u8 != 0
201    }
202}
203#[doc = "Field `TRIG_IN5_VAL` reader - TRIG_IN value"]
204pub type TrigIn5ValR = crate::BitReader<TrigIn5Val>;
205impl TrigIn5ValR {
206    #[doc = "Get enumerated values variant"]
207    #[inline(always)]
208    pub const fn variant(&self) -> TrigIn5Val {
209        match self.bits {
210            false => TrigIn5Val::Val0,
211            true => TrigIn5Val::Val1,
212        }
213    }
214    #[doc = "TRIG_IN5 is 0"]
215    #[inline(always)]
216    pub fn is_val0(&self) -> bool {
217        *self == TrigIn5Val::Val0
218    }
219    #[doc = "TRIG_IN5 is 1"]
220    #[inline(always)]
221    pub fn is_val1(&self) -> bool {
222        *self == TrigIn5Val::Val1
223    }
224}
225#[doc = "TRIG_IN value\n\nValue on reset: 0"]
226#[cfg_attr(feature = "defmt", derive(defmt::Format))]
227#[derive(Clone, Copy, Debug, PartialEq, Eq)]
228pub enum TrigIn6Val {
229    #[doc = "0: TRIG_IN6 is 0"]
230    Val0 = 0,
231    #[doc = "1: TRIG_IN6 is 1"]
232    Val1 = 1,
233}
234impl From<TrigIn6Val> for bool {
235    #[inline(always)]
236    fn from(variant: TrigIn6Val) -> Self {
237        variant as u8 != 0
238    }
239}
240#[doc = "Field `TRIG_IN6_VAL` reader - TRIG_IN value"]
241pub type TrigIn6ValR = crate::BitReader<TrigIn6Val>;
242impl TrigIn6ValR {
243    #[doc = "Get enumerated values variant"]
244    #[inline(always)]
245    pub const fn variant(&self) -> TrigIn6Val {
246        match self.bits {
247            false => TrigIn6Val::Val0,
248            true => TrigIn6Val::Val1,
249        }
250    }
251    #[doc = "TRIG_IN6 is 0"]
252    #[inline(always)]
253    pub fn is_val0(&self) -> bool {
254        *self == TrigIn6Val::Val0
255    }
256    #[doc = "TRIG_IN6 is 1"]
257    #[inline(always)]
258    pub fn is_val1(&self) -> bool {
259        *self == TrigIn6Val::Val1
260    }
261}
262#[doc = "TRIG_IN value\n\nValue on reset: 0"]
263#[cfg_attr(feature = "defmt", derive(defmt::Format))]
264#[derive(Clone, Copy, Debug, PartialEq, Eq)]
265pub enum TrigIn7Val {
266    #[doc = "0: TRIG_IN7 is 0"]
267    Val0 = 0,
268    #[doc = "1: TRIG_IN7 is 1"]
269    Val1 = 1,
270}
271impl From<TrigIn7Val> for bool {
272    #[inline(always)]
273    fn from(variant: TrigIn7Val) -> Self {
274        variant as u8 != 0
275    }
276}
277#[doc = "Field `TRIG_IN7_VAL` reader - TRIG_IN value"]
278pub type TrigIn7ValR = crate::BitReader<TrigIn7Val>;
279impl TrigIn7ValR {
280    #[doc = "Get enumerated values variant"]
281    #[inline(always)]
282    pub const fn variant(&self) -> TrigIn7Val {
283        match self.bits {
284            false => TrigIn7Val::Val0,
285            true => TrigIn7Val::Val1,
286        }
287    }
288    #[doc = "TRIG_IN7 is 0"]
289    #[inline(always)]
290    pub fn is_val0(&self) -> bool {
291        *self == TrigIn7Val::Val0
292    }
293    #[doc = "TRIG_IN7 is 1"]
294    #[inline(always)]
295    pub fn is_val1(&self) -> bool {
296        *self == TrigIn7Val::Val1
297    }
298}
299#[doc = "TRIG_IN value\n\nValue on reset: 0"]
300#[cfg_attr(feature = "defmt", derive(defmt::Format))]
301#[derive(Clone, Copy, Debug, PartialEq, Eq)]
302pub enum TrigIn8Val {
303    #[doc = "0: TRIG_IN8 is 0"]
304    Val0 = 0,
305    #[doc = "1: TRIG_IN8 is 1"]
306    Val1 = 1,
307}
308impl From<TrigIn8Val> for bool {
309    #[inline(always)]
310    fn from(variant: TrigIn8Val) -> Self {
311        variant as u8 != 0
312    }
313}
314#[doc = "Field `TRIG_IN8_VAL` reader - TRIG_IN value"]
315pub type TrigIn8ValR = crate::BitReader<TrigIn8Val>;
316impl TrigIn8ValR {
317    #[doc = "Get enumerated values variant"]
318    #[inline(always)]
319    pub const fn variant(&self) -> TrigIn8Val {
320        match self.bits {
321            false => TrigIn8Val::Val0,
322            true => TrigIn8Val::Val1,
323        }
324    }
325    #[doc = "TRIG_IN8 is 0"]
326    #[inline(always)]
327    pub fn is_val0(&self) -> bool {
328        *self == TrigIn8Val::Val0
329    }
330    #[doc = "TRIG_IN8 is 1"]
331    #[inline(always)]
332    pub fn is_val1(&self) -> bool {
333        *self == TrigIn8Val::Val1
334    }
335}
336#[doc = "TRIG_IN value\n\nValue on reset: 0"]
337#[cfg_attr(feature = "defmt", derive(defmt::Format))]
338#[derive(Clone, Copy, Debug, PartialEq, Eq)]
339pub enum TrigIn9Val {
340    #[doc = "0: TRIG_IN9 is 0"]
341    Val0 = 0,
342    #[doc = "1: TRIG_IN9 is 1"]
343    Val1 = 1,
344}
345impl From<TrigIn9Val> for bool {
346    #[inline(always)]
347    fn from(variant: TrigIn9Val) -> Self {
348        variant as u8 != 0
349    }
350}
351#[doc = "Field `TRIG_IN9_VAL` reader - TRIG_IN value"]
352pub type TrigIn9ValR = crate::BitReader<TrigIn9Val>;
353impl TrigIn9ValR {
354    #[doc = "Get enumerated values variant"]
355    #[inline(always)]
356    pub const fn variant(&self) -> TrigIn9Val {
357        match self.bits {
358            false => TrigIn9Val::Val0,
359            true => TrigIn9Val::Val1,
360        }
361    }
362    #[doc = "TRIG_IN9 is 0"]
363    #[inline(always)]
364    pub fn is_val0(&self) -> bool {
365        *self == TrigIn9Val::Val0
366    }
367    #[doc = "TRIG_IN9 is 1"]
368    #[inline(always)]
369    pub fn is_val1(&self) -> bool {
370        *self == TrigIn9Val::Val1
371    }
372}
373#[doc = "TRIG_IN value\n\nValue on reset: 0"]
374#[cfg_attr(feature = "defmt", derive(defmt::Format))]
375#[derive(Clone, Copy, Debug, PartialEq, Eq)]
376pub enum TrigIn10Val {
377    #[doc = "0: TRIG_IN10 is 0"]
378    Val0 = 0,
379    #[doc = "1: TRIG_IN10 is 1"]
380    Val1 = 1,
381}
382impl From<TrigIn10Val> for bool {
383    #[inline(always)]
384    fn from(variant: TrigIn10Val) -> Self {
385        variant as u8 != 0
386    }
387}
388#[doc = "Field `TRIG_IN10_VAL` reader - TRIG_IN value"]
389pub type TrigIn10ValR = crate::BitReader<TrigIn10Val>;
390impl TrigIn10ValR {
391    #[doc = "Get enumerated values variant"]
392    #[inline(always)]
393    pub const fn variant(&self) -> TrigIn10Val {
394        match self.bits {
395            false => TrigIn10Val::Val0,
396            true => TrigIn10Val::Val1,
397        }
398    }
399    #[doc = "TRIG_IN10 is 0"]
400    #[inline(always)]
401    pub fn is_val0(&self) -> bool {
402        *self == TrigIn10Val::Val0
403    }
404    #[doc = "TRIG_IN10 is 1"]
405    #[inline(always)]
406    pub fn is_val1(&self) -> bool {
407        *self == TrigIn10Val::Val1
408    }
409}
410#[doc = "TRIG_IN value\n\nValue on reset: 0"]
411#[cfg_attr(feature = "defmt", derive(defmt::Format))]
412#[derive(Clone, Copy, Debug, PartialEq, Eq)]
413pub enum TrigIn11Val {
414    #[doc = "0: TRIG_IN11 is 0"]
415    Val0 = 0,
416    #[doc = "1: TRIG_IN11 is 1"]
417    Val1 = 1,
418}
419impl From<TrigIn11Val> for bool {
420    #[inline(always)]
421    fn from(variant: TrigIn11Val) -> Self {
422        variant as u8 != 0
423    }
424}
425#[doc = "Field `TRIG_IN11_VAL` reader - TRIG_IN value"]
426pub type TrigIn11ValR = crate::BitReader<TrigIn11Val>;
427impl TrigIn11ValR {
428    #[doc = "Get enumerated values variant"]
429    #[inline(always)]
430    pub const fn variant(&self) -> TrigIn11Val {
431        match self.bits {
432            false => TrigIn11Val::Val0,
433            true => TrigIn11Val::Val1,
434        }
435    }
436    #[doc = "TRIG_IN11 is 0"]
437    #[inline(always)]
438    pub fn is_val0(&self) -> bool {
439        *self == TrigIn11Val::Val0
440    }
441    #[doc = "TRIG_IN11 is 1"]
442    #[inline(always)]
443    pub fn is_val1(&self) -> bool {
444        *self == TrigIn11Val::Val1
445    }
446}
447impl R {
448    #[doc = "Bit 0 - TRIG_IN value"]
449    #[inline(always)]
450    pub fn trig_in0_val(&self) -> TrigIn0ValR {
451        TrigIn0ValR::new((self.bits & 1) != 0)
452    }
453    #[doc = "Bit 1 - TRIG_IN value"]
454    #[inline(always)]
455    pub fn trig_in1_val(&self) -> TrigIn1ValR {
456        TrigIn1ValR::new(((self.bits >> 1) & 1) != 0)
457    }
458    #[doc = "Bit 2 - TRIG_IN value"]
459    #[inline(always)]
460    pub fn trig_in2_val(&self) -> TrigIn2ValR {
461        TrigIn2ValR::new(((self.bits >> 2) & 1) != 0)
462    }
463    #[doc = "Bit 3 - TRIG_IN value"]
464    #[inline(always)]
465    pub fn trig_in3_val(&self) -> TrigIn3ValR {
466        TrigIn3ValR::new(((self.bits >> 3) & 1) != 0)
467    }
468    #[doc = "Bit 4 - TRIG_IN value"]
469    #[inline(always)]
470    pub fn trig_in4_val(&self) -> TrigIn4ValR {
471        TrigIn4ValR::new(((self.bits >> 4) & 1) != 0)
472    }
473    #[doc = "Bit 5 - TRIG_IN value"]
474    #[inline(always)]
475    pub fn trig_in5_val(&self) -> TrigIn5ValR {
476        TrigIn5ValR::new(((self.bits >> 5) & 1) != 0)
477    }
478    #[doc = "Bit 6 - TRIG_IN value"]
479    #[inline(always)]
480    pub fn trig_in6_val(&self) -> TrigIn6ValR {
481        TrigIn6ValR::new(((self.bits >> 6) & 1) != 0)
482    }
483    #[doc = "Bit 7 - TRIG_IN value"]
484    #[inline(always)]
485    pub fn trig_in7_val(&self) -> TrigIn7ValR {
486        TrigIn7ValR::new(((self.bits >> 7) & 1) != 0)
487    }
488    #[doc = "Bit 8 - TRIG_IN value"]
489    #[inline(always)]
490    pub fn trig_in8_val(&self) -> TrigIn8ValR {
491        TrigIn8ValR::new(((self.bits >> 8) & 1) != 0)
492    }
493    #[doc = "Bit 9 - TRIG_IN value"]
494    #[inline(always)]
495    pub fn trig_in9_val(&self) -> TrigIn9ValR {
496        TrigIn9ValR::new(((self.bits >> 9) & 1) != 0)
497    }
498    #[doc = "Bit 10 - TRIG_IN value"]
499    #[inline(always)]
500    pub fn trig_in10_val(&self) -> TrigIn10ValR {
501        TrigIn10ValR::new(((self.bits >> 10) & 1) != 0)
502    }
503    #[doc = "Bit 11 - TRIG_IN value"]
504    #[inline(always)]
505    pub fn trig_in11_val(&self) -> TrigIn11ValR {
506        TrigIn11ValR::new(((self.bits >> 11) & 1) != 0)
507    }
508}
509#[cfg(feature = "debug")]
510impl core::fmt::Debug for R {
511    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
512        f.debug_struct("TRIGFIL_STAT0")
513            .field("trig_in0_val", &self.trig_in0_val())
514            .field("trig_in1_val", &self.trig_in1_val())
515            .field("trig_in2_val", &self.trig_in2_val())
516            .field("trig_in3_val", &self.trig_in3_val())
517            .field("trig_in4_val", &self.trig_in4_val())
518            .field("trig_in5_val", &self.trig_in5_val())
519            .field("trig_in6_val", &self.trig_in6_val())
520            .field("trig_in7_val", &self.trig_in7_val())
521            .field("trig_in8_val", &self.trig_in8_val())
522            .field("trig_in9_val", &self.trig_in9_val())
523            .field("trig_in10_val", &self.trig_in10_val())
524            .field("trig_in11_val", &self.trig_in11_val())
525            .finish()
526    }
527}
528#[doc = "Trigger filter stat\n\nYou can [`read`](crate::Reg::read) this register and get [`trigfil_stat0::R`](R). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
529pub struct TrigfilStat0Spec;
530impl crate::RegisterSpec for TrigfilStat0Spec {
531    type Ux = u32;
532}
533#[doc = "`read()` method returns [`trigfil_stat0::R`](R) reader structure"]
534impl crate::Readable for TrigfilStat0Spec {}
535#[doc = "`reset()` method sets TRIGFIL_STAT0 to value 0"]
536impl crate::Resettable for TrigfilStat0Spec {}
mcxa_pac/inputmux0/trigfil_stat0.rs

mcxa_pac/inputmux0/
trigfil_stat0.rs
