stm32f103xx/adc2/sqr3/
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::SQR3 {
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 SQ6R {
47    bits: u8,
48}
49impl SQ6R {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bits(&self) -> u8 {
53        self.bits
54    }
55}
56#[doc = r" Value of the field"]
57pub struct SQ5R {
58    bits: u8,
59}
60impl SQ5R {
61    #[doc = r" Value of the field as raw bits"]
62    #[inline]
63    pub fn bits(&self) -> u8 {
64        self.bits
65    }
66}
67#[doc = r" Value of the field"]
68pub struct SQ4R {
69    bits: u8,
70}
71impl SQ4R {
72    #[doc = r" Value of the field as raw bits"]
73    #[inline]
74    pub fn bits(&self) -> u8 {
75        self.bits
76    }
77}
78#[doc = r" Value of the field"]
79pub struct SQ3R {
80    bits: u8,
81}
82impl SQ3R {
83    #[doc = r" Value of the field as raw bits"]
84    #[inline]
85    pub fn bits(&self) -> u8 {
86        self.bits
87    }
88}
89#[doc = r" Value of the field"]
90pub struct SQ2R {
91    bits: u8,
92}
93impl SQ2R {
94    #[doc = r" Value of the field as raw bits"]
95    #[inline]
96    pub fn bits(&self) -> u8 {
97        self.bits
98    }
99}
100#[doc = r" Value of the field"]
101pub struct SQ1R {
102    bits: u8,
103}
104impl SQ1R {
105    #[doc = r" Value of the field as raw bits"]
106    #[inline]
107    pub fn bits(&self) -> u8 {
108        self.bits
109    }
110}
111#[doc = r" Proxy"]
112pub struct _SQ6W<'a> {
113    w: &'a mut W,
114}
115impl<'a> _SQ6W<'a> {
116    #[doc = r" Writes raw bits to the field"]
117    #[inline]
118    pub unsafe fn bits(self, value: u8) -> &'a mut W {
119        const MASK: u8 = 31;
120        const OFFSET: u8 = 25;
121        self.w.bits &= !((MASK as u32) << OFFSET);
122        self.w.bits |= ((value & MASK) as u32) << OFFSET;
123        self.w
124    }
125}
126#[doc = r" Proxy"]
127pub struct _SQ5W<'a> {
128    w: &'a mut W,
129}
130impl<'a> _SQ5W<'a> {
131    #[doc = r" Writes raw bits to the field"]
132    #[inline]
133    pub unsafe fn bits(self, value: u8) -> &'a mut W {
134        const MASK: u8 = 31;
135        const OFFSET: u8 = 20;
136        self.w.bits &= !((MASK as u32) << OFFSET);
137        self.w.bits |= ((value & MASK) as u32) << OFFSET;
138        self.w
139    }
140}
141#[doc = r" Proxy"]
142pub struct _SQ4W<'a> {
143    w: &'a mut W,
144}
145impl<'a> _SQ4W<'a> {
146    #[doc = r" Writes raw bits to the field"]
147    #[inline]
148    pub unsafe fn bits(self, value: u8) -> &'a mut W {
149        const MASK: u8 = 31;
150        const OFFSET: u8 = 15;
151        self.w.bits &= !((MASK as u32) << OFFSET);
152        self.w.bits |= ((value & MASK) as u32) << OFFSET;
153        self.w
154    }
155}
156#[doc = r" Proxy"]
157pub struct _SQ3W<'a> {
158    w: &'a mut W,
159}
160impl<'a> _SQ3W<'a> {
161    #[doc = r" Writes raw bits to the field"]
162    #[inline]
163    pub unsafe fn bits(self, value: u8) -> &'a mut W {
164        const MASK: u8 = 31;
165        const OFFSET: u8 = 10;
166        self.w.bits &= !((MASK as u32) << OFFSET);
167        self.w.bits |= ((value & MASK) as u32) << OFFSET;
168        self.w
169    }
170}
171#[doc = r" Proxy"]
172pub struct _SQ2W<'a> {
173    w: &'a mut W,
174}
175impl<'a> _SQ2W<'a> {
176    #[doc = r" Writes raw bits to the field"]
177    #[inline]
178    pub unsafe fn bits(self, value: u8) -> &'a mut W {
179        const MASK: u8 = 31;
180        const OFFSET: u8 = 5;
181        self.w.bits &= !((MASK as u32) << OFFSET);
182        self.w.bits |= ((value & MASK) as u32) << OFFSET;
183        self.w
184    }
185}
186#[doc = r" Proxy"]
187pub struct _SQ1W<'a> {
188    w: &'a mut W,
189}
190impl<'a> _SQ1W<'a> {
191    #[doc = r" Writes raw bits to the field"]
192    #[inline]
193    pub unsafe fn bits(self, value: u8) -> &'a mut W {
194        const MASK: u8 = 31;
195        const OFFSET: u8 = 0;
196        self.w.bits &= !((MASK as u32) << OFFSET);
197        self.w.bits |= ((value & MASK) as u32) << OFFSET;
198        self.w
199    }
200}
201impl R {
202    #[doc = r" Value of the register as raw bits"]
203    #[inline]
204    pub fn bits(&self) -> u32 {
205        self.bits
206    }
207    #[doc = "Bits 25:29 - 6th conversion in regular sequence"]
208    #[inline]
209    pub fn sq6(&self) -> SQ6R {
210        let bits = {
211            const MASK: u8 = 31;
212            const OFFSET: u8 = 25;
213            ((self.bits >> OFFSET) & MASK as u32) as u8
214        };
215        SQ6R { bits }
216    }
217    #[doc = "Bits 20:24 - 5th conversion in regular sequence"]
218    #[inline]
219    pub fn sq5(&self) -> SQ5R {
220        let bits = {
221            const MASK: u8 = 31;
222            const OFFSET: u8 = 20;
223            ((self.bits >> OFFSET) & MASK as u32) as u8
224        };
225        SQ5R { bits }
226    }
227    #[doc = "Bits 15:19 - 4th conversion in regular sequence"]
228    #[inline]
229    pub fn sq4(&self) -> SQ4R {
230        let bits = {
231            const MASK: u8 = 31;
232            const OFFSET: u8 = 15;
233            ((self.bits >> OFFSET) & MASK as u32) as u8
234        };
235        SQ4R { bits }
236    }
237    #[doc = "Bits 10:14 - 3rd conversion in regular sequence"]
238    #[inline]
239    pub fn sq3(&self) -> SQ3R {
240        let bits = {
241            const MASK: u8 = 31;
242            const OFFSET: u8 = 10;
243            ((self.bits >> OFFSET) & MASK as u32) as u8
244        };
245        SQ3R { bits }
246    }
247    #[doc = "Bits 5:9 - 2nd conversion in regular sequence"]
248    #[inline]
249    pub fn sq2(&self) -> SQ2R {
250        let bits = {
251            const MASK: u8 = 31;
252            const OFFSET: u8 = 5;
253            ((self.bits >> OFFSET) & MASK as u32) as u8
254        };
255        SQ2R { bits }
256    }
257    #[doc = "Bits 0:4 - 1st conversion in regular sequence"]
258    #[inline]
259    pub fn sq1(&self) -> SQ1R {
260        let bits = {
261            const MASK: u8 = 31;
262            const OFFSET: u8 = 0;
263            ((self.bits >> OFFSET) & MASK as u32) as u8
264        };
265        SQ1R { bits }
266    }
267}
268impl W {
269    #[doc = r" Reset value of the register"]
270    #[inline]
271    pub fn reset_value() -> W {
272        W { bits: 0 }
273    }
274    #[doc = r" Writes raw bits to the register"]
275    #[inline]
276    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
277        self.bits = bits;
278        self
279    }
280    #[doc = "Bits 25:29 - 6th conversion in regular sequence"]
281    #[inline]
282    pub fn sq6(&mut self) -> _SQ6W {
283        _SQ6W { w: self }
284    }
285    #[doc = "Bits 20:24 - 5th conversion in regular sequence"]
286    #[inline]
287    pub fn sq5(&mut self) -> _SQ5W {
288        _SQ5W { w: self }
289    }
290    #[doc = "Bits 15:19 - 4th conversion in regular sequence"]
291    #[inline]
292    pub fn sq4(&mut self) -> _SQ4W {
293        _SQ4W { w: self }
294    }
295    #[doc = "Bits 10:14 - 3rd conversion in regular sequence"]
296    #[inline]
297    pub fn sq3(&mut self) -> _SQ3W {
298        _SQ3W { w: self }
299    }
300    #[doc = "Bits 5:9 - 2nd conversion in regular sequence"]
301    #[inline]
302    pub fn sq2(&mut self) -> _SQ2W {
303        _SQ2W { w: self }
304    }
305    #[doc = "Bits 0:4 - 1st conversion in regular sequence"]
306    #[inline]
307    pub fn sq1(&mut self) -> _SQ1W {
308        _SQ1W { w: self }
309    }
310}
stm32f103xx/adc2/sqr3/mod.rs

stm32f103xx/adc2/sqr3/
mod.rs
