stm32f429/rcc/
apb1rstr.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::APB1RSTR {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct TIM2RSTR {
47    bits: bool,
48}
49impl TIM2RSTR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct TIM3RSTR {
68    bits: bool,
69}
70impl TIM3RSTR {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct TIM4RSTR {
89    bits: bool,
90}
91impl TIM4RSTR {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bit(&self) -> bool {
95        self.bits
96    }
97    #[doc = r" Returns `true` if the bit is clear (0)"]
98    #[inline]
99    pub fn bit_is_clear(&self) -> bool {
100        !self.bit()
101    }
102    #[doc = r" Returns `true` if the bit is set (1)"]
103    #[inline]
104    pub fn bit_is_set(&self) -> bool {
105        self.bit()
106    }
107}
108#[doc = r" Value of the field"]
109pub struct TIM5RSTR {
110    bits: bool,
111}
112impl TIM5RSTR {
113    #[doc = r" Value of the field as raw bits"]
114    #[inline]
115    pub fn bit(&self) -> bool {
116        self.bits
117    }
118    #[doc = r" Returns `true` if the bit is clear (0)"]
119    #[inline]
120    pub fn bit_is_clear(&self) -> bool {
121        !self.bit()
122    }
123    #[doc = r" Returns `true` if the bit is set (1)"]
124    #[inline]
125    pub fn bit_is_set(&self) -> bool {
126        self.bit()
127    }
128}
129#[doc = r" Value of the field"]
130pub struct TIM6RSTR {
131    bits: bool,
132}
133impl TIM6RSTR {
134    #[doc = r" Value of the field as raw bits"]
135    #[inline]
136    pub fn bit(&self) -> bool {
137        self.bits
138    }
139    #[doc = r" Returns `true` if the bit is clear (0)"]
140    #[inline]
141    pub fn bit_is_clear(&self) -> bool {
142        !self.bit()
143    }
144    #[doc = r" Returns `true` if the bit is set (1)"]
145    #[inline]
146    pub fn bit_is_set(&self) -> bool {
147        self.bit()
148    }
149}
150#[doc = r" Value of the field"]
151pub struct TIM7RSTR {
152    bits: bool,
153}
154impl TIM7RSTR {
155    #[doc = r" Value of the field as raw bits"]
156    #[inline]
157    pub fn bit(&self) -> bool {
158        self.bits
159    }
160    #[doc = r" Returns `true` if the bit is clear (0)"]
161    #[inline]
162    pub fn bit_is_clear(&self) -> bool {
163        !self.bit()
164    }
165    #[doc = r" Returns `true` if the bit is set (1)"]
166    #[inline]
167    pub fn bit_is_set(&self) -> bool {
168        self.bit()
169    }
170}
171#[doc = r" Value of the field"]
172pub struct TIM12RSTR {
173    bits: bool,
174}
175impl TIM12RSTR {
176    #[doc = r" Value of the field as raw bits"]
177    #[inline]
178    pub fn bit(&self) -> bool {
179        self.bits
180    }
181    #[doc = r" Returns `true` if the bit is clear (0)"]
182    #[inline]
183    pub fn bit_is_clear(&self) -> bool {
184        !self.bit()
185    }
186    #[doc = r" Returns `true` if the bit is set (1)"]
187    #[inline]
188    pub fn bit_is_set(&self) -> bool {
189        self.bit()
190    }
191}
192#[doc = r" Value of the field"]
193pub struct TIM13RSTR {
194    bits: bool,
195}
196impl TIM13RSTR {
197    #[doc = r" Value of the field as raw bits"]
198    #[inline]
199    pub fn bit(&self) -> bool {
200        self.bits
201    }
202    #[doc = r" Returns `true` if the bit is clear (0)"]
203    #[inline]
204    pub fn bit_is_clear(&self) -> bool {
205        !self.bit()
206    }
207    #[doc = r" Returns `true` if the bit is set (1)"]
208    #[inline]
209    pub fn bit_is_set(&self) -> bool {
210        self.bit()
211    }
212}
213#[doc = r" Value of the field"]
214pub struct TIM14RSTR {
215    bits: bool,
216}
217impl TIM14RSTR {
218    #[doc = r" Value of the field as raw bits"]
219    #[inline]
220    pub fn bit(&self) -> bool {
221        self.bits
222    }
223    #[doc = r" Returns `true` if the bit is clear (0)"]
224    #[inline]
225    pub fn bit_is_clear(&self) -> bool {
226        !self.bit()
227    }
228    #[doc = r" Returns `true` if the bit is set (1)"]
229    #[inline]
230    pub fn bit_is_set(&self) -> bool {
231        self.bit()
232    }
233}
234#[doc = r" Value of the field"]
235pub struct WWDGRSTR {
236    bits: bool,
237}
238impl WWDGRSTR {
239    #[doc = r" Value of the field as raw bits"]
240    #[inline]
241    pub fn bit(&self) -> bool {
242        self.bits
243    }
244    #[doc = r" Returns `true` if the bit is clear (0)"]
245    #[inline]
246    pub fn bit_is_clear(&self) -> bool {
247        !self.bit()
248    }
249    #[doc = r" Returns `true` if the bit is set (1)"]
250    #[inline]
251    pub fn bit_is_set(&self) -> bool {
252        self.bit()
253    }
254}
255#[doc = r" Value of the field"]
256pub struct SPI2RSTR {
257    bits: bool,
258}
259impl SPI2RSTR {
260    #[doc = r" Value of the field as raw bits"]
261    #[inline]
262    pub fn bit(&self) -> bool {
263        self.bits
264    }
265    #[doc = r" Returns `true` if the bit is clear (0)"]
266    #[inline]
267    pub fn bit_is_clear(&self) -> bool {
268        !self.bit()
269    }
270    #[doc = r" Returns `true` if the bit is set (1)"]
271    #[inline]
272    pub fn bit_is_set(&self) -> bool {
273        self.bit()
274    }
275}
276#[doc = r" Value of the field"]
277pub struct SPI3RSTR {
278    bits: bool,
279}
280impl SPI3RSTR {
281    #[doc = r" Value of the field as raw bits"]
282    #[inline]
283    pub fn bit(&self) -> bool {
284        self.bits
285    }
286    #[doc = r" Returns `true` if the bit is clear (0)"]
287    #[inline]
288    pub fn bit_is_clear(&self) -> bool {
289        !self.bit()
290    }
291    #[doc = r" Returns `true` if the bit is set (1)"]
292    #[inline]
293    pub fn bit_is_set(&self) -> bool {
294        self.bit()
295    }
296}
297#[doc = r" Value of the field"]
298pub struct UART2RSTR {
299    bits: bool,
300}
301impl UART2RSTR {
302    #[doc = r" Value of the field as raw bits"]
303    #[inline]
304    pub fn bit(&self) -> bool {
305        self.bits
306    }
307    #[doc = r" Returns `true` if the bit is clear (0)"]
308    #[inline]
309    pub fn bit_is_clear(&self) -> bool {
310        !self.bit()
311    }
312    #[doc = r" Returns `true` if the bit is set (1)"]
313    #[inline]
314    pub fn bit_is_set(&self) -> bool {
315        self.bit()
316    }
317}
318#[doc = r" Value of the field"]
319pub struct UART3RSTR {
320    bits: bool,
321}
322impl UART3RSTR {
323    #[doc = r" Value of the field as raw bits"]
324    #[inline]
325    pub fn bit(&self) -> bool {
326        self.bits
327    }
328    #[doc = r" Returns `true` if the bit is clear (0)"]
329    #[inline]
330    pub fn bit_is_clear(&self) -> bool {
331        !self.bit()
332    }
333    #[doc = r" Returns `true` if the bit is set (1)"]
334    #[inline]
335    pub fn bit_is_set(&self) -> bool {
336        self.bit()
337    }
338}
339#[doc = r" Value of the field"]
340pub struct UART4RSTR {
341    bits: bool,
342}
343impl UART4RSTR {
344    #[doc = r" Value of the field as raw bits"]
345    #[inline]
346    pub fn bit(&self) -> bool {
347        self.bits
348    }
349    #[doc = r" Returns `true` if the bit is clear (0)"]
350    #[inline]
351    pub fn bit_is_clear(&self) -> bool {
352        !self.bit()
353    }
354    #[doc = r" Returns `true` if the bit is set (1)"]
355    #[inline]
356    pub fn bit_is_set(&self) -> bool {
357        self.bit()
358    }
359}
360#[doc = r" Value of the field"]
361pub struct UART5RSTR {
362    bits: bool,
363}
364impl UART5RSTR {
365    #[doc = r" Value of the field as raw bits"]
366    #[inline]
367    pub fn bit(&self) -> bool {
368        self.bits
369    }
370    #[doc = r" Returns `true` if the bit is clear (0)"]
371    #[inline]
372    pub fn bit_is_clear(&self) -> bool {
373        !self.bit()
374    }
375    #[doc = r" Returns `true` if the bit is set (1)"]
376    #[inline]
377    pub fn bit_is_set(&self) -> bool {
378        self.bit()
379    }
380}
381#[doc = r" Value of the field"]
382pub struct I2C1RSTR {
383    bits: bool,
384}
385impl I2C1RSTR {
386    #[doc = r" Value of the field as raw bits"]
387    #[inline]
388    pub fn bit(&self) -> bool {
389        self.bits
390    }
391    #[doc = r" Returns `true` if the bit is clear (0)"]
392    #[inline]
393    pub fn bit_is_clear(&self) -> bool {
394        !self.bit()
395    }
396    #[doc = r" Returns `true` if the bit is set (1)"]
397    #[inline]
398    pub fn bit_is_set(&self) -> bool {
399        self.bit()
400    }
401}
402#[doc = r" Value of the field"]
403pub struct I2C2RSTR {
404    bits: bool,
405}
406impl I2C2RSTR {
407    #[doc = r" Value of the field as raw bits"]
408    #[inline]
409    pub fn bit(&self) -> bool {
410        self.bits
411    }
412    #[doc = r" Returns `true` if the bit is clear (0)"]
413    #[inline]
414    pub fn bit_is_clear(&self) -> bool {
415        !self.bit()
416    }
417    #[doc = r" Returns `true` if the bit is set (1)"]
418    #[inline]
419    pub fn bit_is_set(&self) -> bool {
420        self.bit()
421    }
422}
423#[doc = r" Value of the field"]
424pub struct I2C3RSTR {
425    bits: bool,
426}
427impl I2C3RSTR {
428    #[doc = r" Value of the field as raw bits"]
429    #[inline]
430    pub fn bit(&self) -> bool {
431        self.bits
432    }
433    #[doc = r" Returns `true` if the bit is clear (0)"]
434    #[inline]
435    pub fn bit_is_clear(&self) -> bool {
436        !self.bit()
437    }
438    #[doc = r" Returns `true` if the bit is set (1)"]
439    #[inline]
440    pub fn bit_is_set(&self) -> bool {
441        self.bit()
442    }
443}
444#[doc = r" Value of the field"]
445pub struct CAN1RSTR {
446    bits: bool,
447}
448impl CAN1RSTR {
449    #[doc = r" Value of the field as raw bits"]
450    #[inline]
451    pub fn bit(&self) -> bool {
452        self.bits
453    }
454    #[doc = r" Returns `true` if the bit is clear (0)"]
455    #[inline]
456    pub fn bit_is_clear(&self) -> bool {
457        !self.bit()
458    }
459    #[doc = r" Returns `true` if the bit is set (1)"]
460    #[inline]
461    pub fn bit_is_set(&self) -> bool {
462        self.bit()
463    }
464}
465#[doc = r" Value of the field"]
466pub struct CAN2RSTR {
467    bits: bool,
468}
469impl CAN2RSTR {
470    #[doc = r" Value of the field as raw bits"]
471    #[inline]
472    pub fn bit(&self) -> bool {
473        self.bits
474    }
475    #[doc = r" Returns `true` if the bit is clear (0)"]
476    #[inline]
477    pub fn bit_is_clear(&self) -> bool {
478        !self.bit()
479    }
480    #[doc = r" Returns `true` if the bit is set (1)"]
481    #[inline]
482    pub fn bit_is_set(&self) -> bool {
483        self.bit()
484    }
485}
486#[doc = r" Value of the field"]
487pub struct PWRRSTR {
488    bits: bool,
489}
490impl PWRRSTR {
491    #[doc = r" Value of the field as raw bits"]
492    #[inline]
493    pub fn bit(&self) -> bool {
494        self.bits
495    }
496    #[doc = r" Returns `true` if the bit is clear (0)"]
497    #[inline]
498    pub fn bit_is_clear(&self) -> bool {
499        !self.bit()
500    }
501    #[doc = r" Returns `true` if the bit is set (1)"]
502    #[inline]
503    pub fn bit_is_set(&self) -> bool {
504        self.bit()
505    }
506}
507#[doc = r" Value of the field"]
508pub struct DACRSTR {
509    bits: bool,
510}
511impl DACRSTR {
512    #[doc = r" Value of the field as raw bits"]
513    #[inline]
514    pub fn bit(&self) -> bool {
515        self.bits
516    }
517    #[doc = r" Returns `true` if the bit is clear (0)"]
518    #[inline]
519    pub fn bit_is_clear(&self) -> bool {
520        !self.bit()
521    }
522    #[doc = r" Returns `true` if the bit is set (1)"]
523    #[inline]
524    pub fn bit_is_set(&self) -> bool {
525        self.bit()
526    }
527}
528#[doc = r" Value of the field"]
529pub struct UART7RSTR {
530    bits: bool,
531}
532impl UART7RSTR {
533    #[doc = r" Value of the field as raw bits"]
534    #[inline]
535    pub fn bit(&self) -> bool {
536        self.bits
537    }
538    #[doc = r" Returns `true` if the bit is clear (0)"]
539    #[inline]
540    pub fn bit_is_clear(&self) -> bool {
541        !self.bit()
542    }
543    #[doc = r" Returns `true` if the bit is set (1)"]
544    #[inline]
545    pub fn bit_is_set(&self) -> bool {
546        self.bit()
547    }
548}
549#[doc = r" Value of the field"]
550pub struct UART8RSTR {
551    bits: bool,
552}
553impl UART8RSTR {
554    #[doc = r" Value of the field as raw bits"]
555    #[inline]
556    pub fn bit(&self) -> bool {
557        self.bits
558    }
559    #[doc = r" Returns `true` if the bit is clear (0)"]
560    #[inline]
561    pub fn bit_is_clear(&self) -> bool {
562        !self.bit()
563    }
564    #[doc = r" Returns `true` if the bit is set (1)"]
565    #[inline]
566    pub fn bit_is_set(&self) -> bool {
567        self.bit()
568    }
569}
570#[doc = r" Proxy"]
571pub struct _TIM2RSTW<'a> {
572    w: &'a mut W,
573}
574impl<'a> _TIM2RSTW<'a> {
575    #[doc = r" Sets the field bit"]
576    pub fn set_bit(self) -> &'a mut W {
577        self.bit(true)
578    }
579    #[doc = r" Clears the field bit"]
580    pub fn clear_bit(self) -> &'a mut W {
581        self.bit(false)
582    }
583    #[doc = r" Writes raw bits to the field"]
584    #[inline]
585    pub fn bit(self, value: bool) -> &'a mut W {
586        const MASK: bool = true;
587        const OFFSET: u8 = 0;
588        self.w.bits &= !((MASK as u32) << OFFSET);
589        self.w.bits |= ((value & MASK) as u32) << OFFSET;
590        self.w
591    }
592}
593#[doc = r" Proxy"]
594pub struct _TIM3RSTW<'a> {
595    w: &'a mut W,
596}
597impl<'a> _TIM3RSTW<'a> {
598    #[doc = r" Sets the field bit"]
599    pub fn set_bit(self) -> &'a mut W {
600        self.bit(true)
601    }
602    #[doc = r" Clears the field bit"]
603    pub fn clear_bit(self) -> &'a mut W {
604        self.bit(false)
605    }
606    #[doc = r" Writes raw bits to the field"]
607    #[inline]
608    pub fn bit(self, value: bool) -> &'a mut W {
609        const MASK: bool = true;
610        const OFFSET: u8 = 1;
611        self.w.bits &= !((MASK as u32) << OFFSET);
612        self.w.bits |= ((value & MASK) as u32) << OFFSET;
613        self.w
614    }
615}
616#[doc = r" Proxy"]
617pub struct _TIM4RSTW<'a> {
618    w: &'a mut W,
619}
620impl<'a> _TIM4RSTW<'a> {
621    #[doc = r" Sets the field bit"]
622    pub fn set_bit(self) -> &'a mut W {
623        self.bit(true)
624    }
625    #[doc = r" Clears the field bit"]
626    pub fn clear_bit(self) -> &'a mut W {
627        self.bit(false)
628    }
629    #[doc = r" Writes raw bits to the field"]
630    #[inline]
631    pub fn bit(self, value: bool) -> &'a mut W {
632        const MASK: bool = true;
633        const OFFSET: u8 = 2;
634        self.w.bits &= !((MASK as u32) << OFFSET);
635        self.w.bits |= ((value & MASK) as u32) << OFFSET;
636        self.w
637    }
638}
639#[doc = r" Proxy"]
640pub struct _TIM5RSTW<'a> {
641    w: &'a mut W,
642}
643impl<'a> _TIM5RSTW<'a> {
644    #[doc = r" Sets the field bit"]
645    pub fn set_bit(self) -> &'a mut W {
646        self.bit(true)
647    }
648    #[doc = r" Clears the field bit"]
649    pub fn clear_bit(self) -> &'a mut W {
650        self.bit(false)
651    }
652    #[doc = r" Writes raw bits to the field"]
653    #[inline]
654    pub fn bit(self, value: bool) -> &'a mut W {
655        const MASK: bool = true;
656        const OFFSET: u8 = 3;
657        self.w.bits &= !((MASK as u32) << OFFSET);
658        self.w.bits |= ((value & MASK) as u32) << OFFSET;
659        self.w
660    }
661}
662#[doc = r" Proxy"]
663pub struct _TIM6RSTW<'a> {
664    w: &'a mut W,
665}
666impl<'a> _TIM6RSTW<'a> {
667    #[doc = r" Sets the field bit"]
668    pub fn set_bit(self) -> &'a mut W {
669        self.bit(true)
670    }
671    #[doc = r" Clears the field bit"]
672    pub fn clear_bit(self) -> &'a mut W {
673        self.bit(false)
674    }
675    #[doc = r" Writes raw bits to the field"]
676    #[inline]
677    pub fn bit(self, value: bool) -> &'a mut W {
678        const MASK: bool = true;
679        const OFFSET: u8 = 4;
680        self.w.bits &= !((MASK as u32) << OFFSET);
681        self.w.bits |= ((value & MASK) as u32) << OFFSET;
682        self.w
683    }
684}
685#[doc = r" Proxy"]
686pub struct _TIM7RSTW<'a> {
687    w: &'a mut W,
688}
689impl<'a> _TIM7RSTW<'a> {
690    #[doc = r" Sets the field bit"]
691    pub fn set_bit(self) -> &'a mut W {
692        self.bit(true)
693    }
694    #[doc = r" Clears the field bit"]
695    pub fn clear_bit(self) -> &'a mut W {
696        self.bit(false)
697    }
698    #[doc = r" Writes raw bits to the field"]
699    #[inline]
700    pub fn bit(self, value: bool) -> &'a mut W {
701        const MASK: bool = true;
702        const OFFSET: u8 = 5;
703        self.w.bits &= !((MASK as u32) << OFFSET);
704        self.w.bits |= ((value & MASK) as u32) << OFFSET;
705        self.w
706    }
707}
708#[doc = r" Proxy"]
709pub struct _TIM12RSTW<'a> {
710    w: &'a mut W,
711}
712impl<'a> _TIM12RSTW<'a> {
713    #[doc = r" Sets the field bit"]
714    pub fn set_bit(self) -> &'a mut W {
715        self.bit(true)
716    }
717    #[doc = r" Clears the field bit"]
718    pub fn clear_bit(self) -> &'a mut W {
719        self.bit(false)
720    }
721    #[doc = r" Writes raw bits to the field"]
722    #[inline]
723    pub fn bit(self, value: bool) -> &'a mut W {
724        const MASK: bool = true;
725        const OFFSET: u8 = 6;
726        self.w.bits &= !((MASK as u32) << OFFSET);
727        self.w.bits |= ((value & MASK) as u32) << OFFSET;
728        self.w
729    }
730}
731#[doc = r" Proxy"]
732pub struct _TIM13RSTW<'a> {
733    w: &'a mut W,
734}
735impl<'a> _TIM13RSTW<'a> {
736    #[doc = r" Sets the field bit"]
737    pub fn set_bit(self) -> &'a mut W {
738        self.bit(true)
739    }
740    #[doc = r" Clears the field bit"]
741    pub fn clear_bit(self) -> &'a mut W {
742        self.bit(false)
743    }
744    #[doc = r" Writes raw bits to the field"]
745    #[inline]
746    pub fn bit(self, value: bool) -> &'a mut W {
747        const MASK: bool = true;
748        const OFFSET: u8 = 7;
749        self.w.bits &= !((MASK as u32) << OFFSET);
750        self.w.bits |= ((value & MASK) as u32) << OFFSET;
751        self.w
752    }
753}
754#[doc = r" Proxy"]
755pub struct _TIM14RSTW<'a> {
756    w: &'a mut W,
757}
758impl<'a> _TIM14RSTW<'a> {
759    #[doc = r" Sets the field bit"]
760    pub fn set_bit(self) -> &'a mut W {
761        self.bit(true)
762    }
763    #[doc = r" Clears the field bit"]
764    pub fn clear_bit(self) -> &'a mut W {
765        self.bit(false)
766    }
767    #[doc = r" Writes raw bits to the field"]
768    #[inline]
769    pub fn bit(self, value: bool) -> &'a mut W {
770        const MASK: bool = true;
771        const OFFSET: u8 = 8;
772        self.w.bits &= !((MASK as u32) << OFFSET);
773        self.w.bits |= ((value & MASK) as u32) << OFFSET;
774        self.w
775    }
776}
777#[doc = r" Proxy"]
778pub struct _WWDGRSTW<'a> {
779    w: &'a mut W,
780}
781impl<'a> _WWDGRSTW<'a> {
782    #[doc = r" Sets the field bit"]
783    pub fn set_bit(self) -> &'a mut W {
784        self.bit(true)
785    }
786    #[doc = r" Clears the field bit"]
787    pub fn clear_bit(self) -> &'a mut W {
788        self.bit(false)
789    }
790    #[doc = r" Writes raw bits to the field"]
791    #[inline]
792    pub fn bit(self, value: bool) -> &'a mut W {
793        const MASK: bool = true;
794        const OFFSET: u8 = 11;
795        self.w.bits &= !((MASK as u32) << OFFSET);
796        self.w.bits |= ((value & MASK) as u32) << OFFSET;
797        self.w
798    }
799}
800#[doc = r" Proxy"]
801pub struct _SPI2RSTW<'a> {
802    w: &'a mut W,
803}
804impl<'a> _SPI2RSTW<'a> {
805    #[doc = r" Sets the field bit"]
806    pub fn set_bit(self) -> &'a mut W {
807        self.bit(true)
808    }
809    #[doc = r" Clears the field bit"]
810    pub fn clear_bit(self) -> &'a mut W {
811        self.bit(false)
812    }
813    #[doc = r" Writes raw bits to the field"]
814    #[inline]
815    pub fn bit(self, value: bool) -> &'a mut W {
816        const MASK: bool = true;
817        const OFFSET: u8 = 14;
818        self.w.bits &= !((MASK as u32) << OFFSET);
819        self.w.bits |= ((value & MASK) as u32) << OFFSET;
820        self.w
821    }
822}
823#[doc = r" Proxy"]
824pub struct _SPI3RSTW<'a> {
825    w: &'a mut W,
826}
827impl<'a> _SPI3RSTW<'a> {
828    #[doc = r" Sets the field bit"]
829    pub fn set_bit(self) -> &'a mut W {
830        self.bit(true)
831    }
832    #[doc = r" Clears the field bit"]
833    pub fn clear_bit(self) -> &'a mut W {
834        self.bit(false)
835    }
836    #[doc = r" Writes raw bits to the field"]
837    #[inline]
838    pub fn bit(self, value: bool) -> &'a mut W {
839        const MASK: bool = true;
840        const OFFSET: u8 = 15;
841        self.w.bits &= !((MASK as u32) << OFFSET);
842        self.w.bits |= ((value & MASK) as u32) << OFFSET;
843        self.w
844    }
845}
846#[doc = r" Proxy"]
847pub struct _UART2RSTW<'a> {
848    w: &'a mut W,
849}
850impl<'a> _UART2RSTW<'a> {
851    #[doc = r" Sets the field bit"]
852    pub fn set_bit(self) -> &'a mut W {
853        self.bit(true)
854    }
855    #[doc = r" Clears the field bit"]
856    pub fn clear_bit(self) -> &'a mut W {
857        self.bit(false)
858    }
859    #[doc = r" Writes raw bits to the field"]
860    #[inline]
861    pub fn bit(self, value: bool) -> &'a mut W {
862        const MASK: bool = true;
863        const OFFSET: u8 = 17;
864        self.w.bits &= !((MASK as u32) << OFFSET);
865        self.w.bits |= ((value & MASK) as u32) << OFFSET;
866        self.w
867    }
868}
869#[doc = r" Proxy"]
870pub struct _UART3RSTW<'a> {
871    w: &'a mut W,
872}
873impl<'a> _UART3RSTW<'a> {
874    #[doc = r" Sets the field bit"]
875    pub fn set_bit(self) -> &'a mut W {
876        self.bit(true)
877    }
878    #[doc = r" Clears the field bit"]
879    pub fn clear_bit(self) -> &'a mut W {
880        self.bit(false)
881    }
882    #[doc = r" Writes raw bits to the field"]
883    #[inline]
884    pub fn bit(self, value: bool) -> &'a mut W {
885        const MASK: bool = true;
886        const OFFSET: u8 = 18;
887        self.w.bits &= !((MASK as u32) << OFFSET);
888        self.w.bits |= ((value & MASK) as u32) << OFFSET;
889        self.w
890    }
891}
892#[doc = r" Proxy"]
893pub struct _UART4RSTW<'a> {
894    w: &'a mut W,
895}
896impl<'a> _UART4RSTW<'a> {
897    #[doc = r" Sets the field bit"]
898    pub fn set_bit(self) -> &'a mut W {
899        self.bit(true)
900    }
901    #[doc = r" Clears the field bit"]
902    pub fn clear_bit(self) -> &'a mut W {
903        self.bit(false)
904    }
905    #[doc = r" Writes raw bits to the field"]
906    #[inline]
907    pub fn bit(self, value: bool) -> &'a mut W {
908        const MASK: bool = true;
909        const OFFSET: u8 = 19;
910        self.w.bits &= !((MASK as u32) << OFFSET);
911        self.w.bits |= ((value & MASK) as u32) << OFFSET;
912        self.w
913    }
914}
915#[doc = r" Proxy"]
916pub struct _UART5RSTW<'a> {
917    w: &'a mut W,
918}
919impl<'a> _UART5RSTW<'a> {
920    #[doc = r" Sets the field bit"]
921    pub fn set_bit(self) -> &'a mut W {
922        self.bit(true)
923    }
924    #[doc = r" Clears the field bit"]
925    pub fn clear_bit(self) -> &'a mut W {
926        self.bit(false)
927    }
928    #[doc = r" Writes raw bits to the field"]
929    #[inline]
930    pub fn bit(self, value: bool) -> &'a mut W {
931        const MASK: bool = true;
932        const OFFSET: u8 = 20;
933        self.w.bits &= !((MASK as u32) << OFFSET);
934        self.w.bits |= ((value & MASK) as u32) << OFFSET;
935        self.w
936    }
937}
938#[doc = r" Proxy"]
939pub struct _I2C1RSTW<'a> {
940    w: &'a mut W,
941}
942impl<'a> _I2C1RSTW<'a> {
943    #[doc = r" Sets the field bit"]
944    pub fn set_bit(self) -> &'a mut W {
945        self.bit(true)
946    }
947    #[doc = r" Clears the field bit"]
948    pub fn clear_bit(self) -> &'a mut W {
949        self.bit(false)
950    }
951    #[doc = r" Writes raw bits to the field"]
952    #[inline]
953    pub fn bit(self, value: bool) -> &'a mut W {
954        const MASK: bool = true;
955        const OFFSET: u8 = 21;
956        self.w.bits &= !((MASK as u32) << OFFSET);
957        self.w.bits |= ((value & MASK) as u32) << OFFSET;
958        self.w
959    }
960}
961#[doc = r" Proxy"]
962pub struct _I2C2RSTW<'a> {
963    w: &'a mut W,
964}
965impl<'a> _I2C2RSTW<'a> {
966    #[doc = r" Sets the field bit"]
967    pub fn set_bit(self) -> &'a mut W {
968        self.bit(true)
969    }
970    #[doc = r" Clears the field bit"]
971    pub fn clear_bit(self) -> &'a mut W {
972        self.bit(false)
973    }
974    #[doc = r" Writes raw bits to the field"]
975    #[inline]
976    pub fn bit(self, value: bool) -> &'a mut W {
977        const MASK: bool = true;
978        const OFFSET: u8 = 22;
979        self.w.bits &= !((MASK as u32) << OFFSET);
980        self.w.bits |= ((value & MASK) as u32) << OFFSET;
981        self.w
982    }
983}
984#[doc = r" Proxy"]
985pub struct _I2C3RSTW<'a> {
986    w: &'a mut W,
987}
988impl<'a> _I2C3RSTW<'a> {
989    #[doc = r" Sets the field bit"]
990    pub fn set_bit(self) -> &'a mut W {
991        self.bit(true)
992    }
993    #[doc = r" Clears the field bit"]
994    pub fn clear_bit(self) -> &'a mut W {
995        self.bit(false)
996    }
997    #[doc = r" Writes raw bits to the field"]
998    #[inline]
999    pub fn bit(self, value: bool) -> &'a mut W {
1000        const MASK: bool = true;
1001        const OFFSET: u8 = 23;
1002        self.w.bits &= !((MASK as u32) << OFFSET);
1003        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1004        self.w
1005    }
1006}
1007#[doc = r" Proxy"]
1008pub struct _CAN1RSTW<'a> {
1009    w: &'a mut W,
1010}
1011impl<'a> _CAN1RSTW<'a> {
1012    #[doc = r" Sets the field bit"]
1013    pub fn set_bit(self) -> &'a mut W {
1014        self.bit(true)
1015    }
1016    #[doc = r" Clears the field bit"]
1017    pub fn clear_bit(self) -> &'a mut W {
1018        self.bit(false)
1019    }
1020    #[doc = r" Writes raw bits to the field"]
1021    #[inline]
1022    pub fn bit(self, value: bool) -> &'a mut W {
1023        const MASK: bool = true;
1024        const OFFSET: u8 = 25;
1025        self.w.bits &= !((MASK as u32) << OFFSET);
1026        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1027        self.w
1028    }
1029}
1030#[doc = r" Proxy"]
1031pub struct _CAN2RSTW<'a> {
1032    w: &'a mut W,
1033}
1034impl<'a> _CAN2RSTW<'a> {
1035    #[doc = r" Sets the field bit"]
1036    pub fn set_bit(self) -> &'a mut W {
1037        self.bit(true)
1038    }
1039    #[doc = r" Clears the field bit"]
1040    pub fn clear_bit(self) -> &'a mut W {
1041        self.bit(false)
1042    }
1043    #[doc = r" Writes raw bits to the field"]
1044    #[inline]
1045    pub fn bit(self, value: bool) -> &'a mut W {
1046        const MASK: bool = true;
1047        const OFFSET: u8 = 26;
1048        self.w.bits &= !((MASK as u32) << OFFSET);
1049        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1050        self.w
1051    }
1052}
1053#[doc = r" Proxy"]
1054pub struct _PWRRSTW<'a> {
1055    w: &'a mut W,
1056}
1057impl<'a> _PWRRSTW<'a> {
1058    #[doc = r" Sets the field bit"]
1059    pub fn set_bit(self) -> &'a mut W {
1060        self.bit(true)
1061    }
1062    #[doc = r" Clears the field bit"]
1063    pub fn clear_bit(self) -> &'a mut W {
1064        self.bit(false)
1065    }
1066    #[doc = r" Writes raw bits to the field"]
1067    #[inline]
1068    pub fn bit(self, value: bool) -> &'a mut W {
1069        const MASK: bool = true;
1070        const OFFSET: u8 = 28;
1071        self.w.bits &= !((MASK as u32) << OFFSET);
1072        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1073        self.w
1074    }
1075}
1076#[doc = r" Proxy"]
1077pub struct _DACRSTW<'a> {
1078    w: &'a mut W,
1079}
1080impl<'a> _DACRSTW<'a> {
1081    #[doc = r" Sets the field bit"]
1082    pub fn set_bit(self) -> &'a mut W {
1083        self.bit(true)
1084    }
1085    #[doc = r" Clears the field bit"]
1086    pub fn clear_bit(self) -> &'a mut W {
1087        self.bit(false)
1088    }
1089    #[doc = r" Writes raw bits to the field"]
1090    #[inline]
1091    pub fn bit(self, value: bool) -> &'a mut W {
1092        const MASK: bool = true;
1093        const OFFSET: u8 = 29;
1094        self.w.bits &= !((MASK as u32) << OFFSET);
1095        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1096        self.w
1097    }
1098}
1099#[doc = r" Proxy"]
1100pub struct _UART7RSTW<'a> {
1101    w: &'a mut W,
1102}
1103impl<'a> _UART7RSTW<'a> {
1104    #[doc = r" Sets the field bit"]
1105    pub fn set_bit(self) -> &'a mut W {
1106        self.bit(true)
1107    }
1108    #[doc = r" Clears the field bit"]
1109    pub fn clear_bit(self) -> &'a mut W {
1110        self.bit(false)
1111    }
1112    #[doc = r" Writes raw bits to the field"]
1113    #[inline]
1114    pub fn bit(self, value: bool) -> &'a mut W {
1115        const MASK: bool = true;
1116        const OFFSET: u8 = 30;
1117        self.w.bits &= !((MASK as u32) << OFFSET);
1118        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1119        self.w
1120    }
1121}
1122#[doc = r" Proxy"]
1123pub struct _UART8RSTW<'a> {
1124    w: &'a mut W,
1125}
1126impl<'a> _UART8RSTW<'a> {
1127    #[doc = r" Sets the field bit"]
1128    pub fn set_bit(self) -> &'a mut W {
1129        self.bit(true)
1130    }
1131    #[doc = r" Clears the field bit"]
1132    pub fn clear_bit(self) -> &'a mut W {
1133        self.bit(false)
1134    }
1135    #[doc = r" Writes raw bits to the field"]
1136    #[inline]
1137    pub fn bit(self, value: bool) -> &'a mut W {
1138        const MASK: bool = true;
1139        const OFFSET: u8 = 31;
1140        self.w.bits &= !((MASK as u32) << OFFSET);
1141        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1142        self.w
1143    }
1144}
1145impl R {
1146    #[doc = r" Value of the register as raw bits"]
1147    #[inline]
1148    pub fn bits(&self) -> u32 {
1149        self.bits
1150    }
1151    #[doc = "Bit 0 - TIM2 reset"]
1152    #[inline]
1153    pub fn tim2rst(&self) -> TIM2RSTR {
1154        let bits = {
1155            const MASK: bool = true;
1156            const OFFSET: u8 = 0;
1157            ((self.bits >> OFFSET) & MASK as u32) != 0
1158        };
1159        TIM2RSTR { bits }
1160    }
1161    #[doc = "Bit 1 - TIM3 reset"]
1162    #[inline]
1163    pub fn tim3rst(&self) -> TIM3RSTR {
1164        let bits = {
1165            const MASK: bool = true;
1166            const OFFSET: u8 = 1;
1167            ((self.bits >> OFFSET) & MASK as u32) != 0
1168        };
1169        TIM3RSTR { bits }
1170    }
1171    #[doc = "Bit 2 - TIM4 reset"]
1172    #[inline]
1173    pub fn tim4rst(&self) -> TIM4RSTR {
1174        let bits = {
1175            const MASK: bool = true;
1176            const OFFSET: u8 = 2;
1177            ((self.bits >> OFFSET) & MASK as u32) != 0
1178        };
1179        TIM4RSTR { bits }
1180    }
1181    #[doc = "Bit 3 - TIM5 reset"]
1182    #[inline]
1183    pub fn tim5rst(&self) -> TIM5RSTR {
1184        let bits = {
1185            const MASK: bool = true;
1186            const OFFSET: u8 = 3;
1187            ((self.bits >> OFFSET) & MASK as u32) != 0
1188        };
1189        TIM5RSTR { bits }
1190    }
1191    #[doc = "Bit 4 - TIM6 reset"]
1192    #[inline]
1193    pub fn tim6rst(&self) -> TIM6RSTR {
1194        let bits = {
1195            const MASK: bool = true;
1196            const OFFSET: u8 = 4;
1197            ((self.bits >> OFFSET) & MASK as u32) != 0
1198        };
1199        TIM6RSTR { bits }
1200    }
1201    #[doc = "Bit 5 - TIM7 reset"]
1202    #[inline]
1203    pub fn tim7rst(&self) -> TIM7RSTR {
1204        let bits = {
1205            const MASK: bool = true;
1206            const OFFSET: u8 = 5;
1207            ((self.bits >> OFFSET) & MASK as u32) != 0
1208        };
1209        TIM7RSTR { bits }
1210    }
1211    #[doc = "Bit 6 - TIM12 reset"]
1212    #[inline]
1213    pub fn tim12rst(&self) -> TIM12RSTR {
1214        let bits = {
1215            const MASK: bool = true;
1216            const OFFSET: u8 = 6;
1217            ((self.bits >> OFFSET) & MASK as u32) != 0
1218        };
1219        TIM12RSTR { bits }
1220    }
1221    #[doc = "Bit 7 - TIM13 reset"]
1222    #[inline]
1223    pub fn tim13rst(&self) -> TIM13RSTR {
1224        let bits = {
1225            const MASK: bool = true;
1226            const OFFSET: u8 = 7;
1227            ((self.bits >> OFFSET) & MASK as u32) != 0
1228        };
1229        TIM13RSTR { bits }
1230    }
1231    #[doc = "Bit 8 - TIM14 reset"]
1232    #[inline]
1233    pub fn tim14rst(&self) -> TIM14RSTR {
1234        let bits = {
1235            const MASK: bool = true;
1236            const OFFSET: u8 = 8;
1237            ((self.bits >> OFFSET) & MASK as u32) != 0
1238        };
1239        TIM14RSTR { bits }
1240    }
1241    #[doc = "Bit 11 - Window watchdog reset"]
1242    #[inline]
1243    pub fn wwdgrst(&self) -> WWDGRSTR {
1244        let bits = {
1245            const MASK: bool = true;
1246            const OFFSET: u8 = 11;
1247            ((self.bits >> OFFSET) & MASK as u32) != 0
1248        };
1249        WWDGRSTR { bits }
1250    }
1251    #[doc = "Bit 14 - SPI 2 reset"]
1252    #[inline]
1253    pub fn spi2rst(&self) -> SPI2RSTR {
1254        let bits = {
1255            const MASK: bool = true;
1256            const OFFSET: u8 = 14;
1257            ((self.bits >> OFFSET) & MASK as u32) != 0
1258        };
1259        SPI2RSTR { bits }
1260    }
1261    #[doc = "Bit 15 - SPI 3 reset"]
1262    #[inline]
1263    pub fn spi3rst(&self) -> SPI3RSTR {
1264        let bits = {
1265            const MASK: bool = true;
1266            const OFFSET: u8 = 15;
1267            ((self.bits >> OFFSET) & MASK as u32) != 0
1268        };
1269        SPI3RSTR { bits }
1270    }
1271    #[doc = "Bit 17 - USART 2 reset"]
1272    #[inline]
1273    pub fn uart2rst(&self) -> UART2RSTR {
1274        let bits = {
1275            const MASK: bool = true;
1276            const OFFSET: u8 = 17;
1277            ((self.bits >> OFFSET) & MASK as u32) != 0
1278        };
1279        UART2RSTR { bits }
1280    }
1281    #[doc = "Bit 18 - USART 3 reset"]
1282    #[inline]
1283    pub fn uart3rst(&self) -> UART3RSTR {
1284        let bits = {
1285            const MASK: bool = true;
1286            const OFFSET: u8 = 18;
1287            ((self.bits >> OFFSET) & MASK as u32) != 0
1288        };
1289        UART3RSTR { bits }
1290    }
1291    #[doc = "Bit 19 - USART 4 reset"]
1292    #[inline]
1293    pub fn uart4rst(&self) -> UART4RSTR {
1294        let bits = {
1295            const MASK: bool = true;
1296            const OFFSET: u8 = 19;
1297            ((self.bits >> OFFSET) & MASK as u32) != 0
1298        };
1299        UART4RSTR { bits }
1300    }
1301    #[doc = "Bit 20 - USART 5 reset"]
1302    #[inline]
1303    pub fn uart5rst(&self) -> UART5RSTR {
1304        let bits = {
1305            const MASK: bool = true;
1306            const OFFSET: u8 = 20;
1307            ((self.bits >> OFFSET) & MASK as u32) != 0
1308        };
1309        UART5RSTR { bits }
1310    }
1311    #[doc = "Bit 21 - I2C 1 reset"]
1312    #[inline]
1313    pub fn i2c1rst(&self) -> I2C1RSTR {
1314        let bits = {
1315            const MASK: bool = true;
1316            const OFFSET: u8 = 21;
1317            ((self.bits >> OFFSET) & MASK as u32) != 0
1318        };
1319        I2C1RSTR { bits }
1320    }
1321    #[doc = "Bit 22 - I2C 2 reset"]
1322    #[inline]
1323    pub fn i2c2rst(&self) -> I2C2RSTR {
1324        let bits = {
1325            const MASK: bool = true;
1326            const OFFSET: u8 = 22;
1327            ((self.bits >> OFFSET) & MASK as u32) != 0
1328        };
1329        I2C2RSTR { bits }
1330    }
1331    #[doc = "Bit 23 - I2C3 reset"]
1332    #[inline]
1333    pub fn i2c3rst(&self) -> I2C3RSTR {
1334        let bits = {
1335            const MASK: bool = true;
1336            const OFFSET: u8 = 23;
1337            ((self.bits >> OFFSET) & MASK as u32) != 0
1338        };
1339        I2C3RSTR { bits }
1340    }
1341    #[doc = "Bit 25 - CAN1 reset"]
1342    #[inline]
1343    pub fn can1rst(&self) -> CAN1RSTR {
1344        let bits = {
1345            const MASK: bool = true;
1346            const OFFSET: u8 = 25;
1347            ((self.bits >> OFFSET) & MASK as u32) != 0
1348        };
1349        CAN1RSTR { bits }
1350    }
1351    #[doc = "Bit 26 - CAN2 reset"]
1352    #[inline]
1353    pub fn can2rst(&self) -> CAN2RSTR {
1354        let bits = {
1355            const MASK: bool = true;
1356            const OFFSET: u8 = 26;
1357            ((self.bits >> OFFSET) & MASK as u32) != 0
1358        };
1359        CAN2RSTR { bits }
1360    }
1361    #[doc = "Bit 28 - Power interface reset"]
1362    #[inline]
1363    pub fn pwrrst(&self) -> PWRRSTR {
1364        let bits = {
1365            const MASK: bool = true;
1366            const OFFSET: u8 = 28;
1367            ((self.bits >> OFFSET) & MASK as u32) != 0
1368        };
1369        PWRRSTR { bits }
1370    }
1371    #[doc = "Bit 29 - DAC reset"]
1372    #[inline]
1373    pub fn dacrst(&self) -> DACRSTR {
1374        let bits = {
1375            const MASK: bool = true;
1376            const OFFSET: u8 = 29;
1377            ((self.bits >> OFFSET) & MASK as u32) != 0
1378        };
1379        DACRSTR { bits }
1380    }
1381    #[doc = "Bit 30 - UART 7 reset"]
1382    #[inline]
1383    pub fn uart7rst(&self) -> UART7RSTR {
1384        let bits = {
1385            const MASK: bool = true;
1386            const OFFSET: u8 = 30;
1387            ((self.bits >> OFFSET) & MASK as u32) != 0
1388        };
1389        UART7RSTR { bits }
1390    }
1391    #[doc = "Bit 31 - UART 8 reset"]
1392    #[inline]
1393    pub fn uart8rst(&self) -> UART8RSTR {
1394        let bits = {
1395            const MASK: bool = true;
1396            const OFFSET: u8 = 31;
1397            ((self.bits >> OFFSET) & MASK as u32) != 0
1398        };
1399        UART8RSTR { bits }
1400    }
1401}
1402impl W {
1403    #[doc = r" Reset value of the register"]
1404    #[inline]
1405    pub fn reset_value() -> W {
1406        W { bits: 0 }
1407    }
1408    #[doc = r" Writes raw bits to the register"]
1409    #[inline]
1410    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1411        self.bits = bits;
1412        self
1413    }
1414    #[doc = "Bit 0 - TIM2 reset"]
1415    #[inline]
1416    pub fn tim2rst(&mut self) -> _TIM2RSTW {
1417        _TIM2RSTW { w: self }
1418    }
1419    #[doc = "Bit 1 - TIM3 reset"]
1420    #[inline]
1421    pub fn tim3rst(&mut self) -> _TIM3RSTW {
1422        _TIM3RSTW { w: self }
1423    }
1424    #[doc = "Bit 2 - TIM4 reset"]
1425    #[inline]
1426    pub fn tim4rst(&mut self) -> _TIM4RSTW {
1427        _TIM4RSTW { w: self }
1428    }
1429    #[doc = "Bit 3 - TIM5 reset"]
1430    #[inline]
1431    pub fn tim5rst(&mut self) -> _TIM5RSTW {
1432        _TIM5RSTW { w: self }
1433    }
1434    #[doc = "Bit 4 - TIM6 reset"]
1435    #[inline]
1436    pub fn tim6rst(&mut self) -> _TIM6RSTW {
1437        _TIM6RSTW { w: self }
1438    }
1439    #[doc = "Bit 5 - TIM7 reset"]
1440    #[inline]
1441    pub fn tim7rst(&mut self) -> _TIM7RSTW {
1442        _TIM7RSTW { w: self }
1443    }
1444    #[doc = "Bit 6 - TIM12 reset"]
1445    #[inline]
1446    pub fn tim12rst(&mut self) -> _TIM12RSTW {
1447        _TIM12RSTW { w: self }
1448    }
1449    #[doc = "Bit 7 - TIM13 reset"]
1450    #[inline]
1451    pub fn tim13rst(&mut self) -> _TIM13RSTW {
1452        _TIM13RSTW { w: self }
1453    }
1454    #[doc = "Bit 8 - TIM14 reset"]
1455    #[inline]
1456    pub fn tim14rst(&mut self) -> _TIM14RSTW {
1457        _TIM14RSTW { w: self }
1458    }
1459    #[doc = "Bit 11 - Window watchdog reset"]
1460    #[inline]
1461    pub fn wwdgrst(&mut self) -> _WWDGRSTW {
1462        _WWDGRSTW { w: self }
1463    }
1464    #[doc = "Bit 14 - SPI 2 reset"]
1465    #[inline]
1466    pub fn spi2rst(&mut self) -> _SPI2RSTW {
1467        _SPI2RSTW { w: self }
1468    }
1469    #[doc = "Bit 15 - SPI 3 reset"]
1470    #[inline]
1471    pub fn spi3rst(&mut self) -> _SPI3RSTW {
1472        _SPI3RSTW { w: self }
1473    }
1474    #[doc = "Bit 17 - USART 2 reset"]
1475    #[inline]
1476    pub fn uart2rst(&mut self) -> _UART2RSTW {
1477        _UART2RSTW { w: self }
1478    }
1479    #[doc = "Bit 18 - USART 3 reset"]
1480    #[inline]
1481    pub fn uart3rst(&mut self) -> _UART3RSTW {
1482        _UART3RSTW { w: self }
1483    }
1484    #[doc = "Bit 19 - USART 4 reset"]
1485    #[inline]
1486    pub fn uart4rst(&mut self) -> _UART4RSTW {
1487        _UART4RSTW { w: self }
1488    }
1489    #[doc = "Bit 20 - USART 5 reset"]
1490    #[inline]
1491    pub fn uart5rst(&mut self) -> _UART5RSTW {
1492        _UART5RSTW { w: self }
1493    }
1494    #[doc = "Bit 21 - I2C 1 reset"]
1495    #[inline]
1496    pub fn i2c1rst(&mut self) -> _I2C1RSTW {
1497        _I2C1RSTW { w: self }
1498    }
1499    #[doc = "Bit 22 - I2C 2 reset"]
1500    #[inline]
1501    pub fn i2c2rst(&mut self) -> _I2C2RSTW {
1502        _I2C2RSTW { w: self }
1503    }
1504    #[doc = "Bit 23 - I2C3 reset"]
1505    #[inline]
1506    pub fn i2c3rst(&mut self) -> _I2C3RSTW {
1507        _I2C3RSTW { w: self }
1508    }
1509    #[doc = "Bit 25 - CAN1 reset"]
1510    #[inline]
1511    pub fn can1rst(&mut self) -> _CAN1RSTW {
1512        _CAN1RSTW { w: self }
1513    }
1514    #[doc = "Bit 26 - CAN2 reset"]
1515    #[inline]
1516    pub fn can2rst(&mut self) -> _CAN2RSTW {
1517        _CAN2RSTW { w: self }
1518    }
1519    #[doc = "Bit 28 - Power interface reset"]
1520    #[inline]
1521    pub fn pwrrst(&mut self) -> _PWRRSTW {
1522        _PWRRSTW { w: self }
1523    }
1524    #[doc = "Bit 29 - DAC reset"]
1525    #[inline]
1526    pub fn dacrst(&mut self) -> _DACRSTW {
1527        _DACRSTW { w: self }
1528    }
1529    #[doc = "Bit 30 - UART 7 reset"]
1530    #[inline]
1531    pub fn uart7rst(&mut self) -> _UART7RSTW {
1532        _UART7RSTW { w: self }
1533    }
1534    #[doc = "Bit 31 - UART 8 reset"]
1535    #[inline]
1536    pub fn uart8rst(&mut self) -> _UART8RSTW {
1537        _UART8RSTW { w: self }
1538    }
1539}
stm32f429/rcc/apb1rstr.rs

stm32f429/rcc/
apb1rstr.rs
