atsamd11d/tcc0/
fctrla.rs

Help
1#[doc = "Register `FCTRLA` reader"]
2pub type R = crate::R<FctrlaSpec>;
3#[doc = "Register `FCTRLA` writer"]
4pub type W = crate::W<FctrlaSpec>;
5#[doc = "Fault A Source\n\nValue on reset: 0"]
6#[derive(Clone, Copy, Debug, PartialEq, Eq)]
7#[repr(u8)]
8pub enum Srcselect {
9    #[doc = "0: Fault input disabled"]
10    Disable = 0,
11    #[doc = "1: MCEx (x=0,1) event input"]
12    Enable = 1,
13    #[doc = "2: Inverted MCEx (x=0,1) event input"]
14    Invert = 2,
15    #[doc = "3: Alternate fault (A or B) state at the end of the previous period"]
16    Altfault = 3,
17}
18impl From<Srcselect> for u8 {
19    #[inline(always)]
20    fn from(variant: Srcselect) -> Self {
21        variant as _
22    }
23}
24impl crate::FieldSpec for Srcselect {
25    type Ux = u8;
26}
27impl crate::IsEnum for Srcselect {}
28#[doc = "Field `SRC` reader - Fault A Source"]
29pub type SrcR = crate::FieldReader<Srcselect>;
30impl SrcR {
31    #[doc = "Get enumerated values variant"]
32    #[inline(always)]
33    pub const fn variant(&self) -> Srcselect {
34        match self.bits {
35            0 => Srcselect::Disable,
36            1 => Srcselect::Enable,
37            2 => Srcselect::Invert,
38            3 => Srcselect::Altfault,
39            _ => unreachable!(),
40        }
41    }
42    #[doc = "Fault input disabled"]
43    #[inline(always)]
44    pub fn is_disable(&self) -> bool {
45        *self == Srcselect::Disable
46    }
47    #[doc = "MCEx (x=0,1) event input"]
48    #[inline(always)]
49    pub fn is_enable(&self) -> bool {
50        *self == Srcselect::Enable
51    }
52    #[doc = "Inverted MCEx (x=0,1) event input"]
53    #[inline(always)]
54    pub fn is_invert(&self) -> bool {
55        *self == Srcselect::Invert
56    }
57    #[doc = "Alternate fault (A or B) state at the end of the previous period"]
58    #[inline(always)]
59    pub fn is_altfault(&self) -> bool {
60        *self == Srcselect::Altfault
61    }
62}
63#[doc = "Field `SRC` writer - Fault A Source"]
64pub type SrcW<'a, REG> = crate::FieldWriter<'a, REG, 2, Srcselect, crate::Safe>;
65impl<'a, REG> SrcW<'a, REG>
66where
67    REG: crate::Writable + crate::RegisterSpec,
68    REG::Ux: From<u8>,
69{
70    #[doc = "Fault input disabled"]
71    #[inline(always)]
72    pub fn disable(self) -> &'a mut crate::W<REG> {
73        self.variant(Srcselect::Disable)
74    }
75    #[doc = "MCEx (x=0,1) event input"]
76    #[inline(always)]
77    pub fn enable(self) -> &'a mut crate::W<REG> {
78        self.variant(Srcselect::Enable)
79    }
80    #[doc = "Inverted MCEx (x=0,1) event input"]
81    #[inline(always)]
82    pub fn invert(self) -> &'a mut crate::W<REG> {
83        self.variant(Srcselect::Invert)
84    }
85    #[doc = "Alternate fault (A or B) state at the end of the previous period"]
86    #[inline(always)]
87    pub fn altfault(self) -> &'a mut crate::W<REG> {
88        self.variant(Srcselect::Altfault)
89    }
90}
91#[doc = "Field `KEEP` reader - Fault A Keeper"]
92pub type KeepR = crate::BitReader;
93#[doc = "Field `KEEP` writer - Fault A Keeper"]
94pub type KeepW<'a, REG> = crate::BitWriter<'a, REG>;
95#[doc = "Field `QUAL` reader - Fault A Qualification"]
96pub type QualR = crate::BitReader;
97#[doc = "Field `QUAL` writer - Fault A Qualification"]
98pub type QualW<'a, REG> = crate::BitWriter<'a, REG>;
99#[doc = "Fault A Blanking Mode\n\nValue on reset: 0"]
100#[derive(Clone, Copy, Debug, PartialEq, Eq)]
101#[repr(u8)]
102pub enum Blankselect {
103    #[doc = "0: Blanking applied from start of ramp"]
104    Start = 0,
105    #[doc = "1: Blanking applied from rising edge of the output waveform"]
106    Rise = 1,
107    #[doc = "2: Blanking applied from falling edge of the output waveform"]
108    Fall = 2,
109    #[doc = "3: Blanking applied from each toggle of the output waveform"]
110    Both = 3,
111}
112impl From<Blankselect> for u8 {
113    #[inline(always)]
114    fn from(variant: Blankselect) -> Self {
115        variant as _
116    }
117}
118impl crate::FieldSpec for Blankselect {
119    type Ux = u8;
120}
121impl crate::IsEnum for Blankselect {}
122#[doc = "Field `BLANK` reader - Fault A Blanking Mode"]
123pub type BlankR = crate::FieldReader<Blankselect>;
124impl BlankR {
125    #[doc = "Get enumerated values variant"]
126    #[inline(always)]
127    pub const fn variant(&self) -> Blankselect {
128        match self.bits {
129            0 => Blankselect::Start,
130            1 => Blankselect::Rise,
131            2 => Blankselect::Fall,
132            3 => Blankselect::Both,
133            _ => unreachable!(),
134        }
135    }
136    #[doc = "Blanking applied from start of ramp"]
137    #[inline(always)]
138    pub fn is_start(&self) -> bool {
139        *self == Blankselect::Start
140    }
141    #[doc = "Blanking applied from rising edge of the output waveform"]
142    #[inline(always)]
143    pub fn is_rise(&self) -> bool {
144        *self == Blankselect::Rise
145    }
146    #[doc = "Blanking applied from falling edge of the output waveform"]
147    #[inline(always)]
148    pub fn is_fall(&self) -> bool {
149        *self == Blankselect::Fall
150    }
151    #[doc = "Blanking applied from each toggle of the output waveform"]
152    #[inline(always)]
153    pub fn is_both(&self) -> bool {
154        *self == Blankselect::Both
155    }
156}
157#[doc = "Field `BLANK` writer - Fault A Blanking Mode"]
158pub type BlankW<'a, REG> = crate::FieldWriter<'a, REG, 2, Blankselect, crate::Safe>;
159impl<'a, REG> BlankW<'a, REG>
160where
161    REG: crate::Writable + crate::RegisterSpec,
162    REG::Ux: From<u8>,
163{
164    #[doc = "Blanking applied from start of ramp"]
165    #[inline(always)]
166    pub fn start(self) -> &'a mut crate::W<REG> {
167        self.variant(Blankselect::Start)
168    }
169    #[doc = "Blanking applied from rising edge of the output waveform"]
170    #[inline(always)]
171    pub fn rise(self) -> &'a mut crate::W<REG> {
172        self.variant(Blankselect::Rise)
173    }
174    #[doc = "Blanking applied from falling edge of the output waveform"]
175    #[inline(always)]
176    pub fn fall(self) -> &'a mut crate::W<REG> {
177        self.variant(Blankselect::Fall)
178    }
179    #[doc = "Blanking applied from each toggle of the output waveform"]
180    #[inline(always)]
181    pub fn both(self) -> &'a mut crate::W<REG> {
182        self.variant(Blankselect::Both)
183    }
184}
185#[doc = "Field `RESTART` reader - Fault A Restart"]
186pub type RestartR = crate::BitReader;
187#[doc = "Field `RESTART` writer - Fault A Restart"]
188pub type RestartW<'a, REG> = crate::BitWriter<'a, REG>;
189#[doc = "Fault A Halt Mode\n\nValue on reset: 0"]
190#[derive(Clone, Copy, Debug, PartialEq, Eq)]
191#[repr(u8)]
192pub enum Haltselect {
193    #[doc = "0: Halt action disabled"]
194    Disable = 0,
195    #[doc = "1: Hardware halt action"]
196    Hw = 1,
197    #[doc = "2: Software halt action"]
198    Sw = 2,
199    #[doc = "3: Non-recoverable fault"]
200    Nr = 3,
201}
202impl From<Haltselect> for u8 {
203    #[inline(always)]
204    fn from(variant: Haltselect) -> Self {
205        variant as _
206    }
207}
208impl crate::FieldSpec for Haltselect {
209    type Ux = u8;
210}
211impl crate::IsEnum for Haltselect {}
212#[doc = "Field `HALT` reader - Fault A Halt Mode"]
213pub type HaltR = crate::FieldReader<Haltselect>;
214impl HaltR {
215    #[doc = "Get enumerated values variant"]
216    #[inline(always)]
217    pub const fn variant(&self) -> Haltselect {
218        match self.bits {
219            0 => Haltselect::Disable,
220            1 => Haltselect::Hw,
221            2 => Haltselect::Sw,
222            3 => Haltselect::Nr,
223            _ => unreachable!(),
224        }
225    }
226    #[doc = "Halt action disabled"]
227    #[inline(always)]
228    pub fn is_disable(&self) -> bool {
229        *self == Haltselect::Disable
230    }
231    #[doc = "Hardware halt action"]
232    #[inline(always)]
233    pub fn is_hw(&self) -> bool {
234        *self == Haltselect::Hw
235    }
236    #[doc = "Software halt action"]
237    #[inline(always)]
238    pub fn is_sw(&self) -> bool {
239        *self == Haltselect::Sw
240    }
241    #[doc = "Non-recoverable fault"]
242    #[inline(always)]
243    pub fn is_nr(&self) -> bool {
244        *self == Haltselect::Nr
245    }
246}
247#[doc = "Field `HALT` writer - Fault A Halt Mode"]
248pub type HaltW<'a, REG> = crate::FieldWriter<'a, REG, 2, Haltselect, crate::Safe>;
249impl<'a, REG> HaltW<'a, REG>
250where
251    REG: crate::Writable + crate::RegisterSpec,
252    REG::Ux: From<u8>,
253{
254    #[doc = "Halt action disabled"]
255    #[inline(always)]
256    pub fn disable(self) -> &'a mut crate::W<REG> {
257        self.variant(Haltselect::Disable)
258    }
259    #[doc = "Hardware halt action"]
260    #[inline(always)]
261    pub fn hw(self) -> &'a mut crate::W<REG> {
262        self.variant(Haltselect::Hw)
263    }
264    #[doc = "Software halt action"]
265    #[inline(always)]
266    pub fn sw(self) -> &'a mut crate::W<REG> {
267        self.variant(Haltselect::Sw)
268    }
269    #[doc = "Non-recoverable fault"]
270    #[inline(always)]
271    pub fn nr(self) -> &'a mut crate::W<REG> {
272        self.variant(Haltselect::Nr)
273    }
274}
275#[doc = "Fault A Capture Channel\n\nValue on reset: 0"]
276#[derive(Clone, Copy, Debug, PartialEq, Eq)]
277#[repr(u8)]
278pub enum Chselselect {
279    #[doc = "0: Capture value stored in channel 0"]
280    Cc0 = 0,
281    #[doc = "1: Capture value stored in channel 1"]
282    Cc1 = 1,
283    #[doc = "2: Capture value stored in channel 2"]
284    Cc2 = 2,
285    #[doc = "3: Capture value stored in channel 3"]
286    Cc3 = 3,
287}
288impl From<Chselselect> for u8 {
289    #[inline(always)]
290    fn from(variant: Chselselect) -> Self {
291        variant as _
292    }
293}
294impl crate::FieldSpec for Chselselect {
295    type Ux = u8;
296}
297impl crate::IsEnum for Chselselect {}
298#[doc = "Field `CHSEL` reader - Fault A Capture Channel"]
299pub type ChselR = crate::FieldReader<Chselselect>;
300impl ChselR {
301    #[doc = "Get enumerated values variant"]
302    #[inline(always)]
303    pub const fn variant(&self) -> Chselselect {
304        match self.bits {
305            0 => Chselselect::Cc0,
306            1 => Chselselect::Cc1,
307            2 => Chselselect::Cc2,
308            3 => Chselselect::Cc3,
309            _ => unreachable!(),
310        }
311    }
312    #[doc = "Capture value stored in channel 0"]
313    #[inline(always)]
314    pub fn is_cc0(&self) -> bool {
315        *self == Chselselect::Cc0
316    }
317    #[doc = "Capture value stored in channel 1"]
318    #[inline(always)]
319    pub fn is_cc1(&self) -> bool {
320        *self == Chselselect::Cc1
321    }
322    #[doc = "Capture value stored in channel 2"]
323    #[inline(always)]
324    pub fn is_cc2(&self) -> bool {
325        *self == Chselselect::Cc2
326    }
327    #[doc = "Capture value stored in channel 3"]
328    #[inline(always)]
329    pub fn is_cc3(&self) -> bool {
330        *self == Chselselect::Cc3
331    }
332}
333#[doc = "Field `CHSEL` writer - Fault A Capture Channel"]
334pub type ChselW<'a, REG> = crate::FieldWriter<'a, REG, 2, Chselselect, crate::Safe>;
335impl<'a, REG> ChselW<'a, REG>
336where
337    REG: crate::Writable + crate::RegisterSpec,
338    REG::Ux: From<u8>,
339{
340    #[doc = "Capture value stored in channel 0"]
341    #[inline(always)]
342    pub fn cc0(self) -> &'a mut crate::W<REG> {
343        self.variant(Chselselect::Cc0)
344    }
345    #[doc = "Capture value stored in channel 1"]
346    #[inline(always)]
347    pub fn cc1(self) -> &'a mut crate::W<REG> {
348        self.variant(Chselselect::Cc1)
349    }
350    #[doc = "Capture value stored in channel 2"]
351    #[inline(always)]
352    pub fn cc2(self) -> &'a mut crate::W<REG> {
353        self.variant(Chselselect::Cc2)
354    }
355    #[doc = "Capture value stored in channel 3"]
356    #[inline(always)]
357    pub fn cc3(self) -> &'a mut crate::W<REG> {
358        self.variant(Chselselect::Cc3)
359    }
360}
361#[doc = "Fault A Capture Action\n\nValue on reset: 0"]
362#[derive(Clone, Copy, Debug, PartialEq, Eq)]
363#[repr(u8)]
364pub enum Captureselect {
365    #[doc = "0: No capture"]
366    Disable = 0,
367    #[doc = "1: Capture on fault"]
368    Capt = 1,
369    #[doc = "2: Minimum capture"]
370    Captmin = 2,
371    #[doc = "3: Maximum capture"]
372    Captmax = 3,
373    #[doc = "4: Minimum local detection"]
374    Locmin = 4,
375    #[doc = "5: Maximum local detection"]
376    Locmax = 5,
377    #[doc = "6: Minimum and maximum local detection"]
378    Deriv0 = 6,
379    #[doc = "7: Capture with ramp index as MSB value"]
380    Captmark = 7,
381}
382impl From<Captureselect> for u8 {
383    #[inline(always)]
384    fn from(variant: Captureselect) -> Self {
385        variant as _
386    }
387}
388impl crate::FieldSpec for Captureselect {
389    type Ux = u8;
390}
391impl crate::IsEnum for Captureselect {}
392#[doc = "Field `CAPTURE` reader - Fault A Capture Action"]
393pub type CaptureR = crate::FieldReader<Captureselect>;
394impl CaptureR {
395    #[doc = "Get enumerated values variant"]
396    #[inline(always)]
397    pub const fn variant(&self) -> Captureselect {
398        match self.bits {
399            0 => Captureselect::Disable,
400            1 => Captureselect::Capt,
401            2 => Captureselect::Captmin,
402            3 => Captureselect::Captmax,
403            4 => Captureselect::Locmin,
404            5 => Captureselect::Locmax,
405            6 => Captureselect::Deriv0,
406            7 => Captureselect::Captmark,
407            _ => unreachable!(),
408        }
409    }
410    #[doc = "No capture"]
411    #[inline(always)]
412    pub fn is_disable(&self) -> bool {
413        *self == Captureselect::Disable
414    }
415    #[doc = "Capture on fault"]
416    #[inline(always)]
417    pub fn is_capt(&self) -> bool {
418        *self == Captureselect::Capt
419    }
420    #[doc = "Minimum capture"]
421    #[inline(always)]
422    pub fn is_captmin(&self) -> bool {
423        *self == Captureselect::Captmin
424    }
425    #[doc = "Maximum capture"]
426    #[inline(always)]
427    pub fn is_captmax(&self) -> bool {
428        *self == Captureselect::Captmax
429    }
430    #[doc = "Minimum local detection"]
431    #[inline(always)]
432    pub fn is_locmin(&self) -> bool {
433        *self == Captureselect::Locmin
434    }
435    #[doc = "Maximum local detection"]
436    #[inline(always)]
437    pub fn is_locmax(&self) -> bool {
438        *self == Captureselect::Locmax
439    }
440    #[doc = "Minimum and maximum local detection"]
441    #[inline(always)]
442    pub fn is_deriv0(&self) -> bool {
443        *self == Captureselect::Deriv0
444    }
445    #[doc = "Capture with ramp index as MSB value"]
446    #[inline(always)]
447    pub fn is_captmark(&self) -> bool {
448        *self == Captureselect::Captmark
449    }
450}
451#[doc = "Field `CAPTURE` writer - Fault A Capture Action"]
452pub type CaptureW<'a, REG> = crate::FieldWriter<'a, REG, 3, Captureselect, crate::Safe>;
453impl<'a, REG> CaptureW<'a, REG>
454where
455    REG: crate::Writable + crate::RegisterSpec,
456    REG::Ux: From<u8>,
457{
458    #[doc = "No capture"]
459    #[inline(always)]
460    pub fn disable(self) -> &'a mut crate::W<REG> {
461        self.variant(Captureselect::Disable)
462    }
463    #[doc = "Capture on fault"]
464    #[inline(always)]
465    pub fn capt(self) -> &'a mut crate::W<REG> {
466        self.variant(Captureselect::Capt)
467    }
468    #[doc = "Minimum capture"]
469    #[inline(always)]
470    pub fn captmin(self) -> &'a mut crate::W<REG> {
471        self.variant(Captureselect::Captmin)
472    }
473    #[doc = "Maximum capture"]
474    #[inline(always)]
475    pub fn captmax(self) -> &'a mut crate::W<REG> {
476        self.variant(Captureselect::Captmax)
477    }
478    #[doc = "Minimum local detection"]
479    #[inline(always)]
480    pub fn locmin(self) -> &'a mut crate::W<REG> {
481        self.variant(Captureselect::Locmin)
482    }
483    #[doc = "Maximum local detection"]
484    #[inline(always)]
485    pub fn locmax(self) -> &'a mut crate::W<REG> {
486        self.variant(Captureselect::Locmax)
487    }
488    #[doc = "Minimum and maximum local detection"]
489    #[inline(always)]
490    pub fn deriv0(self) -> &'a mut crate::W<REG> {
491        self.variant(Captureselect::Deriv0)
492    }
493    #[doc = "Capture with ramp index as MSB value"]
494    #[inline(always)]
495    pub fn captmark(self) -> &'a mut crate::W<REG> {
496        self.variant(Captureselect::Captmark)
497    }
498}
499#[doc = "Field `BLANKPRESC` reader - Fault A Blanking Prescaler"]
500pub type BlankprescR = crate::BitReader;
501#[doc = "Field `BLANKPRESC` writer - Fault A Blanking Prescaler"]
502pub type BlankprescW<'a, REG> = crate::BitWriter<'a, REG>;
503#[doc = "Field `BLANKVAL` reader - Fault A Blanking Time"]
504pub type BlankvalR = crate::FieldReader;
505#[doc = "Field `BLANKVAL` writer - Fault A Blanking Time"]
506pub type BlankvalW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
507#[doc = "Field `FILTERVAL` reader - Fault A Filter Value"]
508pub type FiltervalR = crate::FieldReader;
509#[doc = "Field `FILTERVAL` writer - Fault A Filter Value"]
510pub type FiltervalW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
511impl R {
512    #[doc = "Bits 0:1 - Fault A Source"]
513    #[inline(always)]
514    pub fn src(&self) -> SrcR {
515        SrcR::new((self.bits & 3) as u8)
516    }
517    #[doc = "Bit 3 - Fault A Keeper"]
518    #[inline(always)]
519    pub fn keep(&self) -> KeepR {
520        KeepR::new(((self.bits >> 3) & 1) != 0)
521    }
522    #[doc = "Bit 4 - Fault A Qualification"]
523    #[inline(always)]
524    pub fn qual(&self) -> QualR {
525        QualR::new(((self.bits >> 4) & 1) != 0)
526    }
527    #[doc = "Bits 5:6 - Fault A Blanking Mode"]
528    #[inline(always)]
529    pub fn blank(&self) -> BlankR {
530        BlankR::new(((self.bits >> 5) & 3) as u8)
531    }
532    #[doc = "Bit 7 - Fault A Restart"]
533    #[inline(always)]
534    pub fn restart(&self) -> RestartR {
535        RestartR::new(((self.bits >> 7) & 1) != 0)
536    }
537    #[doc = "Bits 8:9 - Fault A Halt Mode"]
538    #[inline(always)]
539    pub fn halt(&self) -> HaltR {
540        HaltR::new(((self.bits >> 8) & 3) as u8)
541    }
542    #[doc = "Bits 10:11 - Fault A Capture Channel"]
543    #[inline(always)]
544    pub fn chsel(&self) -> ChselR {
545        ChselR::new(((self.bits >> 10) & 3) as u8)
546    }
547    #[doc = "Bits 12:14 - Fault A Capture Action"]
548    #[inline(always)]
549    pub fn capture(&self) -> CaptureR {
550        CaptureR::new(((self.bits >> 12) & 7) as u8)
551    }
552    #[doc = "Bit 15 - Fault A Blanking Prescaler"]
553    #[inline(always)]
554    pub fn blankpresc(&self) -> BlankprescR {
555        BlankprescR::new(((self.bits >> 15) & 1) != 0)
556    }
557    #[doc = "Bits 16:23 - Fault A Blanking Time"]
558    #[inline(always)]
559    pub fn blankval(&self) -> BlankvalR {
560        BlankvalR::new(((self.bits >> 16) & 0xff) as u8)
561    }
562    #[doc = "Bits 24:27 - Fault A Filter Value"]
563    #[inline(always)]
564    pub fn filterval(&self) -> FiltervalR {
565        FiltervalR::new(((self.bits >> 24) & 0x0f) as u8)
566    }
567}
568impl W {
569    #[doc = "Bits 0:1 - Fault A Source"]
570    #[inline(always)]
571    #[must_use]
572    pub fn src(&mut self) -> SrcW<FctrlaSpec> {
573        SrcW::new(self, 0)
574    }
575    #[doc = "Bit 3 - Fault A Keeper"]
576    #[inline(always)]
577    #[must_use]
578    pub fn keep(&mut self) -> KeepW<FctrlaSpec> {
579        KeepW::new(self, 3)
580    }
581    #[doc = "Bit 4 - Fault A Qualification"]
582    #[inline(always)]
583    #[must_use]
584    pub fn qual(&mut self) -> QualW<FctrlaSpec> {
585        QualW::new(self, 4)
586    }
587    #[doc = "Bits 5:6 - Fault A Blanking Mode"]
588    #[inline(always)]
589    #[must_use]
590    pub fn blank(&mut self) -> BlankW<FctrlaSpec> {
591        BlankW::new(self, 5)
592    }
593    #[doc = "Bit 7 - Fault A Restart"]
594    #[inline(always)]
595    #[must_use]
596    pub fn restart(&mut self) -> RestartW<FctrlaSpec> {
597        RestartW::new(self, 7)
598    }
599    #[doc = "Bits 8:9 - Fault A Halt Mode"]
600    #[inline(always)]
601    #[must_use]
602    pub fn halt(&mut self) -> HaltW<FctrlaSpec> {
603        HaltW::new(self, 8)
604    }
605    #[doc = "Bits 10:11 - Fault A Capture Channel"]
606    #[inline(always)]
607    #[must_use]
608    pub fn chsel(&mut self) -> ChselW<FctrlaSpec> {
609        ChselW::new(self, 10)
610    }
611    #[doc = "Bits 12:14 - Fault A Capture Action"]
612    #[inline(always)]
613    #[must_use]
614    pub fn capture(&mut self) -> CaptureW<FctrlaSpec> {
615        CaptureW::new(self, 12)
616    }
617    #[doc = "Bit 15 - Fault A Blanking Prescaler"]
618    #[inline(always)]
619    #[must_use]
620    pub fn blankpresc(&mut self) -> BlankprescW<FctrlaSpec> {
621        BlankprescW::new(self, 15)
622    }
623    #[doc = "Bits 16:23 - Fault A Blanking Time"]
624    #[inline(always)]
625    #[must_use]
626    pub fn blankval(&mut self) -> BlankvalW<FctrlaSpec> {
627        BlankvalW::new(self, 16)
628    }
629    #[doc = "Bits 24:27 - Fault A Filter Value"]
630    #[inline(always)]
631    #[must_use]
632    pub fn filterval(&mut self) -> FiltervalW<FctrlaSpec> {
633        FiltervalW::new(self, 24)
634    }
635}
636#[doc = "Recoverable Fault A Configuration\n\nYou can [`read`](crate::Reg::read) this register and get [`fctrla::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`fctrla::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
637pub struct FctrlaSpec;
638impl crate::RegisterSpec for FctrlaSpec {
639    type Ux = u32;
640}
641#[doc = "`read()` method returns [`fctrla::R`](R) reader structure"]
642impl crate::Readable for FctrlaSpec {}
643#[doc = "`write(|w| ..)` method takes [`fctrla::W`](W) writer structure"]
644impl crate::Writable for FctrlaSpec {
645    type Safety = crate::Unsafe;
646    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
647    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
648}
649#[doc = "`reset()` method sets FCTRLA to value 0"]
650impl crate::Resettable for FctrlaSpec {
651    const RESET_VALUE: u32 = 0;
652}
atsamd11d/tcc0/fctrla.rs

atsamd11d/tcc0/
fctrla.rs
