stm32wb_pac/rtc/
tampcr.rs

1#[doc = "Reader of register TAMPCR"]
2pub type R = crate::R<u32, super::TAMPCR>;
3#[doc = "Writer for register TAMPCR"]
4pub type W = crate::W<u32, super::TAMPCR>;
5#[doc = "Register TAMPCR `reset()`'s with value 0"]
6impl crate::ResetValue for super::TAMPCR {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0
11    }
12}
13#[doc = "Reader of field `TAMP1E`"]
14pub type TAMP1E_R = crate::R<bool, bool>;
15#[doc = "Write proxy for field `TAMP1E`"]
16pub struct TAMP1E_W<'a> {
17    w: &'a mut W,
18}
19impl<'a> TAMP1E_W<'a> {
20    #[doc = r"Sets the field bit"]
21    #[inline(always)]
22    pub fn set_bit(self) -> &'a mut W {
23        self.bit(true)
24    }
25    #[doc = r"Clears the field bit"]
26    #[inline(always)]
27    pub fn clear_bit(self) -> &'a mut W {
28        self.bit(false)
29    }
30    #[doc = r"Writes raw bits to the field"]
31    #[inline(always)]
32    pub fn bit(self, value: bool) -> &'a mut W {
33        self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
34        self.w
35    }
36}
37#[doc = "Reader of field `TAMP1TRG`"]
38pub type TAMP1TRG_R = crate::R<bool, bool>;
39#[doc = "Write proxy for field `TAMP1TRG`"]
40pub struct TAMP1TRG_W<'a> {
41    w: &'a mut W,
42}
43impl<'a> TAMP1TRG_W<'a> {
44    #[doc = r"Sets the field bit"]
45    #[inline(always)]
46    pub fn set_bit(self) -> &'a mut W {
47        self.bit(true)
48    }
49    #[doc = r"Clears the field bit"]
50    #[inline(always)]
51    pub fn clear_bit(self) -> &'a mut W {
52        self.bit(false)
53    }
54    #[doc = r"Writes raw bits to the field"]
55    #[inline(always)]
56    pub fn bit(self, value: bool) -> &'a mut W {
57        self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
58        self.w
59    }
60}
61#[doc = "Reader of field `TAMPIE`"]
62pub type TAMPIE_R = crate::R<bool, bool>;
63#[doc = "Write proxy for field `TAMPIE`"]
64pub struct TAMPIE_W<'a> {
65    w: &'a mut W,
66}
67impl<'a> TAMPIE_W<'a> {
68    #[doc = r"Sets the field bit"]
69    #[inline(always)]
70    pub fn set_bit(self) -> &'a mut W {
71        self.bit(true)
72    }
73    #[doc = r"Clears the field bit"]
74    #[inline(always)]
75    pub fn clear_bit(self) -> &'a mut W {
76        self.bit(false)
77    }
78    #[doc = r"Writes raw bits to the field"]
79    #[inline(always)]
80    pub fn bit(self, value: bool) -> &'a mut W {
81        self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
82        self.w
83    }
84}
85#[doc = "Reader of field `TAMP2E`"]
86pub type TAMP2E_R = crate::R<bool, bool>;
87#[doc = "Write proxy for field `TAMP2E`"]
88pub struct TAMP2E_W<'a> {
89    w: &'a mut W,
90}
91impl<'a> TAMP2E_W<'a> {
92    #[doc = r"Sets the field bit"]
93    #[inline(always)]
94    pub fn set_bit(self) -> &'a mut W {
95        self.bit(true)
96    }
97    #[doc = r"Clears the field bit"]
98    #[inline(always)]
99    pub fn clear_bit(self) -> &'a mut W {
100        self.bit(false)
101    }
102    #[doc = r"Writes raw bits to the field"]
103    #[inline(always)]
104    pub fn bit(self, value: bool) -> &'a mut W {
105        self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
106        self.w
107    }
108}
109#[doc = "Reader of field `TAMP2TRG`"]
110pub type TAMP2TRG_R = crate::R<bool, bool>;
111#[doc = "Write proxy for field `TAMP2TRG`"]
112pub struct TAMP2TRG_W<'a> {
113    w: &'a mut W,
114}
115impl<'a> TAMP2TRG_W<'a> {
116    #[doc = r"Sets the field bit"]
117    #[inline(always)]
118    pub fn set_bit(self) -> &'a mut W {
119        self.bit(true)
120    }
121    #[doc = r"Clears the field bit"]
122    #[inline(always)]
123    pub fn clear_bit(self) -> &'a mut W {
124        self.bit(false)
125    }
126    #[doc = r"Writes raw bits to the field"]
127    #[inline(always)]
128    pub fn bit(self, value: bool) -> &'a mut W {
129        self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
130        self.w
131    }
132}
133#[doc = "Reader of field `TAMP3E`"]
134pub type TAMP3E_R = crate::R<bool, bool>;
135#[doc = "Write proxy for field `TAMP3E`"]
136pub struct TAMP3E_W<'a> {
137    w: &'a mut W,
138}
139impl<'a> TAMP3E_W<'a> {
140    #[doc = r"Sets the field bit"]
141    #[inline(always)]
142    pub fn set_bit(self) -> &'a mut W {
143        self.bit(true)
144    }
145    #[doc = r"Clears the field bit"]
146    #[inline(always)]
147    pub fn clear_bit(self) -> &'a mut W {
148        self.bit(false)
149    }
150    #[doc = r"Writes raw bits to the field"]
151    #[inline(always)]
152    pub fn bit(self, value: bool) -> &'a mut W {
153        self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
154        self.w
155    }
156}
157#[doc = "Reader of field `TAMP3TRG`"]
158pub type TAMP3TRG_R = crate::R<bool, bool>;
159#[doc = "Write proxy for field `TAMP3TRG`"]
160pub struct TAMP3TRG_W<'a> {
161    w: &'a mut W,
162}
163impl<'a> TAMP3TRG_W<'a> {
164    #[doc = r"Sets the field bit"]
165    #[inline(always)]
166    pub fn set_bit(self) -> &'a mut W {
167        self.bit(true)
168    }
169    #[doc = r"Clears the field bit"]
170    #[inline(always)]
171    pub fn clear_bit(self) -> &'a mut W {
172        self.bit(false)
173    }
174    #[doc = r"Writes raw bits to the field"]
175    #[inline(always)]
176    pub fn bit(self, value: bool) -> &'a mut W {
177        self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
178        self.w
179    }
180}
181#[doc = "Reader of field `TAMPTS`"]
182pub type TAMPTS_R = crate::R<bool, bool>;
183#[doc = "Write proxy for field `TAMPTS`"]
184pub struct TAMPTS_W<'a> {
185    w: &'a mut W,
186}
187impl<'a> TAMPTS_W<'a> {
188    #[doc = r"Sets the field bit"]
189    #[inline(always)]
190    pub fn set_bit(self) -> &'a mut W {
191        self.bit(true)
192    }
193    #[doc = r"Clears the field bit"]
194    #[inline(always)]
195    pub fn clear_bit(self) -> &'a mut W {
196        self.bit(false)
197    }
198    #[doc = r"Writes raw bits to the field"]
199    #[inline(always)]
200    pub fn bit(self, value: bool) -> &'a mut W {
201        self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
202        self.w
203    }
204}
205#[doc = "Reader of field `TAMPFREQ`"]
206pub type TAMPFREQ_R = crate::R<u8, u8>;
207#[doc = "Write proxy for field `TAMPFREQ`"]
208pub struct TAMPFREQ_W<'a> {
209    w: &'a mut W,
210}
211impl<'a> TAMPFREQ_W<'a> {
212    #[doc = r"Writes raw bits to the field"]
213    #[inline(always)]
214    pub unsafe fn bits(self, value: u8) -> &'a mut W {
215        self.w.bits = (self.w.bits & !(0x07 << 8)) | (((value as u32) & 0x07) << 8);
216        self.w
217    }
218}
219#[doc = "Reader of field `TAMPFLT`"]
220pub type TAMPFLT_R = crate::R<u8, u8>;
221#[doc = "Write proxy for field `TAMPFLT`"]
222pub struct TAMPFLT_W<'a> {
223    w: &'a mut W,
224}
225impl<'a> TAMPFLT_W<'a> {
226    #[doc = r"Writes raw bits to the field"]
227    #[inline(always)]
228    pub unsafe fn bits(self, value: u8) -> &'a mut W {
229        self.w.bits = (self.w.bits & !(0x03 << 11)) | (((value as u32) & 0x03) << 11);
230        self.w
231    }
232}
233#[doc = "Reader of field `TAMPPRCH`"]
234pub type TAMPPRCH_R = crate::R<u8, u8>;
235#[doc = "Write proxy for field `TAMPPRCH`"]
236pub struct TAMPPRCH_W<'a> {
237    w: &'a mut W,
238}
239impl<'a> TAMPPRCH_W<'a> {
240    #[doc = r"Writes raw bits to the field"]
241    #[inline(always)]
242    pub unsafe fn bits(self, value: u8) -> &'a mut W {
243        self.w.bits = (self.w.bits & !(0x03 << 13)) | (((value as u32) & 0x03) << 13);
244        self.w
245    }
246}
247#[doc = "Reader of field `TAMPPUDIS`"]
248pub type TAMPPUDIS_R = crate::R<bool, bool>;
249#[doc = "Write proxy for field `TAMPPUDIS`"]
250pub struct TAMPPUDIS_W<'a> {
251    w: &'a mut W,
252}
253impl<'a> TAMPPUDIS_W<'a> {
254    #[doc = r"Sets the field bit"]
255    #[inline(always)]
256    pub fn set_bit(self) -> &'a mut W {
257        self.bit(true)
258    }
259    #[doc = r"Clears the field bit"]
260    #[inline(always)]
261    pub fn clear_bit(self) -> &'a mut W {
262        self.bit(false)
263    }
264    #[doc = r"Writes raw bits to the field"]
265    #[inline(always)]
266    pub fn bit(self, value: bool) -> &'a mut W {
267        self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
268        self.w
269    }
270}
271#[doc = "Reader of field `TAMP1IE`"]
272pub type TAMP1IE_R = crate::R<bool, bool>;
273#[doc = "Write proxy for field `TAMP1IE`"]
274pub struct TAMP1IE_W<'a> {
275    w: &'a mut W,
276}
277impl<'a> TAMP1IE_W<'a> {
278    #[doc = r"Sets the field bit"]
279    #[inline(always)]
280    pub fn set_bit(self) -> &'a mut W {
281        self.bit(true)
282    }
283    #[doc = r"Clears the field bit"]
284    #[inline(always)]
285    pub fn clear_bit(self) -> &'a mut W {
286        self.bit(false)
287    }
288    #[doc = r"Writes raw bits to the field"]
289    #[inline(always)]
290    pub fn bit(self, value: bool) -> &'a mut W {
291        self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
292        self.w
293    }
294}
295#[doc = "Reader of field `TAMP1NOERASE`"]
296pub type TAMP1NOERASE_R = crate::R<bool, bool>;
297#[doc = "Write proxy for field `TAMP1NOERASE`"]
298pub struct TAMP1NOERASE_W<'a> {
299    w: &'a mut W,
300}
301impl<'a> TAMP1NOERASE_W<'a> {
302    #[doc = r"Sets the field bit"]
303    #[inline(always)]
304    pub fn set_bit(self) -> &'a mut W {
305        self.bit(true)
306    }
307    #[doc = r"Clears the field bit"]
308    #[inline(always)]
309    pub fn clear_bit(self) -> &'a mut W {
310        self.bit(false)
311    }
312    #[doc = r"Writes raw bits to the field"]
313    #[inline(always)]
314    pub fn bit(self, value: bool) -> &'a mut W {
315        self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
316        self.w
317    }
318}
319#[doc = "Reader of field `TAMP1MF`"]
320pub type TAMP1MF_R = crate::R<bool, bool>;
321#[doc = "Write proxy for field `TAMP1MF`"]
322pub struct TAMP1MF_W<'a> {
323    w: &'a mut W,
324}
325impl<'a> TAMP1MF_W<'a> {
326    #[doc = r"Sets the field bit"]
327    #[inline(always)]
328    pub fn set_bit(self) -> &'a mut W {
329        self.bit(true)
330    }
331    #[doc = r"Clears the field bit"]
332    #[inline(always)]
333    pub fn clear_bit(self) -> &'a mut W {
334        self.bit(false)
335    }
336    #[doc = r"Writes raw bits to the field"]
337    #[inline(always)]
338    pub fn bit(self, value: bool) -> &'a mut W {
339        self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
340        self.w
341    }
342}
343#[doc = "Reader of field `TAMP2IE`"]
344pub type TAMP2IE_R = crate::R<bool, bool>;
345#[doc = "Write proxy for field `TAMP2IE`"]
346pub struct TAMP2IE_W<'a> {
347    w: &'a mut W,
348}
349impl<'a> TAMP2IE_W<'a> {
350    #[doc = r"Sets the field bit"]
351    #[inline(always)]
352    pub fn set_bit(self) -> &'a mut W {
353        self.bit(true)
354    }
355    #[doc = r"Clears the field bit"]
356    #[inline(always)]
357    pub fn clear_bit(self) -> &'a mut W {
358        self.bit(false)
359    }
360    #[doc = r"Writes raw bits to the field"]
361    #[inline(always)]
362    pub fn bit(self, value: bool) -> &'a mut W {
363        self.w.bits = (self.w.bits & !(0x01 << 19)) | (((value as u32) & 0x01) << 19);
364        self.w
365    }
366}
367#[doc = "Reader of field `TAMP2NOERASE`"]
368pub type TAMP2NOERASE_R = crate::R<bool, bool>;
369#[doc = "Write proxy for field `TAMP2NOERASE`"]
370pub struct TAMP2NOERASE_W<'a> {
371    w: &'a mut W,
372}
373impl<'a> TAMP2NOERASE_W<'a> {
374    #[doc = r"Sets the field bit"]
375    #[inline(always)]
376    pub fn set_bit(self) -> &'a mut W {
377        self.bit(true)
378    }
379    #[doc = r"Clears the field bit"]
380    #[inline(always)]
381    pub fn clear_bit(self) -> &'a mut W {
382        self.bit(false)
383    }
384    #[doc = r"Writes raw bits to the field"]
385    #[inline(always)]
386    pub fn bit(self, value: bool) -> &'a mut W {
387        self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
388        self.w
389    }
390}
391#[doc = "Reader of field `TAMP2MF`"]
392pub type TAMP2MF_R = crate::R<bool, bool>;
393#[doc = "Write proxy for field `TAMP2MF`"]
394pub struct TAMP2MF_W<'a> {
395    w: &'a mut W,
396}
397impl<'a> TAMP2MF_W<'a> {
398    #[doc = r"Sets the field bit"]
399    #[inline(always)]
400    pub fn set_bit(self) -> &'a mut W {
401        self.bit(true)
402    }
403    #[doc = r"Clears the field bit"]
404    #[inline(always)]
405    pub fn clear_bit(self) -> &'a mut W {
406        self.bit(false)
407    }
408    #[doc = r"Writes raw bits to the field"]
409    #[inline(always)]
410    pub fn bit(self, value: bool) -> &'a mut W {
411        self.w.bits = (self.w.bits & !(0x01 << 21)) | (((value as u32) & 0x01) << 21);
412        self.w
413    }
414}
415#[doc = "Reader of field `TAMP3IE`"]
416pub type TAMP3IE_R = crate::R<bool, bool>;
417#[doc = "Write proxy for field `TAMP3IE`"]
418pub struct TAMP3IE_W<'a> {
419    w: &'a mut W,
420}
421impl<'a> TAMP3IE_W<'a> {
422    #[doc = r"Sets the field bit"]
423    #[inline(always)]
424    pub fn set_bit(self) -> &'a mut W {
425        self.bit(true)
426    }
427    #[doc = r"Clears the field bit"]
428    #[inline(always)]
429    pub fn clear_bit(self) -> &'a mut W {
430        self.bit(false)
431    }
432    #[doc = r"Writes raw bits to the field"]
433    #[inline(always)]
434    pub fn bit(self, value: bool) -> &'a mut W {
435        self.w.bits = (self.w.bits & !(0x01 << 22)) | (((value as u32) & 0x01) << 22);
436        self.w
437    }
438}
439#[doc = "Reader of field `TAMP3NOERASE`"]
440pub type TAMP3NOERASE_R = crate::R<bool, bool>;
441#[doc = "Write proxy for field `TAMP3NOERASE`"]
442pub struct TAMP3NOERASE_W<'a> {
443    w: &'a mut W,
444}
445impl<'a> TAMP3NOERASE_W<'a> {
446    #[doc = r"Sets the field bit"]
447    #[inline(always)]
448    pub fn set_bit(self) -> &'a mut W {
449        self.bit(true)
450    }
451    #[doc = r"Clears the field bit"]
452    #[inline(always)]
453    pub fn clear_bit(self) -> &'a mut W {
454        self.bit(false)
455    }
456    #[doc = r"Writes raw bits to the field"]
457    #[inline(always)]
458    pub fn bit(self, value: bool) -> &'a mut W {
459        self.w.bits = (self.w.bits & !(0x01 << 23)) | (((value as u32) & 0x01) << 23);
460        self.w
461    }
462}
463#[doc = "Reader of field `TAMP3MF`"]
464pub type TAMP3MF_R = crate::R<bool, bool>;
465#[doc = "Write proxy for field `TAMP3MF`"]
466pub struct TAMP3MF_W<'a> {
467    w: &'a mut W,
468}
469impl<'a> TAMP3MF_W<'a> {
470    #[doc = r"Sets the field bit"]
471    #[inline(always)]
472    pub fn set_bit(self) -> &'a mut W {
473        self.bit(true)
474    }
475    #[doc = r"Clears the field bit"]
476    #[inline(always)]
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(always)]
482    pub fn bit(self, value: bool) -> &'a mut W {
483        self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
484        self.w
485    }
486}
487impl R {
488    #[doc = "Bit 0 - Tamper 1 detection enable"]
489    #[inline(always)]
490    pub fn tamp1e(&self) -> TAMP1E_R {
491        TAMP1E_R::new((self.bits & 0x01) != 0)
492    }
493    #[doc = "Bit 1 - Active level for tamper 1"]
494    #[inline(always)]
495    pub fn tamp1trg(&self) -> TAMP1TRG_R {
496        TAMP1TRG_R::new(((self.bits >> 1) & 0x01) != 0)
497    }
498    #[doc = "Bit 2 - Tamper interrupt enable"]
499    #[inline(always)]
500    pub fn tampie(&self) -> TAMPIE_R {
501        TAMPIE_R::new(((self.bits >> 2) & 0x01) != 0)
502    }
503    #[doc = "Bit 3 - Tamper 2 detection enable"]
504    #[inline(always)]
505    pub fn tamp2e(&self) -> TAMP2E_R {
506        TAMP2E_R::new(((self.bits >> 3) & 0x01) != 0)
507    }
508    #[doc = "Bit 4 - Active level for tamper 2"]
509    #[inline(always)]
510    pub fn tamp2trg(&self) -> TAMP2TRG_R {
511        TAMP2TRG_R::new(((self.bits >> 4) & 0x01) != 0)
512    }
513    #[doc = "Bit 5 - Tamper 3 detection enable"]
514    #[inline(always)]
515    pub fn tamp3e(&self) -> TAMP3E_R {
516        TAMP3E_R::new(((self.bits >> 5) & 0x01) != 0)
517    }
518    #[doc = "Bit 6 - Active level for tamper 3"]
519    #[inline(always)]
520    pub fn tamp3trg(&self) -> TAMP3TRG_R {
521        TAMP3TRG_R::new(((self.bits >> 6) & 0x01) != 0)
522    }
523    #[doc = "Bit 7 - Activate timestamp on tamper detection event"]
524    #[inline(always)]
525    pub fn tampts(&self) -> TAMPTS_R {
526        TAMPTS_R::new(((self.bits >> 7) & 0x01) != 0)
527    }
528    #[doc = "Bits 8:10 - Tamper sampling frequency"]
529    #[inline(always)]
530    pub fn tampfreq(&self) -> TAMPFREQ_R {
531        TAMPFREQ_R::new(((self.bits >> 8) & 0x07) as u8)
532    }
533    #[doc = "Bits 11:12 - Tamper filter count"]
534    #[inline(always)]
535    pub fn tampflt(&self) -> TAMPFLT_R {
536        TAMPFLT_R::new(((self.bits >> 11) & 0x03) as u8)
537    }
538    #[doc = "Bits 13:14 - Tamper precharge duration"]
539    #[inline(always)]
540    pub fn tampprch(&self) -> TAMPPRCH_R {
541        TAMPPRCH_R::new(((self.bits >> 13) & 0x03) as u8)
542    }
543    #[doc = "Bit 15 - TAMPER pull-up disable"]
544    #[inline(always)]
545    pub fn tamppudis(&self) -> TAMPPUDIS_R {
546        TAMPPUDIS_R::new(((self.bits >> 15) & 0x01) != 0)
547    }
548    #[doc = "Bit 16 - Tamper 1 interrupt enable"]
549    #[inline(always)]
550    pub fn tamp1ie(&self) -> TAMP1IE_R {
551        TAMP1IE_R::new(((self.bits >> 16) & 0x01) != 0)
552    }
553    #[doc = "Bit 17 - Tamper 1 no erase"]
554    #[inline(always)]
555    pub fn tamp1noerase(&self) -> TAMP1NOERASE_R {
556        TAMP1NOERASE_R::new(((self.bits >> 17) & 0x01) != 0)
557    }
558    #[doc = "Bit 18 - Tamper 1 mask flag"]
559    #[inline(always)]
560    pub fn tamp1mf(&self) -> TAMP1MF_R {
561        TAMP1MF_R::new(((self.bits >> 18) & 0x01) != 0)
562    }
563    #[doc = "Bit 19 - Tamper 2 interrupt enable"]
564    #[inline(always)]
565    pub fn tamp2ie(&self) -> TAMP2IE_R {
566        TAMP2IE_R::new(((self.bits >> 19) & 0x01) != 0)
567    }
568    #[doc = "Bit 20 - Tamper 2 no erase"]
569    #[inline(always)]
570    pub fn tamp2noerase(&self) -> TAMP2NOERASE_R {
571        TAMP2NOERASE_R::new(((self.bits >> 20) & 0x01) != 0)
572    }
573    #[doc = "Bit 21 - Tamper 2 mask flag"]
574    #[inline(always)]
575    pub fn tamp2mf(&self) -> TAMP2MF_R {
576        TAMP2MF_R::new(((self.bits >> 21) & 0x01) != 0)
577    }
578    #[doc = "Bit 22 - Tamper 3 interrupt enable"]
579    #[inline(always)]
580    pub fn tamp3ie(&self) -> TAMP3IE_R {
581        TAMP3IE_R::new(((self.bits >> 22) & 0x01) != 0)
582    }
583    #[doc = "Bit 23 - Tamper 3 no erase"]
584    #[inline(always)]
585    pub fn tamp3noerase(&self) -> TAMP3NOERASE_R {
586        TAMP3NOERASE_R::new(((self.bits >> 23) & 0x01) != 0)
587    }
588    #[doc = "Bit 24 - Tamper 3 mask flag"]
589    #[inline(always)]
590    pub fn tamp3mf(&self) -> TAMP3MF_R {
591        TAMP3MF_R::new(((self.bits >> 24) & 0x01) != 0)
592    }
593}
594impl W {
595    #[doc = "Bit 0 - Tamper 1 detection enable"]
596    #[inline(always)]
597    pub fn tamp1e(&mut self) -> TAMP1E_W {
598        TAMP1E_W { w: self }
599    }
600    #[doc = "Bit 1 - Active level for tamper 1"]
601    #[inline(always)]
602    pub fn tamp1trg(&mut self) -> TAMP1TRG_W {
603        TAMP1TRG_W { w: self }
604    }
605    #[doc = "Bit 2 - Tamper interrupt enable"]
606    #[inline(always)]
607    pub fn tampie(&mut self) -> TAMPIE_W {
608        TAMPIE_W { w: self }
609    }
610    #[doc = "Bit 3 - Tamper 2 detection enable"]
611    #[inline(always)]
612    pub fn tamp2e(&mut self) -> TAMP2E_W {
613        TAMP2E_W { w: self }
614    }
615    #[doc = "Bit 4 - Active level for tamper 2"]
616    #[inline(always)]
617    pub fn tamp2trg(&mut self) -> TAMP2TRG_W {
618        TAMP2TRG_W { w: self }
619    }
620    #[doc = "Bit 5 - Tamper 3 detection enable"]
621    #[inline(always)]
622    pub fn tamp3e(&mut self) -> TAMP3E_W {
623        TAMP3E_W { w: self }
624    }
625    #[doc = "Bit 6 - Active level for tamper 3"]
626    #[inline(always)]
627    pub fn tamp3trg(&mut self) -> TAMP3TRG_W {
628        TAMP3TRG_W { w: self }
629    }
630    #[doc = "Bit 7 - Activate timestamp on tamper detection event"]
631    #[inline(always)]
632    pub fn tampts(&mut self) -> TAMPTS_W {
633        TAMPTS_W { w: self }
634    }
635    #[doc = "Bits 8:10 - Tamper sampling frequency"]
636    #[inline(always)]
637    pub fn tampfreq(&mut self) -> TAMPFREQ_W {
638        TAMPFREQ_W { w: self }
639    }
640    #[doc = "Bits 11:12 - Tamper filter count"]
641    #[inline(always)]
642    pub fn tampflt(&mut self) -> TAMPFLT_W {
643        TAMPFLT_W { w: self }
644    }
645    #[doc = "Bits 13:14 - Tamper precharge duration"]
646    #[inline(always)]
647    pub fn tampprch(&mut self) -> TAMPPRCH_W {
648        TAMPPRCH_W { w: self }
649    }
650    #[doc = "Bit 15 - TAMPER pull-up disable"]
651    #[inline(always)]
652    pub fn tamppudis(&mut self) -> TAMPPUDIS_W {
653        TAMPPUDIS_W { w: self }
654    }
655    #[doc = "Bit 16 - Tamper 1 interrupt enable"]
656    #[inline(always)]
657    pub fn tamp1ie(&mut self) -> TAMP1IE_W {
658        TAMP1IE_W { w: self }
659    }
660    #[doc = "Bit 17 - Tamper 1 no erase"]
661    #[inline(always)]
662    pub fn tamp1noerase(&mut self) -> TAMP1NOERASE_W {
663        TAMP1NOERASE_W { w: self }
664    }
665    #[doc = "Bit 18 - Tamper 1 mask flag"]
666    #[inline(always)]
667    pub fn tamp1mf(&mut self) -> TAMP1MF_W {
668        TAMP1MF_W { w: self }
669    }
670    #[doc = "Bit 19 - Tamper 2 interrupt enable"]
671    #[inline(always)]
672    pub fn tamp2ie(&mut self) -> TAMP2IE_W {
673        TAMP2IE_W { w: self }
674    }
675    #[doc = "Bit 20 - Tamper 2 no erase"]
676    #[inline(always)]
677    pub fn tamp2noerase(&mut self) -> TAMP2NOERASE_W {
678        TAMP2NOERASE_W { w: self }
679    }
680    #[doc = "Bit 21 - Tamper 2 mask flag"]
681    #[inline(always)]
682    pub fn tamp2mf(&mut self) -> TAMP2MF_W {
683        TAMP2MF_W { w: self }
684    }
685    #[doc = "Bit 22 - Tamper 3 interrupt enable"]
686    #[inline(always)]
687    pub fn tamp3ie(&mut self) -> TAMP3IE_W {
688        TAMP3IE_W { w: self }
689    }
690    #[doc = "Bit 23 - Tamper 3 no erase"]
691    #[inline(always)]
692    pub fn tamp3noerase(&mut self) -> TAMP3NOERASE_W {
693        TAMP3NOERASE_W { w: self }
694    }
695    #[doc = "Bit 24 - Tamper 3 mask flag"]
696    #[inline(always)]
697    pub fn tamp3mf(&mut self) -> TAMP3MF_W {
698        TAMP3MF_W { w: self }
699    }
700}
stm32wb_pac/rtc/tampcr.rs

stm32wb_pac/rtc/
tampcr.rs
