1#[doc = "Register `DECCTRL` reader"]
2pub struct R(crate::R<DECCTRL_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<DECCTRL_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<DECCTRL_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<DECCTRL_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `DECCTRL` writer"]
17pub struct W(crate::W<DECCTRL_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<DECCTRL_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<DECCTRL_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<DECCTRL_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `DISABLE` reader - Disable the Decoder"]
38pub type DISABLE_R = crate::BitReader<bool>;
39#[doc = "Field `DISABLE` writer - Disable the Decoder"]
40pub type DISABLE_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 0>;
41#[doc = "Field `ERRCHK` reader - Enable Check of Current State"]
42pub type ERRCHK_R = crate::BitReader<bool>;
43#[doc = "Field `ERRCHK` writer - Enable Check of Current State"]
44pub type ERRCHK_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 1>;
45#[doc = "Field `INTMAP` reader - Enable Decoder to Channel Interrupt Mapping"]
46pub type INTMAP_R = crate::BitReader<bool>;
47#[doc = "Field `INTMAP` writer - Enable Decoder to Channel Interrupt Mapping"]
48pub type INTMAP_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 2>;
49#[doc = "Field `HYSTPRS0` reader - Enable Decoder Hysteresis on PRS0 Output"]
50pub type HYSTPRS0_R = crate::BitReader<bool>;
51#[doc = "Field `HYSTPRS0` writer - Enable Decoder Hysteresis on PRS0 Output"]
52pub type HYSTPRS0_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 3>;
53#[doc = "Field `HYSTPRS1` reader - Enable Decoder Hysteresis on PRS1 Output"]
54pub type HYSTPRS1_R = crate::BitReader<bool>;
55#[doc = "Field `HYSTPRS1` writer - Enable Decoder Hysteresis on PRS1 Output"]
56pub type HYSTPRS1_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 4>;
57#[doc = "Field `HYSTPRS2` reader - Enable Decoder Hysteresis on PRS2 Output"]
58pub type HYSTPRS2_R = crate::BitReader<bool>;
59#[doc = "Field `HYSTPRS2` writer - Enable Decoder Hysteresis on PRS2 Output"]
60pub type HYSTPRS2_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 5>;
61#[doc = "Field `HYSTIRQ` reader - Enable Decoder Hysteresis on Interrupt Requests"]
62pub type HYSTIRQ_R = crate::BitReader<bool>;
63#[doc = "Field `HYSTIRQ` writer - Enable Decoder Hysteresis on Interrupt Requests"]
64pub type HYSTIRQ_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 6>;
65#[doc = "Field `PRSCNT` reader - Enable Count Mode on Decoder PRS Channels 0 and 1"]
66pub type PRSCNT_R = crate::BitReader<bool>;
67#[doc = "Field `PRSCNT` writer - Enable Count Mode on Decoder PRS Channels 0 and 1"]
68pub type PRSCNT_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 7>;
69#[doc = "Field `INPUT` reader - LESENSE Decoder Input Configuration"]
70pub type INPUT_R = crate::BitReader<bool>;
71#[doc = "Field `INPUT` writer - LESENSE Decoder Input Configuration"]
72pub type INPUT_W<'a> = crate::BitWriter<'a, u32, DECCTRL_SPEC, bool, 8>;
73#[doc = "LESENSE Decoder PRS Input 0 Configuration\n\nValue on reset: 0"]
74#[derive(Clone, Copy, Debug, PartialEq)]
75#[repr(u8)]
76pub enum PRSSEL0_A {
77 #[doc = "0: PRS Channel 0 selected as input"]
78 PRSCH0 = 0,
79 #[doc = "1: PRS Channel 1 selected as input"]
80 PRSCH1 = 1,
81 #[doc = "2: PRS Channel 2 selected as input"]
82 PRSCH2 = 2,
83 #[doc = "3: PRS Channel 3 selected as input"]
84 PRSCH3 = 3,
85 #[doc = "4: PRS Channel 4 selected as input"]
86 PRSCH4 = 4,
87 #[doc = "5: PRS Channel 5 selected as input"]
88 PRSCH5 = 5,
89 #[doc = "6: PRS Channel 6 selected as input"]
90 PRSCH6 = 6,
91 #[doc = "7: PRS Channel 7 selected as input"]
92 PRSCH7 = 7,
93 #[doc = "8: PRS Channel 8 selected as input"]
94 PRSCH8 = 8,
95 #[doc = "9: PRS Channel 9 selected as input"]
96 PRSCH9 = 9,
97 #[doc = "10: PRS Channel 10 selected as input"]
98 PRSCH10 = 10,
99 #[doc = "11: PRS Channel 11 selected as input"]
100 PRSCH11 = 11,
101 #[doc = "12: PRS Channel 12 selected as input"]
102 PRSCH12 = 12,
103 #[doc = "13: PRS Channel 13 selected as input"]
104 PRSCH13 = 13,
105 #[doc = "14: PRS Channel 14 selected as input"]
106 PRSCH14 = 14,
107 #[doc = "15: PRS Channel 15 selected as input"]
108 PRSCH15 = 15,
109 #[doc = "16: PRS Channel 16 selected as input"]
110 PRSCH16 = 16,
111 #[doc = "17: PRS Channel 17 selected as input"]
112 PRSCH17 = 17,
113 #[doc = "18: PRS Channel 18 selected as input"]
114 PRSCH18 = 18,
115 #[doc = "19: PRS Channel 19 selected as input"]
116 PRSCH19 = 19,
117 #[doc = "20: PRS Channel 20 selected as input"]
118 PRSCH20 = 20,
119 #[doc = "21: PRS Channel 21 selected as input"]
120 PRSCH21 = 21,
121 #[doc = "22: PRS Channel 22 selected as input"]
122 PRSCH22 = 22,
123 #[doc = "23: PRS Channel 23 selected as input"]
124 PRSCH23 = 23,
125}
126impl From<PRSSEL0_A> for u8 {
127 #[inline(always)]
128 fn from(variant: PRSSEL0_A) -> Self {
129 variant as _
130 }
131}
132#[doc = "Field `PRSSEL0` reader - LESENSE Decoder PRS Input 0 Configuration"]
133pub type PRSSEL0_R = crate::FieldReader<u8, PRSSEL0_A>;
134impl PRSSEL0_R {
135 #[doc = "Get enumerated values variant"]
136 #[inline(always)]
137 pub fn variant(&self) -> Option<PRSSEL0_A> {
138 match self.bits {
139 0 => Some(PRSSEL0_A::PRSCH0),
140 1 => Some(PRSSEL0_A::PRSCH1),
141 2 => Some(PRSSEL0_A::PRSCH2),
142 3 => Some(PRSSEL0_A::PRSCH3),
143 4 => Some(PRSSEL0_A::PRSCH4),
144 5 => Some(PRSSEL0_A::PRSCH5),
145 6 => Some(PRSSEL0_A::PRSCH6),
146 7 => Some(PRSSEL0_A::PRSCH7),
147 8 => Some(PRSSEL0_A::PRSCH8),
148 9 => Some(PRSSEL0_A::PRSCH9),
149 10 => Some(PRSSEL0_A::PRSCH10),
150 11 => Some(PRSSEL0_A::PRSCH11),
151 12 => Some(PRSSEL0_A::PRSCH12),
152 13 => Some(PRSSEL0_A::PRSCH13),
153 14 => Some(PRSSEL0_A::PRSCH14),
154 15 => Some(PRSSEL0_A::PRSCH15),
155 16 => Some(PRSSEL0_A::PRSCH16),
156 17 => Some(PRSSEL0_A::PRSCH17),
157 18 => Some(PRSSEL0_A::PRSCH18),
158 19 => Some(PRSSEL0_A::PRSCH19),
159 20 => Some(PRSSEL0_A::PRSCH20),
160 21 => Some(PRSSEL0_A::PRSCH21),
161 22 => Some(PRSSEL0_A::PRSCH22),
162 23 => Some(PRSSEL0_A::PRSCH23),
163 _ => None,
164 }
165 }
166 #[doc = "Checks if the value of the field is `PRSCH0`"]
167 #[inline(always)]
168 pub fn is_prsch0(&self) -> bool {
169 *self == PRSSEL0_A::PRSCH0
170 }
171 #[doc = "Checks if the value of the field is `PRSCH1`"]
172 #[inline(always)]
173 pub fn is_prsch1(&self) -> bool {
174 *self == PRSSEL0_A::PRSCH1
175 }
176 #[doc = "Checks if the value of the field is `PRSCH2`"]
177 #[inline(always)]
178 pub fn is_prsch2(&self) -> bool {
179 *self == PRSSEL0_A::PRSCH2
180 }
181 #[doc = "Checks if the value of the field is `PRSCH3`"]
182 #[inline(always)]
183 pub fn is_prsch3(&self) -> bool {
184 *self == PRSSEL0_A::PRSCH3
185 }
186 #[doc = "Checks if the value of the field is `PRSCH4`"]
187 #[inline(always)]
188 pub fn is_prsch4(&self) -> bool {
189 *self == PRSSEL0_A::PRSCH4
190 }
191 #[doc = "Checks if the value of the field is `PRSCH5`"]
192 #[inline(always)]
193 pub fn is_prsch5(&self) -> bool {
194 *self == PRSSEL0_A::PRSCH5
195 }
196 #[doc = "Checks if the value of the field is `PRSCH6`"]
197 #[inline(always)]
198 pub fn is_prsch6(&self) -> bool {
199 *self == PRSSEL0_A::PRSCH6
200 }
201 #[doc = "Checks if the value of the field is `PRSCH7`"]
202 #[inline(always)]
203 pub fn is_prsch7(&self) -> bool {
204 *self == PRSSEL0_A::PRSCH7
205 }
206 #[doc = "Checks if the value of the field is `PRSCH8`"]
207 #[inline(always)]
208 pub fn is_prsch8(&self) -> bool {
209 *self == PRSSEL0_A::PRSCH8
210 }
211 #[doc = "Checks if the value of the field is `PRSCH9`"]
212 #[inline(always)]
213 pub fn is_prsch9(&self) -> bool {
214 *self == PRSSEL0_A::PRSCH9
215 }
216 #[doc = "Checks if the value of the field is `PRSCH10`"]
217 #[inline(always)]
218 pub fn is_prsch10(&self) -> bool {
219 *self == PRSSEL0_A::PRSCH10
220 }
221 #[doc = "Checks if the value of the field is `PRSCH11`"]
222 #[inline(always)]
223 pub fn is_prsch11(&self) -> bool {
224 *self == PRSSEL0_A::PRSCH11
225 }
226 #[doc = "Checks if the value of the field is `PRSCH12`"]
227 #[inline(always)]
228 pub fn is_prsch12(&self) -> bool {
229 *self == PRSSEL0_A::PRSCH12
230 }
231 #[doc = "Checks if the value of the field is `PRSCH13`"]
232 #[inline(always)]
233 pub fn is_prsch13(&self) -> bool {
234 *self == PRSSEL0_A::PRSCH13
235 }
236 #[doc = "Checks if the value of the field is `PRSCH14`"]
237 #[inline(always)]
238 pub fn is_prsch14(&self) -> bool {
239 *self == PRSSEL0_A::PRSCH14
240 }
241 #[doc = "Checks if the value of the field is `PRSCH15`"]
242 #[inline(always)]
243 pub fn is_prsch15(&self) -> bool {
244 *self == PRSSEL0_A::PRSCH15
245 }
246 #[doc = "Checks if the value of the field is `PRSCH16`"]
247 #[inline(always)]
248 pub fn is_prsch16(&self) -> bool {
249 *self == PRSSEL0_A::PRSCH16
250 }
251 #[doc = "Checks if the value of the field is `PRSCH17`"]
252 #[inline(always)]
253 pub fn is_prsch17(&self) -> bool {
254 *self == PRSSEL0_A::PRSCH17
255 }
256 #[doc = "Checks if the value of the field is `PRSCH18`"]
257 #[inline(always)]
258 pub fn is_prsch18(&self) -> bool {
259 *self == PRSSEL0_A::PRSCH18
260 }
261 #[doc = "Checks if the value of the field is `PRSCH19`"]
262 #[inline(always)]
263 pub fn is_prsch19(&self) -> bool {
264 *self == PRSSEL0_A::PRSCH19
265 }
266 #[doc = "Checks if the value of the field is `PRSCH20`"]
267 #[inline(always)]
268 pub fn is_prsch20(&self) -> bool {
269 *self == PRSSEL0_A::PRSCH20
270 }
271 #[doc = "Checks if the value of the field is `PRSCH21`"]
272 #[inline(always)]
273 pub fn is_prsch21(&self) -> bool {
274 *self == PRSSEL0_A::PRSCH21
275 }
276 #[doc = "Checks if the value of the field is `PRSCH22`"]
277 #[inline(always)]
278 pub fn is_prsch22(&self) -> bool {
279 *self == PRSSEL0_A::PRSCH22
280 }
281 #[doc = "Checks if the value of the field is `PRSCH23`"]
282 #[inline(always)]
283 pub fn is_prsch23(&self) -> bool {
284 *self == PRSSEL0_A::PRSCH23
285 }
286}
287#[doc = "Field `PRSSEL0` writer - LESENSE Decoder PRS Input 0 Configuration"]
288pub type PRSSEL0_W<'a> = crate::FieldWriter<'a, u32, DECCTRL_SPEC, u8, PRSSEL0_A, 5, 10>;
289impl<'a> PRSSEL0_W<'a> {
290 #[doc = "PRS Channel 0 selected as input"]
291 #[inline(always)]
292 pub fn prsch0(self) -> &'a mut W {
293 self.variant(PRSSEL0_A::PRSCH0)
294 }
295 #[doc = "PRS Channel 1 selected as input"]
296 #[inline(always)]
297 pub fn prsch1(self) -> &'a mut W {
298 self.variant(PRSSEL0_A::PRSCH1)
299 }
300 #[doc = "PRS Channel 2 selected as input"]
301 #[inline(always)]
302 pub fn prsch2(self) -> &'a mut W {
303 self.variant(PRSSEL0_A::PRSCH2)
304 }
305 #[doc = "PRS Channel 3 selected as input"]
306 #[inline(always)]
307 pub fn prsch3(self) -> &'a mut W {
308 self.variant(PRSSEL0_A::PRSCH3)
309 }
310 #[doc = "PRS Channel 4 selected as input"]
311 #[inline(always)]
312 pub fn prsch4(self) -> &'a mut W {
313 self.variant(PRSSEL0_A::PRSCH4)
314 }
315 #[doc = "PRS Channel 5 selected as input"]
316 #[inline(always)]
317 pub fn prsch5(self) -> &'a mut W {
318 self.variant(PRSSEL0_A::PRSCH5)
319 }
320 #[doc = "PRS Channel 6 selected as input"]
321 #[inline(always)]
322 pub fn prsch6(self) -> &'a mut W {
323 self.variant(PRSSEL0_A::PRSCH6)
324 }
325 #[doc = "PRS Channel 7 selected as input"]
326 #[inline(always)]
327 pub fn prsch7(self) -> &'a mut W {
328 self.variant(PRSSEL0_A::PRSCH7)
329 }
330 #[doc = "PRS Channel 8 selected as input"]
331 #[inline(always)]
332 pub fn prsch8(self) -> &'a mut W {
333 self.variant(PRSSEL0_A::PRSCH8)
334 }
335 #[doc = "PRS Channel 9 selected as input"]
336 #[inline(always)]
337 pub fn prsch9(self) -> &'a mut W {
338 self.variant(PRSSEL0_A::PRSCH9)
339 }
340 #[doc = "PRS Channel 10 selected as input"]
341 #[inline(always)]
342 pub fn prsch10(self) -> &'a mut W {
343 self.variant(PRSSEL0_A::PRSCH10)
344 }
345 #[doc = "PRS Channel 11 selected as input"]
346 #[inline(always)]
347 pub fn prsch11(self) -> &'a mut W {
348 self.variant(PRSSEL0_A::PRSCH11)
349 }
350 #[doc = "PRS Channel 12 selected as input"]
351 #[inline(always)]
352 pub fn prsch12(self) -> &'a mut W {
353 self.variant(PRSSEL0_A::PRSCH12)
354 }
355 #[doc = "PRS Channel 13 selected as input"]
356 #[inline(always)]
357 pub fn prsch13(self) -> &'a mut W {
358 self.variant(PRSSEL0_A::PRSCH13)
359 }
360 #[doc = "PRS Channel 14 selected as input"]
361 #[inline(always)]
362 pub fn prsch14(self) -> &'a mut W {
363 self.variant(PRSSEL0_A::PRSCH14)
364 }
365 #[doc = "PRS Channel 15 selected as input"]
366 #[inline(always)]
367 pub fn prsch15(self) -> &'a mut W {
368 self.variant(PRSSEL0_A::PRSCH15)
369 }
370 #[doc = "PRS Channel 16 selected as input"]
371 #[inline(always)]
372 pub fn prsch16(self) -> &'a mut W {
373 self.variant(PRSSEL0_A::PRSCH16)
374 }
375 #[doc = "PRS Channel 17 selected as input"]
376 #[inline(always)]
377 pub fn prsch17(self) -> &'a mut W {
378 self.variant(PRSSEL0_A::PRSCH17)
379 }
380 #[doc = "PRS Channel 18 selected as input"]
381 #[inline(always)]
382 pub fn prsch18(self) -> &'a mut W {
383 self.variant(PRSSEL0_A::PRSCH18)
384 }
385 #[doc = "PRS Channel 19 selected as input"]
386 #[inline(always)]
387 pub fn prsch19(self) -> &'a mut W {
388 self.variant(PRSSEL0_A::PRSCH19)
389 }
390 #[doc = "PRS Channel 20 selected as input"]
391 #[inline(always)]
392 pub fn prsch20(self) -> &'a mut W {
393 self.variant(PRSSEL0_A::PRSCH20)
394 }
395 #[doc = "PRS Channel 21 selected as input"]
396 #[inline(always)]
397 pub fn prsch21(self) -> &'a mut W {
398 self.variant(PRSSEL0_A::PRSCH21)
399 }
400 #[doc = "PRS Channel 22 selected as input"]
401 #[inline(always)]
402 pub fn prsch22(self) -> &'a mut W {
403 self.variant(PRSSEL0_A::PRSCH22)
404 }
405 #[doc = "PRS Channel 23 selected as input"]
406 #[inline(always)]
407 pub fn prsch23(self) -> &'a mut W {
408 self.variant(PRSSEL0_A::PRSCH23)
409 }
410}
411#[doc = "LESENSE Decoder PRS Input 1 Configuration\n\nValue on reset: 0"]
412#[derive(Clone, Copy, Debug, PartialEq)]
413#[repr(u8)]
414pub enum PRSSEL1_A {
415 #[doc = "0: PRS Channel 0 selected as input"]
416 PRSCH0 = 0,
417 #[doc = "1: PRS Channel 1 selected as input"]
418 PRSCH1 = 1,
419 #[doc = "2: PRS Channel 2 selected as input"]
420 PRSCH2 = 2,
421 #[doc = "3: PRS Channel 3 selected as input"]
422 PRSCH3 = 3,
423 #[doc = "4: PRS Channel 4 selected as input"]
424 PRSCH4 = 4,
425 #[doc = "5: PRS Channel 5 selected as input"]
426 PRSCH5 = 5,
427 #[doc = "6: PRS Channel 6 selected as input"]
428 PRSCH6 = 6,
429 #[doc = "7: PRS Channel 7 selected as input"]
430 PRSCH7 = 7,
431 #[doc = "8: PRS Channel 8 selected as input"]
432 PRSCH8 = 8,
433 #[doc = "9: PRS Channel 9 selected as input"]
434 PRSCH9 = 9,
435 #[doc = "10: PRS Channel 10 selected as input"]
436 PRSCH10 = 10,
437 #[doc = "11: PRS Channel 11 selected as input"]
438 PRSCH11 = 11,
439 #[doc = "12: PRS Channel 12 selected as input"]
440 PRSCH12 = 12,
441 #[doc = "13: PRS Channel 13 selected as input"]
442 PRSCH13 = 13,
443 #[doc = "14: PRS Channel 14 selected as input"]
444 PRSCH14 = 14,
445 #[doc = "15: PRS Channel 15 selected as input"]
446 PRSCH15 = 15,
447 #[doc = "16: PRS Channel 16 selected as input"]
448 PRSCH16 = 16,
449 #[doc = "17: PRS Channel 17 selected as input"]
450 PRSCH17 = 17,
451 #[doc = "18: PRS Channel 18 selected as input"]
452 PRSCH18 = 18,
453 #[doc = "19: PRS Channel 19 selected as input"]
454 PRSCH19 = 19,
455 #[doc = "20: PRS Channel 20 selected as input"]
456 PRSCH20 = 20,
457 #[doc = "21: PRS Channel 21 selected as input"]
458 PRSCH21 = 21,
459 #[doc = "22: PRS Channel 22 selected as input"]
460 PRSCH22 = 22,
461 #[doc = "23: PRS Channel 23 selected as input"]
462 PRSCH23 = 23,
463}
464impl From<PRSSEL1_A> for u8 {
465 #[inline(always)]
466 fn from(variant: PRSSEL1_A) -> Self {
467 variant as _
468 }
469}
470#[doc = "Field `PRSSEL1` reader - LESENSE Decoder PRS Input 1 Configuration"]
471pub type PRSSEL1_R = crate::FieldReader<u8, PRSSEL1_A>;
472impl PRSSEL1_R {
473 #[doc = "Get enumerated values variant"]
474 #[inline(always)]
475 pub fn variant(&self) -> Option<PRSSEL1_A> {
476 match self.bits {
477 0 => Some(PRSSEL1_A::PRSCH0),
478 1 => Some(PRSSEL1_A::PRSCH1),
479 2 => Some(PRSSEL1_A::PRSCH2),
480 3 => Some(PRSSEL1_A::PRSCH3),
481 4 => Some(PRSSEL1_A::PRSCH4),
482 5 => Some(PRSSEL1_A::PRSCH5),
483 6 => Some(PRSSEL1_A::PRSCH6),
484 7 => Some(PRSSEL1_A::PRSCH7),
485 8 => Some(PRSSEL1_A::PRSCH8),
486 9 => Some(PRSSEL1_A::PRSCH9),
487 10 => Some(PRSSEL1_A::PRSCH10),
488 11 => Some(PRSSEL1_A::PRSCH11),
489 12 => Some(PRSSEL1_A::PRSCH12),
490 13 => Some(PRSSEL1_A::PRSCH13),
491 14 => Some(PRSSEL1_A::PRSCH14),
492 15 => Some(PRSSEL1_A::PRSCH15),
493 16 => Some(PRSSEL1_A::PRSCH16),
494 17 => Some(PRSSEL1_A::PRSCH17),
495 18 => Some(PRSSEL1_A::PRSCH18),
496 19 => Some(PRSSEL1_A::PRSCH19),
497 20 => Some(PRSSEL1_A::PRSCH20),
498 21 => Some(PRSSEL1_A::PRSCH21),
499 22 => Some(PRSSEL1_A::PRSCH22),
500 23 => Some(PRSSEL1_A::PRSCH23),
501 _ => None,
502 }
503 }
504 #[doc = "Checks if the value of the field is `PRSCH0`"]
505 #[inline(always)]
506 pub fn is_prsch0(&self) -> bool {
507 *self == PRSSEL1_A::PRSCH0
508 }
509 #[doc = "Checks if the value of the field is `PRSCH1`"]
510 #[inline(always)]
511 pub fn is_prsch1(&self) -> bool {
512 *self == PRSSEL1_A::PRSCH1
513 }
514 #[doc = "Checks if the value of the field is `PRSCH2`"]
515 #[inline(always)]
516 pub fn is_prsch2(&self) -> bool {
517 *self == PRSSEL1_A::PRSCH2
518 }
519 #[doc = "Checks if the value of the field is `PRSCH3`"]
520 #[inline(always)]
521 pub fn is_prsch3(&self) -> bool {
522 *self == PRSSEL1_A::PRSCH3
523 }
524 #[doc = "Checks if the value of the field is `PRSCH4`"]
525 #[inline(always)]
526 pub fn is_prsch4(&self) -> bool {
527 *self == PRSSEL1_A::PRSCH4
528 }
529 #[doc = "Checks if the value of the field is `PRSCH5`"]
530 #[inline(always)]
531 pub fn is_prsch5(&self) -> bool {
532 *self == PRSSEL1_A::PRSCH5
533 }
534 #[doc = "Checks if the value of the field is `PRSCH6`"]
535 #[inline(always)]
536 pub fn is_prsch6(&self) -> bool {
537 *self == PRSSEL1_A::PRSCH6
538 }
539 #[doc = "Checks if the value of the field is `PRSCH7`"]
540 #[inline(always)]
541 pub fn is_prsch7(&self) -> bool {
542 *self == PRSSEL1_A::PRSCH7
543 }
544 #[doc = "Checks if the value of the field is `PRSCH8`"]
545 #[inline(always)]
546 pub fn is_prsch8(&self) -> bool {
547 *self == PRSSEL1_A::PRSCH8
548 }
549 #[doc = "Checks if the value of the field is `PRSCH9`"]
550 #[inline(always)]
551 pub fn is_prsch9(&self) -> bool {
552 *self == PRSSEL1_A::PRSCH9
553 }
554 #[doc = "Checks if the value of the field is `PRSCH10`"]
555 #[inline(always)]
556 pub fn is_prsch10(&self) -> bool {
557 *self == PRSSEL1_A::PRSCH10
558 }
559 #[doc = "Checks if the value of the field is `PRSCH11`"]
560 #[inline(always)]
561 pub fn is_prsch11(&self) -> bool {
562 *self == PRSSEL1_A::PRSCH11
563 }
564 #[doc = "Checks if the value of the field is `PRSCH12`"]
565 #[inline(always)]
566 pub fn is_prsch12(&self) -> bool {
567 *self == PRSSEL1_A::PRSCH12
568 }
569 #[doc = "Checks if the value of the field is `PRSCH13`"]
570 #[inline(always)]
571 pub fn is_prsch13(&self) -> bool {
572 *self == PRSSEL1_A::PRSCH13
573 }
574 #[doc = "Checks if the value of the field is `PRSCH14`"]
575 #[inline(always)]
576 pub fn is_prsch14(&self) -> bool {
577 *self == PRSSEL1_A::PRSCH14
578 }
579 #[doc = "Checks if the value of the field is `PRSCH15`"]
580 #[inline(always)]
581 pub fn is_prsch15(&self) -> bool {
582 *self == PRSSEL1_A::PRSCH15
583 }
584 #[doc = "Checks if the value of the field is `PRSCH16`"]
585 #[inline(always)]
586 pub fn is_prsch16(&self) -> bool {
587 *self == PRSSEL1_A::PRSCH16
588 }
589 #[doc = "Checks if the value of the field is `PRSCH17`"]
590 #[inline(always)]
591 pub fn is_prsch17(&self) -> bool {
592 *self == PRSSEL1_A::PRSCH17
593 }
594 #[doc = "Checks if the value of the field is `PRSCH18`"]
595 #[inline(always)]
596 pub fn is_prsch18(&self) -> bool {
597 *self == PRSSEL1_A::PRSCH18
598 }
599 #[doc = "Checks if the value of the field is `PRSCH19`"]
600 #[inline(always)]
601 pub fn is_prsch19(&self) -> bool {
602 *self == PRSSEL1_A::PRSCH19
603 }
604 #[doc = "Checks if the value of the field is `PRSCH20`"]
605 #[inline(always)]
606 pub fn is_prsch20(&self) -> bool {
607 *self == PRSSEL1_A::PRSCH20
608 }
609 #[doc = "Checks if the value of the field is `PRSCH21`"]
610 #[inline(always)]
611 pub fn is_prsch21(&self) -> bool {
612 *self == PRSSEL1_A::PRSCH21
613 }
614 #[doc = "Checks if the value of the field is `PRSCH22`"]
615 #[inline(always)]
616 pub fn is_prsch22(&self) -> bool {
617 *self == PRSSEL1_A::PRSCH22
618 }
619 #[doc = "Checks if the value of the field is `PRSCH23`"]
620 #[inline(always)]
621 pub fn is_prsch23(&self) -> bool {
622 *self == PRSSEL1_A::PRSCH23
623 }
624}
625#[doc = "Field `PRSSEL1` writer - LESENSE Decoder PRS Input 1 Configuration"]
626pub type PRSSEL1_W<'a> = crate::FieldWriter<'a, u32, DECCTRL_SPEC, u8, PRSSEL1_A, 5, 15>;
627impl<'a> PRSSEL1_W<'a> {
628 #[doc = "PRS Channel 0 selected as input"]
629 #[inline(always)]
630 pub fn prsch0(self) -> &'a mut W {
631 self.variant(PRSSEL1_A::PRSCH0)
632 }
633 #[doc = "PRS Channel 1 selected as input"]
634 #[inline(always)]
635 pub fn prsch1(self) -> &'a mut W {
636 self.variant(PRSSEL1_A::PRSCH1)
637 }
638 #[doc = "PRS Channel 2 selected as input"]
639 #[inline(always)]
640 pub fn prsch2(self) -> &'a mut W {
641 self.variant(PRSSEL1_A::PRSCH2)
642 }
643 #[doc = "PRS Channel 3 selected as input"]
644 #[inline(always)]
645 pub fn prsch3(self) -> &'a mut W {
646 self.variant(PRSSEL1_A::PRSCH3)
647 }
648 #[doc = "PRS Channel 4 selected as input"]
649 #[inline(always)]
650 pub fn prsch4(self) -> &'a mut W {
651 self.variant(PRSSEL1_A::PRSCH4)
652 }
653 #[doc = "PRS Channel 5 selected as input"]
654 #[inline(always)]
655 pub fn prsch5(self) -> &'a mut W {
656 self.variant(PRSSEL1_A::PRSCH5)
657 }
658 #[doc = "PRS Channel 6 selected as input"]
659 #[inline(always)]
660 pub fn prsch6(self) -> &'a mut W {
661 self.variant(PRSSEL1_A::PRSCH6)
662 }
663 #[doc = "PRS Channel 7 selected as input"]
664 #[inline(always)]
665 pub fn prsch7(self) -> &'a mut W {
666 self.variant(PRSSEL1_A::PRSCH7)
667 }
668 #[doc = "PRS Channel 8 selected as input"]
669 #[inline(always)]
670 pub fn prsch8(self) -> &'a mut W {
671 self.variant(PRSSEL1_A::PRSCH8)
672 }
673 #[doc = "PRS Channel 9 selected as input"]
674 #[inline(always)]
675 pub fn prsch9(self) -> &'a mut W {
676 self.variant(PRSSEL1_A::PRSCH9)
677 }
678 #[doc = "PRS Channel 10 selected as input"]
679 #[inline(always)]
680 pub fn prsch10(self) -> &'a mut W {
681 self.variant(PRSSEL1_A::PRSCH10)
682 }
683 #[doc = "PRS Channel 11 selected as input"]
684 #[inline(always)]
685 pub fn prsch11(self) -> &'a mut W {
686 self.variant(PRSSEL1_A::PRSCH11)
687 }
688 #[doc = "PRS Channel 12 selected as input"]
689 #[inline(always)]
690 pub fn prsch12(self) -> &'a mut W {
691 self.variant(PRSSEL1_A::PRSCH12)
692 }
693 #[doc = "PRS Channel 13 selected as input"]
694 #[inline(always)]
695 pub fn prsch13(self) -> &'a mut W {
696 self.variant(PRSSEL1_A::PRSCH13)
697 }
698 #[doc = "PRS Channel 14 selected as input"]
699 #[inline(always)]
700 pub fn prsch14(self) -> &'a mut W {
701 self.variant(PRSSEL1_A::PRSCH14)
702 }
703 #[doc = "PRS Channel 15 selected as input"]
704 #[inline(always)]
705 pub fn prsch15(self) -> &'a mut W {
706 self.variant(PRSSEL1_A::PRSCH15)
707 }
708 #[doc = "PRS Channel 16 selected as input"]
709 #[inline(always)]
710 pub fn prsch16(self) -> &'a mut W {
711 self.variant(PRSSEL1_A::PRSCH16)
712 }
713 #[doc = "PRS Channel 17 selected as input"]
714 #[inline(always)]
715 pub fn prsch17(self) -> &'a mut W {
716 self.variant(PRSSEL1_A::PRSCH17)
717 }
718 #[doc = "PRS Channel 18 selected as input"]
719 #[inline(always)]
720 pub fn prsch18(self) -> &'a mut W {
721 self.variant(PRSSEL1_A::PRSCH18)
722 }
723 #[doc = "PRS Channel 19 selected as input"]
724 #[inline(always)]
725 pub fn prsch19(self) -> &'a mut W {
726 self.variant(PRSSEL1_A::PRSCH19)
727 }
728 #[doc = "PRS Channel 20 selected as input"]
729 #[inline(always)]
730 pub fn prsch20(self) -> &'a mut W {
731 self.variant(PRSSEL1_A::PRSCH20)
732 }
733 #[doc = "PRS Channel 21 selected as input"]
734 #[inline(always)]
735 pub fn prsch21(self) -> &'a mut W {
736 self.variant(PRSSEL1_A::PRSCH21)
737 }
738 #[doc = "PRS Channel 22 selected as input"]
739 #[inline(always)]
740 pub fn prsch22(self) -> &'a mut W {
741 self.variant(PRSSEL1_A::PRSCH22)
742 }
743 #[doc = "PRS Channel 23 selected as input"]
744 #[inline(always)]
745 pub fn prsch23(self) -> &'a mut W {
746 self.variant(PRSSEL1_A::PRSCH23)
747 }
748}
749#[doc = "LESENSE Decoder PRS Input 2 Configuration\n\nValue on reset: 0"]
750#[derive(Clone, Copy, Debug, PartialEq)]
751#[repr(u8)]
752pub enum PRSSEL2_A {
753 #[doc = "0: PRS Channel 0 selected as input"]
754 PRSCH0 = 0,
755 #[doc = "1: PRS Channel 1 selected as input"]
756 PRSCH1 = 1,
757 #[doc = "2: PRS Channel 2 selected as input"]
758 PRSCH2 = 2,
759 #[doc = "3: PRS Channel 3 selected as input"]
760 PRSCH3 = 3,
761 #[doc = "4: PRS Channel 4 selected as input"]
762 PRSCH4 = 4,
763 #[doc = "5: PRS Channel 5 selected as input"]
764 PRSCH5 = 5,
765 #[doc = "6: PRS Channel 6 selected as input"]
766 PRSCH6 = 6,
767 #[doc = "7: PRS Channel 7 selected as input"]
768 PRSCH7 = 7,
769 #[doc = "8: PRS Channel 8 selected as input"]
770 PRSCH8 = 8,
771 #[doc = "9: PRS Channel 9 selected as input"]
772 PRSCH9 = 9,
773 #[doc = "10: PRS Channel 10 selected as input"]
774 PRSCH10 = 10,
775 #[doc = "11: PRS Channel 11 selected as input"]
776 PRSCH11 = 11,
777 #[doc = "12: PRS Channel 12 selected as input"]
778 PRSCH12 = 12,
779 #[doc = "13: PRS Channel 13 selected as input"]
780 PRSCH13 = 13,
781 #[doc = "14: PRS Channel 14 selected as input"]
782 PRSCH14 = 14,
783 #[doc = "15: PRS Channel 15 selected as input"]
784 PRSCH15 = 15,
785 #[doc = "16: PRS Channel 16 selected as input"]
786 PRSCH16 = 16,
787 #[doc = "17: PRS Channel 17 selected as input"]
788 PRSCH17 = 17,
789 #[doc = "18: PRS Channel 18 selected as input"]
790 PRSCH18 = 18,
791 #[doc = "19: PRS Channel 19 selected as input"]
792 PRSCH19 = 19,
793 #[doc = "20: PRS Channel 20 selected as input"]
794 PRSCH20 = 20,
795 #[doc = "21: PRS Channel 21 selected as input"]
796 PRSCH21 = 21,
797 #[doc = "22: PRS Channel 22 selected as input"]
798 PRSCH22 = 22,
799 #[doc = "23: PRS Channel 23 selected as input"]
800 PRSCH23 = 23,
801}
802impl From<PRSSEL2_A> for u8 {
803 #[inline(always)]
804 fn from(variant: PRSSEL2_A) -> Self {
805 variant as _
806 }
807}
808#[doc = "Field `PRSSEL2` reader - LESENSE Decoder PRS Input 2 Configuration"]
809pub type PRSSEL2_R = crate::FieldReader<u8, PRSSEL2_A>;
810impl PRSSEL2_R {
811 #[doc = "Get enumerated values variant"]
812 #[inline(always)]
813 pub fn variant(&self) -> Option<PRSSEL2_A> {
814 match self.bits {
815 0 => Some(PRSSEL2_A::PRSCH0),
816 1 => Some(PRSSEL2_A::PRSCH1),
817 2 => Some(PRSSEL2_A::PRSCH2),
818 3 => Some(PRSSEL2_A::PRSCH3),
819 4 => Some(PRSSEL2_A::PRSCH4),
820 5 => Some(PRSSEL2_A::PRSCH5),
821 6 => Some(PRSSEL2_A::PRSCH6),
822 7 => Some(PRSSEL2_A::PRSCH7),
823 8 => Some(PRSSEL2_A::PRSCH8),
824 9 => Some(PRSSEL2_A::PRSCH9),
825 10 => Some(PRSSEL2_A::PRSCH10),
826 11 => Some(PRSSEL2_A::PRSCH11),
827 12 => Some(PRSSEL2_A::PRSCH12),
828 13 => Some(PRSSEL2_A::PRSCH13),
829 14 => Some(PRSSEL2_A::PRSCH14),
830 15 => Some(PRSSEL2_A::PRSCH15),
831 16 => Some(PRSSEL2_A::PRSCH16),
832 17 => Some(PRSSEL2_A::PRSCH17),
833 18 => Some(PRSSEL2_A::PRSCH18),
834 19 => Some(PRSSEL2_A::PRSCH19),
835 20 => Some(PRSSEL2_A::PRSCH20),
836 21 => Some(PRSSEL2_A::PRSCH21),
837 22 => Some(PRSSEL2_A::PRSCH22),
838 23 => Some(PRSSEL2_A::PRSCH23),
839 _ => None,
840 }
841 }
842 #[doc = "Checks if the value of the field is `PRSCH0`"]
843 #[inline(always)]
844 pub fn is_prsch0(&self) -> bool {
845 *self == PRSSEL2_A::PRSCH0
846 }
847 #[doc = "Checks if the value of the field is `PRSCH1`"]
848 #[inline(always)]
849 pub fn is_prsch1(&self) -> bool {
850 *self == PRSSEL2_A::PRSCH1
851 }
852 #[doc = "Checks if the value of the field is `PRSCH2`"]
853 #[inline(always)]
854 pub fn is_prsch2(&self) -> bool {
855 *self == PRSSEL2_A::PRSCH2
856 }
857 #[doc = "Checks if the value of the field is `PRSCH3`"]
858 #[inline(always)]
859 pub fn is_prsch3(&self) -> bool {
860 *self == PRSSEL2_A::PRSCH3
861 }
862 #[doc = "Checks if the value of the field is `PRSCH4`"]
863 #[inline(always)]
864 pub fn is_prsch4(&self) -> bool {
865 *self == PRSSEL2_A::PRSCH4
866 }
867 #[doc = "Checks if the value of the field is `PRSCH5`"]
868 #[inline(always)]
869 pub fn is_prsch5(&self) -> bool {
870 *self == PRSSEL2_A::PRSCH5
871 }
872 #[doc = "Checks if the value of the field is `PRSCH6`"]
873 #[inline(always)]
874 pub fn is_prsch6(&self) -> bool {
875 *self == PRSSEL2_A::PRSCH6
876 }
877 #[doc = "Checks if the value of the field is `PRSCH7`"]
878 #[inline(always)]
879 pub fn is_prsch7(&self) -> bool {
880 *self == PRSSEL2_A::PRSCH7
881 }
882 #[doc = "Checks if the value of the field is `PRSCH8`"]
883 #[inline(always)]
884 pub fn is_prsch8(&self) -> bool {
885 *self == PRSSEL2_A::PRSCH8
886 }
887 #[doc = "Checks if the value of the field is `PRSCH9`"]
888 #[inline(always)]
889 pub fn is_prsch9(&self) -> bool {
890 *self == PRSSEL2_A::PRSCH9
891 }
892 #[doc = "Checks if the value of the field is `PRSCH10`"]
893 #[inline(always)]
894 pub fn is_prsch10(&self) -> bool {
895 *self == PRSSEL2_A::PRSCH10
896 }
897 #[doc = "Checks if the value of the field is `PRSCH11`"]
898 #[inline(always)]
899 pub fn is_prsch11(&self) -> bool {
900 *self == PRSSEL2_A::PRSCH11
901 }
902 #[doc = "Checks if the value of the field is `PRSCH12`"]
903 #[inline(always)]
904 pub fn is_prsch12(&self) -> bool {
905 *self == PRSSEL2_A::PRSCH12
906 }
907 #[doc = "Checks if the value of the field is `PRSCH13`"]
908 #[inline(always)]
909 pub fn is_prsch13(&self) -> bool {
910 *self == PRSSEL2_A::PRSCH13
911 }
912 #[doc = "Checks if the value of the field is `PRSCH14`"]
913 #[inline(always)]
914 pub fn is_prsch14(&self) -> bool {
915 *self == PRSSEL2_A::PRSCH14
916 }
917 #[doc = "Checks if the value of the field is `PRSCH15`"]
918 #[inline(always)]
919 pub fn is_prsch15(&self) -> bool {
920 *self == PRSSEL2_A::PRSCH15
921 }
922 #[doc = "Checks if the value of the field is `PRSCH16`"]
923 #[inline(always)]
924 pub fn is_prsch16(&self) -> bool {
925 *self == PRSSEL2_A::PRSCH16
926 }
927 #[doc = "Checks if the value of the field is `PRSCH17`"]
928 #[inline(always)]
929 pub fn is_prsch17(&self) -> bool {
930 *self == PRSSEL2_A::PRSCH17
931 }
932 #[doc = "Checks if the value of the field is `PRSCH18`"]
933 #[inline(always)]
934 pub fn is_prsch18(&self) -> bool {
935 *self == PRSSEL2_A::PRSCH18
936 }
937 #[doc = "Checks if the value of the field is `PRSCH19`"]
938 #[inline(always)]
939 pub fn is_prsch19(&self) -> bool {
940 *self == PRSSEL2_A::PRSCH19
941 }
942 #[doc = "Checks if the value of the field is `PRSCH20`"]
943 #[inline(always)]
944 pub fn is_prsch20(&self) -> bool {
945 *self == PRSSEL2_A::PRSCH20
946 }
947 #[doc = "Checks if the value of the field is `PRSCH21`"]
948 #[inline(always)]
949 pub fn is_prsch21(&self) -> bool {
950 *self == PRSSEL2_A::PRSCH21
951 }
952 #[doc = "Checks if the value of the field is `PRSCH22`"]
953 #[inline(always)]
954 pub fn is_prsch22(&self) -> bool {
955 *self == PRSSEL2_A::PRSCH22
956 }
957 #[doc = "Checks if the value of the field is `PRSCH23`"]
958 #[inline(always)]
959 pub fn is_prsch23(&self) -> bool {
960 *self == PRSSEL2_A::PRSCH23
961 }
962}
963#[doc = "Field `PRSSEL2` writer - LESENSE Decoder PRS Input 2 Configuration"]
964pub type PRSSEL2_W<'a> = crate::FieldWriter<'a, u32, DECCTRL_SPEC, u8, PRSSEL2_A, 5, 20>;
965impl<'a> PRSSEL2_W<'a> {
966 #[doc = "PRS Channel 0 selected as input"]
967 #[inline(always)]
968 pub fn prsch0(self) -> &'a mut W {
969 self.variant(PRSSEL2_A::PRSCH0)
970 }
971 #[doc = "PRS Channel 1 selected as input"]
972 #[inline(always)]
973 pub fn prsch1(self) -> &'a mut W {
974 self.variant(PRSSEL2_A::PRSCH1)
975 }
976 #[doc = "PRS Channel 2 selected as input"]
977 #[inline(always)]
978 pub fn prsch2(self) -> &'a mut W {
979 self.variant(PRSSEL2_A::PRSCH2)
980 }
981 #[doc = "PRS Channel 3 selected as input"]
982 #[inline(always)]
983 pub fn prsch3(self) -> &'a mut W {
984 self.variant(PRSSEL2_A::PRSCH3)
985 }
986 #[doc = "PRS Channel 4 selected as input"]
987 #[inline(always)]
988 pub fn prsch4(self) -> &'a mut W {
989 self.variant(PRSSEL2_A::PRSCH4)
990 }
991 #[doc = "PRS Channel 5 selected as input"]
992 #[inline(always)]
993 pub fn prsch5(self) -> &'a mut W {
994 self.variant(PRSSEL2_A::PRSCH5)
995 }
996 #[doc = "PRS Channel 6 selected as input"]
997 #[inline(always)]
998 pub fn prsch6(self) -> &'a mut W {
999 self.variant(PRSSEL2_A::PRSCH6)
1000 }
1001 #[doc = "PRS Channel 7 selected as input"]
1002 #[inline(always)]
1003 pub fn prsch7(self) -> &'a mut W {
1004 self.variant(PRSSEL2_A::PRSCH7)
1005 }
1006 #[doc = "PRS Channel 8 selected as input"]
1007 #[inline(always)]
1008 pub fn prsch8(self) -> &'a mut W {
1009 self.variant(PRSSEL2_A::PRSCH8)
1010 }
1011 #[doc = "PRS Channel 9 selected as input"]
1012 #[inline(always)]
1013 pub fn prsch9(self) -> &'a mut W {
1014 self.variant(PRSSEL2_A::PRSCH9)
1015 }
1016 #[doc = "PRS Channel 10 selected as input"]
1017 #[inline(always)]
1018 pub fn prsch10(self) -> &'a mut W {
1019 self.variant(PRSSEL2_A::PRSCH10)
1020 }
1021 #[doc = "PRS Channel 11 selected as input"]
1022 #[inline(always)]
1023 pub fn prsch11(self) -> &'a mut W {
1024 self.variant(PRSSEL2_A::PRSCH11)
1025 }
1026 #[doc = "PRS Channel 12 selected as input"]
1027 #[inline(always)]
1028 pub fn prsch12(self) -> &'a mut W {
1029 self.variant(PRSSEL2_A::PRSCH12)
1030 }
1031 #[doc = "PRS Channel 13 selected as input"]
1032 #[inline(always)]
1033 pub fn prsch13(self) -> &'a mut W {
1034 self.variant(PRSSEL2_A::PRSCH13)
1035 }
1036 #[doc = "PRS Channel 14 selected as input"]
1037 #[inline(always)]
1038 pub fn prsch14(self) -> &'a mut W {
1039 self.variant(PRSSEL2_A::PRSCH14)
1040 }
1041 #[doc = "PRS Channel 15 selected as input"]
1042 #[inline(always)]
1043 pub fn prsch15(self) -> &'a mut W {
1044 self.variant(PRSSEL2_A::PRSCH15)
1045 }
1046 #[doc = "PRS Channel 16 selected as input"]
1047 #[inline(always)]
1048 pub fn prsch16(self) -> &'a mut W {
1049 self.variant(PRSSEL2_A::PRSCH16)
1050 }
1051 #[doc = "PRS Channel 17 selected as input"]
1052 #[inline(always)]
1053 pub fn prsch17(self) -> &'a mut W {
1054 self.variant(PRSSEL2_A::PRSCH17)
1055 }
1056 #[doc = "PRS Channel 18 selected as input"]
1057 #[inline(always)]
1058 pub fn prsch18(self) -> &'a mut W {
1059 self.variant(PRSSEL2_A::PRSCH18)
1060 }
1061 #[doc = "PRS Channel 19 selected as input"]
1062 #[inline(always)]
1063 pub fn prsch19(self) -> &'a mut W {
1064 self.variant(PRSSEL2_A::PRSCH19)
1065 }
1066 #[doc = "PRS Channel 20 selected as input"]
1067 #[inline(always)]
1068 pub fn prsch20(self) -> &'a mut W {
1069 self.variant(PRSSEL2_A::PRSCH20)
1070 }
1071 #[doc = "PRS Channel 21 selected as input"]
1072 #[inline(always)]
1073 pub fn prsch21(self) -> &'a mut W {
1074 self.variant(PRSSEL2_A::PRSCH21)
1075 }
1076 #[doc = "PRS Channel 22 selected as input"]
1077 #[inline(always)]
1078 pub fn prsch22(self) -> &'a mut W {
1079 self.variant(PRSSEL2_A::PRSCH22)
1080 }
1081 #[doc = "PRS Channel 23 selected as input"]
1082 #[inline(always)]
1083 pub fn prsch23(self) -> &'a mut W {
1084 self.variant(PRSSEL2_A::PRSCH23)
1085 }
1086}
1087#[doc = "LESENSE Decoder PRS Input 3 Configuration\n\nValue on reset: 0"]
1088#[derive(Clone, Copy, Debug, PartialEq)]
1089#[repr(u8)]
1090pub enum PRSSEL3_A {
1091 #[doc = "0: PRS Channel 0 selected as input"]
1092 PRSCH0 = 0,
1093 #[doc = "1: PRS Channel 1 selected as input"]
1094 PRSCH1 = 1,
1095 #[doc = "2: PRS Channel 2 selected as input"]
1096 PRSCH2 = 2,
1097 #[doc = "3: PRS Channel 3 selected as input"]
1098 PRSCH3 = 3,
1099 #[doc = "4: PRS Channel 4 selected as input"]
1100 PRSCH4 = 4,
1101 #[doc = "5: PRS Channel 5 selected as input"]
1102 PRSCH5 = 5,
1103 #[doc = "6: PRS Channel 6 selected as input"]
1104 PRSCH6 = 6,
1105 #[doc = "7: PRS Channel 7 selected as input"]
1106 PRSCH7 = 7,
1107 #[doc = "8: PRS Channel 8 selected as input"]
1108 PRSCH8 = 8,
1109 #[doc = "9: PRS Channel 9 selected as input"]
1110 PRSCH9 = 9,
1111 #[doc = "10: PRS Channel 10 selected as input"]
1112 PRSCH10 = 10,
1113 #[doc = "11: PRS Channel 11 selected as input"]
1114 PRSCH11 = 11,
1115 #[doc = "12: PRS Channel 12 selected as input"]
1116 PRSCH12 = 12,
1117 #[doc = "13: PRS Channel 13 selected as input"]
1118 PRSCH13 = 13,
1119 #[doc = "14: PRS Channel 14 selected as input"]
1120 PRSCH14 = 14,
1121 #[doc = "15: PRS Channel 15 selected as input"]
1122 PRSCH15 = 15,
1123 #[doc = "16: PRS Channel 16 selected as input"]
1124 PRSCH16 = 16,
1125 #[doc = "17: PRS Channel 17 selected as input"]
1126 PRSCH17 = 17,
1127 #[doc = "18: PRS Channel 18 selected as input"]
1128 PRSCH18 = 18,
1129 #[doc = "19: PRS Channel 19 selected as input"]
1130 PRSCH19 = 19,
1131 #[doc = "20: PRS Channel 20 selected as input"]
1132 PRSCH20 = 20,
1133 #[doc = "21: PRS Channel 21 selected as input"]
1134 PRSCH21 = 21,
1135 #[doc = "22: PRS Channel 22 selected as input"]
1136 PRSCH22 = 22,
1137 #[doc = "23: PRS Channel 23 selected as input"]
1138 PRSCH23 = 23,
1139}
1140impl From<PRSSEL3_A> for u8 {
1141 #[inline(always)]
1142 fn from(variant: PRSSEL3_A) -> Self {
1143 variant as _
1144 }
1145}
1146#[doc = "Field `PRSSEL3` reader - LESENSE Decoder PRS Input 3 Configuration"]
1147pub type PRSSEL3_R = crate::FieldReader<u8, PRSSEL3_A>;
1148impl PRSSEL3_R {
1149 #[doc = "Get enumerated values variant"]
1150 #[inline(always)]
1151 pub fn variant(&self) -> Option<PRSSEL3_A> {
1152 match self.bits {
1153 0 => Some(PRSSEL3_A::PRSCH0),
1154 1 => Some(PRSSEL3_A::PRSCH1),
1155 2 => Some(PRSSEL3_A::PRSCH2),
1156 3 => Some(PRSSEL3_A::PRSCH3),
1157 4 => Some(PRSSEL3_A::PRSCH4),
1158 5 => Some(PRSSEL3_A::PRSCH5),
1159 6 => Some(PRSSEL3_A::PRSCH6),
1160 7 => Some(PRSSEL3_A::PRSCH7),
1161 8 => Some(PRSSEL3_A::PRSCH8),
1162 9 => Some(PRSSEL3_A::PRSCH9),
1163 10 => Some(PRSSEL3_A::PRSCH10),
1164 11 => Some(PRSSEL3_A::PRSCH11),
1165 12 => Some(PRSSEL3_A::PRSCH12),
1166 13 => Some(PRSSEL3_A::PRSCH13),
1167 14 => Some(PRSSEL3_A::PRSCH14),
1168 15 => Some(PRSSEL3_A::PRSCH15),
1169 16 => Some(PRSSEL3_A::PRSCH16),
1170 17 => Some(PRSSEL3_A::PRSCH17),
1171 18 => Some(PRSSEL3_A::PRSCH18),
1172 19 => Some(PRSSEL3_A::PRSCH19),
1173 20 => Some(PRSSEL3_A::PRSCH20),
1174 21 => Some(PRSSEL3_A::PRSCH21),
1175 22 => Some(PRSSEL3_A::PRSCH22),
1176 23 => Some(PRSSEL3_A::PRSCH23),
1177 _ => None,
1178 }
1179 }
1180 #[doc = "Checks if the value of the field is `PRSCH0`"]
1181 #[inline(always)]
1182 pub fn is_prsch0(&self) -> bool {
1183 *self == PRSSEL3_A::PRSCH0
1184 }
1185 #[doc = "Checks if the value of the field is `PRSCH1`"]
1186 #[inline(always)]
1187 pub fn is_prsch1(&self) -> bool {
1188 *self == PRSSEL3_A::PRSCH1
1189 }
1190 #[doc = "Checks if the value of the field is `PRSCH2`"]
1191 #[inline(always)]
1192 pub fn is_prsch2(&self) -> bool {
1193 *self == PRSSEL3_A::PRSCH2
1194 }
1195 #[doc = "Checks if the value of the field is `PRSCH3`"]
1196 #[inline(always)]
1197 pub fn is_prsch3(&self) -> bool {
1198 *self == PRSSEL3_A::PRSCH3
1199 }
1200 #[doc = "Checks if the value of the field is `PRSCH4`"]
1201 #[inline(always)]
1202 pub fn is_prsch4(&self) -> bool {
1203 *self == PRSSEL3_A::PRSCH4
1204 }
1205 #[doc = "Checks if the value of the field is `PRSCH5`"]
1206 #[inline(always)]
1207 pub fn is_prsch5(&self) -> bool {
1208 *self == PRSSEL3_A::PRSCH5
1209 }
1210 #[doc = "Checks if the value of the field is `PRSCH6`"]
1211 #[inline(always)]
1212 pub fn is_prsch6(&self) -> bool {
1213 *self == PRSSEL3_A::PRSCH6
1214 }
1215 #[doc = "Checks if the value of the field is `PRSCH7`"]
1216 #[inline(always)]
1217 pub fn is_prsch7(&self) -> bool {
1218 *self == PRSSEL3_A::PRSCH7
1219 }
1220 #[doc = "Checks if the value of the field is `PRSCH8`"]
1221 #[inline(always)]
1222 pub fn is_prsch8(&self) -> bool {
1223 *self == PRSSEL3_A::PRSCH8
1224 }
1225 #[doc = "Checks if the value of the field is `PRSCH9`"]
1226 #[inline(always)]
1227 pub fn is_prsch9(&self) -> bool {
1228 *self == PRSSEL3_A::PRSCH9
1229 }
1230 #[doc = "Checks if the value of the field is `PRSCH10`"]
1231 #[inline(always)]
1232 pub fn is_prsch10(&self) -> bool {
1233 *self == PRSSEL3_A::PRSCH10
1234 }
1235 #[doc = "Checks if the value of the field is `PRSCH11`"]
1236 #[inline(always)]
1237 pub fn is_prsch11(&self) -> bool {
1238 *self == PRSSEL3_A::PRSCH11
1239 }
1240 #[doc = "Checks if the value of the field is `PRSCH12`"]
1241 #[inline(always)]
1242 pub fn is_prsch12(&self) -> bool {
1243 *self == PRSSEL3_A::PRSCH12
1244 }
1245 #[doc = "Checks if the value of the field is `PRSCH13`"]
1246 #[inline(always)]
1247 pub fn is_prsch13(&self) -> bool {
1248 *self == PRSSEL3_A::PRSCH13
1249 }
1250 #[doc = "Checks if the value of the field is `PRSCH14`"]
1251 #[inline(always)]
1252 pub fn is_prsch14(&self) -> bool {
1253 *self == PRSSEL3_A::PRSCH14
1254 }
1255 #[doc = "Checks if the value of the field is `PRSCH15`"]
1256 #[inline(always)]
1257 pub fn is_prsch15(&self) -> bool {
1258 *self == PRSSEL3_A::PRSCH15
1259 }
1260 #[doc = "Checks if the value of the field is `PRSCH16`"]
1261 #[inline(always)]
1262 pub fn is_prsch16(&self) -> bool {
1263 *self == PRSSEL3_A::PRSCH16
1264 }
1265 #[doc = "Checks if the value of the field is `PRSCH17`"]
1266 #[inline(always)]
1267 pub fn is_prsch17(&self) -> bool {
1268 *self == PRSSEL3_A::PRSCH17
1269 }
1270 #[doc = "Checks if the value of the field is `PRSCH18`"]
1271 #[inline(always)]
1272 pub fn is_prsch18(&self) -> bool {
1273 *self == PRSSEL3_A::PRSCH18
1274 }
1275 #[doc = "Checks if the value of the field is `PRSCH19`"]
1276 #[inline(always)]
1277 pub fn is_prsch19(&self) -> bool {
1278 *self == PRSSEL3_A::PRSCH19
1279 }
1280 #[doc = "Checks if the value of the field is `PRSCH20`"]
1281 #[inline(always)]
1282 pub fn is_prsch20(&self) -> bool {
1283 *self == PRSSEL3_A::PRSCH20
1284 }
1285 #[doc = "Checks if the value of the field is `PRSCH21`"]
1286 #[inline(always)]
1287 pub fn is_prsch21(&self) -> bool {
1288 *self == PRSSEL3_A::PRSCH21
1289 }
1290 #[doc = "Checks if the value of the field is `PRSCH22`"]
1291 #[inline(always)]
1292 pub fn is_prsch22(&self) -> bool {
1293 *self == PRSSEL3_A::PRSCH22
1294 }
1295 #[doc = "Checks if the value of the field is `PRSCH23`"]
1296 #[inline(always)]
1297 pub fn is_prsch23(&self) -> bool {
1298 *self == PRSSEL3_A::PRSCH23
1299 }
1300}
1301#[doc = "Field `PRSSEL3` writer - LESENSE Decoder PRS Input 3 Configuration"]
1302pub type PRSSEL3_W<'a> = crate::FieldWriter<'a, u32, DECCTRL_SPEC, u8, PRSSEL3_A, 5, 25>;
1303impl<'a> PRSSEL3_W<'a> {
1304 #[doc = "PRS Channel 0 selected as input"]
1305 #[inline(always)]
1306 pub fn prsch0(self) -> &'a mut W {
1307 self.variant(PRSSEL3_A::PRSCH0)
1308 }
1309 #[doc = "PRS Channel 1 selected as input"]
1310 #[inline(always)]
1311 pub fn prsch1(self) -> &'a mut W {
1312 self.variant(PRSSEL3_A::PRSCH1)
1313 }
1314 #[doc = "PRS Channel 2 selected as input"]
1315 #[inline(always)]
1316 pub fn prsch2(self) -> &'a mut W {
1317 self.variant(PRSSEL3_A::PRSCH2)
1318 }
1319 #[doc = "PRS Channel 3 selected as input"]
1320 #[inline(always)]
1321 pub fn prsch3(self) -> &'a mut W {
1322 self.variant(PRSSEL3_A::PRSCH3)
1323 }
1324 #[doc = "PRS Channel 4 selected as input"]
1325 #[inline(always)]
1326 pub fn prsch4(self) -> &'a mut W {
1327 self.variant(PRSSEL3_A::PRSCH4)
1328 }
1329 #[doc = "PRS Channel 5 selected as input"]
1330 #[inline(always)]
1331 pub fn prsch5(self) -> &'a mut W {
1332 self.variant(PRSSEL3_A::PRSCH5)
1333 }
1334 #[doc = "PRS Channel 6 selected as input"]
1335 #[inline(always)]
1336 pub fn prsch6(self) -> &'a mut W {
1337 self.variant(PRSSEL3_A::PRSCH6)
1338 }
1339 #[doc = "PRS Channel 7 selected as input"]
1340 #[inline(always)]
1341 pub fn prsch7(self) -> &'a mut W {
1342 self.variant(PRSSEL3_A::PRSCH7)
1343 }
1344 #[doc = "PRS Channel 8 selected as input"]
1345 #[inline(always)]
1346 pub fn prsch8(self) -> &'a mut W {
1347 self.variant(PRSSEL3_A::PRSCH8)
1348 }
1349 #[doc = "PRS Channel 9 selected as input"]
1350 #[inline(always)]
1351 pub fn prsch9(self) -> &'a mut W {
1352 self.variant(PRSSEL3_A::PRSCH9)
1353 }
1354 #[doc = "PRS Channel 10 selected as input"]
1355 #[inline(always)]
1356 pub fn prsch10(self) -> &'a mut W {
1357 self.variant(PRSSEL3_A::PRSCH10)
1358 }
1359 #[doc = "PRS Channel 11 selected as input"]
1360 #[inline(always)]
1361 pub fn prsch11(self) -> &'a mut W {
1362 self.variant(PRSSEL3_A::PRSCH11)
1363 }
1364 #[doc = "PRS Channel 12 selected as input"]
1365 #[inline(always)]
1366 pub fn prsch12(self) -> &'a mut W {
1367 self.variant(PRSSEL3_A::PRSCH12)
1368 }
1369 #[doc = "PRS Channel 13 selected as input"]
1370 #[inline(always)]
1371 pub fn prsch13(self) -> &'a mut W {
1372 self.variant(PRSSEL3_A::PRSCH13)
1373 }
1374 #[doc = "PRS Channel 14 selected as input"]
1375 #[inline(always)]
1376 pub fn prsch14(self) -> &'a mut W {
1377 self.variant(PRSSEL3_A::PRSCH14)
1378 }
1379 #[doc = "PRS Channel 15 selected as input"]
1380 #[inline(always)]
1381 pub fn prsch15(self) -> &'a mut W {
1382 self.variant(PRSSEL3_A::PRSCH15)
1383 }
1384 #[doc = "PRS Channel 16 selected as input"]
1385 #[inline(always)]
1386 pub fn prsch16(self) -> &'a mut W {
1387 self.variant(PRSSEL3_A::PRSCH16)
1388 }
1389 #[doc = "PRS Channel 17 selected as input"]
1390 #[inline(always)]
1391 pub fn prsch17(self) -> &'a mut W {
1392 self.variant(PRSSEL3_A::PRSCH17)
1393 }
1394 #[doc = "PRS Channel 18 selected as input"]
1395 #[inline(always)]
1396 pub fn prsch18(self) -> &'a mut W {
1397 self.variant(PRSSEL3_A::PRSCH18)
1398 }
1399 #[doc = "PRS Channel 19 selected as input"]
1400 #[inline(always)]
1401 pub fn prsch19(self) -> &'a mut W {
1402 self.variant(PRSSEL3_A::PRSCH19)
1403 }
1404 #[doc = "PRS Channel 20 selected as input"]
1405 #[inline(always)]
1406 pub fn prsch20(self) -> &'a mut W {
1407 self.variant(PRSSEL3_A::PRSCH20)
1408 }
1409 #[doc = "PRS Channel 21 selected as input"]
1410 #[inline(always)]
1411 pub fn prsch21(self) -> &'a mut W {
1412 self.variant(PRSSEL3_A::PRSCH21)
1413 }
1414 #[doc = "PRS Channel 22 selected as input"]
1415 #[inline(always)]
1416 pub fn prsch22(self) -> &'a mut W {
1417 self.variant(PRSSEL3_A::PRSCH22)
1418 }
1419 #[doc = "PRS Channel 23 selected as input"]
1420 #[inline(always)]
1421 pub fn prsch23(self) -> &'a mut W {
1422 self.variant(PRSSEL3_A::PRSCH23)
1423 }
1424}
1425impl R {
1426 #[doc = "Bit 0 - Disable the Decoder"]
1427 #[inline(always)]
1428 pub fn disable(&self) -> DISABLE_R {
1429 DISABLE_R::new((self.bits & 1) != 0)
1430 }
1431 #[doc = "Bit 1 - Enable Check of Current State"]
1432 #[inline(always)]
1433 pub fn errchk(&self) -> ERRCHK_R {
1434 ERRCHK_R::new(((self.bits >> 1) & 1) != 0)
1435 }
1436 #[doc = "Bit 2 - Enable Decoder to Channel Interrupt Mapping"]
1437 #[inline(always)]
1438 pub fn intmap(&self) -> INTMAP_R {
1439 INTMAP_R::new(((self.bits >> 2) & 1) != 0)
1440 }
1441 #[doc = "Bit 3 - Enable Decoder Hysteresis on PRS0 Output"]
1442 #[inline(always)]
1443 pub fn hystprs0(&self) -> HYSTPRS0_R {
1444 HYSTPRS0_R::new(((self.bits >> 3) & 1) != 0)
1445 }
1446 #[doc = "Bit 4 - Enable Decoder Hysteresis on PRS1 Output"]
1447 #[inline(always)]
1448 pub fn hystprs1(&self) -> HYSTPRS1_R {
1449 HYSTPRS1_R::new(((self.bits >> 4) & 1) != 0)
1450 }
1451 #[doc = "Bit 5 - Enable Decoder Hysteresis on PRS2 Output"]
1452 #[inline(always)]
1453 pub fn hystprs2(&self) -> HYSTPRS2_R {
1454 HYSTPRS2_R::new(((self.bits >> 5) & 1) != 0)
1455 }
1456 #[doc = "Bit 6 - Enable Decoder Hysteresis on Interrupt Requests"]
1457 #[inline(always)]
1458 pub fn hystirq(&self) -> HYSTIRQ_R {
1459 HYSTIRQ_R::new(((self.bits >> 6) & 1) != 0)
1460 }
1461 #[doc = "Bit 7 - Enable Count Mode on Decoder PRS Channels 0 and 1"]
1462 #[inline(always)]
1463 pub fn prscnt(&self) -> PRSCNT_R {
1464 PRSCNT_R::new(((self.bits >> 7) & 1) != 0)
1465 }
1466 #[doc = "Bit 8 - LESENSE Decoder Input Configuration"]
1467 #[inline(always)]
1468 pub fn input(&self) -> INPUT_R {
1469 INPUT_R::new(((self.bits >> 8) & 1) != 0)
1470 }
1471 #[doc = "Bits 10:14 - LESENSE Decoder PRS Input 0 Configuration"]
1472 #[inline(always)]
1473 pub fn prssel0(&self) -> PRSSEL0_R {
1474 PRSSEL0_R::new(((self.bits >> 10) & 0x1f) as u8)
1475 }
1476 #[doc = "Bits 15:19 - LESENSE Decoder PRS Input 1 Configuration"]
1477 #[inline(always)]
1478 pub fn prssel1(&self) -> PRSSEL1_R {
1479 PRSSEL1_R::new(((self.bits >> 15) & 0x1f) as u8)
1480 }
1481 #[doc = "Bits 20:24 - LESENSE Decoder PRS Input 2 Configuration"]
1482 #[inline(always)]
1483 pub fn prssel2(&self) -> PRSSEL2_R {
1484 PRSSEL2_R::new(((self.bits >> 20) & 0x1f) as u8)
1485 }
1486 #[doc = "Bits 25:29 - LESENSE Decoder PRS Input 3 Configuration"]
1487 #[inline(always)]
1488 pub fn prssel3(&self) -> PRSSEL3_R {
1489 PRSSEL3_R::new(((self.bits >> 25) & 0x1f) as u8)
1490 }
1491}
1492impl W {
1493 #[doc = "Bit 0 - Disable the Decoder"]
1494 #[inline(always)]
1495 pub fn disable(&mut self) -> DISABLE_W {
1496 DISABLE_W::new(self)
1497 }
1498 #[doc = "Bit 1 - Enable Check of Current State"]
1499 #[inline(always)]
1500 pub fn errchk(&mut self) -> ERRCHK_W {
1501 ERRCHK_W::new(self)
1502 }
1503 #[doc = "Bit 2 - Enable Decoder to Channel Interrupt Mapping"]
1504 #[inline(always)]
1505 pub fn intmap(&mut self) -> INTMAP_W {
1506 INTMAP_W::new(self)
1507 }
1508 #[doc = "Bit 3 - Enable Decoder Hysteresis on PRS0 Output"]
1509 #[inline(always)]
1510 pub fn hystprs0(&mut self) -> HYSTPRS0_W {
1511 HYSTPRS0_W::new(self)
1512 }
1513 #[doc = "Bit 4 - Enable Decoder Hysteresis on PRS1 Output"]
1514 #[inline(always)]
1515 pub fn hystprs1(&mut self) -> HYSTPRS1_W {
1516 HYSTPRS1_W::new(self)
1517 }
1518 #[doc = "Bit 5 - Enable Decoder Hysteresis on PRS2 Output"]
1519 #[inline(always)]
1520 pub fn hystprs2(&mut self) -> HYSTPRS2_W {
1521 HYSTPRS2_W::new(self)
1522 }
1523 #[doc = "Bit 6 - Enable Decoder Hysteresis on Interrupt Requests"]
1524 #[inline(always)]
1525 pub fn hystirq(&mut self) -> HYSTIRQ_W {
1526 HYSTIRQ_W::new(self)
1527 }
1528 #[doc = "Bit 7 - Enable Count Mode on Decoder PRS Channels 0 and 1"]
1529 #[inline(always)]
1530 pub fn prscnt(&mut self) -> PRSCNT_W {
1531 PRSCNT_W::new(self)
1532 }
1533 #[doc = "Bit 8 - LESENSE Decoder Input Configuration"]
1534 #[inline(always)]
1535 pub fn input(&mut self) -> INPUT_W {
1536 INPUT_W::new(self)
1537 }
1538 #[doc = "Bits 10:14 - LESENSE Decoder PRS Input 0 Configuration"]
1539 #[inline(always)]
1540 pub fn prssel0(&mut self) -> PRSSEL0_W {
1541 PRSSEL0_W::new(self)
1542 }
1543 #[doc = "Bits 15:19 - LESENSE Decoder PRS Input 1 Configuration"]
1544 #[inline(always)]
1545 pub fn prssel1(&mut self) -> PRSSEL1_W {
1546 PRSSEL1_W::new(self)
1547 }
1548 #[doc = "Bits 20:24 - LESENSE Decoder PRS Input 2 Configuration"]
1549 #[inline(always)]
1550 pub fn prssel2(&mut self) -> PRSSEL2_W {
1551 PRSSEL2_W::new(self)
1552 }
1553 #[doc = "Bits 25:29 - LESENSE Decoder PRS Input 3 Configuration"]
1554 #[inline(always)]
1555 pub fn prssel3(&mut self) -> PRSSEL3_W {
1556 PRSSEL3_W::new(self)
1557 }
1558 #[doc = "Writes raw bits to the register."]
1559 #[inline(always)]
1560 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1561 self.0.bits(bits);
1562 self
1563 }
1564}
1565#[doc = "Decoder Control Register\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [decctrl](index.html) module"]
1566pub struct DECCTRL_SPEC;
1567impl crate::RegisterSpec for DECCTRL_SPEC {
1568 type Ux = u32;
1569}
1570#[doc = "`read()` method returns [decctrl::R](R) reader structure"]
1571impl crate::Readable for DECCTRL_SPEC {
1572 type Reader = R;
1573}
1574#[doc = "`write(|w| ..)` method takes [decctrl::W](W) writer structure"]
1575impl crate::Writable for DECCTRL_SPEC {
1576 type Writer = W;
1577}
1578#[doc = "`reset()` method sets DECCTRL to value 0"]
1579impl crate::Resettable for DECCTRL_SPEC {
1580 #[inline(always)]
1581 fn reset_value() -> Self::Ux {
1582 0
1583 }
1584}