stm32l4x2_pac/gpioa/
ospeedr.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::OSPEEDR {
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 = "Possible values of the field `OSPEEDR15`"]
46#[derive(Clone, Copy, Debug, PartialEq)]
47pub enum OSPEEDR15R {
48    #[doc = "Low speed"]
49    LOWSPEED,
50    #[doc = "Medium speed"]
51    MEDIUMSPEED,
52    #[doc = "High speed"]
53    HIGHSPEED,
54    #[doc = "Very high speed"]
55    VERYHIGHSPEED,
56}
57impl OSPEEDR15R {
58    #[doc = r" Value of the field as raw bits"]
59    #[inline]
60    pub fn bits(&self) -> u8 {
61        match *self {
62            OSPEEDR15R::LOWSPEED => 0,
63            OSPEEDR15R::MEDIUMSPEED => 1,
64            OSPEEDR15R::HIGHSPEED => 2,
65            OSPEEDR15R::VERYHIGHSPEED => 3,
66        }
67    }
68    #[allow(missing_docs)]
69    #[doc(hidden)]
70    #[inline]
71    pub fn _from(value: u8) -> OSPEEDR15R {
72        match value {
73            0 => OSPEEDR15R::LOWSPEED,
74            1 => OSPEEDR15R::MEDIUMSPEED,
75            2 => OSPEEDR15R::HIGHSPEED,
76            3 => OSPEEDR15R::VERYHIGHSPEED,
77            _ => unreachable!(),
78        }
79    }
80    #[doc = "Checks if the value of the field is `LOWSPEED`"]
81    #[inline]
82    pub fn is_low_speed(&self) -> bool {
83        *self == OSPEEDR15R::LOWSPEED
84    }
85    #[doc = "Checks if the value of the field is `MEDIUMSPEED`"]
86    #[inline]
87    pub fn is_medium_speed(&self) -> bool {
88        *self == OSPEEDR15R::MEDIUMSPEED
89    }
90    #[doc = "Checks if the value of the field is `HIGHSPEED`"]
91    #[inline]
92    pub fn is_high_speed(&self) -> bool {
93        *self == OSPEEDR15R::HIGHSPEED
94    }
95    #[doc = "Checks if the value of the field is `VERYHIGHSPEED`"]
96    #[inline]
97    pub fn is_very_high_speed(&self) -> bool {
98        *self == OSPEEDR15R::VERYHIGHSPEED
99    }
100}
101#[doc = "Possible values of the field `OSPEEDR14`"]
102pub type OSPEEDR14R = OSPEEDR15R;
103#[doc = "Possible values of the field `OSPEEDR13`"]
104pub type OSPEEDR13R = OSPEEDR15R;
105#[doc = "Possible values of the field `OSPEEDR12`"]
106pub type OSPEEDR12R = OSPEEDR15R;
107#[doc = "Possible values of the field `OSPEEDR11`"]
108pub type OSPEEDR11R = OSPEEDR15R;
109#[doc = "Possible values of the field `OSPEEDR10`"]
110pub type OSPEEDR10R = OSPEEDR15R;
111#[doc = "Possible values of the field `OSPEEDR9`"]
112pub type OSPEEDR9R = OSPEEDR15R;
113#[doc = "Possible values of the field `OSPEEDR8`"]
114pub type OSPEEDR8R = OSPEEDR15R;
115#[doc = "Possible values of the field `OSPEEDR7`"]
116pub type OSPEEDR7R = OSPEEDR15R;
117#[doc = "Possible values of the field `OSPEEDR6`"]
118pub type OSPEEDR6R = OSPEEDR15R;
119#[doc = "Possible values of the field `OSPEEDR5`"]
120pub type OSPEEDR5R = OSPEEDR15R;
121#[doc = "Possible values of the field `OSPEEDR4`"]
122pub type OSPEEDR4R = OSPEEDR15R;
123#[doc = "Possible values of the field `OSPEEDR3`"]
124pub type OSPEEDR3R = OSPEEDR15R;
125#[doc = "Possible values of the field `OSPEEDR2`"]
126pub type OSPEEDR2R = OSPEEDR15R;
127#[doc = "Possible values of the field `OSPEEDR1`"]
128pub type OSPEEDR1R = OSPEEDR15R;
129#[doc = "Possible values of the field `OSPEEDR0`"]
130pub type OSPEEDR0R = OSPEEDR15R;
131#[doc = "Values that can be written to the field `OSPEEDR15`"]
132pub enum OSPEEDR15W {
133    #[doc = "Low speed"]
134    LOWSPEED,
135    #[doc = "Medium speed"]
136    MEDIUMSPEED,
137    #[doc = "High speed"]
138    HIGHSPEED,
139    #[doc = "Very high speed"]
140    VERYHIGHSPEED,
141}
142impl OSPEEDR15W {
143    #[allow(missing_docs)]
144    #[doc(hidden)]
145    #[inline]
146    pub fn _bits(&self) -> u8 {
147        match *self {
148            OSPEEDR15W::LOWSPEED => 0,
149            OSPEEDR15W::MEDIUMSPEED => 1,
150            OSPEEDR15W::HIGHSPEED => 2,
151            OSPEEDR15W::VERYHIGHSPEED => 3,
152        }
153    }
154}
155#[doc = r" Proxy"]
156pub struct _OSPEEDR15W<'a> {
157    w: &'a mut W,
158}
159impl<'a> _OSPEEDR15W<'a> {
160    #[doc = r" Writes `variant` to the field"]
161    #[inline]
162    pub fn variant(self, variant: OSPEEDR15W) -> &'a mut W {
163        {
164            self.bits(variant._bits())
165        }
166    }
167    #[doc = "Low speed"]
168    #[inline]
169    pub fn low_speed(self) -> &'a mut W {
170        self.variant(OSPEEDR15W::LOWSPEED)
171    }
172    #[doc = "Medium speed"]
173    #[inline]
174    pub fn medium_speed(self) -> &'a mut W {
175        self.variant(OSPEEDR15W::MEDIUMSPEED)
176    }
177    #[doc = "High speed"]
178    #[inline]
179    pub fn high_speed(self) -> &'a mut W {
180        self.variant(OSPEEDR15W::HIGHSPEED)
181    }
182    #[doc = "Very high speed"]
183    #[inline]
184    pub fn very_high_speed(self) -> &'a mut W {
185        self.variant(OSPEEDR15W::VERYHIGHSPEED)
186    }
187    #[doc = r" Writes raw bits to the field"]
188    #[inline]
189    pub fn bits(self, value: u8) -> &'a mut W {
190        const MASK: u8 = 3;
191        const OFFSET: u8 = 30;
192        self.w.bits &= !((MASK as u32) << OFFSET);
193        self.w.bits |= ((value & MASK) as u32) << OFFSET;
194        self.w
195    }
196}
197#[doc = "Values that can be written to the field `OSPEEDR14`"]
198pub type OSPEEDR14W = OSPEEDR15W;
199#[doc = r" Proxy"]
200pub struct _OSPEEDR14W<'a> {
201    w: &'a mut W,
202}
203impl<'a> _OSPEEDR14W<'a> {
204    #[doc = r" Writes `variant` to the field"]
205    #[inline]
206    pub fn variant(self, variant: OSPEEDR14W) -> &'a mut W {
207        {
208            self.bits(variant._bits())
209        }
210    }
211    #[doc = "Low speed"]
212    #[inline]
213    pub fn low_speed(self) -> &'a mut W {
214        self.variant(OSPEEDR15W::LOWSPEED)
215    }
216    #[doc = "Medium speed"]
217    #[inline]
218    pub fn medium_speed(self) -> &'a mut W {
219        self.variant(OSPEEDR15W::MEDIUMSPEED)
220    }
221    #[doc = "High speed"]
222    #[inline]
223    pub fn high_speed(self) -> &'a mut W {
224        self.variant(OSPEEDR15W::HIGHSPEED)
225    }
226    #[doc = "Very high speed"]
227    #[inline]
228    pub fn very_high_speed(self) -> &'a mut W {
229        self.variant(OSPEEDR15W::VERYHIGHSPEED)
230    }
231    #[doc = r" Writes raw bits to the field"]
232    #[inline]
233    pub fn bits(self, value: u8) -> &'a mut W {
234        const MASK: u8 = 3;
235        const OFFSET: u8 = 28;
236        self.w.bits &= !((MASK as u32) << OFFSET);
237        self.w.bits |= ((value & MASK) as u32) << OFFSET;
238        self.w
239    }
240}
241#[doc = "Values that can be written to the field `OSPEEDR13`"]
242pub type OSPEEDR13W = OSPEEDR15W;
243#[doc = r" Proxy"]
244pub struct _OSPEEDR13W<'a> {
245    w: &'a mut W,
246}
247impl<'a> _OSPEEDR13W<'a> {
248    #[doc = r" Writes `variant` to the field"]
249    #[inline]
250    pub fn variant(self, variant: OSPEEDR13W) -> &'a mut W {
251        {
252            self.bits(variant._bits())
253        }
254    }
255    #[doc = "Low speed"]
256    #[inline]
257    pub fn low_speed(self) -> &'a mut W {
258        self.variant(OSPEEDR15W::LOWSPEED)
259    }
260    #[doc = "Medium speed"]
261    #[inline]
262    pub fn medium_speed(self) -> &'a mut W {
263        self.variant(OSPEEDR15W::MEDIUMSPEED)
264    }
265    #[doc = "High speed"]
266    #[inline]
267    pub fn high_speed(self) -> &'a mut W {
268        self.variant(OSPEEDR15W::HIGHSPEED)
269    }
270    #[doc = "Very high speed"]
271    #[inline]
272    pub fn very_high_speed(self) -> &'a mut W {
273        self.variant(OSPEEDR15W::VERYHIGHSPEED)
274    }
275    #[doc = r" Writes raw bits to the field"]
276    #[inline]
277    pub fn bits(self, value: u8) -> &'a mut W {
278        const MASK: u8 = 3;
279        const OFFSET: u8 = 26;
280        self.w.bits &= !((MASK as u32) << OFFSET);
281        self.w.bits |= ((value & MASK) as u32) << OFFSET;
282        self.w
283    }
284}
285#[doc = "Values that can be written to the field `OSPEEDR12`"]
286pub type OSPEEDR12W = OSPEEDR15W;
287#[doc = r" Proxy"]
288pub struct _OSPEEDR12W<'a> {
289    w: &'a mut W,
290}
291impl<'a> _OSPEEDR12W<'a> {
292    #[doc = r" Writes `variant` to the field"]
293    #[inline]
294    pub fn variant(self, variant: OSPEEDR12W) -> &'a mut W {
295        {
296            self.bits(variant._bits())
297        }
298    }
299    #[doc = "Low speed"]
300    #[inline]
301    pub fn low_speed(self) -> &'a mut W {
302        self.variant(OSPEEDR15W::LOWSPEED)
303    }
304    #[doc = "Medium speed"]
305    #[inline]
306    pub fn medium_speed(self) -> &'a mut W {
307        self.variant(OSPEEDR15W::MEDIUMSPEED)
308    }
309    #[doc = "High speed"]
310    #[inline]
311    pub fn high_speed(self) -> &'a mut W {
312        self.variant(OSPEEDR15W::HIGHSPEED)
313    }
314    #[doc = "Very high speed"]
315    #[inline]
316    pub fn very_high_speed(self) -> &'a mut W {
317        self.variant(OSPEEDR15W::VERYHIGHSPEED)
318    }
319    #[doc = r" Writes raw bits to the field"]
320    #[inline]
321    pub fn bits(self, value: u8) -> &'a mut W {
322        const MASK: u8 = 3;
323        const OFFSET: u8 = 24;
324        self.w.bits &= !((MASK as u32) << OFFSET);
325        self.w.bits |= ((value & MASK) as u32) << OFFSET;
326        self.w
327    }
328}
329#[doc = "Values that can be written to the field `OSPEEDR11`"]
330pub type OSPEEDR11W = OSPEEDR15W;
331#[doc = r" Proxy"]
332pub struct _OSPEEDR11W<'a> {
333    w: &'a mut W,
334}
335impl<'a> _OSPEEDR11W<'a> {
336    #[doc = r" Writes `variant` to the field"]
337    #[inline]
338    pub fn variant(self, variant: OSPEEDR11W) -> &'a mut W {
339        {
340            self.bits(variant._bits())
341        }
342    }
343    #[doc = "Low speed"]
344    #[inline]
345    pub fn low_speed(self) -> &'a mut W {
346        self.variant(OSPEEDR15W::LOWSPEED)
347    }
348    #[doc = "Medium speed"]
349    #[inline]
350    pub fn medium_speed(self) -> &'a mut W {
351        self.variant(OSPEEDR15W::MEDIUMSPEED)
352    }
353    #[doc = "High speed"]
354    #[inline]
355    pub fn high_speed(self) -> &'a mut W {
356        self.variant(OSPEEDR15W::HIGHSPEED)
357    }
358    #[doc = "Very high speed"]
359    #[inline]
360    pub fn very_high_speed(self) -> &'a mut W {
361        self.variant(OSPEEDR15W::VERYHIGHSPEED)
362    }
363    #[doc = r" Writes raw bits to the field"]
364    #[inline]
365    pub fn bits(self, value: u8) -> &'a mut W {
366        const MASK: u8 = 3;
367        const OFFSET: u8 = 22;
368        self.w.bits &= !((MASK as u32) << OFFSET);
369        self.w.bits |= ((value & MASK) as u32) << OFFSET;
370        self.w
371    }
372}
373#[doc = "Values that can be written to the field `OSPEEDR10`"]
374pub type OSPEEDR10W = OSPEEDR15W;
375#[doc = r" Proxy"]
376pub struct _OSPEEDR10W<'a> {
377    w: &'a mut W,
378}
379impl<'a> _OSPEEDR10W<'a> {
380    #[doc = r" Writes `variant` to the field"]
381    #[inline]
382    pub fn variant(self, variant: OSPEEDR10W) -> &'a mut W {
383        {
384            self.bits(variant._bits())
385        }
386    }
387    #[doc = "Low speed"]
388    #[inline]
389    pub fn low_speed(self) -> &'a mut W {
390        self.variant(OSPEEDR15W::LOWSPEED)
391    }
392    #[doc = "Medium speed"]
393    #[inline]
394    pub fn medium_speed(self) -> &'a mut W {
395        self.variant(OSPEEDR15W::MEDIUMSPEED)
396    }
397    #[doc = "High speed"]
398    #[inline]
399    pub fn high_speed(self) -> &'a mut W {
400        self.variant(OSPEEDR15W::HIGHSPEED)
401    }
402    #[doc = "Very high speed"]
403    #[inline]
404    pub fn very_high_speed(self) -> &'a mut W {
405        self.variant(OSPEEDR15W::VERYHIGHSPEED)
406    }
407    #[doc = r" Writes raw bits to the field"]
408    #[inline]
409    pub fn bits(self, value: u8) -> &'a mut W {
410        const MASK: u8 = 3;
411        const OFFSET: u8 = 20;
412        self.w.bits &= !((MASK as u32) << OFFSET);
413        self.w.bits |= ((value & MASK) as u32) << OFFSET;
414        self.w
415    }
416}
417#[doc = "Values that can be written to the field `OSPEEDR9`"]
418pub type OSPEEDR9W = OSPEEDR15W;
419#[doc = r" Proxy"]
420pub struct _OSPEEDR9W<'a> {
421    w: &'a mut W,
422}
423impl<'a> _OSPEEDR9W<'a> {
424    #[doc = r" Writes `variant` to the field"]
425    #[inline]
426    pub fn variant(self, variant: OSPEEDR9W) -> &'a mut W {
427        {
428            self.bits(variant._bits())
429        }
430    }
431    #[doc = "Low speed"]
432    #[inline]
433    pub fn low_speed(self) -> &'a mut W {
434        self.variant(OSPEEDR15W::LOWSPEED)
435    }
436    #[doc = "Medium speed"]
437    #[inline]
438    pub fn medium_speed(self) -> &'a mut W {
439        self.variant(OSPEEDR15W::MEDIUMSPEED)
440    }
441    #[doc = "High speed"]
442    #[inline]
443    pub fn high_speed(self) -> &'a mut W {
444        self.variant(OSPEEDR15W::HIGHSPEED)
445    }
446    #[doc = "Very high speed"]
447    #[inline]
448    pub fn very_high_speed(self) -> &'a mut W {
449        self.variant(OSPEEDR15W::VERYHIGHSPEED)
450    }
451    #[doc = r" Writes raw bits to the field"]
452    #[inline]
453    pub fn bits(self, value: u8) -> &'a mut W {
454        const MASK: u8 = 3;
455        const OFFSET: u8 = 18;
456        self.w.bits &= !((MASK as u32) << OFFSET);
457        self.w.bits |= ((value & MASK) as u32) << OFFSET;
458        self.w
459    }
460}
461#[doc = "Values that can be written to the field `OSPEEDR8`"]
462pub type OSPEEDR8W = OSPEEDR15W;
463#[doc = r" Proxy"]
464pub struct _OSPEEDR8W<'a> {
465    w: &'a mut W,
466}
467impl<'a> _OSPEEDR8W<'a> {
468    #[doc = r" Writes `variant` to the field"]
469    #[inline]
470    pub fn variant(self, variant: OSPEEDR8W) -> &'a mut W {
471        {
472            self.bits(variant._bits())
473        }
474    }
475    #[doc = "Low speed"]
476    #[inline]
477    pub fn low_speed(self) -> &'a mut W {
478        self.variant(OSPEEDR15W::LOWSPEED)
479    }
480    #[doc = "Medium speed"]
481    #[inline]
482    pub fn medium_speed(self) -> &'a mut W {
483        self.variant(OSPEEDR15W::MEDIUMSPEED)
484    }
485    #[doc = "High speed"]
486    #[inline]
487    pub fn high_speed(self) -> &'a mut W {
488        self.variant(OSPEEDR15W::HIGHSPEED)
489    }
490    #[doc = "Very high speed"]
491    #[inline]
492    pub fn very_high_speed(self) -> &'a mut W {
493        self.variant(OSPEEDR15W::VERYHIGHSPEED)
494    }
495    #[doc = r" Writes raw bits to the field"]
496    #[inline]
497    pub fn bits(self, value: u8) -> &'a mut W {
498        const MASK: u8 = 3;
499        const OFFSET: u8 = 16;
500        self.w.bits &= !((MASK as u32) << OFFSET);
501        self.w.bits |= ((value & MASK) as u32) << OFFSET;
502        self.w
503    }
504}
505#[doc = "Values that can be written to the field `OSPEEDR7`"]
506pub type OSPEEDR7W = OSPEEDR15W;
507#[doc = r" Proxy"]
508pub struct _OSPEEDR7W<'a> {
509    w: &'a mut W,
510}
511impl<'a> _OSPEEDR7W<'a> {
512    #[doc = r" Writes `variant` to the field"]
513    #[inline]
514    pub fn variant(self, variant: OSPEEDR7W) -> &'a mut W {
515        {
516            self.bits(variant._bits())
517        }
518    }
519    #[doc = "Low speed"]
520    #[inline]
521    pub fn low_speed(self) -> &'a mut W {
522        self.variant(OSPEEDR15W::LOWSPEED)
523    }
524    #[doc = "Medium speed"]
525    #[inline]
526    pub fn medium_speed(self) -> &'a mut W {
527        self.variant(OSPEEDR15W::MEDIUMSPEED)
528    }
529    #[doc = "High speed"]
530    #[inline]
531    pub fn high_speed(self) -> &'a mut W {
532        self.variant(OSPEEDR15W::HIGHSPEED)
533    }
534    #[doc = "Very high speed"]
535    #[inline]
536    pub fn very_high_speed(self) -> &'a mut W {
537        self.variant(OSPEEDR15W::VERYHIGHSPEED)
538    }
539    #[doc = r" Writes raw bits to the field"]
540    #[inline]
541    pub fn bits(self, value: u8) -> &'a mut W {
542        const MASK: u8 = 3;
543        const OFFSET: u8 = 14;
544        self.w.bits &= !((MASK as u32) << OFFSET);
545        self.w.bits |= ((value & MASK) as u32) << OFFSET;
546        self.w
547    }
548}
549#[doc = "Values that can be written to the field `OSPEEDR6`"]
550pub type OSPEEDR6W = OSPEEDR15W;
551#[doc = r" Proxy"]
552pub struct _OSPEEDR6W<'a> {
553    w: &'a mut W,
554}
555impl<'a> _OSPEEDR6W<'a> {
556    #[doc = r" Writes `variant` to the field"]
557    #[inline]
558    pub fn variant(self, variant: OSPEEDR6W) -> &'a mut W {
559        {
560            self.bits(variant._bits())
561        }
562    }
563    #[doc = "Low speed"]
564    #[inline]
565    pub fn low_speed(self) -> &'a mut W {
566        self.variant(OSPEEDR15W::LOWSPEED)
567    }
568    #[doc = "Medium speed"]
569    #[inline]
570    pub fn medium_speed(self) -> &'a mut W {
571        self.variant(OSPEEDR15W::MEDIUMSPEED)
572    }
573    #[doc = "High speed"]
574    #[inline]
575    pub fn high_speed(self) -> &'a mut W {
576        self.variant(OSPEEDR15W::HIGHSPEED)
577    }
578    #[doc = "Very high speed"]
579    #[inline]
580    pub fn very_high_speed(self) -> &'a mut W {
581        self.variant(OSPEEDR15W::VERYHIGHSPEED)
582    }
583    #[doc = r" Writes raw bits to the field"]
584    #[inline]
585    pub fn bits(self, value: u8) -> &'a mut W {
586        const MASK: u8 = 3;
587        const OFFSET: u8 = 12;
588        self.w.bits &= !((MASK as u32) << OFFSET);
589        self.w.bits |= ((value & MASK) as u32) << OFFSET;
590        self.w
591    }
592}
593#[doc = "Values that can be written to the field `OSPEEDR5`"]
594pub type OSPEEDR5W = OSPEEDR15W;
595#[doc = r" Proxy"]
596pub struct _OSPEEDR5W<'a> {
597    w: &'a mut W,
598}
599impl<'a> _OSPEEDR5W<'a> {
600    #[doc = r" Writes `variant` to the field"]
601    #[inline]
602    pub fn variant(self, variant: OSPEEDR5W) -> &'a mut W {
603        {
604            self.bits(variant._bits())
605        }
606    }
607    #[doc = "Low speed"]
608    #[inline]
609    pub fn low_speed(self) -> &'a mut W {
610        self.variant(OSPEEDR15W::LOWSPEED)
611    }
612    #[doc = "Medium speed"]
613    #[inline]
614    pub fn medium_speed(self) -> &'a mut W {
615        self.variant(OSPEEDR15W::MEDIUMSPEED)
616    }
617    #[doc = "High speed"]
618    #[inline]
619    pub fn high_speed(self) -> &'a mut W {
620        self.variant(OSPEEDR15W::HIGHSPEED)
621    }
622    #[doc = "Very high speed"]
623    #[inline]
624    pub fn very_high_speed(self) -> &'a mut W {
625        self.variant(OSPEEDR15W::VERYHIGHSPEED)
626    }
627    #[doc = r" Writes raw bits to the field"]
628    #[inline]
629    pub fn bits(self, value: u8) -> &'a mut W {
630        const MASK: u8 = 3;
631        const OFFSET: u8 = 10;
632        self.w.bits &= !((MASK as u32) << OFFSET);
633        self.w.bits |= ((value & MASK) as u32) << OFFSET;
634        self.w
635    }
636}
637#[doc = "Values that can be written to the field `OSPEEDR4`"]
638pub type OSPEEDR4W = OSPEEDR15W;
639#[doc = r" Proxy"]
640pub struct _OSPEEDR4W<'a> {
641    w: &'a mut W,
642}
643impl<'a> _OSPEEDR4W<'a> {
644    #[doc = r" Writes `variant` to the field"]
645    #[inline]
646    pub fn variant(self, variant: OSPEEDR4W) -> &'a mut W {
647        {
648            self.bits(variant._bits())
649        }
650    }
651    #[doc = "Low speed"]
652    #[inline]
653    pub fn low_speed(self) -> &'a mut W {
654        self.variant(OSPEEDR15W::LOWSPEED)
655    }
656    #[doc = "Medium speed"]
657    #[inline]
658    pub fn medium_speed(self) -> &'a mut W {
659        self.variant(OSPEEDR15W::MEDIUMSPEED)
660    }
661    #[doc = "High speed"]
662    #[inline]
663    pub fn high_speed(self) -> &'a mut W {
664        self.variant(OSPEEDR15W::HIGHSPEED)
665    }
666    #[doc = "Very high speed"]
667    #[inline]
668    pub fn very_high_speed(self) -> &'a mut W {
669        self.variant(OSPEEDR15W::VERYHIGHSPEED)
670    }
671    #[doc = r" Writes raw bits to the field"]
672    #[inline]
673    pub fn bits(self, value: u8) -> &'a mut W {
674        const MASK: u8 = 3;
675        const OFFSET: u8 = 8;
676        self.w.bits &= !((MASK as u32) << OFFSET);
677        self.w.bits |= ((value & MASK) as u32) << OFFSET;
678        self.w
679    }
680}
681#[doc = "Values that can be written to the field `OSPEEDR3`"]
682pub type OSPEEDR3W = OSPEEDR15W;
683#[doc = r" Proxy"]
684pub struct _OSPEEDR3W<'a> {
685    w: &'a mut W,
686}
687impl<'a> _OSPEEDR3W<'a> {
688    #[doc = r" Writes `variant` to the field"]
689    #[inline]
690    pub fn variant(self, variant: OSPEEDR3W) -> &'a mut W {
691        {
692            self.bits(variant._bits())
693        }
694    }
695    #[doc = "Low speed"]
696    #[inline]
697    pub fn low_speed(self) -> &'a mut W {
698        self.variant(OSPEEDR15W::LOWSPEED)
699    }
700    #[doc = "Medium speed"]
701    #[inline]
702    pub fn medium_speed(self) -> &'a mut W {
703        self.variant(OSPEEDR15W::MEDIUMSPEED)
704    }
705    #[doc = "High speed"]
706    #[inline]
707    pub fn high_speed(self) -> &'a mut W {
708        self.variant(OSPEEDR15W::HIGHSPEED)
709    }
710    #[doc = "Very high speed"]
711    #[inline]
712    pub fn very_high_speed(self) -> &'a mut W {
713        self.variant(OSPEEDR15W::VERYHIGHSPEED)
714    }
715    #[doc = r" Writes raw bits to the field"]
716    #[inline]
717    pub fn bits(self, value: u8) -> &'a mut W {
718        const MASK: u8 = 3;
719        const OFFSET: u8 = 6;
720        self.w.bits &= !((MASK as u32) << OFFSET);
721        self.w.bits |= ((value & MASK) as u32) << OFFSET;
722        self.w
723    }
724}
725#[doc = "Values that can be written to the field `OSPEEDR2`"]
726pub type OSPEEDR2W = OSPEEDR15W;
727#[doc = r" Proxy"]
728pub struct _OSPEEDR2W<'a> {
729    w: &'a mut W,
730}
731impl<'a> _OSPEEDR2W<'a> {
732    #[doc = r" Writes `variant` to the field"]
733    #[inline]
734    pub fn variant(self, variant: OSPEEDR2W) -> &'a mut W {
735        {
736            self.bits(variant._bits())
737        }
738    }
739    #[doc = "Low speed"]
740    #[inline]
741    pub fn low_speed(self) -> &'a mut W {
742        self.variant(OSPEEDR15W::LOWSPEED)
743    }
744    #[doc = "Medium speed"]
745    #[inline]
746    pub fn medium_speed(self) -> &'a mut W {
747        self.variant(OSPEEDR15W::MEDIUMSPEED)
748    }
749    #[doc = "High speed"]
750    #[inline]
751    pub fn high_speed(self) -> &'a mut W {
752        self.variant(OSPEEDR15W::HIGHSPEED)
753    }
754    #[doc = "Very high speed"]
755    #[inline]
756    pub fn very_high_speed(self) -> &'a mut W {
757        self.variant(OSPEEDR15W::VERYHIGHSPEED)
758    }
759    #[doc = r" Writes raw bits to the field"]
760    #[inline]
761    pub fn bits(self, value: u8) -> &'a mut W {
762        const MASK: u8 = 3;
763        const OFFSET: u8 = 4;
764        self.w.bits &= !((MASK as u32) << OFFSET);
765        self.w.bits |= ((value & MASK) as u32) << OFFSET;
766        self.w
767    }
768}
769#[doc = "Values that can be written to the field `OSPEEDR1`"]
770pub type OSPEEDR1W = OSPEEDR15W;
771#[doc = r" Proxy"]
772pub struct _OSPEEDR1W<'a> {
773    w: &'a mut W,
774}
775impl<'a> _OSPEEDR1W<'a> {
776    #[doc = r" Writes `variant` to the field"]
777    #[inline]
778    pub fn variant(self, variant: OSPEEDR1W) -> &'a mut W {
779        {
780            self.bits(variant._bits())
781        }
782    }
783    #[doc = "Low speed"]
784    #[inline]
785    pub fn low_speed(self) -> &'a mut W {
786        self.variant(OSPEEDR15W::LOWSPEED)
787    }
788    #[doc = "Medium speed"]
789    #[inline]
790    pub fn medium_speed(self) -> &'a mut W {
791        self.variant(OSPEEDR15W::MEDIUMSPEED)
792    }
793    #[doc = "High speed"]
794    #[inline]
795    pub fn high_speed(self) -> &'a mut W {
796        self.variant(OSPEEDR15W::HIGHSPEED)
797    }
798    #[doc = "Very high speed"]
799    #[inline]
800    pub fn very_high_speed(self) -> &'a mut W {
801        self.variant(OSPEEDR15W::VERYHIGHSPEED)
802    }
803    #[doc = r" Writes raw bits to the field"]
804    #[inline]
805    pub fn bits(self, value: u8) -> &'a mut W {
806        const MASK: u8 = 3;
807        const OFFSET: u8 = 2;
808        self.w.bits &= !((MASK as u32) << OFFSET);
809        self.w.bits |= ((value & MASK) as u32) << OFFSET;
810        self.w
811    }
812}
813#[doc = "Values that can be written to the field `OSPEEDR0`"]
814pub type OSPEEDR0W = OSPEEDR15W;
815#[doc = r" Proxy"]
816pub struct _OSPEEDR0W<'a> {
817    w: &'a mut W,
818}
819impl<'a> _OSPEEDR0W<'a> {
820    #[doc = r" Writes `variant` to the field"]
821    #[inline]
822    pub fn variant(self, variant: OSPEEDR0W) -> &'a mut W {
823        {
824            self.bits(variant._bits())
825        }
826    }
827    #[doc = "Low speed"]
828    #[inline]
829    pub fn low_speed(self) -> &'a mut W {
830        self.variant(OSPEEDR15W::LOWSPEED)
831    }
832    #[doc = "Medium speed"]
833    #[inline]
834    pub fn medium_speed(self) -> &'a mut W {
835        self.variant(OSPEEDR15W::MEDIUMSPEED)
836    }
837    #[doc = "High speed"]
838    #[inline]
839    pub fn high_speed(self) -> &'a mut W {
840        self.variant(OSPEEDR15W::HIGHSPEED)
841    }
842    #[doc = "Very high speed"]
843    #[inline]
844    pub fn very_high_speed(self) -> &'a mut W {
845        self.variant(OSPEEDR15W::VERYHIGHSPEED)
846    }
847    #[doc = r" Writes raw bits to the field"]
848    #[inline]
849    pub fn bits(self, value: u8) -> &'a mut W {
850        const MASK: u8 = 3;
851        const OFFSET: u8 = 0;
852        self.w.bits &= !((MASK as u32) << OFFSET);
853        self.w.bits |= ((value & MASK) as u32) << OFFSET;
854        self.w
855    }
856}
857impl R {
858    #[doc = r" Value of the register as raw bits"]
859    #[inline]
860    pub fn bits(&self) -> u32 {
861        self.bits
862    }
863    #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"]
864    #[inline]
865    pub fn ospeedr15(&self) -> OSPEEDR15R {
866        OSPEEDR15R::_from({
867            const MASK: u8 = 3;
868            const OFFSET: u8 = 30;
869            ((self.bits >> OFFSET) & MASK as u32) as u8
870        })
871    }
872    #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
873    #[inline]
874    pub fn ospeedr14(&self) -> OSPEEDR14R {
875        OSPEEDR14R::_from({
876            const MASK: u8 = 3;
877            const OFFSET: u8 = 28;
878            ((self.bits >> OFFSET) & MASK as u32) as u8
879        })
880    }
881    #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
882    #[inline]
883    pub fn ospeedr13(&self) -> OSPEEDR13R {
884        OSPEEDR13R::_from({
885            const MASK: u8 = 3;
886            const OFFSET: u8 = 26;
887            ((self.bits >> OFFSET) & MASK as u32) as u8
888        })
889    }
890    #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
891    #[inline]
892    pub fn ospeedr12(&self) -> OSPEEDR12R {
893        OSPEEDR12R::_from({
894            const MASK: u8 = 3;
895            const OFFSET: u8 = 24;
896            ((self.bits >> OFFSET) & MASK as u32) as u8
897        })
898    }
899    #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
900    #[inline]
901    pub fn ospeedr11(&self) -> OSPEEDR11R {
902        OSPEEDR11R::_from({
903            const MASK: u8 = 3;
904            const OFFSET: u8 = 22;
905            ((self.bits >> OFFSET) & MASK as u32) as u8
906        })
907    }
908    #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
909    #[inline]
910    pub fn ospeedr10(&self) -> OSPEEDR10R {
911        OSPEEDR10R::_from({
912            const MASK: u8 = 3;
913            const OFFSET: u8 = 20;
914            ((self.bits >> OFFSET) & MASK as u32) as u8
915        })
916    }
917    #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
918    #[inline]
919    pub fn ospeedr9(&self) -> OSPEEDR9R {
920        OSPEEDR9R::_from({
921            const MASK: u8 = 3;
922            const OFFSET: u8 = 18;
923            ((self.bits >> OFFSET) & MASK as u32) as u8
924        })
925    }
926    #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
927    #[inline]
928    pub fn ospeedr8(&self) -> OSPEEDR8R {
929        OSPEEDR8R::_from({
930            const MASK: u8 = 3;
931            const OFFSET: u8 = 16;
932            ((self.bits >> OFFSET) & MASK as u32) as u8
933        })
934    }
935    #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
936    #[inline]
937    pub fn ospeedr7(&self) -> OSPEEDR7R {
938        OSPEEDR7R::_from({
939            const MASK: u8 = 3;
940            const OFFSET: u8 = 14;
941            ((self.bits >> OFFSET) & MASK as u32) as u8
942        })
943    }
944    #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
945    #[inline]
946    pub fn ospeedr6(&self) -> OSPEEDR6R {
947        OSPEEDR6R::_from({
948            const MASK: u8 = 3;
949            const OFFSET: u8 = 12;
950            ((self.bits >> OFFSET) & MASK as u32) as u8
951        })
952    }
953    #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
954    #[inline]
955    pub fn ospeedr5(&self) -> OSPEEDR5R {
956        OSPEEDR5R::_from({
957            const MASK: u8 = 3;
958            const OFFSET: u8 = 10;
959            ((self.bits >> OFFSET) & MASK as u32) as u8
960        })
961    }
962    #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
963    #[inline]
964    pub fn ospeedr4(&self) -> OSPEEDR4R {
965        OSPEEDR4R::_from({
966            const MASK: u8 = 3;
967            const OFFSET: u8 = 8;
968            ((self.bits >> OFFSET) & MASK as u32) as u8
969        })
970    }
971    #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
972    #[inline]
973    pub fn ospeedr3(&self) -> OSPEEDR3R {
974        OSPEEDR3R::_from({
975            const MASK: u8 = 3;
976            const OFFSET: u8 = 6;
977            ((self.bits >> OFFSET) & MASK as u32) as u8
978        })
979    }
980    #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
981    #[inline]
982    pub fn ospeedr2(&self) -> OSPEEDR2R {
983        OSPEEDR2R::_from({
984            const MASK: u8 = 3;
985            const OFFSET: u8 = 4;
986            ((self.bits >> OFFSET) & MASK as u32) as u8
987        })
988    }
989    #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
990    #[inline]
991    pub fn ospeedr1(&self) -> OSPEEDR1R {
992        OSPEEDR1R::_from({
993            const MASK: u8 = 3;
994            const OFFSET: u8 = 2;
995            ((self.bits >> OFFSET) & MASK as u32) as u8
996        })
997    }
998    #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
999    #[inline]
1000    pub fn ospeedr0(&self) -> OSPEEDR0R {
1001        OSPEEDR0R::_from({
1002            const MASK: u8 = 3;
1003            const OFFSET: u8 = 0;
1004            ((self.bits >> OFFSET) & MASK as u32) as u8
1005        })
1006    }
1007}
1008impl W {
1009    #[doc = r" Reset value of the register"]
1010    #[inline]
1011    pub fn reset_value() -> W {
1012        W { bits: 0 }
1013    }
1014    #[doc = r" Writes raw bits to the register"]
1015    #[inline]
1016    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1017        self.bits = bits;
1018        self
1019    }
1020    #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"]
1021    #[inline]
1022    pub fn ospeedr15(&mut self) -> _OSPEEDR15W {
1023        _OSPEEDR15W { w: self }
1024    }
1025    #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"]
1026    #[inline]
1027    pub fn ospeedr14(&mut self) -> _OSPEEDR14W {
1028        _OSPEEDR14W { w: self }
1029    }
1030    #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"]
1031    #[inline]
1032    pub fn ospeedr13(&mut self) -> _OSPEEDR13W {
1033        _OSPEEDR13W { w: self }
1034    }
1035    #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"]
1036    #[inline]
1037    pub fn ospeedr12(&mut self) -> _OSPEEDR12W {
1038        _OSPEEDR12W { w: self }
1039    }
1040    #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"]
1041    #[inline]
1042    pub fn ospeedr11(&mut self) -> _OSPEEDR11W {
1043        _OSPEEDR11W { w: self }
1044    }
1045    #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"]
1046    #[inline]
1047    pub fn ospeedr10(&mut self) -> _OSPEEDR10W {
1048        _OSPEEDR10W { w: self }
1049    }
1050    #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"]
1051    #[inline]
1052    pub fn ospeedr9(&mut self) -> _OSPEEDR9W {
1053        _OSPEEDR9W { w: self }
1054    }
1055    #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"]
1056    #[inline]
1057    pub fn ospeedr8(&mut self) -> _OSPEEDR8W {
1058        _OSPEEDR8W { w: self }
1059    }
1060    #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"]
1061    #[inline]
1062    pub fn ospeedr7(&mut self) -> _OSPEEDR7W {
1063        _OSPEEDR7W { w: self }
1064    }
1065    #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"]
1066    #[inline]
1067    pub fn ospeedr6(&mut self) -> _OSPEEDR6W {
1068        _OSPEEDR6W { w: self }
1069    }
1070    #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"]
1071    #[inline]
1072    pub fn ospeedr5(&mut self) -> _OSPEEDR5W {
1073        _OSPEEDR5W { w: self }
1074    }
1075    #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"]
1076    #[inline]
1077    pub fn ospeedr4(&mut self) -> _OSPEEDR4W {
1078        _OSPEEDR4W { w: self }
1079    }
1080    #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"]
1081    #[inline]
1082    pub fn ospeedr3(&mut self) -> _OSPEEDR3W {
1083        _OSPEEDR3W { w: self }
1084    }
1085    #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"]
1086    #[inline]
1087    pub fn ospeedr2(&mut self) -> _OSPEEDR2W {
1088        _OSPEEDR2W { w: self }
1089    }
1090    #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"]
1091    #[inline]
1092    pub fn ospeedr1(&mut self) -> _OSPEEDR1W {
1093        _OSPEEDR1W { w: self }
1094    }
1095    #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"]
1096    #[inline]
1097    pub fn ospeedr0(&mut self) -> _OSPEEDR0W {
1098        _OSPEEDR0W { w: self }
1099    }
1100}
stm32l4x2_pac/gpioa/ospeedr.rs

stm32l4x2_pac/gpioa/
ospeedr.rs
