stm32f103xx/adc1/cr1/
mod.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::CR1 {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct AWDENR {
47    bits: bool,
48}
49impl AWDENR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct JAWDENR {
68    bits: bool,
69}
70impl JAWDENR {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct DUALMODR {
89    bits: u8,
90}
91impl DUALMODR {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bits(&self) -> u8 {
95        self.bits
96    }
97}
98#[doc = r" Value of the field"]
99pub struct DISCNUMR {
100    bits: u8,
101}
102impl DISCNUMR {
103    #[doc = r" Value of the field as raw bits"]
104    #[inline]
105    pub fn bits(&self) -> u8 {
106        self.bits
107    }
108}
109#[doc = r" Value of the field"]
110pub struct JDISCENR {
111    bits: bool,
112}
113impl JDISCENR {
114    #[doc = r" Value of the field as raw bits"]
115    #[inline]
116    pub fn bit(&self) -> bool {
117        self.bits
118    }
119    #[doc = r" Returns `true` if the bit is clear (0)"]
120    #[inline]
121    pub fn bit_is_clear(&self) -> bool {
122        !self.bit()
123    }
124    #[doc = r" Returns `true` if the bit is set (1)"]
125    #[inline]
126    pub fn bit_is_set(&self) -> bool {
127        self.bit()
128    }
129}
130#[doc = r" Value of the field"]
131pub struct DISCENR {
132    bits: bool,
133}
134impl DISCENR {
135    #[doc = r" Value of the field as raw bits"]
136    #[inline]
137    pub fn bit(&self) -> bool {
138        self.bits
139    }
140    #[doc = r" Returns `true` if the bit is clear (0)"]
141    #[inline]
142    pub fn bit_is_clear(&self) -> bool {
143        !self.bit()
144    }
145    #[doc = r" Returns `true` if the bit is set (1)"]
146    #[inline]
147    pub fn bit_is_set(&self) -> bool {
148        self.bit()
149    }
150}
151#[doc = r" Value of the field"]
152pub struct JAUTOR {
153    bits: bool,
154}
155impl JAUTOR {
156    #[doc = r" Value of the field as raw bits"]
157    #[inline]
158    pub fn bit(&self) -> bool {
159        self.bits
160    }
161    #[doc = r" Returns `true` if the bit is clear (0)"]
162    #[inline]
163    pub fn bit_is_clear(&self) -> bool {
164        !self.bit()
165    }
166    #[doc = r" Returns `true` if the bit is set (1)"]
167    #[inline]
168    pub fn bit_is_set(&self) -> bool {
169        self.bit()
170    }
171}
172#[doc = r" Value of the field"]
173pub struct AWDSGLR {
174    bits: bool,
175}
176impl AWDSGLR {
177    #[doc = r" Value of the field as raw bits"]
178    #[inline]
179    pub fn bit(&self) -> bool {
180        self.bits
181    }
182    #[doc = r" Returns `true` if the bit is clear (0)"]
183    #[inline]
184    pub fn bit_is_clear(&self) -> bool {
185        !self.bit()
186    }
187    #[doc = r" Returns `true` if the bit is set (1)"]
188    #[inline]
189    pub fn bit_is_set(&self) -> bool {
190        self.bit()
191    }
192}
193#[doc = r" Value of the field"]
194pub struct SCANR {
195    bits: bool,
196}
197impl SCANR {
198    #[doc = r" Value of the field as raw bits"]
199    #[inline]
200    pub fn bit(&self) -> bool {
201        self.bits
202    }
203    #[doc = r" Returns `true` if the bit is clear (0)"]
204    #[inline]
205    pub fn bit_is_clear(&self) -> bool {
206        !self.bit()
207    }
208    #[doc = r" Returns `true` if the bit is set (1)"]
209    #[inline]
210    pub fn bit_is_set(&self) -> bool {
211        self.bit()
212    }
213}
214#[doc = r" Value of the field"]
215pub struct JEOCIER {
216    bits: bool,
217}
218impl JEOCIER {
219    #[doc = r" Value of the field as raw bits"]
220    #[inline]
221    pub fn bit(&self) -> bool {
222        self.bits
223    }
224    #[doc = r" Returns `true` if the bit is clear (0)"]
225    #[inline]
226    pub fn bit_is_clear(&self) -> bool {
227        !self.bit()
228    }
229    #[doc = r" Returns `true` if the bit is set (1)"]
230    #[inline]
231    pub fn bit_is_set(&self) -> bool {
232        self.bit()
233    }
234}
235#[doc = r" Value of the field"]
236pub struct AWDIER {
237    bits: bool,
238}
239impl AWDIER {
240    #[doc = r" Value of the field as raw bits"]
241    #[inline]
242    pub fn bit(&self) -> bool {
243        self.bits
244    }
245    #[doc = r" Returns `true` if the bit is clear (0)"]
246    #[inline]
247    pub fn bit_is_clear(&self) -> bool {
248        !self.bit()
249    }
250    #[doc = r" Returns `true` if the bit is set (1)"]
251    #[inline]
252    pub fn bit_is_set(&self) -> bool {
253        self.bit()
254    }
255}
256#[doc = r" Value of the field"]
257pub struct EOCIER {
258    bits: bool,
259}
260impl EOCIER {
261    #[doc = r" Value of the field as raw bits"]
262    #[inline]
263    pub fn bit(&self) -> bool {
264        self.bits
265    }
266    #[doc = r" Returns `true` if the bit is clear (0)"]
267    #[inline]
268    pub fn bit_is_clear(&self) -> bool {
269        !self.bit()
270    }
271    #[doc = r" Returns `true` if the bit is set (1)"]
272    #[inline]
273    pub fn bit_is_set(&self) -> bool {
274        self.bit()
275    }
276}
277#[doc = r" Value of the field"]
278pub struct AWDCHR {
279    bits: u8,
280}
281impl AWDCHR {
282    #[doc = r" Value of the field as raw bits"]
283    #[inline]
284    pub fn bits(&self) -> u8 {
285        self.bits
286    }
287}
288#[doc = r" Proxy"]
289pub struct _AWDENW<'a> {
290    w: &'a mut W,
291}
292impl<'a> _AWDENW<'a> {
293    #[doc = r" Sets the field bit"]
294    pub fn set_bit(self) -> &'a mut W {
295        self.bit(true)
296    }
297    #[doc = r" Clears the field bit"]
298    pub fn clear_bit(self) -> &'a mut W {
299        self.bit(false)
300    }
301    #[doc = r" Writes raw bits to the field"]
302    #[inline]
303    pub fn bit(self, value: bool) -> &'a mut W {
304        const MASK: bool = true;
305        const OFFSET: u8 = 23;
306        self.w.bits &= !((MASK as u32) << OFFSET);
307        self.w.bits |= ((value & MASK) as u32) << OFFSET;
308        self.w
309    }
310}
311#[doc = r" Proxy"]
312pub struct _JAWDENW<'a> {
313    w: &'a mut W,
314}
315impl<'a> _JAWDENW<'a> {
316    #[doc = r" Sets the field bit"]
317    pub fn set_bit(self) -> &'a mut W {
318        self.bit(true)
319    }
320    #[doc = r" Clears the field bit"]
321    pub fn clear_bit(self) -> &'a mut W {
322        self.bit(false)
323    }
324    #[doc = r" Writes raw bits to the field"]
325    #[inline]
326    pub fn bit(self, value: bool) -> &'a mut W {
327        const MASK: bool = true;
328        const OFFSET: u8 = 22;
329        self.w.bits &= !((MASK as u32) << OFFSET);
330        self.w.bits |= ((value & MASK) as u32) << OFFSET;
331        self.w
332    }
333}
334#[doc = r" Proxy"]
335pub struct _DUALMODW<'a> {
336    w: &'a mut W,
337}
338impl<'a> _DUALMODW<'a> {
339    #[doc = r" Writes raw bits to the field"]
340    #[inline]
341    pub unsafe fn bits(self, value: u8) -> &'a mut W {
342        const MASK: u8 = 15;
343        const OFFSET: u8 = 16;
344        self.w.bits &= !((MASK as u32) << OFFSET);
345        self.w.bits |= ((value & MASK) as u32) << OFFSET;
346        self.w
347    }
348}
349#[doc = r" Proxy"]
350pub struct _DISCNUMW<'a> {
351    w: &'a mut W,
352}
353impl<'a> _DISCNUMW<'a> {
354    #[doc = r" Writes raw bits to the field"]
355    #[inline]
356    pub unsafe fn bits(self, value: u8) -> &'a mut W {
357        const MASK: u8 = 7;
358        const OFFSET: u8 = 13;
359        self.w.bits &= !((MASK as u32) << OFFSET);
360        self.w.bits |= ((value & MASK) as u32) << OFFSET;
361        self.w
362    }
363}
364#[doc = r" Proxy"]
365pub struct _JDISCENW<'a> {
366    w: &'a mut W,
367}
368impl<'a> _JDISCENW<'a> {
369    #[doc = r" Sets the field bit"]
370    pub fn set_bit(self) -> &'a mut W {
371        self.bit(true)
372    }
373    #[doc = r" Clears the field bit"]
374    pub fn clear_bit(self) -> &'a mut W {
375        self.bit(false)
376    }
377    #[doc = r" Writes raw bits to the field"]
378    #[inline]
379    pub fn bit(self, value: bool) -> &'a mut W {
380        const MASK: bool = true;
381        const OFFSET: u8 = 12;
382        self.w.bits &= !((MASK as u32) << OFFSET);
383        self.w.bits |= ((value & MASK) as u32) << OFFSET;
384        self.w
385    }
386}
387#[doc = r" Proxy"]
388pub struct _DISCENW<'a> {
389    w: &'a mut W,
390}
391impl<'a> _DISCENW<'a> {
392    #[doc = r" Sets the field bit"]
393    pub fn set_bit(self) -> &'a mut W {
394        self.bit(true)
395    }
396    #[doc = r" Clears the field bit"]
397    pub fn clear_bit(self) -> &'a mut W {
398        self.bit(false)
399    }
400    #[doc = r" Writes raw bits to the field"]
401    #[inline]
402    pub fn bit(self, value: bool) -> &'a mut W {
403        const MASK: bool = true;
404        const OFFSET: u8 = 11;
405        self.w.bits &= !((MASK as u32) << OFFSET);
406        self.w.bits |= ((value & MASK) as u32) << OFFSET;
407        self.w
408    }
409}
410#[doc = r" Proxy"]
411pub struct _JAUTOW<'a> {
412    w: &'a mut W,
413}
414impl<'a> _JAUTOW<'a> {
415    #[doc = r" Sets the field bit"]
416    pub fn set_bit(self) -> &'a mut W {
417        self.bit(true)
418    }
419    #[doc = r" Clears the field bit"]
420    pub fn clear_bit(self) -> &'a mut W {
421        self.bit(false)
422    }
423    #[doc = r" Writes raw bits to the field"]
424    #[inline]
425    pub fn bit(self, value: bool) -> &'a mut W {
426        const MASK: bool = true;
427        const OFFSET: u8 = 10;
428        self.w.bits &= !((MASK as u32) << OFFSET);
429        self.w.bits |= ((value & MASK) as u32) << OFFSET;
430        self.w
431    }
432}
433#[doc = r" Proxy"]
434pub struct _AWDSGLW<'a> {
435    w: &'a mut W,
436}
437impl<'a> _AWDSGLW<'a> {
438    #[doc = r" Sets the field bit"]
439    pub fn set_bit(self) -> &'a mut W {
440        self.bit(true)
441    }
442    #[doc = r" Clears the field bit"]
443    pub fn clear_bit(self) -> &'a mut W {
444        self.bit(false)
445    }
446    #[doc = r" Writes raw bits to the field"]
447    #[inline]
448    pub fn bit(self, value: bool) -> &'a mut W {
449        const MASK: bool = true;
450        const OFFSET: u8 = 9;
451        self.w.bits &= !((MASK as u32) << OFFSET);
452        self.w.bits |= ((value & MASK) as u32) << OFFSET;
453        self.w
454    }
455}
456#[doc = r" Proxy"]
457pub struct _SCANW<'a> {
458    w: &'a mut W,
459}
460impl<'a> _SCANW<'a> {
461    #[doc = r" Sets the field bit"]
462    pub fn set_bit(self) -> &'a mut W {
463        self.bit(true)
464    }
465    #[doc = r" Clears the field bit"]
466    pub fn clear_bit(self) -> &'a mut W {
467        self.bit(false)
468    }
469    #[doc = r" Writes raw bits to the field"]
470    #[inline]
471    pub fn bit(self, value: bool) -> &'a mut W {
472        const MASK: bool = true;
473        const OFFSET: u8 = 8;
474        self.w.bits &= !((MASK as u32) << OFFSET);
475        self.w.bits |= ((value & MASK) as u32) << OFFSET;
476        self.w
477    }
478}
479#[doc = r" Proxy"]
480pub struct _JEOCIEW<'a> {
481    w: &'a mut W,
482}
483impl<'a> _JEOCIEW<'a> {
484    #[doc = r" Sets the field bit"]
485    pub fn set_bit(self) -> &'a mut W {
486        self.bit(true)
487    }
488    #[doc = r" Clears the field bit"]
489    pub fn clear_bit(self) -> &'a mut W {
490        self.bit(false)
491    }
492    #[doc = r" Writes raw bits to the field"]
493    #[inline]
494    pub fn bit(self, value: bool) -> &'a mut W {
495        const MASK: bool = true;
496        const OFFSET: u8 = 7;
497        self.w.bits &= !((MASK as u32) << OFFSET);
498        self.w.bits |= ((value & MASK) as u32) << OFFSET;
499        self.w
500    }
501}
502#[doc = r" Proxy"]
503pub struct _AWDIEW<'a> {
504    w: &'a mut W,
505}
506impl<'a> _AWDIEW<'a> {
507    #[doc = r" Sets the field bit"]
508    pub fn set_bit(self) -> &'a mut W {
509        self.bit(true)
510    }
511    #[doc = r" Clears the field bit"]
512    pub fn clear_bit(self) -> &'a mut W {
513        self.bit(false)
514    }
515    #[doc = r" Writes raw bits to the field"]
516    #[inline]
517    pub fn bit(self, value: bool) -> &'a mut W {
518        const MASK: bool = true;
519        const OFFSET: u8 = 6;
520        self.w.bits &= !((MASK as u32) << OFFSET);
521        self.w.bits |= ((value & MASK) as u32) << OFFSET;
522        self.w
523    }
524}
525#[doc = r" Proxy"]
526pub struct _EOCIEW<'a> {
527    w: &'a mut W,
528}
529impl<'a> _EOCIEW<'a> {
530    #[doc = r" Sets the field bit"]
531    pub fn set_bit(self) -> &'a mut W {
532        self.bit(true)
533    }
534    #[doc = r" Clears the field bit"]
535    pub fn clear_bit(self) -> &'a mut W {
536        self.bit(false)
537    }
538    #[doc = r" Writes raw bits to the field"]
539    #[inline]
540    pub fn bit(self, value: bool) -> &'a mut W {
541        const MASK: bool = true;
542        const OFFSET: u8 = 5;
543        self.w.bits &= !((MASK as u32) << OFFSET);
544        self.w.bits |= ((value & MASK) as u32) << OFFSET;
545        self.w
546    }
547}
548#[doc = r" Proxy"]
549pub struct _AWDCHW<'a> {
550    w: &'a mut W,
551}
552impl<'a> _AWDCHW<'a> {
553    #[doc = r" Writes raw bits to the field"]
554    #[inline]
555    pub unsafe fn bits(self, value: u8) -> &'a mut W {
556        const MASK: u8 = 31;
557        const OFFSET: u8 = 0;
558        self.w.bits &= !((MASK as u32) << OFFSET);
559        self.w.bits |= ((value & MASK) as u32) << OFFSET;
560        self.w
561    }
562}
563impl R {
564    #[doc = r" Value of the register as raw bits"]
565    #[inline]
566    pub fn bits(&self) -> u32 {
567        self.bits
568    }
569    #[doc = "Bit 23 - Analog watchdog enable on regular channels"]
570    #[inline]
571    pub fn awden(&self) -> AWDENR {
572        let bits = {
573            const MASK: bool = true;
574            const OFFSET: u8 = 23;
575            ((self.bits >> OFFSET) & MASK as u32) != 0
576        };
577        AWDENR { bits }
578    }
579    #[doc = "Bit 22 - Analog watchdog enable on injected channels"]
580    #[inline]
581    pub fn jawden(&self) -> JAWDENR {
582        let bits = {
583            const MASK: bool = true;
584            const OFFSET: u8 = 22;
585            ((self.bits >> OFFSET) & MASK as u32) != 0
586        };
587        JAWDENR { bits }
588    }
589    #[doc = "Bits 16:19 - Dual mode selection"]
590    #[inline]
591    pub fn dualmod(&self) -> DUALMODR {
592        let bits = {
593            const MASK: u8 = 15;
594            const OFFSET: u8 = 16;
595            ((self.bits >> OFFSET) & MASK as u32) as u8
596        };
597        DUALMODR { bits }
598    }
599    #[doc = "Bits 13:15 - Discontinuous mode channel count"]
600    #[inline]
601    pub fn discnum(&self) -> DISCNUMR {
602        let bits = {
603            const MASK: u8 = 7;
604            const OFFSET: u8 = 13;
605            ((self.bits >> OFFSET) & MASK as u32) as u8
606        };
607        DISCNUMR { bits }
608    }
609    #[doc = "Bit 12 - Discontinuous mode on injected channels"]
610    #[inline]
611    pub fn jdiscen(&self) -> JDISCENR {
612        let bits = {
613            const MASK: bool = true;
614            const OFFSET: u8 = 12;
615            ((self.bits >> OFFSET) & MASK as u32) != 0
616        };
617        JDISCENR { bits }
618    }
619    #[doc = "Bit 11 - Discontinuous mode on regular channels"]
620    #[inline]
621    pub fn discen(&self) -> DISCENR {
622        let bits = {
623            const MASK: bool = true;
624            const OFFSET: u8 = 11;
625            ((self.bits >> OFFSET) & MASK as u32) != 0
626        };
627        DISCENR { bits }
628    }
629    #[doc = "Bit 10 - Automatic injected group conversion"]
630    #[inline]
631    pub fn jauto(&self) -> JAUTOR {
632        let bits = {
633            const MASK: bool = true;
634            const OFFSET: u8 = 10;
635            ((self.bits >> OFFSET) & MASK as u32) != 0
636        };
637        JAUTOR { bits }
638    }
639    #[doc = "Bit 9 - Enable the watchdog on a single channel in scan mode"]
640    #[inline]
641    pub fn awdsgl(&self) -> AWDSGLR {
642        let bits = {
643            const MASK: bool = true;
644            const OFFSET: u8 = 9;
645            ((self.bits >> OFFSET) & MASK as u32) != 0
646        };
647        AWDSGLR { bits }
648    }
649    #[doc = "Bit 8 - Scan mode"]
650    #[inline]
651    pub fn scan(&self) -> SCANR {
652        let bits = {
653            const MASK: bool = true;
654            const OFFSET: u8 = 8;
655            ((self.bits >> OFFSET) & MASK as u32) != 0
656        };
657        SCANR { bits }
658    }
659    #[doc = "Bit 7 - Interrupt enable for injected channels"]
660    #[inline]
661    pub fn jeocie(&self) -> JEOCIER {
662        let bits = {
663            const MASK: bool = true;
664            const OFFSET: u8 = 7;
665            ((self.bits >> OFFSET) & MASK as u32) != 0
666        };
667        JEOCIER { bits }
668    }
669    #[doc = "Bit 6 - Analog watchdog interrupt enable"]
670    #[inline]
671    pub fn awdie(&self) -> AWDIER {
672        let bits = {
673            const MASK: bool = true;
674            const OFFSET: u8 = 6;
675            ((self.bits >> OFFSET) & MASK as u32) != 0
676        };
677        AWDIER { bits }
678    }
679    #[doc = "Bit 5 - Interrupt enable for EOC"]
680    #[inline]
681    pub fn eocie(&self) -> EOCIER {
682        let bits = {
683            const MASK: bool = true;
684            const OFFSET: u8 = 5;
685            ((self.bits >> OFFSET) & MASK as u32) != 0
686        };
687        EOCIER { bits }
688    }
689    #[doc = "Bits 0:4 - Analog watchdog channel select bits"]
690    #[inline]
691    pub fn awdch(&self) -> AWDCHR {
692        let bits = {
693            const MASK: u8 = 31;
694            const OFFSET: u8 = 0;
695            ((self.bits >> OFFSET) & MASK as u32) as u8
696        };
697        AWDCHR { bits }
698    }
699}
700impl W {
701    #[doc = r" Reset value of the register"]
702    #[inline]
703    pub fn reset_value() -> W {
704        W { bits: 0 }
705    }
706    #[doc = r" Writes raw bits to the register"]
707    #[inline]
708    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
709        self.bits = bits;
710        self
711    }
712    #[doc = "Bit 23 - Analog watchdog enable on regular channels"]
713    #[inline]
714    pub fn awden(&mut self) -> _AWDENW {
715        _AWDENW { w: self }
716    }
717    #[doc = "Bit 22 - Analog watchdog enable on injected channels"]
718    #[inline]
719    pub fn jawden(&mut self) -> _JAWDENW {
720        _JAWDENW { w: self }
721    }
722    #[doc = "Bits 16:19 - Dual mode selection"]
723    #[inline]
724    pub fn dualmod(&mut self) -> _DUALMODW {
725        _DUALMODW { w: self }
726    }
727    #[doc = "Bits 13:15 - Discontinuous mode channel count"]
728    #[inline]
729    pub fn discnum(&mut self) -> _DISCNUMW {
730        _DISCNUMW { w: self }
731    }
732    #[doc = "Bit 12 - Discontinuous mode on injected channels"]
733    #[inline]
734    pub fn jdiscen(&mut self) -> _JDISCENW {
735        _JDISCENW { w: self }
736    }
737    #[doc = "Bit 11 - Discontinuous mode on regular channels"]
738    #[inline]
739    pub fn discen(&mut self) -> _DISCENW {
740        _DISCENW { w: self }
741    }
742    #[doc = "Bit 10 - Automatic injected group conversion"]
743    #[inline]
744    pub fn jauto(&mut self) -> _JAUTOW {
745        _JAUTOW { w: self }
746    }
747    #[doc = "Bit 9 - Enable the watchdog on a single channel in scan mode"]
748    #[inline]
749    pub fn awdsgl(&mut self) -> _AWDSGLW {
750        _AWDSGLW { w: self }
751    }
752    #[doc = "Bit 8 - Scan mode"]
753    #[inline]
754    pub fn scan(&mut self) -> _SCANW {
755        _SCANW { w: self }
756    }
757    #[doc = "Bit 7 - Interrupt enable for injected channels"]
758    #[inline]
759    pub fn jeocie(&mut self) -> _JEOCIEW {
760        _JEOCIEW { w: self }
761    }
762    #[doc = "Bit 6 - Analog watchdog interrupt enable"]
763    #[inline]
764    pub fn awdie(&mut self) -> _AWDIEW {
765        _AWDIEW { w: self }
766    }
767    #[doc = "Bit 5 - Interrupt enable for EOC"]
768    #[inline]
769    pub fn eocie(&mut self) -> _EOCIEW {
770        _EOCIEW { w: self }
771    }
772    #[doc = "Bits 0:4 - Analog watchdog channel select bits"]
773    #[inline]
774    pub fn awdch(&mut self) -> _AWDCHW {
775        _AWDCHW { w: self }
776    }
777}
stm32f103xx/adc1/cr1/mod.rs

stm32f103xx/adc1/cr1/
mod.rs
