stm32l0x1/gpiob/bsrr/
mod.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 = r" Proxy"]
18pub struct _BR15W<'a> {
19    w: &'a mut W,
20}
21impl<'a> _BR15W<'a> {
22    #[doc = r" Sets the field bit"]
23    pub fn set_bit(self) -> &'a mut W {
24        self.bit(true)
25    }
26    #[doc = r" Clears the field bit"]
27    pub fn clear_bit(self) -> &'a mut W {
28        self.bit(false)
29    }
30    #[doc = r" Writes raw bits to the field"]
31    #[inline]
32    pub fn bit(self, value: bool) -> &'a mut W {
33        const MASK: bool = true;
34        const OFFSET: u8 = 31;
35        self.w.bits &= !((MASK as u32) << OFFSET);
36        self.w.bits |= ((value & MASK) as u32) << OFFSET;
37        self.w
38    }
39}
40#[doc = r" Proxy"]
41pub struct _BR14W<'a> {
42    w: &'a mut W,
43}
44impl<'a> _BR14W<'a> {
45    #[doc = r" Sets the field bit"]
46    pub fn set_bit(self) -> &'a mut W {
47        self.bit(true)
48    }
49    #[doc = r" Clears the field bit"]
50    pub fn clear_bit(self) -> &'a mut W {
51        self.bit(false)
52    }
53    #[doc = r" Writes raw bits to the field"]
54    #[inline]
55    pub fn bit(self, value: bool) -> &'a mut W {
56        const MASK: bool = true;
57        const OFFSET: u8 = 30;
58        self.w.bits &= !((MASK as u32) << OFFSET);
59        self.w.bits |= ((value & MASK) as u32) << OFFSET;
60        self.w
61    }
62}
63#[doc = r" Proxy"]
64pub struct _BR13W<'a> {
65    w: &'a mut W,
66}
67impl<'a> _BR13W<'a> {
68    #[doc = r" Sets the field bit"]
69    pub fn set_bit(self) -> &'a mut W {
70        self.bit(true)
71    }
72    #[doc = r" Clears the field bit"]
73    pub fn clear_bit(self) -> &'a mut W {
74        self.bit(false)
75    }
76    #[doc = r" Writes raw bits to the field"]
77    #[inline]
78    pub fn bit(self, value: bool) -> &'a mut W {
79        const MASK: bool = true;
80        const OFFSET: u8 = 29;
81        self.w.bits &= !((MASK as u32) << OFFSET);
82        self.w.bits |= ((value & MASK) as u32) << OFFSET;
83        self.w
84    }
85}
86#[doc = r" Proxy"]
87pub struct _BR12W<'a> {
88    w: &'a mut W,
89}
90impl<'a> _BR12W<'a> {
91    #[doc = r" Sets the field bit"]
92    pub fn set_bit(self) -> &'a mut W {
93        self.bit(true)
94    }
95    #[doc = r" Clears the field bit"]
96    pub fn clear_bit(self) -> &'a mut W {
97        self.bit(false)
98    }
99    #[doc = r" Writes raw bits to the field"]
100    #[inline]
101    pub fn bit(self, value: bool) -> &'a mut W {
102        const MASK: bool = true;
103        const OFFSET: u8 = 28;
104        self.w.bits &= !((MASK as u32) << OFFSET);
105        self.w.bits |= ((value & MASK) as u32) << OFFSET;
106        self.w
107    }
108}
109#[doc = r" Proxy"]
110pub struct _BR11W<'a> {
111    w: &'a mut W,
112}
113impl<'a> _BR11W<'a> {
114    #[doc = r" Sets the field bit"]
115    pub fn set_bit(self) -> &'a mut W {
116        self.bit(true)
117    }
118    #[doc = r" Clears the field bit"]
119    pub fn clear_bit(self) -> &'a mut W {
120        self.bit(false)
121    }
122    #[doc = r" Writes raw bits to the field"]
123    #[inline]
124    pub fn bit(self, value: bool) -> &'a mut W {
125        const MASK: bool = true;
126        const OFFSET: u8 = 27;
127        self.w.bits &= !((MASK as u32) << OFFSET);
128        self.w.bits |= ((value & MASK) as u32) << OFFSET;
129        self.w
130    }
131}
132#[doc = r" Proxy"]
133pub struct _BR10W<'a> {
134    w: &'a mut W,
135}
136impl<'a> _BR10W<'a> {
137    #[doc = r" Sets the field bit"]
138    pub fn set_bit(self) -> &'a mut W {
139        self.bit(true)
140    }
141    #[doc = r" Clears the field bit"]
142    pub fn clear_bit(self) -> &'a mut W {
143        self.bit(false)
144    }
145    #[doc = r" Writes raw bits to the field"]
146    #[inline]
147    pub fn bit(self, value: bool) -> &'a mut W {
148        const MASK: bool = true;
149        const OFFSET: u8 = 26;
150        self.w.bits &= !((MASK as u32) << OFFSET);
151        self.w.bits |= ((value & MASK) as u32) << OFFSET;
152        self.w
153    }
154}
155#[doc = r" Proxy"]
156pub struct _BR9W<'a> {
157    w: &'a mut W,
158}
159impl<'a> _BR9W<'a> {
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 = 25;
173        self.w.bits &= !((MASK as u32) << OFFSET);
174        self.w.bits |= ((value & MASK) as u32) << OFFSET;
175        self.w
176    }
177}
178#[doc = r" Proxy"]
179pub struct _BR8W<'a> {
180    w: &'a mut W,
181}
182impl<'a> _BR8W<'a> {
183    #[doc = r" Sets the field bit"]
184    pub fn set_bit(self) -> &'a mut W {
185        self.bit(true)
186    }
187    #[doc = r" Clears the field bit"]
188    pub fn clear_bit(self) -> &'a mut W {
189        self.bit(false)
190    }
191    #[doc = r" Writes raw bits to the field"]
192    #[inline]
193    pub fn bit(self, value: bool) -> &'a mut W {
194        const MASK: bool = true;
195        const OFFSET: u8 = 24;
196        self.w.bits &= !((MASK as u32) << OFFSET);
197        self.w.bits |= ((value & MASK) as u32) << OFFSET;
198        self.w
199    }
200}
201#[doc = r" Proxy"]
202pub struct _BR7W<'a> {
203    w: &'a mut W,
204}
205impl<'a> _BR7W<'a> {
206    #[doc = r" Sets the field bit"]
207    pub fn set_bit(self) -> &'a mut W {
208        self.bit(true)
209    }
210    #[doc = r" Clears the field bit"]
211    pub fn clear_bit(self) -> &'a mut W {
212        self.bit(false)
213    }
214    #[doc = r" Writes raw bits to the field"]
215    #[inline]
216    pub fn bit(self, value: bool) -> &'a mut W {
217        const MASK: bool = true;
218        const OFFSET: u8 = 23;
219        self.w.bits &= !((MASK as u32) << OFFSET);
220        self.w.bits |= ((value & MASK) as u32) << OFFSET;
221        self.w
222    }
223}
224#[doc = r" Proxy"]
225pub struct _BR6W<'a> {
226    w: &'a mut W,
227}
228impl<'a> _BR6W<'a> {
229    #[doc = r" Sets the field bit"]
230    pub fn set_bit(self) -> &'a mut W {
231        self.bit(true)
232    }
233    #[doc = r" Clears the field bit"]
234    pub fn clear_bit(self) -> &'a mut W {
235        self.bit(false)
236    }
237    #[doc = r" Writes raw bits to the field"]
238    #[inline]
239    pub fn bit(self, value: bool) -> &'a mut W {
240        const MASK: bool = true;
241        const OFFSET: u8 = 22;
242        self.w.bits &= !((MASK as u32) << OFFSET);
243        self.w.bits |= ((value & MASK) as u32) << OFFSET;
244        self.w
245    }
246}
247#[doc = r" Proxy"]
248pub struct _BR5W<'a> {
249    w: &'a mut W,
250}
251impl<'a> _BR5W<'a> {
252    #[doc = r" Sets the field bit"]
253    pub fn set_bit(self) -> &'a mut W {
254        self.bit(true)
255    }
256    #[doc = r" Clears the field bit"]
257    pub fn clear_bit(self) -> &'a mut W {
258        self.bit(false)
259    }
260    #[doc = r" Writes raw bits to the field"]
261    #[inline]
262    pub fn bit(self, value: bool) -> &'a mut W {
263        const MASK: bool = true;
264        const OFFSET: u8 = 21;
265        self.w.bits &= !((MASK as u32) << OFFSET);
266        self.w.bits |= ((value & MASK) as u32) << OFFSET;
267        self.w
268    }
269}
270#[doc = r" Proxy"]
271pub struct _BR4W<'a> {
272    w: &'a mut W,
273}
274impl<'a> _BR4W<'a> {
275    #[doc = r" Sets the field bit"]
276    pub fn set_bit(self) -> &'a mut W {
277        self.bit(true)
278    }
279    #[doc = r" Clears the field bit"]
280    pub fn clear_bit(self) -> &'a mut W {
281        self.bit(false)
282    }
283    #[doc = r" Writes raw bits to the field"]
284    #[inline]
285    pub fn bit(self, value: bool) -> &'a mut W {
286        const MASK: bool = true;
287        const OFFSET: u8 = 20;
288        self.w.bits &= !((MASK as u32) << OFFSET);
289        self.w.bits |= ((value & MASK) as u32) << OFFSET;
290        self.w
291    }
292}
293#[doc = r" Proxy"]
294pub struct _BR3W<'a> {
295    w: &'a mut W,
296}
297impl<'a> _BR3W<'a> {
298    #[doc = r" Sets the field bit"]
299    pub fn set_bit(self) -> &'a mut W {
300        self.bit(true)
301    }
302    #[doc = r" Clears the field bit"]
303    pub fn clear_bit(self) -> &'a mut W {
304        self.bit(false)
305    }
306    #[doc = r" Writes raw bits to the field"]
307    #[inline]
308    pub fn bit(self, value: bool) -> &'a mut W {
309        const MASK: bool = true;
310        const OFFSET: u8 = 19;
311        self.w.bits &= !((MASK as u32) << OFFSET);
312        self.w.bits |= ((value & MASK) as u32) << OFFSET;
313        self.w
314    }
315}
316#[doc = r" Proxy"]
317pub struct _BR2W<'a> {
318    w: &'a mut W,
319}
320impl<'a> _BR2W<'a> {
321    #[doc = r" Sets the field bit"]
322    pub fn set_bit(self) -> &'a mut W {
323        self.bit(true)
324    }
325    #[doc = r" Clears the field bit"]
326    pub fn clear_bit(self) -> &'a mut W {
327        self.bit(false)
328    }
329    #[doc = r" Writes raw bits to the field"]
330    #[inline]
331    pub fn bit(self, value: bool) -> &'a mut W {
332        const MASK: bool = true;
333        const OFFSET: u8 = 18;
334        self.w.bits &= !((MASK as u32) << OFFSET);
335        self.w.bits |= ((value & MASK) as u32) << OFFSET;
336        self.w
337    }
338}
339#[doc = r" Proxy"]
340pub struct _BR1W<'a> {
341    w: &'a mut W,
342}
343impl<'a> _BR1W<'a> {
344    #[doc = r" Sets the field bit"]
345    pub fn set_bit(self) -> &'a mut W {
346        self.bit(true)
347    }
348    #[doc = r" Clears the field bit"]
349    pub fn clear_bit(self) -> &'a mut W {
350        self.bit(false)
351    }
352    #[doc = r" Writes raw bits to the field"]
353    #[inline]
354    pub fn bit(self, value: bool) -> &'a mut W {
355        const MASK: bool = true;
356        const OFFSET: u8 = 17;
357        self.w.bits &= !((MASK as u32) << OFFSET);
358        self.w.bits |= ((value & MASK) as u32) << OFFSET;
359        self.w
360    }
361}
362#[doc = r" Proxy"]
363pub struct _BR0W<'a> {
364    w: &'a mut W,
365}
366impl<'a> _BR0W<'a> {
367    #[doc = r" Sets the field bit"]
368    pub fn set_bit(self) -> &'a mut W {
369        self.bit(true)
370    }
371    #[doc = r" Clears the field bit"]
372    pub fn clear_bit(self) -> &'a mut W {
373        self.bit(false)
374    }
375    #[doc = r" Writes raw bits to the field"]
376    #[inline]
377    pub fn bit(self, value: bool) -> &'a mut W {
378        const MASK: bool = true;
379        const OFFSET: u8 = 16;
380        self.w.bits &= !((MASK as u32) << OFFSET);
381        self.w.bits |= ((value & MASK) as u32) << OFFSET;
382        self.w
383    }
384}
385#[doc = r" Proxy"]
386pub struct _BS15W<'a> {
387    w: &'a mut W,
388}
389impl<'a> _BS15W<'a> {
390    #[doc = r" Sets the field bit"]
391    pub fn set_bit(self) -> &'a mut W {
392        self.bit(true)
393    }
394    #[doc = r" Clears the field bit"]
395    pub fn clear_bit(self) -> &'a mut W {
396        self.bit(false)
397    }
398    #[doc = r" Writes raw bits to the field"]
399    #[inline]
400    pub fn bit(self, value: bool) -> &'a mut W {
401        const MASK: bool = true;
402        const OFFSET: u8 = 15;
403        self.w.bits &= !((MASK as u32) << OFFSET);
404        self.w.bits |= ((value & MASK) as u32) << OFFSET;
405        self.w
406    }
407}
408#[doc = r" Proxy"]
409pub struct _BS14W<'a> {
410    w: &'a mut W,
411}
412impl<'a> _BS14W<'a> {
413    #[doc = r" Sets the field bit"]
414    pub fn set_bit(self) -> &'a mut W {
415        self.bit(true)
416    }
417    #[doc = r" Clears the field bit"]
418    pub fn clear_bit(self) -> &'a mut W {
419        self.bit(false)
420    }
421    #[doc = r" Writes raw bits to the field"]
422    #[inline]
423    pub fn bit(self, value: bool) -> &'a mut W {
424        const MASK: bool = true;
425        const OFFSET: u8 = 14;
426        self.w.bits &= !((MASK as u32) << OFFSET);
427        self.w.bits |= ((value & MASK) as u32) << OFFSET;
428        self.w
429    }
430}
431#[doc = r" Proxy"]
432pub struct _BS13W<'a> {
433    w: &'a mut W,
434}
435impl<'a> _BS13W<'a> {
436    #[doc = r" Sets the field bit"]
437    pub fn set_bit(self) -> &'a mut W {
438        self.bit(true)
439    }
440    #[doc = r" Clears the field bit"]
441    pub fn clear_bit(self) -> &'a mut W {
442        self.bit(false)
443    }
444    #[doc = r" Writes raw bits to the field"]
445    #[inline]
446    pub fn bit(self, value: bool) -> &'a mut W {
447        const MASK: bool = true;
448        const OFFSET: u8 = 13;
449        self.w.bits &= !((MASK as u32) << OFFSET);
450        self.w.bits |= ((value & MASK) as u32) << OFFSET;
451        self.w
452    }
453}
454#[doc = r" Proxy"]
455pub struct _BS12W<'a> {
456    w: &'a mut W,
457}
458impl<'a> _BS12W<'a> {
459    #[doc = r" Sets the field bit"]
460    pub fn set_bit(self) -> &'a mut W {
461        self.bit(true)
462    }
463    #[doc = r" Clears the field bit"]
464    pub fn clear_bit(self) -> &'a mut W {
465        self.bit(false)
466    }
467    #[doc = r" Writes raw bits to the field"]
468    #[inline]
469    pub fn bit(self, value: bool) -> &'a mut W {
470        const MASK: bool = true;
471        const OFFSET: u8 = 12;
472        self.w.bits &= !((MASK as u32) << OFFSET);
473        self.w.bits |= ((value & MASK) as u32) << OFFSET;
474        self.w
475    }
476}
477#[doc = r" Proxy"]
478pub struct _BS11W<'a> {
479    w: &'a mut W,
480}
481impl<'a> _BS11W<'a> {
482    #[doc = r" Sets the field bit"]
483    pub fn set_bit(self) -> &'a mut W {
484        self.bit(true)
485    }
486    #[doc = r" Clears the field bit"]
487    pub fn clear_bit(self) -> &'a mut W {
488        self.bit(false)
489    }
490    #[doc = r" Writes raw bits to the field"]
491    #[inline]
492    pub fn bit(self, value: bool) -> &'a mut W {
493        const MASK: bool = true;
494        const OFFSET: u8 = 11;
495        self.w.bits &= !((MASK as u32) << OFFSET);
496        self.w.bits |= ((value & MASK) as u32) << OFFSET;
497        self.w
498    }
499}
500#[doc = r" Proxy"]
501pub struct _BS10W<'a> {
502    w: &'a mut W,
503}
504impl<'a> _BS10W<'a> {
505    #[doc = r" Sets the field bit"]
506    pub fn set_bit(self) -> &'a mut W {
507        self.bit(true)
508    }
509    #[doc = r" Clears the field bit"]
510    pub fn clear_bit(self) -> &'a mut W {
511        self.bit(false)
512    }
513    #[doc = r" Writes raw bits to the field"]
514    #[inline]
515    pub fn bit(self, value: bool) -> &'a mut W {
516        const MASK: bool = true;
517        const OFFSET: u8 = 10;
518        self.w.bits &= !((MASK as u32) << OFFSET);
519        self.w.bits |= ((value & MASK) as u32) << OFFSET;
520        self.w
521    }
522}
523#[doc = r" Proxy"]
524pub struct _BS9W<'a> {
525    w: &'a mut W,
526}
527impl<'a> _BS9W<'a> {
528    #[doc = r" Sets the field bit"]
529    pub fn set_bit(self) -> &'a mut W {
530        self.bit(true)
531    }
532    #[doc = r" Clears the field bit"]
533    pub fn clear_bit(self) -> &'a mut W {
534        self.bit(false)
535    }
536    #[doc = r" Writes raw bits to the field"]
537    #[inline]
538    pub fn bit(self, value: bool) -> &'a mut W {
539        const MASK: bool = true;
540        const OFFSET: u8 = 9;
541        self.w.bits &= !((MASK as u32) << OFFSET);
542        self.w.bits |= ((value & MASK) as u32) << OFFSET;
543        self.w
544    }
545}
546#[doc = r" Proxy"]
547pub struct _BS8W<'a> {
548    w: &'a mut W,
549}
550impl<'a> _BS8W<'a> {
551    #[doc = r" Sets the field bit"]
552    pub fn set_bit(self) -> &'a mut W {
553        self.bit(true)
554    }
555    #[doc = r" Clears the field bit"]
556    pub fn clear_bit(self) -> &'a mut W {
557        self.bit(false)
558    }
559    #[doc = r" Writes raw bits to the field"]
560    #[inline]
561    pub fn bit(self, value: bool) -> &'a mut W {
562        const MASK: bool = true;
563        const OFFSET: u8 = 8;
564        self.w.bits &= !((MASK as u32) << OFFSET);
565        self.w.bits |= ((value & MASK) as u32) << OFFSET;
566        self.w
567    }
568}
569#[doc = r" Proxy"]
570pub struct _BS7W<'a> {
571    w: &'a mut W,
572}
573impl<'a> _BS7W<'a> {
574    #[doc = r" Sets the field bit"]
575    pub fn set_bit(self) -> &'a mut W {
576        self.bit(true)
577    }
578    #[doc = r" Clears the field bit"]
579    pub fn clear_bit(self) -> &'a mut W {
580        self.bit(false)
581    }
582    #[doc = r" Writes raw bits to the field"]
583    #[inline]
584    pub fn bit(self, value: bool) -> &'a mut W {
585        const MASK: bool = true;
586        const OFFSET: u8 = 7;
587        self.w.bits &= !((MASK as u32) << OFFSET);
588        self.w.bits |= ((value & MASK) as u32) << OFFSET;
589        self.w
590    }
591}
592#[doc = r" Proxy"]
593pub struct _BS6W<'a> {
594    w: &'a mut W,
595}
596impl<'a> _BS6W<'a> {
597    #[doc = r" Sets the field bit"]
598    pub fn set_bit(self) -> &'a mut W {
599        self.bit(true)
600    }
601    #[doc = r" Clears the field bit"]
602    pub fn clear_bit(self) -> &'a mut W {
603        self.bit(false)
604    }
605    #[doc = r" Writes raw bits to the field"]
606    #[inline]
607    pub fn bit(self, value: bool) -> &'a mut W {
608        const MASK: bool = true;
609        const OFFSET: u8 = 6;
610        self.w.bits &= !((MASK as u32) << OFFSET);
611        self.w.bits |= ((value & MASK) as u32) << OFFSET;
612        self.w
613    }
614}
615#[doc = r" Proxy"]
616pub struct _BS5W<'a> {
617    w: &'a mut W,
618}
619impl<'a> _BS5W<'a> {
620    #[doc = r" Sets the field bit"]
621    pub fn set_bit(self) -> &'a mut W {
622        self.bit(true)
623    }
624    #[doc = r" Clears the field bit"]
625    pub fn clear_bit(self) -> &'a mut W {
626        self.bit(false)
627    }
628    #[doc = r" Writes raw bits to the field"]
629    #[inline]
630    pub fn bit(self, value: bool) -> &'a mut W {
631        const MASK: bool = true;
632        const OFFSET: u8 = 5;
633        self.w.bits &= !((MASK as u32) << OFFSET);
634        self.w.bits |= ((value & MASK) as u32) << OFFSET;
635        self.w
636    }
637}
638#[doc = r" Proxy"]
639pub struct _BS4W<'a> {
640    w: &'a mut W,
641}
642impl<'a> _BS4W<'a> {
643    #[doc = r" Sets the field bit"]
644    pub fn set_bit(self) -> &'a mut W {
645        self.bit(true)
646    }
647    #[doc = r" Clears the field bit"]
648    pub fn clear_bit(self) -> &'a mut W {
649        self.bit(false)
650    }
651    #[doc = r" Writes raw bits to the field"]
652    #[inline]
653    pub fn bit(self, value: bool) -> &'a mut W {
654        const MASK: bool = true;
655        const OFFSET: u8 = 4;
656        self.w.bits &= !((MASK as u32) << OFFSET);
657        self.w.bits |= ((value & MASK) as u32) << OFFSET;
658        self.w
659    }
660}
661#[doc = r" Proxy"]
662pub struct _BS3W<'a> {
663    w: &'a mut W,
664}
665impl<'a> _BS3W<'a> {
666    #[doc = r" Sets the field bit"]
667    pub fn set_bit(self) -> &'a mut W {
668        self.bit(true)
669    }
670    #[doc = r" Clears the field bit"]
671    pub fn clear_bit(self) -> &'a mut W {
672        self.bit(false)
673    }
674    #[doc = r" Writes raw bits to the field"]
675    #[inline]
676    pub fn bit(self, value: bool) -> &'a mut W {
677        const MASK: bool = true;
678        const OFFSET: u8 = 3;
679        self.w.bits &= !((MASK as u32) << OFFSET);
680        self.w.bits |= ((value & MASK) as u32) << OFFSET;
681        self.w
682    }
683}
684#[doc = r" Proxy"]
685pub struct _BS2W<'a> {
686    w: &'a mut W,
687}
688impl<'a> _BS2W<'a> {
689    #[doc = r" Sets the field bit"]
690    pub fn set_bit(self) -> &'a mut W {
691        self.bit(true)
692    }
693    #[doc = r" Clears the field bit"]
694    pub fn clear_bit(self) -> &'a mut W {
695        self.bit(false)
696    }
697    #[doc = r" Writes raw bits to the field"]
698    #[inline]
699    pub fn bit(self, value: bool) -> &'a mut W {
700        const MASK: bool = true;
701        const OFFSET: u8 = 2;
702        self.w.bits &= !((MASK as u32) << OFFSET);
703        self.w.bits |= ((value & MASK) as u32) << OFFSET;
704        self.w
705    }
706}
707#[doc = r" Proxy"]
708pub struct _BS1W<'a> {
709    w: &'a mut W,
710}
711impl<'a> _BS1W<'a> {
712    #[doc = r" Sets the field bit"]
713    pub fn set_bit(self) -> &'a mut W {
714        self.bit(true)
715    }
716    #[doc = r" Clears the field bit"]
717    pub fn clear_bit(self) -> &'a mut W {
718        self.bit(false)
719    }
720    #[doc = r" Writes raw bits to the field"]
721    #[inline]
722    pub fn bit(self, value: bool) -> &'a mut W {
723        const MASK: bool = true;
724        const OFFSET: u8 = 1;
725        self.w.bits &= !((MASK as u32) << OFFSET);
726        self.w.bits |= ((value & MASK) as u32) << OFFSET;
727        self.w
728    }
729}
730#[doc = r" Proxy"]
731pub struct _BS0W<'a> {
732    w: &'a mut W,
733}
734impl<'a> _BS0W<'a> {
735    #[doc = r" Sets the field bit"]
736    pub fn set_bit(self) -> &'a mut W {
737        self.bit(true)
738    }
739    #[doc = r" Clears the field bit"]
740    pub fn clear_bit(self) -> &'a mut W {
741        self.bit(false)
742    }
743    #[doc = r" Writes raw bits to the field"]
744    #[inline]
745    pub fn bit(self, value: bool) -> &'a mut W {
746        const MASK: bool = true;
747        const OFFSET: u8 = 0;
748        self.w.bits &= !((MASK as u32) << OFFSET);
749        self.w.bits |= ((value & MASK) as u32) << OFFSET;
750        self.w
751    }
752}
753impl W {
754    #[doc = r" Reset value of the register"]
755    #[inline]
756    pub fn reset_value() -> W {
757        W { bits: 0 }
758    }
759    #[doc = r" Writes raw bits to the register"]
760    #[inline]
761    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
762        self.bits = bits;
763        self
764    }
765    #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"]
766    #[inline]
767    pub fn br15(&mut self) -> _BR15W {
768        _BR15W { w: self }
769    }
770    #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"]
771    #[inline]
772    pub fn br14(&mut self) -> _BR14W {
773        _BR14W { w: self }
774    }
775    #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"]
776    #[inline]
777    pub fn br13(&mut self) -> _BR13W {
778        _BR13W { w: self }
779    }
780    #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"]
781    #[inline]
782    pub fn br12(&mut self) -> _BR12W {
783        _BR12W { w: self }
784    }
785    #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"]
786    #[inline]
787    pub fn br11(&mut self) -> _BR11W {
788        _BR11W { w: self }
789    }
790    #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"]
791    #[inline]
792    pub fn br10(&mut self) -> _BR10W {
793        _BR10W { w: self }
794    }
795    #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"]
796    #[inline]
797    pub fn br9(&mut self) -> _BR9W {
798        _BR9W { w: self }
799    }
800    #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"]
801    #[inline]
802    pub fn br8(&mut self) -> _BR8W {
803        _BR8W { w: self }
804    }
805    #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"]
806    #[inline]
807    pub fn br7(&mut self) -> _BR7W {
808        _BR7W { w: self }
809    }
810    #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"]
811    #[inline]
812    pub fn br6(&mut self) -> _BR6W {
813        _BR6W { w: self }
814    }
815    #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"]
816    #[inline]
817    pub fn br5(&mut self) -> _BR5W {
818        _BR5W { w: self }
819    }
820    #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"]
821    #[inline]
822    pub fn br4(&mut self) -> _BR4W {
823        _BR4W { w: self }
824    }
825    #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"]
826    #[inline]
827    pub fn br3(&mut self) -> _BR3W {
828        _BR3W { w: self }
829    }
830    #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"]
831    #[inline]
832    pub fn br2(&mut self) -> _BR2W {
833        _BR2W { w: self }
834    }
835    #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"]
836    #[inline]
837    pub fn br1(&mut self) -> _BR1W {
838        _BR1W { w: self }
839    }
840    #[doc = "Bit 16 - Port x reset bit y (y = 0..15)"]
841    #[inline]
842    pub fn br0(&mut self) -> _BR0W {
843        _BR0W { w: self }
844    }
845    #[doc = "Bit 15 - Port x set bit y (y= 0..15)"]
846    #[inline]
847    pub fn bs15(&mut self) -> _BS15W {
848        _BS15W { w: self }
849    }
850    #[doc = "Bit 14 - Port x set bit y (y= 0..15)"]
851    #[inline]
852    pub fn bs14(&mut self) -> _BS14W {
853        _BS14W { w: self }
854    }
855    #[doc = "Bit 13 - Port x set bit y (y= 0..15)"]
856    #[inline]
857    pub fn bs13(&mut self) -> _BS13W {
858        _BS13W { w: self }
859    }
860    #[doc = "Bit 12 - Port x set bit y (y= 0..15)"]
861    #[inline]
862    pub fn bs12(&mut self) -> _BS12W {
863        _BS12W { w: self }
864    }
865    #[doc = "Bit 11 - Port x set bit y (y= 0..15)"]
866    #[inline]
867    pub fn bs11(&mut self) -> _BS11W {
868        _BS11W { w: self }
869    }
870    #[doc = "Bit 10 - Port x set bit y (y= 0..15)"]
871    #[inline]
872    pub fn bs10(&mut self) -> _BS10W {
873        _BS10W { w: self }
874    }
875    #[doc = "Bit 9 - Port x set bit y (y= 0..15)"]
876    #[inline]
877    pub fn bs9(&mut self) -> _BS9W {
878        _BS9W { w: self }
879    }
880    #[doc = "Bit 8 - Port x set bit y (y= 0..15)"]
881    #[inline]
882    pub fn bs8(&mut self) -> _BS8W {
883        _BS8W { w: self }
884    }
885    #[doc = "Bit 7 - Port x set bit y (y= 0..15)"]
886    #[inline]
887    pub fn bs7(&mut self) -> _BS7W {
888        _BS7W { w: self }
889    }
890    #[doc = "Bit 6 - Port x set bit y (y= 0..15)"]
891    #[inline]
892    pub fn bs6(&mut self) -> _BS6W {
893        _BS6W { w: self }
894    }
895    #[doc = "Bit 5 - Port x set bit y (y= 0..15)"]
896    #[inline]
897    pub fn bs5(&mut self) -> _BS5W {
898        _BS5W { w: self }
899    }
900    #[doc = "Bit 4 - Port x set bit y (y= 0..15)"]
901    #[inline]
902    pub fn bs4(&mut self) -> _BS4W {
903        _BS4W { w: self }
904    }
905    #[doc = "Bit 3 - Port x set bit y (y= 0..15)"]
906    #[inline]
907    pub fn bs3(&mut self) -> _BS3W {
908        _BS3W { w: self }
909    }
910    #[doc = "Bit 2 - Port x set bit y (y= 0..15)"]
911    #[inline]
912    pub fn bs2(&mut self) -> _BS2W {
913        _BS2W { w: self }
914    }
915    #[doc = "Bit 1 - Port x set bit y (y= 0..15)"]
916    #[inline]
917    pub fn bs1(&mut self) -> _BS1W {
918        _BS1W { w: self }
919    }
920    #[doc = "Bit 0 - Port x set bit y (y= 0..15)"]
921    #[inline]
922    pub fn bs0(&mut self) -> _BS0W {
923        _BS0W { w: self }
924    }
925}
stm32l0x1/gpiob/bsrr/mod.rs

stm32l0x1/gpiob/bsrr/
mod.rs
