1#[doc = "Register `cir_rxsta` reader"]
2pub type R = crate::R<CIR_RXSTA_SPEC>;
3#[doc = "Register `cir_rxsta` writer"]
4pub type W = crate::W<CIR_RXSTA_SPEC>;
5#[doc = "Field `roi` reader - Receiver FIFO Overrun"]
6pub type ROI_R = crate::BitReader<ROI_A>;
7#[doc = "Receiver FIFO Overrun\n\nValue on reset: 0"]
8#[derive(Clone, Copy, Debug, PartialEq, Eq)]
9pub enum ROI_A {
10 #[doc = "0: Receiver FIFO not overrun"]
11 NOT_OVERRUN = 0,
12 #[doc = "1: Receiver FIFO overrun"]
13 OVERRUN = 1,
14}
15impl From<ROI_A> for bool {
16 #[inline(always)]
17 fn from(variant: ROI_A) -> Self {
18 variant as u8 != 0
19 }
20}
21impl ROI_R {
22 #[doc = "Get enumerated values variant"]
23 #[inline(always)]
24 pub const fn variant(&self) -> ROI_A {
25 match self.bits {
26 false => ROI_A::NOT_OVERRUN,
27 true => ROI_A::OVERRUN,
28 }
29 }
30 #[doc = "Receiver FIFO not overrun"]
31 #[inline(always)]
32 pub fn is_not_overrun(&self) -> bool {
33 *self == ROI_A::NOT_OVERRUN
34 }
35 #[doc = "Receiver FIFO overrun"]
36 #[inline(always)]
37 pub fn is_overrun(&self) -> bool {
38 *self == ROI_A::OVERRUN
39 }
40}
41#[doc = "Field `roi` writer - Receiver FIFO Overrun"]
42pub type ROI_W<'a, REG> = crate::BitWriter1C<'a, REG, ROI_A>;
43impl<'a, REG> ROI_W<'a, REG>
44where
45 REG: crate::Writable + crate::RegisterSpec,
46{
47 #[doc = "Receiver FIFO not overrun"]
48 #[inline(always)]
49 pub fn not_overrun(self) -> &'a mut crate::W<REG> {
50 self.variant(ROI_A::NOT_OVERRUN)
51 }
52 #[doc = "Receiver FIFO overrun"]
53 #[inline(always)]
54 pub fn overrun(self) -> &'a mut crate::W<REG> {
55 self.variant(ROI_A::OVERRUN)
56 }
57}
58#[doc = "Field `rpe` reader - Receiver Packet End Flag"]
59pub type RPE_R = crate::BitReader<RPE_A>;
60#[doc = "Receiver Packet End Flag\n\nValue on reset: 0"]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum RPE_A {
63 #[doc = "0: STO was not detected. In CIR mode, one CIR symbol is receiving or not detected."]
64 NOT_DETECTED = 0,
65 #[doc = "1: STO field or packet abort symbol (7'b0000,000 and 8'b0000,0000 for MIR and FIR) is detected. In CIR mode, one CIR symbol is received."]
66 STO_FIELD = 1,
67}
68impl From<RPE_A> for bool {
69 #[inline(always)]
70 fn from(variant: RPE_A) -> Self {
71 variant as u8 != 0
72 }
73}
74impl RPE_R {
75 #[doc = "Get enumerated values variant"]
76 #[inline(always)]
77 pub const fn variant(&self) -> RPE_A {
78 match self.bits {
79 false => RPE_A::NOT_DETECTED,
80 true => RPE_A::STO_FIELD,
81 }
82 }
83 #[doc = "STO was not detected. In CIR mode, one CIR symbol is receiving or not detected."]
84 #[inline(always)]
85 pub fn is_not_detected(&self) -> bool {
86 *self == RPE_A::NOT_DETECTED
87 }
88 #[doc = "STO field or packet abort symbol (7'b0000,000 and 8'b0000,0000 for MIR and FIR) is detected. In CIR mode, one CIR symbol is received."]
89 #[inline(always)]
90 pub fn is_sto_field(&self) -> bool {
91 *self == RPE_A::STO_FIELD
92 }
93}
94#[doc = "Field `rpe` writer - Receiver Packet End Flag"]
95pub type RPE_W<'a, REG> = crate::BitWriter1C<'a, REG, RPE_A>;
96impl<'a, REG> RPE_W<'a, REG>
97where
98 REG: crate::Writable + crate::RegisterSpec,
99{
100 #[doc = "STO was not detected. In CIR mode, one CIR symbol is receiving or not detected."]
101 #[inline(always)]
102 pub fn not_detected(self) -> &'a mut crate::W<REG> {
103 self.variant(RPE_A::NOT_DETECTED)
104 }
105 #[doc = "STO field or packet abort symbol (7'b0000,000 and 8'b0000,0000 for MIR and FIR) is detected. In CIR mode, one CIR symbol is received."]
106 #[inline(always)]
107 pub fn sto_field(self) -> &'a mut crate::W<REG> {
108 self.variant(RPE_A::STO_FIELD)
109 }
110}
111#[doc = "Field `ra` reader - RX FIFO Available"]
112pub type RA_R = crate::BitReader<RA_A>;
113#[doc = "RX FIFO Available\n\nValue on reset: 0"]
114#[derive(Clone, Copy, Debug, PartialEq, Eq)]
115pub enum RA_A {
116 #[doc = "0: RX FIFO not available according to its level"]
117 NO_AVAILABLE = 0,
118 #[doc = "1: RX FIFO available according to its level Writing 1 clears this bit."]
119 AVAILABLE = 1,
120}
121impl From<RA_A> for bool {
122 #[inline(always)]
123 fn from(variant: RA_A) -> Self {
124 variant as u8 != 0
125 }
126}
127impl RA_R {
128 #[doc = "Get enumerated values variant"]
129 #[inline(always)]
130 pub const fn variant(&self) -> RA_A {
131 match self.bits {
132 false => RA_A::NO_AVAILABLE,
133 true => RA_A::AVAILABLE,
134 }
135 }
136 #[doc = "RX FIFO not available according to its level"]
137 #[inline(always)]
138 pub fn is_no_available(&self) -> bool {
139 *self == RA_A::NO_AVAILABLE
140 }
141 #[doc = "RX FIFO available according to its level Writing 1 clears this bit."]
142 #[inline(always)]
143 pub fn is_available(&self) -> bool {
144 *self == RA_A::AVAILABLE
145 }
146}
147#[doc = "Field `ra` writer - RX FIFO Available"]
148pub type RA_W<'a, REG> = crate::BitWriter1C<'a, REG, RA_A>;
149impl<'a, REG> RA_W<'a, REG>
150where
151 REG: crate::Writable + crate::RegisterSpec,
152{
153 #[doc = "RX FIFO not available according to its level"]
154 #[inline(always)]
155 pub fn no_available(self) -> &'a mut crate::W<REG> {
156 self.variant(RA_A::NO_AVAILABLE)
157 }
158 #[doc = "RX FIFO available according to its level Writing 1 clears this bit."]
159 #[inline(always)]
160 pub fn available(self) -> &'a mut crate::W<REG> {
161 self.variant(RA_A::AVAILABLE)
162 }
163}
164#[doc = "Field `stat` reader - Status of CIR"]
165pub type STAT_R = crate::BitReader<STAT_A>;
166#[doc = "Status of CIR\n\nValue on reset: 0"]
167#[derive(Clone, Copy, Debug, PartialEq, Eq)]
168pub enum STAT_A {
169 #[doc = "0: Idle"]
170 IDLE = 0,
171 #[doc = "1: Busy"]
172 BUSY = 1,
173}
174impl From<STAT_A> for bool {
175 #[inline(always)]
176 fn from(variant: STAT_A) -> Self {
177 variant as u8 != 0
178 }
179}
180impl STAT_R {
181 #[doc = "Get enumerated values variant"]
182 #[inline(always)]
183 pub const fn variant(&self) -> STAT_A {
184 match self.bits {
185 false => STAT_A::IDLE,
186 true => STAT_A::BUSY,
187 }
188 }
189 #[doc = "Idle"]
190 #[inline(always)]
191 pub fn is_idle(&self) -> bool {
192 *self == STAT_A::IDLE
193 }
194 #[doc = "Busy"]
195 #[inline(always)]
196 pub fn is_busy(&self) -> bool {
197 *self == STAT_A::BUSY
198 }
199}
200#[doc = "Field `rac` reader - RX FIFO Available Counter"]
201pub type RAC_R = crate::FieldReader<RAC_A>;
202#[doc = "RX FIFO Available Counter\n\nValue on reset: 0"]
203#[derive(Clone, Copy, Debug, PartialEq, Eq)]
204#[repr(u8)]
205pub enum RAC_A {
206 #[doc = "0: No available data in RX FIFO"]
207 B0 = 0,
208 #[doc = "1: 1 byte available in RX FIFO"]
209 B1 = 1,
210 #[doc = "2: 2 bytes available in RX FIFO"]
211 B2 = 2,
212 #[doc = "3: 3 bytes available in RX FIFO"]
213 B3 = 3,
214 #[doc = "4: 4 bytes available in RX FIFO"]
215 B4 = 4,
216 #[doc = "5: 5 bytes available in RX FIFO"]
217 B5 = 5,
218 #[doc = "6: 6 bytes available in RX FIFO"]
219 B6 = 6,
220 #[doc = "7: 7 bytes available in RX FIFO"]
221 B7 = 7,
222 #[doc = "8: 8 bytes available in RX FIFO"]
223 B8 = 8,
224 #[doc = "9: 9 bytes available in RX FIFO"]
225 B9 = 9,
226 #[doc = "10: 10 bytes available in RX FIFO"]
227 B10 = 10,
228 #[doc = "11: 11 bytes available in RX FIFO"]
229 B11 = 11,
230 #[doc = "12: 12 bytes available in RX FIFO"]
231 B12 = 12,
232 #[doc = "13: 13 bytes available in RX FIFO"]
233 B13 = 13,
234 #[doc = "14: 14 bytes available in RX FIFO"]
235 B14 = 14,
236 #[doc = "15: 15 bytes available in RX FIFO"]
237 B15 = 15,
238 #[doc = "16: 16 bytes available in RX FIFO"]
239 B16 = 16,
240 #[doc = "17: 17 bytes available in RX FIFO"]
241 B17 = 17,
242 #[doc = "18: 18 bytes available in RX FIFO"]
243 B18 = 18,
244 #[doc = "19: 19 bytes available in RX FIFO"]
245 B19 = 19,
246 #[doc = "20: 20 bytes available in RX FIFO"]
247 B20 = 20,
248 #[doc = "21: 21 bytes available in RX FIFO"]
249 B21 = 21,
250 #[doc = "22: 22 bytes available in RX FIFO"]
251 B22 = 22,
252 #[doc = "23: 23 bytes available in RX FIFO"]
253 B23 = 23,
254 #[doc = "24: 24 bytes available in RX FIFO"]
255 B24 = 24,
256 #[doc = "25: 25 bytes available in RX FIFO"]
257 B25 = 25,
258 #[doc = "26: 26 bytes available in RX FIFO"]
259 B26 = 26,
260 #[doc = "27: 27 bytes available in RX FIFO"]
261 B27 = 27,
262 #[doc = "28: 28 bytes available in RX FIFO"]
263 B28 = 28,
264 #[doc = "29: 29 bytes available in RX FIFO"]
265 B29 = 29,
266 #[doc = "30: 30 bytes available in RX FIFO"]
267 B30 = 30,
268 #[doc = "31: 31 bytes available in RX FIFO"]
269 B31 = 31,
270 #[doc = "32: 32 bytes available in RX FIFO"]
271 B32 = 32,
272 #[doc = "33: 33 bytes available in RX FIFO"]
273 B33 = 33,
274 #[doc = "34: 34 bytes available in RX FIFO"]
275 B34 = 34,
276 #[doc = "35: 35 bytes available in RX FIFO"]
277 B35 = 35,
278 #[doc = "36: 36 bytes available in RX FIFO"]
279 B36 = 36,
280 #[doc = "37: 37 bytes available in RX FIFO"]
281 B37 = 37,
282 #[doc = "38: 38 bytes available in RX FIFO"]
283 B38 = 38,
284 #[doc = "39: 39 bytes available in RX FIFO"]
285 B39 = 39,
286 #[doc = "40: 40 bytes available in RX FIFO"]
287 B40 = 40,
288 #[doc = "41: 41 bytes available in RX FIFO"]
289 B41 = 41,
290 #[doc = "42: 42 bytes available in RX FIFO"]
291 B42 = 42,
292 #[doc = "43: 43 bytes available in RX FIFO"]
293 B43 = 43,
294 #[doc = "44: 44 bytes available in RX FIFO"]
295 B44 = 44,
296 #[doc = "45: 45 bytes available in RX FIFO"]
297 B45 = 45,
298 #[doc = "46: 46 bytes available in RX FIFO"]
299 B46 = 46,
300 #[doc = "47: 47 bytes available in RX FIFO"]
301 B47 = 47,
302 #[doc = "48: 48 bytes available in RX FIFO"]
303 B48 = 48,
304 #[doc = "49: 49 bytes available in RX FIFO"]
305 B49 = 49,
306 #[doc = "50: 50 bytes available in RX FIFO"]
307 B50 = 50,
308 #[doc = "51: 51 bytes available in RX FIFO"]
309 B51 = 51,
310 #[doc = "52: 52 bytes available in RX FIFO"]
311 B52 = 52,
312 #[doc = "53: 53 bytes available in RX FIFO"]
313 B53 = 53,
314 #[doc = "54: 54 bytes available in RX FIFO"]
315 B54 = 54,
316 #[doc = "55: 55 bytes available in RX FIFO"]
317 B55 = 55,
318 #[doc = "56: 56 bytes available in RX FIFO"]
319 B56 = 56,
320 #[doc = "57: 57 bytes available in RX FIFO"]
321 B57 = 57,
322 #[doc = "58: 58 bytes available in RX FIFO"]
323 B58 = 58,
324 #[doc = "59: 59 bytes available in RX FIFO"]
325 B59 = 59,
326 #[doc = "60: 60 bytes available in RX FIFO"]
327 B60 = 60,
328 #[doc = "61: 61 bytes available in RX FIFO"]
329 B61 = 61,
330 #[doc = "62: 62 bytes available in RX FIFO"]
331 B62 = 62,
332 #[doc = "63: 63 bytes available in RX FIFO"]
333 B63 = 63,
334 #[doc = "64: 64 bytes available in RX FIFO"]
335 B64 = 64,
336}
337impl From<RAC_A> for u8 {
338 #[inline(always)]
339 fn from(variant: RAC_A) -> Self {
340 variant as _
341 }
342}
343impl crate::FieldSpec for RAC_A {
344 type Ux = u8;
345}
346impl RAC_R {
347 #[doc = "Get enumerated values variant"]
348 #[inline(always)]
349 pub const fn variant(&self) -> Option<RAC_A> {
350 match self.bits {
351 0 => Some(RAC_A::B0),
352 1 => Some(RAC_A::B1),
353 2 => Some(RAC_A::B2),
354 3 => Some(RAC_A::B3),
355 4 => Some(RAC_A::B4),
356 5 => Some(RAC_A::B5),
357 6 => Some(RAC_A::B6),
358 7 => Some(RAC_A::B7),
359 8 => Some(RAC_A::B8),
360 9 => Some(RAC_A::B9),
361 10 => Some(RAC_A::B10),
362 11 => Some(RAC_A::B11),
363 12 => Some(RAC_A::B12),
364 13 => Some(RAC_A::B13),
365 14 => Some(RAC_A::B14),
366 15 => Some(RAC_A::B15),
367 16 => Some(RAC_A::B16),
368 17 => Some(RAC_A::B17),
369 18 => Some(RAC_A::B18),
370 19 => Some(RAC_A::B19),
371 20 => Some(RAC_A::B20),
372 21 => Some(RAC_A::B21),
373 22 => Some(RAC_A::B22),
374 23 => Some(RAC_A::B23),
375 24 => Some(RAC_A::B24),
376 25 => Some(RAC_A::B25),
377 26 => Some(RAC_A::B26),
378 27 => Some(RAC_A::B27),
379 28 => Some(RAC_A::B28),
380 29 => Some(RAC_A::B29),
381 30 => Some(RAC_A::B30),
382 31 => Some(RAC_A::B31),
383 32 => Some(RAC_A::B32),
384 33 => Some(RAC_A::B33),
385 34 => Some(RAC_A::B34),
386 35 => Some(RAC_A::B35),
387 36 => Some(RAC_A::B36),
388 37 => Some(RAC_A::B37),
389 38 => Some(RAC_A::B38),
390 39 => Some(RAC_A::B39),
391 40 => Some(RAC_A::B40),
392 41 => Some(RAC_A::B41),
393 42 => Some(RAC_A::B42),
394 43 => Some(RAC_A::B43),
395 44 => Some(RAC_A::B44),
396 45 => Some(RAC_A::B45),
397 46 => Some(RAC_A::B46),
398 47 => Some(RAC_A::B47),
399 48 => Some(RAC_A::B48),
400 49 => Some(RAC_A::B49),
401 50 => Some(RAC_A::B50),
402 51 => Some(RAC_A::B51),
403 52 => Some(RAC_A::B52),
404 53 => Some(RAC_A::B53),
405 54 => Some(RAC_A::B54),
406 55 => Some(RAC_A::B55),
407 56 => Some(RAC_A::B56),
408 57 => Some(RAC_A::B57),
409 58 => Some(RAC_A::B58),
410 59 => Some(RAC_A::B59),
411 60 => Some(RAC_A::B60),
412 61 => Some(RAC_A::B61),
413 62 => Some(RAC_A::B62),
414 63 => Some(RAC_A::B63),
415 64 => Some(RAC_A::B64),
416 _ => None,
417 }
418 }
419 #[doc = "No available data in RX FIFO"]
420 #[inline(always)]
421 pub fn is_b0(&self) -> bool {
422 *self == RAC_A::B0
423 }
424 #[doc = "1 byte available in RX FIFO"]
425 #[inline(always)]
426 pub fn is_b1(&self) -> bool {
427 *self == RAC_A::B1
428 }
429 #[doc = "2 bytes available in RX FIFO"]
430 #[inline(always)]
431 pub fn is_b2(&self) -> bool {
432 *self == RAC_A::B2
433 }
434 #[doc = "3 bytes available in RX FIFO"]
435 #[inline(always)]
436 pub fn is_b3(&self) -> bool {
437 *self == RAC_A::B3
438 }
439 #[doc = "4 bytes available in RX FIFO"]
440 #[inline(always)]
441 pub fn is_b4(&self) -> bool {
442 *self == RAC_A::B4
443 }
444 #[doc = "5 bytes available in RX FIFO"]
445 #[inline(always)]
446 pub fn is_b5(&self) -> bool {
447 *self == RAC_A::B5
448 }
449 #[doc = "6 bytes available in RX FIFO"]
450 #[inline(always)]
451 pub fn is_b6(&self) -> bool {
452 *self == RAC_A::B6
453 }
454 #[doc = "7 bytes available in RX FIFO"]
455 #[inline(always)]
456 pub fn is_b7(&self) -> bool {
457 *self == RAC_A::B7
458 }
459 #[doc = "8 bytes available in RX FIFO"]
460 #[inline(always)]
461 pub fn is_b8(&self) -> bool {
462 *self == RAC_A::B8
463 }
464 #[doc = "9 bytes available in RX FIFO"]
465 #[inline(always)]
466 pub fn is_b9(&self) -> bool {
467 *self == RAC_A::B9
468 }
469 #[doc = "10 bytes available in RX FIFO"]
470 #[inline(always)]
471 pub fn is_b10(&self) -> bool {
472 *self == RAC_A::B10
473 }
474 #[doc = "11 bytes available in RX FIFO"]
475 #[inline(always)]
476 pub fn is_b11(&self) -> bool {
477 *self == RAC_A::B11
478 }
479 #[doc = "12 bytes available in RX FIFO"]
480 #[inline(always)]
481 pub fn is_b12(&self) -> bool {
482 *self == RAC_A::B12
483 }
484 #[doc = "13 bytes available in RX FIFO"]
485 #[inline(always)]
486 pub fn is_b13(&self) -> bool {
487 *self == RAC_A::B13
488 }
489 #[doc = "14 bytes available in RX FIFO"]
490 #[inline(always)]
491 pub fn is_b14(&self) -> bool {
492 *self == RAC_A::B14
493 }
494 #[doc = "15 bytes available in RX FIFO"]
495 #[inline(always)]
496 pub fn is_b15(&self) -> bool {
497 *self == RAC_A::B15
498 }
499 #[doc = "16 bytes available in RX FIFO"]
500 #[inline(always)]
501 pub fn is_b16(&self) -> bool {
502 *self == RAC_A::B16
503 }
504 #[doc = "17 bytes available in RX FIFO"]
505 #[inline(always)]
506 pub fn is_b17(&self) -> bool {
507 *self == RAC_A::B17
508 }
509 #[doc = "18 bytes available in RX FIFO"]
510 #[inline(always)]
511 pub fn is_b18(&self) -> bool {
512 *self == RAC_A::B18
513 }
514 #[doc = "19 bytes available in RX FIFO"]
515 #[inline(always)]
516 pub fn is_b19(&self) -> bool {
517 *self == RAC_A::B19
518 }
519 #[doc = "20 bytes available in RX FIFO"]
520 #[inline(always)]
521 pub fn is_b20(&self) -> bool {
522 *self == RAC_A::B20
523 }
524 #[doc = "21 bytes available in RX FIFO"]
525 #[inline(always)]
526 pub fn is_b21(&self) -> bool {
527 *self == RAC_A::B21
528 }
529 #[doc = "22 bytes available in RX FIFO"]
530 #[inline(always)]
531 pub fn is_b22(&self) -> bool {
532 *self == RAC_A::B22
533 }
534 #[doc = "23 bytes available in RX FIFO"]
535 #[inline(always)]
536 pub fn is_b23(&self) -> bool {
537 *self == RAC_A::B23
538 }
539 #[doc = "24 bytes available in RX FIFO"]
540 #[inline(always)]
541 pub fn is_b24(&self) -> bool {
542 *self == RAC_A::B24
543 }
544 #[doc = "25 bytes available in RX FIFO"]
545 #[inline(always)]
546 pub fn is_b25(&self) -> bool {
547 *self == RAC_A::B25
548 }
549 #[doc = "26 bytes available in RX FIFO"]
550 #[inline(always)]
551 pub fn is_b26(&self) -> bool {
552 *self == RAC_A::B26
553 }
554 #[doc = "27 bytes available in RX FIFO"]
555 #[inline(always)]
556 pub fn is_b27(&self) -> bool {
557 *self == RAC_A::B27
558 }
559 #[doc = "28 bytes available in RX FIFO"]
560 #[inline(always)]
561 pub fn is_b28(&self) -> bool {
562 *self == RAC_A::B28
563 }
564 #[doc = "29 bytes available in RX FIFO"]
565 #[inline(always)]
566 pub fn is_b29(&self) -> bool {
567 *self == RAC_A::B29
568 }
569 #[doc = "30 bytes available in RX FIFO"]
570 #[inline(always)]
571 pub fn is_b30(&self) -> bool {
572 *self == RAC_A::B30
573 }
574 #[doc = "31 bytes available in RX FIFO"]
575 #[inline(always)]
576 pub fn is_b31(&self) -> bool {
577 *self == RAC_A::B31
578 }
579 #[doc = "32 bytes available in RX FIFO"]
580 #[inline(always)]
581 pub fn is_b32(&self) -> bool {
582 *self == RAC_A::B32
583 }
584 #[doc = "33 bytes available in RX FIFO"]
585 #[inline(always)]
586 pub fn is_b33(&self) -> bool {
587 *self == RAC_A::B33
588 }
589 #[doc = "34 bytes available in RX FIFO"]
590 #[inline(always)]
591 pub fn is_b34(&self) -> bool {
592 *self == RAC_A::B34
593 }
594 #[doc = "35 bytes available in RX FIFO"]
595 #[inline(always)]
596 pub fn is_b35(&self) -> bool {
597 *self == RAC_A::B35
598 }
599 #[doc = "36 bytes available in RX FIFO"]
600 #[inline(always)]
601 pub fn is_b36(&self) -> bool {
602 *self == RAC_A::B36
603 }
604 #[doc = "37 bytes available in RX FIFO"]
605 #[inline(always)]
606 pub fn is_b37(&self) -> bool {
607 *self == RAC_A::B37
608 }
609 #[doc = "38 bytes available in RX FIFO"]
610 #[inline(always)]
611 pub fn is_b38(&self) -> bool {
612 *self == RAC_A::B38
613 }
614 #[doc = "39 bytes available in RX FIFO"]
615 #[inline(always)]
616 pub fn is_b39(&self) -> bool {
617 *self == RAC_A::B39
618 }
619 #[doc = "40 bytes available in RX FIFO"]
620 #[inline(always)]
621 pub fn is_b40(&self) -> bool {
622 *self == RAC_A::B40
623 }
624 #[doc = "41 bytes available in RX FIFO"]
625 #[inline(always)]
626 pub fn is_b41(&self) -> bool {
627 *self == RAC_A::B41
628 }
629 #[doc = "42 bytes available in RX FIFO"]
630 #[inline(always)]
631 pub fn is_b42(&self) -> bool {
632 *self == RAC_A::B42
633 }
634 #[doc = "43 bytes available in RX FIFO"]
635 #[inline(always)]
636 pub fn is_b43(&self) -> bool {
637 *self == RAC_A::B43
638 }
639 #[doc = "44 bytes available in RX FIFO"]
640 #[inline(always)]
641 pub fn is_b44(&self) -> bool {
642 *self == RAC_A::B44
643 }
644 #[doc = "45 bytes available in RX FIFO"]
645 #[inline(always)]
646 pub fn is_b45(&self) -> bool {
647 *self == RAC_A::B45
648 }
649 #[doc = "46 bytes available in RX FIFO"]
650 #[inline(always)]
651 pub fn is_b46(&self) -> bool {
652 *self == RAC_A::B46
653 }
654 #[doc = "47 bytes available in RX FIFO"]
655 #[inline(always)]
656 pub fn is_b47(&self) -> bool {
657 *self == RAC_A::B47
658 }
659 #[doc = "48 bytes available in RX FIFO"]
660 #[inline(always)]
661 pub fn is_b48(&self) -> bool {
662 *self == RAC_A::B48
663 }
664 #[doc = "49 bytes available in RX FIFO"]
665 #[inline(always)]
666 pub fn is_b49(&self) -> bool {
667 *self == RAC_A::B49
668 }
669 #[doc = "50 bytes available in RX FIFO"]
670 #[inline(always)]
671 pub fn is_b50(&self) -> bool {
672 *self == RAC_A::B50
673 }
674 #[doc = "51 bytes available in RX FIFO"]
675 #[inline(always)]
676 pub fn is_b51(&self) -> bool {
677 *self == RAC_A::B51
678 }
679 #[doc = "52 bytes available in RX FIFO"]
680 #[inline(always)]
681 pub fn is_b52(&self) -> bool {
682 *self == RAC_A::B52
683 }
684 #[doc = "53 bytes available in RX FIFO"]
685 #[inline(always)]
686 pub fn is_b53(&self) -> bool {
687 *self == RAC_A::B53
688 }
689 #[doc = "54 bytes available in RX FIFO"]
690 #[inline(always)]
691 pub fn is_b54(&self) -> bool {
692 *self == RAC_A::B54
693 }
694 #[doc = "55 bytes available in RX FIFO"]
695 #[inline(always)]
696 pub fn is_b55(&self) -> bool {
697 *self == RAC_A::B55
698 }
699 #[doc = "56 bytes available in RX FIFO"]
700 #[inline(always)]
701 pub fn is_b56(&self) -> bool {
702 *self == RAC_A::B56
703 }
704 #[doc = "57 bytes available in RX FIFO"]
705 #[inline(always)]
706 pub fn is_b57(&self) -> bool {
707 *self == RAC_A::B57
708 }
709 #[doc = "58 bytes available in RX FIFO"]
710 #[inline(always)]
711 pub fn is_b58(&self) -> bool {
712 *self == RAC_A::B58
713 }
714 #[doc = "59 bytes available in RX FIFO"]
715 #[inline(always)]
716 pub fn is_b59(&self) -> bool {
717 *self == RAC_A::B59
718 }
719 #[doc = "60 bytes available in RX FIFO"]
720 #[inline(always)]
721 pub fn is_b60(&self) -> bool {
722 *self == RAC_A::B60
723 }
724 #[doc = "61 bytes available in RX FIFO"]
725 #[inline(always)]
726 pub fn is_b61(&self) -> bool {
727 *self == RAC_A::B61
728 }
729 #[doc = "62 bytes available in RX FIFO"]
730 #[inline(always)]
731 pub fn is_b62(&self) -> bool {
732 *self == RAC_A::B62
733 }
734 #[doc = "63 bytes available in RX FIFO"]
735 #[inline(always)]
736 pub fn is_b63(&self) -> bool {
737 *self == RAC_A::B63
738 }
739 #[doc = "64 bytes available in RX FIFO"]
740 #[inline(always)]
741 pub fn is_b64(&self) -> bool {
742 *self == RAC_A::B64
743 }
744}
745impl R {
746 #[doc = "Bit 0 - Receiver FIFO Overrun"]
747 #[inline(always)]
748 pub fn roi(&self) -> ROI_R {
749 ROI_R::new((self.bits & 1) != 0)
750 }
751 #[doc = "Bit 1 - Receiver Packet End Flag"]
752 #[inline(always)]
753 pub fn rpe(&self) -> RPE_R {
754 RPE_R::new(((self.bits >> 1) & 1) != 0)
755 }
756 #[doc = "Bit 4 - RX FIFO Available"]
757 #[inline(always)]
758 pub fn ra(&self) -> RA_R {
759 RA_R::new(((self.bits >> 4) & 1) != 0)
760 }
761 #[doc = "Bit 7 - Status of CIR"]
762 #[inline(always)]
763 pub fn stat(&self) -> STAT_R {
764 STAT_R::new(((self.bits >> 7) & 1) != 0)
765 }
766 #[doc = "Bits 8:14 - RX FIFO Available Counter"]
767 #[inline(always)]
768 pub fn rac(&self) -> RAC_R {
769 RAC_R::new(((self.bits >> 8) & 0x7f) as u8)
770 }
771}
772impl W {
773 #[doc = "Bit 0 - Receiver FIFO Overrun"]
774 #[inline(always)]
775 #[must_use]
776 pub fn roi(&mut self) -> ROI_W<CIR_RXSTA_SPEC> {
777 ROI_W::new(self, 0)
778 }
779 #[doc = "Bit 1 - Receiver Packet End Flag"]
780 #[inline(always)]
781 #[must_use]
782 pub fn rpe(&mut self) -> RPE_W<CIR_RXSTA_SPEC> {
783 RPE_W::new(self, 1)
784 }
785 #[doc = "Bit 4 - RX FIFO Available"]
786 #[inline(always)]
787 #[must_use]
788 pub fn ra(&mut self) -> RA_W<CIR_RXSTA_SPEC> {
789 RA_W::new(self, 4)
790 }
791 #[doc = r" Writes raw bits to the register."]
792 #[doc = r""]
793 #[doc = r" # Safety"]
794 #[doc = r""]
795 #[doc = r" Passing incorrect value can cause undefined behaviour. See reference manual"]
796 #[inline(always)]
797 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
798 self.bits = bits;
799 self
800 }
801}
802#[doc = "CIR Receiver Status Register\n\nYou can [`read`](crate::generic::Reg::read) this register and get [`cir_rxsta::R`](R). You can [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`write_with_zero`](crate::generic::Reg::write_with_zero) this register using [`cir_rxsta::W`](W). You can also [`modify`](crate::generic::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
803pub struct CIR_RXSTA_SPEC;
804impl crate::RegisterSpec for CIR_RXSTA_SPEC {
805 type Ux = u32;
806}
807#[doc = "`read()` method returns [`cir_rxsta::R`](R) reader structure"]
808impl crate::Readable for CIR_RXSTA_SPEC {}
809#[doc = "`write(|w| ..)` method takes [`cir_rxsta::W`](W) writer structure"]
810impl crate::Writable for CIR_RXSTA_SPEC {
811 const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
812 const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0x13;
813}
814#[doc = "`reset()` method sets cir_rxsta to value 0"]
815impl crate::Resettable for CIR_RXSTA_SPEC {
816 const RESET_VALUE: Self::Ux = 0;
817}