atsamd21g/tcc0/
fctrlb.rs

Help
1#[doc = "Register `FCTRLB` reader"]
2pub type R = crate::R<FctrlbSpec>;
3#[doc = "Register `FCTRLB` writer"]
4pub type W = crate::W<FctrlbSpec>;
5#[doc = "Fault B 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 B 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 B 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 B Keeper"]
92pub type KeepR = crate::BitReader;
93#[doc = "Field `KEEP` writer - Fault B Keeper"]
94pub type KeepW<'a, REG> = crate::BitWriter<'a, REG>;
95#[doc = "Field `QUAL` reader - Fault B Qualification"]
96pub type QualR = crate::BitReader;
97#[doc = "Field `QUAL` writer - Fault B Qualification"]
98pub type QualW<'a, REG> = crate::BitWriter<'a, REG>;
99#[doc = "Fault B Blanking Mode\n\nValue on reset: 0"]
100#[derive(Clone, Copy, Debug, PartialEq, Eq)]
101#[repr(u8)]
102pub enum Blankselect {
103    #[doc = "0: No blanking applied"]
104    None = 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 B 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::None,
130            1 => Blankselect::Rise,
131            2 => Blankselect::Fall,
132            3 => Blankselect::Both,
133            _ => unreachable!(),
134        }
135    }
136    #[doc = "No blanking applied"]
137    #[inline(always)]
138    pub fn is_none(&self) -> bool {
139        *self == Blankselect::None
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 B 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 = "No blanking applied"]
165    #[inline(always)]
166    pub fn none(self) -> &'a mut crate::W<REG> {
167        self.variant(Blankselect::None)
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 B Restart"]
186pub type RestartR = crate::BitReader;
187#[doc = "Field `RESTART` writer - Fault B Restart"]
188pub type RestartW<'a, REG> = crate::BitWriter<'a, REG>;
189#[doc = "Fault B 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 B 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 B 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 B 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 B 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 B 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 B 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}
380impl From<Captureselect> for u8 {
381    #[inline(always)]
382    fn from(variant: Captureselect) -> Self {
383        variant as _
384    }
385}
386impl crate::FieldSpec for Captureselect {
387    type Ux = u8;
388}
389impl crate::IsEnum for Captureselect {}
390#[doc = "Field `CAPTURE` reader - Fault B Capture Action"]
391pub type CaptureR = crate::FieldReader<Captureselect>;
392impl CaptureR {
393    #[doc = "Get enumerated values variant"]
394    #[inline(always)]
395    pub const fn variant(&self) -> Option<Captureselect> {
396        match self.bits {
397            0 => Some(Captureselect::Disable),
398            1 => Some(Captureselect::Capt),
399            2 => Some(Captureselect::Captmin),
400            3 => Some(Captureselect::Captmax),
401            4 => Some(Captureselect::Locmin),
402            5 => Some(Captureselect::Locmax),
403            6 => Some(Captureselect::Deriv0),
404            _ => None,
405        }
406    }
407    #[doc = "No capture"]
408    #[inline(always)]
409    pub fn is_disable(&self) -> bool {
410        *self == Captureselect::Disable
411    }
412    #[doc = "Capture on fault"]
413    #[inline(always)]
414    pub fn is_capt(&self) -> bool {
415        *self == Captureselect::Capt
416    }
417    #[doc = "Minimum capture"]
418    #[inline(always)]
419    pub fn is_captmin(&self) -> bool {
420        *self == Captureselect::Captmin
421    }
422    #[doc = "Maximum capture"]
423    #[inline(always)]
424    pub fn is_captmax(&self) -> bool {
425        *self == Captureselect::Captmax
426    }
427    #[doc = "Minimum local detection"]
428    #[inline(always)]
429    pub fn is_locmin(&self) -> bool {
430        *self == Captureselect::Locmin
431    }
432    #[doc = "Maximum local detection"]
433    #[inline(always)]
434    pub fn is_locmax(&self) -> bool {
435        *self == Captureselect::Locmax
436    }
437    #[doc = "Minimum and maximum local detection"]
438    #[inline(always)]
439    pub fn is_deriv0(&self) -> bool {
440        *self == Captureselect::Deriv0
441    }
442}
443#[doc = "Field `CAPTURE` writer - Fault B Capture Action"]
444pub type CaptureW<'a, REG> = crate::FieldWriter<'a, REG, 3, Captureselect>;
445impl<'a, REG> CaptureW<'a, REG>
446where
447    REG: crate::Writable + crate::RegisterSpec,
448    REG::Ux: From<u8>,
449{
450    #[doc = "No capture"]
451    #[inline(always)]
452    pub fn disable(self) -> &'a mut crate::W<REG> {
453        self.variant(Captureselect::Disable)
454    }
455    #[doc = "Capture on fault"]
456    #[inline(always)]
457    pub fn capt(self) -> &'a mut crate::W<REG> {
458        self.variant(Captureselect::Capt)
459    }
460    #[doc = "Minimum capture"]
461    #[inline(always)]
462    pub fn captmin(self) -> &'a mut crate::W<REG> {
463        self.variant(Captureselect::Captmin)
464    }
465    #[doc = "Maximum capture"]
466    #[inline(always)]
467    pub fn captmax(self) -> &'a mut crate::W<REG> {
468        self.variant(Captureselect::Captmax)
469    }
470    #[doc = "Minimum local detection"]
471    #[inline(always)]
472    pub fn locmin(self) -> &'a mut crate::W<REG> {
473        self.variant(Captureselect::Locmin)
474    }
475    #[doc = "Maximum local detection"]
476    #[inline(always)]
477    pub fn locmax(self) -> &'a mut crate::W<REG> {
478        self.variant(Captureselect::Locmax)
479    }
480    #[doc = "Minimum and maximum local detection"]
481    #[inline(always)]
482    pub fn deriv0(self) -> &'a mut crate::W<REG> {
483        self.variant(Captureselect::Deriv0)
484    }
485}
486#[doc = "Field `BLANKVAL` reader - Fault B Blanking Time"]
487pub type BlankvalR = crate::FieldReader;
488#[doc = "Field `BLANKVAL` writer - Fault B Blanking Time"]
489pub type BlankvalW<'a, REG> = crate::FieldWriter<'a, REG, 8>;
490#[doc = "Field `FILTERVAL` reader - Fault B Filter Value"]
491pub type FiltervalR = crate::FieldReader;
492#[doc = "Field `FILTERVAL` writer - Fault B Filter Value"]
493pub type FiltervalW<'a, REG> = crate::FieldWriter<'a, REG, 4>;
494impl R {
495    #[doc = "Bits 0:1 - Fault B Source"]
496    #[inline(always)]
497    pub fn src(&self) -> SrcR {
498        SrcR::new((self.bits & 3) as u8)
499    }
500    #[doc = "Bit 3 - Fault B Keeper"]
501    #[inline(always)]
502    pub fn keep(&self) -> KeepR {
503        KeepR::new(((self.bits >> 3) & 1) != 0)
504    }
505    #[doc = "Bit 4 - Fault B Qualification"]
506    #[inline(always)]
507    pub fn qual(&self) -> QualR {
508        QualR::new(((self.bits >> 4) & 1) != 0)
509    }
510    #[doc = "Bits 5:6 - Fault B Blanking Mode"]
511    #[inline(always)]
512    pub fn blank(&self) -> BlankR {
513        BlankR::new(((self.bits >> 5) & 3) as u8)
514    }
515    #[doc = "Bit 7 - Fault B Restart"]
516    #[inline(always)]
517    pub fn restart(&self) -> RestartR {
518        RestartR::new(((self.bits >> 7) & 1) != 0)
519    }
520    #[doc = "Bits 8:9 - Fault B Halt Mode"]
521    #[inline(always)]
522    pub fn halt(&self) -> HaltR {
523        HaltR::new(((self.bits >> 8) & 3) as u8)
524    }
525    #[doc = "Bits 10:11 - Fault B Capture Channel"]
526    #[inline(always)]
527    pub fn chsel(&self) -> ChselR {
528        ChselR::new(((self.bits >> 10) & 3) as u8)
529    }
530    #[doc = "Bits 12:14 - Fault B Capture Action"]
531    #[inline(always)]
532    pub fn capture(&self) -> CaptureR {
533        CaptureR::new(((self.bits >> 12) & 7) as u8)
534    }
535    #[doc = "Bits 16:23 - Fault B Blanking Time"]
536    #[inline(always)]
537    pub fn blankval(&self) -> BlankvalR {
538        BlankvalR::new(((self.bits >> 16) & 0xff) as u8)
539    }
540    #[doc = "Bits 24:27 - Fault B Filter Value"]
541    #[inline(always)]
542    pub fn filterval(&self) -> FiltervalR {
543        FiltervalR::new(((self.bits >> 24) & 0x0f) as u8)
544    }
545}
546impl W {
547    #[doc = "Bits 0:1 - Fault B Source"]
548    #[inline(always)]
549    #[must_use]
550    pub fn src(&mut self) -> SrcW<FctrlbSpec> {
551        SrcW::new(self, 0)
552    }
553    #[doc = "Bit 3 - Fault B Keeper"]
554    #[inline(always)]
555    #[must_use]
556    pub fn keep(&mut self) -> KeepW<FctrlbSpec> {
557        KeepW::new(self, 3)
558    }
559    #[doc = "Bit 4 - Fault B Qualification"]
560    #[inline(always)]
561    #[must_use]
562    pub fn qual(&mut self) -> QualW<FctrlbSpec> {
563        QualW::new(self, 4)
564    }
565    #[doc = "Bits 5:6 - Fault B Blanking Mode"]
566    #[inline(always)]
567    #[must_use]
568    pub fn blank(&mut self) -> BlankW<FctrlbSpec> {
569        BlankW::new(self, 5)
570    }
571    #[doc = "Bit 7 - Fault B Restart"]
572    #[inline(always)]
573    #[must_use]
574    pub fn restart(&mut self) -> RestartW<FctrlbSpec> {
575        RestartW::new(self, 7)
576    }
577    #[doc = "Bits 8:9 - Fault B Halt Mode"]
578    #[inline(always)]
579    #[must_use]
580    pub fn halt(&mut self) -> HaltW<FctrlbSpec> {
581        HaltW::new(self, 8)
582    }
583    #[doc = "Bits 10:11 - Fault B Capture Channel"]
584    #[inline(always)]
585    #[must_use]
586    pub fn chsel(&mut self) -> ChselW<FctrlbSpec> {
587        ChselW::new(self, 10)
588    }
589    #[doc = "Bits 12:14 - Fault B Capture Action"]
590    #[inline(always)]
591    #[must_use]
592    pub fn capture(&mut self) -> CaptureW<FctrlbSpec> {
593        CaptureW::new(self, 12)
594    }
595    #[doc = "Bits 16:23 - Fault B Blanking Time"]
596    #[inline(always)]
597    #[must_use]
598    pub fn blankval(&mut self) -> BlankvalW<FctrlbSpec> {
599        BlankvalW::new(self, 16)
600    }
601    #[doc = "Bits 24:27 - Fault B Filter Value"]
602    #[inline(always)]
603    #[must_use]
604    pub fn filterval(&mut self) -> FiltervalW<FctrlbSpec> {
605        FiltervalW::new(self, 24)
606    }
607}
608#[doc = "Recoverable Fault B Configuration\n\nYou can [`read`](crate::Reg::read) this register and get [`fctrlb::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`fctrlb::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
609pub struct FctrlbSpec;
610impl crate::RegisterSpec for FctrlbSpec {
611    type Ux = u32;
612}
613#[doc = "`read()` method returns [`fctrlb::R`](R) reader structure"]
614impl crate::Readable for FctrlbSpec {}
615#[doc = "`write(|w| ..)` method takes [`fctrlb::W`](W) writer structure"]
616impl crate::Writable for FctrlbSpec {
617    type Safety = crate::Unsafe;
618    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
619    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
620}
621#[doc = "`reset()` method sets FCTRLB to value 0"]
622impl crate::Resettable for FctrlbSpec {
623    const RESET_VALUE: u32 = 0;
624}
atsamd21g/tcc0/fctrlb.rs

atsamd21g/tcc0/
fctrlb.rs
