1#[doc = "Reader of register DECCTRL"]
2pub type R = crate::R<u32, super::DECCTRL>;
3#[doc = "Writer for register DECCTRL"]
4pub type W = crate::W<u32, super::DECCTRL>;
5#[doc = "Register DECCTRL `reset()`'s with value 0"]
6impl crate::ResetValue for super::DECCTRL {
7 type Type = u32;
8 #[inline(always)]
9 fn reset_value() -> Self::Type {
10 0
11 }
12}
13#[doc = "Reader of field `DISABLE`"]
14pub type DISABLE_R = crate::R<bool, bool>;
15#[doc = "Write proxy for field `DISABLE`"]
16pub struct DISABLE_W<'a> {
17 w: &'a mut W,
18}
19impl<'a> DISABLE_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 `ERRCHK`"]
38pub type ERRCHK_R = crate::R<bool, bool>;
39#[doc = "Write proxy for field `ERRCHK`"]
40pub struct ERRCHK_W<'a> {
41 w: &'a mut W,
42}
43impl<'a> ERRCHK_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 `INTMAP`"]
62pub type INTMAP_R = crate::R<bool, bool>;
63#[doc = "Write proxy for field `INTMAP`"]
64pub struct INTMAP_W<'a> {
65 w: &'a mut W,
66}
67impl<'a> INTMAP_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 `HYSTPRS0`"]
86pub type HYSTPRS0_R = crate::R<bool, bool>;
87#[doc = "Write proxy for field `HYSTPRS0`"]
88pub struct HYSTPRS0_W<'a> {
89 w: &'a mut W,
90}
91impl<'a> HYSTPRS0_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 `HYSTPRS1`"]
110pub type HYSTPRS1_R = crate::R<bool, bool>;
111#[doc = "Write proxy for field `HYSTPRS1`"]
112pub struct HYSTPRS1_W<'a> {
113 w: &'a mut W,
114}
115impl<'a> HYSTPRS1_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 `HYSTPRS2`"]
134pub type HYSTPRS2_R = crate::R<bool, bool>;
135#[doc = "Write proxy for field `HYSTPRS2`"]
136pub struct HYSTPRS2_W<'a> {
137 w: &'a mut W,
138}
139impl<'a> HYSTPRS2_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 `HYSTIRQ`"]
158pub type HYSTIRQ_R = crate::R<bool, bool>;
159#[doc = "Write proxy for field `HYSTIRQ`"]
160pub struct HYSTIRQ_W<'a> {
161 w: &'a mut W,
162}
163impl<'a> HYSTIRQ_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 `PRSCNT`"]
182pub type PRSCNT_R = crate::R<bool, bool>;
183#[doc = "Write proxy for field `PRSCNT`"]
184pub struct PRSCNT_W<'a> {
185 w: &'a mut W,
186}
187impl<'a> PRSCNT_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 `INPUT`"]
206pub type INPUT_R = crate::R<bool, bool>;
207#[doc = "Write proxy for field `INPUT`"]
208pub struct INPUT_W<'a> {
209 w: &'a mut W,
210}
211impl<'a> INPUT_W<'a> {
212 #[doc = r"Sets the field bit"]
213 #[inline(always)]
214 pub fn set_bit(self) -> &'a mut W {
215 self.bit(true)
216 }
217 #[doc = r"Clears the field bit"]
218 #[inline(always)]
219 pub fn clear_bit(self) -> &'a mut W {
220 self.bit(false)
221 }
222 #[doc = r"Writes raw bits to the field"]
223 #[inline(always)]
224 pub fn bit(self, value: bool) -> &'a mut W {
225 self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
226 self.w
227 }
228}
229#[doc = "LESENSE Decoder PRS Input 0 Configuration\n\nValue on reset: 0"]
230#[derive(Clone, Copy, Debug, PartialEq)]
231#[repr(u8)]
232pub enum PRSSEL0_A {
233 #[doc = "0: PRS Channel 0 selected as input"]
234 PRSCH0 = 0,
235 #[doc = "1: PRS Channel 1 selected as input"]
236 PRSCH1 = 1,
237 #[doc = "2: PRS Channel 2 selected as input"]
238 PRSCH2 = 2,
239 #[doc = "3: PRS Channel 3 selected as input"]
240 PRSCH3 = 3,
241 #[doc = "4: PRS Channel 4 selected as input"]
242 PRSCH4 = 4,
243 #[doc = "5: PRS Channel 5 selected as input"]
244 PRSCH5 = 5,
245 #[doc = "6: PRS Channel 6 selected as input"]
246 PRSCH6 = 6,
247 #[doc = "7: PRS Channel 7 selected as input"]
248 PRSCH7 = 7,
249 #[doc = "8: PRS Channel 8 selected as input"]
250 PRSCH8 = 8,
251 #[doc = "9: PRS Channel 9 selected as input"]
252 PRSCH9 = 9,
253 #[doc = "10: PRS Channel 10 selected as input"]
254 PRSCH10 = 10,
255 #[doc = "11: PRS Channel 11 selected as input"]
256 PRSCH11 = 11,
257}
258impl From<PRSSEL0_A> for u8 {
259 #[inline(always)]
260 fn from(variant: PRSSEL0_A) -> Self {
261 variant as _
262 }
263}
264#[doc = "Reader of field `PRSSEL0`"]
265pub type PRSSEL0_R = crate::R<u8, PRSSEL0_A>;
266impl PRSSEL0_R {
267 #[doc = r"Get enumerated values variant"]
268 #[inline(always)]
269 pub fn variant(&self) -> crate::Variant<u8, PRSSEL0_A> {
270 use crate::Variant::*;
271 match self.bits {
272 0 => Val(PRSSEL0_A::PRSCH0),
273 1 => Val(PRSSEL0_A::PRSCH1),
274 2 => Val(PRSSEL0_A::PRSCH2),
275 3 => Val(PRSSEL0_A::PRSCH3),
276 4 => Val(PRSSEL0_A::PRSCH4),
277 5 => Val(PRSSEL0_A::PRSCH5),
278 6 => Val(PRSSEL0_A::PRSCH6),
279 7 => Val(PRSSEL0_A::PRSCH7),
280 8 => Val(PRSSEL0_A::PRSCH8),
281 9 => Val(PRSSEL0_A::PRSCH9),
282 10 => Val(PRSSEL0_A::PRSCH10),
283 11 => Val(PRSSEL0_A::PRSCH11),
284 i => Res(i),
285 }
286 }
287 #[doc = "Checks if the value of the field is `PRSCH0`"]
288 #[inline(always)]
289 pub fn is_prsch0(&self) -> bool {
290 *self == PRSSEL0_A::PRSCH0
291 }
292 #[doc = "Checks if the value of the field is `PRSCH1`"]
293 #[inline(always)]
294 pub fn is_prsch1(&self) -> bool {
295 *self == PRSSEL0_A::PRSCH1
296 }
297 #[doc = "Checks if the value of the field is `PRSCH2`"]
298 #[inline(always)]
299 pub fn is_prsch2(&self) -> bool {
300 *self == PRSSEL0_A::PRSCH2
301 }
302 #[doc = "Checks if the value of the field is `PRSCH3`"]
303 #[inline(always)]
304 pub fn is_prsch3(&self) -> bool {
305 *self == PRSSEL0_A::PRSCH3
306 }
307 #[doc = "Checks if the value of the field is `PRSCH4`"]
308 #[inline(always)]
309 pub fn is_prsch4(&self) -> bool {
310 *self == PRSSEL0_A::PRSCH4
311 }
312 #[doc = "Checks if the value of the field is `PRSCH5`"]
313 #[inline(always)]
314 pub fn is_prsch5(&self) -> bool {
315 *self == PRSSEL0_A::PRSCH5
316 }
317 #[doc = "Checks if the value of the field is `PRSCH6`"]
318 #[inline(always)]
319 pub fn is_prsch6(&self) -> bool {
320 *self == PRSSEL0_A::PRSCH6
321 }
322 #[doc = "Checks if the value of the field is `PRSCH7`"]
323 #[inline(always)]
324 pub fn is_prsch7(&self) -> bool {
325 *self == PRSSEL0_A::PRSCH7
326 }
327 #[doc = "Checks if the value of the field is `PRSCH8`"]
328 #[inline(always)]
329 pub fn is_prsch8(&self) -> bool {
330 *self == PRSSEL0_A::PRSCH8
331 }
332 #[doc = "Checks if the value of the field is `PRSCH9`"]
333 #[inline(always)]
334 pub fn is_prsch9(&self) -> bool {
335 *self == PRSSEL0_A::PRSCH9
336 }
337 #[doc = "Checks if the value of the field is `PRSCH10`"]
338 #[inline(always)]
339 pub fn is_prsch10(&self) -> bool {
340 *self == PRSSEL0_A::PRSCH10
341 }
342 #[doc = "Checks if the value of the field is `PRSCH11`"]
343 #[inline(always)]
344 pub fn is_prsch11(&self) -> bool {
345 *self == PRSSEL0_A::PRSCH11
346 }
347}
348#[doc = "Write proxy for field `PRSSEL0`"]
349pub struct PRSSEL0_W<'a> {
350 w: &'a mut W,
351}
352impl<'a> PRSSEL0_W<'a> {
353 #[doc = r"Writes `variant` to the field"]
354 #[inline(always)]
355 pub fn variant(self, variant: PRSSEL0_A) -> &'a mut W {
356 unsafe { self.bits(variant.into()) }
357 }
358 #[doc = "PRS Channel 0 selected as input"]
359 #[inline(always)]
360 pub fn prsch0(self) -> &'a mut W {
361 self.variant(PRSSEL0_A::PRSCH0)
362 }
363 #[doc = "PRS Channel 1 selected as input"]
364 #[inline(always)]
365 pub fn prsch1(self) -> &'a mut W {
366 self.variant(PRSSEL0_A::PRSCH1)
367 }
368 #[doc = "PRS Channel 2 selected as input"]
369 #[inline(always)]
370 pub fn prsch2(self) -> &'a mut W {
371 self.variant(PRSSEL0_A::PRSCH2)
372 }
373 #[doc = "PRS Channel 3 selected as input"]
374 #[inline(always)]
375 pub fn prsch3(self) -> &'a mut W {
376 self.variant(PRSSEL0_A::PRSCH3)
377 }
378 #[doc = "PRS Channel 4 selected as input"]
379 #[inline(always)]
380 pub fn prsch4(self) -> &'a mut W {
381 self.variant(PRSSEL0_A::PRSCH4)
382 }
383 #[doc = "PRS Channel 5 selected as input"]
384 #[inline(always)]
385 pub fn prsch5(self) -> &'a mut W {
386 self.variant(PRSSEL0_A::PRSCH5)
387 }
388 #[doc = "PRS Channel 6 selected as input"]
389 #[inline(always)]
390 pub fn prsch6(self) -> &'a mut W {
391 self.variant(PRSSEL0_A::PRSCH6)
392 }
393 #[doc = "PRS Channel 7 selected as input"]
394 #[inline(always)]
395 pub fn prsch7(self) -> &'a mut W {
396 self.variant(PRSSEL0_A::PRSCH7)
397 }
398 #[doc = "PRS Channel 8 selected as input"]
399 #[inline(always)]
400 pub fn prsch8(self) -> &'a mut W {
401 self.variant(PRSSEL0_A::PRSCH8)
402 }
403 #[doc = "PRS Channel 9 selected as input"]
404 #[inline(always)]
405 pub fn prsch9(self) -> &'a mut W {
406 self.variant(PRSSEL0_A::PRSCH9)
407 }
408 #[doc = "PRS Channel 10 selected as input"]
409 #[inline(always)]
410 pub fn prsch10(self) -> &'a mut W {
411 self.variant(PRSSEL0_A::PRSCH10)
412 }
413 #[doc = "PRS Channel 11 selected as input"]
414 #[inline(always)]
415 pub fn prsch11(self) -> &'a mut W {
416 self.variant(PRSSEL0_A::PRSCH11)
417 }
418 #[doc = r"Writes raw bits to the field"]
419 #[inline(always)]
420 pub unsafe fn bits(self, value: u8) -> &'a mut W {
421 self.w.bits = (self.w.bits & !(0x0f << 10)) | (((value as u32) & 0x0f) << 10);
422 self.w
423 }
424}
425#[doc = "LESENSE Decoder PRS Input 1 Configuration\n\nValue on reset: 0"]
426#[derive(Clone, Copy, Debug, PartialEq)]
427#[repr(u8)]
428pub enum PRSSEL1_A {
429 #[doc = "0: PRS Channel 0 selected as input"]
430 PRSCH0 = 0,
431 #[doc = "1: PRS Channel 1 selected as input"]
432 PRSCH1 = 1,
433 #[doc = "2: PRS Channel 2 selected as input"]
434 PRSCH2 = 2,
435 #[doc = "3: PRS Channel 3 selected as input"]
436 PRSCH3 = 3,
437 #[doc = "4: PRS Channel 4 selected as input"]
438 PRSCH4 = 4,
439 #[doc = "5: PRS Channel 5 selected as input"]
440 PRSCH5 = 5,
441 #[doc = "6: PRS Channel 6 selected as input"]
442 PRSCH6 = 6,
443 #[doc = "7: PRS Channel 7 selected as input"]
444 PRSCH7 = 7,
445 #[doc = "8: PRS Channel 8 selected as input"]
446 PRSCH8 = 8,
447 #[doc = "9: PRS Channel 9 selected as input"]
448 PRSCH9 = 9,
449 #[doc = "10: PRS Channel 10 selected as input"]
450 PRSCH10 = 10,
451 #[doc = "11: PRS Channel 11 selected as input"]
452 PRSCH11 = 11,
453}
454impl From<PRSSEL1_A> for u8 {
455 #[inline(always)]
456 fn from(variant: PRSSEL1_A) -> Self {
457 variant as _
458 }
459}
460#[doc = "Reader of field `PRSSEL1`"]
461pub type PRSSEL1_R = crate::R<u8, PRSSEL1_A>;
462impl PRSSEL1_R {
463 #[doc = r"Get enumerated values variant"]
464 #[inline(always)]
465 pub fn variant(&self) -> crate::Variant<u8, PRSSEL1_A> {
466 use crate::Variant::*;
467 match self.bits {
468 0 => Val(PRSSEL1_A::PRSCH0),
469 1 => Val(PRSSEL1_A::PRSCH1),
470 2 => Val(PRSSEL1_A::PRSCH2),
471 3 => Val(PRSSEL1_A::PRSCH3),
472 4 => Val(PRSSEL1_A::PRSCH4),
473 5 => Val(PRSSEL1_A::PRSCH5),
474 6 => Val(PRSSEL1_A::PRSCH6),
475 7 => Val(PRSSEL1_A::PRSCH7),
476 8 => Val(PRSSEL1_A::PRSCH8),
477 9 => Val(PRSSEL1_A::PRSCH9),
478 10 => Val(PRSSEL1_A::PRSCH10),
479 11 => Val(PRSSEL1_A::PRSCH11),
480 i => Res(i),
481 }
482 }
483 #[doc = "Checks if the value of the field is `PRSCH0`"]
484 #[inline(always)]
485 pub fn is_prsch0(&self) -> bool {
486 *self == PRSSEL1_A::PRSCH0
487 }
488 #[doc = "Checks if the value of the field is `PRSCH1`"]
489 #[inline(always)]
490 pub fn is_prsch1(&self) -> bool {
491 *self == PRSSEL1_A::PRSCH1
492 }
493 #[doc = "Checks if the value of the field is `PRSCH2`"]
494 #[inline(always)]
495 pub fn is_prsch2(&self) -> bool {
496 *self == PRSSEL1_A::PRSCH2
497 }
498 #[doc = "Checks if the value of the field is `PRSCH3`"]
499 #[inline(always)]
500 pub fn is_prsch3(&self) -> bool {
501 *self == PRSSEL1_A::PRSCH3
502 }
503 #[doc = "Checks if the value of the field is `PRSCH4`"]
504 #[inline(always)]
505 pub fn is_prsch4(&self) -> bool {
506 *self == PRSSEL1_A::PRSCH4
507 }
508 #[doc = "Checks if the value of the field is `PRSCH5`"]
509 #[inline(always)]
510 pub fn is_prsch5(&self) -> bool {
511 *self == PRSSEL1_A::PRSCH5
512 }
513 #[doc = "Checks if the value of the field is `PRSCH6`"]
514 #[inline(always)]
515 pub fn is_prsch6(&self) -> bool {
516 *self == PRSSEL1_A::PRSCH6
517 }
518 #[doc = "Checks if the value of the field is `PRSCH7`"]
519 #[inline(always)]
520 pub fn is_prsch7(&self) -> bool {
521 *self == PRSSEL1_A::PRSCH7
522 }
523 #[doc = "Checks if the value of the field is `PRSCH8`"]
524 #[inline(always)]
525 pub fn is_prsch8(&self) -> bool {
526 *self == PRSSEL1_A::PRSCH8
527 }
528 #[doc = "Checks if the value of the field is `PRSCH9`"]
529 #[inline(always)]
530 pub fn is_prsch9(&self) -> bool {
531 *self == PRSSEL1_A::PRSCH9
532 }
533 #[doc = "Checks if the value of the field is `PRSCH10`"]
534 #[inline(always)]
535 pub fn is_prsch10(&self) -> bool {
536 *self == PRSSEL1_A::PRSCH10
537 }
538 #[doc = "Checks if the value of the field is `PRSCH11`"]
539 #[inline(always)]
540 pub fn is_prsch11(&self) -> bool {
541 *self == PRSSEL1_A::PRSCH11
542 }
543}
544#[doc = "Write proxy for field `PRSSEL1`"]
545pub struct PRSSEL1_W<'a> {
546 w: &'a mut W,
547}
548impl<'a> PRSSEL1_W<'a> {
549 #[doc = r"Writes `variant` to the field"]
550 #[inline(always)]
551 pub fn variant(self, variant: PRSSEL1_A) -> &'a mut W {
552 unsafe { self.bits(variant.into()) }
553 }
554 #[doc = "PRS Channel 0 selected as input"]
555 #[inline(always)]
556 pub fn prsch0(self) -> &'a mut W {
557 self.variant(PRSSEL1_A::PRSCH0)
558 }
559 #[doc = "PRS Channel 1 selected as input"]
560 #[inline(always)]
561 pub fn prsch1(self) -> &'a mut W {
562 self.variant(PRSSEL1_A::PRSCH1)
563 }
564 #[doc = "PRS Channel 2 selected as input"]
565 #[inline(always)]
566 pub fn prsch2(self) -> &'a mut W {
567 self.variant(PRSSEL1_A::PRSCH2)
568 }
569 #[doc = "PRS Channel 3 selected as input"]
570 #[inline(always)]
571 pub fn prsch3(self) -> &'a mut W {
572 self.variant(PRSSEL1_A::PRSCH3)
573 }
574 #[doc = "PRS Channel 4 selected as input"]
575 #[inline(always)]
576 pub fn prsch4(self) -> &'a mut W {
577 self.variant(PRSSEL1_A::PRSCH4)
578 }
579 #[doc = "PRS Channel 5 selected as input"]
580 #[inline(always)]
581 pub fn prsch5(self) -> &'a mut W {
582 self.variant(PRSSEL1_A::PRSCH5)
583 }
584 #[doc = "PRS Channel 6 selected as input"]
585 #[inline(always)]
586 pub fn prsch6(self) -> &'a mut W {
587 self.variant(PRSSEL1_A::PRSCH6)
588 }
589 #[doc = "PRS Channel 7 selected as input"]
590 #[inline(always)]
591 pub fn prsch7(self) -> &'a mut W {
592 self.variant(PRSSEL1_A::PRSCH7)
593 }
594 #[doc = "PRS Channel 8 selected as input"]
595 #[inline(always)]
596 pub fn prsch8(self) -> &'a mut W {
597 self.variant(PRSSEL1_A::PRSCH8)
598 }
599 #[doc = "PRS Channel 9 selected as input"]
600 #[inline(always)]
601 pub fn prsch9(self) -> &'a mut W {
602 self.variant(PRSSEL1_A::PRSCH9)
603 }
604 #[doc = "PRS Channel 10 selected as input"]
605 #[inline(always)]
606 pub fn prsch10(self) -> &'a mut W {
607 self.variant(PRSSEL1_A::PRSCH10)
608 }
609 #[doc = "PRS Channel 11 selected as input"]
610 #[inline(always)]
611 pub fn prsch11(self) -> &'a mut W {
612 self.variant(PRSSEL1_A::PRSCH11)
613 }
614 #[doc = r"Writes raw bits to the field"]
615 #[inline(always)]
616 pub unsafe fn bits(self, value: u8) -> &'a mut W {
617 self.w.bits = (self.w.bits & !(0x0f << 15)) | (((value as u32) & 0x0f) << 15);
618 self.w
619 }
620}
621#[doc = "LESENSE Decoder PRS Input 2 Configuration\n\nValue on reset: 0"]
622#[derive(Clone, Copy, Debug, PartialEq)]
623#[repr(u8)]
624pub enum PRSSEL2_A {
625 #[doc = "0: PRS Channel 0 selected as input"]
626 PRSCH0 = 0,
627 #[doc = "1: PRS Channel 1 selected as input"]
628 PRSCH1 = 1,
629 #[doc = "2: PRS Channel 2 selected as input"]
630 PRSCH2 = 2,
631 #[doc = "3: PRS Channel 3 selected as input"]
632 PRSCH3 = 3,
633 #[doc = "4: PRS Channel 4 selected as input"]
634 PRSCH4 = 4,
635 #[doc = "5: PRS Channel 5 selected as input"]
636 PRSCH5 = 5,
637 #[doc = "6: PRS Channel 6 selected as input"]
638 PRSCH6 = 6,
639 #[doc = "7: PRS Channel 7 selected as input"]
640 PRSCH7 = 7,
641 #[doc = "8: PRS Channel 8 selected as input"]
642 PRSCH8 = 8,
643 #[doc = "9: PRS Channel 9 selected as input"]
644 PRSCH9 = 9,
645 #[doc = "10: PRS Channel 10 selected as input"]
646 PRSCH10 = 10,
647 #[doc = "11: PRS Channel 11 selected as input"]
648 PRSCH11 = 11,
649}
650impl From<PRSSEL2_A> for u8 {
651 #[inline(always)]
652 fn from(variant: PRSSEL2_A) -> Self {
653 variant as _
654 }
655}
656#[doc = "Reader of field `PRSSEL2`"]
657pub type PRSSEL2_R = crate::R<u8, PRSSEL2_A>;
658impl PRSSEL2_R {
659 #[doc = r"Get enumerated values variant"]
660 #[inline(always)]
661 pub fn variant(&self) -> crate::Variant<u8, PRSSEL2_A> {
662 use crate::Variant::*;
663 match self.bits {
664 0 => Val(PRSSEL2_A::PRSCH0),
665 1 => Val(PRSSEL2_A::PRSCH1),
666 2 => Val(PRSSEL2_A::PRSCH2),
667 3 => Val(PRSSEL2_A::PRSCH3),
668 4 => Val(PRSSEL2_A::PRSCH4),
669 5 => Val(PRSSEL2_A::PRSCH5),
670 6 => Val(PRSSEL2_A::PRSCH6),
671 7 => Val(PRSSEL2_A::PRSCH7),
672 8 => Val(PRSSEL2_A::PRSCH8),
673 9 => Val(PRSSEL2_A::PRSCH9),
674 10 => Val(PRSSEL2_A::PRSCH10),
675 11 => Val(PRSSEL2_A::PRSCH11),
676 i => Res(i),
677 }
678 }
679 #[doc = "Checks if the value of the field is `PRSCH0`"]
680 #[inline(always)]
681 pub fn is_prsch0(&self) -> bool {
682 *self == PRSSEL2_A::PRSCH0
683 }
684 #[doc = "Checks if the value of the field is `PRSCH1`"]
685 #[inline(always)]
686 pub fn is_prsch1(&self) -> bool {
687 *self == PRSSEL2_A::PRSCH1
688 }
689 #[doc = "Checks if the value of the field is `PRSCH2`"]
690 #[inline(always)]
691 pub fn is_prsch2(&self) -> bool {
692 *self == PRSSEL2_A::PRSCH2
693 }
694 #[doc = "Checks if the value of the field is `PRSCH3`"]
695 #[inline(always)]
696 pub fn is_prsch3(&self) -> bool {
697 *self == PRSSEL2_A::PRSCH3
698 }
699 #[doc = "Checks if the value of the field is `PRSCH4`"]
700 #[inline(always)]
701 pub fn is_prsch4(&self) -> bool {
702 *self == PRSSEL2_A::PRSCH4
703 }
704 #[doc = "Checks if the value of the field is `PRSCH5`"]
705 #[inline(always)]
706 pub fn is_prsch5(&self) -> bool {
707 *self == PRSSEL2_A::PRSCH5
708 }
709 #[doc = "Checks if the value of the field is `PRSCH6`"]
710 #[inline(always)]
711 pub fn is_prsch6(&self) -> bool {
712 *self == PRSSEL2_A::PRSCH6
713 }
714 #[doc = "Checks if the value of the field is `PRSCH7`"]
715 #[inline(always)]
716 pub fn is_prsch7(&self) -> bool {
717 *self == PRSSEL2_A::PRSCH7
718 }
719 #[doc = "Checks if the value of the field is `PRSCH8`"]
720 #[inline(always)]
721 pub fn is_prsch8(&self) -> bool {
722 *self == PRSSEL2_A::PRSCH8
723 }
724 #[doc = "Checks if the value of the field is `PRSCH9`"]
725 #[inline(always)]
726 pub fn is_prsch9(&self) -> bool {
727 *self == PRSSEL2_A::PRSCH9
728 }
729 #[doc = "Checks if the value of the field is `PRSCH10`"]
730 #[inline(always)]
731 pub fn is_prsch10(&self) -> bool {
732 *self == PRSSEL2_A::PRSCH10
733 }
734 #[doc = "Checks if the value of the field is `PRSCH11`"]
735 #[inline(always)]
736 pub fn is_prsch11(&self) -> bool {
737 *self == PRSSEL2_A::PRSCH11
738 }
739}
740#[doc = "Write proxy for field `PRSSEL2`"]
741pub struct PRSSEL2_W<'a> {
742 w: &'a mut W,
743}
744impl<'a> PRSSEL2_W<'a> {
745 #[doc = r"Writes `variant` to the field"]
746 #[inline(always)]
747 pub fn variant(self, variant: PRSSEL2_A) -> &'a mut W {
748 unsafe { self.bits(variant.into()) }
749 }
750 #[doc = "PRS Channel 0 selected as input"]
751 #[inline(always)]
752 pub fn prsch0(self) -> &'a mut W {
753 self.variant(PRSSEL2_A::PRSCH0)
754 }
755 #[doc = "PRS Channel 1 selected as input"]
756 #[inline(always)]
757 pub fn prsch1(self) -> &'a mut W {
758 self.variant(PRSSEL2_A::PRSCH1)
759 }
760 #[doc = "PRS Channel 2 selected as input"]
761 #[inline(always)]
762 pub fn prsch2(self) -> &'a mut W {
763 self.variant(PRSSEL2_A::PRSCH2)
764 }
765 #[doc = "PRS Channel 3 selected as input"]
766 #[inline(always)]
767 pub fn prsch3(self) -> &'a mut W {
768 self.variant(PRSSEL2_A::PRSCH3)
769 }
770 #[doc = "PRS Channel 4 selected as input"]
771 #[inline(always)]
772 pub fn prsch4(self) -> &'a mut W {
773 self.variant(PRSSEL2_A::PRSCH4)
774 }
775 #[doc = "PRS Channel 5 selected as input"]
776 #[inline(always)]
777 pub fn prsch5(self) -> &'a mut W {
778 self.variant(PRSSEL2_A::PRSCH5)
779 }
780 #[doc = "PRS Channel 6 selected as input"]
781 #[inline(always)]
782 pub fn prsch6(self) -> &'a mut W {
783 self.variant(PRSSEL2_A::PRSCH6)
784 }
785 #[doc = "PRS Channel 7 selected as input"]
786 #[inline(always)]
787 pub fn prsch7(self) -> &'a mut W {
788 self.variant(PRSSEL2_A::PRSCH7)
789 }
790 #[doc = "PRS Channel 8 selected as input"]
791 #[inline(always)]
792 pub fn prsch8(self) -> &'a mut W {
793 self.variant(PRSSEL2_A::PRSCH8)
794 }
795 #[doc = "PRS Channel 9 selected as input"]
796 #[inline(always)]
797 pub fn prsch9(self) -> &'a mut W {
798 self.variant(PRSSEL2_A::PRSCH9)
799 }
800 #[doc = "PRS Channel 10 selected as input"]
801 #[inline(always)]
802 pub fn prsch10(self) -> &'a mut W {
803 self.variant(PRSSEL2_A::PRSCH10)
804 }
805 #[doc = "PRS Channel 11 selected as input"]
806 #[inline(always)]
807 pub fn prsch11(self) -> &'a mut W {
808 self.variant(PRSSEL2_A::PRSCH11)
809 }
810 #[doc = r"Writes raw bits to the field"]
811 #[inline(always)]
812 pub unsafe fn bits(self, value: u8) -> &'a mut W {
813 self.w.bits = (self.w.bits & !(0x0f << 20)) | (((value as u32) & 0x0f) << 20);
814 self.w
815 }
816}
817#[doc = "LESENSE Decoder PRS Input 3 Configuration\n\nValue on reset: 0"]
818#[derive(Clone, Copy, Debug, PartialEq)]
819#[repr(u8)]
820pub enum PRSSEL3_A {
821 #[doc = "0: PRS Channel 0 selected as input"]
822 PRSCH0 = 0,
823 #[doc = "1: PRS Channel 1 selected as input"]
824 PRSCH1 = 1,
825 #[doc = "2: PRS Channel 2 selected as input"]
826 PRSCH2 = 2,
827 #[doc = "3: PRS Channel 3 selected as input"]
828 PRSCH3 = 3,
829 #[doc = "4: PRS Channel 4 selected as input"]
830 PRSCH4 = 4,
831 #[doc = "5: PRS Channel 5 selected as input"]
832 PRSCH5 = 5,
833 #[doc = "6: PRS Channel 6 selected as input"]
834 PRSCH6 = 6,
835 #[doc = "7: PRS Channel 7 selected as input"]
836 PRSCH7 = 7,
837 #[doc = "8: PRS Channel 8 selected as input"]
838 PRSCH8 = 8,
839 #[doc = "9: PRS Channel 9 selected as input"]
840 PRSCH9 = 9,
841 #[doc = "10: PRS Channel 10 selected as input"]
842 PRSCH10 = 10,
843 #[doc = "11: PRS Channel 11 selected as input"]
844 PRSCH11 = 11,
845}
846impl From<PRSSEL3_A> for u8 {
847 #[inline(always)]
848 fn from(variant: PRSSEL3_A) -> Self {
849 variant as _
850 }
851}
852#[doc = "Reader of field `PRSSEL3`"]
853pub type PRSSEL3_R = crate::R<u8, PRSSEL3_A>;
854impl PRSSEL3_R {
855 #[doc = r"Get enumerated values variant"]
856 #[inline(always)]
857 pub fn variant(&self) -> crate::Variant<u8, PRSSEL3_A> {
858 use crate::Variant::*;
859 match self.bits {
860 0 => Val(PRSSEL3_A::PRSCH0),
861 1 => Val(PRSSEL3_A::PRSCH1),
862 2 => Val(PRSSEL3_A::PRSCH2),
863 3 => Val(PRSSEL3_A::PRSCH3),
864 4 => Val(PRSSEL3_A::PRSCH4),
865 5 => Val(PRSSEL3_A::PRSCH5),
866 6 => Val(PRSSEL3_A::PRSCH6),
867 7 => Val(PRSSEL3_A::PRSCH7),
868 8 => Val(PRSSEL3_A::PRSCH8),
869 9 => Val(PRSSEL3_A::PRSCH9),
870 10 => Val(PRSSEL3_A::PRSCH10),
871 11 => Val(PRSSEL3_A::PRSCH11),
872 i => Res(i),
873 }
874 }
875 #[doc = "Checks if the value of the field is `PRSCH0`"]
876 #[inline(always)]
877 pub fn is_prsch0(&self) -> bool {
878 *self == PRSSEL3_A::PRSCH0
879 }
880 #[doc = "Checks if the value of the field is `PRSCH1`"]
881 #[inline(always)]
882 pub fn is_prsch1(&self) -> bool {
883 *self == PRSSEL3_A::PRSCH1
884 }
885 #[doc = "Checks if the value of the field is `PRSCH2`"]
886 #[inline(always)]
887 pub fn is_prsch2(&self) -> bool {
888 *self == PRSSEL3_A::PRSCH2
889 }
890 #[doc = "Checks if the value of the field is `PRSCH3`"]
891 #[inline(always)]
892 pub fn is_prsch3(&self) -> bool {
893 *self == PRSSEL3_A::PRSCH3
894 }
895 #[doc = "Checks if the value of the field is `PRSCH4`"]
896 #[inline(always)]
897 pub fn is_prsch4(&self) -> bool {
898 *self == PRSSEL3_A::PRSCH4
899 }
900 #[doc = "Checks if the value of the field is `PRSCH5`"]
901 #[inline(always)]
902 pub fn is_prsch5(&self) -> bool {
903 *self == PRSSEL3_A::PRSCH5
904 }
905 #[doc = "Checks if the value of the field is `PRSCH6`"]
906 #[inline(always)]
907 pub fn is_prsch6(&self) -> bool {
908 *self == PRSSEL3_A::PRSCH6
909 }
910 #[doc = "Checks if the value of the field is `PRSCH7`"]
911 #[inline(always)]
912 pub fn is_prsch7(&self) -> bool {
913 *self == PRSSEL3_A::PRSCH7
914 }
915 #[doc = "Checks if the value of the field is `PRSCH8`"]
916 #[inline(always)]
917 pub fn is_prsch8(&self) -> bool {
918 *self == PRSSEL3_A::PRSCH8
919 }
920 #[doc = "Checks if the value of the field is `PRSCH9`"]
921 #[inline(always)]
922 pub fn is_prsch9(&self) -> bool {
923 *self == PRSSEL3_A::PRSCH9
924 }
925 #[doc = "Checks if the value of the field is `PRSCH10`"]
926 #[inline(always)]
927 pub fn is_prsch10(&self) -> bool {
928 *self == PRSSEL3_A::PRSCH10
929 }
930 #[doc = "Checks if the value of the field is `PRSCH11`"]
931 #[inline(always)]
932 pub fn is_prsch11(&self) -> bool {
933 *self == PRSSEL3_A::PRSCH11
934 }
935}
936#[doc = "Write proxy for field `PRSSEL3`"]
937pub struct PRSSEL3_W<'a> {
938 w: &'a mut W,
939}
940impl<'a> PRSSEL3_W<'a> {
941 #[doc = r"Writes `variant` to the field"]
942 #[inline(always)]
943 pub fn variant(self, variant: PRSSEL3_A) -> &'a mut W {
944 unsafe { self.bits(variant.into()) }
945 }
946 #[doc = "PRS Channel 0 selected as input"]
947 #[inline(always)]
948 pub fn prsch0(self) -> &'a mut W {
949 self.variant(PRSSEL3_A::PRSCH0)
950 }
951 #[doc = "PRS Channel 1 selected as input"]
952 #[inline(always)]
953 pub fn prsch1(self) -> &'a mut W {
954 self.variant(PRSSEL3_A::PRSCH1)
955 }
956 #[doc = "PRS Channel 2 selected as input"]
957 #[inline(always)]
958 pub fn prsch2(self) -> &'a mut W {
959 self.variant(PRSSEL3_A::PRSCH2)
960 }
961 #[doc = "PRS Channel 3 selected as input"]
962 #[inline(always)]
963 pub fn prsch3(self) -> &'a mut W {
964 self.variant(PRSSEL3_A::PRSCH3)
965 }
966 #[doc = "PRS Channel 4 selected as input"]
967 #[inline(always)]
968 pub fn prsch4(self) -> &'a mut W {
969 self.variant(PRSSEL3_A::PRSCH4)
970 }
971 #[doc = "PRS Channel 5 selected as input"]
972 #[inline(always)]
973 pub fn prsch5(self) -> &'a mut W {
974 self.variant(PRSSEL3_A::PRSCH5)
975 }
976 #[doc = "PRS Channel 6 selected as input"]
977 #[inline(always)]
978 pub fn prsch6(self) -> &'a mut W {
979 self.variant(PRSSEL3_A::PRSCH6)
980 }
981 #[doc = "PRS Channel 7 selected as input"]
982 #[inline(always)]
983 pub fn prsch7(self) -> &'a mut W {
984 self.variant(PRSSEL3_A::PRSCH7)
985 }
986 #[doc = "PRS Channel 8 selected as input"]
987 #[inline(always)]
988 pub fn prsch8(self) -> &'a mut W {
989 self.variant(PRSSEL3_A::PRSCH8)
990 }
991 #[doc = "PRS Channel 9 selected as input"]
992 #[inline(always)]
993 pub fn prsch9(self) -> &'a mut W {
994 self.variant(PRSSEL3_A::PRSCH9)
995 }
996 #[doc = "PRS Channel 10 selected as input"]
997 #[inline(always)]
998 pub fn prsch10(self) -> &'a mut W {
999 self.variant(PRSSEL3_A::PRSCH10)
1000 }
1001 #[doc = "PRS Channel 11 selected as input"]
1002 #[inline(always)]
1003 pub fn prsch11(self) -> &'a mut W {
1004 self.variant(PRSSEL3_A::PRSCH11)
1005 }
1006 #[doc = r"Writes raw bits to the field"]
1007 #[inline(always)]
1008 pub unsafe fn bits(self, value: u8) -> &'a mut W {
1009 self.w.bits = (self.w.bits & !(0x0f << 25)) | (((value as u32) & 0x0f) << 25);
1010 self.w
1011 }
1012}
1013impl R {
1014 #[doc = "Bit 0 - Disable the Decoder"]
1015 #[inline(always)]
1016 pub fn disable(&self) -> DISABLE_R {
1017 DISABLE_R::new((self.bits & 0x01) != 0)
1018 }
1019 #[doc = "Bit 1 - Enable Check of Current State"]
1020 #[inline(always)]
1021 pub fn errchk(&self) -> ERRCHK_R {
1022 ERRCHK_R::new(((self.bits >> 1) & 0x01) != 0)
1023 }
1024 #[doc = "Bit 2 - Enable Decoder to Channel Interrupt Mapping"]
1025 #[inline(always)]
1026 pub fn intmap(&self) -> INTMAP_R {
1027 INTMAP_R::new(((self.bits >> 2) & 0x01) != 0)
1028 }
1029 #[doc = "Bit 3 - Enable Decoder Hysteresis on PRS0 Output"]
1030 #[inline(always)]
1031 pub fn hystprs0(&self) -> HYSTPRS0_R {
1032 HYSTPRS0_R::new(((self.bits >> 3) & 0x01) != 0)
1033 }
1034 #[doc = "Bit 4 - Enable Decoder Hysteresis on PRS1 Output"]
1035 #[inline(always)]
1036 pub fn hystprs1(&self) -> HYSTPRS1_R {
1037 HYSTPRS1_R::new(((self.bits >> 4) & 0x01) != 0)
1038 }
1039 #[doc = "Bit 5 - Enable Decoder Hysteresis on PRS2 Output"]
1040 #[inline(always)]
1041 pub fn hystprs2(&self) -> HYSTPRS2_R {
1042 HYSTPRS2_R::new(((self.bits >> 5) & 0x01) != 0)
1043 }
1044 #[doc = "Bit 6 - Enable Decoder Hysteresis on Interrupt Requests"]
1045 #[inline(always)]
1046 pub fn hystirq(&self) -> HYSTIRQ_R {
1047 HYSTIRQ_R::new(((self.bits >> 6) & 0x01) != 0)
1048 }
1049 #[doc = "Bit 7 - Enable Count Mode on Decoder PRS Channels 0 and 1"]
1050 #[inline(always)]
1051 pub fn prscnt(&self) -> PRSCNT_R {
1052 PRSCNT_R::new(((self.bits >> 7) & 0x01) != 0)
1053 }
1054 #[doc = "Bit 8 - LESENSE Decoder Input Configuration"]
1055 #[inline(always)]
1056 pub fn input(&self) -> INPUT_R {
1057 INPUT_R::new(((self.bits >> 8) & 0x01) != 0)
1058 }
1059 #[doc = "Bits 10:13 - LESENSE Decoder PRS Input 0 Configuration"]
1060 #[inline(always)]
1061 pub fn prssel0(&self) -> PRSSEL0_R {
1062 PRSSEL0_R::new(((self.bits >> 10) & 0x0f) as u8)
1063 }
1064 #[doc = "Bits 15:18 - LESENSE Decoder PRS Input 1 Configuration"]
1065 #[inline(always)]
1066 pub fn prssel1(&self) -> PRSSEL1_R {
1067 PRSSEL1_R::new(((self.bits >> 15) & 0x0f) as u8)
1068 }
1069 #[doc = "Bits 20:23 - LESENSE Decoder PRS Input 2 Configuration"]
1070 #[inline(always)]
1071 pub fn prssel2(&self) -> PRSSEL2_R {
1072 PRSSEL2_R::new(((self.bits >> 20) & 0x0f) as u8)
1073 }
1074 #[doc = "Bits 25:28 - LESENSE Decoder PRS Input 3 Configuration"]
1075 #[inline(always)]
1076 pub fn prssel3(&self) -> PRSSEL3_R {
1077 PRSSEL3_R::new(((self.bits >> 25) & 0x0f) as u8)
1078 }
1079}
1080impl W {
1081 #[doc = "Bit 0 - Disable the Decoder"]
1082 #[inline(always)]
1083 pub fn disable(&mut self) -> DISABLE_W {
1084 DISABLE_W { w: self }
1085 }
1086 #[doc = "Bit 1 - Enable Check of Current State"]
1087 #[inline(always)]
1088 pub fn errchk(&mut self) -> ERRCHK_W {
1089 ERRCHK_W { w: self }
1090 }
1091 #[doc = "Bit 2 - Enable Decoder to Channel Interrupt Mapping"]
1092 #[inline(always)]
1093 pub fn intmap(&mut self) -> INTMAP_W {
1094 INTMAP_W { w: self }
1095 }
1096 #[doc = "Bit 3 - Enable Decoder Hysteresis on PRS0 Output"]
1097 #[inline(always)]
1098 pub fn hystprs0(&mut self) -> HYSTPRS0_W {
1099 HYSTPRS0_W { w: self }
1100 }
1101 #[doc = "Bit 4 - Enable Decoder Hysteresis on PRS1 Output"]
1102 #[inline(always)]
1103 pub fn hystprs1(&mut self) -> HYSTPRS1_W {
1104 HYSTPRS1_W { w: self }
1105 }
1106 #[doc = "Bit 5 - Enable Decoder Hysteresis on PRS2 Output"]
1107 #[inline(always)]
1108 pub fn hystprs2(&mut self) -> HYSTPRS2_W {
1109 HYSTPRS2_W { w: self }
1110 }
1111 #[doc = "Bit 6 - Enable Decoder Hysteresis on Interrupt Requests"]
1112 #[inline(always)]
1113 pub fn hystirq(&mut self) -> HYSTIRQ_W {
1114 HYSTIRQ_W { w: self }
1115 }
1116 #[doc = "Bit 7 - Enable Count Mode on Decoder PRS Channels 0 and 1"]
1117 #[inline(always)]
1118 pub fn prscnt(&mut self) -> PRSCNT_W {
1119 PRSCNT_W { w: self }
1120 }
1121 #[doc = "Bit 8 - LESENSE Decoder Input Configuration"]
1122 #[inline(always)]
1123 pub fn input(&mut self) -> INPUT_W {
1124 INPUT_W { w: self }
1125 }
1126 #[doc = "Bits 10:13 - LESENSE Decoder PRS Input 0 Configuration"]
1127 #[inline(always)]
1128 pub fn prssel0(&mut self) -> PRSSEL0_W {
1129 PRSSEL0_W { w: self }
1130 }
1131 #[doc = "Bits 15:18 - LESENSE Decoder PRS Input 1 Configuration"]
1132 #[inline(always)]
1133 pub fn prssel1(&mut self) -> PRSSEL1_W {
1134 PRSSEL1_W { w: self }
1135 }
1136 #[doc = "Bits 20:23 - LESENSE Decoder PRS Input 2 Configuration"]
1137 #[inline(always)]
1138 pub fn prssel2(&mut self) -> PRSSEL2_W {
1139 PRSSEL2_W { w: self }
1140 }
1141 #[doc = "Bits 25:28 - LESENSE Decoder PRS Input 3 Configuration"]
1142 #[inline(always)]
1143 pub fn prssel3(&mut self) -> PRSSEL3_W {
1144 PRSSEL3_W { w: self }
1145 }
1146}