1#[doc = r" Value read from the register"]
2pub struct R {
3 bits: u32,
4}
5impl super::INTPEND {
6 #[doc = r" Reads the contents of the register"]
7 #[inline]
8 pub fn read(&self) -> R {
9 R {
10 bits: self.register.get(),
11 }
12 }
13}
14#[doc = "Possible values of the field `RECEIVE0`"]
15#[derive(Clone, Copy, Debug, PartialEq)]
16pub enum RECEIVE0R {
17 #[doc = "Read: Not pending"]
18 NOTPENDING,
19 #[doc = "Read: Pending"]
20 PENDING,
21}
22impl RECEIVE0R {
23 #[doc = r" Returns `true` if the bit is clear (0)"]
24 #[inline]
25 pub fn bit_is_clear(&self) -> bool {
26 !self.bit()
27 }
28 #[doc = r" Returns `true` if the bit is set (1)"]
29 #[inline]
30 pub fn bit_is_set(&self) -> bool {
31 self.bit()
32 }
33 #[doc = r" Value of the field as raw bits"]
34 #[inline]
35 pub fn bit(&self) -> bool {
36 match *self {
37 RECEIVE0R::NOTPENDING => false,
38 RECEIVE0R::PENDING => true,
39 }
40 }
41 #[allow(missing_docs)]
42 #[doc(hidden)]
43 #[inline]
44 pub fn _from(value: bool) -> RECEIVE0R {
45 match value {
46 false => RECEIVE0R::NOTPENDING,
47 true => RECEIVE0R::PENDING,
48 }
49 }
50 #[doc = "Checks if the value of the field is `NOTPENDING`"]
51 #[inline]
52 pub fn is_not_pending(&self) -> bool {
53 *self == RECEIVE0R::NOTPENDING
54 }
55 #[doc = "Checks if the value of the field is `PENDING`"]
56 #[inline]
57 pub fn is_pending(&self) -> bool {
58 *self == RECEIVE0R::PENDING
59 }
60}
61#[doc = "Possible values of the field `RECEIVE1`"]
62#[derive(Clone, Copy, Debug, PartialEq)]
63pub enum RECEIVE1R {
64 #[doc = "Read: Not pending"]
65 NOTPENDING,
66 #[doc = "Read: Pending"]
67 PENDING,
68}
69impl RECEIVE1R {
70 #[doc = r" Returns `true` if the bit is clear (0)"]
71 #[inline]
72 pub fn bit_is_clear(&self) -> bool {
73 !self.bit()
74 }
75 #[doc = r" Returns `true` if the bit is set (1)"]
76 #[inline]
77 pub fn bit_is_set(&self) -> bool {
78 self.bit()
79 }
80 #[doc = r" Value of the field as raw bits"]
81 #[inline]
82 pub fn bit(&self) -> bool {
83 match *self {
84 RECEIVE1R::NOTPENDING => false,
85 RECEIVE1R::PENDING => true,
86 }
87 }
88 #[allow(missing_docs)]
89 #[doc(hidden)]
90 #[inline]
91 pub fn _from(value: bool) -> RECEIVE1R {
92 match value {
93 false => RECEIVE1R::NOTPENDING,
94 true => RECEIVE1R::PENDING,
95 }
96 }
97 #[doc = "Checks if the value of the field is `NOTPENDING`"]
98 #[inline]
99 pub fn is_not_pending(&self) -> bool {
100 *self == RECEIVE1R::NOTPENDING
101 }
102 #[doc = "Checks if the value of the field is `PENDING`"]
103 #[inline]
104 pub fn is_pending(&self) -> bool {
105 *self == RECEIVE1R::PENDING
106 }
107}
108#[doc = "Possible values of the field `RECEIVE2`"]
109#[derive(Clone, Copy, Debug, PartialEq)]
110pub enum RECEIVE2R {
111 #[doc = "Read: Not pending"]
112 NOTPENDING,
113 #[doc = "Read: Pending"]
114 PENDING,
115}
116impl RECEIVE2R {
117 #[doc = r" Returns `true` if the bit is clear (0)"]
118 #[inline]
119 pub fn bit_is_clear(&self) -> bool {
120 !self.bit()
121 }
122 #[doc = r" Returns `true` if the bit is set (1)"]
123 #[inline]
124 pub fn bit_is_set(&self) -> bool {
125 self.bit()
126 }
127 #[doc = r" Value of the field as raw bits"]
128 #[inline]
129 pub fn bit(&self) -> bool {
130 match *self {
131 RECEIVE2R::NOTPENDING => false,
132 RECEIVE2R::PENDING => true,
133 }
134 }
135 #[allow(missing_docs)]
136 #[doc(hidden)]
137 #[inline]
138 pub fn _from(value: bool) -> RECEIVE2R {
139 match value {
140 false => RECEIVE2R::NOTPENDING,
141 true => RECEIVE2R::PENDING,
142 }
143 }
144 #[doc = "Checks if the value of the field is `NOTPENDING`"]
145 #[inline]
146 pub fn is_not_pending(&self) -> bool {
147 *self == RECEIVE2R::NOTPENDING
148 }
149 #[doc = "Checks if the value of the field is `PENDING`"]
150 #[inline]
151 pub fn is_pending(&self) -> bool {
152 *self == RECEIVE2R::PENDING
153 }
154}
155#[doc = "Possible values of the field `RECEIVE3`"]
156#[derive(Clone, Copy, Debug, PartialEq)]
157pub enum RECEIVE3R {
158 #[doc = "Read: Not pending"]
159 NOTPENDING,
160 #[doc = "Read: Pending"]
161 PENDING,
162}
163impl RECEIVE3R {
164 #[doc = r" Returns `true` if the bit is clear (0)"]
165 #[inline]
166 pub fn bit_is_clear(&self) -> bool {
167 !self.bit()
168 }
169 #[doc = r" Returns `true` if the bit is set (1)"]
170 #[inline]
171 pub fn bit_is_set(&self) -> bool {
172 self.bit()
173 }
174 #[doc = r" Value of the field as raw bits"]
175 #[inline]
176 pub fn bit(&self) -> bool {
177 match *self {
178 RECEIVE3R::NOTPENDING => false,
179 RECEIVE3R::PENDING => true,
180 }
181 }
182 #[allow(missing_docs)]
183 #[doc(hidden)]
184 #[inline]
185 pub fn _from(value: bool) -> RECEIVE3R {
186 match value {
187 false => RECEIVE3R::NOTPENDING,
188 true => RECEIVE3R::PENDING,
189 }
190 }
191 #[doc = "Checks if the value of the field is `NOTPENDING`"]
192 #[inline]
193 pub fn is_not_pending(&self) -> bool {
194 *self == RECEIVE3R::NOTPENDING
195 }
196 #[doc = "Checks if the value of the field is `PENDING`"]
197 #[inline]
198 pub fn is_pending(&self) -> bool {
199 *self == RECEIVE3R::PENDING
200 }
201}
202#[doc = "Possible values of the field `RECEIVE4`"]
203#[derive(Clone, Copy, Debug, PartialEq)]
204pub enum RECEIVE4R {
205 #[doc = "Read: Not pending"]
206 NOTPENDING,
207 #[doc = "Read: Pending"]
208 PENDING,
209}
210impl RECEIVE4R {
211 #[doc = r" Returns `true` if the bit is clear (0)"]
212 #[inline]
213 pub fn bit_is_clear(&self) -> bool {
214 !self.bit()
215 }
216 #[doc = r" Returns `true` if the bit is set (1)"]
217 #[inline]
218 pub fn bit_is_set(&self) -> bool {
219 self.bit()
220 }
221 #[doc = r" Value of the field as raw bits"]
222 #[inline]
223 pub fn bit(&self) -> bool {
224 match *self {
225 RECEIVE4R::NOTPENDING => false,
226 RECEIVE4R::PENDING => true,
227 }
228 }
229 #[allow(missing_docs)]
230 #[doc(hidden)]
231 #[inline]
232 pub fn _from(value: bool) -> RECEIVE4R {
233 match value {
234 false => RECEIVE4R::NOTPENDING,
235 true => RECEIVE4R::PENDING,
236 }
237 }
238 #[doc = "Checks if the value of the field is `NOTPENDING`"]
239 #[inline]
240 pub fn is_not_pending(&self) -> bool {
241 *self == RECEIVE4R::NOTPENDING
242 }
243 #[doc = "Checks if the value of the field is `PENDING`"]
244 #[inline]
245 pub fn is_pending(&self) -> bool {
246 *self == RECEIVE4R::PENDING
247 }
248}
249#[doc = "Possible values of the field `RECEIVE5`"]
250#[derive(Clone, Copy, Debug, PartialEq)]
251pub enum RECEIVE5R {
252 #[doc = "Read: Not pending"]
253 NOTPENDING,
254 #[doc = "Read: Pending"]
255 PENDING,
256}
257impl RECEIVE5R {
258 #[doc = r" Returns `true` if the bit is clear (0)"]
259 #[inline]
260 pub fn bit_is_clear(&self) -> bool {
261 !self.bit()
262 }
263 #[doc = r" Returns `true` if the bit is set (1)"]
264 #[inline]
265 pub fn bit_is_set(&self) -> bool {
266 self.bit()
267 }
268 #[doc = r" Value of the field as raw bits"]
269 #[inline]
270 pub fn bit(&self) -> bool {
271 match *self {
272 RECEIVE5R::NOTPENDING => false,
273 RECEIVE5R::PENDING => true,
274 }
275 }
276 #[allow(missing_docs)]
277 #[doc(hidden)]
278 #[inline]
279 pub fn _from(value: bool) -> RECEIVE5R {
280 match value {
281 false => RECEIVE5R::NOTPENDING,
282 true => RECEIVE5R::PENDING,
283 }
284 }
285 #[doc = "Checks if the value of the field is `NOTPENDING`"]
286 #[inline]
287 pub fn is_not_pending(&self) -> bool {
288 *self == RECEIVE5R::NOTPENDING
289 }
290 #[doc = "Checks if the value of the field is `PENDING`"]
291 #[inline]
292 pub fn is_pending(&self) -> bool {
293 *self == RECEIVE5R::PENDING
294 }
295}
296#[doc = "Possible values of the field `RECEIVE6`"]
297#[derive(Clone, Copy, Debug, PartialEq)]
298pub enum RECEIVE6R {
299 #[doc = "Read: Not pending"]
300 NOTPENDING,
301 #[doc = "Read: Pending"]
302 PENDING,
303}
304impl RECEIVE6R {
305 #[doc = r" Returns `true` if the bit is clear (0)"]
306 #[inline]
307 pub fn bit_is_clear(&self) -> bool {
308 !self.bit()
309 }
310 #[doc = r" Returns `true` if the bit is set (1)"]
311 #[inline]
312 pub fn bit_is_set(&self) -> bool {
313 self.bit()
314 }
315 #[doc = r" Value of the field as raw bits"]
316 #[inline]
317 pub fn bit(&self) -> bool {
318 match *self {
319 RECEIVE6R::NOTPENDING => false,
320 RECEIVE6R::PENDING => true,
321 }
322 }
323 #[allow(missing_docs)]
324 #[doc(hidden)]
325 #[inline]
326 pub fn _from(value: bool) -> RECEIVE6R {
327 match value {
328 false => RECEIVE6R::NOTPENDING,
329 true => RECEIVE6R::PENDING,
330 }
331 }
332 #[doc = "Checks if the value of the field is `NOTPENDING`"]
333 #[inline]
334 pub fn is_not_pending(&self) -> bool {
335 *self == RECEIVE6R::NOTPENDING
336 }
337 #[doc = "Checks if the value of the field is `PENDING`"]
338 #[inline]
339 pub fn is_pending(&self) -> bool {
340 *self == RECEIVE6R::PENDING
341 }
342}
343#[doc = "Possible values of the field `RECEIVE7`"]
344#[derive(Clone, Copy, Debug, PartialEq)]
345pub enum RECEIVE7R {
346 #[doc = "Read: Not pending"]
347 NOTPENDING,
348 #[doc = "Read: Pending"]
349 PENDING,
350}
351impl RECEIVE7R {
352 #[doc = r" Returns `true` if the bit is clear (0)"]
353 #[inline]
354 pub fn bit_is_clear(&self) -> bool {
355 !self.bit()
356 }
357 #[doc = r" Returns `true` if the bit is set (1)"]
358 #[inline]
359 pub fn bit_is_set(&self) -> bool {
360 self.bit()
361 }
362 #[doc = r" Value of the field as raw bits"]
363 #[inline]
364 pub fn bit(&self) -> bool {
365 match *self {
366 RECEIVE7R::NOTPENDING => false,
367 RECEIVE7R::PENDING => true,
368 }
369 }
370 #[allow(missing_docs)]
371 #[doc(hidden)]
372 #[inline]
373 pub fn _from(value: bool) -> RECEIVE7R {
374 match value {
375 false => RECEIVE7R::NOTPENDING,
376 true => RECEIVE7R::PENDING,
377 }
378 }
379 #[doc = "Checks if the value of the field is `NOTPENDING`"]
380 #[inline]
381 pub fn is_not_pending(&self) -> bool {
382 *self == RECEIVE7R::NOTPENDING
383 }
384 #[doc = "Checks if the value of the field is `PENDING`"]
385 #[inline]
386 pub fn is_pending(&self) -> bool {
387 *self == RECEIVE7R::PENDING
388 }
389}
390impl R {
391 #[doc = r" Value of the register as raw bits"]
392 #[inline]
393 pub fn bits(&self) -> u32 {
394 self.bits
395 }
396 #[doc = "Bit 0 - Read pending status of interrupt for event RECEIVE\\[0\\]"]
397 #[inline]
398 pub fn receive0(&self) -> RECEIVE0R {
399 RECEIVE0R::_from({
400 const MASK: bool = true;
401 const OFFSET: u8 = 0;
402 ((self.bits >> OFFSET) & MASK as u32) != 0
403 })
404 }
405 #[doc = "Bit 1 - Read pending status of interrupt for event RECEIVE\\[1\\]"]
406 #[inline]
407 pub fn receive1(&self) -> RECEIVE1R {
408 RECEIVE1R::_from({
409 const MASK: bool = true;
410 const OFFSET: u8 = 1;
411 ((self.bits >> OFFSET) & MASK as u32) != 0
412 })
413 }
414 #[doc = "Bit 2 - Read pending status of interrupt for event RECEIVE\\[2\\]"]
415 #[inline]
416 pub fn receive2(&self) -> RECEIVE2R {
417 RECEIVE2R::_from({
418 const MASK: bool = true;
419 const OFFSET: u8 = 2;
420 ((self.bits >> OFFSET) & MASK as u32) != 0
421 })
422 }
423 #[doc = "Bit 3 - Read pending status of interrupt for event RECEIVE\\[3\\]"]
424 #[inline]
425 pub fn receive3(&self) -> RECEIVE3R {
426 RECEIVE3R::_from({
427 const MASK: bool = true;
428 const OFFSET: u8 = 3;
429 ((self.bits >> OFFSET) & MASK as u32) != 0
430 })
431 }
432 #[doc = "Bit 4 - Read pending status of interrupt for event RECEIVE\\[4\\]"]
433 #[inline]
434 pub fn receive4(&self) -> RECEIVE4R {
435 RECEIVE4R::_from({
436 const MASK: bool = true;
437 const OFFSET: u8 = 4;
438 ((self.bits >> OFFSET) & MASK as u32) != 0
439 })
440 }
441 #[doc = "Bit 5 - Read pending status of interrupt for event RECEIVE\\[5\\]"]
442 #[inline]
443 pub fn receive5(&self) -> RECEIVE5R {
444 RECEIVE5R::_from({
445 const MASK: bool = true;
446 const OFFSET: u8 = 5;
447 ((self.bits >> OFFSET) & MASK as u32) != 0
448 })
449 }
450 #[doc = "Bit 6 - Read pending status of interrupt for event RECEIVE\\[6\\]"]
451 #[inline]
452 pub fn receive6(&self) -> RECEIVE6R {
453 RECEIVE6R::_from({
454 const MASK: bool = true;
455 const OFFSET: u8 = 6;
456 ((self.bits >> OFFSET) & MASK as u32) != 0
457 })
458 }
459 #[doc = "Bit 7 - Read pending status of interrupt for event RECEIVE\\[7\\]"]
460 #[inline]
461 pub fn receive7(&self) -> RECEIVE7R {
462 RECEIVE7R::_from({
463 const MASK: bool = true;
464 const OFFSET: u8 = 7;
465 ((self.bits >> OFFSET) & MASK as u32) != 0
466 })
467 }
468}