stm32f103xx/exti/rtsr/
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::RTSR {
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 TR0R {
47    bits: bool,
48}
49impl TR0R {
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 TR1R {
68    bits: bool,
69}
70impl TR1R {
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 TR2R {
89    bits: bool,
90}
91impl TR2R {
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 TR3R {
110    bits: bool,
111}
112impl TR3R {
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 TR4R {
131    bits: bool,
132}
133impl TR4R {
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 TR5R {
152    bits: bool,
153}
154impl TR5R {
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 TR6R {
173    bits: bool,
174}
175impl TR6R {
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 TR7R {
194    bits: bool,
195}
196impl TR7R {
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 TR8R {
215    bits: bool,
216}
217impl TR8R {
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 TR9R {
236    bits: bool,
237}
238impl TR9R {
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 TR10R {
257    bits: bool,
258}
259impl TR10R {
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 TR11R {
278    bits: bool,
279}
280impl TR11R {
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 TR12R {
299    bits: bool,
300}
301impl TR12R {
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 TR13R {
320    bits: bool,
321}
322impl TR13R {
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 TR14R {
341    bits: bool,
342}
343impl TR14R {
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 TR15R {
362    bits: bool,
363}
364impl TR15R {
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 TR16R {
383    bits: bool,
384}
385impl TR16R {
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 TR17R {
404    bits: bool,
405}
406impl TR17R {
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 TR18R {
425    bits: bool,
426}
427impl TR18R {
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 _TR0W<'a> {
446    w: &'a mut W,
447}
448impl<'a> _TR0W<'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 _TR1W<'a> {
469    w: &'a mut W,
470}
471impl<'a> _TR1W<'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 _TR2W<'a> {
492    w: &'a mut W,
493}
494impl<'a> _TR2W<'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 _TR3W<'a> {
515    w: &'a mut W,
516}
517impl<'a> _TR3W<'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 _TR4W<'a> {
538    w: &'a mut W,
539}
540impl<'a> _TR4W<'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 _TR5W<'a> {
561    w: &'a mut W,
562}
563impl<'a> _TR5W<'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 _TR6W<'a> {
584    w: &'a mut W,
585}
586impl<'a> _TR6W<'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 _TR7W<'a> {
607    w: &'a mut W,
608}
609impl<'a> _TR7W<'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 _TR8W<'a> {
630    w: &'a mut W,
631}
632impl<'a> _TR8W<'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 _TR9W<'a> {
653    w: &'a mut W,
654}
655impl<'a> _TR9W<'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 _TR10W<'a> {
676    w: &'a mut W,
677}
678impl<'a> _TR10W<'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 _TR11W<'a> {
699    w: &'a mut W,
700}
701impl<'a> _TR11W<'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 _TR12W<'a> {
722    w: &'a mut W,
723}
724impl<'a> _TR12W<'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 _TR13W<'a> {
745    w: &'a mut W,
746}
747impl<'a> _TR13W<'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 _TR14W<'a> {
768    w: &'a mut W,
769}
770impl<'a> _TR14W<'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 _TR15W<'a> {
791    w: &'a mut W,
792}
793impl<'a> _TR15W<'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 _TR16W<'a> {
814    w: &'a mut W,
815}
816impl<'a> _TR16W<'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 _TR17W<'a> {
837    w: &'a mut W,
838}
839impl<'a> _TR17W<'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 _TR18W<'a> {
860    w: &'a mut W,
861}
862impl<'a> _TR18W<'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 - Rising trigger event configuration of line 0"]
888    #[inline]
889    pub fn tr0(&self) -> TR0R {
890        let bits = {
891            const MASK: bool = true;
892            const OFFSET: u8 = 0;
893            ((self.bits >> OFFSET) & MASK as u32) != 0
894        };
895        TR0R { bits }
896    }
897    #[doc = "Bit 1 - Rising trigger event configuration of line 1"]
898    #[inline]
899    pub fn tr1(&self) -> TR1R {
900        let bits = {
901            const MASK: bool = true;
902            const OFFSET: u8 = 1;
903            ((self.bits >> OFFSET) & MASK as u32) != 0
904        };
905        TR1R { bits }
906    }
907    #[doc = "Bit 2 - Rising trigger event configuration of line 2"]
908    #[inline]
909    pub fn tr2(&self) -> TR2R {
910        let bits = {
911            const MASK: bool = true;
912            const OFFSET: u8 = 2;
913            ((self.bits >> OFFSET) & MASK as u32) != 0
914        };
915        TR2R { bits }
916    }
917    #[doc = "Bit 3 - Rising trigger event configuration of line 3"]
918    #[inline]
919    pub fn tr3(&self) -> TR3R {
920        let bits = {
921            const MASK: bool = true;
922            const OFFSET: u8 = 3;
923            ((self.bits >> OFFSET) & MASK as u32) != 0
924        };
925        TR3R { bits }
926    }
927    #[doc = "Bit 4 - Rising trigger event configuration of line 4"]
928    #[inline]
929    pub fn tr4(&self) -> TR4R {
930        let bits = {
931            const MASK: bool = true;
932            const OFFSET: u8 = 4;
933            ((self.bits >> OFFSET) & MASK as u32) != 0
934        };
935        TR4R { bits }
936    }
937    #[doc = "Bit 5 - Rising trigger event configuration of line 5"]
938    #[inline]
939    pub fn tr5(&self) -> TR5R {
940        let bits = {
941            const MASK: bool = true;
942            const OFFSET: u8 = 5;
943            ((self.bits >> OFFSET) & MASK as u32) != 0
944        };
945        TR5R { bits }
946    }
947    #[doc = "Bit 6 - Rising trigger event configuration of line 6"]
948    #[inline]
949    pub fn tr6(&self) -> TR6R {
950        let bits = {
951            const MASK: bool = true;
952            const OFFSET: u8 = 6;
953            ((self.bits >> OFFSET) & MASK as u32) != 0
954        };
955        TR6R { bits }
956    }
957    #[doc = "Bit 7 - Rising trigger event configuration of line 7"]
958    #[inline]
959    pub fn tr7(&self) -> TR7R {
960        let bits = {
961            const MASK: bool = true;
962            const OFFSET: u8 = 7;
963            ((self.bits >> OFFSET) & MASK as u32) != 0
964        };
965        TR7R { bits }
966    }
967    #[doc = "Bit 8 - Rising trigger event configuration of line 8"]
968    #[inline]
969    pub fn tr8(&self) -> TR8R {
970        let bits = {
971            const MASK: bool = true;
972            const OFFSET: u8 = 8;
973            ((self.bits >> OFFSET) & MASK as u32) != 0
974        };
975        TR8R { bits }
976    }
977    #[doc = "Bit 9 - Rising trigger event configuration of line 9"]
978    #[inline]
979    pub fn tr9(&self) -> TR9R {
980        let bits = {
981            const MASK: bool = true;
982            const OFFSET: u8 = 9;
983            ((self.bits >> OFFSET) & MASK as u32) != 0
984        };
985        TR9R { bits }
986    }
987    #[doc = "Bit 10 - Rising trigger event configuration of line 10"]
988    #[inline]
989    pub fn tr10(&self) -> TR10R {
990        let bits = {
991            const MASK: bool = true;
992            const OFFSET: u8 = 10;
993            ((self.bits >> OFFSET) & MASK as u32) != 0
994        };
995        TR10R { bits }
996    }
997    #[doc = "Bit 11 - Rising trigger event configuration of line 11"]
998    #[inline]
999    pub fn tr11(&self) -> TR11R {
1000        let bits = {
1001            const MASK: bool = true;
1002            const OFFSET: u8 = 11;
1003            ((self.bits >> OFFSET) & MASK as u32) != 0
1004        };
1005        TR11R { bits }
1006    }
1007    #[doc = "Bit 12 - Rising trigger event configuration of line 12"]
1008    #[inline]
1009    pub fn tr12(&self) -> TR12R {
1010        let bits = {
1011            const MASK: bool = true;
1012            const OFFSET: u8 = 12;
1013            ((self.bits >> OFFSET) & MASK as u32) != 0
1014        };
1015        TR12R { bits }
1016    }
1017    #[doc = "Bit 13 - Rising trigger event configuration of line 13"]
1018    #[inline]
1019    pub fn tr13(&self) -> TR13R {
1020        let bits = {
1021            const MASK: bool = true;
1022            const OFFSET: u8 = 13;
1023            ((self.bits >> OFFSET) & MASK as u32) != 0
1024        };
1025        TR13R { bits }
1026    }
1027    #[doc = "Bit 14 - Rising trigger event configuration of line 14"]
1028    #[inline]
1029    pub fn tr14(&self) -> TR14R {
1030        let bits = {
1031            const MASK: bool = true;
1032            const OFFSET: u8 = 14;
1033            ((self.bits >> OFFSET) & MASK as u32) != 0
1034        };
1035        TR14R { bits }
1036    }
1037    #[doc = "Bit 15 - Rising trigger event configuration of line 15"]
1038    #[inline]
1039    pub fn tr15(&self) -> TR15R {
1040        let bits = {
1041            const MASK: bool = true;
1042            const OFFSET: u8 = 15;
1043            ((self.bits >> OFFSET) & MASK as u32) != 0
1044        };
1045        TR15R { bits }
1046    }
1047    #[doc = "Bit 16 - Rising trigger event configuration of line 16"]
1048    #[inline]
1049    pub fn tr16(&self) -> TR16R {
1050        let bits = {
1051            const MASK: bool = true;
1052            const OFFSET: u8 = 16;
1053            ((self.bits >> OFFSET) & MASK as u32) != 0
1054        };
1055        TR16R { bits }
1056    }
1057    #[doc = "Bit 17 - Rising trigger event configuration of line 17"]
1058    #[inline]
1059    pub fn tr17(&self) -> TR17R {
1060        let bits = {
1061            const MASK: bool = true;
1062            const OFFSET: u8 = 17;
1063            ((self.bits >> OFFSET) & MASK as u32) != 0
1064        };
1065        TR17R { bits }
1066    }
1067    #[doc = "Bit 18 - Rising trigger event configuration of line 18"]
1068    #[inline]
1069    pub fn tr18(&self) -> TR18R {
1070        let bits = {
1071            const MASK: bool = true;
1072            const OFFSET: u8 = 18;
1073            ((self.bits >> OFFSET) & MASK as u32) != 0
1074        };
1075        TR18R { 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 - Rising trigger event configuration of line 0"]
1091    #[inline]
1092    pub fn tr0(&mut self) -> _TR0W {
1093        _TR0W { w: self }
1094    }
1095    #[doc = "Bit 1 - Rising trigger event configuration of line 1"]
1096    #[inline]
1097    pub fn tr1(&mut self) -> _TR1W {
1098        _TR1W { w: self }
1099    }
1100    #[doc = "Bit 2 - Rising trigger event configuration of line 2"]
1101    #[inline]
1102    pub fn tr2(&mut self) -> _TR2W {
1103        _TR2W { w: self }
1104    }
1105    #[doc = "Bit 3 - Rising trigger event configuration of line 3"]
1106    #[inline]
1107    pub fn tr3(&mut self) -> _TR3W {
1108        _TR3W { w: self }
1109    }
1110    #[doc = "Bit 4 - Rising trigger event configuration of line 4"]
1111    #[inline]
1112    pub fn tr4(&mut self) -> _TR4W {
1113        _TR4W { w: self }
1114    }
1115    #[doc = "Bit 5 - Rising trigger event configuration of line 5"]
1116    #[inline]
1117    pub fn tr5(&mut self) -> _TR5W {
1118        _TR5W { w: self }
1119    }
1120    #[doc = "Bit 6 - Rising trigger event configuration of line 6"]
1121    #[inline]
1122    pub fn tr6(&mut self) -> _TR6W {
1123        _TR6W { w: self }
1124    }
1125    #[doc = "Bit 7 - Rising trigger event configuration of line 7"]
1126    #[inline]
1127    pub fn tr7(&mut self) -> _TR7W {
1128        _TR7W { w: self }
1129    }
1130    #[doc = "Bit 8 - Rising trigger event configuration of line 8"]
1131    #[inline]
1132    pub fn tr8(&mut self) -> _TR8W {
1133        _TR8W { w: self }
1134    }
1135    #[doc = "Bit 9 - Rising trigger event configuration of line 9"]
1136    #[inline]
1137    pub fn tr9(&mut self) -> _TR9W {
1138        _TR9W { w: self }
1139    }
1140    #[doc = "Bit 10 - Rising trigger event configuration of line 10"]
1141    #[inline]
1142    pub fn tr10(&mut self) -> _TR10W {
1143        _TR10W { w: self }
1144    }
1145    #[doc = "Bit 11 - Rising trigger event configuration of line 11"]
1146    #[inline]
1147    pub fn tr11(&mut self) -> _TR11W {
1148        _TR11W { w: self }
1149    }
1150    #[doc = "Bit 12 - Rising trigger event configuration of line 12"]
1151    #[inline]
1152    pub fn tr12(&mut self) -> _TR12W {
1153        _TR12W { w: self }
1154    }
1155    #[doc = "Bit 13 - Rising trigger event configuration of line 13"]
1156    #[inline]
1157    pub fn tr13(&mut self) -> _TR13W {
1158        _TR13W { w: self }
1159    }
1160    #[doc = "Bit 14 - Rising trigger event configuration of line 14"]
1161    #[inline]
1162    pub fn tr14(&mut self) -> _TR14W {
1163        _TR14W { w: self }
1164    }
1165    #[doc = "Bit 15 - Rising trigger event configuration of line 15"]
1166    #[inline]
1167    pub fn tr15(&mut self) -> _TR15W {
1168        _TR15W { w: self }
1169    }
1170    #[doc = "Bit 16 - Rising trigger event configuration of line 16"]
1171    #[inline]
1172    pub fn tr16(&mut self) -> _TR16W {
1173        _TR16W { w: self }
1174    }
1175    #[doc = "Bit 17 - Rising trigger event configuration of line 17"]
1176    #[inline]
1177    pub fn tr17(&mut self) -> _TR17W {
1178        _TR17W { w: self }
1179    }
1180    #[doc = "Bit 18 - Rising trigger event configuration of line 18"]
1181    #[inline]
1182    pub fn tr18(&mut self) -> _TR18W {
1183        _TR18W { w: self }
1184    }
1185}
stm32f103xx/exti/rtsr/mod.rs

stm32f103xx/exti/rtsr/
mod.rs
