stm32f429/exti/
pr.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" Value of the field"]
445pub struct PR19R {
446    bits: bool,
447}
448impl PR19R {
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 PR20R {
467    bits: bool,
468}
469impl PR20R {
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 PR21R {
488    bits: bool,
489}
490impl PR21R {
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 PR22R {
509    bits: bool,
510}
511impl PR22R {
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" Proxy"]
529pub struct _PR0W<'a> {
530    w: &'a mut W,
531}
532impl<'a> _PR0W<'a> {
533    #[doc = r" Sets the field bit"]
534    pub fn set_bit(self) -> &'a mut W {
535        self.bit(true)
536    }
537    #[doc = r" Clears the field bit"]
538    pub fn clear_bit(self) -> &'a mut W {
539        self.bit(false)
540    }
541    #[doc = r" Writes raw bits to the field"]
542    #[inline]
543    pub fn bit(self, value: bool) -> &'a mut W {
544        const MASK: bool = true;
545        const OFFSET: u8 = 0;
546        self.w.bits &= !((MASK as u32) << OFFSET);
547        self.w.bits |= ((value & MASK) as u32) << OFFSET;
548        self.w
549    }
550}
551#[doc = r" Proxy"]
552pub struct _PR1W<'a> {
553    w: &'a mut W,
554}
555impl<'a> _PR1W<'a> {
556    #[doc = r" Sets the field bit"]
557    pub fn set_bit(self) -> &'a mut W {
558        self.bit(true)
559    }
560    #[doc = r" Clears the field bit"]
561    pub fn clear_bit(self) -> &'a mut W {
562        self.bit(false)
563    }
564    #[doc = r" Writes raw bits to the field"]
565    #[inline]
566    pub fn bit(self, value: bool) -> &'a mut W {
567        const MASK: bool = true;
568        const OFFSET: u8 = 1;
569        self.w.bits &= !((MASK as u32) << OFFSET);
570        self.w.bits |= ((value & MASK) as u32) << OFFSET;
571        self.w
572    }
573}
574#[doc = r" Proxy"]
575pub struct _PR2W<'a> {
576    w: &'a mut W,
577}
578impl<'a> _PR2W<'a> {
579    #[doc = r" Sets the field bit"]
580    pub fn set_bit(self) -> &'a mut W {
581        self.bit(true)
582    }
583    #[doc = r" Clears the field bit"]
584    pub fn clear_bit(self) -> &'a mut W {
585        self.bit(false)
586    }
587    #[doc = r" Writes raw bits to the field"]
588    #[inline]
589    pub fn bit(self, value: bool) -> &'a mut W {
590        const MASK: bool = true;
591        const OFFSET: u8 = 2;
592        self.w.bits &= !((MASK as u32) << OFFSET);
593        self.w.bits |= ((value & MASK) as u32) << OFFSET;
594        self.w
595    }
596}
597#[doc = r" Proxy"]
598pub struct _PR3W<'a> {
599    w: &'a mut W,
600}
601impl<'a> _PR3W<'a> {
602    #[doc = r" Sets the field bit"]
603    pub fn set_bit(self) -> &'a mut W {
604        self.bit(true)
605    }
606    #[doc = r" Clears the field bit"]
607    pub fn clear_bit(self) -> &'a mut W {
608        self.bit(false)
609    }
610    #[doc = r" Writes raw bits to the field"]
611    #[inline]
612    pub fn bit(self, value: bool) -> &'a mut W {
613        const MASK: bool = true;
614        const OFFSET: u8 = 3;
615        self.w.bits &= !((MASK as u32) << OFFSET);
616        self.w.bits |= ((value & MASK) as u32) << OFFSET;
617        self.w
618    }
619}
620#[doc = r" Proxy"]
621pub struct _PR4W<'a> {
622    w: &'a mut W,
623}
624impl<'a> _PR4W<'a> {
625    #[doc = r" Sets the field bit"]
626    pub fn set_bit(self) -> &'a mut W {
627        self.bit(true)
628    }
629    #[doc = r" Clears the field bit"]
630    pub fn clear_bit(self) -> &'a mut W {
631        self.bit(false)
632    }
633    #[doc = r" Writes raw bits to the field"]
634    #[inline]
635    pub fn bit(self, value: bool) -> &'a mut W {
636        const MASK: bool = true;
637        const OFFSET: u8 = 4;
638        self.w.bits &= !((MASK as u32) << OFFSET);
639        self.w.bits |= ((value & MASK) as u32) << OFFSET;
640        self.w
641    }
642}
643#[doc = r" Proxy"]
644pub struct _PR5W<'a> {
645    w: &'a mut W,
646}
647impl<'a> _PR5W<'a> {
648    #[doc = r" Sets the field bit"]
649    pub fn set_bit(self) -> &'a mut W {
650        self.bit(true)
651    }
652    #[doc = r" Clears the field bit"]
653    pub fn clear_bit(self) -> &'a mut W {
654        self.bit(false)
655    }
656    #[doc = r" Writes raw bits to the field"]
657    #[inline]
658    pub fn bit(self, value: bool) -> &'a mut W {
659        const MASK: bool = true;
660        const OFFSET: u8 = 5;
661        self.w.bits &= !((MASK as u32) << OFFSET);
662        self.w.bits |= ((value & MASK) as u32) << OFFSET;
663        self.w
664    }
665}
666#[doc = r" Proxy"]
667pub struct _PR6W<'a> {
668    w: &'a mut W,
669}
670impl<'a> _PR6W<'a> {
671    #[doc = r" Sets the field bit"]
672    pub fn set_bit(self) -> &'a mut W {
673        self.bit(true)
674    }
675    #[doc = r" Clears the field bit"]
676    pub fn clear_bit(self) -> &'a mut W {
677        self.bit(false)
678    }
679    #[doc = r" Writes raw bits to the field"]
680    #[inline]
681    pub fn bit(self, value: bool) -> &'a mut W {
682        const MASK: bool = true;
683        const OFFSET: u8 = 6;
684        self.w.bits &= !((MASK as u32) << OFFSET);
685        self.w.bits |= ((value & MASK) as u32) << OFFSET;
686        self.w
687    }
688}
689#[doc = r" Proxy"]
690pub struct _PR7W<'a> {
691    w: &'a mut W,
692}
693impl<'a> _PR7W<'a> {
694    #[doc = r" Sets the field bit"]
695    pub fn set_bit(self) -> &'a mut W {
696        self.bit(true)
697    }
698    #[doc = r" Clears the field bit"]
699    pub fn clear_bit(self) -> &'a mut W {
700        self.bit(false)
701    }
702    #[doc = r" Writes raw bits to the field"]
703    #[inline]
704    pub fn bit(self, value: bool) -> &'a mut W {
705        const MASK: bool = true;
706        const OFFSET: u8 = 7;
707        self.w.bits &= !((MASK as u32) << OFFSET);
708        self.w.bits |= ((value & MASK) as u32) << OFFSET;
709        self.w
710    }
711}
712#[doc = r" Proxy"]
713pub struct _PR8W<'a> {
714    w: &'a mut W,
715}
716impl<'a> _PR8W<'a> {
717    #[doc = r" Sets the field bit"]
718    pub fn set_bit(self) -> &'a mut W {
719        self.bit(true)
720    }
721    #[doc = r" Clears the field bit"]
722    pub fn clear_bit(self) -> &'a mut W {
723        self.bit(false)
724    }
725    #[doc = r" Writes raw bits to the field"]
726    #[inline]
727    pub fn bit(self, value: bool) -> &'a mut W {
728        const MASK: bool = true;
729        const OFFSET: u8 = 8;
730        self.w.bits &= !((MASK as u32) << OFFSET);
731        self.w.bits |= ((value & MASK) as u32) << OFFSET;
732        self.w
733    }
734}
735#[doc = r" Proxy"]
736pub struct _PR9W<'a> {
737    w: &'a mut W,
738}
739impl<'a> _PR9W<'a> {
740    #[doc = r" Sets the field bit"]
741    pub fn set_bit(self) -> &'a mut W {
742        self.bit(true)
743    }
744    #[doc = r" Clears the field bit"]
745    pub fn clear_bit(self) -> &'a mut W {
746        self.bit(false)
747    }
748    #[doc = r" Writes raw bits to the field"]
749    #[inline]
750    pub fn bit(self, value: bool) -> &'a mut W {
751        const MASK: bool = true;
752        const OFFSET: u8 = 9;
753        self.w.bits &= !((MASK as u32) << OFFSET);
754        self.w.bits |= ((value & MASK) as u32) << OFFSET;
755        self.w
756    }
757}
758#[doc = r" Proxy"]
759pub struct _PR10W<'a> {
760    w: &'a mut W,
761}
762impl<'a> _PR10W<'a> {
763    #[doc = r" Sets the field bit"]
764    pub fn set_bit(self) -> &'a mut W {
765        self.bit(true)
766    }
767    #[doc = r" Clears the field bit"]
768    pub fn clear_bit(self) -> &'a mut W {
769        self.bit(false)
770    }
771    #[doc = r" Writes raw bits to the field"]
772    #[inline]
773    pub fn bit(self, value: bool) -> &'a mut W {
774        const MASK: bool = true;
775        const OFFSET: u8 = 10;
776        self.w.bits &= !((MASK as u32) << OFFSET);
777        self.w.bits |= ((value & MASK) as u32) << OFFSET;
778        self.w
779    }
780}
781#[doc = r" Proxy"]
782pub struct _PR11W<'a> {
783    w: &'a mut W,
784}
785impl<'a> _PR11W<'a> {
786    #[doc = r" Sets the field bit"]
787    pub fn set_bit(self) -> &'a mut W {
788        self.bit(true)
789    }
790    #[doc = r" Clears the field bit"]
791    pub fn clear_bit(self) -> &'a mut W {
792        self.bit(false)
793    }
794    #[doc = r" Writes raw bits to the field"]
795    #[inline]
796    pub fn bit(self, value: bool) -> &'a mut W {
797        const MASK: bool = true;
798        const OFFSET: u8 = 11;
799        self.w.bits &= !((MASK as u32) << OFFSET);
800        self.w.bits |= ((value & MASK) as u32) << OFFSET;
801        self.w
802    }
803}
804#[doc = r" Proxy"]
805pub struct _PR12W<'a> {
806    w: &'a mut W,
807}
808impl<'a> _PR12W<'a> {
809    #[doc = r" Sets the field bit"]
810    pub fn set_bit(self) -> &'a mut W {
811        self.bit(true)
812    }
813    #[doc = r" Clears the field bit"]
814    pub fn clear_bit(self) -> &'a mut W {
815        self.bit(false)
816    }
817    #[doc = r" Writes raw bits to the field"]
818    #[inline]
819    pub fn bit(self, value: bool) -> &'a mut W {
820        const MASK: bool = true;
821        const OFFSET: u8 = 12;
822        self.w.bits &= !((MASK as u32) << OFFSET);
823        self.w.bits |= ((value & MASK) as u32) << OFFSET;
824        self.w
825    }
826}
827#[doc = r" Proxy"]
828pub struct _PR13W<'a> {
829    w: &'a mut W,
830}
831impl<'a> _PR13W<'a> {
832    #[doc = r" Sets the field bit"]
833    pub fn set_bit(self) -> &'a mut W {
834        self.bit(true)
835    }
836    #[doc = r" Clears the field bit"]
837    pub fn clear_bit(self) -> &'a mut W {
838        self.bit(false)
839    }
840    #[doc = r" Writes raw bits to the field"]
841    #[inline]
842    pub fn bit(self, value: bool) -> &'a mut W {
843        const MASK: bool = true;
844        const OFFSET: u8 = 13;
845        self.w.bits &= !((MASK as u32) << OFFSET);
846        self.w.bits |= ((value & MASK) as u32) << OFFSET;
847        self.w
848    }
849}
850#[doc = r" Proxy"]
851pub struct _PR14W<'a> {
852    w: &'a mut W,
853}
854impl<'a> _PR14W<'a> {
855    #[doc = r" Sets the field bit"]
856    pub fn set_bit(self) -> &'a mut W {
857        self.bit(true)
858    }
859    #[doc = r" Clears the field bit"]
860    pub fn clear_bit(self) -> &'a mut W {
861        self.bit(false)
862    }
863    #[doc = r" Writes raw bits to the field"]
864    #[inline]
865    pub fn bit(self, value: bool) -> &'a mut W {
866        const MASK: bool = true;
867        const OFFSET: u8 = 14;
868        self.w.bits &= !((MASK as u32) << OFFSET);
869        self.w.bits |= ((value & MASK) as u32) << OFFSET;
870        self.w
871    }
872}
873#[doc = r" Proxy"]
874pub struct _PR15W<'a> {
875    w: &'a mut W,
876}
877impl<'a> _PR15W<'a> {
878    #[doc = r" Sets the field bit"]
879    pub fn set_bit(self) -> &'a mut W {
880        self.bit(true)
881    }
882    #[doc = r" Clears the field bit"]
883    pub fn clear_bit(self) -> &'a mut W {
884        self.bit(false)
885    }
886    #[doc = r" Writes raw bits to the field"]
887    #[inline]
888    pub fn bit(self, value: bool) -> &'a mut W {
889        const MASK: bool = true;
890        const OFFSET: u8 = 15;
891        self.w.bits &= !((MASK as u32) << OFFSET);
892        self.w.bits |= ((value & MASK) as u32) << OFFSET;
893        self.w
894    }
895}
896#[doc = r" Proxy"]
897pub struct _PR16W<'a> {
898    w: &'a mut W,
899}
900impl<'a> _PR16W<'a> {
901    #[doc = r" Sets the field bit"]
902    pub fn set_bit(self) -> &'a mut W {
903        self.bit(true)
904    }
905    #[doc = r" Clears the field bit"]
906    pub fn clear_bit(self) -> &'a mut W {
907        self.bit(false)
908    }
909    #[doc = r" Writes raw bits to the field"]
910    #[inline]
911    pub fn bit(self, value: bool) -> &'a mut W {
912        const MASK: bool = true;
913        const OFFSET: u8 = 16;
914        self.w.bits &= !((MASK as u32) << OFFSET);
915        self.w.bits |= ((value & MASK) as u32) << OFFSET;
916        self.w
917    }
918}
919#[doc = r" Proxy"]
920pub struct _PR17W<'a> {
921    w: &'a mut W,
922}
923impl<'a> _PR17W<'a> {
924    #[doc = r" Sets the field bit"]
925    pub fn set_bit(self) -> &'a mut W {
926        self.bit(true)
927    }
928    #[doc = r" Clears the field bit"]
929    pub fn clear_bit(self) -> &'a mut W {
930        self.bit(false)
931    }
932    #[doc = r" Writes raw bits to the field"]
933    #[inline]
934    pub fn bit(self, value: bool) -> &'a mut W {
935        const MASK: bool = true;
936        const OFFSET: u8 = 17;
937        self.w.bits &= !((MASK as u32) << OFFSET);
938        self.w.bits |= ((value & MASK) as u32) << OFFSET;
939        self.w
940    }
941}
942#[doc = r" Proxy"]
943pub struct _PR18W<'a> {
944    w: &'a mut W,
945}
946impl<'a> _PR18W<'a> {
947    #[doc = r" Sets the field bit"]
948    pub fn set_bit(self) -> &'a mut W {
949        self.bit(true)
950    }
951    #[doc = r" Clears the field bit"]
952    pub fn clear_bit(self) -> &'a mut W {
953        self.bit(false)
954    }
955    #[doc = r" Writes raw bits to the field"]
956    #[inline]
957    pub fn bit(self, value: bool) -> &'a mut W {
958        const MASK: bool = true;
959        const OFFSET: u8 = 18;
960        self.w.bits &= !((MASK as u32) << OFFSET);
961        self.w.bits |= ((value & MASK) as u32) << OFFSET;
962        self.w
963    }
964}
965#[doc = r" Proxy"]
966pub struct _PR19W<'a> {
967    w: &'a mut W,
968}
969impl<'a> _PR19W<'a> {
970    #[doc = r" Sets the field bit"]
971    pub fn set_bit(self) -> &'a mut W {
972        self.bit(true)
973    }
974    #[doc = r" Clears the field bit"]
975    pub fn clear_bit(self) -> &'a mut W {
976        self.bit(false)
977    }
978    #[doc = r" Writes raw bits to the field"]
979    #[inline]
980    pub fn bit(self, value: bool) -> &'a mut W {
981        const MASK: bool = true;
982        const OFFSET: u8 = 19;
983        self.w.bits &= !((MASK as u32) << OFFSET);
984        self.w.bits |= ((value & MASK) as u32) << OFFSET;
985        self.w
986    }
987}
988#[doc = r" Proxy"]
989pub struct _PR20W<'a> {
990    w: &'a mut W,
991}
992impl<'a> _PR20W<'a> {
993    #[doc = r" Sets the field bit"]
994    pub fn set_bit(self) -> &'a mut W {
995        self.bit(true)
996    }
997    #[doc = r" Clears the field bit"]
998    pub fn clear_bit(self) -> &'a mut W {
999        self.bit(false)
1000    }
1001    #[doc = r" Writes raw bits to the field"]
1002    #[inline]
1003    pub fn bit(self, value: bool) -> &'a mut W {
1004        const MASK: bool = true;
1005        const OFFSET: u8 = 20;
1006        self.w.bits &= !((MASK as u32) << OFFSET);
1007        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1008        self.w
1009    }
1010}
1011#[doc = r" Proxy"]
1012pub struct _PR21W<'a> {
1013    w: &'a mut W,
1014}
1015impl<'a> _PR21W<'a> {
1016    #[doc = r" Sets the field bit"]
1017    pub fn set_bit(self) -> &'a mut W {
1018        self.bit(true)
1019    }
1020    #[doc = r" Clears the field bit"]
1021    pub fn clear_bit(self) -> &'a mut W {
1022        self.bit(false)
1023    }
1024    #[doc = r" Writes raw bits to the field"]
1025    #[inline]
1026    pub fn bit(self, value: bool) -> &'a mut W {
1027        const MASK: bool = true;
1028        const OFFSET: u8 = 21;
1029        self.w.bits &= !((MASK as u32) << OFFSET);
1030        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1031        self.w
1032    }
1033}
1034#[doc = r" Proxy"]
1035pub struct _PR22W<'a> {
1036    w: &'a mut W,
1037}
1038impl<'a> _PR22W<'a> {
1039    #[doc = r" Sets the field bit"]
1040    pub fn set_bit(self) -> &'a mut W {
1041        self.bit(true)
1042    }
1043    #[doc = r" Clears the field bit"]
1044    pub fn clear_bit(self) -> &'a mut W {
1045        self.bit(false)
1046    }
1047    #[doc = r" Writes raw bits to the field"]
1048    #[inline]
1049    pub fn bit(self, value: bool) -> &'a mut W {
1050        const MASK: bool = true;
1051        const OFFSET: u8 = 22;
1052        self.w.bits &= !((MASK as u32) << OFFSET);
1053        self.w.bits |= ((value & MASK) as u32) << OFFSET;
1054        self.w
1055    }
1056}
1057impl R {
1058    #[doc = r" Value of the register as raw bits"]
1059    #[inline]
1060    pub fn bits(&self) -> u32 {
1061        self.bits
1062    }
1063    #[doc = "Bit 0 - Pending bit 0"]
1064    #[inline]
1065    pub fn pr0(&self) -> PR0R {
1066        let bits = {
1067            const MASK: bool = true;
1068            const OFFSET: u8 = 0;
1069            ((self.bits >> OFFSET) & MASK as u32) != 0
1070        };
1071        PR0R { bits }
1072    }
1073    #[doc = "Bit 1 - Pending bit 1"]
1074    #[inline]
1075    pub fn pr1(&self) -> PR1R {
1076        let bits = {
1077            const MASK: bool = true;
1078            const OFFSET: u8 = 1;
1079            ((self.bits >> OFFSET) & MASK as u32) != 0
1080        };
1081        PR1R { bits }
1082    }
1083    #[doc = "Bit 2 - Pending bit 2"]
1084    #[inline]
1085    pub fn pr2(&self) -> PR2R {
1086        let bits = {
1087            const MASK: bool = true;
1088            const OFFSET: u8 = 2;
1089            ((self.bits >> OFFSET) & MASK as u32) != 0
1090        };
1091        PR2R { bits }
1092    }
1093    #[doc = "Bit 3 - Pending bit 3"]
1094    #[inline]
1095    pub fn pr3(&self) -> PR3R {
1096        let bits = {
1097            const MASK: bool = true;
1098            const OFFSET: u8 = 3;
1099            ((self.bits >> OFFSET) & MASK as u32) != 0
1100        };
1101        PR3R { bits }
1102    }
1103    #[doc = "Bit 4 - Pending bit 4"]
1104    #[inline]
1105    pub fn pr4(&self) -> PR4R {
1106        let bits = {
1107            const MASK: bool = true;
1108            const OFFSET: u8 = 4;
1109            ((self.bits >> OFFSET) & MASK as u32) != 0
1110        };
1111        PR4R { bits }
1112    }
1113    #[doc = "Bit 5 - Pending bit 5"]
1114    #[inline]
1115    pub fn pr5(&self) -> PR5R {
1116        let bits = {
1117            const MASK: bool = true;
1118            const OFFSET: u8 = 5;
1119            ((self.bits >> OFFSET) & MASK as u32) != 0
1120        };
1121        PR5R { bits }
1122    }
1123    #[doc = "Bit 6 - Pending bit 6"]
1124    #[inline]
1125    pub fn pr6(&self) -> PR6R {
1126        let bits = {
1127            const MASK: bool = true;
1128            const OFFSET: u8 = 6;
1129            ((self.bits >> OFFSET) & MASK as u32) != 0
1130        };
1131        PR6R { bits }
1132    }
1133    #[doc = "Bit 7 - Pending bit 7"]
1134    #[inline]
1135    pub fn pr7(&self) -> PR7R {
1136        let bits = {
1137            const MASK: bool = true;
1138            const OFFSET: u8 = 7;
1139            ((self.bits >> OFFSET) & MASK as u32) != 0
1140        };
1141        PR7R { bits }
1142    }
1143    #[doc = "Bit 8 - Pending bit 8"]
1144    #[inline]
1145    pub fn pr8(&self) -> PR8R {
1146        let bits = {
1147            const MASK: bool = true;
1148            const OFFSET: u8 = 8;
1149            ((self.bits >> OFFSET) & MASK as u32) != 0
1150        };
1151        PR8R { bits }
1152    }
1153    #[doc = "Bit 9 - Pending bit 9"]
1154    #[inline]
1155    pub fn pr9(&self) -> PR9R {
1156        let bits = {
1157            const MASK: bool = true;
1158            const OFFSET: u8 = 9;
1159            ((self.bits >> OFFSET) & MASK as u32) != 0
1160        };
1161        PR9R { bits }
1162    }
1163    #[doc = "Bit 10 - Pending bit 10"]
1164    #[inline]
1165    pub fn pr10(&self) -> PR10R {
1166        let bits = {
1167            const MASK: bool = true;
1168            const OFFSET: u8 = 10;
1169            ((self.bits >> OFFSET) & MASK as u32) != 0
1170        };
1171        PR10R { bits }
1172    }
1173    #[doc = "Bit 11 - Pending bit 11"]
1174    #[inline]
1175    pub fn pr11(&self) -> PR11R {
1176        let bits = {
1177            const MASK: bool = true;
1178            const OFFSET: u8 = 11;
1179            ((self.bits >> OFFSET) & MASK as u32) != 0
1180        };
1181        PR11R { bits }
1182    }
1183    #[doc = "Bit 12 - Pending bit 12"]
1184    #[inline]
1185    pub fn pr12(&self) -> PR12R {
1186        let bits = {
1187            const MASK: bool = true;
1188            const OFFSET: u8 = 12;
1189            ((self.bits >> OFFSET) & MASK as u32) != 0
1190        };
1191        PR12R { bits }
1192    }
1193    #[doc = "Bit 13 - Pending bit 13"]
1194    #[inline]
1195    pub fn pr13(&self) -> PR13R {
1196        let bits = {
1197            const MASK: bool = true;
1198            const OFFSET: u8 = 13;
1199            ((self.bits >> OFFSET) & MASK as u32) != 0
1200        };
1201        PR13R { bits }
1202    }
1203    #[doc = "Bit 14 - Pending bit 14"]
1204    #[inline]
1205    pub fn pr14(&self) -> PR14R {
1206        let bits = {
1207            const MASK: bool = true;
1208            const OFFSET: u8 = 14;
1209            ((self.bits >> OFFSET) & MASK as u32) != 0
1210        };
1211        PR14R { bits }
1212    }
1213    #[doc = "Bit 15 - Pending bit 15"]
1214    #[inline]
1215    pub fn pr15(&self) -> PR15R {
1216        let bits = {
1217            const MASK: bool = true;
1218            const OFFSET: u8 = 15;
1219            ((self.bits >> OFFSET) & MASK as u32) != 0
1220        };
1221        PR15R { bits }
1222    }
1223    #[doc = "Bit 16 - Pending bit 16"]
1224    #[inline]
1225    pub fn pr16(&self) -> PR16R {
1226        let bits = {
1227            const MASK: bool = true;
1228            const OFFSET: u8 = 16;
1229            ((self.bits >> OFFSET) & MASK as u32) != 0
1230        };
1231        PR16R { bits }
1232    }
1233    #[doc = "Bit 17 - Pending bit 17"]
1234    #[inline]
1235    pub fn pr17(&self) -> PR17R {
1236        let bits = {
1237            const MASK: bool = true;
1238            const OFFSET: u8 = 17;
1239            ((self.bits >> OFFSET) & MASK as u32) != 0
1240        };
1241        PR17R { bits }
1242    }
1243    #[doc = "Bit 18 - Pending bit 18"]
1244    #[inline]
1245    pub fn pr18(&self) -> PR18R {
1246        let bits = {
1247            const MASK: bool = true;
1248            const OFFSET: u8 = 18;
1249            ((self.bits >> OFFSET) & MASK as u32) != 0
1250        };
1251        PR18R { bits }
1252    }
1253    #[doc = "Bit 19 - Pending bit 19"]
1254    #[inline]
1255    pub fn pr19(&self) -> PR19R {
1256        let bits = {
1257            const MASK: bool = true;
1258            const OFFSET: u8 = 19;
1259            ((self.bits >> OFFSET) & MASK as u32) != 0
1260        };
1261        PR19R { bits }
1262    }
1263    #[doc = "Bit 20 - Pending bit 20"]
1264    #[inline]
1265    pub fn pr20(&self) -> PR20R {
1266        let bits = {
1267            const MASK: bool = true;
1268            const OFFSET: u8 = 20;
1269            ((self.bits >> OFFSET) & MASK as u32) != 0
1270        };
1271        PR20R { bits }
1272    }
1273    #[doc = "Bit 21 - Pending bit 21"]
1274    #[inline]
1275    pub fn pr21(&self) -> PR21R {
1276        let bits = {
1277            const MASK: bool = true;
1278            const OFFSET: u8 = 21;
1279            ((self.bits >> OFFSET) & MASK as u32) != 0
1280        };
1281        PR21R { bits }
1282    }
1283    #[doc = "Bit 22 - Pending bit 22"]
1284    #[inline]
1285    pub fn pr22(&self) -> PR22R {
1286        let bits = {
1287            const MASK: bool = true;
1288            const OFFSET: u8 = 22;
1289            ((self.bits >> OFFSET) & MASK as u32) != 0
1290        };
1291        PR22R { bits }
1292    }
1293}
1294impl W {
1295    #[doc = r" Reset value of the register"]
1296    #[inline]
1297    pub fn reset_value() -> W {
1298        W { bits: 0 }
1299    }
1300    #[doc = r" Writes raw bits to the register"]
1301    #[inline]
1302    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1303        self.bits = bits;
1304        self
1305    }
1306    #[doc = "Bit 0 - Pending bit 0"]
1307    #[inline]
1308    pub fn pr0(&mut self) -> _PR0W {
1309        _PR0W { w: self }
1310    }
1311    #[doc = "Bit 1 - Pending bit 1"]
1312    #[inline]
1313    pub fn pr1(&mut self) -> _PR1W {
1314        _PR1W { w: self }
1315    }
1316    #[doc = "Bit 2 - Pending bit 2"]
1317    #[inline]
1318    pub fn pr2(&mut self) -> _PR2W {
1319        _PR2W { w: self }
1320    }
1321    #[doc = "Bit 3 - Pending bit 3"]
1322    #[inline]
1323    pub fn pr3(&mut self) -> _PR3W {
1324        _PR3W { w: self }
1325    }
1326    #[doc = "Bit 4 - Pending bit 4"]
1327    #[inline]
1328    pub fn pr4(&mut self) -> _PR4W {
1329        _PR4W { w: self }
1330    }
1331    #[doc = "Bit 5 - Pending bit 5"]
1332    #[inline]
1333    pub fn pr5(&mut self) -> _PR5W {
1334        _PR5W { w: self }
1335    }
1336    #[doc = "Bit 6 - Pending bit 6"]
1337    #[inline]
1338    pub fn pr6(&mut self) -> _PR6W {
1339        _PR6W { w: self }
1340    }
1341    #[doc = "Bit 7 - Pending bit 7"]
1342    #[inline]
1343    pub fn pr7(&mut self) -> _PR7W {
1344        _PR7W { w: self }
1345    }
1346    #[doc = "Bit 8 - Pending bit 8"]
1347    #[inline]
1348    pub fn pr8(&mut self) -> _PR8W {
1349        _PR8W { w: self }
1350    }
1351    #[doc = "Bit 9 - Pending bit 9"]
1352    #[inline]
1353    pub fn pr9(&mut self) -> _PR9W {
1354        _PR9W { w: self }
1355    }
1356    #[doc = "Bit 10 - Pending bit 10"]
1357    #[inline]
1358    pub fn pr10(&mut self) -> _PR10W {
1359        _PR10W { w: self }
1360    }
1361    #[doc = "Bit 11 - Pending bit 11"]
1362    #[inline]
1363    pub fn pr11(&mut self) -> _PR11W {
1364        _PR11W { w: self }
1365    }
1366    #[doc = "Bit 12 - Pending bit 12"]
1367    #[inline]
1368    pub fn pr12(&mut self) -> _PR12W {
1369        _PR12W { w: self }
1370    }
1371    #[doc = "Bit 13 - Pending bit 13"]
1372    #[inline]
1373    pub fn pr13(&mut self) -> _PR13W {
1374        _PR13W { w: self }
1375    }
1376    #[doc = "Bit 14 - Pending bit 14"]
1377    #[inline]
1378    pub fn pr14(&mut self) -> _PR14W {
1379        _PR14W { w: self }
1380    }
1381    #[doc = "Bit 15 - Pending bit 15"]
1382    #[inline]
1383    pub fn pr15(&mut self) -> _PR15W {
1384        _PR15W { w: self }
1385    }
1386    #[doc = "Bit 16 - Pending bit 16"]
1387    #[inline]
1388    pub fn pr16(&mut self) -> _PR16W {
1389        _PR16W { w: self }
1390    }
1391    #[doc = "Bit 17 - Pending bit 17"]
1392    #[inline]
1393    pub fn pr17(&mut self) -> _PR17W {
1394        _PR17W { w: self }
1395    }
1396    #[doc = "Bit 18 - Pending bit 18"]
1397    #[inline]
1398    pub fn pr18(&mut self) -> _PR18W {
1399        _PR18W { w: self }
1400    }
1401    #[doc = "Bit 19 - Pending bit 19"]
1402    #[inline]
1403    pub fn pr19(&mut self) -> _PR19W {
1404        _PR19W { w: self }
1405    }
1406    #[doc = "Bit 20 - Pending bit 20"]
1407    #[inline]
1408    pub fn pr20(&mut self) -> _PR20W {
1409        _PR20W { w: self }
1410    }
1411    #[doc = "Bit 21 - Pending bit 21"]
1412    #[inline]
1413    pub fn pr21(&mut self) -> _PR21W {
1414        _PR21W { w: self }
1415    }
1416    #[doc = "Bit 22 - Pending bit 22"]
1417    #[inline]
1418    pub fn pr22(&mut self) -> _PR22W {
1419        _PR22W { w: self }
1420    }
1421}
stm32f429/exti/pr.rs

stm32f429/exti/
pr.rs
