rv32m1_ri5cy_pac/dma0/
int.rs

1#[doc = "Reader of register INT"]
2pub type R = crate::R<u32, super::INT>;
3#[doc = "Writer for register INT"]
4pub type W = crate::W<u32, super::INT>;
5#[doc = "Register INT `reset()`'s with value 0"]
6impl crate::ResetValue for super::INT {
7  type Type = u32;
8  #[inline(always)]
9  fn reset_value() -> Self::Type {
10    0
11  }
12}
13#[doc = "Interrupt Request 0\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15pub enum INT0_A {
16  #[doc = "0: The interrupt request for corresponding channel is cleared"]
17  INT0_0,
18  #[doc = "1: The interrupt request for corresponding channel is active"]
19  INT0_1,
20}
21impl From<INT0_A> for bool {
22  #[inline(always)]
23  fn from(variant: INT0_A) -> Self {
24    match variant {
25      INT0_A::INT0_0 => false,
26      INT0_A::INT0_1 => true,
27    }
28  }
29}
30#[doc = "Reader of field `INT0`"]
31pub type INT0_R = crate::R<bool, INT0_A>;
32impl INT0_R {
33  #[doc = r"Get enumerated values variant"]
34  #[inline(always)]
35  pub fn variant(&self) -> INT0_A {
36    match self.bits {
37      false => INT0_A::INT0_0,
38      true => INT0_A::INT0_1,
39    }
40  }
41  #[doc = "Checks if the value of the field is `INT0_0`"]
42  #[inline(always)]
43  pub fn is_int0_0(&self) -> bool {
44    *self == INT0_A::INT0_0
45  }
46  #[doc = "Checks if the value of the field is `INT0_1`"]
47  #[inline(always)]
48  pub fn is_int0_1(&self) -> bool {
49    *self == INT0_A::INT0_1
50  }
51}
52#[doc = "Write proxy for field `INT0`"]
53pub struct INT0_W<'a> {
54  w: &'a mut W,
55}
56impl<'a> INT0_W<'a> {
57  #[doc = r"Writes `variant` to the field"]
58  #[inline(always)]
59  pub fn variant(self, variant: INT0_A) -> &'a mut W {
60    {
61      self.bit(variant.into())
62    }
63  }
64  #[doc = "The interrupt request for corresponding channel is cleared"]
65  #[inline(always)]
66  pub fn int0_0(self) -> &'a mut W {
67    self.variant(INT0_A::INT0_0)
68  }
69  #[doc = "The interrupt request for corresponding channel is active"]
70  #[inline(always)]
71  pub fn int0_1(self) -> &'a mut W {
72    self.variant(INT0_A::INT0_1)
73  }
74  #[doc = r"Sets the field bit"]
75  #[inline(always)]
76  pub fn set_bit(self) -> &'a mut W {
77    self.bit(true)
78  }
79  #[doc = r"Clears the field bit"]
80  #[inline(always)]
81  pub fn clear_bit(self) -> &'a mut W {
82    self.bit(false)
83  }
84  #[doc = r"Writes raw bits to the field"]
85  #[inline(always)]
86  pub fn bit(self, value: bool) -> &'a mut W {
87    self.w.bits = (self.w.bits & !0x01) | ((value as u32) & 0x01);
88    self.w
89  }
90}
91#[doc = "Interrupt Request 1\n\nValue on reset: 0"]
92#[derive(Clone, Copy, Debug, PartialEq)]
93pub enum INT1_A {
94  #[doc = "0: The interrupt request for corresponding channel is cleared"]
95  INT1_0,
96  #[doc = "1: The interrupt request for corresponding channel is active"]
97  INT1_1,
98}
99impl From<INT1_A> for bool {
100  #[inline(always)]
101  fn from(variant: INT1_A) -> Self {
102    match variant {
103      INT1_A::INT1_0 => false,
104      INT1_A::INT1_1 => true,
105    }
106  }
107}
108#[doc = "Reader of field `INT1`"]
109pub type INT1_R = crate::R<bool, INT1_A>;
110impl INT1_R {
111  #[doc = r"Get enumerated values variant"]
112  #[inline(always)]
113  pub fn variant(&self) -> INT1_A {
114    match self.bits {
115      false => INT1_A::INT1_0,
116      true => INT1_A::INT1_1,
117    }
118  }
119  #[doc = "Checks if the value of the field is `INT1_0`"]
120  #[inline(always)]
121  pub fn is_int1_0(&self) -> bool {
122    *self == INT1_A::INT1_0
123  }
124  #[doc = "Checks if the value of the field is `INT1_1`"]
125  #[inline(always)]
126  pub fn is_int1_1(&self) -> bool {
127    *self == INT1_A::INT1_1
128  }
129}
130#[doc = "Write proxy for field `INT1`"]
131pub struct INT1_W<'a> {
132  w: &'a mut W,
133}
134impl<'a> INT1_W<'a> {
135  #[doc = r"Writes `variant` to the field"]
136  #[inline(always)]
137  pub fn variant(self, variant: INT1_A) -> &'a mut W {
138    {
139      self.bit(variant.into())
140    }
141  }
142  #[doc = "The interrupt request for corresponding channel is cleared"]
143  #[inline(always)]
144  pub fn int1_0(self) -> &'a mut W {
145    self.variant(INT1_A::INT1_0)
146  }
147  #[doc = "The interrupt request for corresponding channel is active"]
148  #[inline(always)]
149  pub fn int1_1(self) -> &'a mut W {
150    self.variant(INT1_A::INT1_1)
151  }
152  #[doc = r"Sets the field bit"]
153  #[inline(always)]
154  pub fn set_bit(self) -> &'a mut W {
155    self.bit(true)
156  }
157  #[doc = r"Clears the field bit"]
158  #[inline(always)]
159  pub fn clear_bit(self) -> &'a mut W {
160    self.bit(false)
161  }
162  #[doc = r"Writes raw bits to the field"]
163  #[inline(always)]
164  pub fn bit(self, value: bool) -> &'a mut W {
165    self.w.bits = (self.w.bits & !(0x01 << 1)) | (((value as u32) & 0x01) << 1);
166    self.w
167  }
168}
169#[doc = "Interrupt Request 2\n\nValue on reset: 0"]
170#[derive(Clone, Copy, Debug, PartialEq)]
171pub enum INT2_A {
172  #[doc = "0: The interrupt request for corresponding channel is cleared"]
173  INT2_0,
174  #[doc = "1: The interrupt request for corresponding channel is active"]
175  INT2_1,
176}
177impl From<INT2_A> for bool {
178  #[inline(always)]
179  fn from(variant: INT2_A) -> Self {
180    match variant {
181      INT2_A::INT2_0 => false,
182      INT2_A::INT2_1 => true,
183    }
184  }
185}
186#[doc = "Reader of field `INT2`"]
187pub type INT2_R = crate::R<bool, INT2_A>;
188impl INT2_R {
189  #[doc = r"Get enumerated values variant"]
190  #[inline(always)]
191  pub fn variant(&self) -> INT2_A {
192    match self.bits {
193      false => INT2_A::INT2_0,
194      true => INT2_A::INT2_1,
195    }
196  }
197  #[doc = "Checks if the value of the field is `INT2_0`"]
198  #[inline(always)]
199  pub fn is_int2_0(&self) -> bool {
200    *self == INT2_A::INT2_0
201  }
202  #[doc = "Checks if the value of the field is `INT2_1`"]
203  #[inline(always)]
204  pub fn is_int2_1(&self) -> bool {
205    *self == INT2_A::INT2_1
206  }
207}
208#[doc = "Write proxy for field `INT2`"]
209pub struct INT2_W<'a> {
210  w: &'a mut W,
211}
212impl<'a> INT2_W<'a> {
213  #[doc = r"Writes `variant` to the field"]
214  #[inline(always)]
215  pub fn variant(self, variant: INT2_A) -> &'a mut W {
216    {
217      self.bit(variant.into())
218    }
219  }
220  #[doc = "The interrupt request for corresponding channel is cleared"]
221  #[inline(always)]
222  pub fn int2_0(self) -> &'a mut W {
223    self.variant(INT2_A::INT2_0)
224  }
225  #[doc = "The interrupt request for corresponding channel is active"]
226  #[inline(always)]
227  pub fn int2_1(self) -> &'a mut W {
228    self.variant(INT2_A::INT2_1)
229  }
230  #[doc = r"Sets the field bit"]
231  #[inline(always)]
232  pub fn set_bit(self) -> &'a mut W {
233    self.bit(true)
234  }
235  #[doc = r"Clears the field bit"]
236  #[inline(always)]
237  pub fn clear_bit(self) -> &'a mut W {
238    self.bit(false)
239  }
240  #[doc = r"Writes raw bits to the field"]
241  #[inline(always)]
242  pub fn bit(self, value: bool) -> &'a mut W {
243    self.w.bits = (self.w.bits & !(0x01 << 2)) | (((value as u32) & 0x01) << 2);
244    self.w
245  }
246}
247#[doc = "Interrupt Request 3\n\nValue on reset: 0"]
248#[derive(Clone, Copy, Debug, PartialEq)]
249pub enum INT3_A {
250  #[doc = "0: The interrupt request for corresponding channel is cleared"]
251  INT3_0,
252  #[doc = "1: The interrupt request for corresponding channel is active"]
253  INT3_1,
254}
255impl From<INT3_A> for bool {
256  #[inline(always)]
257  fn from(variant: INT3_A) -> Self {
258    match variant {
259      INT3_A::INT3_0 => false,
260      INT3_A::INT3_1 => true,
261    }
262  }
263}
264#[doc = "Reader of field `INT3`"]
265pub type INT3_R = crate::R<bool, INT3_A>;
266impl INT3_R {
267  #[doc = r"Get enumerated values variant"]
268  #[inline(always)]
269  pub fn variant(&self) -> INT3_A {
270    match self.bits {
271      false => INT3_A::INT3_0,
272      true => INT3_A::INT3_1,
273    }
274  }
275  #[doc = "Checks if the value of the field is `INT3_0`"]
276  #[inline(always)]
277  pub fn is_int3_0(&self) -> bool {
278    *self == INT3_A::INT3_0
279  }
280  #[doc = "Checks if the value of the field is `INT3_1`"]
281  #[inline(always)]
282  pub fn is_int3_1(&self) -> bool {
283    *self == INT3_A::INT3_1
284  }
285}
286#[doc = "Write proxy for field `INT3`"]
287pub struct INT3_W<'a> {
288  w: &'a mut W,
289}
290impl<'a> INT3_W<'a> {
291  #[doc = r"Writes `variant` to the field"]
292  #[inline(always)]
293  pub fn variant(self, variant: INT3_A) -> &'a mut W {
294    {
295      self.bit(variant.into())
296    }
297  }
298  #[doc = "The interrupt request for corresponding channel is cleared"]
299  #[inline(always)]
300  pub fn int3_0(self) -> &'a mut W {
301    self.variant(INT3_A::INT3_0)
302  }
303  #[doc = "The interrupt request for corresponding channel is active"]
304  #[inline(always)]
305  pub fn int3_1(self) -> &'a mut W {
306    self.variant(INT3_A::INT3_1)
307  }
308  #[doc = r"Sets the field bit"]
309  #[inline(always)]
310  pub fn set_bit(self) -> &'a mut W {
311    self.bit(true)
312  }
313  #[doc = r"Clears the field bit"]
314  #[inline(always)]
315  pub fn clear_bit(self) -> &'a mut W {
316    self.bit(false)
317  }
318  #[doc = r"Writes raw bits to the field"]
319  #[inline(always)]
320  pub fn bit(self, value: bool) -> &'a mut W {
321    self.w.bits = (self.w.bits & !(0x01 << 3)) | (((value as u32) & 0x01) << 3);
322    self.w
323  }
324}
325#[doc = "Interrupt Request 4\n\nValue on reset: 0"]
326#[derive(Clone, Copy, Debug, PartialEq)]
327pub enum INT4_A {
328  #[doc = "0: The interrupt request for corresponding channel is cleared"]
329  INT4_0,
330  #[doc = "1: The interrupt request for corresponding channel is active"]
331  INT4_1,
332}
333impl From<INT4_A> for bool {
334  #[inline(always)]
335  fn from(variant: INT4_A) -> Self {
336    match variant {
337      INT4_A::INT4_0 => false,
338      INT4_A::INT4_1 => true,
339    }
340  }
341}
342#[doc = "Reader of field `INT4`"]
343pub type INT4_R = crate::R<bool, INT4_A>;
344impl INT4_R {
345  #[doc = r"Get enumerated values variant"]
346  #[inline(always)]
347  pub fn variant(&self) -> INT4_A {
348    match self.bits {
349      false => INT4_A::INT4_0,
350      true => INT4_A::INT4_1,
351    }
352  }
353  #[doc = "Checks if the value of the field is `INT4_0`"]
354  #[inline(always)]
355  pub fn is_int4_0(&self) -> bool {
356    *self == INT4_A::INT4_0
357  }
358  #[doc = "Checks if the value of the field is `INT4_1`"]
359  #[inline(always)]
360  pub fn is_int4_1(&self) -> bool {
361    *self == INT4_A::INT4_1
362  }
363}
364#[doc = "Write proxy for field `INT4`"]
365pub struct INT4_W<'a> {
366  w: &'a mut W,
367}
368impl<'a> INT4_W<'a> {
369  #[doc = r"Writes `variant` to the field"]
370  #[inline(always)]
371  pub fn variant(self, variant: INT4_A) -> &'a mut W {
372    {
373      self.bit(variant.into())
374    }
375  }
376  #[doc = "The interrupt request for corresponding channel is cleared"]
377  #[inline(always)]
378  pub fn int4_0(self) -> &'a mut W {
379    self.variant(INT4_A::INT4_0)
380  }
381  #[doc = "The interrupt request for corresponding channel is active"]
382  #[inline(always)]
383  pub fn int4_1(self) -> &'a mut W {
384    self.variant(INT4_A::INT4_1)
385  }
386  #[doc = r"Sets the field bit"]
387  #[inline(always)]
388  pub fn set_bit(self) -> &'a mut W {
389    self.bit(true)
390  }
391  #[doc = r"Clears the field bit"]
392  #[inline(always)]
393  pub fn clear_bit(self) -> &'a mut W {
394    self.bit(false)
395  }
396  #[doc = r"Writes raw bits to the field"]
397  #[inline(always)]
398  pub fn bit(self, value: bool) -> &'a mut W {
399    self.w.bits = (self.w.bits & !(0x01 << 4)) | (((value as u32) & 0x01) << 4);
400    self.w
401  }
402}
403#[doc = "Interrupt Request 5\n\nValue on reset: 0"]
404#[derive(Clone, Copy, Debug, PartialEq)]
405pub enum INT5_A {
406  #[doc = "0: The interrupt request for corresponding channel is cleared"]
407  INT5_0,
408  #[doc = "1: The interrupt request for corresponding channel is active"]
409  INT5_1,
410}
411impl From<INT5_A> for bool {
412  #[inline(always)]
413  fn from(variant: INT5_A) -> Self {
414    match variant {
415      INT5_A::INT5_0 => false,
416      INT5_A::INT5_1 => true,
417    }
418  }
419}
420#[doc = "Reader of field `INT5`"]
421pub type INT5_R = crate::R<bool, INT5_A>;
422impl INT5_R {
423  #[doc = r"Get enumerated values variant"]
424  #[inline(always)]
425  pub fn variant(&self) -> INT5_A {
426    match self.bits {
427      false => INT5_A::INT5_0,
428      true => INT5_A::INT5_1,
429    }
430  }
431  #[doc = "Checks if the value of the field is `INT5_0`"]
432  #[inline(always)]
433  pub fn is_int5_0(&self) -> bool {
434    *self == INT5_A::INT5_0
435  }
436  #[doc = "Checks if the value of the field is `INT5_1`"]
437  #[inline(always)]
438  pub fn is_int5_1(&self) -> bool {
439    *self == INT5_A::INT5_1
440  }
441}
442#[doc = "Write proxy for field `INT5`"]
443pub struct INT5_W<'a> {
444  w: &'a mut W,
445}
446impl<'a> INT5_W<'a> {
447  #[doc = r"Writes `variant` to the field"]
448  #[inline(always)]
449  pub fn variant(self, variant: INT5_A) -> &'a mut W {
450    {
451      self.bit(variant.into())
452    }
453  }
454  #[doc = "The interrupt request for corresponding channel is cleared"]
455  #[inline(always)]
456  pub fn int5_0(self) -> &'a mut W {
457    self.variant(INT5_A::INT5_0)
458  }
459  #[doc = "The interrupt request for corresponding channel is active"]
460  #[inline(always)]
461  pub fn int5_1(self) -> &'a mut W {
462    self.variant(INT5_A::INT5_1)
463  }
464  #[doc = r"Sets the field bit"]
465  #[inline(always)]
466  pub fn set_bit(self) -> &'a mut W {
467    self.bit(true)
468  }
469  #[doc = r"Clears the field bit"]
470  #[inline(always)]
471  pub fn clear_bit(self) -> &'a mut W {
472    self.bit(false)
473  }
474  #[doc = r"Writes raw bits to the field"]
475  #[inline(always)]
476  pub fn bit(self, value: bool) -> &'a mut W {
477    self.w.bits = (self.w.bits & !(0x01 << 5)) | (((value as u32) & 0x01) << 5);
478    self.w
479  }
480}
481#[doc = "Interrupt Request 6\n\nValue on reset: 0"]
482#[derive(Clone, Copy, Debug, PartialEq)]
483pub enum INT6_A {
484  #[doc = "0: The interrupt request for corresponding channel is cleared"]
485  INT6_0,
486  #[doc = "1: The interrupt request for corresponding channel is active"]
487  INT6_1,
488}
489impl From<INT6_A> for bool {
490  #[inline(always)]
491  fn from(variant: INT6_A) -> Self {
492    match variant {
493      INT6_A::INT6_0 => false,
494      INT6_A::INT6_1 => true,
495    }
496  }
497}
498#[doc = "Reader of field `INT6`"]
499pub type INT6_R = crate::R<bool, INT6_A>;
500impl INT6_R {
501  #[doc = r"Get enumerated values variant"]
502  #[inline(always)]
503  pub fn variant(&self) -> INT6_A {
504    match self.bits {
505      false => INT6_A::INT6_0,
506      true => INT6_A::INT6_1,
507    }
508  }
509  #[doc = "Checks if the value of the field is `INT6_0`"]
510  #[inline(always)]
511  pub fn is_int6_0(&self) -> bool {
512    *self == INT6_A::INT6_0
513  }
514  #[doc = "Checks if the value of the field is `INT6_1`"]
515  #[inline(always)]
516  pub fn is_int6_1(&self) -> bool {
517    *self == INT6_A::INT6_1
518  }
519}
520#[doc = "Write proxy for field `INT6`"]
521pub struct INT6_W<'a> {
522  w: &'a mut W,
523}
524impl<'a> INT6_W<'a> {
525  #[doc = r"Writes `variant` to the field"]
526  #[inline(always)]
527  pub fn variant(self, variant: INT6_A) -> &'a mut W {
528    {
529      self.bit(variant.into())
530    }
531  }
532  #[doc = "The interrupt request for corresponding channel is cleared"]
533  #[inline(always)]
534  pub fn int6_0(self) -> &'a mut W {
535    self.variant(INT6_A::INT6_0)
536  }
537  #[doc = "The interrupt request for corresponding channel is active"]
538  #[inline(always)]
539  pub fn int6_1(self) -> &'a mut W {
540    self.variant(INT6_A::INT6_1)
541  }
542  #[doc = r"Sets the field bit"]
543  #[inline(always)]
544  pub fn set_bit(self) -> &'a mut W {
545    self.bit(true)
546  }
547  #[doc = r"Clears the field bit"]
548  #[inline(always)]
549  pub fn clear_bit(self) -> &'a mut W {
550    self.bit(false)
551  }
552  #[doc = r"Writes raw bits to the field"]
553  #[inline(always)]
554  pub fn bit(self, value: bool) -> &'a mut W {
555    self.w.bits = (self.w.bits & !(0x01 << 6)) | (((value as u32) & 0x01) << 6);
556    self.w
557  }
558}
559#[doc = "Interrupt Request 7\n\nValue on reset: 0"]
560#[derive(Clone, Copy, Debug, PartialEq)]
561pub enum INT7_A {
562  #[doc = "0: The interrupt request for corresponding channel is cleared"]
563  INT7_0,
564  #[doc = "1: The interrupt request for corresponding channel is active"]
565  INT7_1,
566}
567impl From<INT7_A> for bool {
568  #[inline(always)]
569  fn from(variant: INT7_A) -> Self {
570    match variant {
571      INT7_A::INT7_0 => false,
572      INT7_A::INT7_1 => true,
573    }
574  }
575}
576#[doc = "Reader of field `INT7`"]
577pub type INT7_R = crate::R<bool, INT7_A>;
578impl INT7_R {
579  #[doc = r"Get enumerated values variant"]
580  #[inline(always)]
581  pub fn variant(&self) -> INT7_A {
582    match self.bits {
583      false => INT7_A::INT7_0,
584      true => INT7_A::INT7_1,
585    }
586  }
587  #[doc = "Checks if the value of the field is `INT7_0`"]
588  #[inline(always)]
589  pub fn is_int7_0(&self) -> bool {
590    *self == INT7_A::INT7_0
591  }
592  #[doc = "Checks if the value of the field is `INT7_1`"]
593  #[inline(always)]
594  pub fn is_int7_1(&self) -> bool {
595    *self == INT7_A::INT7_1
596  }
597}
598#[doc = "Write proxy for field `INT7`"]
599pub struct INT7_W<'a> {
600  w: &'a mut W,
601}
602impl<'a> INT7_W<'a> {
603  #[doc = r"Writes `variant` to the field"]
604  #[inline(always)]
605  pub fn variant(self, variant: INT7_A) -> &'a mut W {
606    {
607      self.bit(variant.into())
608    }
609  }
610  #[doc = "The interrupt request for corresponding channel is cleared"]
611  #[inline(always)]
612  pub fn int7_0(self) -> &'a mut W {
613    self.variant(INT7_A::INT7_0)
614  }
615  #[doc = "The interrupt request for corresponding channel is active"]
616  #[inline(always)]
617  pub fn int7_1(self) -> &'a mut W {
618    self.variant(INT7_A::INT7_1)
619  }
620  #[doc = r"Sets the field bit"]
621  #[inline(always)]
622  pub fn set_bit(self) -> &'a mut W {
623    self.bit(true)
624  }
625  #[doc = r"Clears the field bit"]
626  #[inline(always)]
627  pub fn clear_bit(self) -> &'a mut W {
628    self.bit(false)
629  }
630  #[doc = r"Writes raw bits to the field"]
631  #[inline(always)]
632  pub fn bit(self, value: bool) -> &'a mut W {
633    self.w.bits = (self.w.bits & !(0x01 << 7)) | (((value as u32) & 0x01) << 7);
634    self.w
635  }
636}
637#[doc = "Interrupt Request 8\n\nValue on reset: 0"]
638#[derive(Clone, Copy, Debug, PartialEq)]
639pub enum INT8_A {
640  #[doc = "0: The interrupt request for corresponding channel is cleared"]
641  INT8_0,
642  #[doc = "1: The interrupt request for corresponding channel is active"]
643  INT8_1,
644}
645impl From<INT8_A> for bool {
646  #[inline(always)]
647  fn from(variant: INT8_A) -> Self {
648    match variant {
649      INT8_A::INT8_0 => false,
650      INT8_A::INT8_1 => true,
651    }
652  }
653}
654#[doc = "Reader of field `INT8`"]
655pub type INT8_R = crate::R<bool, INT8_A>;
656impl INT8_R {
657  #[doc = r"Get enumerated values variant"]
658  #[inline(always)]
659  pub fn variant(&self) -> INT8_A {
660    match self.bits {
661      false => INT8_A::INT8_0,
662      true => INT8_A::INT8_1,
663    }
664  }
665  #[doc = "Checks if the value of the field is `INT8_0`"]
666  #[inline(always)]
667  pub fn is_int8_0(&self) -> bool {
668    *self == INT8_A::INT8_0
669  }
670  #[doc = "Checks if the value of the field is `INT8_1`"]
671  #[inline(always)]
672  pub fn is_int8_1(&self) -> bool {
673    *self == INT8_A::INT8_1
674  }
675}
676#[doc = "Write proxy for field `INT8`"]
677pub struct INT8_W<'a> {
678  w: &'a mut W,
679}
680impl<'a> INT8_W<'a> {
681  #[doc = r"Writes `variant` to the field"]
682  #[inline(always)]
683  pub fn variant(self, variant: INT8_A) -> &'a mut W {
684    {
685      self.bit(variant.into())
686    }
687  }
688  #[doc = "The interrupt request for corresponding channel is cleared"]
689  #[inline(always)]
690  pub fn int8_0(self) -> &'a mut W {
691    self.variant(INT8_A::INT8_0)
692  }
693  #[doc = "The interrupt request for corresponding channel is active"]
694  #[inline(always)]
695  pub fn int8_1(self) -> &'a mut W {
696    self.variant(INT8_A::INT8_1)
697  }
698  #[doc = r"Sets the field bit"]
699  #[inline(always)]
700  pub fn set_bit(self) -> &'a mut W {
701    self.bit(true)
702  }
703  #[doc = r"Clears the field bit"]
704  #[inline(always)]
705  pub fn clear_bit(self) -> &'a mut W {
706    self.bit(false)
707  }
708  #[doc = r"Writes raw bits to the field"]
709  #[inline(always)]
710  pub fn bit(self, value: bool) -> &'a mut W {
711    self.w.bits = (self.w.bits & !(0x01 << 8)) | (((value as u32) & 0x01) << 8);
712    self.w
713  }
714}
715#[doc = "Interrupt Request 9\n\nValue on reset: 0"]
716#[derive(Clone, Copy, Debug, PartialEq)]
717pub enum INT9_A {
718  #[doc = "0: The interrupt request for corresponding channel is cleared"]
719  INT9_0,
720  #[doc = "1: The interrupt request for corresponding channel is active"]
721  INT9_1,
722}
723impl From<INT9_A> for bool {
724  #[inline(always)]
725  fn from(variant: INT9_A) -> Self {
726    match variant {
727      INT9_A::INT9_0 => false,
728      INT9_A::INT9_1 => true,
729    }
730  }
731}
732#[doc = "Reader of field `INT9`"]
733pub type INT9_R = crate::R<bool, INT9_A>;
734impl INT9_R {
735  #[doc = r"Get enumerated values variant"]
736  #[inline(always)]
737  pub fn variant(&self) -> INT9_A {
738    match self.bits {
739      false => INT9_A::INT9_0,
740      true => INT9_A::INT9_1,
741    }
742  }
743  #[doc = "Checks if the value of the field is `INT9_0`"]
744  #[inline(always)]
745  pub fn is_int9_0(&self) -> bool {
746    *self == INT9_A::INT9_0
747  }
748  #[doc = "Checks if the value of the field is `INT9_1`"]
749  #[inline(always)]
750  pub fn is_int9_1(&self) -> bool {
751    *self == INT9_A::INT9_1
752  }
753}
754#[doc = "Write proxy for field `INT9`"]
755pub struct INT9_W<'a> {
756  w: &'a mut W,
757}
758impl<'a> INT9_W<'a> {
759  #[doc = r"Writes `variant` to the field"]
760  #[inline(always)]
761  pub fn variant(self, variant: INT9_A) -> &'a mut W {
762    {
763      self.bit(variant.into())
764    }
765  }
766  #[doc = "The interrupt request for corresponding channel is cleared"]
767  #[inline(always)]
768  pub fn int9_0(self) -> &'a mut W {
769    self.variant(INT9_A::INT9_0)
770  }
771  #[doc = "The interrupt request for corresponding channel is active"]
772  #[inline(always)]
773  pub fn int9_1(self) -> &'a mut W {
774    self.variant(INT9_A::INT9_1)
775  }
776  #[doc = r"Sets the field bit"]
777  #[inline(always)]
778  pub fn set_bit(self) -> &'a mut W {
779    self.bit(true)
780  }
781  #[doc = r"Clears the field bit"]
782  #[inline(always)]
783  pub fn clear_bit(self) -> &'a mut W {
784    self.bit(false)
785  }
786  #[doc = r"Writes raw bits to the field"]
787  #[inline(always)]
788  pub fn bit(self, value: bool) -> &'a mut W {
789    self.w.bits = (self.w.bits & !(0x01 << 9)) | (((value as u32) & 0x01) << 9);
790    self.w
791  }
792}
793#[doc = "Interrupt Request 10\n\nValue on reset: 0"]
794#[derive(Clone, Copy, Debug, PartialEq)]
795pub enum INT10_A {
796  #[doc = "0: The interrupt request for corresponding channel is cleared"]
797  INT10_0,
798  #[doc = "1: The interrupt request for corresponding channel is active"]
799  INT10_1,
800}
801impl From<INT10_A> for bool {
802  #[inline(always)]
803  fn from(variant: INT10_A) -> Self {
804    match variant {
805      INT10_A::INT10_0 => false,
806      INT10_A::INT10_1 => true,
807    }
808  }
809}
810#[doc = "Reader of field `INT10`"]
811pub type INT10_R = crate::R<bool, INT10_A>;
812impl INT10_R {
813  #[doc = r"Get enumerated values variant"]
814  #[inline(always)]
815  pub fn variant(&self) -> INT10_A {
816    match self.bits {
817      false => INT10_A::INT10_0,
818      true => INT10_A::INT10_1,
819    }
820  }
821  #[doc = "Checks if the value of the field is `INT10_0`"]
822  #[inline(always)]
823  pub fn is_int10_0(&self) -> bool {
824    *self == INT10_A::INT10_0
825  }
826  #[doc = "Checks if the value of the field is `INT10_1`"]
827  #[inline(always)]
828  pub fn is_int10_1(&self) -> bool {
829    *self == INT10_A::INT10_1
830  }
831}
832#[doc = "Write proxy for field `INT10`"]
833pub struct INT10_W<'a> {
834  w: &'a mut W,
835}
836impl<'a> INT10_W<'a> {
837  #[doc = r"Writes `variant` to the field"]
838  #[inline(always)]
839  pub fn variant(self, variant: INT10_A) -> &'a mut W {
840    {
841      self.bit(variant.into())
842    }
843  }
844  #[doc = "The interrupt request for corresponding channel is cleared"]
845  #[inline(always)]
846  pub fn int10_0(self) -> &'a mut W {
847    self.variant(INT10_A::INT10_0)
848  }
849  #[doc = "The interrupt request for corresponding channel is active"]
850  #[inline(always)]
851  pub fn int10_1(self) -> &'a mut W {
852    self.variant(INT10_A::INT10_1)
853  }
854  #[doc = r"Sets the field bit"]
855  #[inline(always)]
856  pub fn set_bit(self) -> &'a mut W {
857    self.bit(true)
858  }
859  #[doc = r"Clears the field bit"]
860  #[inline(always)]
861  pub fn clear_bit(self) -> &'a mut W {
862    self.bit(false)
863  }
864  #[doc = r"Writes raw bits to the field"]
865  #[inline(always)]
866  pub fn bit(self, value: bool) -> &'a mut W {
867    self.w.bits = (self.w.bits & !(0x01 << 10)) | (((value as u32) & 0x01) << 10);
868    self.w
869  }
870}
871#[doc = "Interrupt Request 11\n\nValue on reset: 0"]
872#[derive(Clone, Copy, Debug, PartialEq)]
873pub enum INT11_A {
874  #[doc = "0: The interrupt request for corresponding channel is cleared"]
875  INT11_0,
876  #[doc = "1: The interrupt request for corresponding channel is active"]
877  INT11_1,
878}
879impl From<INT11_A> for bool {
880  #[inline(always)]
881  fn from(variant: INT11_A) -> Self {
882    match variant {
883      INT11_A::INT11_0 => false,
884      INT11_A::INT11_1 => true,
885    }
886  }
887}
888#[doc = "Reader of field `INT11`"]
889pub type INT11_R = crate::R<bool, INT11_A>;
890impl INT11_R {
891  #[doc = r"Get enumerated values variant"]
892  #[inline(always)]
893  pub fn variant(&self) -> INT11_A {
894    match self.bits {
895      false => INT11_A::INT11_0,
896      true => INT11_A::INT11_1,
897    }
898  }
899  #[doc = "Checks if the value of the field is `INT11_0`"]
900  #[inline(always)]
901  pub fn is_int11_0(&self) -> bool {
902    *self == INT11_A::INT11_0
903  }
904  #[doc = "Checks if the value of the field is `INT11_1`"]
905  #[inline(always)]
906  pub fn is_int11_1(&self) -> bool {
907    *self == INT11_A::INT11_1
908  }
909}
910#[doc = "Write proxy for field `INT11`"]
911pub struct INT11_W<'a> {
912  w: &'a mut W,
913}
914impl<'a> INT11_W<'a> {
915  #[doc = r"Writes `variant` to the field"]
916  #[inline(always)]
917  pub fn variant(self, variant: INT11_A) -> &'a mut W {
918    {
919      self.bit(variant.into())
920    }
921  }
922  #[doc = "The interrupt request for corresponding channel is cleared"]
923  #[inline(always)]
924  pub fn int11_0(self) -> &'a mut W {
925    self.variant(INT11_A::INT11_0)
926  }
927  #[doc = "The interrupt request for corresponding channel is active"]
928  #[inline(always)]
929  pub fn int11_1(self) -> &'a mut W {
930    self.variant(INT11_A::INT11_1)
931  }
932  #[doc = r"Sets the field bit"]
933  #[inline(always)]
934  pub fn set_bit(self) -> &'a mut W {
935    self.bit(true)
936  }
937  #[doc = r"Clears the field bit"]
938  #[inline(always)]
939  pub fn clear_bit(self) -> &'a mut W {
940    self.bit(false)
941  }
942  #[doc = r"Writes raw bits to the field"]
943  #[inline(always)]
944  pub fn bit(self, value: bool) -> &'a mut W {
945    self.w.bits = (self.w.bits & !(0x01 << 11)) | (((value as u32) & 0x01) << 11);
946    self.w
947  }
948}
949#[doc = "Interrupt Request 12\n\nValue on reset: 0"]
950#[derive(Clone, Copy, Debug, PartialEq)]
951pub enum INT12_A {
952  #[doc = "0: The interrupt request for corresponding channel is cleared"]
953  INT12_0,
954  #[doc = "1: The interrupt request for corresponding channel is active"]
955  INT12_1,
956}
957impl From<INT12_A> for bool {
958  #[inline(always)]
959  fn from(variant: INT12_A) -> Self {
960    match variant {
961      INT12_A::INT12_0 => false,
962      INT12_A::INT12_1 => true,
963    }
964  }
965}
966#[doc = "Reader of field `INT12`"]
967pub type INT12_R = crate::R<bool, INT12_A>;
968impl INT12_R {
969  #[doc = r"Get enumerated values variant"]
970  #[inline(always)]
971  pub fn variant(&self) -> INT12_A {
972    match self.bits {
973      false => INT12_A::INT12_0,
974      true => INT12_A::INT12_1,
975    }
976  }
977  #[doc = "Checks if the value of the field is `INT12_0`"]
978  #[inline(always)]
979  pub fn is_int12_0(&self) -> bool {
980    *self == INT12_A::INT12_0
981  }
982  #[doc = "Checks if the value of the field is `INT12_1`"]
983  #[inline(always)]
984  pub fn is_int12_1(&self) -> bool {
985    *self == INT12_A::INT12_1
986  }
987}
988#[doc = "Write proxy for field `INT12`"]
989pub struct INT12_W<'a> {
990  w: &'a mut W,
991}
992impl<'a> INT12_W<'a> {
993  #[doc = r"Writes `variant` to the field"]
994  #[inline(always)]
995  pub fn variant(self, variant: INT12_A) -> &'a mut W {
996    {
997      self.bit(variant.into())
998    }
999  }
1000  #[doc = "The interrupt request for corresponding channel is cleared"]
1001  #[inline(always)]
1002  pub fn int12_0(self) -> &'a mut W {
1003    self.variant(INT12_A::INT12_0)
1004  }
1005  #[doc = "The interrupt request for corresponding channel is active"]
1006  #[inline(always)]
1007  pub fn int12_1(self) -> &'a mut W {
1008    self.variant(INT12_A::INT12_1)
1009  }
1010  #[doc = r"Sets the field bit"]
1011  #[inline(always)]
1012  pub fn set_bit(self) -> &'a mut W {
1013    self.bit(true)
1014  }
1015  #[doc = r"Clears the field bit"]
1016  #[inline(always)]
1017  pub fn clear_bit(self) -> &'a mut W {
1018    self.bit(false)
1019  }
1020  #[doc = r"Writes raw bits to the field"]
1021  #[inline(always)]
1022  pub fn bit(self, value: bool) -> &'a mut W {
1023    self.w.bits = (self.w.bits & !(0x01 << 12)) | (((value as u32) & 0x01) << 12);
1024    self.w
1025  }
1026}
1027#[doc = "Interrupt Request 13\n\nValue on reset: 0"]
1028#[derive(Clone, Copy, Debug, PartialEq)]
1029pub enum INT13_A {
1030  #[doc = "0: The interrupt request for corresponding channel is cleared"]
1031  INT13_0,
1032  #[doc = "1: The interrupt request for corresponding channel is active"]
1033  INT13_1,
1034}
1035impl From<INT13_A> for bool {
1036  #[inline(always)]
1037  fn from(variant: INT13_A) -> Self {
1038    match variant {
1039      INT13_A::INT13_0 => false,
1040      INT13_A::INT13_1 => true,
1041    }
1042  }
1043}
1044#[doc = "Reader of field `INT13`"]
1045pub type INT13_R = crate::R<bool, INT13_A>;
1046impl INT13_R {
1047  #[doc = r"Get enumerated values variant"]
1048  #[inline(always)]
1049  pub fn variant(&self) -> INT13_A {
1050    match self.bits {
1051      false => INT13_A::INT13_0,
1052      true => INT13_A::INT13_1,
1053    }
1054  }
1055  #[doc = "Checks if the value of the field is `INT13_0`"]
1056  #[inline(always)]
1057  pub fn is_int13_0(&self) -> bool {
1058    *self == INT13_A::INT13_0
1059  }
1060  #[doc = "Checks if the value of the field is `INT13_1`"]
1061  #[inline(always)]
1062  pub fn is_int13_1(&self) -> bool {
1063    *self == INT13_A::INT13_1
1064  }
1065}
1066#[doc = "Write proxy for field `INT13`"]
1067pub struct INT13_W<'a> {
1068  w: &'a mut W,
1069}
1070impl<'a> INT13_W<'a> {
1071  #[doc = r"Writes `variant` to the field"]
1072  #[inline(always)]
1073  pub fn variant(self, variant: INT13_A) -> &'a mut W {
1074    {
1075      self.bit(variant.into())
1076    }
1077  }
1078  #[doc = "The interrupt request for corresponding channel is cleared"]
1079  #[inline(always)]
1080  pub fn int13_0(self) -> &'a mut W {
1081    self.variant(INT13_A::INT13_0)
1082  }
1083  #[doc = "The interrupt request for corresponding channel is active"]
1084  #[inline(always)]
1085  pub fn int13_1(self) -> &'a mut W {
1086    self.variant(INT13_A::INT13_1)
1087  }
1088  #[doc = r"Sets the field bit"]
1089  #[inline(always)]
1090  pub fn set_bit(self) -> &'a mut W {
1091    self.bit(true)
1092  }
1093  #[doc = r"Clears the field bit"]
1094  #[inline(always)]
1095  pub fn clear_bit(self) -> &'a mut W {
1096    self.bit(false)
1097  }
1098  #[doc = r"Writes raw bits to the field"]
1099  #[inline(always)]
1100  pub fn bit(self, value: bool) -> &'a mut W {
1101    self.w.bits = (self.w.bits & !(0x01 << 13)) | (((value as u32) & 0x01) << 13);
1102    self.w
1103  }
1104}
1105#[doc = "Interrupt Request 14\n\nValue on reset: 0"]
1106#[derive(Clone, Copy, Debug, PartialEq)]
1107pub enum INT14_A {
1108  #[doc = "0: The interrupt request for corresponding channel is cleared"]
1109  INT14_0,
1110  #[doc = "1: The interrupt request for corresponding channel is active"]
1111  INT14_1,
1112}
1113impl From<INT14_A> for bool {
1114  #[inline(always)]
1115  fn from(variant: INT14_A) -> Self {
1116    match variant {
1117      INT14_A::INT14_0 => false,
1118      INT14_A::INT14_1 => true,
1119    }
1120  }
1121}
1122#[doc = "Reader of field `INT14`"]
1123pub type INT14_R = crate::R<bool, INT14_A>;
1124impl INT14_R {
1125  #[doc = r"Get enumerated values variant"]
1126  #[inline(always)]
1127  pub fn variant(&self) -> INT14_A {
1128    match self.bits {
1129      false => INT14_A::INT14_0,
1130      true => INT14_A::INT14_1,
1131    }
1132  }
1133  #[doc = "Checks if the value of the field is `INT14_0`"]
1134  #[inline(always)]
1135  pub fn is_int14_0(&self) -> bool {
1136    *self == INT14_A::INT14_0
1137  }
1138  #[doc = "Checks if the value of the field is `INT14_1`"]
1139  #[inline(always)]
1140  pub fn is_int14_1(&self) -> bool {
1141    *self == INT14_A::INT14_1
1142  }
1143}
1144#[doc = "Write proxy for field `INT14`"]
1145pub struct INT14_W<'a> {
1146  w: &'a mut W,
1147}
1148impl<'a> INT14_W<'a> {
1149  #[doc = r"Writes `variant` to the field"]
1150  #[inline(always)]
1151  pub fn variant(self, variant: INT14_A) -> &'a mut W {
1152    {
1153      self.bit(variant.into())
1154    }
1155  }
1156  #[doc = "The interrupt request for corresponding channel is cleared"]
1157  #[inline(always)]
1158  pub fn int14_0(self) -> &'a mut W {
1159    self.variant(INT14_A::INT14_0)
1160  }
1161  #[doc = "The interrupt request for corresponding channel is active"]
1162  #[inline(always)]
1163  pub fn int14_1(self) -> &'a mut W {
1164    self.variant(INT14_A::INT14_1)
1165  }
1166  #[doc = r"Sets the field bit"]
1167  #[inline(always)]
1168  pub fn set_bit(self) -> &'a mut W {
1169    self.bit(true)
1170  }
1171  #[doc = r"Clears the field bit"]
1172  #[inline(always)]
1173  pub fn clear_bit(self) -> &'a mut W {
1174    self.bit(false)
1175  }
1176  #[doc = r"Writes raw bits to the field"]
1177  #[inline(always)]
1178  pub fn bit(self, value: bool) -> &'a mut W {
1179    self.w.bits = (self.w.bits & !(0x01 << 14)) | (((value as u32) & 0x01) << 14);
1180    self.w
1181  }
1182}
1183#[doc = "Interrupt Request 15\n\nValue on reset: 0"]
1184#[derive(Clone, Copy, Debug, PartialEq)]
1185pub enum INT15_A {
1186  #[doc = "0: The interrupt request for corresponding channel is cleared"]
1187  INT15_0,
1188  #[doc = "1: The interrupt request for corresponding channel is active"]
1189  INT15_1,
1190}
1191impl From<INT15_A> for bool {
1192  #[inline(always)]
1193  fn from(variant: INT15_A) -> Self {
1194    match variant {
1195      INT15_A::INT15_0 => false,
1196      INT15_A::INT15_1 => true,
1197    }
1198  }
1199}
1200#[doc = "Reader of field `INT15`"]
1201pub type INT15_R = crate::R<bool, INT15_A>;
1202impl INT15_R {
1203  #[doc = r"Get enumerated values variant"]
1204  #[inline(always)]
1205  pub fn variant(&self) -> INT15_A {
1206    match self.bits {
1207      false => INT15_A::INT15_0,
1208      true => INT15_A::INT15_1,
1209    }
1210  }
1211  #[doc = "Checks if the value of the field is `INT15_0`"]
1212  #[inline(always)]
1213  pub fn is_int15_0(&self) -> bool {
1214    *self == INT15_A::INT15_0
1215  }
1216  #[doc = "Checks if the value of the field is `INT15_1`"]
1217  #[inline(always)]
1218  pub fn is_int15_1(&self) -> bool {
1219    *self == INT15_A::INT15_1
1220  }
1221}
1222#[doc = "Write proxy for field `INT15`"]
1223pub struct INT15_W<'a> {
1224  w: &'a mut W,
1225}
1226impl<'a> INT15_W<'a> {
1227  #[doc = r"Writes `variant` to the field"]
1228  #[inline(always)]
1229  pub fn variant(self, variant: INT15_A) -> &'a mut W {
1230    {
1231      self.bit(variant.into())
1232    }
1233  }
1234  #[doc = "The interrupt request for corresponding channel is cleared"]
1235  #[inline(always)]
1236  pub fn int15_0(self) -> &'a mut W {
1237    self.variant(INT15_A::INT15_0)
1238  }
1239  #[doc = "The interrupt request for corresponding channel is active"]
1240  #[inline(always)]
1241  pub fn int15_1(self) -> &'a mut W {
1242    self.variant(INT15_A::INT15_1)
1243  }
1244  #[doc = r"Sets the field bit"]
1245  #[inline(always)]
1246  pub fn set_bit(self) -> &'a mut W {
1247    self.bit(true)
1248  }
1249  #[doc = r"Clears the field bit"]
1250  #[inline(always)]
1251  pub fn clear_bit(self) -> &'a mut W {
1252    self.bit(false)
1253  }
1254  #[doc = r"Writes raw bits to the field"]
1255  #[inline(always)]
1256  pub fn bit(self, value: bool) -> &'a mut W {
1257    self.w.bits = (self.w.bits & !(0x01 << 15)) | (((value as u32) & 0x01) << 15);
1258    self.w
1259  }
1260}
1261impl R {
1262  #[doc = "Bit 0 - Interrupt Request 0"]
1263  #[inline(always)]
1264  pub fn int0(&self) -> INT0_R {
1265    INT0_R::new((self.bits & 0x01) != 0)
1266  }
1267  #[doc = "Bit 1 - Interrupt Request 1"]
1268  #[inline(always)]
1269  pub fn int1(&self) -> INT1_R {
1270    INT1_R::new(((self.bits >> 1) & 0x01) != 0)
1271  }
1272  #[doc = "Bit 2 - Interrupt Request 2"]
1273  #[inline(always)]
1274  pub fn int2(&self) -> INT2_R {
1275    INT2_R::new(((self.bits >> 2) & 0x01) != 0)
1276  }
1277  #[doc = "Bit 3 - Interrupt Request 3"]
1278  #[inline(always)]
1279  pub fn int3(&self) -> INT3_R {
1280    INT3_R::new(((self.bits >> 3) & 0x01) != 0)
1281  }
1282  #[doc = "Bit 4 - Interrupt Request 4"]
1283  #[inline(always)]
1284  pub fn int4(&self) -> INT4_R {
1285    INT4_R::new(((self.bits >> 4) & 0x01) != 0)
1286  }
1287  #[doc = "Bit 5 - Interrupt Request 5"]
1288  #[inline(always)]
1289  pub fn int5(&self) -> INT5_R {
1290    INT5_R::new(((self.bits >> 5) & 0x01) != 0)
1291  }
1292  #[doc = "Bit 6 - Interrupt Request 6"]
1293  #[inline(always)]
1294  pub fn int6(&self) -> INT6_R {
1295    INT6_R::new(((self.bits >> 6) & 0x01) != 0)
1296  }
1297  #[doc = "Bit 7 - Interrupt Request 7"]
1298  #[inline(always)]
1299  pub fn int7(&self) -> INT7_R {
1300    INT7_R::new(((self.bits >> 7) & 0x01) != 0)
1301  }
1302  #[doc = "Bit 8 - Interrupt Request 8"]
1303  #[inline(always)]
1304  pub fn int8(&self) -> INT8_R {
1305    INT8_R::new(((self.bits >> 8) & 0x01) != 0)
1306  }
1307  #[doc = "Bit 9 - Interrupt Request 9"]
1308  #[inline(always)]
1309  pub fn int9(&self) -> INT9_R {
1310    INT9_R::new(((self.bits >> 9) & 0x01) != 0)
1311  }
1312  #[doc = "Bit 10 - Interrupt Request 10"]
1313  #[inline(always)]
1314  pub fn int10(&self) -> INT10_R {
1315    INT10_R::new(((self.bits >> 10) & 0x01) != 0)
1316  }
1317  #[doc = "Bit 11 - Interrupt Request 11"]
1318  #[inline(always)]
1319  pub fn int11(&self) -> INT11_R {
1320    INT11_R::new(((self.bits >> 11) & 0x01) != 0)
1321  }
1322  #[doc = "Bit 12 - Interrupt Request 12"]
1323  #[inline(always)]
1324  pub fn int12(&self) -> INT12_R {
1325    INT12_R::new(((self.bits >> 12) & 0x01) != 0)
1326  }
1327  #[doc = "Bit 13 - Interrupt Request 13"]
1328  #[inline(always)]
1329  pub fn int13(&self) -> INT13_R {
1330    INT13_R::new(((self.bits >> 13) & 0x01) != 0)
1331  }
1332  #[doc = "Bit 14 - Interrupt Request 14"]
1333  #[inline(always)]
1334  pub fn int14(&self) -> INT14_R {
1335    INT14_R::new(((self.bits >> 14) & 0x01) != 0)
1336  }
1337  #[doc = "Bit 15 - Interrupt Request 15"]
1338  #[inline(always)]
1339  pub fn int15(&self) -> INT15_R {
1340    INT15_R::new(((self.bits >> 15) & 0x01) != 0)
1341  }
1342}
1343impl W {
1344  #[doc = "Bit 0 - Interrupt Request 0"]
1345  #[inline(always)]
1346  pub fn int0(&mut self) -> INT0_W {
1347    INT0_W { w: self }
1348  }
1349  #[doc = "Bit 1 - Interrupt Request 1"]
1350  #[inline(always)]
1351  pub fn int1(&mut self) -> INT1_W {
1352    INT1_W { w: self }
1353  }
1354  #[doc = "Bit 2 - Interrupt Request 2"]
1355  #[inline(always)]
1356  pub fn int2(&mut self) -> INT2_W {
1357    INT2_W { w: self }
1358  }
1359  #[doc = "Bit 3 - Interrupt Request 3"]
1360  #[inline(always)]
1361  pub fn int3(&mut self) -> INT3_W {
1362    INT3_W { w: self }
1363  }
1364  #[doc = "Bit 4 - Interrupt Request 4"]
1365  #[inline(always)]
1366  pub fn int4(&mut self) -> INT4_W {
1367    INT4_W { w: self }
1368  }
1369  #[doc = "Bit 5 - Interrupt Request 5"]
1370  #[inline(always)]
1371  pub fn int5(&mut self) -> INT5_W {
1372    INT5_W { w: self }
1373  }
1374  #[doc = "Bit 6 - Interrupt Request 6"]
1375  #[inline(always)]
1376  pub fn int6(&mut self) -> INT6_W {
1377    INT6_W { w: self }
1378  }
1379  #[doc = "Bit 7 - Interrupt Request 7"]
1380  #[inline(always)]
1381  pub fn int7(&mut self) -> INT7_W {
1382    INT7_W { w: self }
1383  }
1384  #[doc = "Bit 8 - Interrupt Request 8"]
1385  #[inline(always)]
1386  pub fn int8(&mut self) -> INT8_W {
1387    INT8_W { w: self }
1388  }
1389  #[doc = "Bit 9 - Interrupt Request 9"]
1390  #[inline(always)]
1391  pub fn int9(&mut self) -> INT9_W {
1392    INT9_W { w: self }
1393  }
1394  #[doc = "Bit 10 - Interrupt Request 10"]
1395  #[inline(always)]
1396  pub fn int10(&mut self) -> INT10_W {
1397    INT10_W { w: self }
1398  }
1399  #[doc = "Bit 11 - Interrupt Request 11"]
1400  #[inline(always)]
1401  pub fn int11(&mut self) -> INT11_W {
1402    INT11_W { w: self }
1403  }
1404  #[doc = "Bit 12 - Interrupt Request 12"]
1405  #[inline(always)]
1406  pub fn int12(&mut self) -> INT12_W {
1407    INT12_W { w: self }
1408  }
1409  #[doc = "Bit 13 - Interrupt Request 13"]
1410  #[inline(always)]
1411  pub fn int13(&mut self) -> INT13_W {
1412    INT13_W { w: self }
1413  }
1414  #[doc = "Bit 14 - Interrupt Request 14"]
1415  #[inline(always)]
1416  pub fn int14(&mut self) -> INT14_W {
1417    INT14_W { w: self }
1418  }
1419  #[doc = "Bit 15 - Interrupt Request 15"]
1420  #[inline(always)]
1421  pub fn int15(&mut self) -> INT15_W {
1422    INT15_W { w: self }
1423  }
1424}
rv32m1_ri5cy_pac/dma0/int.rs

rv32m1_ri5cy_pac/dma0/
int.rs
