xmc4100/vadc_g0/
refclr.rs

1#[doc = "Register `REFCLR` writer"]
2pub type W = crate::W<REFCLR_SPEC>;
3#[doc = "Clear Result Event for Result Register 0\n\nValue on reset: 0"]
4#[derive(Clone, Copy, Debug, PartialEq, Eq)]
5pub enum REV0_A {
6    #[doc = "0: No action"]
7    VALUE1 = 0,
8    #[doc = "1: Clear the result event flag in GxREFLAG"]
9    VALUE2 = 1,
10}
11impl From<REV0_A> for bool {
12    #[inline(always)]
13    fn from(variant: REV0_A) -> Self {
14        variant as u8 != 0
15    }
16}
17#[doc = "Field `REV0` writer - Clear Result Event for Result Register 0"]
18pub type REV0_W<'a, REG> = crate::BitWriter<'a, REG, REV0_A>;
19impl<'a, REG> REV0_W<'a, REG>
20where
21    REG: crate::Writable + crate::RegisterSpec,
22{
23    #[doc = "No action"]
24    #[inline(always)]
25    pub fn value1(self) -> &'a mut crate::W<REG> {
26        self.variant(REV0_A::VALUE1)
27    }
28    #[doc = "Clear the result event flag in GxREFLAG"]
29    #[inline(always)]
30    pub fn value2(self) -> &'a mut crate::W<REG> {
31        self.variant(REV0_A::VALUE2)
32    }
33}
34#[doc = "Clear Result Event for Result Register 1\n\nValue on reset: 0"]
35#[derive(Clone, Copy, Debug, PartialEq, Eq)]
36pub enum REV1_A {
37    #[doc = "0: No action"]
38    VALUE1 = 0,
39    #[doc = "1: Clear the result event flag in GxREFLAG"]
40    VALUE2 = 1,
41}
42impl From<REV1_A> for bool {
43    #[inline(always)]
44    fn from(variant: REV1_A) -> Self {
45        variant as u8 != 0
46    }
47}
48#[doc = "Field `REV1` writer - Clear Result Event for Result Register 1"]
49pub type REV1_W<'a, REG> = crate::BitWriter<'a, REG, REV1_A>;
50impl<'a, REG> REV1_W<'a, REG>
51where
52    REG: crate::Writable + crate::RegisterSpec,
53{
54    #[doc = "No action"]
55    #[inline(always)]
56    pub fn value1(self) -> &'a mut crate::W<REG> {
57        self.variant(REV1_A::VALUE1)
58    }
59    #[doc = "Clear the result event flag in GxREFLAG"]
60    #[inline(always)]
61    pub fn value2(self) -> &'a mut crate::W<REG> {
62        self.variant(REV1_A::VALUE2)
63    }
64}
65#[doc = "Clear Result Event for Result Register 2\n\nValue on reset: 0"]
66#[derive(Clone, Copy, Debug, PartialEq, Eq)]
67pub enum REV2_A {
68    #[doc = "0: No action"]
69    VALUE1 = 0,
70    #[doc = "1: Clear the result event flag in GxREFLAG"]
71    VALUE2 = 1,
72}
73impl From<REV2_A> for bool {
74    #[inline(always)]
75    fn from(variant: REV2_A) -> Self {
76        variant as u8 != 0
77    }
78}
79#[doc = "Field `REV2` writer - Clear Result Event for Result Register 2"]
80pub type REV2_W<'a, REG> = crate::BitWriter<'a, REG, REV2_A>;
81impl<'a, REG> REV2_W<'a, REG>
82where
83    REG: crate::Writable + crate::RegisterSpec,
84{
85    #[doc = "No action"]
86    #[inline(always)]
87    pub fn value1(self) -> &'a mut crate::W<REG> {
88        self.variant(REV2_A::VALUE1)
89    }
90    #[doc = "Clear the result event flag in GxREFLAG"]
91    #[inline(always)]
92    pub fn value2(self) -> &'a mut crate::W<REG> {
93        self.variant(REV2_A::VALUE2)
94    }
95}
96#[doc = "Clear Result Event for Result Register 3\n\nValue on reset: 0"]
97#[derive(Clone, Copy, Debug, PartialEq, Eq)]
98pub enum REV3_A {
99    #[doc = "0: No action"]
100    VALUE1 = 0,
101    #[doc = "1: Clear the result event flag in GxREFLAG"]
102    VALUE2 = 1,
103}
104impl From<REV3_A> for bool {
105    #[inline(always)]
106    fn from(variant: REV3_A) -> Self {
107        variant as u8 != 0
108    }
109}
110#[doc = "Field `REV3` writer - Clear Result Event for Result Register 3"]
111pub type REV3_W<'a, REG> = crate::BitWriter<'a, REG, REV3_A>;
112impl<'a, REG> REV3_W<'a, REG>
113where
114    REG: crate::Writable + crate::RegisterSpec,
115{
116    #[doc = "No action"]
117    #[inline(always)]
118    pub fn value1(self) -> &'a mut crate::W<REG> {
119        self.variant(REV3_A::VALUE1)
120    }
121    #[doc = "Clear the result event flag in GxREFLAG"]
122    #[inline(always)]
123    pub fn value2(self) -> &'a mut crate::W<REG> {
124        self.variant(REV3_A::VALUE2)
125    }
126}
127#[doc = "Clear Result Event for Result Register 4\n\nValue on reset: 0"]
128#[derive(Clone, Copy, Debug, PartialEq, Eq)]
129pub enum REV4_A {
130    #[doc = "0: No action"]
131    VALUE1 = 0,
132    #[doc = "1: Clear the result event flag in GxREFLAG"]
133    VALUE2 = 1,
134}
135impl From<REV4_A> for bool {
136    #[inline(always)]
137    fn from(variant: REV4_A) -> Self {
138        variant as u8 != 0
139    }
140}
141#[doc = "Field `REV4` writer - Clear Result Event for Result Register 4"]
142pub type REV4_W<'a, REG> = crate::BitWriter<'a, REG, REV4_A>;
143impl<'a, REG> REV4_W<'a, REG>
144where
145    REG: crate::Writable + crate::RegisterSpec,
146{
147    #[doc = "No action"]
148    #[inline(always)]
149    pub fn value1(self) -> &'a mut crate::W<REG> {
150        self.variant(REV4_A::VALUE1)
151    }
152    #[doc = "Clear the result event flag in GxREFLAG"]
153    #[inline(always)]
154    pub fn value2(self) -> &'a mut crate::W<REG> {
155        self.variant(REV4_A::VALUE2)
156    }
157}
158#[doc = "Clear Result Event for Result Register 5\n\nValue on reset: 0"]
159#[derive(Clone, Copy, Debug, PartialEq, Eq)]
160pub enum REV5_A {
161    #[doc = "0: No action"]
162    VALUE1 = 0,
163    #[doc = "1: Clear the result event flag in GxREFLAG"]
164    VALUE2 = 1,
165}
166impl From<REV5_A> for bool {
167    #[inline(always)]
168    fn from(variant: REV5_A) -> Self {
169        variant as u8 != 0
170    }
171}
172#[doc = "Field `REV5` writer - Clear Result Event for Result Register 5"]
173pub type REV5_W<'a, REG> = crate::BitWriter<'a, REG, REV5_A>;
174impl<'a, REG> REV5_W<'a, REG>
175where
176    REG: crate::Writable + crate::RegisterSpec,
177{
178    #[doc = "No action"]
179    #[inline(always)]
180    pub fn value1(self) -> &'a mut crate::W<REG> {
181        self.variant(REV5_A::VALUE1)
182    }
183    #[doc = "Clear the result event flag in GxREFLAG"]
184    #[inline(always)]
185    pub fn value2(self) -> &'a mut crate::W<REG> {
186        self.variant(REV5_A::VALUE2)
187    }
188}
189#[doc = "Clear Result Event for Result Register 6\n\nValue on reset: 0"]
190#[derive(Clone, Copy, Debug, PartialEq, Eq)]
191pub enum REV6_A {
192    #[doc = "0: No action"]
193    VALUE1 = 0,
194    #[doc = "1: Clear the result event flag in GxREFLAG"]
195    VALUE2 = 1,
196}
197impl From<REV6_A> for bool {
198    #[inline(always)]
199    fn from(variant: REV6_A) -> Self {
200        variant as u8 != 0
201    }
202}
203#[doc = "Field `REV6` writer - Clear Result Event for Result Register 6"]
204pub type REV6_W<'a, REG> = crate::BitWriter<'a, REG, REV6_A>;
205impl<'a, REG> REV6_W<'a, REG>
206where
207    REG: crate::Writable + crate::RegisterSpec,
208{
209    #[doc = "No action"]
210    #[inline(always)]
211    pub fn value1(self) -> &'a mut crate::W<REG> {
212        self.variant(REV6_A::VALUE1)
213    }
214    #[doc = "Clear the result event flag in GxREFLAG"]
215    #[inline(always)]
216    pub fn value2(self) -> &'a mut crate::W<REG> {
217        self.variant(REV6_A::VALUE2)
218    }
219}
220#[doc = "Clear Result Event for Result Register 7\n\nValue on reset: 0"]
221#[derive(Clone, Copy, Debug, PartialEq, Eq)]
222pub enum REV7_A {
223    #[doc = "0: No action"]
224    VALUE1 = 0,
225    #[doc = "1: Clear the result event flag in GxREFLAG"]
226    VALUE2 = 1,
227}
228impl From<REV7_A> for bool {
229    #[inline(always)]
230    fn from(variant: REV7_A) -> Self {
231        variant as u8 != 0
232    }
233}
234#[doc = "Field `REV7` writer - Clear Result Event for Result Register 7"]
235pub type REV7_W<'a, REG> = crate::BitWriter<'a, REG, REV7_A>;
236impl<'a, REG> REV7_W<'a, REG>
237where
238    REG: crate::Writable + crate::RegisterSpec,
239{
240    #[doc = "No action"]
241    #[inline(always)]
242    pub fn value1(self) -> &'a mut crate::W<REG> {
243        self.variant(REV7_A::VALUE1)
244    }
245    #[doc = "Clear the result event flag in GxREFLAG"]
246    #[inline(always)]
247    pub fn value2(self) -> &'a mut crate::W<REG> {
248        self.variant(REV7_A::VALUE2)
249    }
250}
251#[doc = "Clear Result Event for Result Register 8\n\nValue on reset: 0"]
252#[derive(Clone, Copy, Debug, PartialEq, Eq)]
253pub enum REV8_A {
254    #[doc = "0: No action"]
255    VALUE1 = 0,
256    #[doc = "1: Clear the result event flag in GxREFLAG"]
257    VALUE2 = 1,
258}
259impl From<REV8_A> for bool {
260    #[inline(always)]
261    fn from(variant: REV8_A) -> Self {
262        variant as u8 != 0
263    }
264}
265#[doc = "Field `REV8` writer - Clear Result Event for Result Register 8"]
266pub type REV8_W<'a, REG> = crate::BitWriter<'a, REG, REV8_A>;
267impl<'a, REG> REV8_W<'a, REG>
268where
269    REG: crate::Writable + crate::RegisterSpec,
270{
271    #[doc = "No action"]
272    #[inline(always)]
273    pub fn value1(self) -> &'a mut crate::W<REG> {
274        self.variant(REV8_A::VALUE1)
275    }
276    #[doc = "Clear the result event flag in GxREFLAG"]
277    #[inline(always)]
278    pub fn value2(self) -> &'a mut crate::W<REG> {
279        self.variant(REV8_A::VALUE2)
280    }
281}
282#[doc = "Clear Result Event for Result Register 9\n\nValue on reset: 0"]
283#[derive(Clone, Copy, Debug, PartialEq, Eq)]
284pub enum REV9_A {
285    #[doc = "0: No action"]
286    VALUE1 = 0,
287    #[doc = "1: Clear the result event flag in GxREFLAG"]
288    VALUE2 = 1,
289}
290impl From<REV9_A> for bool {
291    #[inline(always)]
292    fn from(variant: REV9_A) -> Self {
293        variant as u8 != 0
294    }
295}
296#[doc = "Field `REV9` writer - Clear Result Event for Result Register 9"]
297pub type REV9_W<'a, REG> = crate::BitWriter<'a, REG, REV9_A>;
298impl<'a, REG> REV9_W<'a, REG>
299where
300    REG: crate::Writable + crate::RegisterSpec,
301{
302    #[doc = "No action"]
303    #[inline(always)]
304    pub fn value1(self) -> &'a mut crate::W<REG> {
305        self.variant(REV9_A::VALUE1)
306    }
307    #[doc = "Clear the result event flag in GxREFLAG"]
308    #[inline(always)]
309    pub fn value2(self) -> &'a mut crate::W<REG> {
310        self.variant(REV9_A::VALUE2)
311    }
312}
313#[doc = "Clear Result Event for Result Register 10\n\nValue on reset: 0"]
314#[derive(Clone, Copy, Debug, PartialEq, Eq)]
315pub enum REV10_A {
316    #[doc = "0: No action"]
317    VALUE1 = 0,
318    #[doc = "1: Clear the result event flag in GxREFLAG"]
319    VALUE2 = 1,
320}
321impl From<REV10_A> for bool {
322    #[inline(always)]
323    fn from(variant: REV10_A) -> Self {
324        variant as u8 != 0
325    }
326}
327#[doc = "Field `REV10` writer - Clear Result Event for Result Register 10"]
328pub type REV10_W<'a, REG> = crate::BitWriter<'a, REG, REV10_A>;
329impl<'a, REG> REV10_W<'a, REG>
330where
331    REG: crate::Writable + crate::RegisterSpec,
332{
333    #[doc = "No action"]
334    #[inline(always)]
335    pub fn value1(self) -> &'a mut crate::W<REG> {
336        self.variant(REV10_A::VALUE1)
337    }
338    #[doc = "Clear the result event flag in GxREFLAG"]
339    #[inline(always)]
340    pub fn value2(self) -> &'a mut crate::W<REG> {
341        self.variant(REV10_A::VALUE2)
342    }
343}
344#[doc = "Clear Result Event for Result Register 11\n\nValue on reset: 0"]
345#[derive(Clone, Copy, Debug, PartialEq, Eq)]
346pub enum REV11_A {
347    #[doc = "0: No action"]
348    VALUE1 = 0,
349    #[doc = "1: Clear the result event flag in GxREFLAG"]
350    VALUE2 = 1,
351}
352impl From<REV11_A> for bool {
353    #[inline(always)]
354    fn from(variant: REV11_A) -> Self {
355        variant as u8 != 0
356    }
357}
358#[doc = "Field `REV11` writer - Clear Result Event for Result Register 11"]
359pub type REV11_W<'a, REG> = crate::BitWriter<'a, REG, REV11_A>;
360impl<'a, REG> REV11_W<'a, REG>
361where
362    REG: crate::Writable + crate::RegisterSpec,
363{
364    #[doc = "No action"]
365    #[inline(always)]
366    pub fn value1(self) -> &'a mut crate::W<REG> {
367        self.variant(REV11_A::VALUE1)
368    }
369    #[doc = "Clear the result event flag in GxREFLAG"]
370    #[inline(always)]
371    pub fn value2(self) -> &'a mut crate::W<REG> {
372        self.variant(REV11_A::VALUE2)
373    }
374}
375#[doc = "Clear Result Event for Result Register 12\n\nValue on reset: 0"]
376#[derive(Clone, Copy, Debug, PartialEq, Eq)]
377pub enum REV12_A {
378    #[doc = "0: No action"]
379    VALUE1 = 0,
380    #[doc = "1: Clear the result event flag in GxREFLAG"]
381    VALUE2 = 1,
382}
383impl From<REV12_A> for bool {
384    #[inline(always)]
385    fn from(variant: REV12_A) -> Self {
386        variant as u8 != 0
387    }
388}
389#[doc = "Field `REV12` writer - Clear Result Event for Result Register 12"]
390pub type REV12_W<'a, REG> = crate::BitWriter<'a, REG, REV12_A>;
391impl<'a, REG> REV12_W<'a, REG>
392where
393    REG: crate::Writable + crate::RegisterSpec,
394{
395    #[doc = "No action"]
396    #[inline(always)]
397    pub fn value1(self) -> &'a mut crate::W<REG> {
398        self.variant(REV12_A::VALUE1)
399    }
400    #[doc = "Clear the result event flag in GxREFLAG"]
401    #[inline(always)]
402    pub fn value2(self) -> &'a mut crate::W<REG> {
403        self.variant(REV12_A::VALUE2)
404    }
405}
406#[doc = "Clear Result Event for Result Register 13\n\nValue on reset: 0"]
407#[derive(Clone, Copy, Debug, PartialEq, Eq)]
408pub enum REV13_A {
409    #[doc = "0: No action"]
410    VALUE1 = 0,
411    #[doc = "1: Clear the result event flag in GxREFLAG"]
412    VALUE2 = 1,
413}
414impl From<REV13_A> for bool {
415    #[inline(always)]
416    fn from(variant: REV13_A) -> Self {
417        variant as u8 != 0
418    }
419}
420#[doc = "Field `REV13` writer - Clear Result Event for Result Register 13"]
421pub type REV13_W<'a, REG> = crate::BitWriter<'a, REG, REV13_A>;
422impl<'a, REG> REV13_W<'a, REG>
423where
424    REG: crate::Writable + crate::RegisterSpec,
425{
426    #[doc = "No action"]
427    #[inline(always)]
428    pub fn value1(self) -> &'a mut crate::W<REG> {
429        self.variant(REV13_A::VALUE1)
430    }
431    #[doc = "Clear the result event flag in GxREFLAG"]
432    #[inline(always)]
433    pub fn value2(self) -> &'a mut crate::W<REG> {
434        self.variant(REV13_A::VALUE2)
435    }
436}
437#[doc = "Clear Result Event for Result Register 14\n\nValue on reset: 0"]
438#[derive(Clone, Copy, Debug, PartialEq, Eq)]
439pub enum REV14_A {
440    #[doc = "0: No action"]
441    VALUE1 = 0,
442    #[doc = "1: Clear the result event flag in GxREFLAG"]
443    VALUE2 = 1,
444}
445impl From<REV14_A> for bool {
446    #[inline(always)]
447    fn from(variant: REV14_A) -> Self {
448        variant as u8 != 0
449    }
450}
451#[doc = "Field `REV14` writer - Clear Result Event for Result Register 14"]
452pub type REV14_W<'a, REG> = crate::BitWriter<'a, REG, REV14_A>;
453impl<'a, REG> REV14_W<'a, REG>
454where
455    REG: crate::Writable + crate::RegisterSpec,
456{
457    #[doc = "No action"]
458    #[inline(always)]
459    pub fn value1(self) -> &'a mut crate::W<REG> {
460        self.variant(REV14_A::VALUE1)
461    }
462    #[doc = "Clear the result event flag in GxREFLAG"]
463    #[inline(always)]
464    pub fn value2(self) -> &'a mut crate::W<REG> {
465        self.variant(REV14_A::VALUE2)
466    }
467}
468#[doc = "Clear Result Event for Result Register 15\n\nValue on reset: 0"]
469#[derive(Clone, Copy, Debug, PartialEq, Eq)]
470pub enum REV15_A {
471    #[doc = "0: No action"]
472    VALUE1 = 0,
473    #[doc = "1: Clear the result event flag in GxREFLAG"]
474    VALUE2 = 1,
475}
476impl From<REV15_A> for bool {
477    #[inline(always)]
478    fn from(variant: REV15_A) -> Self {
479        variant as u8 != 0
480    }
481}
482#[doc = "Field `REV15` writer - Clear Result Event for Result Register 15"]
483pub type REV15_W<'a, REG> = crate::BitWriter<'a, REG, REV15_A>;
484impl<'a, REG> REV15_W<'a, REG>
485where
486    REG: crate::Writable + crate::RegisterSpec,
487{
488    #[doc = "No action"]
489    #[inline(always)]
490    pub fn value1(self) -> &'a mut crate::W<REG> {
491        self.variant(REV15_A::VALUE1)
492    }
493    #[doc = "Clear the result event flag in GxREFLAG"]
494    #[inline(always)]
495    pub fn value2(self) -> &'a mut crate::W<REG> {
496        self.variant(REV15_A::VALUE2)
497    }
498}
499impl W {
500    #[doc = "Bit 0 - Clear Result Event for Result Register 0"]
501    #[inline(always)]
502    pub fn rev0(&mut self) -> REV0_W<REFCLR_SPEC> {
503        REV0_W::new(self, 0)
504    }
505    #[doc = "Bit 1 - Clear Result Event for Result Register 1"]
506    #[inline(always)]
507    pub fn rev1(&mut self) -> REV1_W<REFCLR_SPEC> {
508        REV1_W::new(self, 1)
509    }
510    #[doc = "Bit 2 - Clear Result Event for Result Register 2"]
511    #[inline(always)]
512    pub fn rev2(&mut self) -> REV2_W<REFCLR_SPEC> {
513        REV2_W::new(self, 2)
514    }
515    #[doc = "Bit 3 - Clear Result Event for Result Register 3"]
516    #[inline(always)]
517    pub fn rev3(&mut self) -> REV3_W<REFCLR_SPEC> {
518        REV3_W::new(self, 3)
519    }
520    #[doc = "Bit 4 - Clear Result Event for Result Register 4"]
521    #[inline(always)]
522    pub fn rev4(&mut self) -> REV4_W<REFCLR_SPEC> {
523        REV4_W::new(self, 4)
524    }
525    #[doc = "Bit 5 - Clear Result Event for Result Register 5"]
526    #[inline(always)]
527    pub fn rev5(&mut self) -> REV5_W<REFCLR_SPEC> {
528        REV5_W::new(self, 5)
529    }
530    #[doc = "Bit 6 - Clear Result Event for Result Register 6"]
531    #[inline(always)]
532    pub fn rev6(&mut self) -> REV6_W<REFCLR_SPEC> {
533        REV6_W::new(self, 6)
534    }
535    #[doc = "Bit 7 - Clear Result Event for Result Register 7"]
536    #[inline(always)]
537    pub fn rev7(&mut self) -> REV7_W<REFCLR_SPEC> {
538        REV7_W::new(self, 7)
539    }
540    #[doc = "Bit 8 - Clear Result Event for Result Register 8"]
541    #[inline(always)]
542    pub fn rev8(&mut self) -> REV8_W<REFCLR_SPEC> {
543        REV8_W::new(self, 8)
544    }
545    #[doc = "Bit 9 - Clear Result Event for Result Register 9"]
546    #[inline(always)]
547    pub fn rev9(&mut self) -> REV9_W<REFCLR_SPEC> {
548        REV9_W::new(self, 9)
549    }
550    #[doc = "Bit 10 - Clear Result Event for Result Register 10"]
551    #[inline(always)]
552    pub fn rev10(&mut self) -> REV10_W<REFCLR_SPEC> {
553        REV10_W::new(self, 10)
554    }
555    #[doc = "Bit 11 - Clear Result Event for Result Register 11"]
556    #[inline(always)]
557    pub fn rev11(&mut self) -> REV11_W<REFCLR_SPEC> {
558        REV11_W::new(self, 11)
559    }
560    #[doc = "Bit 12 - Clear Result Event for Result Register 12"]
561    #[inline(always)]
562    pub fn rev12(&mut self) -> REV12_W<REFCLR_SPEC> {
563        REV12_W::new(self, 12)
564    }
565    #[doc = "Bit 13 - Clear Result Event for Result Register 13"]
566    #[inline(always)]
567    pub fn rev13(&mut self) -> REV13_W<REFCLR_SPEC> {
568        REV13_W::new(self, 13)
569    }
570    #[doc = "Bit 14 - Clear Result Event for Result Register 14"]
571    #[inline(always)]
572    pub fn rev14(&mut self) -> REV14_W<REFCLR_SPEC> {
573        REV14_W::new(self, 14)
574    }
575    #[doc = "Bit 15 - Clear Result Event for Result Register 15"]
576    #[inline(always)]
577    pub fn rev15(&mut self) -> REV15_W<REFCLR_SPEC> {
578        REV15_W::new(self, 15)
579    }
580}
581#[doc = "Result Event Flag Clear Register\n\nYou can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`refclr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
582pub struct REFCLR_SPEC;
583impl crate::RegisterSpec for REFCLR_SPEC {
584    type Ux = u32;
585}
586#[doc = "`write(|w| ..)` method takes [`refclr::W`](W) writer structure"]
587impl crate::Writable for REFCLR_SPEC {
588    type Safety = crate::Unsafe;
589    const ZERO_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
590    const ONE_TO_MODIFY_FIELDS_BITMAP: u32 = 0;
591}
592#[doc = "`reset()` method sets REFCLR to value 0"]
593impl crate::Resettable for REFCLR_SPEC {
594    const RESET_VALUE: u32 = 0;
595}
xmc4100/vadc_g0/refclr.rs

xmc4100/vadc_g0/
refclr.rs
