stm32l4x2_pac/rtc/
isr.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::ISR {
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 ALRAWFR {
47    bits: bool,
48}
49impl ALRAWFR {
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 ALRBWFR {
68    bits: bool,
69}
70impl ALRBWFR {
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 WUTWFR {
89    bits: bool,
90}
91impl WUTWFR {
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 SHPFR {
110    bits: bool,
111}
112impl SHPFR {
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 INITSR {
131    bits: bool,
132}
133impl INITSR {
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 RSFR {
152    bits: bool,
153}
154impl RSFR {
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 INITFR {
173    bits: bool,
174}
175impl INITFR {
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 INITR {
194    bits: bool,
195}
196impl INITR {
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 ALRAFR {
215    bits: bool,
216}
217impl ALRAFR {
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 ALRBFR {
236    bits: bool,
237}
238impl ALRBFR {
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 WUTFR {
257    bits: bool,
258}
259impl WUTFR {
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 TSFR {
278    bits: bool,
279}
280impl TSFR {
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 TSOVFR {
299    bits: bool,
300}
301impl TSOVFR {
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 TAMP1FR {
320    bits: bool,
321}
322impl TAMP1FR {
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 TAMP2FR {
341    bits: bool,
342}
343impl TAMP2FR {
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 TAMP3FR {
362    bits: bool,
363}
364impl TAMP3FR {
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 RECALPFR {
383    bits: bool,
384}
385impl RECALPFR {
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" Proxy"]
403pub struct _SHPFW<'a> {
404    w: &'a mut W,
405}
406impl<'a> _SHPFW<'a> {
407    #[doc = r" Sets the field bit"]
408    pub fn set_bit(self) -> &'a mut W {
409        self.bit(true)
410    }
411    #[doc = r" Clears the field bit"]
412    pub fn clear_bit(self) -> &'a mut W {
413        self.bit(false)
414    }
415    #[doc = r" Writes raw bits to the field"]
416    #[inline]
417    pub fn bit(self, value: bool) -> &'a mut W {
418        const MASK: bool = true;
419        const OFFSET: u8 = 3;
420        self.w.bits &= !((MASK as u32) << OFFSET);
421        self.w.bits |= ((value & MASK) as u32) << OFFSET;
422        self.w
423    }
424}
425#[doc = r" Proxy"]
426pub struct _RSFW<'a> {
427    w: &'a mut W,
428}
429impl<'a> _RSFW<'a> {
430    #[doc = r" Sets the field bit"]
431    pub fn set_bit(self) -> &'a mut W {
432        self.bit(true)
433    }
434    #[doc = r" Clears the field bit"]
435    pub fn clear_bit(self) -> &'a mut W {
436        self.bit(false)
437    }
438    #[doc = r" Writes raw bits to the field"]
439    #[inline]
440    pub fn bit(self, value: bool) -> &'a mut W {
441        const MASK: bool = true;
442        const OFFSET: u8 = 5;
443        self.w.bits &= !((MASK as u32) << OFFSET);
444        self.w.bits |= ((value & MASK) as u32) << OFFSET;
445        self.w
446    }
447}
448#[doc = r" Proxy"]
449pub struct _INITW<'a> {
450    w: &'a mut W,
451}
452impl<'a> _INITW<'a> {
453    #[doc = r" Sets the field bit"]
454    pub fn set_bit(self) -> &'a mut W {
455        self.bit(true)
456    }
457    #[doc = r" Clears the field bit"]
458    pub fn clear_bit(self) -> &'a mut W {
459        self.bit(false)
460    }
461    #[doc = r" Writes raw bits to the field"]
462    #[inline]
463    pub fn bit(self, value: bool) -> &'a mut W {
464        const MASK: bool = true;
465        const OFFSET: u8 = 7;
466        self.w.bits &= !((MASK as u32) << OFFSET);
467        self.w.bits |= ((value & MASK) as u32) << OFFSET;
468        self.w
469    }
470}
471#[doc = r" Proxy"]
472pub struct _ALRAFW<'a> {
473    w: &'a mut W,
474}
475impl<'a> _ALRAFW<'a> {
476    #[doc = r" Sets the field bit"]
477    pub fn set_bit(self) -> &'a mut W {
478        self.bit(true)
479    }
480    #[doc = r" Clears the field bit"]
481    pub fn clear_bit(self) -> &'a mut W {
482        self.bit(false)
483    }
484    #[doc = r" Writes raw bits to the field"]
485    #[inline]
486    pub fn bit(self, value: bool) -> &'a mut W {
487        const MASK: bool = true;
488        const OFFSET: u8 = 8;
489        self.w.bits &= !((MASK as u32) << OFFSET);
490        self.w.bits |= ((value & MASK) as u32) << OFFSET;
491        self.w
492    }
493}
494#[doc = r" Proxy"]
495pub struct _ALRBFW<'a> {
496    w: &'a mut W,
497}
498impl<'a> _ALRBFW<'a> {
499    #[doc = r" Sets the field bit"]
500    pub fn set_bit(self) -> &'a mut W {
501        self.bit(true)
502    }
503    #[doc = r" Clears the field bit"]
504    pub fn clear_bit(self) -> &'a mut W {
505        self.bit(false)
506    }
507    #[doc = r" Writes raw bits to the field"]
508    #[inline]
509    pub fn bit(self, value: bool) -> &'a mut W {
510        const MASK: bool = true;
511        const OFFSET: u8 = 9;
512        self.w.bits &= !((MASK as u32) << OFFSET);
513        self.w.bits |= ((value & MASK) as u32) << OFFSET;
514        self.w
515    }
516}
517#[doc = r" Proxy"]
518pub struct _WUTFW<'a> {
519    w: &'a mut W,
520}
521impl<'a> _WUTFW<'a> {
522    #[doc = r" Sets the field bit"]
523    pub fn set_bit(self) -> &'a mut W {
524        self.bit(true)
525    }
526    #[doc = r" Clears the field bit"]
527    pub fn clear_bit(self) -> &'a mut W {
528        self.bit(false)
529    }
530    #[doc = r" Writes raw bits to the field"]
531    #[inline]
532    pub fn bit(self, value: bool) -> &'a mut W {
533        const MASK: bool = true;
534        const OFFSET: u8 = 10;
535        self.w.bits &= !((MASK as u32) << OFFSET);
536        self.w.bits |= ((value & MASK) as u32) << OFFSET;
537        self.w
538    }
539}
540#[doc = r" Proxy"]
541pub struct _TSFW<'a> {
542    w: &'a mut W,
543}
544impl<'a> _TSFW<'a> {
545    #[doc = r" Sets the field bit"]
546    pub fn set_bit(self) -> &'a mut W {
547        self.bit(true)
548    }
549    #[doc = r" Clears the field bit"]
550    pub fn clear_bit(self) -> &'a mut W {
551        self.bit(false)
552    }
553    #[doc = r" Writes raw bits to the field"]
554    #[inline]
555    pub fn bit(self, value: bool) -> &'a mut W {
556        const MASK: bool = true;
557        const OFFSET: u8 = 11;
558        self.w.bits &= !((MASK as u32) << OFFSET);
559        self.w.bits |= ((value & MASK) as u32) << OFFSET;
560        self.w
561    }
562}
563#[doc = r" Proxy"]
564pub struct _TSOVFW<'a> {
565    w: &'a mut W,
566}
567impl<'a> _TSOVFW<'a> {
568    #[doc = r" Sets the field bit"]
569    pub fn set_bit(self) -> &'a mut W {
570        self.bit(true)
571    }
572    #[doc = r" Clears the field bit"]
573    pub fn clear_bit(self) -> &'a mut W {
574        self.bit(false)
575    }
576    #[doc = r" Writes raw bits to the field"]
577    #[inline]
578    pub fn bit(self, value: bool) -> &'a mut W {
579        const MASK: bool = true;
580        const OFFSET: u8 = 12;
581        self.w.bits &= !((MASK as u32) << OFFSET);
582        self.w.bits |= ((value & MASK) as u32) << OFFSET;
583        self.w
584    }
585}
586#[doc = r" Proxy"]
587pub struct _TAMP1FW<'a> {
588    w: &'a mut W,
589}
590impl<'a> _TAMP1FW<'a> {
591    #[doc = r" Sets the field bit"]
592    pub fn set_bit(self) -> &'a mut W {
593        self.bit(true)
594    }
595    #[doc = r" Clears the field bit"]
596    pub fn clear_bit(self) -> &'a mut W {
597        self.bit(false)
598    }
599    #[doc = r" Writes raw bits to the field"]
600    #[inline]
601    pub fn bit(self, value: bool) -> &'a mut W {
602        const MASK: bool = true;
603        const OFFSET: u8 = 13;
604        self.w.bits &= !((MASK as u32) << OFFSET);
605        self.w.bits |= ((value & MASK) as u32) << OFFSET;
606        self.w
607    }
608}
609#[doc = r" Proxy"]
610pub struct _TAMP2FW<'a> {
611    w: &'a mut W,
612}
613impl<'a> _TAMP2FW<'a> {
614    #[doc = r" Sets the field bit"]
615    pub fn set_bit(self) -> &'a mut W {
616        self.bit(true)
617    }
618    #[doc = r" Clears the field bit"]
619    pub fn clear_bit(self) -> &'a mut W {
620        self.bit(false)
621    }
622    #[doc = r" Writes raw bits to the field"]
623    #[inline]
624    pub fn bit(self, value: bool) -> &'a mut W {
625        const MASK: bool = true;
626        const OFFSET: u8 = 14;
627        self.w.bits &= !((MASK as u32) << OFFSET);
628        self.w.bits |= ((value & MASK) as u32) << OFFSET;
629        self.w
630    }
631}
632#[doc = r" Proxy"]
633pub struct _TAMP3FW<'a> {
634    w: &'a mut W,
635}
636impl<'a> _TAMP3FW<'a> {
637    #[doc = r" Sets the field bit"]
638    pub fn set_bit(self) -> &'a mut W {
639        self.bit(true)
640    }
641    #[doc = r" Clears the field bit"]
642    pub fn clear_bit(self) -> &'a mut W {
643        self.bit(false)
644    }
645    #[doc = r" Writes raw bits to the field"]
646    #[inline]
647    pub fn bit(self, value: bool) -> &'a mut W {
648        const MASK: bool = true;
649        const OFFSET: u8 = 15;
650        self.w.bits &= !((MASK as u32) << OFFSET);
651        self.w.bits |= ((value & MASK) as u32) << OFFSET;
652        self.w
653    }
654}
655impl R {
656    #[doc = r" Value of the register as raw bits"]
657    #[inline]
658    pub fn bits(&self) -> u32 {
659        self.bits
660    }
661    #[doc = "Bit 0 - Alarm A write flag"]
662    #[inline]
663    pub fn alrawf(&self) -> ALRAWFR {
664        let bits = {
665            const MASK: bool = true;
666            const OFFSET: u8 = 0;
667            ((self.bits >> OFFSET) & MASK as u32) != 0
668        };
669        ALRAWFR { bits }
670    }
671    #[doc = "Bit 1 - Alarm B write flag"]
672    #[inline]
673    pub fn alrbwf(&self) -> ALRBWFR {
674        let bits = {
675            const MASK: bool = true;
676            const OFFSET: u8 = 1;
677            ((self.bits >> OFFSET) & MASK as u32) != 0
678        };
679        ALRBWFR { bits }
680    }
681    #[doc = "Bit 2 - Wakeup timer write flag"]
682    #[inline]
683    pub fn wutwf(&self) -> WUTWFR {
684        let bits = {
685            const MASK: bool = true;
686            const OFFSET: u8 = 2;
687            ((self.bits >> OFFSET) & MASK as u32) != 0
688        };
689        WUTWFR { bits }
690    }
691    #[doc = "Bit 3 - Shift operation pending"]
692    #[inline]
693    pub fn shpf(&self) -> SHPFR {
694        let bits = {
695            const MASK: bool = true;
696            const OFFSET: u8 = 3;
697            ((self.bits >> OFFSET) & MASK as u32) != 0
698        };
699        SHPFR { bits }
700    }
701    #[doc = "Bit 4 - Initialization status flag"]
702    #[inline]
703    pub fn inits(&self) -> INITSR {
704        let bits = {
705            const MASK: bool = true;
706            const OFFSET: u8 = 4;
707            ((self.bits >> OFFSET) & MASK as u32) != 0
708        };
709        INITSR { bits }
710    }
711    #[doc = "Bit 5 - Registers synchronization flag"]
712    #[inline]
713    pub fn rsf(&self) -> RSFR {
714        let bits = {
715            const MASK: bool = true;
716            const OFFSET: u8 = 5;
717            ((self.bits >> OFFSET) & MASK as u32) != 0
718        };
719        RSFR { bits }
720    }
721    #[doc = "Bit 6 - Initialization flag"]
722    #[inline]
723    pub fn initf(&self) -> INITFR {
724        let bits = {
725            const MASK: bool = true;
726            const OFFSET: u8 = 6;
727            ((self.bits >> OFFSET) & MASK as u32) != 0
728        };
729        INITFR { bits }
730    }
731    #[doc = "Bit 7 - Initialization mode"]
732    #[inline]
733    pub fn init(&self) -> INITR {
734        let bits = {
735            const MASK: bool = true;
736            const OFFSET: u8 = 7;
737            ((self.bits >> OFFSET) & MASK as u32) != 0
738        };
739        INITR { bits }
740    }
741    #[doc = "Bit 8 - Alarm A flag"]
742    #[inline]
743    pub fn alraf(&self) -> ALRAFR {
744        let bits = {
745            const MASK: bool = true;
746            const OFFSET: u8 = 8;
747            ((self.bits >> OFFSET) & MASK as u32) != 0
748        };
749        ALRAFR { bits }
750    }
751    #[doc = "Bit 9 - Alarm B flag"]
752    #[inline]
753    pub fn alrbf(&self) -> ALRBFR {
754        let bits = {
755            const MASK: bool = true;
756            const OFFSET: u8 = 9;
757            ((self.bits >> OFFSET) & MASK as u32) != 0
758        };
759        ALRBFR { bits }
760    }
761    #[doc = "Bit 10 - Wakeup timer flag"]
762    #[inline]
763    pub fn wutf(&self) -> WUTFR {
764        let bits = {
765            const MASK: bool = true;
766            const OFFSET: u8 = 10;
767            ((self.bits >> OFFSET) & MASK as u32) != 0
768        };
769        WUTFR { bits }
770    }
771    #[doc = "Bit 11 - Time-stamp flag"]
772    #[inline]
773    pub fn tsf(&self) -> TSFR {
774        let bits = {
775            const MASK: bool = true;
776            const OFFSET: u8 = 11;
777            ((self.bits >> OFFSET) & MASK as u32) != 0
778        };
779        TSFR { bits }
780    }
781    #[doc = "Bit 12 - Time-stamp overflow flag"]
782    #[inline]
783    pub fn tsovf(&self) -> TSOVFR {
784        let bits = {
785            const MASK: bool = true;
786            const OFFSET: u8 = 12;
787            ((self.bits >> OFFSET) & MASK as u32) != 0
788        };
789        TSOVFR { bits }
790    }
791    #[doc = "Bit 13 - Tamper detection flag"]
792    #[inline]
793    pub fn tamp1f(&self) -> TAMP1FR {
794        let bits = {
795            const MASK: bool = true;
796            const OFFSET: u8 = 13;
797            ((self.bits >> OFFSET) & MASK as u32) != 0
798        };
799        TAMP1FR { bits }
800    }
801    #[doc = "Bit 14 - RTC_TAMP2 detection flag"]
802    #[inline]
803    pub fn tamp2f(&self) -> TAMP2FR {
804        let bits = {
805            const MASK: bool = true;
806            const OFFSET: u8 = 14;
807            ((self.bits >> OFFSET) & MASK as u32) != 0
808        };
809        TAMP2FR { bits }
810    }
811    #[doc = "Bit 15 - RTC_TAMP3 detection flag"]
812    #[inline]
813    pub fn tamp3f(&self) -> TAMP3FR {
814        let bits = {
815            const MASK: bool = true;
816            const OFFSET: u8 = 15;
817            ((self.bits >> OFFSET) & MASK as u32) != 0
818        };
819        TAMP3FR { bits }
820    }
821    #[doc = "Bit 16 - Recalibration pending Flag"]
822    #[inline]
823    pub fn recalpf(&self) -> RECALPFR {
824        let bits = {
825            const MASK: bool = true;
826            const OFFSET: u8 = 16;
827            ((self.bits >> OFFSET) & MASK as u32) != 0
828        };
829        RECALPFR { bits }
830    }
831}
832impl W {
833    #[doc = r" Reset value of the register"]
834    #[inline]
835    pub fn reset_value() -> W {
836        W { bits: 7 }
837    }
838    #[doc = r" Writes raw bits to the register"]
839    #[inline]
840    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
841        self.bits = bits;
842        self
843    }
844    #[doc = "Bit 3 - Shift operation pending"]
845    #[inline]
846    pub fn shpf(&mut self) -> _SHPFW {
847        _SHPFW { w: self }
848    }
849    #[doc = "Bit 5 - Registers synchronization flag"]
850    #[inline]
851    pub fn rsf(&mut self) -> _RSFW {
852        _RSFW { w: self }
853    }
854    #[doc = "Bit 7 - Initialization mode"]
855    #[inline]
856    pub fn init(&mut self) -> _INITW {
857        _INITW { w: self }
858    }
859    #[doc = "Bit 8 - Alarm A flag"]
860    #[inline]
861    pub fn alraf(&mut self) -> _ALRAFW {
862        _ALRAFW { w: self }
863    }
864    #[doc = "Bit 9 - Alarm B flag"]
865    #[inline]
866    pub fn alrbf(&mut self) -> _ALRBFW {
867        _ALRBFW { w: self }
868    }
869    #[doc = "Bit 10 - Wakeup timer flag"]
870    #[inline]
871    pub fn wutf(&mut self) -> _WUTFW {
872        _WUTFW { w: self }
873    }
874    #[doc = "Bit 11 - Time-stamp flag"]
875    #[inline]
876    pub fn tsf(&mut self) -> _TSFW {
877        _TSFW { w: self }
878    }
879    #[doc = "Bit 12 - Time-stamp overflow flag"]
880    #[inline]
881    pub fn tsovf(&mut self) -> _TSOVFW {
882        _TSOVFW { w: self }
883    }
884    #[doc = "Bit 13 - Tamper detection flag"]
885    #[inline]
886    pub fn tamp1f(&mut self) -> _TAMP1FW {
887        _TAMP1FW { w: self }
888    }
889    #[doc = "Bit 14 - RTC_TAMP2 detection flag"]
890    #[inline]
891    pub fn tamp2f(&mut self) -> _TAMP2FW {
892        _TAMP2FW { w: self }
893    }
894    #[doc = "Bit 15 - RTC_TAMP3 detection flag"]
895    #[inline]
896    pub fn tamp3f(&mut self) -> _TAMP3FW {
897        _TAMP3FW { w: self }
898    }
899}
stm32l4x2_pac/rtc/isr.rs

stm32l4x2_pac/rtc/
isr.rs
