stm32l4x2_pac/gpioa/
bsrr.rs

1#[doc = r" Value to write to the register"]
2pub struct W {
3    bits: u32,
4}
5impl super::BSRR {
6    #[doc = r" Writes to the register"]
7    #[inline]
8    pub fn write<F>(&self, f: F)
9    where
10        F: FnOnce(&mut W) -> &mut W,
11    {
12        let mut w = W::reset_value();
13        f(&mut w);
14        self.register.set(w.bits);
15    }
16}
17#[doc = "Values that can be written to the field `BR15`"]
18pub enum BR15W {
19    #[doc = "Resets the corresponding ODRx bit"]
20    RESET,
21}
22impl BR15W {
23    #[allow(missing_docs)]
24    #[doc(hidden)]
25    #[inline]
26    pub fn _bits(&self) -> bool {
27        match *self {
28            BR15W::RESET => true,
29        }
30    }
31}
32#[doc = r" Proxy"]
33pub struct _BR15W<'a> {
34    w: &'a mut W,
35}
36impl<'a> _BR15W<'a> {
37    #[doc = r" Writes `variant` to the field"]
38    #[inline]
39    pub fn variant(self, variant: BR15W) -> &'a mut W {
40        {
41            self.bit(variant._bits())
42        }
43    }
44    #[doc = "Resets the corresponding ODRx bit"]
45    #[inline]
46    pub fn reset(self) -> &'a mut W {
47        self.variant(BR15W::RESET)
48    }
49    #[doc = r" Sets the field bit"]
50    pub fn set_bit(self) -> &'a mut W {
51        self.bit(true)
52    }
53    #[doc = r" Clears the field bit"]
54    pub fn clear_bit(self) -> &'a mut W {
55        self.bit(false)
56    }
57    #[doc = r" Writes raw bits to the field"]
58    #[inline]
59    pub fn bit(self, value: bool) -> &'a mut W {
60        const MASK: bool = true;
61        const OFFSET: u8 = 31;
62        self.w.bits &= !((MASK as u32) << OFFSET);
63        self.w.bits |= ((value & MASK) as u32) << OFFSET;
64        self.w
65    }
66}
67#[doc = "Values that can be written to the field `BR14`"]
68pub type BR14W = BR15W;
69#[doc = r" Proxy"]
70pub struct _BR14W<'a> {
71    w: &'a mut W,
72}
73impl<'a> _BR14W<'a> {
74    #[doc = r" Writes `variant` to the field"]
75    #[inline]
76    pub fn variant(self, variant: BR14W) -> &'a mut W {
77        {
78            self.bit(variant._bits())
79        }
80    }
81    #[doc = "Resets the corresponding ODRx bit"]
82    #[inline]
83    pub fn reset(self) -> &'a mut W {
84        self.variant(BR15W::RESET)
85    }
86    #[doc = r" Sets the field bit"]
87    pub fn set_bit(self) -> &'a mut W {
88        self.bit(true)
89    }
90    #[doc = r" Clears the field bit"]
91    pub fn clear_bit(self) -> &'a mut W {
92        self.bit(false)
93    }
94    #[doc = r" Writes raw bits to the field"]
95    #[inline]
96    pub fn bit(self, value: bool) -> &'a mut W {
97        const MASK: bool = true;
98        const OFFSET: u8 = 30;
99        self.w.bits &= !((MASK as u32) << OFFSET);
100        self.w.bits |= ((value & MASK) as u32) << OFFSET;
101        self.w
102    }
103}
104#[doc = "Values that can be written to the field `BR13`"]
105pub type BR13W = BR15W;
106#[doc = r" Proxy"]
107pub struct _BR13W<'a> {
108    w: &'a mut W,
109}
110impl<'a> _BR13W<'a> {
111    #[doc = r" Writes `variant` to the field"]
112    #[inline]
113    pub fn variant(self, variant: BR13W) -> &'a mut W {
114        {
115            self.bit(variant._bits())
116        }
117    }
118    #[doc = "Resets the corresponding ODRx bit"]
119    #[inline]
120    pub fn reset(self) -> &'a mut W {
121        self.variant(BR15W::RESET)
122    }
123    #[doc = r" Sets the field bit"]
124    pub fn set_bit(self) -> &'a mut W {
125        self.bit(true)
126    }
127    #[doc = r" Clears the field bit"]
128    pub fn clear_bit(self) -> &'a mut W {
129        self.bit(false)
130    }
131    #[doc = r" Writes raw bits to the field"]
132    #[inline]
133    pub fn bit(self, value: bool) -> &'a mut W {
134        const MASK: bool = true;
135        const OFFSET: u8 = 29;
136        self.w.bits &= !((MASK as u32) << OFFSET);
137        self.w.bits |= ((value & MASK) as u32) << OFFSET;
138        self.w
139    }
140}
141#[doc = "Values that can be written to the field `BR12`"]
142pub type BR12W = BR15W;
143#[doc = r" Proxy"]
144pub struct _BR12W<'a> {
145    w: &'a mut W,
146}
147impl<'a> _BR12W<'a> {
148    #[doc = r" Writes `variant` to the field"]
149    #[inline]
150    pub fn variant(self, variant: BR12W) -> &'a mut W {
151        {
152            self.bit(variant._bits())
153        }
154    }
155    #[doc = "Resets the corresponding ODRx bit"]
156    #[inline]
157    pub fn reset(self) -> &'a mut W {
158        self.variant(BR15W::RESET)
159    }
160    #[doc = r" Sets the field bit"]
161    pub fn set_bit(self) -> &'a mut W {
162        self.bit(true)
163    }
164    #[doc = r" Clears the field bit"]
165    pub fn clear_bit(self) -> &'a mut W {
166        self.bit(false)
167    }
168    #[doc = r" Writes raw bits to the field"]
169    #[inline]
170    pub fn bit(self, value: bool) -> &'a mut W {
171        const MASK: bool = true;
172        const OFFSET: u8 = 28;
173        self.w.bits &= !((MASK as u32) << OFFSET);
174        self.w.bits |= ((value & MASK) as u32) << OFFSET;
175        self.w
176    }
177}
178#[doc = "Values that can be written to the field `BR11`"]
179pub type BR11W = BR15W;
180#[doc = r" Proxy"]
181pub struct _BR11W<'a> {
182    w: &'a mut W,
183}
184impl<'a> _BR11W<'a> {
185    #[doc = r" Writes `variant` to the field"]
186    #[inline]
187    pub fn variant(self, variant: BR11W) -> &'a mut W {
188        {
189            self.bit(variant._bits())
190        }
191    }
192    #[doc = "Resets the corresponding ODRx bit"]
193    #[inline]
194    pub fn reset(self) -> &'a mut W {
195        self.variant(BR15W::RESET)
196    }
197    #[doc = r" Sets the field bit"]
198    pub fn set_bit(self) -> &'a mut W {
199        self.bit(true)
200    }
201    #[doc = r" Clears the field bit"]
202    pub fn clear_bit(self) -> &'a mut W {
203        self.bit(false)
204    }
205    #[doc = r" Writes raw bits to the field"]
206    #[inline]
207    pub fn bit(self, value: bool) -> &'a mut W {
208        const MASK: bool = true;
209        const OFFSET: u8 = 27;
210        self.w.bits &= !((MASK as u32) << OFFSET);
211        self.w.bits |= ((value & MASK) as u32) << OFFSET;
212        self.w
213    }
214}
215#[doc = "Values that can be written to the field `BR10`"]
216pub type BR10W = BR15W;
217#[doc = r" Proxy"]
218pub struct _BR10W<'a> {
219    w: &'a mut W,
220}
221impl<'a> _BR10W<'a> {
222    #[doc = r" Writes `variant` to the field"]
223    #[inline]
224    pub fn variant(self, variant: BR10W) -> &'a mut W {
225        {
226            self.bit(variant._bits())
227        }
228    }
229    #[doc = "Resets the corresponding ODRx bit"]
230    #[inline]
231    pub fn reset(self) -> &'a mut W {
232        self.variant(BR15W::RESET)
233    }
234    #[doc = r" Sets the field bit"]
235    pub fn set_bit(self) -> &'a mut W {
236        self.bit(true)
237    }
238    #[doc = r" Clears the field bit"]
239    pub fn clear_bit(self) -> &'a mut W {
240        self.bit(false)
241    }
242    #[doc = r" Writes raw bits to the field"]
243    #[inline]
244    pub fn bit(self, value: bool) -> &'a mut W {
245        const MASK: bool = true;
246        const OFFSET: u8 = 26;
247        self.w.bits &= !((MASK as u32) << OFFSET);
248        self.w.bits |= ((value & MASK) as u32) << OFFSET;
249        self.w
250    }
251}
252#[doc = "Values that can be written to the field `BR9`"]
253pub type BR9W = BR15W;
254#[doc = r" Proxy"]
255pub struct _BR9W<'a> {
256    w: &'a mut W,
257}
258impl<'a> _BR9W<'a> {
259    #[doc = r" Writes `variant` to the field"]
260    #[inline]
261    pub fn variant(self, variant: BR9W) -> &'a mut W {
262        {
263            self.bit(variant._bits())
264        }
265    }
266    #[doc = "Resets the corresponding ODRx bit"]
267    #[inline]
268    pub fn reset(self) -> &'a mut W {
269        self.variant(BR15W::RESET)
270    }
271    #[doc = r" Sets the field bit"]
272    pub fn set_bit(self) -> &'a mut W {
273        self.bit(true)
274    }
275    #[doc = r" Clears the field bit"]
276    pub fn clear_bit(self) -> &'a mut W {
277        self.bit(false)
278    }
279    #[doc = r" Writes raw bits to the field"]
280    #[inline]
281    pub fn bit(self, value: bool) -> &'a mut W {
282        const MASK: bool = true;
283        const OFFSET: u8 = 25;
284        self.w.bits &= !((MASK as u32) << OFFSET);
285        self.w.bits |= ((value & MASK) as u32) << OFFSET;
286        self.w
287    }
288}
289#[doc = "Values that can be written to the field `BR8`"]
290pub type BR8W = BR15W;
291#[doc = r" Proxy"]
292pub struct _BR8W<'a> {
293    w: &'a mut W,
294}
295impl<'a> _BR8W<'a> {
296    #[doc = r" Writes `variant` to the field"]
297    #[inline]
298    pub fn variant(self, variant: BR8W) -> &'a mut W {
299        {
300            self.bit(variant._bits())
301        }
302    }
303    #[doc = "Resets the corresponding ODRx bit"]
304    #[inline]
305    pub fn reset(self) -> &'a mut W {
306        self.variant(BR15W::RESET)
307    }
308    #[doc = r" Sets the field bit"]
309    pub fn set_bit(self) -> &'a mut W {
310        self.bit(true)
311    }
312    #[doc = r" Clears the field bit"]
313    pub fn clear_bit(self) -> &'a mut W {
314        self.bit(false)
315    }
316    #[doc = r" Writes raw bits to the field"]
317    #[inline]
318    pub fn bit(self, value: bool) -> &'a mut W {
319        const MASK: bool = true;
320        const OFFSET: u8 = 24;
321        self.w.bits &= !((MASK as u32) << OFFSET);
322        self.w.bits |= ((value & MASK) as u32) << OFFSET;
323        self.w
324    }
325}
326#[doc = "Values that can be written to the field `BR7`"]
327pub type BR7W = BR15W;
328#[doc = r" Proxy"]
329pub struct _BR7W<'a> {
330    w: &'a mut W,
331}
332impl<'a> _BR7W<'a> {
333    #[doc = r" Writes `variant` to the field"]
334    #[inline]
335    pub fn variant(self, variant: BR7W) -> &'a mut W {
336        {
337            self.bit(variant._bits())
338        }
339    }
340    #[doc = "Resets the corresponding ODRx bit"]
341    #[inline]
342    pub fn reset(self) -> &'a mut W {
343        self.variant(BR15W::RESET)
344    }
345    #[doc = r" Sets the field bit"]
346    pub fn set_bit(self) -> &'a mut W {
347        self.bit(true)
348    }
349    #[doc = r" Clears the field bit"]
350    pub fn clear_bit(self) -> &'a mut W {
351        self.bit(false)
352    }
353    #[doc = r" Writes raw bits to the field"]
354    #[inline]
355    pub fn bit(self, value: bool) -> &'a mut W {
356        const MASK: bool = true;
357        const OFFSET: u8 = 23;
358        self.w.bits &= !((MASK as u32) << OFFSET);
359        self.w.bits |= ((value & MASK) as u32) << OFFSET;
360        self.w
361    }
362}
363#[doc = "Values that can be written to the field `BR6`"]
364pub type BR6W = BR15W;
365#[doc = r" Proxy"]
366pub struct _BR6W<'a> {
367    w: &'a mut W,
368}
369impl<'a> _BR6W<'a> {
370    #[doc = r" Writes `variant` to the field"]
371    #[inline]
372    pub fn variant(self, variant: BR6W) -> &'a mut W {
373        {
374            self.bit(variant._bits())
375        }
376    }
377    #[doc = "Resets the corresponding ODRx bit"]
378    #[inline]
379    pub fn reset(self) -> &'a mut W {
380        self.variant(BR15W::RESET)
381    }
382    #[doc = r" Sets the field bit"]
383    pub fn set_bit(self) -> &'a mut W {
384        self.bit(true)
385    }
386    #[doc = r" Clears the field bit"]
387    pub fn clear_bit(self) -> &'a mut W {
388        self.bit(false)
389    }
390    #[doc = r" Writes raw bits to the field"]
391    #[inline]
392    pub fn bit(self, value: bool) -> &'a mut W {
393        const MASK: bool = true;
394        const OFFSET: u8 = 22;
395        self.w.bits &= !((MASK as u32) << OFFSET);
396        self.w.bits |= ((value & MASK) as u32) << OFFSET;
397        self.w
398    }
399}
400#[doc = "Values that can be written to the field `BR5`"]
401pub type BR5W = BR15W;
402#[doc = r" Proxy"]
403pub struct _BR5W<'a> {
404    w: &'a mut W,
405}
406impl<'a> _BR5W<'a> {
407    #[doc = r" Writes `variant` to the field"]
408    #[inline]
409    pub fn variant(self, variant: BR5W) -> &'a mut W {
410        {
411            self.bit(variant._bits())
412        }
413    }
414    #[doc = "Resets the corresponding ODRx bit"]
415    #[inline]
416    pub fn reset(self) -> &'a mut W {
417        self.variant(BR15W::RESET)
418    }
419    #[doc = r" Sets the field bit"]
420    pub fn set_bit(self) -> &'a mut W {
421        self.bit(true)
422    }
423    #[doc = r" Clears the field bit"]
424    pub fn clear_bit(self) -> &'a mut W {
425        self.bit(false)
426    }
427    #[doc = r" Writes raw bits to the field"]
428    #[inline]
429    pub fn bit(self, value: bool) -> &'a mut W {
430        const MASK: bool = true;
431        const OFFSET: u8 = 21;
432        self.w.bits &= !((MASK as u32) << OFFSET);
433        self.w.bits |= ((value & MASK) as u32) << OFFSET;
434        self.w
435    }
436}
437#[doc = "Values that can be written to the field `BR4`"]
438pub type BR4W = BR15W;
439#[doc = r" Proxy"]
440pub struct _BR4W<'a> {
441    w: &'a mut W,
442}
443impl<'a> _BR4W<'a> {
444    #[doc = r" Writes `variant` to the field"]
445    #[inline]
446    pub fn variant(self, variant: BR4W) -> &'a mut W {
447        {
448            self.bit(variant._bits())
449        }
450    }
451    #[doc = "Resets the corresponding ODRx bit"]
452    #[inline]
453    pub fn reset(self) -> &'a mut W {
454        self.variant(BR15W::RESET)
455    }
456    #[doc = r" Sets the field bit"]
457    pub fn set_bit(self) -> &'a mut W {
458        self.bit(true)
459    }
460    #[doc = r" Clears the field bit"]
461    pub fn clear_bit(self) -> &'a mut W {
462        self.bit(false)
463    }
464    #[doc = r" Writes raw bits to the field"]
465    #[inline]
466    pub fn bit(self, value: bool) -> &'a mut W {
467        const MASK: bool = true;
468        const OFFSET: u8 = 20;
469        self.w.bits &= !((MASK as u32) << OFFSET);
470        self.w.bits |= ((value & MASK) as u32) << OFFSET;
471        self.w
472    }
473}
474#[doc = "Values that can be written to the field `BR3`"]
475pub type BR3W = BR15W;
476#[doc = r" Proxy"]
477pub struct _BR3W<'a> {
478    w: &'a mut W,
479}
480impl<'a> _BR3W<'a> {
481    #[doc = r" Writes `variant` to the field"]
482    #[inline]
483    pub fn variant(self, variant: BR3W) -> &'a mut W {
484        {
485            self.bit(variant._bits())
486        }
487    }
488    #[doc = "Resets the corresponding ODRx bit"]
489    #[inline]
490    pub fn reset(self) -> &'a mut W {
491        self.variant(BR15W::RESET)
492    }
493    #[doc = r" Sets the field bit"]
494    pub fn set_bit(self) -> &'a mut W {
495        self.bit(true)
496    }
497    #[doc = r" Clears the field bit"]
498    pub fn clear_bit(self) -> &'a mut W {
499        self.bit(false)
500    }
501    #[doc = r" Writes raw bits to the field"]
502    #[inline]
503    pub fn bit(self, value: bool) -> &'a mut W {
504        const MASK: bool = true;
505        const OFFSET: u8 = 19;
506        self.w.bits &= !((MASK as u32) << OFFSET);
507        self.w.bits |= ((value & MASK) as u32) << OFFSET;
508        self.w
509    }
510}
511#[doc = "Values that can be written to the field `BR2`"]
512pub type BR2W = BR15W;
513#[doc = r" Proxy"]
514pub struct _BR2W<'a> {
515    w: &'a mut W,
516}
517impl<'a> _BR2W<'a> {
518    #[doc = r" Writes `variant` to the field"]
519    #[inline]
520    pub fn variant(self, variant: BR2W) -> &'a mut W {
521        {
522            self.bit(variant._bits())
523        }
524    }
525    #[doc = "Resets the corresponding ODRx bit"]
526    #[inline]
527    pub fn reset(self) -> &'a mut W {
528        self.variant(BR15W::RESET)
529    }
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 = 18;
543        self.w.bits &= !((MASK as u32) << OFFSET);
544        self.w.bits |= ((value & MASK) as u32) << OFFSET;
545        self.w
546    }
547}
548#[doc = "Values that can be written to the field `BR1`"]
549pub type BR1W = BR15W;
550#[doc = r" Proxy"]
551pub struct _BR1W<'a> {
552    w: &'a mut W,
553}
554impl<'a> _BR1W<'a> {
555    #[doc = r" Writes `variant` to the field"]
556    #[inline]
557    pub fn variant(self, variant: BR1W) -> &'a mut W {
558        {
559            self.bit(variant._bits())
560        }
561    }
562    #[doc = "Resets the corresponding ODRx bit"]
563    #[inline]
564    pub fn reset(self) -> &'a mut W {
565        self.variant(BR15W::RESET)
566    }
567    #[doc = r" Sets the field bit"]
568    pub fn set_bit(self) -> &'a mut W {
569        self.bit(true)
570    }
571    #[doc = r" Clears the field bit"]
572    pub fn clear_bit(self) -> &'a mut W {
573        self.bit(false)
574    }
575    #[doc = r" Writes raw bits to the field"]
576    #[inline]
577    pub fn bit(self, value: bool) -> &'a mut W {
578        const MASK: bool = true;
579        const OFFSET: u8 = 17;
580        self.w.bits &= !((MASK as u32) << OFFSET);
581        self.w.bits |= ((value & MASK) as u32) << OFFSET;
582        self.w
583    }
584}
585#[doc = "Values that can be written to the field `BR0`"]
586pub type BR0W = BR15W;
587#[doc = r" Proxy"]
588pub struct _BR0W<'a> {
589    w: &'a mut W,
590}
591impl<'a> _BR0W<'a> {
592    #[doc = r" Writes `variant` to the field"]
593    #[inline]
594    pub fn variant(self, variant: BR0W) -> &'a mut W {
595        {
596            self.bit(variant._bits())
597        }
598    }
599    #[doc = "Resets the corresponding ODRx bit"]
600    #[inline]
601    pub fn reset(self) -> &'a mut W {
602        self.variant(BR15W::RESET)
603    }
604    #[doc = r" Sets the field bit"]
605    pub fn set_bit(self) -> &'a mut W {
606        self.bit(true)
607    }
608    #[doc = r" Clears the field bit"]
609    pub fn clear_bit(self) -> &'a mut W {
610        self.bit(false)
611    }
612    #[doc = r" Writes raw bits to the field"]
613    #[inline]
614    pub fn bit(self, value: bool) -> &'a mut W {
615        const MASK: bool = true;
616        const OFFSET: u8 = 16;
617        self.w.bits &= !((MASK as u32) << OFFSET);
618        self.w.bits |= ((value & MASK) as u32) << OFFSET;
619        self.w
620    }
621}
622#[doc = "Values that can be written to the field `BS15`"]
623pub enum BS15W {
624    #[doc = "Sets the corresponding ODRx bit"]
625    SET,
626}
627impl BS15W {
628    #[allow(missing_docs)]
629    #[doc(hidden)]
630    #[inline]
631    pub fn _bits(&self) -> bool {
632        match *self {
633            BS15W::SET => true,
634        }
635    }
636}
637#[doc = r" Proxy"]
638pub struct _BS15W<'a> {
639    w: &'a mut W,
640}
641impl<'a> _BS15W<'a> {
642    #[doc = r" Writes `variant` to the field"]
643    #[inline]
644    pub fn variant(self, variant: BS15W) -> &'a mut W {
645        {
646            self.bit(variant._bits())
647        }
648    }
649    #[doc = "Sets the corresponding ODRx bit"]
650    #[inline]
651    pub fn set(self) -> &'a mut W {
652        self.variant(BS15W::SET)
653    }
654    #[doc = r" Sets the field bit"]
655    pub fn set_bit(self) -> &'a mut W {
656        self.bit(true)
657    }
658    #[doc = r" Clears the field bit"]
659    pub fn clear_bit(self) -> &'a mut W {
660        self.bit(false)
661    }
662    #[doc = r" Writes raw bits to the field"]
663    #[inline]
664    pub fn bit(self, value: bool) -> &'a mut W {
665        const MASK: bool = true;
666        const OFFSET: u8 = 15;
667        self.w.bits &= !((MASK as u32) << OFFSET);
668        self.w.bits |= ((value & MASK) as u32) << OFFSET;
669        self.w
670    }
671}
672#[doc = "Values that can be written to the field `BS14`"]
673pub type BS14W = BS15W;
674#[doc = r" Proxy"]
675pub struct _BS14W<'a> {
676    w: &'a mut W,
677}
678impl<'a> _BS14W<'a> {
679    #[doc = r" Writes `variant` to the field"]
680    #[inline]
681    pub fn variant(self, variant: BS14W) -> &'a mut W {
682        {
683            self.bit(variant._bits())
684        }
685    }
686    #[doc = "Sets the corresponding ODRx bit"]
687    #[inline]
688    pub fn set(self) -> &'a mut W {
689        self.variant(BS15W::SET)
690    }
691    #[doc = r" Sets the field bit"]
692    pub fn set_bit(self) -> &'a mut W {
693        self.bit(true)
694    }
695    #[doc = r" Clears the field bit"]
696    pub fn clear_bit(self) -> &'a mut W {
697        self.bit(false)
698    }
699    #[doc = r" Writes raw bits to the field"]
700    #[inline]
701    pub fn bit(self, value: bool) -> &'a mut W {
702        const MASK: bool = true;
703        const OFFSET: u8 = 14;
704        self.w.bits &= !((MASK as u32) << OFFSET);
705        self.w.bits |= ((value & MASK) as u32) << OFFSET;
706        self.w
707    }
708}
709#[doc = "Values that can be written to the field `BS13`"]
710pub type BS13W = BS15W;
711#[doc = r" Proxy"]
712pub struct _BS13W<'a> {
713    w: &'a mut W,
714}
715impl<'a> _BS13W<'a> {
716    #[doc = r" Writes `variant` to the field"]
717    #[inline]
718    pub fn variant(self, variant: BS13W) -> &'a mut W {
719        {
720            self.bit(variant._bits())
721        }
722    }
723    #[doc = "Sets the corresponding ODRx bit"]
724    #[inline]
725    pub fn set(self) -> &'a mut W {
726        self.variant(BS15W::SET)
727    }
728    #[doc = r" Sets the field bit"]
729    pub fn set_bit(self) -> &'a mut W {
730        self.bit(true)
731    }
732    #[doc = r" Clears the field bit"]
733    pub fn clear_bit(self) -> &'a mut W {
734        self.bit(false)
735    }
736    #[doc = r" Writes raw bits to the field"]
737    #[inline]
738    pub fn bit(self, value: bool) -> &'a mut W {
739        const MASK: bool = true;
740        const OFFSET: u8 = 13;
741        self.w.bits &= !((MASK as u32) << OFFSET);
742        self.w.bits |= ((value & MASK) as u32) << OFFSET;
743        self.w
744    }
745}
746#[doc = "Values that can be written to the field `BS12`"]
747pub type BS12W = BS15W;
748#[doc = r" Proxy"]
749pub struct _BS12W<'a> {
750    w: &'a mut W,
751}
752impl<'a> _BS12W<'a> {
753    #[doc = r" Writes `variant` to the field"]
754    #[inline]
755    pub fn variant(self, variant: BS12W) -> &'a mut W {
756        {
757            self.bit(variant._bits())
758        }
759    }
760    #[doc = "Sets the corresponding ODRx bit"]
761    #[inline]
762    pub fn set(self) -> &'a mut W {
763        self.variant(BS15W::SET)
764    }
765    #[doc = r" Sets the field bit"]
766    pub fn set_bit(self) -> &'a mut W {
767        self.bit(true)
768    }
769    #[doc = r" Clears the field bit"]
770    pub fn clear_bit(self) -> &'a mut W {
771        self.bit(false)
772    }
773    #[doc = r" Writes raw bits to the field"]
774    #[inline]
775    pub fn bit(self, value: bool) -> &'a mut W {
776        const MASK: bool = true;
777        const OFFSET: u8 = 12;
778        self.w.bits &= !((MASK as u32) << OFFSET);
779        self.w.bits |= ((value & MASK) as u32) << OFFSET;
780        self.w
781    }
782}
783#[doc = "Values that can be written to the field `BS11`"]
784pub type BS11W = BS15W;
785#[doc = r" Proxy"]
786pub struct _BS11W<'a> {
787    w: &'a mut W,
788}
789impl<'a> _BS11W<'a> {
790    #[doc = r" Writes `variant` to the field"]
791    #[inline]
792    pub fn variant(self, variant: BS11W) -> &'a mut W {
793        {
794            self.bit(variant._bits())
795        }
796    }
797    #[doc = "Sets the corresponding ODRx bit"]
798    #[inline]
799    pub fn set(self) -> &'a mut W {
800        self.variant(BS15W::SET)
801    }
802    #[doc = r" Sets the field bit"]
803    pub fn set_bit(self) -> &'a mut W {
804        self.bit(true)
805    }
806    #[doc = r" Clears the field bit"]
807    pub fn clear_bit(self) -> &'a mut W {
808        self.bit(false)
809    }
810    #[doc = r" Writes raw bits to the field"]
811    #[inline]
812    pub fn bit(self, value: bool) -> &'a mut W {
813        const MASK: bool = true;
814        const OFFSET: u8 = 11;
815        self.w.bits &= !((MASK as u32) << OFFSET);
816        self.w.bits |= ((value & MASK) as u32) << OFFSET;
817        self.w
818    }
819}
820#[doc = "Values that can be written to the field `BS10`"]
821pub type BS10W = BS15W;
822#[doc = r" Proxy"]
823pub struct _BS10W<'a> {
824    w: &'a mut W,
825}
826impl<'a> _BS10W<'a> {
827    #[doc = r" Writes `variant` to the field"]
828    #[inline]
829    pub fn variant(self, variant: BS10W) -> &'a mut W {
830        {
831            self.bit(variant._bits())
832        }
833    }
834    #[doc = "Sets the corresponding ODRx bit"]
835    #[inline]
836    pub fn set(self) -> &'a mut W {
837        self.variant(BS15W::SET)
838    }
839    #[doc = r" Sets the field bit"]
840    pub fn set_bit(self) -> &'a mut W {
841        self.bit(true)
842    }
843    #[doc = r" Clears the field bit"]
844    pub fn clear_bit(self) -> &'a mut W {
845        self.bit(false)
846    }
847    #[doc = r" Writes raw bits to the field"]
848    #[inline]
849    pub fn bit(self, value: bool) -> &'a mut W {
850        const MASK: bool = true;
851        const OFFSET: u8 = 10;
852        self.w.bits &= !((MASK as u32) << OFFSET);
853        self.w.bits |= ((value & MASK) as u32) << OFFSET;
854        self.w
855    }
856}
857#[doc = "Values that can be written to the field `BS9`"]
858pub type BS9W = BS15W;
859#[doc = r" Proxy"]
860pub struct _BS9W<'a> {
861    w: &'a mut W,
862}
863impl<'a> _BS9W<'a> {
864    #[doc = r" Writes `variant` to the field"]
865    #[inline]
866    pub fn variant(self, variant: BS9W) -> &'a mut W {
867        {
868            self.bit(variant._bits())
869        }
870    }
871    #[doc = "Sets the corresponding ODRx bit"]
872    #[inline]
873    pub fn set(self) -> &'a mut W {
874        self.variant(BS15W::SET)
875    }
876    #[doc = r" Sets the field bit"]
877    pub fn set_bit(self) -> &'a mut W {
878        self.bit(true)
879    }
880    #[doc = r" Clears the field bit"]
881    pub fn clear_bit(self) -> &'a mut W {
882        self.bit(false)
883    }
884    #[doc = r" Writes raw bits to the field"]
885    #[inline]
886    pub fn bit(self, value: bool) -> &'a mut W {
887        const MASK: bool = true;
888        const OFFSET: u8 = 9;
889        self.w.bits &= !((MASK as u32) << OFFSET);
890        self.w.bits |= ((value & MASK) as u32) << OFFSET;
891        self.w
892    }
893}
894#[doc = "Values that can be written to the field `BS8`"]
895pub type BS8W = BS15W;
896#[doc = r" Proxy"]
897pub struct _BS8W<'a> {
898    w: &'a mut W,
899}
900impl<'a> _BS8W<'a> {
901    #[doc = r" Writes `variant` to the field"]
902    #[inline]
903    pub fn variant(self, variant: BS8W) -> &'a mut W {
904        {
905            self.bit(variant._bits())
906        }
907    }
908    #[doc = "Sets the corresponding ODRx bit"]
909    #[inline]
910    pub fn set(self) -> &'a mut W {
911        self.variant(BS15W::SET)
912    }
913    #[doc = r" Sets the field bit"]
914    pub fn set_bit(self) -> &'a mut W {
915        self.bit(true)
916    }
917    #[doc = r" Clears the field bit"]
918    pub fn clear_bit(self) -> &'a mut W {
919        self.bit(false)
920    }
921    #[doc = r" Writes raw bits to the field"]
922    #[inline]
923    pub fn bit(self, value: bool) -> &'a mut W {
924        const MASK: bool = true;
925        const OFFSET: u8 = 8;
926        self.w.bits &= !((MASK as u32) << OFFSET);
927        self.w.bits |= ((value & MASK) as u32) << OFFSET;
928        self.w
929    }
930}
931#[doc = "Values that can be written to the field `BS7`"]
932pub type BS7W = BS15W;
933#[doc = r" Proxy"]
934pub struct _BS7W<'a> {
935    w: &'a mut W,
936}
937impl<'a> _BS7W<'a> {
938    #[doc = r" Writes `variant` to the field"]
939    #[inline]
940    pub fn variant(self, variant: BS7W) -> &'a mut W {
941        {
942            self.bit(variant._bits())
943        }
944    }
945    #[doc = "Sets the corresponding ODRx bit"]
946    #[inline]
947    pub fn set(self) -> &'a mut W {
948        self.variant(BS15W::SET)
949    }
950    #[doc = r" Sets the field bit"]
951    pub fn set_bit(self) -> &'a mut W {
952        self.bit(true)
953    }
954    #[doc = r" Clears the field bit"]
955    pub fn clear_bit(self) -> &'a mut W {
956        self.bit(false)
957    }
958    #[doc = r" Writes raw bits to the field"]
959    #[inline]
960    pub fn bit(self, value: bool) -> &'a mut W {
961        const MASK: bool = true;
962        const OFFSET: u8 = 7;
963        self.w.bits &= !((MASK as u32) << OFFSET);
964        self.w.bits |= ((value & MASK) as u32) << OFFSET;
965        self.w
966    }
967}
968#[doc = "Values that can be written to the field `BS6`"]
969pub type BS6W = BS15W;
970#[doc = r" Proxy"]
971pub struct _BS6W<'a> {
972    w: &'a mut W,
973}
974impl<'a> _BS6W<'a> {
975    #[doc = r" Writes `variant` to the field"]
976    #[inline]
977    pub fn variant(self, variant: BS6W) -> &'a mut W {
978        {
979            self.bit(variant._bits())
980        }
981    }
982    #[doc = "Sets the corresponding ODRx bit"]
983    #[inline]
984    pub fn set(self) -> &'a mut W {
985        self.variant(BS15W::SET)
986    }
987    #[doc = r" Sets the field bit"]
988    pub fn set_bit(self) -> &'a mut W {
989        self.bit(true)
990    }
991    #[doc = r" Clears the field bit"]
992    pub fn clear_bit(self) -> &'a mut W {
993        self.bit(false)
994    }
995    #[doc = r" Writes raw bits to the field"]
996    #[inline]
997    pub fn bit(self, value: bool) -> &'a mut W {
998        const MASK: bool = true;
999        const OFFSET: u8 = 6;
1000        self.w.bits &= !((MASK as u32) << OFFSET);
1001        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1002        self.w
1003    }
1004}
1005#[doc = "Values that can be written to the field `BS5`"]
1006pub type BS5W = BS15W;
1007#[doc = r" Proxy"]
1008pub struct _BS5W<'a> {
1009    w: &'a mut W,
1010}
1011impl<'a> _BS5W<'a> {
1012    #[doc = r" Writes `variant` to the field"]
1013    #[inline]
1014    pub fn variant(self, variant: BS5W) -> &'a mut W {
1015        {
1016            self.bit(variant._bits())
1017        }
1018    }
1019    #[doc = "Sets the corresponding ODRx bit"]
1020    #[inline]
1021    pub fn set(self) -> &'a mut W {
1022        self.variant(BS15W::SET)
1023    }
1024    #[doc = r" Sets the field bit"]
1025    pub fn set_bit(self) -> &'a mut W {
1026        self.bit(true)
1027    }
1028    #[doc = r" Clears the field bit"]
1029    pub fn clear_bit(self) -> &'a mut W {
1030        self.bit(false)
1031    }
1032    #[doc = r" Writes raw bits to the field"]
1033    #[inline]
1034    pub fn bit(self, value: bool) -> &'a mut W {
1035        const MASK: bool = true;
1036        const OFFSET: u8 = 5;
1037        self.w.bits &= !((MASK as u32) << OFFSET);
1038        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1039        self.w
1040    }
1041}
1042#[doc = "Values that can be written to the field `BS4`"]
1043pub type BS4W = BS15W;
1044#[doc = r" Proxy"]
1045pub struct _BS4W<'a> {
1046    w: &'a mut W,
1047}
1048impl<'a> _BS4W<'a> {
1049    #[doc = r" Writes `variant` to the field"]
1050    #[inline]
1051    pub fn variant(self, variant: BS4W) -> &'a mut W {
1052        {
1053            self.bit(variant._bits())
1054        }
1055    }
1056    #[doc = "Sets the corresponding ODRx bit"]
1057    #[inline]
1058    pub fn set(self) -> &'a mut W {
1059        self.variant(BS15W::SET)
1060    }
1061    #[doc = r" Sets the field bit"]
1062    pub fn set_bit(self) -> &'a mut W {
1063        self.bit(true)
1064    }
1065    #[doc = r" Clears the field bit"]
1066    pub fn clear_bit(self) -> &'a mut W {
1067        self.bit(false)
1068    }
1069    #[doc = r" Writes raw bits to the field"]
1070    #[inline]
1071    pub fn bit(self, value: bool) -> &'a mut W {
1072        const MASK: bool = true;
1073        const OFFSET: u8 = 4;
1074        self.w.bits &= !((MASK as u32) << OFFSET);
1075        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1076        self.w
1077    }
1078}
1079#[doc = "Values that can be written to the field `BS3`"]
1080pub type BS3W = BS15W;
1081#[doc = r" Proxy"]
1082pub struct _BS3W<'a> {
1083    w: &'a mut W,
1084}
1085impl<'a> _BS3W<'a> {
1086    #[doc = r" Writes `variant` to the field"]
1087    #[inline]
1088    pub fn variant(self, variant: BS3W) -> &'a mut W {
1089        {
1090            self.bit(variant._bits())
1091        }
1092    }
1093    #[doc = "Sets the corresponding ODRx bit"]
1094    #[inline]
1095    pub fn set(self) -> &'a mut W {
1096        self.variant(BS15W::SET)
1097    }
1098    #[doc = r" Sets the field bit"]
1099    pub fn set_bit(self) -> &'a mut W {
1100        self.bit(true)
1101    }
1102    #[doc = r" Clears the field bit"]
1103    pub fn clear_bit(self) -> &'a mut W {
1104        self.bit(false)
1105    }
1106    #[doc = r" Writes raw bits to the field"]
1107    #[inline]
1108    pub fn bit(self, value: bool) -> &'a mut W {
1109        const MASK: bool = true;
1110        const OFFSET: u8 = 3;
1111        self.w.bits &= !((MASK as u32) << OFFSET);
1112        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1113        self.w
1114    }
1115}
1116#[doc = "Values that can be written to the field `BS2`"]
1117pub type BS2W = BS15W;
1118#[doc = r" Proxy"]
1119pub struct _BS2W<'a> {
1120    w: &'a mut W,
1121}
1122impl<'a> _BS2W<'a> {
1123    #[doc = r" Writes `variant` to the field"]
1124    #[inline]
1125    pub fn variant(self, variant: BS2W) -> &'a mut W {
1126        {
1127            self.bit(variant._bits())
1128        }
1129    }
1130    #[doc = "Sets the corresponding ODRx bit"]
1131    #[inline]
1132    pub fn set(self) -> &'a mut W {
1133        self.variant(BS15W::SET)
1134    }
1135    #[doc = r" Sets the field bit"]
1136    pub fn set_bit(self) -> &'a mut W {
1137        self.bit(true)
1138    }
1139    #[doc = r" Clears the field bit"]
1140    pub fn clear_bit(self) -> &'a mut W {
1141        self.bit(false)
1142    }
1143    #[doc = r" Writes raw bits to the field"]
1144    #[inline]
1145    pub fn bit(self, value: bool) -> &'a mut W {
1146        const MASK: bool = true;
1147        const OFFSET: u8 = 2;
1148        self.w.bits &= !((MASK as u32) << OFFSET);
1149        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1150        self.w
1151    }
1152}
1153#[doc = "Values that can be written to the field `BS1`"]
1154pub type BS1W = BS15W;
1155#[doc = r" Proxy"]
1156pub struct _BS1W<'a> {
1157    w: &'a mut W,
1158}
1159impl<'a> _BS1W<'a> {
1160    #[doc = r" Writes `variant` to the field"]
1161    #[inline]
1162    pub fn variant(self, variant: BS1W) -> &'a mut W {
1163        {
1164            self.bit(variant._bits())
1165        }
1166    }
1167    #[doc = "Sets the corresponding ODRx bit"]
1168    #[inline]
1169    pub fn set(self) -> &'a mut W {
1170        self.variant(BS15W::SET)
1171    }
1172    #[doc = r" Sets the field bit"]
1173    pub fn set_bit(self) -> &'a mut W {
1174        self.bit(true)
1175    }
1176    #[doc = r" Clears the field bit"]
1177    pub fn clear_bit(self) -> &'a mut W {
1178        self.bit(false)
1179    }
1180    #[doc = r" Writes raw bits to the field"]
1181    #[inline]
1182    pub fn bit(self, value: bool) -> &'a mut W {
1183        const MASK: bool = true;
1184        const OFFSET: u8 = 1;
1185        self.w.bits &= !((MASK as u32) << OFFSET);
1186        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1187        self.w
1188    }
1189}
1190#[doc = "Values that can be written to the field `BS0`"]
1191pub type BS0W = BS15W;
1192#[doc = r" Proxy"]
1193pub struct _BS0W<'a> {
1194    w: &'a mut W,
1195}
1196impl<'a> _BS0W<'a> {
1197    #[doc = r" Writes `variant` to the field"]
1198    #[inline]
1199    pub fn variant(self, variant: BS0W) -> &'a mut W {
1200        {
1201            self.bit(variant._bits())
1202        }
1203    }
1204    #[doc = "Sets the corresponding ODRx bit"]
1205    #[inline]
1206    pub fn set(self) -> &'a mut W {
1207        self.variant(BS15W::SET)
1208    }
1209    #[doc = r" Sets the field bit"]
1210    pub fn set_bit(self) -> &'a mut W {
1211        self.bit(true)
1212    }
1213    #[doc = r" Clears the field bit"]
1214    pub fn clear_bit(self) -> &'a mut W {
1215        self.bit(false)
1216    }
1217    #[doc = r" Writes raw bits to the field"]
1218    #[inline]
1219    pub fn bit(self, value: bool) -> &'a mut W {
1220        const MASK: bool = true;
1221        const OFFSET: u8 = 0;
1222        self.w.bits &= !((MASK as u32) << OFFSET);
1223        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1224        self.w
1225    }
1226}
1227impl W {
1228    #[doc = r" Reset value of the register"]
1229    #[inline]
1230    pub fn reset_value() -> W {
1231        W { bits: 0 }
1232    }
1233    #[doc = r" Writes raw bits to the register"]
1234    #[inline]
1235    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1236        self.bits = bits;
1237        self
1238    }
1239    #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"]
1240    #[inline]
1241    pub fn br15(&mut self) -> _BR15W {
1242        _BR15W { w: self }
1243    }
1244    #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"]
1245    #[inline]
1246    pub fn br14(&mut self) -> _BR14W {
1247        _BR14W { w: self }
1248    }
1249    #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"]
1250    #[inline]
1251    pub fn br13(&mut self) -> _BR13W {
1252        _BR13W { w: self }
1253    }
1254    #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"]
1255    #[inline]
1256    pub fn br12(&mut self) -> _BR12W {
1257        _BR12W { w: self }
1258    }
1259    #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"]
1260    #[inline]
1261    pub fn br11(&mut self) -> _BR11W {
1262        _BR11W { w: self }
1263    }
1264    #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"]
1265    #[inline]
1266    pub fn br10(&mut self) -> _BR10W {
1267        _BR10W { w: self }
1268    }
1269    #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"]
1270    #[inline]
1271    pub fn br9(&mut self) -> _BR9W {
1272        _BR9W { w: self }
1273    }
1274    #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"]
1275    #[inline]
1276    pub fn br8(&mut self) -> _BR8W {
1277        _BR8W { w: self }
1278    }
1279    #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"]
1280    #[inline]
1281    pub fn br7(&mut self) -> _BR7W {
1282        _BR7W { w: self }
1283    }
1284    #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"]
1285    #[inline]
1286    pub fn br6(&mut self) -> _BR6W {
1287        _BR6W { w: self }
1288    }
1289    #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"]
1290    #[inline]
1291    pub fn br5(&mut self) -> _BR5W {
1292        _BR5W { w: self }
1293    }
1294    #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"]
1295    #[inline]
1296    pub fn br4(&mut self) -> _BR4W {
1297        _BR4W { w: self }
1298    }
1299    #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"]
1300    #[inline]
1301    pub fn br3(&mut self) -> _BR3W {
1302        _BR3W { w: self }
1303    }
1304    #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"]
1305    #[inline]
1306    pub fn br2(&mut self) -> _BR2W {
1307        _BR2W { w: self }
1308    }
1309    #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"]
1310    #[inline]
1311    pub fn br1(&mut self) -> _BR1W {
1312        _BR1W { w: self }
1313    }
1314    #[doc = "Bit 16 - Port x set bit y (y= 0..15)"]
1315    #[inline]
1316    pub fn br0(&mut self) -> _BR0W {
1317        _BR0W { w: self }
1318    }
1319    #[doc = "Bit 15 - Port x set bit y (y= 0..15)"]
1320    #[inline]
1321    pub fn bs15(&mut self) -> _BS15W {
1322        _BS15W { w: self }
1323    }
1324    #[doc = "Bit 14 - Port x set bit y (y= 0..15)"]
1325    #[inline]
1326    pub fn bs14(&mut self) -> _BS14W {
1327        _BS14W { w: self }
1328    }
1329    #[doc = "Bit 13 - Port x set bit y (y= 0..15)"]
1330    #[inline]
1331    pub fn bs13(&mut self) -> _BS13W {
1332        _BS13W { w: self }
1333    }
1334    #[doc = "Bit 12 - Port x set bit y (y= 0..15)"]
1335    #[inline]
1336    pub fn bs12(&mut self) -> _BS12W {
1337        _BS12W { w: self }
1338    }
1339    #[doc = "Bit 11 - Port x set bit y (y= 0..15)"]
1340    #[inline]
1341    pub fn bs11(&mut self) -> _BS11W {
1342        _BS11W { w: self }
1343    }
1344    #[doc = "Bit 10 - Port x set bit y (y= 0..15)"]
1345    #[inline]
1346    pub fn bs10(&mut self) -> _BS10W {
1347        _BS10W { w: self }
1348    }
1349    #[doc = "Bit 9 - Port x set bit y (y= 0..15)"]
1350    #[inline]
1351    pub fn bs9(&mut self) -> _BS9W {
1352        _BS9W { w: self }
1353    }
1354    #[doc = "Bit 8 - Port x set bit y (y= 0..15)"]
1355    #[inline]
1356    pub fn bs8(&mut self) -> _BS8W {
1357        _BS8W { w: self }
1358    }
1359    #[doc = "Bit 7 - Port x set bit y (y= 0..15)"]
1360    #[inline]
1361    pub fn bs7(&mut self) -> _BS7W {
1362        _BS7W { w: self }
1363    }
1364    #[doc = "Bit 6 - Port x set bit y (y= 0..15)"]
1365    #[inline]
1366    pub fn bs6(&mut self) -> _BS6W {
1367        _BS6W { w: self }
1368    }
1369    #[doc = "Bit 5 - Port x set bit y (y= 0..15)"]
1370    #[inline]
1371    pub fn bs5(&mut self) -> _BS5W {
1372        _BS5W { w: self }
1373    }
1374    #[doc = "Bit 4 - Port x set bit y (y= 0..15)"]
1375    #[inline]
1376    pub fn bs4(&mut self) -> _BS4W {
1377        _BS4W { w: self }
1378    }
1379    #[doc = "Bit 3 - Port x set bit y (y= 0..15)"]
1380    #[inline]
1381    pub fn bs3(&mut self) -> _BS3W {
1382        _BS3W { w: self }
1383    }
1384    #[doc = "Bit 2 - Port x set bit y (y= 0..15)"]
1385    #[inline]
1386    pub fn bs2(&mut self) -> _BS2W {
1387        _BS2W { w: self }
1388    }
1389    #[doc = "Bit 1 - Port x set bit y (y= 0..15)"]
1390    #[inline]
1391    pub fn bs1(&mut self) -> _BS1W {
1392        _BS1W { w: self }
1393    }
1394    #[doc = "Bit 0 - Port x set bit y (y= 0..15)"]
1395    #[inline]
1396    pub fn bs0(&mut self) -> _BS0W {
1397        _BS0W { w: self }
1398    }
1399}
stm32l4x2_pac/gpioa/bsrr.rs

stm32l4x2_pac/gpioa/
bsrr.rs
