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

stm32l4x2_pac/exti/
rtsr1.rs
