stm32f103xx/exti/pr/
mod.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::PR {
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 PR0R {
47    bits: bool,
48}
49impl PR0R {
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 PR1R {
68    bits: bool,
69}
70impl PR1R {
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 PR2R {
89    bits: bool,
90}
91impl PR2R {
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 PR3R {
110    bits: bool,
111}
112impl PR3R {
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 PR4R {
131    bits: bool,
132}
133impl PR4R {
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 PR5R {
152    bits: bool,
153}
154impl PR5R {
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 PR6R {
173    bits: bool,
174}
175impl PR6R {
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 PR7R {
194    bits: bool,
195}
196impl PR7R {
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 PR8R {
215    bits: bool,
216}
217impl PR8R {
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 PR9R {
236    bits: bool,
237}
238impl PR9R {
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 PR10R {
257    bits: bool,
258}
259impl PR10R {
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 PR11R {
278    bits: bool,
279}
280impl PR11R {
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 PR12R {
299    bits: bool,
300}
301impl PR12R {
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 PR13R {
320    bits: bool,
321}
322impl PR13R {
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 PR14R {
341    bits: bool,
342}
343impl PR14R {
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 PR15R {
362    bits: bool,
363}
364impl PR15R {
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 PR16R {
383    bits: bool,
384}
385impl PR16R {
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 PR17R {
404    bits: bool,
405}
406impl PR17R {
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 PR18R {
425    bits: bool,
426}
427impl PR18R {
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" Proxy"]
445pub struct _PR0W<'a> {
446    w: &'a mut W,
447}
448impl<'a> _PR0W<'a> {
449    #[doc = r" Sets the field bit"]
450    pub fn set_bit(self) -> &'a mut W {
451        self.bit(true)
452    }
453    #[doc = r" Clears the field bit"]
454    pub fn clear_bit(self) -> &'a mut W {
455        self.bit(false)
456    }
457    #[doc = r" Writes raw bits to the field"]
458    #[inline]
459    pub fn bit(self, value: bool) -> &'a mut W {
460        const MASK: bool = true;
461        const OFFSET: u8 = 0;
462        self.w.bits &= !((MASK as u32) << OFFSET);
463        self.w.bits |= ((value & MASK) as u32) << OFFSET;
464        self.w
465    }
466}
467#[doc = r" Proxy"]
468pub struct _PR1W<'a> {
469    w: &'a mut W,
470}
471impl<'a> _PR1W<'a> {
472    #[doc = r" Sets the field bit"]
473    pub fn set_bit(self) -> &'a mut W {
474        self.bit(true)
475    }
476    #[doc = r" Clears the field bit"]
477    pub fn clear_bit(self) -> &'a mut W {
478        self.bit(false)
479    }
480    #[doc = r" Writes raw bits to the field"]
481    #[inline]
482    pub fn bit(self, value: bool) -> &'a mut W {
483        const MASK: bool = true;
484        const OFFSET: u8 = 1;
485        self.w.bits &= !((MASK as u32) << OFFSET);
486        self.w.bits |= ((value & MASK) as u32) << OFFSET;
487        self.w
488    }
489}
490#[doc = r" Proxy"]
491pub struct _PR2W<'a> {
492    w: &'a mut W,
493}
494impl<'a> _PR2W<'a> {
495    #[doc = r" Sets the field bit"]
496    pub fn set_bit(self) -> &'a mut W {
497        self.bit(true)
498    }
499    #[doc = r" Clears the field bit"]
500    pub fn clear_bit(self) -> &'a mut W {
501        self.bit(false)
502    }
503    #[doc = r" Writes raw bits to the field"]
504    #[inline]
505    pub fn bit(self, value: bool) -> &'a mut W {
506        const MASK: bool = true;
507        const OFFSET: u8 = 2;
508        self.w.bits &= !((MASK as u32) << OFFSET);
509        self.w.bits |= ((value & MASK) as u32) << OFFSET;
510        self.w
511    }
512}
513#[doc = r" Proxy"]
514pub struct _PR3W<'a> {
515    w: &'a mut W,
516}
517impl<'a> _PR3W<'a> {
518    #[doc = r" Sets the field bit"]
519    pub fn set_bit(self) -> &'a mut W {
520        self.bit(true)
521    }
522    #[doc = r" Clears the field bit"]
523    pub fn clear_bit(self) -> &'a mut W {
524        self.bit(false)
525    }
526    #[doc = r" Writes raw bits to the field"]
527    #[inline]
528    pub fn bit(self, value: bool) -> &'a mut W {
529        const MASK: bool = true;
530        const OFFSET: u8 = 3;
531        self.w.bits &= !((MASK as u32) << OFFSET);
532        self.w.bits |= ((value & MASK) as u32) << OFFSET;
533        self.w
534    }
535}
536#[doc = r" Proxy"]
537pub struct _PR4W<'a> {
538    w: &'a mut W,
539}
540impl<'a> _PR4W<'a> {
541    #[doc = r" Sets the field bit"]
542    pub fn set_bit(self) -> &'a mut W {
543        self.bit(true)
544    }
545    #[doc = r" Clears the field bit"]
546    pub fn clear_bit(self) -> &'a mut W {
547        self.bit(false)
548    }
549    #[doc = r" Writes raw bits to the field"]
550    #[inline]
551    pub fn bit(self, value: bool) -> &'a mut W {
552        const MASK: bool = true;
553        const OFFSET: u8 = 4;
554        self.w.bits &= !((MASK as u32) << OFFSET);
555        self.w.bits |= ((value & MASK) as u32) << OFFSET;
556        self.w
557    }
558}
559#[doc = r" Proxy"]
560pub struct _PR5W<'a> {
561    w: &'a mut W,
562}
563impl<'a> _PR5W<'a> {
564    #[doc = r" Sets the field bit"]
565    pub fn set_bit(self) -> &'a mut W {
566        self.bit(true)
567    }
568    #[doc = r" Clears the field bit"]
569    pub fn clear_bit(self) -> &'a mut W {
570        self.bit(false)
571    }
572    #[doc = r" Writes raw bits to the field"]
573    #[inline]
574    pub fn bit(self, value: bool) -> &'a mut W {
575        const MASK: bool = true;
576        const OFFSET: u8 = 5;
577        self.w.bits &= !((MASK as u32) << OFFSET);
578        self.w.bits |= ((value & MASK) as u32) << OFFSET;
579        self.w
580    }
581}
582#[doc = r" Proxy"]
583pub struct _PR6W<'a> {
584    w: &'a mut W,
585}
586impl<'a> _PR6W<'a> {
587    #[doc = r" Sets the field bit"]
588    pub fn set_bit(self) -> &'a mut W {
589        self.bit(true)
590    }
591    #[doc = r" Clears the field bit"]
592    pub fn clear_bit(self) -> &'a mut W {
593        self.bit(false)
594    }
595    #[doc = r" Writes raw bits to the field"]
596    #[inline]
597    pub fn bit(self, value: bool) -> &'a mut W {
598        const MASK: bool = true;
599        const OFFSET: u8 = 6;
600        self.w.bits &= !((MASK as u32) << OFFSET);
601        self.w.bits |= ((value & MASK) as u32) << OFFSET;
602        self.w
603    }
604}
605#[doc = r" Proxy"]
606pub struct _PR7W<'a> {
607    w: &'a mut W,
608}
609impl<'a> _PR7W<'a> {
610    #[doc = r" Sets the field bit"]
611    pub fn set_bit(self) -> &'a mut W {
612        self.bit(true)
613    }
614    #[doc = r" Clears the field bit"]
615    pub fn clear_bit(self) -> &'a mut W {
616        self.bit(false)
617    }
618    #[doc = r" Writes raw bits to the field"]
619    #[inline]
620    pub fn bit(self, value: bool) -> &'a mut W {
621        const MASK: bool = true;
622        const OFFSET: u8 = 7;
623        self.w.bits &= !((MASK as u32) << OFFSET);
624        self.w.bits |= ((value & MASK) as u32) << OFFSET;
625        self.w
626    }
627}
628#[doc = r" Proxy"]
629pub struct _PR8W<'a> {
630    w: &'a mut W,
631}
632impl<'a> _PR8W<'a> {
633    #[doc = r" Sets the field bit"]
634    pub fn set_bit(self) -> &'a mut W {
635        self.bit(true)
636    }
637    #[doc = r" Clears the field bit"]
638    pub fn clear_bit(self) -> &'a mut W {
639        self.bit(false)
640    }
641    #[doc = r" Writes raw bits to the field"]
642    #[inline]
643    pub fn bit(self, value: bool) -> &'a mut W {
644        const MASK: bool = true;
645        const OFFSET: u8 = 8;
646        self.w.bits &= !((MASK as u32) << OFFSET);
647        self.w.bits |= ((value & MASK) as u32) << OFFSET;
648        self.w
649    }
650}
651#[doc = r" Proxy"]
652pub struct _PR9W<'a> {
653    w: &'a mut W,
654}
655impl<'a> _PR9W<'a> {
656    #[doc = r" Sets the field bit"]
657    pub fn set_bit(self) -> &'a mut W {
658        self.bit(true)
659    }
660    #[doc = r" Clears the field bit"]
661    pub fn clear_bit(self) -> &'a mut W {
662        self.bit(false)
663    }
664    #[doc = r" Writes raw bits to the field"]
665    #[inline]
666    pub fn bit(self, value: bool) -> &'a mut W {
667        const MASK: bool = true;
668        const OFFSET: u8 = 9;
669        self.w.bits &= !((MASK as u32) << OFFSET);
670        self.w.bits |= ((value & MASK) as u32) << OFFSET;
671        self.w
672    }
673}
674#[doc = r" Proxy"]
675pub struct _PR10W<'a> {
676    w: &'a mut W,
677}
678impl<'a> _PR10W<'a> {
679    #[doc = r" Sets the field bit"]
680    pub fn set_bit(self) -> &'a mut W {
681        self.bit(true)
682    }
683    #[doc = r" Clears the field bit"]
684    pub fn clear_bit(self) -> &'a mut W {
685        self.bit(false)
686    }
687    #[doc = r" Writes raw bits to the field"]
688    #[inline]
689    pub fn bit(self, value: bool) -> &'a mut W {
690        const MASK: bool = true;
691        const OFFSET: u8 = 10;
692        self.w.bits &= !((MASK as u32) << OFFSET);
693        self.w.bits |= ((value & MASK) as u32) << OFFSET;
694        self.w
695    }
696}
697#[doc = r" Proxy"]
698pub struct _PR11W<'a> {
699    w: &'a mut W,
700}
701impl<'a> _PR11W<'a> {
702    #[doc = r" Sets the field bit"]
703    pub fn set_bit(self) -> &'a mut W {
704        self.bit(true)
705    }
706    #[doc = r" Clears the field bit"]
707    pub fn clear_bit(self) -> &'a mut W {
708        self.bit(false)
709    }
710    #[doc = r" Writes raw bits to the field"]
711    #[inline]
712    pub fn bit(self, value: bool) -> &'a mut W {
713        const MASK: bool = true;
714        const OFFSET: u8 = 11;
715        self.w.bits &= !((MASK as u32) << OFFSET);
716        self.w.bits |= ((value & MASK) as u32) << OFFSET;
717        self.w
718    }
719}
720#[doc = r" Proxy"]
721pub struct _PR12W<'a> {
722    w: &'a mut W,
723}
724impl<'a> _PR12W<'a> {
725    #[doc = r" Sets the field bit"]
726    pub fn set_bit(self) -> &'a mut W {
727        self.bit(true)
728    }
729    #[doc = r" Clears the field bit"]
730    pub fn clear_bit(self) -> &'a mut W {
731        self.bit(false)
732    }
733    #[doc = r" Writes raw bits to the field"]
734    #[inline]
735    pub fn bit(self, value: bool) -> &'a mut W {
736        const MASK: bool = true;
737        const OFFSET: u8 = 12;
738        self.w.bits &= !((MASK as u32) << OFFSET);
739        self.w.bits |= ((value & MASK) as u32) << OFFSET;
740        self.w
741    }
742}
743#[doc = r" Proxy"]
744pub struct _PR13W<'a> {
745    w: &'a mut W,
746}
747impl<'a> _PR13W<'a> {
748    #[doc = r" Sets the field bit"]
749    pub fn set_bit(self) -> &'a mut W {
750        self.bit(true)
751    }
752    #[doc = r" Clears the field bit"]
753    pub fn clear_bit(self) -> &'a mut W {
754        self.bit(false)
755    }
756    #[doc = r" Writes raw bits to the field"]
757    #[inline]
758    pub fn bit(self, value: bool) -> &'a mut W {
759        const MASK: bool = true;
760        const OFFSET: u8 = 13;
761        self.w.bits &= !((MASK as u32) << OFFSET);
762        self.w.bits |= ((value & MASK) as u32) << OFFSET;
763        self.w
764    }
765}
766#[doc = r" Proxy"]
767pub struct _PR14W<'a> {
768    w: &'a mut W,
769}
770impl<'a> _PR14W<'a> {
771    #[doc = r" Sets the field bit"]
772    pub fn set_bit(self) -> &'a mut W {
773        self.bit(true)
774    }
775    #[doc = r" Clears the field bit"]
776    pub fn clear_bit(self) -> &'a mut W {
777        self.bit(false)
778    }
779    #[doc = r" Writes raw bits to the field"]
780    #[inline]
781    pub fn bit(self, value: bool) -> &'a mut W {
782        const MASK: bool = true;
783        const OFFSET: u8 = 14;
784        self.w.bits &= !((MASK as u32) << OFFSET);
785        self.w.bits |= ((value & MASK) as u32) << OFFSET;
786        self.w
787    }
788}
789#[doc = r" Proxy"]
790pub struct _PR15W<'a> {
791    w: &'a mut W,
792}
793impl<'a> _PR15W<'a> {
794    #[doc = r" Sets the field bit"]
795    pub fn set_bit(self) -> &'a mut W {
796        self.bit(true)
797    }
798    #[doc = r" Clears the field bit"]
799    pub fn clear_bit(self) -> &'a mut W {
800        self.bit(false)
801    }
802    #[doc = r" Writes raw bits to the field"]
803    #[inline]
804    pub fn bit(self, value: bool) -> &'a mut W {
805        const MASK: bool = true;
806        const OFFSET: u8 = 15;
807        self.w.bits &= !((MASK as u32) << OFFSET);
808        self.w.bits |= ((value & MASK) as u32) << OFFSET;
809        self.w
810    }
811}
812#[doc = r" Proxy"]
813pub struct _PR16W<'a> {
814    w: &'a mut W,
815}
816impl<'a> _PR16W<'a> {
817    #[doc = r" Sets the field bit"]
818    pub fn set_bit(self) -> &'a mut W {
819        self.bit(true)
820    }
821    #[doc = r" Clears the field bit"]
822    pub fn clear_bit(self) -> &'a mut W {
823        self.bit(false)
824    }
825    #[doc = r" Writes raw bits to the field"]
826    #[inline]
827    pub fn bit(self, value: bool) -> &'a mut W {
828        const MASK: bool = true;
829        const OFFSET: u8 = 16;
830        self.w.bits &= !((MASK as u32) << OFFSET);
831        self.w.bits |= ((value & MASK) as u32) << OFFSET;
832        self.w
833    }
834}
835#[doc = r" Proxy"]
836pub struct _PR17W<'a> {
837    w: &'a mut W,
838}
839impl<'a> _PR17W<'a> {
840    #[doc = r" Sets the field bit"]
841    pub fn set_bit(self) -> &'a mut W {
842        self.bit(true)
843    }
844    #[doc = r" Clears the field bit"]
845    pub fn clear_bit(self) -> &'a mut W {
846        self.bit(false)
847    }
848    #[doc = r" Writes raw bits to the field"]
849    #[inline]
850    pub fn bit(self, value: bool) -> &'a mut W {
851        const MASK: bool = true;
852        const OFFSET: u8 = 17;
853        self.w.bits &= !((MASK as u32) << OFFSET);
854        self.w.bits |= ((value & MASK) as u32) << OFFSET;
855        self.w
856    }
857}
858#[doc = r" Proxy"]
859pub struct _PR18W<'a> {
860    w: &'a mut W,
861}
862impl<'a> _PR18W<'a> {
863    #[doc = r" Sets the field bit"]
864    pub fn set_bit(self) -> &'a mut W {
865        self.bit(true)
866    }
867    #[doc = r" Clears the field bit"]
868    pub fn clear_bit(self) -> &'a mut W {
869        self.bit(false)
870    }
871    #[doc = r" Writes raw bits to the field"]
872    #[inline]
873    pub fn bit(self, value: bool) -> &'a mut W {
874        const MASK: bool = true;
875        const OFFSET: u8 = 18;
876        self.w.bits &= !((MASK as u32) << OFFSET);
877        self.w.bits |= ((value & MASK) as u32) << OFFSET;
878        self.w
879    }
880}
881impl R {
882    #[doc = r" Value of the register as raw bits"]
883    #[inline]
884    pub fn bits(&self) -> u32 {
885        self.bits
886    }
887    #[doc = "Bit 0 - Pending bit 0"]
888    #[inline]
889    pub fn pr0(&self) -> PR0R {
890        let bits = {
891            const MASK: bool = true;
892            const OFFSET: u8 = 0;
893            ((self.bits >> OFFSET) & MASK as u32) != 0
894        };
895        PR0R { bits }
896    }
897    #[doc = "Bit 1 - Pending bit 1"]
898    #[inline]
899    pub fn pr1(&self) -> PR1R {
900        let bits = {
901            const MASK: bool = true;
902            const OFFSET: u8 = 1;
903            ((self.bits >> OFFSET) & MASK as u32) != 0
904        };
905        PR1R { bits }
906    }
907    #[doc = "Bit 2 - Pending bit 2"]
908    #[inline]
909    pub fn pr2(&self) -> PR2R {
910        let bits = {
911            const MASK: bool = true;
912            const OFFSET: u8 = 2;
913            ((self.bits >> OFFSET) & MASK as u32) != 0
914        };
915        PR2R { bits }
916    }
917    #[doc = "Bit 3 - Pending bit 3"]
918    #[inline]
919    pub fn pr3(&self) -> PR3R {
920        let bits = {
921            const MASK: bool = true;
922            const OFFSET: u8 = 3;
923            ((self.bits >> OFFSET) & MASK as u32) != 0
924        };
925        PR3R { bits }
926    }
927    #[doc = "Bit 4 - Pending bit 4"]
928    #[inline]
929    pub fn pr4(&self) -> PR4R {
930        let bits = {
931            const MASK: bool = true;
932            const OFFSET: u8 = 4;
933            ((self.bits >> OFFSET) & MASK as u32) != 0
934        };
935        PR4R { bits }
936    }
937    #[doc = "Bit 5 - Pending bit 5"]
938    #[inline]
939    pub fn pr5(&self) -> PR5R {
940        let bits = {
941            const MASK: bool = true;
942            const OFFSET: u8 = 5;
943            ((self.bits >> OFFSET) & MASK as u32) != 0
944        };
945        PR5R { bits }
946    }
947    #[doc = "Bit 6 - Pending bit 6"]
948    #[inline]
949    pub fn pr6(&self) -> PR6R {
950        let bits = {
951            const MASK: bool = true;
952            const OFFSET: u8 = 6;
953            ((self.bits >> OFFSET) & MASK as u32) != 0
954        };
955        PR6R { bits }
956    }
957    #[doc = "Bit 7 - Pending bit 7"]
958    #[inline]
959    pub fn pr7(&self) -> PR7R {
960        let bits = {
961            const MASK: bool = true;
962            const OFFSET: u8 = 7;
963            ((self.bits >> OFFSET) & MASK as u32) != 0
964        };
965        PR7R { bits }
966    }
967    #[doc = "Bit 8 - Pending bit 8"]
968    #[inline]
969    pub fn pr8(&self) -> PR8R {
970        let bits = {
971            const MASK: bool = true;
972            const OFFSET: u8 = 8;
973            ((self.bits >> OFFSET) & MASK as u32) != 0
974        };
975        PR8R { bits }
976    }
977    #[doc = "Bit 9 - Pending bit 9"]
978    #[inline]
979    pub fn pr9(&self) -> PR9R {
980        let bits = {
981            const MASK: bool = true;
982            const OFFSET: u8 = 9;
983            ((self.bits >> OFFSET) & MASK as u32) != 0
984        };
985        PR9R { bits }
986    }
987    #[doc = "Bit 10 - Pending bit 10"]
988    #[inline]
989    pub fn pr10(&self) -> PR10R {
990        let bits = {
991            const MASK: bool = true;
992            const OFFSET: u8 = 10;
993            ((self.bits >> OFFSET) & MASK as u32) != 0
994        };
995        PR10R { bits }
996    }
997    #[doc = "Bit 11 - Pending bit 11"]
998    #[inline]
999    pub fn pr11(&self) -> PR11R {
1000        let bits = {
1001            const MASK: bool = true;
1002            const OFFSET: u8 = 11;
1003            ((self.bits >> OFFSET) & MASK as u32) != 0
1004        };
1005        PR11R { bits }
1006    }
1007    #[doc = "Bit 12 - Pending bit 12"]
1008    #[inline]
1009    pub fn pr12(&self) -> PR12R {
1010        let bits = {
1011            const MASK: bool = true;
1012            const OFFSET: u8 = 12;
1013            ((self.bits >> OFFSET) & MASK as u32) != 0
1014        };
1015        PR12R { bits }
1016    }
1017    #[doc = "Bit 13 - Pending bit 13"]
1018    #[inline]
1019    pub fn pr13(&self) -> PR13R {
1020        let bits = {
1021            const MASK: bool = true;
1022            const OFFSET: u8 = 13;
1023            ((self.bits >> OFFSET) & MASK as u32) != 0
1024        };
1025        PR13R { bits }
1026    }
1027    #[doc = "Bit 14 - Pending bit 14"]
1028    #[inline]
1029    pub fn pr14(&self) -> PR14R {
1030        let bits = {
1031            const MASK: bool = true;
1032            const OFFSET: u8 = 14;
1033            ((self.bits >> OFFSET) & MASK as u32) != 0
1034        };
1035        PR14R { bits }
1036    }
1037    #[doc = "Bit 15 - Pending bit 15"]
1038    #[inline]
1039    pub fn pr15(&self) -> PR15R {
1040        let bits = {
1041            const MASK: bool = true;
1042            const OFFSET: u8 = 15;
1043            ((self.bits >> OFFSET) & MASK as u32) != 0
1044        };
1045        PR15R { bits }
1046    }
1047    #[doc = "Bit 16 - Pending bit 16"]
1048    #[inline]
1049    pub fn pr16(&self) -> PR16R {
1050        let bits = {
1051            const MASK: bool = true;
1052            const OFFSET: u8 = 16;
1053            ((self.bits >> OFFSET) & MASK as u32) != 0
1054        };
1055        PR16R { bits }
1056    }
1057    #[doc = "Bit 17 - Pending bit 17"]
1058    #[inline]
1059    pub fn pr17(&self) -> PR17R {
1060        let bits = {
1061            const MASK: bool = true;
1062            const OFFSET: u8 = 17;
1063            ((self.bits >> OFFSET) & MASK as u32) != 0
1064        };
1065        PR17R { bits }
1066    }
1067    #[doc = "Bit 18 - Pending bit 18"]
1068    #[inline]
1069    pub fn pr18(&self) -> PR18R {
1070        let bits = {
1071            const MASK: bool = true;
1072            const OFFSET: u8 = 18;
1073            ((self.bits >> OFFSET) & MASK as u32) != 0
1074        };
1075        PR18R { bits }
1076    }
1077}
1078impl W {
1079    #[doc = r" Reset value of the register"]
1080    #[inline]
1081    pub fn reset_value() -> W {
1082        W { bits: 0 }
1083    }
1084    #[doc = r" Writes raw bits to the register"]
1085    #[inline]
1086    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1087        self.bits = bits;
1088        self
1089    }
1090    #[doc = "Bit 0 - Pending bit 0"]
1091    #[inline]
1092    pub fn pr0(&mut self) -> _PR0W {
1093        _PR0W { w: self }
1094    }
1095    #[doc = "Bit 1 - Pending bit 1"]
1096    #[inline]
1097    pub fn pr1(&mut self) -> _PR1W {
1098        _PR1W { w: self }
1099    }
1100    #[doc = "Bit 2 - Pending bit 2"]
1101    #[inline]
1102    pub fn pr2(&mut self) -> _PR2W {
1103        _PR2W { w: self }
1104    }
1105    #[doc = "Bit 3 - Pending bit 3"]
1106    #[inline]
1107    pub fn pr3(&mut self) -> _PR3W {
1108        _PR3W { w: self }
1109    }
1110    #[doc = "Bit 4 - Pending bit 4"]
1111    #[inline]
1112    pub fn pr4(&mut self) -> _PR4W {
1113        _PR4W { w: self }
1114    }
1115    #[doc = "Bit 5 - Pending bit 5"]
1116    #[inline]
1117    pub fn pr5(&mut self) -> _PR5W {
1118        _PR5W { w: self }
1119    }
1120    #[doc = "Bit 6 - Pending bit 6"]
1121    #[inline]
1122    pub fn pr6(&mut self) -> _PR6W {
1123        _PR6W { w: self }
1124    }
1125    #[doc = "Bit 7 - Pending bit 7"]
1126    #[inline]
1127    pub fn pr7(&mut self) -> _PR7W {
1128        _PR7W { w: self }
1129    }
1130    #[doc = "Bit 8 - Pending bit 8"]
1131    #[inline]
1132    pub fn pr8(&mut self) -> _PR8W {
1133        _PR8W { w: self }
1134    }
1135    #[doc = "Bit 9 - Pending bit 9"]
1136    #[inline]
1137    pub fn pr9(&mut self) -> _PR9W {
1138        _PR9W { w: self }
1139    }
1140    #[doc = "Bit 10 - Pending bit 10"]
1141    #[inline]
1142    pub fn pr10(&mut self) -> _PR10W {
1143        _PR10W { w: self }
1144    }
1145    #[doc = "Bit 11 - Pending bit 11"]
1146    #[inline]
1147    pub fn pr11(&mut self) -> _PR11W {
1148        _PR11W { w: self }
1149    }
1150    #[doc = "Bit 12 - Pending bit 12"]
1151    #[inline]
1152    pub fn pr12(&mut self) -> _PR12W {
1153        _PR12W { w: self }
1154    }
1155    #[doc = "Bit 13 - Pending bit 13"]
1156    #[inline]
1157    pub fn pr13(&mut self) -> _PR13W {
1158        _PR13W { w: self }
1159    }
1160    #[doc = "Bit 14 - Pending bit 14"]
1161    #[inline]
1162    pub fn pr14(&mut self) -> _PR14W {
1163        _PR14W { w: self }
1164    }
1165    #[doc = "Bit 15 - Pending bit 15"]
1166    #[inline]
1167    pub fn pr15(&mut self) -> _PR15W {
1168        _PR15W { w: self }
1169    }
1170    #[doc = "Bit 16 - Pending bit 16"]
1171    #[inline]
1172    pub fn pr16(&mut self) -> _PR16W {
1173        _PR16W { w: self }
1174    }
1175    #[doc = "Bit 17 - Pending bit 17"]
1176    #[inline]
1177    pub fn pr17(&mut self) -> _PR17W {
1178        _PR17W { w: self }
1179    }
1180    #[doc = "Bit 18 - Pending bit 18"]
1181    #[inline]
1182    pub fn pr18(&mut self) -> _PR18W {
1183        _PR18W { w: self }
1184    }
1185}
stm32f103xx/exti/pr/mod.rs

stm32f103xx/exti/pr/
mod.rs
