1#[doc = "Reader of register CR"]
2pub type R = crate::R<u32, super::CR>;
3#[doc = "Writer for register CR"]
4pub type W = crate::W<u32, super::CR>;
5#[doc = "Register CR `reset()`'s with value 0"]
6impl crate::ResetValue for super::CR {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Reader of field `WCKSEL`"]
14pub type WCKSEL_R = crate::R<u8, u8>;
15#[doc = "Write proxy for field `WCKSEL`"]
16pub struct WCKSEL_W<'a> {
17 w: &'a mut W,
18}
19impl<'a> WCKSEL_W<'a> {
20 #[doc = r"Writes raw bits to the field"]
21 #[inline(always)]
22 pub unsafe fn bits(self, value: u8) -> &'a mut W {
23 self.w.bits = (self.w.bits & !0x07) | ((value as u32) & 0x07);
24 self.w
25 }
26}
27#[doc = "Reader of field `TSEDGE`"]
28pub type TSEDGE_R = crate::R<bool, bool>;
29#[doc = "Write proxy for field `TSEDGE`"]
30pub struct TSEDGE_W<'a> {
31 w: &'a mut W,
32}
33impl<'a> TSEDGE_W<'a> {
34 #[doc = r"Sets the field bit"]
35 #[inline(always)]
36 pub fn set_bit(self) -> &'a mut W {
37 self.bit(true)
38 }
39 #[doc = r"Clears the field bit"]
40 #[inline(always)]
41 pub fn clear_bit(self) -> &'a mut W {
42 self.bit(false)
43 }
44 #[doc = r"Writes raw bits to the field"]
45 #[inline(always)]
46 pub fn bit(self, value: bool) -> &'a mut W {
47 self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
48 self.w
49 }
50}
51#[doc = "Reader of field `REFCKON`"]
52pub type REFCKON_R = crate::R<bool, bool>;
53#[doc = "Write proxy for field `REFCKON`"]
54pub struct REFCKON_W<'a> {
55 w: &'a mut W,
56}
57impl<'a> REFCKON_W<'a> {
58 #[doc = r"Sets the field bit"]
59 #[inline(always)]
60 pub fn set_bit(self) -> &'a mut W {
61 self.bit(true)
62 }
63 #[doc = r"Clears the field bit"]
64 #[inline(always)]
65 pub fn clear_bit(self) -> &'a mut W {
66 self.bit(false)
67 }
68 #[doc = r"Writes raw bits to the field"]
69 #[inline(always)]
70 pub fn bit(self, value: bool) -> &'a mut W {
71 self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
72 self.w
73 }
74}
75#[doc = "Reader of field `BYPSHAD`"]
76pub type BYPSHAD_R = crate::R<bool, bool>;
77#[doc = "Write proxy for field `BYPSHAD`"]
78pub struct BYPSHAD_W<'a> {
79 w: &'a mut W,
80}
81impl<'a> BYPSHAD_W<'a> {
82 #[doc = r"Sets the field bit"]
83 #[inline(always)]
84 pub fn set_bit(self) -> &'a mut W {
85 self.bit(true)
86 }
87 #[doc = r"Clears the field bit"]
88 #[inline(always)]
89 pub fn clear_bit(self) -> &'a mut W {
90 self.bit(false)
91 }
92 #[doc = r"Writes raw bits to the field"]
93 #[inline(always)]
94 pub fn bit(self, value: bool) -> &'a mut W {
95 self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
96 self.w
97 }
98}
99#[doc = "Reader of field `FMT`"]
100pub type FMT_R = crate::R<bool, bool>;
101#[doc = "Write proxy for field `FMT`"]
102pub struct FMT_W<'a> {
103 w: &'a mut W,
104}
105impl<'a> FMT_W<'a> {
106 #[doc = r"Sets the field bit"]
107 #[inline(always)]
108 pub fn set_bit(self) -> &'a mut W {
109 self.bit(true)
110 }
111 #[doc = r"Clears the field bit"]
112 #[inline(always)]
113 pub fn clear_bit(self) -> &'a mut W {
114 self.bit(false)
115 }
116 #[doc = r"Writes raw bits to the field"]
117 #[inline(always)]
118 pub fn bit(self, value: bool) -> &'a mut W {
119 self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
120 self.w
121 }
122}
123#[doc = "Reader of field `ALRAE`"]
124pub type ALRAE_R = crate::R<bool, bool>;
125#[doc = "Write proxy for field `ALRAE`"]
126pub struct ALRAE_W<'a> {
127 w: &'a mut W,
128}
129impl<'a> ALRAE_W<'a> {
130 #[doc = r"Sets the field bit"]
131 #[inline(always)]
132 pub fn set_bit(self) -> &'a mut W {
133 self.bit(true)
134 }
135 #[doc = r"Clears the field bit"]
136 #[inline(always)]
137 pub fn clear_bit(self) -> &'a mut W {
138 self.bit(false)
139 }
140 #[doc = r"Writes raw bits to the field"]
141 #[inline(always)]
142 pub fn bit(self, value: bool) -> &'a mut W {
143 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
144 self.w
145 }
146}
147#[doc = "Reader of field `ALRBE`"]
148pub type ALRBE_R = crate::R<bool, bool>;
149#[doc = "Write proxy for field `ALRBE`"]
150pub struct ALRBE_W<'a> {
151 w: &'a mut W,
152}
153impl<'a> ALRBE_W<'a> {
154 #[doc = r"Sets the field bit"]
155 #[inline(always)]
156 pub fn set_bit(self) -> &'a mut W {
157 self.bit(true)
158 }
159 #[doc = r"Clears the field bit"]
160 #[inline(always)]
161 pub fn clear_bit(self) -> &'a mut W {
162 self.bit(false)
163 }
164 #[doc = r"Writes raw bits to the field"]
165 #[inline(always)]
166 pub fn bit(self, value: bool) -> &'a mut W {
167 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
168 self.w
169 }
170}
171#[doc = "Reader of field `WUTE`"]
172pub type WUTE_R = crate::R<bool, bool>;
173#[doc = "Write proxy for field `WUTE`"]
174pub struct WUTE_W<'a> {
175 w: &'a mut W,
176}
177impl<'a> WUTE_W<'a> {
178 #[doc = r"Sets the field bit"]
179 #[inline(always)]
180 pub fn set_bit(self) -> &'a mut W {
181 self.bit(true)
182 }
183 #[doc = r"Clears the field bit"]
184 #[inline(always)]
185 pub fn clear_bit(self) -> &'a mut W {
186 self.bit(false)
187 }
188 #[doc = r"Writes raw bits to the field"]
189 #[inline(always)]
190 pub fn bit(self, value: bool) -> &'a mut W {
191 self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
192 self.w
193 }
194}
195#[doc = "Reader of field `TSE`"]
196pub type TSE_R = crate::R<bool, bool>;
197#[doc = "Write proxy for field `TSE`"]
198pub struct TSE_W<'a> {
199 w: &'a mut W,
200}
201impl<'a> TSE_W<'a> {
202 #[doc = r"Sets the field bit"]
203 #[inline(always)]
204 pub fn set_bit(self) -> &'a mut W {
205 self.bit(true)
206 }
207 #[doc = r"Clears the field bit"]
208 #[inline(always)]
209 pub fn clear_bit(self) -> &'a mut W {
210 self.bit(false)
211 }
212 #[doc = r"Writes raw bits to the field"]
213 #[inline(always)]
214 pub fn bit(self, value: bool) -> &'a mut W {
215 self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
216 self.w
217 }
218}
219#[doc = "Reader of field `ALRAIE`"]
220pub type ALRAIE_R = crate::R<bool, bool>;
221#[doc = "Write proxy for field `ALRAIE`"]
222pub struct ALRAIE_W<'a> {
223 w: &'a mut W,
224}
225impl<'a> ALRAIE_W<'a> {
226 #[doc = r"Sets the field bit"]
227 #[inline(always)]
228 pub fn set_bit(self) -> &'a mut W {
229 self.bit(true)
230 }
231 #[doc = r"Clears the field bit"]
232 #[inline(always)]
233 pub fn clear_bit(self) -> &'a mut W {
234 self.bit(false)
235 }
236 #[doc = r"Writes raw bits to the field"]
237 #[inline(always)]
238 pub fn bit(self, value: bool) -> &'a mut W {
239 self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
240 self.w
241 }
242}
243#[doc = "Reader of field `ALRBIE`"]
244pub type ALRBIE_R = crate::R<bool, bool>;
245#[doc = "Write proxy for field `ALRBIE`"]
246pub struct ALRBIE_W<'a> {
247 w: &'a mut W,
248}
249impl<'a> ALRBIE_W<'a> {
250 #[doc = r"Sets the field bit"]
251 #[inline(always)]
252 pub fn set_bit(self) -> &'a mut W {
253 self.bit(true)
254 }
255 #[doc = r"Clears the field bit"]
256 #[inline(always)]
257 pub fn clear_bit(self) -> &'a mut W {
258 self.bit(false)
259 }
260 #[doc = r"Writes raw bits to the field"]
261 #[inline(always)]
262 pub fn bit(self, value: bool) -> &'a mut W {
263 self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
264 self.w
265 }
266}
267#[doc = "Reader of field `WUTIE`"]
268pub type WUTIE_R = crate::R<bool, bool>;
269#[doc = "Write proxy for field `WUTIE`"]
270pub struct WUTIE_W<'a> {
271 w: &'a mut W,
272}
273impl<'a> WUTIE_W<'a> {
274 #[doc = r"Sets the field bit"]
275 #[inline(always)]
276 pub fn set_bit(self) -> &'a mut W {
277 self.bit(true)
278 }
279 #[doc = r"Clears the field bit"]
280 #[inline(always)]
281 pub fn clear_bit(self) -> &'a mut W {
282 self.bit(false)
283 }
284 #[doc = r"Writes raw bits to the field"]
285 #[inline(always)]
286 pub fn bit(self, value: bool) -> &'a mut W {
287 self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
288 self.w
289 }
290}
291#[doc = "Reader of field `TSIE`"]
292pub type TSIE_R = crate::R<bool, bool>;
293#[doc = "Write proxy for field `TSIE`"]
294pub struct TSIE_W<'a> {
295 w: &'a mut W,
296}
297impl<'a> TSIE_W<'a> {
298 #[doc = r"Sets the field bit"]
299 #[inline(always)]
300 pub fn set_bit(self) -> &'a mut W {
301 self.bit(true)
302 }
303 #[doc = r"Clears the field bit"]
304 #[inline(always)]
305 pub fn clear_bit(self) -> &'a mut W {
306 self.bit(false)
307 }
308 #[doc = r"Writes raw bits to the field"]
309 #[inline(always)]
310 pub fn bit(self, value: bool) -> &'a mut W {
311 self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
312 self.w
313 }
314}
315#[doc = "Reader of field `ADD1H`"]
316pub type ADD1H_R = crate::R<bool, bool>;
317#[doc = "Write proxy for field `ADD1H`"]
318pub struct ADD1H_W<'a> {
319 w: &'a mut W,
320}
321impl<'a> ADD1H_W<'a> {
322 #[doc = r"Sets the field bit"]
323 #[inline(always)]
324 pub fn set_bit(self) -> &'a mut W {
325 self.bit(true)
326 }
327 #[doc = r"Clears the field bit"]
328 #[inline(always)]
329 pub fn clear_bit(self) -> &'a mut W {
330 self.bit(false)
331 }
332 #[doc = r"Writes raw bits to the field"]
333 #[inline(always)]
334 pub fn bit(self, value: bool) -> &'a mut W {
335 self.w.bits = (self.w.bits & !(0x01 << 16)) | (((value as u32) & 0x01) << 16);
336 self.w
337 }
338}
339#[doc = "Reader of field `SUB1H`"]
340pub type SUB1H_R = crate::R<bool, bool>;
341#[doc = "Write proxy for field `SUB1H`"]
342pub struct SUB1H_W<'a> {
343 w: &'a mut W,
344}
345impl<'a> SUB1H_W<'a> {
346 #[doc = r"Sets the field bit"]
347 #[inline(always)]
348 pub fn set_bit(self) -> &'a mut W {
349 self.bit(true)
350 }
351 #[doc = r"Clears the field bit"]
352 #[inline(always)]
353 pub fn clear_bit(self) -> &'a mut W {
354 self.bit(false)
355 }
356 #[doc = r"Writes raw bits to the field"]
357 #[inline(always)]
358 pub fn bit(self, value: bool) -> &'a mut W {
359 self.w.bits = (self.w.bits & !(0x01 << 17)) | (((value as u32) & 0x01) << 17);
360 self.w
361 }
362}
363#[doc = "Reader of field `BKP`"]
364pub type BKP_R = crate::R<bool, bool>;
365#[doc = "Write proxy for field `BKP`"]
366pub struct BKP_W<'a> {
367 w: &'a mut W,
368}
369impl<'a> BKP_W<'a> {
370 #[doc = r"Sets the field bit"]
371 #[inline(always)]
372 pub fn set_bit(self) -> &'a mut W {
373 self.bit(true)
374 }
375 #[doc = r"Clears the field bit"]
376 #[inline(always)]
377 pub fn clear_bit(self) -> &'a mut W {
378 self.bit(false)
379 }
380 #[doc = r"Writes raw bits to the field"]
381 #[inline(always)]
382 pub fn bit(self, value: bool) -> &'a mut W {
383 self.w.bits = (self.w.bits & !(0x01 << 18)) | (((value as u32) & 0x01) << 18);
384 self.w
385 }
386}
387#[doc = "Reader of field `COSEL`"]
388pub type COSEL_R = crate::R<bool, bool>;
389#[doc = "Write proxy for field `COSEL`"]
390pub struct COSEL_W<'a> {
391 w: &'a mut W,
392}
393impl<'a> COSEL_W<'a> {
394 #[doc = r"Sets the field bit"]
395 #[inline(always)]
396 pub fn set_bit(self) -> &'a mut W {
397 self.bit(true)
398 }
399 #[doc = r"Clears the field bit"]
400 #[inline(always)]
401 pub fn clear_bit(self) -> &'a mut W {
402 self.bit(false)
403 }
404 #[doc = r"Writes raw bits to the field"]
405 #[inline(always)]
406 pub fn bit(self, value: bool) -> &'a mut W {
407 self.w.bits = (self.w.bits & !(0x01 << 19)) | (((value as u32) & 0x01) << 19);
408 self.w
409 }
410}
411#[doc = "Reader of field `POL`"]
412pub type POL_R = crate::R<bool, bool>;
413#[doc = "Write proxy for field `POL`"]
414pub struct POL_W<'a> {
415 w: &'a mut W,
416}
417impl<'a> POL_W<'a> {
418 #[doc = r"Sets the field bit"]
419 #[inline(always)]
420 pub fn set_bit(self) -> &'a mut W {
421 self.bit(true)
422 }
423 #[doc = r"Clears the field bit"]
424 #[inline(always)]
425 pub fn clear_bit(self) -> &'a mut W {
426 self.bit(false)
427 }
428 #[doc = r"Writes raw bits to the field"]
429 #[inline(always)]
430 pub fn bit(self, value: bool) -> &'a mut W {
431 self.w.bits = (self.w.bits & !(0x01 << 20)) | (((value as u32) & 0x01) << 20);
432 self.w
433 }
434}
435#[doc = "Reader of field `OSEL`"]
436pub type OSEL_R = crate::R<u8, u8>;
437#[doc = "Write proxy for field `OSEL`"]
438pub struct OSEL_W<'a> {
439 w: &'a mut W,
440}
441impl<'a> OSEL_W<'a> {
442 #[doc = r"Writes raw bits to the field"]
443 #[inline(always)]
444 pub unsafe fn bits(self, value: u8) -> &'a mut W {
445 self.w.bits = (self.w.bits & !(0x03 << 21)) | (((value as u32) & 0x03) << 21);
446 self.w
447 }
448}
449#[doc = "Reader of field `COE`"]
450pub type COE_R = crate::R<bool, bool>;
451#[doc = "Write proxy for field `COE`"]
452pub struct COE_W<'a> {
453 w: &'a mut W,
454}
455impl<'a> COE_W<'a> {
456 #[doc = r"Sets the field bit"]
457 #[inline(always)]
458 pub fn set_bit(self) -> &'a mut W {
459 self.bit(true)
460 }
461 #[doc = r"Clears the field bit"]
462 #[inline(always)]
463 pub fn clear_bit(self) -> &'a mut W {
464 self.bit(false)
465 }
466 #[doc = r"Writes raw bits to the field"]
467 #[inline(always)]
468 pub fn bit(self, value: bool) -> &'a mut W {
469 self.w.bits = (self.w.bits & !(0x01 << 23)) | (((value as u32) & 0x01) << 23);
470 self.w
471 }
472}
473#[doc = "Reader of field `ITSE`"]
474pub type ITSE_R = crate::R<bool, bool>;
475#[doc = "Write proxy for field `ITSE`"]
476pub struct ITSE_W<'a> {
477 w: &'a mut W,
478}
479impl<'a> ITSE_W<'a> {
480 #[doc = r"Sets the field bit"]
481 #[inline(always)]
482 pub fn set_bit(self) -> &'a mut W {
483 self.bit(true)
484 }
485 #[doc = r"Clears the field bit"]
486 #[inline(always)]
487 pub fn clear_bit(self) -> &'a mut W {
488 self.bit(false)
489 }
490 #[doc = r"Writes raw bits to the field"]
491 #[inline(always)]
492 pub fn bit(self, value: bool) -> &'a mut W {
493 self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
494 self.w
495 }
496}
497impl R {
498 #[doc = "Bits 0:2 - Wakeup clock selection"]
499 #[inline(always)]
500 pub fn wcksel(&self) -> WCKSEL_R {
501 WCKSEL_R::new((self.bits & 0x07) as u8)
502 }
503 #[doc = "Bit 3 - Time-stamp event active edge"]
504 #[inline(always)]
505 pub fn tsedge(&self) -> TSEDGE_R {
506 TSEDGE_R::new(((self.bits >> 3) & 0x01) != 0)
507 }
508 #[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"]
509 #[inline(always)]
510 pub fn refckon(&self) -> REFCKON_R {
511 REFCKON_R::new(((self.bits >> 4) & 0x01) != 0)
512 }
513 #[doc = "Bit 5 - Bypass the shadow registers"]
514 #[inline(always)]
515 pub fn bypshad(&self) -> BYPSHAD_R {
516 BYPSHAD_R::new(((self.bits >> 5) & 0x01) != 0)
517 }
518 #[doc = "Bit 6 - Hour format"]
519 #[inline(always)]
520 pub fn fmt(&self) -> FMT_R {
521 FMT_R::new(((self.bits >> 6) & 0x01) != 0)
522 }
523 #[doc = "Bit 8 - Alarm A enable"]
524 #[inline(always)]
525 pub fn alrae(&self) -> ALRAE_R {
526 ALRAE_R::new(((self.bits >> 8) & 0x01) != 0)
527 }
528 #[doc = "Bit 9 - Alarm B enable"]
529 #[inline(always)]
530 pub fn alrbe(&self) -> ALRBE_R {
531 ALRBE_R::new(((self.bits >> 9) & 0x01) != 0)
532 }
533 #[doc = "Bit 10 - Wakeup timer enable"]
534 #[inline(always)]
535 pub fn wute(&self) -> WUTE_R {
536 WUTE_R::new(((self.bits >> 10) & 0x01) != 0)
537 }
538 #[doc = "Bit 11 - Time stamp enable"]
539 #[inline(always)]
540 pub fn tse(&self) -> TSE_R {
541 TSE_R::new(((self.bits >> 11) & 0x01) != 0)
542 }
543 #[doc = "Bit 12 - Alarm A interrupt enable"]
544 #[inline(always)]
545 pub fn alraie(&self) -> ALRAIE_R {
546 ALRAIE_R::new(((self.bits >> 12) & 0x01) != 0)
547 }
548 #[doc = "Bit 13 - Alarm B interrupt enable"]
549 #[inline(always)]
550 pub fn alrbie(&self) -> ALRBIE_R {
551 ALRBIE_R::new(((self.bits >> 13) & 0x01) != 0)
552 }
553 #[doc = "Bit 14 - Wakeup timer interrupt enable"]
554 #[inline(always)]
555 pub fn wutie(&self) -> WUTIE_R {
556 WUTIE_R::new(((self.bits >> 14) & 0x01) != 0)
557 }
558 #[doc = "Bit 15 - Time-stamp interrupt enable"]
559 #[inline(always)]
560 pub fn tsie(&self) -> TSIE_R {
561 TSIE_R::new(((self.bits >> 15) & 0x01) != 0)
562 }
563 #[doc = "Bit 16 - Add 1 hour (summer time change)"]
564 #[inline(always)]
565 pub fn add1h(&self) -> ADD1H_R {
566 ADD1H_R::new(((self.bits >> 16) & 0x01) != 0)
567 }
568 #[doc = "Bit 17 - Subtract 1 hour (winter time change)"]
569 #[inline(always)]
570 pub fn sub1h(&self) -> SUB1H_R {
571 SUB1H_R::new(((self.bits >> 17) & 0x01) != 0)
572 }
573 #[doc = "Bit 18 - Backup"]
574 #[inline(always)]
575 pub fn bkp(&self) -> BKP_R {
576 BKP_R::new(((self.bits >> 18) & 0x01) != 0)
577 }
578 #[doc = "Bit 19 - Calibration output selection"]
579 #[inline(always)]
580 pub fn cosel(&self) -> COSEL_R {
581 COSEL_R::new(((self.bits >> 19) & 0x01) != 0)
582 }
583 #[doc = "Bit 20 - Output polarity"]
584 #[inline(always)]
585 pub fn pol(&self) -> POL_R {
586 POL_R::new(((self.bits >> 20) & 0x01) != 0)
587 }
588 #[doc = "Bits 21:22 - Output selection"]
589 #[inline(always)]
590 pub fn osel(&self) -> OSEL_R {
591 OSEL_R::new(((self.bits >> 21) & 0x03) as u8)
592 }
593 #[doc = "Bit 23 - Calibration output enable"]
594 #[inline(always)]
595 pub fn coe(&self) -> COE_R {
596 COE_R::new(((self.bits >> 23) & 0x01) != 0)
597 }
598 #[doc = "Bit 24 - timestamp on internal event enable"]
599 #[inline(always)]
600 pub fn itse(&self) -> ITSE_R {
601 ITSE_R::new(((self.bits >> 24) & 0x01) != 0)
602 }
603}
604impl W {
605 #[doc = "Bits 0:2 - Wakeup clock selection"]
606 #[inline(always)]
607 pub fn wcksel(&mut self) -> WCKSEL_W {
608 WCKSEL_W { w: self }
609 }
610 #[doc = "Bit 3 - Time-stamp event active edge"]
611 #[inline(always)]
612 pub fn tsedge(&mut self) -> TSEDGE_W {
613 TSEDGE_W { w: self }
614 }
615 #[doc = "Bit 4 - Reference clock detection enable (50 or 60 Hz)"]
616 #[inline(always)]
617 pub fn refckon(&mut self) -> REFCKON_W {
618 REFCKON_W { w: self }
619 }
620 #[doc = "Bit 5 - Bypass the shadow registers"]
621 #[inline(always)]
622 pub fn bypshad(&mut self) -> BYPSHAD_W {
623 BYPSHAD_W { w: self }
624 }
625 #[doc = "Bit 6 - Hour format"]
626 #[inline(always)]
627 pub fn fmt(&mut self) -> FMT_W {
628 FMT_W { w: self }
629 }
630 #[doc = "Bit 8 - Alarm A enable"]
631 #[inline(always)]
632 pub fn alrae(&mut self) -> ALRAE_W {
633 ALRAE_W { w: self }
634 }
635 #[doc = "Bit 9 - Alarm B enable"]
636 #[inline(always)]
637 pub fn alrbe(&mut self) -> ALRBE_W {
638 ALRBE_W { w: self }
639 }
640 #[doc = "Bit 10 - Wakeup timer enable"]
641 #[inline(always)]
642 pub fn wute(&mut self) -> WUTE_W {
643 WUTE_W { w: self }
644 }
645 #[doc = "Bit 11 - Time stamp enable"]
646 #[inline(always)]
647 pub fn tse(&mut self) -> TSE_W {
648 TSE_W { w: self }
649 }
650 #[doc = "Bit 12 - Alarm A interrupt enable"]
651 #[inline(always)]
652 pub fn alraie(&mut self) -> ALRAIE_W {
653 ALRAIE_W { w: self }
654 }
655 #[doc = "Bit 13 - Alarm B interrupt enable"]
656 #[inline(always)]
657 pub fn alrbie(&mut self) -> ALRBIE_W {
658 ALRBIE_W { w: self }
659 }
660 #[doc = "Bit 14 - Wakeup timer interrupt enable"]
661 #[inline(always)]
662 pub fn wutie(&mut self) -> WUTIE_W {
663 WUTIE_W { w: self }
664 }
665 #[doc = "Bit 15 - Time-stamp interrupt enable"]
666 #[inline(always)]
667 pub fn tsie(&mut self) -> TSIE_W {
668 TSIE_W { w: self }
669 }
670 #[doc = "Bit 16 - Add 1 hour (summer time change)"]
671 #[inline(always)]
672 pub fn add1h(&mut self) -> ADD1H_W {
673 ADD1H_W { w: self }
674 }
675 #[doc = "Bit 17 - Subtract 1 hour (winter time change)"]
676 #[inline(always)]
677 pub fn sub1h(&mut self) -> SUB1H_W {
678 SUB1H_W { w: self }
679 }
680 #[doc = "Bit 18 - Backup"]
681 #[inline(always)]
682 pub fn bkp(&mut self) -> BKP_W {
683 BKP_W { w: self }
684 }
685 #[doc = "Bit 19 - Calibration output selection"]
686 #[inline(always)]
687 pub fn cosel(&mut self) -> COSEL_W {
688 COSEL_W { w: self }
689 }
690 #[doc = "Bit 20 - Output polarity"]
691 #[inline(always)]
692 pub fn pol(&mut self) -> POL_W {
693 POL_W { w: self }
694 }
695 #[doc = "Bits 21:22 - Output selection"]
696 #[inline(always)]
697 pub fn osel(&mut self) -> OSEL_W {
698 OSEL_W { w: self }
699 }
700 #[doc = "Bit 23 - Calibration output enable"]
701 #[inline(always)]
702 pub fn coe(&mut self) -> COE_W {
703 COE_W { w: self }
704 }
705 #[doc = "Bit 24 - timestamp on internal event enable"]
706 #[inline(always)]
707 pub fn itse(&mut self) -> ITSE_W {
708 ITSE_W { w: self }
709 }
710}