efm32gg11b820/wtimer3/
dtctrl.rs1#[doc = "Reader of register DTCTRL"]
2pub type R = crate::R<u32, super::DTCTRL>;
3#[doc = "Writer for register DTCTRL"]
4pub type W = crate::W<u32, super::DTCTRL>;
5#[doc = "Register DTCTRL `reset()`'s with value 0"]
6impl crate::ResetValue for super::DTCTRL {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Reader of field `DTEN`"]
14pub type DTEN_R = crate::R<bool, bool>;
15#[doc = "Write proxy for field `DTEN`"]
16pub struct DTEN_W<'a> {
17 w: &'a mut W,
18}
19impl<'a> DTEN_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 `DTDAS`"]
38pub type DTDAS_R = crate::R<bool, bool>;
39#[doc = "Write proxy for field `DTDAS`"]
40pub struct DTDAS_W<'a> {
41 w: &'a mut W,
42}
43impl<'a> DTDAS_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 `DTIPOL`"]
62pub type DTIPOL_R = crate::R<bool, bool>;
63#[doc = "Write proxy for field `DTIPOL`"]
64pub struct DTIPOL_W<'a> {
65 w: &'a mut W,
66}
67impl<'a> DTIPOL_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 `DTCINV`"]
86pub type DTCINV_R = crate::R<bool, bool>;
87#[doc = "Write proxy for field `DTCINV`"]
88pub struct DTCINV_W<'a> {
89 w: &'a mut W,
90}
91impl<'a> DTCINV_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 = "DTI PRS Source Channel Select\n\nValue on reset: 0"]
110#[derive(Clone, Copy, Debug, PartialEq)]
111#[repr(u8)]
112pub enum DTPRSSEL_A {
113 #[doc = "0: PRS Channel 0 selected as input"]
114 PRSCH0 = 0,
115 #[doc = "1: PRS Channel 1 selected as input"]
116 PRSCH1 = 1,
117 #[doc = "2: PRS Channel 2 selected as input"]
118 PRSCH2 = 2,
119 #[doc = "3: PRS Channel 3 selected as input"]
120 PRSCH3 = 3,
121 #[doc = "4: PRS Channel 4 selected as input"]
122 PRSCH4 = 4,
123 #[doc = "5: PRS Channel 5 selected as input"]
124 PRSCH5 = 5,
125 #[doc = "6: PRS Channel 6 selected as input"]
126 PRSCH6 = 6,
127 #[doc = "7: PRS Channel 7 selected as input"]
128 PRSCH7 = 7,
129 #[doc = "8: PRS Channel 8 selected as input"]
130 PRSCH8 = 8,
131 #[doc = "9: PRS Channel 9 selected as input"]
132 PRSCH9 = 9,
133 #[doc = "10: PRS Channel 10 selected as input"]
134 PRSCH10 = 10,
135 #[doc = "11: PRS Channel 11 selected as input"]
136 PRSCH11 = 11,
137 #[doc = "12: PRS Channel 12 selected as input"]
138 PRSCH12 = 12,
139 #[doc = "13: PRS Channel 13 selected as input"]
140 PRSCH13 = 13,
141 #[doc = "14: PRS Channel 14 selected as input"]
142 PRSCH14 = 14,
143 #[doc = "15: PRS Channel 15 selected as input"]
144 PRSCH15 = 15,
145 #[doc = "16: PRS Channel 16 selected as input"]
146 PRSCH16 = 16,
147 #[doc = "17: PRS Channel 17 selected as input"]
148 PRSCH17 = 17,
149 #[doc = "18: PRS Channel 18 selected as input"]
150 PRSCH18 = 18,
151 #[doc = "19: PRS Channel 19 selected as input"]
152 PRSCH19 = 19,
153 #[doc = "20: PRS Channel 20 selected as input"]
154 PRSCH20 = 20,
155 #[doc = "21: PRS Channel 21 selected as input"]
156 PRSCH21 = 21,
157 #[doc = "22: PRS Channel 22 selected as input"]
158 PRSCH22 = 22,
159 #[doc = "23: PRS Channel 23 selected as input"]
160 PRSCH23 = 23,
161}
162impl From<DTPRSSEL_A> for u8 {
163 #[inline(always)]
164 fn from(variant: DTPRSSEL_A) -> Self {
165 variant as _
166 }
167}
168#[doc = "Reader of field `DTPRSSEL`"]
169pub type DTPRSSEL_R = crate::R<u8, DTPRSSEL_A>;
170impl DTPRSSEL_R {
171 #[doc = r"Get enumerated values variant"]
172 #[inline(always)]
173 pub fn variant(&self) -> crate::Variant<u8, DTPRSSEL_A> {
174 use crate::Variant::*;
175 match self.bits {
176 0 => Val(DTPRSSEL_A::PRSCH0),
177 1 => Val(DTPRSSEL_A::PRSCH1),
178 2 => Val(DTPRSSEL_A::PRSCH2),
179 3 => Val(DTPRSSEL_A::PRSCH3),
180 4 => Val(DTPRSSEL_A::PRSCH4),
181 5 => Val(DTPRSSEL_A::PRSCH5),
182 6 => Val(DTPRSSEL_A::PRSCH6),
183 7 => Val(DTPRSSEL_A::PRSCH7),
184 8 => Val(DTPRSSEL_A::PRSCH8),
185 9 => Val(DTPRSSEL_A::PRSCH9),
186 10 => Val(DTPRSSEL_A::PRSCH10),
187 11 => Val(DTPRSSEL_A::PRSCH11),
188 12 => Val(DTPRSSEL_A::PRSCH12),
189 13 => Val(DTPRSSEL_A::PRSCH13),
190 14 => Val(DTPRSSEL_A::PRSCH14),
191 15 => Val(DTPRSSEL_A::PRSCH15),
192 16 => Val(DTPRSSEL_A::PRSCH16),
193 17 => Val(DTPRSSEL_A::PRSCH17),
194 18 => Val(DTPRSSEL_A::PRSCH18),
195 19 => Val(DTPRSSEL_A::PRSCH19),
196 20 => Val(DTPRSSEL_A::PRSCH20),
197 21 => Val(DTPRSSEL_A::PRSCH21),
198 22 => Val(DTPRSSEL_A::PRSCH22),
199 23 => Val(DTPRSSEL_A::PRSCH23),
200 i => Res(i),
201 }
202 }
203 #[doc = "Checks if the value of the field is `PRSCH0`"]
204 #[inline(always)]
205 pub fn is_prsch0(&self) -> bool {
206 *self == DTPRSSEL_A::PRSCH0
207 }
208 #[doc = "Checks if the value of the field is `PRSCH1`"]
209 #[inline(always)]
210 pub fn is_prsch1(&self) -> bool {
211 *self == DTPRSSEL_A::PRSCH1
212 }
213 #[doc = "Checks if the value of the field is `PRSCH2`"]
214 #[inline(always)]
215 pub fn is_prsch2(&self) -> bool {
216 *self == DTPRSSEL_A::PRSCH2
217 }
218 #[doc = "Checks if the value of the field is `PRSCH3`"]
219 #[inline(always)]
220 pub fn is_prsch3(&self) -> bool {
221 *self == DTPRSSEL_A::PRSCH3
222 }
223 #[doc = "Checks if the value of the field is `PRSCH4`"]
224 #[inline(always)]
225 pub fn is_prsch4(&self) -> bool {
226 *self == DTPRSSEL_A::PRSCH4
227 }
228 #[doc = "Checks if the value of the field is `PRSCH5`"]
229 #[inline(always)]
230 pub fn is_prsch5(&self) -> bool {
231 *self == DTPRSSEL_A::PRSCH5
232 }
233 #[doc = "Checks if the value of the field is `PRSCH6`"]
234 #[inline(always)]
235 pub fn is_prsch6(&self) -> bool {
236 *self == DTPRSSEL_A::PRSCH6
237 }
238 #[doc = "Checks if the value of the field is `PRSCH7`"]
239 #[inline(always)]
240 pub fn is_prsch7(&self) -> bool {
241 *self == DTPRSSEL_A::PRSCH7
242 }
243 #[doc = "Checks if the value of the field is `PRSCH8`"]
244 #[inline(always)]
245 pub fn is_prsch8(&self) -> bool {
246 *self == DTPRSSEL_A::PRSCH8
247 }
248 #[doc = "Checks if the value of the field is `PRSCH9`"]
249 #[inline(always)]
250 pub fn is_prsch9(&self) -> bool {
251 *self == DTPRSSEL_A::PRSCH9
252 }
253 #[doc = "Checks if the value of the field is `PRSCH10`"]
254 #[inline(always)]
255 pub fn is_prsch10(&self) -> bool {
256 *self == DTPRSSEL_A::PRSCH10
257 }
258 #[doc = "Checks if the value of the field is `PRSCH11`"]
259 #[inline(always)]
260 pub fn is_prsch11(&self) -> bool {
261 *self == DTPRSSEL_A::PRSCH11
262 }
263 #[doc = "Checks if the value of the field is `PRSCH12`"]
264 #[inline(always)]
265 pub fn is_prsch12(&self) -> bool {
266 *self == DTPRSSEL_A::PRSCH12
267 }
268 #[doc = "Checks if the value of the field is `PRSCH13`"]
269 #[inline(always)]
270 pub fn is_prsch13(&self) -> bool {
271 *self == DTPRSSEL_A::PRSCH13
272 }
273 #[doc = "Checks if the value of the field is `PRSCH14`"]
274 #[inline(always)]
275 pub fn is_prsch14(&self) -> bool {
276 *self == DTPRSSEL_A::PRSCH14
277 }
278 #[doc = "Checks if the value of the field is `PRSCH15`"]
279 #[inline(always)]
280 pub fn is_prsch15(&self) -> bool {
281 *self == DTPRSSEL_A::PRSCH15
282 }
283 #[doc = "Checks if the value of the field is `PRSCH16`"]
284 #[inline(always)]
285 pub fn is_prsch16(&self) -> bool {
286 *self == DTPRSSEL_A::PRSCH16
287 }
288 #[doc = "Checks if the value of the field is `PRSCH17`"]
289 #[inline(always)]
290 pub fn is_prsch17(&self) -> bool {
291 *self == DTPRSSEL_A::PRSCH17
292 }
293 #[doc = "Checks if the value of the field is `PRSCH18`"]
294 #[inline(always)]
295 pub fn is_prsch18(&self) -> bool {
296 *self == DTPRSSEL_A::PRSCH18
297 }
298 #[doc = "Checks if the value of the field is `PRSCH19`"]
299 #[inline(always)]
300 pub fn is_prsch19(&self) -> bool {
301 *self == DTPRSSEL_A::PRSCH19
302 }
303 #[doc = "Checks if the value of the field is `PRSCH20`"]
304 #[inline(always)]
305 pub fn is_prsch20(&self) -> bool {
306 *self == DTPRSSEL_A::PRSCH20
307 }
308 #[doc = "Checks if the value of the field is `PRSCH21`"]
309 #[inline(always)]
310 pub fn is_prsch21(&self) -> bool {
311 *self == DTPRSSEL_A::PRSCH21
312 }
313 #[doc = "Checks if the value of the field is `PRSCH22`"]
314 #[inline(always)]
315 pub fn is_prsch22(&self) -> bool {
316 *self == DTPRSSEL_A::PRSCH22
317 }
318 #[doc = "Checks if the value of the field is `PRSCH23`"]
319 #[inline(always)]
320 pub fn is_prsch23(&self) -> bool {
321 *self == DTPRSSEL_A::PRSCH23
322 }
323}
324#[doc = "Write proxy for field `DTPRSSEL`"]
325pub struct DTPRSSEL_W<'a> {
326 w: &'a mut W,
327}
328impl<'a> DTPRSSEL_W<'a> {
329 #[doc = r"Writes `variant` to the field"]
330 #[inline(always)]
331 pub fn variant(self, variant: DTPRSSEL_A) -> &'a mut W {
332 unsafe { self.bits(variant.into()) }
333 }
334 #[doc = "PRS Channel 0 selected as input"]
335 #[inline(always)]
336 pub fn prsch0(self) -> &'a mut W {
337 self.variant(DTPRSSEL_A::PRSCH0)
338 }
339 #[doc = "PRS Channel 1 selected as input"]
340 #[inline(always)]
341 pub fn prsch1(self) -> &'a mut W {
342 self.variant(DTPRSSEL_A::PRSCH1)
343 }
344 #[doc = "PRS Channel 2 selected as input"]
345 #[inline(always)]
346 pub fn prsch2(self) -> &'a mut W {
347 self.variant(DTPRSSEL_A::PRSCH2)
348 }
349 #[doc = "PRS Channel 3 selected as input"]
350 #[inline(always)]
351 pub fn prsch3(self) -> &'a mut W {
352 self.variant(DTPRSSEL_A::PRSCH3)
353 }
354 #[doc = "PRS Channel 4 selected as input"]
355 #[inline(always)]
356 pub fn prsch4(self) -> &'a mut W {
357 self.variant(DTPRSSEL_A::PRSCH4)
358 }
359 #[doc = "PRS Channel 5 selected as input"]
360 #[inline(always)]
361 pub fn prsch5(self) -> &'a mut W {
362 self.variant(DTPRSSEL_A::PRSCH5)
363 }
364 #[doc = "PRS Channel 6 selected as input"]
365 #[inline(always)]
366 pub fn prsch6(self) -> &'a mut W {
367 self.variant(DTPRSSEL_A::PRSCH6)
368 }
369 #[doc = "PRS Channel 7 selected as input"]
370 #[inline(always)]
371 pub fn prsch7(self) -> &'a mut W {
372 self.variant(DTPRSSEL_A::PRSCH7)
373 }
374 #[doc = "PRS Channel 8 selected as input"]
375 #[inline(always)]
376 pub fn prsch8(self) -> &'a mut W {
377 self.variant(DTPRSSEL_A::PRSCH8)
378 }
379 #[doc = "PRS Channel 9 selected as input"]
380 #[inline(always)]
381 pub fn prsch9(self) -> &'a mut W {
382 self.variant(DTPRSSEL_A::PRSCH9)
383 }
384 #[doc = "PRS Channel 10 selected as input"]
385 #[inline(always)]
386 pub fn prsch10(self) -> &'a mut W {
387 self.variant(DTPRSSEL_A::PRSCH10)
388 }
389 #[doc = "PRS Channel 11 selected as input"]
390 #[inline(always)]
391 pub fn prsch11(self) -> &'a mut W {
392 self.variant(DTPRSSEL_A::PRSCH11)
393 }
394 #[doc = "PRS Channel 12 selected as input"]
395 #[inline(always)]
396 pub fn prsch12(self) -> &'a mut W {
397 self.variant(DTPRSSEL_A::PRSCH12)
398 }
399 #[doc = "PRS Channel 13 selected as input"]
400 #[inline(always)]
401 pub fn prsch13(self) -> &'a mut W {
402 self.variant(DTPRSSEL_A::PRSCH13)
403 }
404 #[doc = "PRS Channel 14 selected as input"]
405 #[inline(always)]
406 pub fn prsch14(self) -> &'a mut W {
407 self.variant(DTPRSSEL_A::PRSCH14)
408 }
409 #[doc = "PRS Channel 15 selected as input"]
410 #[inline(always)]
411 pub fn prsch15(self) -> &'a mut W {
412 self.variant(DTPRSSEL_A::PRSCH15)
413 }
414 #[doc = "PRS Channel 16 selected as input"]
415 #[inline(always)]
416 pub fn prsch16(self) -> &'a mut W {
417 self.variant(DTPRSSEL_A::PRSCH16)
418 }
419 #[doc = "PRS Channel 17 selected as input"]
420 #[inline(always)]
421 pub fn prsch17(self) -> &'a mut W {
422 self.variant(DTPRSSEL_A::PRSCH17)
423 }
424 #[doc = "PRS Channel 18 selected as input"]
425 #[inline(always)]
426 pub fn prsch18(self) -> &'a mut W {
427 self.variant(DTPRSSEL_A::PRSCH18)
428 }
429 #[doc = "PRS Channel 19 selected as input"]
430 #[inline(always)]
431 pub fn prsch19(self) -> &'a mut W {
432 self.variant(DTPRSSEL_A::PRSCH19)
433 }
434 #[doc = "PRS Channel 20 selected as input"]
435 #[inline(always)]
436 pub fn prsch20(self) -> &'a mut W {
437 self.variant(DTPRSSEL_A::PRSCH20)
438 }
439 #[doc = "PRS Channel 21 selected as input"]
440 #[inline(always)]
441 pub fn prsch21(self) -> &'a mut W {
442 self.variant(DTPRSSEL_A::PRSCH21)
443 }
444 #[doc = "PRS Channel 22 selected as input"]
445 #[inline(always)]
446 pub fn prsch22(self) -> &'a mut W {
447 self.variant(DTPRSSEL_A::PRSCH22)
448 }
449 #[doc = "PRS Channel 23 selected as input"]
450 #[inline(always)]
451 pub fn prsch23(self) -> &'a mut W {
452 self.variant(DTPRSSEL_A::PRSCH23)
453 }
454 #[doc = r"Writes raw bits to the field"]
455 #[inline(always)]
456 pub unsafe fn bits(self, value: u8) -> &'a mut W {
457 self.w.bits = (self.w.bits & !(0x1f << 4)) | (((value as u32) & 0x1f) << 4);
458 self.w
459 }
460}
461#[doc = "Reader of field `DTAR`"]
462pub type DTAR_R = crate::R<bool, bool>;
463#[doc = "Write proxy for field `DTAR`"]
464pub struct DTAR_W<'a> {
465 w: &'a mut W,
466}
467impl<'a> DTAR_W<'a> {
468 #[doc = r"Sets the field bit"]
469 #[inline(always)]
470 pub fn set_bit(self) -> &'a mut W {
471 self.bit(true)
472 }
473 #[doc = r"Clears the field bit"]
474 #[inline(always)]
475 pub fn clear_bit(self) -> &'a mut W {
476 self.bit(false)
477 }
478 #[doc = r"Writes raw bits to the field"]
479 #[inline(always)]
480 pub fn bit(self, value: bool) -> &'a mut W {
481 self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
482 self.w
483 }
484}
485#[doc = "Reader of field `DTFATS`"]
486pub type DTFATS_R = crate::R<bool, bool>;
487#[doc = "Write proxy for field `DTFATS`"]
488pub struct DTFATS_W<'a> {
489 w: &'a mut W,
490}
491impl<'a> DTFATS_W<'a> {
492 #[doc = r"Sets the field bit"]
493 #[inline(always)]
494 pub fn set_bit(self) -> &'a mut W {
495 self.bit(true)
496 }
497 #[doc = r"Clears the field bit"]
498 #[inline(always)]
499 pub fn clear_bit(self) -> &'a mut W {
500 self.bit(false)
501 }
502 #[doc = r"Writes raw bits to the field"]
503 #[inline(always)]
504 pub fn bit(self, value: bool) -> &'a mut W {
505 self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
506 self.w
507 }
508}
509#[doc = "Reader of field `DTPRSEN`"]
510pub type DTPRSEN_R = crate::R<bool, bool>;
511#[doc = "Write proxy for field `DTPRSEN`"]
512pub struct DTPRSEN_W<'a> {
513 w: &'a mut W,
514}
515impl<'a> DTPRSEN_W<'a> {
516 #[doc = r"Sets the field bit"]
517 #[inline(always)]
518 pub fn set_bit(self) -> &'a mut W {
519 self.bit(true)
520 }
521 #[doc = r"Clears the field bit"]
522 #[inline(always)]
523 pub fn clear_bit(self) -> &'a mut W {
524 self.bit(false)
525 }
526 #[doc = r"Writes raw bits to the field"]
527 #[inline(always)]
528 pub fn bit(self, value: bool) -> &'a mut W {
529 self.w.bits = (self.w.bits & !(0x01 << 24)) | (((value as u32) & 0x01) << 24);
530 self.w
531 }
532}
533impl R {
534 #[doc = "Bit 0 - DTI Enable"]
535 #[inline(always)]
536 pub fn dten(&self) -> DTEN_R {
537 DTEN_R::new((self.bits & 0x01) != 0)
538 }
539 #[doc = "Bit 1 - DTI Automatic Start-up Functionality"]
540 #[inline(always)]
541 pub fn dtdas(&self) -> DTDAS_R {
542 DTDAS_R::new(((self.bits >> 1) & 0x01) != 0)
543 }
544 #[doc = "Bit 2 - DTI Inactive Polarity"]
545 #[inline(always)]
546 pub fn dtipol(&self) -> DTIPOL_R {
547 DTIPOL_R::new(((self.bits >> 2) & 0x01) != 0)
548 }
549 #[doc = "Bit 3 - DTI Complementary Output Invert"]
550 #[inline(always)]
551 pub fn dtcinv(&self) -> DTCINV_R {
552 DTCINV_R::new(((self.bits >> 3) & 0x01) != 0)
553 }
554 #[doc = "Bits 4:8 - DTI PRS Source Channel Select"]
555 #[inline(always)]
556 pub fn dtprssel(&self) -> DTPRSSEL_R {
557 DTPRSSEL_R::new(((self.bits >> 4) & 0x1f) as u8)
558 }
559 #[doc = "Bit 9 - DTI Always Run"]
560 #[inline(always)]
561 pub fn dtar(&self) -> DTAR_R {
562 DTAR_R::new(((self.bits >> 9) & 0x01) != 0)
563 }
564 #[doc = "Bit 10 - DTI Fault Action on Timer Stop"]
565 #[inline(always)]
566 pub fn dtfats(&self) -> DTFATS_R {
567 DTFATS_R::new(((self.bits >> 10) & 0x01) != 0)
568 }
569 #[doc = "Bit 24 - DTI PRS Source Enable"]
570 #[inline(always)]
571 pub fn dtprsen(&self) -> DTPRSEN_R {
572 DTPRSEN_R::new(((self.bits >> 24) & 0x01) != 0)
573 }
574}
575impl W {
576 #[doc = "Bit 0 - DTI Enable"]
577 #[inline(always)]
578 pub fn dten(&mut self) -> DTEN_W {
579 DTEN_W { w: self }
580 }
581 #[doc = "Bit 1 - DTI Automatic Start-up Functionality"]
582 #[inline(always)]
583 pub fn dtdas(&mut self) -> DTDAS_W {
584 DTDAS_W { w: self }
585 }
586 #[doc = "Bit 2 - DTI Inactive Polarity"]
587 #[inline(always)]
588 pub fn dtipol(&mut self) -> DTIPOL_W {
589 DTIPOL_W { w: self }
590 }
591 #[doc = "Bit 3 - DTI Complementary Output Invert"]
592 #[inline(always)]
593 pub fn dtcinv(&mut self) -> DTCINV_W {
594 DTCINV_W { w: self }
595 }
596 #[doc = "Bits 4:8 - DTI PRS Source Channel Select"]
597 #[inline(always)]
598 pub fn dtprssel(&mut self) -> DTPRSSEL_W {
599 DTPRSSEL_W { w: self }
600 }
601 #[doc = "Bit 9 - DTI Always Run"]
602 #[inline(always)]
603 pub fn dtar(&mut self) -> DTAR_W {
604 DTAR_W { w: self }
605 }
606 #[doc = "Bit 10 - DTI Fault Action on Timer Stop"]
607 #[inline(always)]
608 pub fn dtfats(&mut self) -> DTFATS_W {
609 DTFATS_W { w: self }
610 }
611 #[doc = "Bit 24 - DTI PRS Source Enable"]
612 #[inline(always)]
613 pub fn dtprsen(&mut self) -> DTPRSEN_W {
614 DTPRSEN_W { w: self }
615 }
616}