1#[doc = "Register `INTPEND` reader"]
2pub struct R(crate::R<INTPEND_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<INTPEND_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<INTPEND_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<INTPEND_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Field `RECEIVE0` reader - Read pending status of interrupt for event RECEIVE\\[0\\]"]
17pub type RECEIVE0_R = crate::BitReader<RECEIVE0_A>;
18#[doc = "Read pending status of interrupt for event RECEIVE\\[0\\]\n\nValue on reset: 0"]
19#[derive(Clone, Copy, Debug, PartialEq)]
20pub enum RECEIVE0_A {
21 #[doc = "0: Read: Not pending"]
22 NOT_PENDING = 0,
23 #[doc = "1: Read: Pending"]
24 PENDING = 1,
25}
26impl From<RECEIVE0_A> for bool {
27 #[inline(always)]
28 fn from(variant: RECEIVE0_A) -> Self {
29 variant as u8 != 0
30 }
31}
32impl RECEIVE0_R {
33 #[doc = "Get enumerated values variant"]
34 #[inline(always)]
35 pub fn variant(&self) -> RECEIVE0_A {
36 match self.bits {
37 false => RECEIVE0_A::NOT_PENDING,
38 true => RECEIVE0_A::PENDING,
39 }
40 }
41 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
42 #[inline(always)]
43 pub fn is_not_pending(&self) -> bool {
44 *self == RECEIVE0_A::NOT_PENDING
45 }
46 #[doc = "Checks if the value of the field is `PENDING`"]
47 #[inline(always)]
48 pub fn is_pending(&self) -> bool {
49 *self == RECEIVE0_A::PENDING
50 }
51}
52#[doc = "Field `RECEIVE1` reader - Read pending status of interrupt for event RECEIVE\\[1\\]"]
53pub type RECEIVE1_R = crate::BitReader<RECEIVE1_A>;
54#[doc = "Read pending status of interrupt for event RECEIVE\\[1\\]\n\nValue on reset: 0"]
55#[derive(Clone, Copy, Debug, PartialEq)]
56pub enum RECEIVE1_A {
57 #[doc = "0: Read: Not pending"]
58 NOT_PENDING = 0,
59 #[doc = "1: Read: Pending"]
60 PENDING = 1,
61}
62impl From<RECEIVE1_A> for bool {
63 #[inline(always)]
64 fn from(variant: RECEIVE1_A) -> Self {
65 variant as u8 != 0
66 }
67}
68impl RECEIVE1_R {
69 #[doc = "Get enumerated values variant"]
70 #[inline(always)]
71 pub fn variant(&self) -> RECEIVE1_A {
72 match self.bits {
73 false => RECEIVE1_A::NOT_PENDING,
74 true => RECEIVE1_A::PENDING,
75 }
76 }
77 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
78 #[inline(always)]
79 pub fn is_not_pending(&self) -> bool {
80 *self == RECEIVE1_A::NOT_PENDING
81 }
82 #[doc = "Checks if the value of the field is `PENDING`"]
83 #[inline(always)]
84 pub fn is_pending(&self) -> bool {
85 *self == RECEIVE1_A::PENDING
86 }
87}
88#[doc = "Field `RECEIVE2` reader - Read pending status of interrupt for event RECEIVE\\[2\\]"]
89pub type RECEIVE2_R = crate::BitReader<RECEIVE2_A>;
90#[doc = "Read pending status of interrupt for event RECEIVE\\[2\\]\n\nValue on reset: 0"]
91#[derive(Clone, Copy, Debug, PartialEq)]
92pub enum RECEIVE2_A {
93 #[doc = "0: Read: Not pending"]
94 NOT_PENDING = 0,
95 #[doc = "1: Read: Pending"]
96 PENDING = 1,
97}
98impl From<RECEIVE2_A> for bool {
99 #[inline(always)]
100 fn from(variant: RECEIVE2_A) -> Self {
101 variant as u8 != 0
102 }
103}
104impl RECEIVE2_R {
105 #[doc = "Get enumerated values variant"]
106 #[inline(always)]
107 pub fn variant(&self) -> RECEIVE2_A {
108 match self.bits {
109 false => RECEIVE2_A::NOT_PENDING,
110 true => RECEIVE2_A::PENDING,
111 }
112 }
113 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
114 #[inline(always)]
115 pub fn is_not_pending(&self) -> bool {
116 *self == RECEIVE2_A::NOT_PENDING
117 }
118 #[doc = "Checks if the value of the field is `PENDING`"]
119 #[inline(always)]
120 pub fn is_pending(&self) -> bool {
121 *self == RECEIVE2_A::PENDING
122 }
123}
124#[doc = "Field `RECEIVE3` reader - Read pending status of interrupt for event RECEIVE\\[3\\]"]
125pub type RECEIVE3_R = crate::BitReader<RECEIVE3_A>;
126#[doc = "Read pending status of interrupt for event RECEIVE\\[3\\]\n\nValue on reset: 0"]
127#[derive(Clone, Copy, Debug, PartialEq)]
128pub enum RECEIVE3_A {
129 #[doc = "0: Read: Not pending"]
130 NOT_PENDING = 0,
131 #[doc = "1: Read: Pending"]
132 PENDING = 1,
133}
134impl From<RECEIVE3_A> for bool {
135 #[inline(always)]
136 fn from(variant: RECEIVE3_A) -> Self {
137 variant as u8 != 0
138 }
139}
140impl RECEIVE3_R {
141 #[doc = "Get enumerated values variant"]
142 #[inline(always)]
143 pub fn variant(&self) -> RECEIVE3_A {
144 match self.bits {
145 false => RECEIVE3_A::NOT_PENDING,
146 true => RECEIVE3_A::PENDING,
147 }
148 }
149 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
150 #[inline(always)]
151 pub fn is_not_pending(&self) -> bool {
152 *self == RECEIVE3_A::NOT_PENDING
153 }
154 #[doc = "Checks if the value of the field is `PENDING`"]
155 #[inline(always)]
156 pub fn is_pending(&self) -> bool {
157 *self == RECEIVE3_A::PENDING
158 }
159}
160#[doc = "Field `RECEIVE4` reader - Read pending status of interrupt for event RECEIVE\\[4\\]"]
161pub type RECEIVE4_R = crate::BitReader<RECEIVE4_A>;
162#[doc = "Read pending status of interrupt for event RECEIVE\\[4\\]\n\nValue on reset: 0"]
163#[derive(Clone, Copy, Debug, PartialEq)]
164pub enum RECEIVE4_A {
165 #[doc = "0: Read: Not pending"]
166 NOT_PENDING = 0,
167 #[doc = "1: Read: Pending"]
168 PENDING = 1,
169}
170impl From<RECEIVE4_A> for bool {
171 #[inline(always)]
172 fn from(variant: RECEIVE4_A) -> Self {
173 variant as u8 != 0
174 }
175}
176impl RECEIVE4_R {
177 #[doc = "Get enumerated values variant"]
178 #[inline(always)]
179 pub fn variant(&self) -> RECEIVE4_A {
180 match self.bits {
181 false => RECEIVE4_A::NOT_PENDING,
182 true => RECEIVE4_A::PENDING,
183 }
184 }
185 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
186 #[inline(always)]
187 pub fn is_not_pending(&self) -> bool {
188 *self == RECEIVE4_A::NOT_PENDING
189 }
190 #[doc = "Checks if the value of the field is `PENDING`"]
191 #[inline(always)]
192 pub fn is_pending(&self) -> bool {
193 *self == RECEIVE4_A::PENDING
194 }
195}
196#[doc = "Field `RECEIVE5` reader - Read pending status of interrupt for event RECEIVE\\[5\\]"]
197pub type RECEIVE5_R = crate::BitReader<RECEIVE5_A>;
198#[doc = "Read pending status of interrupt for event RECEIVE\\[5\\]\n\nValue on reset: 0"]
199#[derive(Clone, Copy, Debug, PartialEq)]
200pub enum RECEIVE5_A {
201 #[doc = "0: Read: Not pending"]
202 NOT_PENDING = 0,
203 #[doc = "1: Read: Pending"]
204 PENDING = 1,
205}
206impl From<RECEIVE5_A> for bool {
207 #[inline(always)]
208 fn from(variant: RECEIVE5_A) -> Self {
209 variant as u8 != 0
210 }
211}
212impl RECEIVE5_R {
213 #[doc = "Get enumerated values variant"]
214 #[inline(always)]
215 pub fn variant(&self) -> RECEIVE5_A {
216 match self.bits {
217 false => RECEIVE5_A::NOT_PENDING,
218 true => RECEIVE5_A::PENDING,
219 }
220 }
221 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
222 #[inline(always)]
223 pub fn is_not_pending(&self) -> bool {
224 *self == RECEIVE5_A::NOT_PENDING
225 }
226 #[doc = "Checks if the value of the field is `PENDING`"]
227 #[inline(always)]
228 pub fn is_pending(&self) -> bool {
229 *self == RECEIVE5_A::PENDING
230 }
231}
232#[doc = "Field `RECEIVE6` reader - Read pending status of interrupt for event RECEIVE\\[6\\]"]
233pub type RECEIVE6_R = crate::BitReader<RECEIVE6_A>;
234#[doc = "Read pending status of interrupt for event RECEIVE\\[6\\]\n\nValue on reset: 0"]
235#[derive(Clone, Copy, Debug, PartialEq)]
236pub enum RECEIVE6_A {
237 #[doc = "0: Read: Not pending"]
238 NOT_PENDING = 0,
239 #[doc = "1: Read: Pending"]
240 PENDING = 1,
241}
242impl From<RECEIVE6_A> for bool {
243 #[inline(always)]
244 fn from(variant: RECEIVE6_A) -> Self {
245 variant as u8 != 0
246 }
247}
248impl RECEIVE6_R {
249 #[doc = "Get enumerated values variant"]
250 #[inline(always)]
251 pub fn variant(&self) -> RECEIVE6_A {
252 match self.bits {
253 false => RECEIVE6_A::NOT_PENDING,
254 true => RECEIVE6_A::PENDING,
255 }
256 }
257 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
258 #[inline(always)]
259 pub fn is_not_pending(&self) -> bool {
260 *self == RECEIVE6_A::NOT_PENDING
261 }
262 #[doc = "Checks if the value of the field is `PENDING`"]
263 #[inline(always)]
264 pub fn is_pending(&self) -> bool {
265 *self == RECEIVE6_A::PENDING
266 }
267}
268#[doc = "Field `RECEIVE7` reader - Read pending status of interrupt for event RECEIVE\\[7\\]"]
269pub type RECEIVE7_R = crate::BitReader<RECEIVE7_A>;
270#[doc = "Read pending status of interrupt for event RECEIVE\\[7\\]\n\nValue on reset: 0"]
271#[derive(Clone, Copy, Debug, PartialEq)]
272pub enum RECEIVE7_A {
273 #[doc = "0: Read: Not pending"]
274 NOT_PENDING = 0,
275 #[doc = "1: Read: Pending"]
276 PENDING = 1,
277}
278impl From<RECEIVE7_A> for bool {
279 #[inline(always)]
280 fn from(variant: RECEIVE7_A) -> Self {
281 variant as u8 != 0
282 }
283}
284impl RECEIVE7_R {
285 #[doc = "Get enumerated values variant"]
286 #[inline(always)]
287 pub fn variant(&self) -> RECEIVE7_A {
288 match self.bits {
289 false => RECEIVE7_A::NOT_PENDING,
290 true => RECEIVE7_A::PENDING,
291 }
292 }
293 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
294 #[inline(always)]
295 pub fn is_not_pending(&self) -> bool {
296 *self == RECEIVE7_A::NOT_PENDING
297 }
298 #[doc = "Checks if the value of the field is `PENDING`"]
299 #[inline(always)]
300 pub fn is_pending(&self) -> bool {
301 *self == RECEIVE7_A::PENDING
302 }
303}
304#[doc = "Field `RECEIVE8` reader - Read pending status of interrupt for event RECEIVE\\[8\\]"]
305pub type RECEIVE8_R = crate::BitReader<RECEIVE8_A>;
306#[doc = "Read pending status of interrupt for event RECEIVE\\[8\\]\n\nValue on reset: 0"]
307#[derive(Clone, Copy, Debug, PartialEq)]
308pub enum RECEIVE8_A {
309 #[doc = "0: Read: Not pending"]
310 NOT_PENDING = 0,
311 #[doc = "1: Read: Pending"]
312 PENDING = 1,
313}
314impl From<RECEIVE8_A> for bool {
315 #[inline(always)]
316 fn from(variant: RECEIVE8_A) -> Self {
317 variant as u8 != 0
318 }
319}
320impl RECEIVE8_R {
321 #[doc = "Get enumerated values variant"]
322 #[inline(always)]
323 pub fn variant(&self) -> RECEIVE8_A {
324 match self.bits {
325 false => RECEIVE8_A::NOT_PENDING,
326 true => RECEIVE8_A::PENDING,
327 }
328 }
329 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
330 #[inline(always)]
331 pub fn is_not_pending(&self) -> bool {
332 *self == RECEIVE8_A::NOT_PENDING
333 }
334 #[doc = "Checks if the value of the field is `PENDING`"]
335 #[inline(always)]
336 pub fn is_pending(&self) -> bool {
337 *self == RECEIVE8_A::PENDING
338 }
339}
340#[doc = "Field `RECEIVE9` reader - Read pending status of interrupt for event RECEIVE\\[9\\]"]
341pub type RECEIVE9_R = crate::BitReader<RECEIVE9_A>;
342#[doc = "Read pending status of interrupt for event RECEIVE\\[9\\]\n\nValue on reset: 0"]
343#[derive(Clone, Copy, Debug, PartialEq)]
344pub enum RECEIVE9_A {
345 #[doc = "0: Read: Not pending"]
346 NOT_PENDING = 0,
347 #[doc = "1: Read: Pending"]
348 PENDING = 1,
349}
350impl From<RECEIVE9_A> for bool {
351 #[inline(always)]
352 fn from(variant: RECEIVE9_A) -> Self {
353 variant as u8 != 0
354 }
355}
356impl RECEIVE9_R {
357 #[doc = "Get enumerated values variant"]
358 #[inline(always)]
359 pub fn variant(&self) -> RECEIVE9_A {
360 match self.bits {
361 false => RECEIVE9_A::NOT_PENDING,
362 true => RECEIVE9_A::PENDING,
363 }
364 }
365 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
366 #[inline(always)]
367 pub fn is_not_pending(&self) -> bool {
368 *self == RECEIVE9_A::NOT_PENDING
369 }
370 #[doc = "Checks if the value of the field is `PENDING`"]
371 #[inline(always)]
372 pub fn is_pending(&self) -> bool {
373 *self == RECEIVE9_A::PENDING
374 }
375}
376#[doc = "Field `RECEIVE10` reader - Read pending status of interrupt for event RECEIVE\\[10\\]"]
377pub type RECEIVE10_R = crate::BitReader<RECEIVE10_A>;
378#[doc = "Read pending status of interrupt for event RECEIVE\\[10\\]\n\nValue on reset: 0"]
379#[derive(Clone, Copy, Debug, PartialEq)]
380pub enum RECEIVE10_A {
381 #[doc = "0: Read: Not pending"]
382 NOT_PENDING = 0,
383 #[doc = "1: Read: Pending"]
384 PENDING = 1,
385}
386impl From<RECEIVE10_A> for bool {
387 #[inline(always)]
388 fn from(variant: RECEIVE10_A) -> Self {
389 variant as u8 != 0
390 }
391}
392impl RECEIVE10_R {
393 #[doc = "Get enumerated values variant"]
394 #[inline(always)]
395 pub fn variant(&self) -> RECEIVE10_A {
396 match self.bits {
397 false => RECEIVE10_A::NOT_PENDING,
398 true => RECEIVE10_A::PENDING,
399 }
400 }
401 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
402 #[inline(always)]
403 pub fn is_not_pending(&self) -> bool {
404 *self == RECEIVE10_A::NOT_PENDING
405 }
406 #[doc = "Checks if the value of the field is `PENDING`"]
407 #[inline(always)]
408 pub fn is_pending(&self) -> bool {
409 *self == RECEIVE10_A::PENDING
410 }
411}
412#[doc = "Field `RECEIVE11` reader - Read pending status of interrupt for event RECEIVE\\[11\\]"]
413pub type RECEIVE11_R = crate::BitReader<RECEIVE11_A>;
414#[doc = "Read pending status of interrupt for event RECEIVE\\[11\\]\n\nValue on reset: 0"]
415#[derive(Clone, Copy, Debug, PartialEq)]
416pub enum RECEIVE11_A {
417 #[doc = "0: Read: Not pending"]
418 NOT_PENDING = 0,
419 #[doc = "1: Read: Pending"]
420 PENDING = 1,
421}
422impl From<RECEIVE11_A> for bool {
423 #[inline(always)]
424 fn from(variant: RECEIVE11_A) -> Self {
425 variant as u8 != 0
426 }
427}
428impl RECEIVE11_R {
429 #[doc = "Get enumerated values variant"]
430 #[inline(always)]
431 pub fn variant(&self) -> RECEIVE11_A {
432 match self.bits {
433 false => RECEIVE11_A::NOT_PENDING,
434 true => RECEIVE11_A::PENDING,
435 }
436 }
437 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
438 #[inline(always)]
439 pub fn is_not_pending(&self) -> bool {
440 *self == RECEIVE11_A::NOT_PENDING
441 }
442 #[doc = "Checks if the value of the field is `PENDING`"]
443 #[inline(always)]
444 pub fn is_pending(&self) -> bool {
445 *self == RECEIVE11_A::PENDING
446 }
447}
448#[doc = "Field `RECEIVE12` reader - Read pending status of interrupt for event RECEIVE\\[12\\]"]
449pub type RECEIVE12_R = crate::BitReader<RECEIVE12_A>;
450#[doc = "Read pending status of interrupt for event RECEIVE\\[12\\]\n\nValue on reset: 0"]
451#[derive(Clone, Copy, Debug, PartialEq)]
452pub enum RECEIVE12_A {
453 #[doc = "0: Read: Not pending"]
454 NOT_PENDING = 0,
455 #[doc = "1: Read: Pending"]
456 PENDING = 1,
457}
458impl From<RECEIVE12_A> for bool {
459 #[inline(always)]
460 fn from(variant: RECEIVE12_A) -> Self {
461 variant as u8 != 0
462 }
463}
464impl RECEIVE12_R {
465 #[doc = "Get enumerated values variant"]
466 #[inline(always)]
467 pub fn variant(&self) -> RECEIVE12_A {
468 match self.bits {
469 false => RECEIVE12_A::NOT_PENDING,
470 true => RECEIVE12_A::PENDING,
471 }
472 }
473 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
474 #[inline(always)]
475 pub fn is_not_pending(&self) -> bool {
476 *self == RECEIVE12_A::NOT_PENDING
477 }
478 #[doc = "Checks if the value of the field is `PENDING`"]
479 #[inline(always)]
480 pub fn is_pending(&self) -> bool {
481 *self == RECEIVE12_A::PENDING
482 }
483}
484#[doc = "Field `RECEIVE13` reader - Read pending status of interrupt for event RECEIVE\\[13\\]"]
485pub type RECEIVE13_R = crate::BitReader<RECEIVE13_A>;
486#[doc = "Read pending status of interrupt for event RECEIVE\\[13\\]\n\nValue on reset: 0"]
487#[derive(Clone, Copy, Debug, PartialEq)]
488pub enum RECEIVE13_A {
489 #[doc = "0: Read: Not pending"]
490 NOT_PENDING = 0,
491 #[doc = "1: Read: Pending"]
492 PENDING = 1,
493}
494impl From<RECEIVE13_A> for bool {
495 #[inline(always)]
496 fn from(variant: RECEIVE13_A) -> Self {
497 variant as u8 != 0
498 }
499}
500impl RECEIVE13_R {
501 #[doc = "Get enumerated values variant"]
502 #[inline(always)]
503 pub fn variant(&self) -> RECEIVE13_A {
504 match self.bits {
505 false => RECEIVE13_A::NOT_PENDING,
506 true => RECEIVE13_A::PENDING,
507 }
508 }
509 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
510 #[inline(always)]
511 pub fn is_not_pending(&self) -> bool {
512 *self == RECEIVE13_A::NOT_PENDING
513 }
514 #[doc = "Checks if the value of the field is `PENDING`"]
515 #[inline(always)]
516 pub fn is_pending(&self) -> bool {
517 *self == RECEIVE13_A::PENDING
518 }
519}
520#[doc = "Field `RECEIVE14` reader - Read pending status of interrupt for event RECEIVE\\[14\\]"]
521pub type RECEIVE14_R = crate::BitReader<RECEIVE14_A>;
522#[doc = "Read pending status of interrupt for event RECEIVE\\[14\\]\n\nValue on reset: 0"]
523#[derive(Clone, Copy, Debug, PartialEq)]
524pub enum RECEIVE14_A {
525 #[doc = "0: Read: Not pending"]
526 NOT_PENDING = 0,
527 #[doc = "1: Read: Pending"]
528 PENDING = 1,
529}
530impl From<RECEIVE14_A> for bool {
531 #[inline(always)]
532 fn from(variant: RECEIVE14_A) -> Self {
533 variant as u8 != 0
534 }
535}
536impl RECEIVE14_R {
537 #[doc = "Get enumerated values variant"]
538 #[inline(always)]
539 pub fn variant(&self) -> RECEIVE14_A {
540 match self.bits {
541 false => RECEIVE14_A::NOT_PENDING,
542 true => RECEIVE14_A::PENDING,
543 }
544 }
545 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
546 #[inline(always)]
547 pub fn is_not_pending(&self) -> bool {
548 *self == RECEIVE14_A::NOT_PENDING
549 }
550 #[doc = "Checks if the value of the field is `PENDING`"]
551 #[inline(always)]
552 pub fn is_pending(&self) -> bool {
553 *self == RECEIVE14_A::PENDING
554 }
555}
556#[doc = "Field `RECEIVE15` reader - Read pending status of interrupt for event RECEIVE\\[15\\]"]
557pub type RECEIVE15_R = crate::BitReader<RECEIVE15_A>;
558#[doc = "Read pending status of interrupt for event RECEIVE\\[15\\]\n\nValue on reset: 0"]
559#[derive(Clone, Copy, Debug, PartialEq)]
560pub enum RECEIVE15_A {
561 #[doc = "0: Read: Not pending"]
562 NOT_PENDING = 0,
563 #[doc = "1: Read: Pending"]
564 PENDING = 1,
565}
566impl From<RECEIVE15_A> for bool {
567 #[inline(always)]
568 fn from(variant: RECEIVE15_A) -> Self {
569 variant as u8 != 0
570 }
571}
572impl RECEIVE15_R {
573 #[doc = "Get enumerated values variant"]
574 #[inline(always)]
575 pub fn variant(&self) -> RECEIVE15_A {
576 match self.bits {
577 false => RECEIVE15_A::NOT_PENDING,
578 true => RECEIVE15_A::PENDING,
579 }
580 }
581 #[doc = "Checks if the value of the field is `NOT_PENDING`"]
582 #[inline(always)]
583 pub fn is_not_pending(&self) -> bool {
584 *self == RECEIVE15_A::NOT_PENDING
585 }
586 #[doc = "Checks if the value of the field is `PENDING`"]
587 #[inline(always)]
588 pub fn is_pending(&self) -> bool {
589 *self == RECEIVE15_A::PENDING
590 }
591}
592impl R {
593 #[doc = "Bit 0 - Read pending status of interrupt for event RECEIVE\\[0\\]"]
594 #[inline(always)]
595 pub fn receive0(&self) -> RECEIVE0_R {
596 RECEIVE0_R::new((self.bits & 1) != 0)
597 }
598 #[doc = "Bit 1 - Read pending status of interrupt for event RECEIVE\\[1\\]"]
599 #[inline(always)]
600 pub fn receive1(&self) -> RECEIVE1_R {
601 RECEIVE1_R::new(((self.bits >> 1) & 1) != 0)
602 }
603 #[doc = "Bit 2 - Read pending status of interrupt for event RECEIVE\\[2\\]"]
604 #[inline(always)]
605 pub fn receive2(&self) -> RECEIVE2_R {
606 RECEIVE2_R::new(((self.bits >> 2) & 1) != 0)
607 }
608 #[doc = "Bit 3 - Read pending status of interrupt for event RECEIVE\\[3\\]"]
609 #[inline(always)]
610 pub fn receive3(&self) -> RECEIVE3_R {
611 RECEIVE3_R::new(((self.bits >> 3) & 1) != 0)
612 }
613 #[doc = "Bit 4 - Read pending status of interrupt for event RECEIVE\\[4\\]"]
614 #[inline(always)]
615 pub fn receive4(&self) -> RECEIVE4_R {
616 RECEIVE4_R::new(((self.bits >> 4) & 1) != 0)
617 }
618 #[doc = "Bit 5 - Read pending status of interrupt for event RECEIVE\\[5\\]"]
619 #[inline(always)]
620 pub fn receive5(&self) -> RECEIVE5_R {
621 RECEIVE5_R::new(((self.bits >> 5) & 1) != 0)
622 }
623 #[doc = "Bit 6 - Read pending status of interrupt for event RECEIVE\\[6\\]"]
624 #[inline(always)]
625 pub fn receive6(&self) -> RECEIVE6_R {
626 RECEIVE6_R::new(((self.bits >> 6) & 1) != 0)
627 }
628 #[doc = "Bit 7 - Read pending status of interrupt for event RECEIVE\\[7\\]"]
629 #[inline(always)]
630 pub fn receive7(&self) -> RECEIVE7_R {
631 RECEIVE7_R::new(((self.bits >> 7) & 1) != 0)
632 }
633 #[doc = "Bit 8 - Read pending status of interrupt for event RECEIVE\\[8\\]"]
634 #[inline(always)]
635 pub fn receive8(&self) -> RECEIVE8_R {
636 RECEIVE8_R::new(((self.bits >> 8) & 1) != 0)
637 }
638 #[doc = "Bit 9 - Read pending status of interrupt for event RECEIVE\\[9\\]"]
639 #[inline(always)]
640 pub fn receive9(&self) -> RECEIVE9_R {
641 RECEIVE9_R::new(((self.bits >> 9) & 1) != 0)
642 }
643 #[doc = "Bit 10 - Read pending status of interrupt for event RECEIVE\\[10\\]"]
644 #[inline(always)]
645 pub fn receive10(&self) -> RECEIVE10_R {
646 RECEIVE10_R::new(((self.bits >> 10) & 1) != 0)
647 }
648 #[doc = "Bit 11 - Read pending status of interrupt for event RECEIVE\\[11\\]"]
649 #[inline(always)]
650 pub fn receive11(&self) -> RECEIVE11_R {
651 RECEIVE11_R::new(((self.bits >> 11) & 1) != 0)
652 }
653 #[doc = "Bit 12 - Read pending status of interrupt for event RECEIVE\\[12\\]"]
654 #[inline(always)]
655 pub fn receive12(&self) -> RECEIVE12_R {
656 RECEIVE12_R::new(((self.bits >> 12) & 1) != 0)
657 }
658 #[doc = "Bit 13 - Read pending status of interrupt for event RECEIVE\\[13\\]"]
659 #[inline(always)]
660 pub fn receive13(&self) -> RECEIVE13_R {
661 RECEIVE13_R::new(((self.bits >> 13) & 1) != 0)
662 }
663 #[doc = "Bit 14 - Read pending status of interrupt for event RECEIVE\\[14\\]"]
664 #[inline(always)]
665 pub fn receive14(&self) -> RECEIVE14_R {
666 RECEIVE14_R::new(((self.bits >> 14) & 1) != 0)
667 }
668 #[doc = "Bit 15 - Read pending status of interrupt for event RECEIVE\\[15\\]"]
669 #[inline(always)]
670 pub fn receive15(&self) -> RECEIVE15_R {
671 RECEIVE15_R::new(((self.bits >> 15) & 1) != 0)
672 }
673}
674#[doc = "Pending interrupts\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [intpend](index.html) module"]
675pub struct INTPEND_SPEC;
676impl crate::RegisterSpec for INTPEND_SPEC {
677 type Ux = u32;
678}
679#[doc = "`read()` method returns [intpend::R](R) reader structure"]
680impl crate::Readable for INTPEND_SPEC {
681 type Reader = R;
682}
683#[doc = "`reset()` method sets INTPEND to value 0"]
684impl crate::Resettable for INTPEND_SPEC {
685 #[inline(always)]
686 fn reset_value() -> Self::Ux {
687 0
688 }
689}