bl602_pac/glb/
gpio_int_stat1.rs

1#[doc = "Register `GPIO_INT_STAT1` reader"]
2pub struct R(crate::R<GPIO_INT_STAT1_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<GPIO_INT_STAT1_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<GPIO_INT_STAT1_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<GPIO_INT_STAT1_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Field `reg_gpio_0_interrupt_status` reader - Interrupt status register for GPIO0."]
17pub type REG_GPIO_0_INTERRUPT_STATUS_R = crate::BitReader<GPIO0INTERRUPT_STATUS_A>;
18#[doc = "Interrupt status register for GPIO0.\n\nValue on reset: 0"]
19#[derive(Clone, Copy, Debug, PartialEq, Eq)]
20pub enum GPIO0INTERRUPT_STATUS_A {
21    #[doc = "0: `0`"]
22    RESET = 0,
23    #[doc = "1: `1`"]
24    SET = 1,
25}
26impl From<GPIO0INTERRUPT_STATUS_A> for bool {
27    #[inline(always)]
28    fn from(variant: GPIO0INTERRUPT_STATUS_A) -> Self {
29        variant as u8 != 0
30    }
31}
32impl REG_GPIO_0_INTERRUPT_STATUS_R {
33    #[doc = "Get enumerated values variant"]
34    #[inline(always)]
35    pub fn variant(&self) -> GPIO0INTERRUPT_STATUS_A {
36        match self.bits {
37            false => GPIO0INTERRUPT_STATUS_A::RESET,
38            true => GPIO0INTERRUPT_STATUS_A::SET,
39        }
40    }
41    #[doc = "Checks if the value of the field is `RESET`"]
42    #[inline(always)]
43    pub fn is_reset(&self) -> bool {
44        *self == GPIO0INTERRUPT_STATUS_A::RESET
45    }
46    #[doc = "Checks if the value of the field is `SET`"]
47    #[inline(always)]
48    pub fn is_set(&self) -> bool {
49        *self == GPIO0INTERRUPT_STATUS_A::SET
50    }
51}
52#[doc = "Field `reg_gpio_1_interrupt_status` reader - Interrupt status register for GPIO1."]
53pub type REG_GPIO_1_INTERRUPT_STATUS_R = crate::BitReader<GPIO1INTERRUPT_STATUS_A>;
54#[doc = "Interrupt status register for GPIO1.\n\nValue on reset: 0"]
55#[derive(Clone, Copy, Debug, PartialEq, Eq)]
56pub enum GPIO1INTERRUPT_STATUS_A {
57    #[doc = "0: `0`"]
58    RESET = 0,
59    #[doc = "1: `1`"]
60    SET = 1,
61}
62impl From<GPIO1INTERRUPT_STATUS_A> for bool {
63    #[inline(always)]
64    fn from(variant: GPIO1INTERRUPT_STATUS_A) -> Self {
65        variant as u8 != 0
66    }
67}
68impl REG_GPIO_1_INTERRUPT_STATUS_R {
69    #[doc = "Get enumerated values variant"]
70    #[inline(always)]
71    pub fn variant(&self) -> GPIO1INTERRUPT_STATUS_A {
72        match self.bits {
73            false => GPIO1INTERRUPT_STATUS_A::RESET,
74            true => GPIO1INTERRUPT_STATUS_A::SET,
75        }
76    }
77    #[doc = "Checks if the value of the field is `RESET`"]
78    #[inline(always)]
79    pub fn is_reset(&self) -> bool {
80        *self == GPIO1INTERRUPT_STATUS_A::RESET
81    }
82    #[doc = "Checks if the value of the field is `SET`"]
83    #[inline(always)]
84    pub fn is_set(&self) -> bool {
85        *self == GPIO1INTERRUPT_STATUS_A::SET
86    }
87}
88#[doc = "Field `reg_gpio_2_interrupt_status` reader - Interrupt status register for GPIO2."]
89pub type REG_GPIO_2_INTERRUPT_STATUS_R = crate::BitReader<GPIO2INTERRUPT_STATUS_A>;
90#[doc = "Interrupt status register for GPIO2.\n\nValue on reset: 0"]
91#[derive(Clone, Copy, Debug, PartialEq, Eq)]
92pub enum GPIO2INTERRUPT_STATUS_A {
93    #[doc = "0: `0`"]
94    RESET = 0,
95    #[doc = "1: `1`"]
96    SET = 1,
97}
98impl From<GPIO2INTERRUPT_STATUS_A> for bool {
99    #[inline(always)]
100    fn from(variant: GPIO2INTERRUPT_STATUS_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl REG_GPIO_2_INTERRUPT_STATUS_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> GPIO2INTERRUPT_STATUS_A {
108        match self.bits {
109            false => GPIO2INTERRUPT_STATUS_A::RESET,
110            true => GPIO2INTERRUPT_STATUS_A::SET,
111        }
112    }
113    #[doc = "Checks if the value of the field is `RESET`"]
114    #[inline(always)]
115    pub fn is_reset(&self) -> bool {
116        *self == GPIO2INTERRUPT_STATUS_A::RESET
117    }
118    #[doc = "Checks if the value of the field is `SET`"]
119    #[inline(always)]
120    pub fn is_set(&self) -> bool {
121        *self == GPIO2INTERRUPT_STATUS_A::SET
122    }
123}
124#[doc = "Field `reg_gpio_3_interrupt_status` reader - Interrupt status register for GPIO3."]
125pub type REG_GPIO_3_INTERRUPT_STATUS_R = crate::BitReader<GPIO3INTERRUPT_STATUS_A>;
126#[doc = "Interrupt status register for GPIO3.\n\nValue on reset: 0"]
127#[derive(Clone, Copy, Debug, PartialEq, Eq)]
128pub enum GPIO3INTERRUPT_STATUS_A {
129    #[doc = "0: `0`"]
130    RESET = 0,
131    #[doc = "1: `1`"]
132    SET = 1,
133}
134impl From<GPIO3INTERRUPT_STATUS_A> for bool {
135    #[inline(always)]
136    fn from(variant: GPIO3INTERRUPT_STATUS_A) -> Self {
137        variant as u8 != 0
138    }
139}
140impl REG_GPIO_3_INTERRUPT_STATUS_R {
141    #[doc = "Get enumerated values variant"]
142    #[inline(always)]
143    pub fn variant(&self) -> GPIO3INTERRUPT_STATUS_A {
144        match self.bits {
145            false => GPIO3INTERRUPT_STATUS_A::RESET,
146            true => GPIO3INTERRUPT_STATUS_A::SET,
147        }
148    }
149    #[doc = "Checks if the value of the field is `RESET`"]
150    #[inline(always)]
151    pub fn is_reset(&self) -> bool {
152        *self == GPIO3INTERRUPT_STATUS_A::RESET
153    }
154    #[doc = "Checks if the value of the field is `SET`"]
155    #[inline(always)]
156    pub fn is_set(&self) -> bool {
157        *self == GPIO3INTERRUPT_STATUS_A::SET
158    }
159}
160#[doc = "Field `reg_gpio_4_interrupt_status` reader - Interrupt status register for GPIO4."]
161pub type REG_GPIO_4_INTERRUPT_STATUS_R = crate::BitReader<GPIO4INTERRUPT_STATUS_A>;
162#[doc = "Interrupt status register for GPIO4.\n\nValue on reset: 0"]
163#[derive(Clone, Copy, Debug, PartialEq, Eq)]
164pub enum GPIO4INTERRUPT_STATUS_A {
165    #[doc = "0: `0`"]
166    RESET = 0,
167    #[doc = "1: `1`"]
168    SET = 1,
169}
170impl From<GPIO4INTERRUPT_STATUS_A> for bool {
171    #[inline(always)]
172    fn from(variant: GPIO4INTERRUPT_STATUS_A) -> Self {
173        variant as u8 != 0
174    }
175}
176impl REG_GPIO_4_INTERRUPT_STATUS_R {
177    #[doc = "Get enumerated values variant"]
178    #[inline(always)]
179    pub fn variant(&self) -> GPIO4INTERRUPT_STATUS_A {
180        match self.bits {
181            false => GPIO4INTERRUPT_STATUS_A::RESET,
182            true => GPIO4INTERRUPT_STATUS_A::SET,
183        }
184    }
185    #[doc = "Checks if the value of the field is `RESET`"]
186    #[inline(always)]
187    pub fn is_reset(&self) -> bool {
188        *self == GPIO4INTERRUPT_STATUS_A::RESET
189    }
190    #[doc = "Checks if the value of the field is `SET`"]
191    #[inline(always)]
192    pub fn is_set(&self) -> bool {
193        *self == GPIO4INTERRUPT_STATUS_A::SET
194    }
195}
196#[doc = "Field `reg_gpio_5_interrupt_status` reader - Interrupt status register for GPIO5."]
197pub type REG_GPIO_5_INTERRUPT_STATUS_R = crate::BitReader<GPIO5INTERRUPT_STATUS_A>;
198#[doc = "Interrupt status register for GPIO5.\n\nValue on reset: 0"]
199#[derive(Clone, Copy, Debug, PartialEq, Eq)]
200pub enum GPIO5INTERRUPT_STATUS_A {
201    #[doc = "0: `0`"]
202    RESET = 0,
203    #[doc = "1: `1`"]
204    SET = 1,
205}
206impl From<GPIO5INTERRUPT_STATUS_A> for bool {
207    #[inline(always)]
208    fn from(variant: GPIO5INTERRUPT_STATUS_A) -> Self {
209        variant as u8 != 0
210    }
211}
212impl REG_GPIO_5_INTERRUPT_STATUS_R {
213    #[doc = "Get enumerated values variant"]
214    #[inline(always)]
215    pub fn variant(&self) -> GPIO5INTERRUPT_STATUS_A {
216        match self.bits {
217            false => GPIO5INTERRUPT_STATUS_A::RESET,
218            true => GPIO5INTERRUPT_STATUS_A::SET,
219        }
220    }
221    #[doc = "Checks if the value of the field is `RESET`"]
222    #[inline(always)]
223    pub fn is_reset(&self) -> bool {
224        *self == GPIO5INTERRUPT_STATUS_A::RESET
225    }
226    #[doc = "Checks if the value of the field is `SET`"]
227    #[inline(always)]
228    pub fn is_set(&self) -> bool {
229        *self == GPIO5INTERRUPT_STATUS_A::SET
230    }
231}
232#[doc = "Field `reg_gpio_6_interrupt_status` reader - Interrupt status register for GPIO6."]
233pub type REG_GPIO_6_INTERRUPT_STATUS_R = crate::BitReader<GPIO6INTERRUPT_STATUS_A>;
234#[doc = "Interrupt status register for GPIO6.\n\nValue on reset: 0"]
235#[derive(Clone, Copy, Debug, PartialEq, Eq)]
236pub enum GPIO6INTERRUPT_STATUS_A {
237    #[doc = "0: `0`"]
238    RESET = 0,
239    #[doc = "1: `1`"]
240    SET = 1,
241}
242impl From<GPIO6INTERRUPT_STATUS_A> for bool {
243    #[inline(always)]
244    fn from(variant: GPIO6INTERRUPT_STATUS_A) -> Self {
245        variant as u8 != 0
246    }
247}
248impl REG_GPIO_6_INTERRUPT_STATUS_R {
249    #[doc = "Get enumerated values variant"]
250    #[inline(always)]
251    pub fn variant(&self) -> GPIO6INTERRUPT_STATUS_A {
252        match self.bits {
253            false => GPIO6INTERRUPT_STATUS_A::RESET,
254            true => GPIO6INTERRUPT_STATUS_A::SET,
255        }
256    }
257    #[doc = "Checks if the value of the field is `RESET`"]
258    #[inline(always)]
259    pub fn is_reset(&self) -> bool {
260        *self == GPIO6INTERRUPT_STATUS_A::RESET
261    }
262    #[doc = "Checks if the value of the field is `SET`"]
263    #[inline(always)]
264    pub fn is_set(&self) -> bool {
265        *self == GPIO6INTERRUPT_STATUS_A::SET
266    }
267}
268#[doc = "Field `reg_gpio_7_interrupt_status` reader - Interrupt status register for GPIO7."]
269pub type REG_GPIO_7_INTERRUPT_STATUS_R = crate::BitReader<GPIO7INTERRUPT_STATUS_A>;
270#[doc = "Interrupt status register for GPIO7.\n\nValue on reset: 0"]
271#[derive(Clone, Copy, Debug, PartialEq, Eq)]
272pub enum GPIO7INTERRUPT_STATUS_A {
273    #[doc = "0: `0`"]
274    RESET = 0,
275    #[doc = "1: `1`"]
276    SET = 1,
277}
278impl From<GPIO7INTERRUPT_STATUS_A> for bool {
279    #[inline(always)]
280    fn from(variant: GPIO7INTERRUPT_STATUS_A) -> Self {
281        variant as u8 != 0
282    }
283}
284impl REG_GPIO_7_INTERRUPT_STATUS_R {
285    #[doc = "Get enumerated values variant"]
286    #[inline(always)]
287    pub fn variant(&self) -> GPIO7INTERRUPT_STATUS_A {
288        match self.bits {
289            false => GPIO7INTERRUPT_STATUS_A::RESET,
290            true => GPIO7INTERRUPT_STATUS_A::SET,
291        }
292    }
293    #[doc = "Checks if the value of the field is `RESET`"]
294    #[inline(always)]
295    pub fn is_reset(&self) -> bool {
296        *self == GPIO7INTERRUPT_STATUS_A::RESET
297    }
298    #[doc = "Checks if the value of the field is `SET`"]
299    #[inline(always)]
300    pub fn is_set(&self) -> bool {
301        *self == GPIO7INTERRUPT_STATUS_A::SET
302    }
303}
304#[doc = "Field `reg_gpio_8_interrupt_status` reader - Interrupt status register for GPIO8."]
305pub type REG_GPIO_8_INTERRUPT_STATUS_R = crate::BitReader<GPIO8INTERRUPT_STATUS_A>;
306#[doc = "Interrupt status register for GPIO8.\n\nValue on reset: 0"]
307#[derive(Clone, Copy, Debug, PartialEq, Eq)]
308pub enum GPIO8INTERRUPT_STATUS_A {
309    #[doc = "0: `0`"]
310    RESET = 0,
311    #[doc = "1: `1`"]
312    SET = 1,
313}
314impl From<GPIO8INTERRUPT_STATUS_A> for bool {
315    #[inline(always)]
316    fn from(variant: GPIO8INTERRUPT_STATUS_A) -> Self {
317        variant as u8 != 0
318    }
319}
320impl REG_GPIO_8_INTERRUPT_STATUS_R {
321    #[doc = "Get enumerated values variant"]
322    #[inline(always)]
323    pub fn variant(&self) -> GPIO8INTERRUPT_STATUS_A {
324        match self.bits {
325            false => GPIO8INTERRUPT_STATUS_A::RESET,
326            true => GPIO8INTERRUPT_STATUS_A::SET,
327        }
328    }
329    #[doc = "Checks if the value of the field is `RESET`"]
330    #[inline(always)]
331    pub fn is_reset(&self) -> bool {
332        *self == GPIO8INTERRUPT_STATUS_A::RESET
333    }
334    #[doc = "Checks if the value of the field is `SET`"]
335    #[inline(always)]
336    pub fn is_set(&self) -> bool {
337        *self == GPIO8INTERRUPT_STATUS_A::SET
338    }
339}
340#[doc = "Field `reg_gpio_9_interrupt_status` reader - Interrupt status register for GPIO9."]
341pub type REG_GPIO_9_INTERRUPT_STATUS_R = crate::BitReader<GPIO9INTERRUPT_STATUS_A>;
342#[doc = "Interrupt status register for GPIO9.\n\nValue on reset: 0"]
343#[derive(Clone, Copy, Debug, PartialEq, Eq)]
344pub enum GPIO9INTERRUPT_STATUS_A {
345    #[doc = "0: `0`"]
346    RESET = 0,
347    #[doc = "1: `1`"]
348    SET = 1,
349}
350impl From<GPIO9INTERRUPT_STATUS_A> for bool {
351    #[inline(always)]
352    fn from(variant: GPIO9INTERRUPT_STATUS_A) -> Self {
353        variant as u8 != 0
354    }
355}
356impl REG_GPIO_9_INTERRUPT_STATUS_R {
357    #[doc = "Get enumerated values variant"]
358    #[inline(always)]
359    pub fn variant(&self) -> GPIO9INTERRUPT_STATUS_A {
360        match self.bits {
361            false => GPIO9INTERRUPT_STATUS_A::RESET,
362            true => GPIO9INTERRUPT_STATUS_A::SET,
363        }
364    }
365    #[doc = "Checks if the value of the field is `RESET`"]
366    #[inline(always)]
367    pub fn is_reset(&self) -> bool {
368        *self == GPIO9INTERRUPT_STATUS_A::RESET
369    }
370    #[doc = "Checks if the value of the field is `SET`"]
371    #[inline(always)]
372    pub fn is_set(&self) -> bool {
373        *self == GPIO9INTERRUPT_STATUS_A::SET
374    }
375}
376#[doc = "Field `reg_gpio_10_interrupt_status` reader - Interrupt status register for GPIO10."]
377pub type REG_GPIO_10_INTERRUPT_STATUS_R = crate::BitReader<GPIO10INTERRUPT_STATUS_A>;
378#[doc = "Interrupt status register for GPIO10.\n\nValue on reset: 0"]
379#[derive(Clone, Copy, Debug, PartialEq, Eq)]
380pub enum GPIO10INTERRUPT_STATUS_A {
381    #[doc = "0: `0`"]
382    RESET = 0,
383    #[doc = "1: `1`"]
384    SET = 1,
385}
386impl From<GPIO10INTERRUPT_STATUS_A> for bool {
387    #[inline(always)]
388    fn from(variant: GPIO10INTERRUPT_STATUS_A) -> Self {
389        variant as u8 != 0
390    }
391}
392impl REG_GPIO_10_INTERRUPT_STATUS_R {
393    #[doc = "Get enumerated values variant"]
394    #[inline(always)]
395    pub fn variant(&self) -> GPIO10INTERRUPT_STATUS_A {
396        match self.bits {
397            false => GPIO10INTERRUPT_STATUS_A::RESET,
398            true => GPIO10INTERRUPT_STATUS_A::SET,
399        }
400    }
401    #[doc = "Checks if the value of the field is `RESET`"]
402    #[inline(always)]
403    pub fn is_reset(&self) -> bool {
404        *self == GPIO10INTERRUPT_STATUS_A::RESET
405    }
406    #[doc = "Checks if the value of the field is `SET`"]
407    #[inline(always)]
408    pub fn is_set(&self) -> bool {
409        *self == GPIO10INTERRUPT_STATUS_A::SET
410    }
411}
412#[doc = "Field `reg_gpio_11_interrupt_status` reader - Interrupt status register for GPIO11."]
413pub type REG_GPIO_11_INTERRUPT_STATUS_R = crate::BitReader<GPIO11INTERRUPT_STATUS_A>;
414#[doc = "Interrupt status register for GPIO11.\n\nValue on reset: 0"]
415#[derive(Clone, Copy, Debug, PartialEq, Eq)]
416pub enum GPIO11INTERRUPT_STATUS_A {
417    #[doc = "0: `0`"]
418    RESET = 0,
419    #[doc = "1: `1`"]
420    SET = 1,
421}
422impl From<GPIO11INTERRUPT_STATUS_A> for bool {
423    #[inline(always)]
424    fn from(variant: GPIO11INTERRUPT_STATUS_A) -> Self {
425        variant as u8 != 0
426    }
427}
428impl REG_GPIO_11_INTERRUPT_STATUS_R {
429    #[doc = "Get enumerated values variant"]
430    #[inline(always)]
431    pub fn variant(&self) -> GPIO11INTERRUPT_STATUS_A {
432        match self.bits {
433            false => GPIO11INTERRUPT_STATUS_A::RESET,
434            true => GPIO11INTERRUPT_STATUS_A::SET,
435        }
436    }
437    #[doc = "Checks if the value of the field is `RESET`"]
438    #[inline(always)]
439    pub fn is_reset(&self) -> bool {
440        *self == GPIO11INTERRUPT_STATUS_A::RESET
441    }
442    #[doc = "Checks if the value of the field is `SET`"]
443    #[inline(always)]
444    pub fn is_set(&self) -> bool {
445        *self == GPIO11INTERRUPT_STATUS_A::SET
446    }
447}
448#[doc = "Field `reg_gpio_12_interrupt_status` reader - Interrupt status register for GPIO12."]
449pub type REG_GPIO_12_INTERRUPT_STATUS_R = crate::BitReader<GPIO12INTERRUPT_STATUS_A>;
450#[doc = "Interrupt status register for GPIO12.\n\nValue on reset: 0"]
451#[derive(Clone, Copy, Debug, PartialEq, Eq)]
452pub enum GPIO12INTERRUPT_STATUS_A {
453    #[doc = "0: `0`"]
454    RESET = 0,
455    #[doc = "1: `1`"]
456    SET = 1,
457}
458impl From<GPIO12INTERRUPT_STATUS_A> for bool {
459    #[inline(always)]
460    fn from(variant: GPIO12INTERRUPT_STATUS_A) -> Self {
461        variant as u8 != 0
462    }
463}
464impl REG_GPIO_12_INTERRUPT_STATUS_R {
465    #[doc = "Get enumerated values variant"]
466    #[inline(always)]
467    pub fn variant(&self) -> GPIO12INTERRUPT_STATUS_A {
468        match self.bits {
469            false => GPIO12INTERRUPT_STATUS_A::RESET,
470            true => GPIO12INTERRUPT_STATUS_A::SET,
471        }
472    }
473    #[doc = "Checks if the value of the field is `RESET`"]
474    #[inline(always)]
475    pub fn is_reset(&self) -> bool {
476        *self == GPIO12INTERRUPT_STATUS_A::RESET
477    }
478    #[doc = "Checks if the value of the field is `SET`"]
479    #[inline(always)]
480    pub fn is_set(&self) -> bool {
481        *self == GPIO12INTERRUPT_STATUS_A::SET
482    }
483}
484#[doc = "Field `reg_gpio_13_interrupt_status` reader - Interrupt status register for GPIO13."]
485pub type REG_GPIO_13_INTERRUPT_STATUS_R = crate::BitReader<GPIO13INTERRUPT_STATUS_A>;
486#[doc = "Interrupt status register for GPIO13.\n\nValue on reset: 0"]
487#[derive(Clone, Copy, Debug, PartialEq, Eq)]
488pub enum GPIO13INTERRUPT_STATUS_A {
489    #[doc = "0: `0`"]
490    RESET = 0,
491    #[doc = "1: `1`"]
492    SET = 1,
493}
494impl From<GPIO13INTERRUPT_STATUS_A> for bool {
495    #[inline(always)]
496    fn from(variant: GPIO13INTERRUPT_STATUS_A) -> Self {
497        variant as u8 != 0
498    }
499}
500impl REG_GPIO_13_INTERRUPT_STATUS_R {
501    #[doc = "Get enumerated values variant"]
502    #[inline(always)]
503    pub fn variant(&self) -> GPIO13INTERRUPT_STATUS_A {
504        match self.bits {
505            false => GPIO13INTERRUPT_STATUS_A::RESET,
506            true => GPIO13INTERRUPT_STATUS_A::SET,
507        }
508    }
509    #[doc = "Checks if the value of the field is `RESET`"]
510    #[inline(always)]
511    pub fn is_reset(&self) -> bool {
512        *self == GPIO13INTERRUPT_STATUS_A::RESET
513    }
514    #[doc = "Checks if the value of the field is `SET`"]
515    #[inline(always)]
516    pub fn is_set(&self) -> bool {
517        *self == GPIO13INTERRUPT_STATUS_A::SET
518    }
519}
520#[doc = "Field `reg_gpio_14_interrupt_status` reader - Interrupt status register for GPIO14."]
521pub type REG_GPIO_14_INTERRUPT_STATUS_R = crate::BitReader<GPIO14INTERRUPT_STATUS_A>;
522#[doc = "Interrupt status register for GPIO14.\n\nValue on reset: 0"]
523#[derive(Clone, Copy, Debug, PartialEq, Eq)]
524pub enum GPIO14INTERRUPT_STATUS_A {
525    #[doc = "0: `0`"]
526    RESET = 0,
527    #[doc = "1: `1`"]
528    SET = 1,
529}
530impl From<GPIO14INTERRUPT_STATUS_A> for bool {
531    #[inline(always)]
532    fn from(variant: GPIO14INTERRUPT_STATUS_A) -> Self {
533        variant as u8 != 0
534    }
535}
536impl REG_GPIO_14_INTERRUPT_STATUS_R {
537    #[doc = "Get enumerated values variant"]
538    #[inline(always)]
539    pub fn variant(&self) -> GPIO14INTERRUPT_STATUS_A {
540        match self.bits {
541            false => GPIO14INTERRUPT_STATUS_A::RESET,
542            true => GPIO14INTERRUPT_STATUS_A::SET,
543        }
544    }
545    #[doc = "Checks if the value of the field is `RESET`"]
546    #[inline(always)]
547    pub fn is_reset(&self) -> bool {
548        *self == GPIO14INTERRUPT_STATUS_A::RESET
549    }
550    #[doc = "Checks if the value of the field is `SET`"]
551    #[inline(always)]
552    pub fn is_set(&self) -> bool {
553        *self == GPIO14INTERRUPT_STATUS_A::SET
554    }
555}
556#[doc = "Field `reg_gpio_15_interrupt_status` reader - Interrupt status register for GPIO15."]
557pub type REG_GPIO_15_INTERRUPT_STATUS_R = crate::BitReader<GPIO15INTERRUPT_STATUS_A>;
558#[doc = "Interrupt status register for GPIO15.\n\nValue on reset: 0"]
559#[derive(Clone, Copy, Debug, PartialEq, Eq)]
560pub enum GPIO15INTERRUPT_STATUS_A {
561    #[doc = "0: `0`"]
562    RESET = 0,
563    #[doc = "1: `1`"]
564    SET = 1,
565}
566impl From<GPIO15INTERRUPT_STATUS_A> for bool {
567    #[inline(always)]
568    fn from(variant: GPIO15INTERRUPT_STATUS_A) -> Self {
569        variant as u8 != 0
570    }
571}
572impl REG_GPIO_15_INTERRUPT_STATUS_R {
573    #[doc = "Get enumerated values variant"]
574    #[inline(always)]
575    pub fn variant(&self) -> GPIO15INTERRUPT_STATUS_A {
576        match self.bits {
577            false => GPIO15INTERRUPT_STATUS_A::RESET,
578            true => GPIO15INTERRUPT_STATUS_A::SET,
579        }
580    }
581    #[doc = "Checks if the value of the field is `RESET`"]
582    #[inline(always)]
583    pub fn is_reset(&self) -> bool {
584        *self == GPIO15INTERRUPT_STATUS_A::RESET
585    }
586    #[doc = "Checks if the value of the field is `SET`"]
587    #[inline(always)]
588    pub fn is_set(&self) -> bool {
589        *self == GPIO15INTERRUPT_STATUS_A::SET
590    }
591}
592#[doc = "Field `reg_gpio_16_interrupt_status` reader - Interrupt status register for GPIO16."]
593pub type REG_GPIO_16_INTERRUPT_STATUS_R = crate::BitReader<GPIO16INTERRUPT_STATUS_A>;
594#[doc = "Interrupt status register for GPIO16.\n\nValue on reset: 0"]
595#[derive(Clone, Copy, Debug, PartialEq, Eq)]
596pub enum GPIO16INTERRUPT_STATUS_A {
597    #[doc = "0: `0`"]
598    RESET = 0,
599    #[doc = "1: `1`"]
600    SET = 1,
601}
602impl From<GPIO16INTERRUPT_STATUS_A> for bool {
603    #[inline(always)]
604    fn from(variant: GPIO16INTERRUPT_STATUS_A) -> Self {
605        variant as u8 != 0
606    }
607}
608impl REG_GPIO_16_INTERRUPT_STATUS_R {
609    #[doc = "Get enumerated values variant"]
610    #[inline(always)]
611    pub fn variant(&self) -> GPIO16INTERRUPT_STATUS_A {
612        match self.bits {
613            false => GPIO16INTERRUPT_STATUS_A::RESET,
614            true => GPIO16INTERRUPT_STATUS_A::SET,
615        }
616    }
617    #[doc = "Checks if the value of the field is `RESET`"]
618    #[inline(always)]
619    pub fn is_reset(&self) -> bool {
620        *self == GPIO16INTERRUPT_STATUS_A::RESET
621    }
622    #[doc = "Checks if the value of the field is `SET`"]
623    #[inline(always)]
624    pub fn is_set(&self) -> bool {
625        *self == GPIO16INTERRUPT_STATUS_A::SET
626    }
627}
628#[doc = "Field `reg_gpio_17_interrupt_status` reader - Interrupt status register for GPIO17."]
629pub type REG_GPIO_17_INTERRUPT_STATUS_R = crate::BitReader<GPIO17INTERRUPT_STATUS_A>;
630#[doc = "Interrupt status register for GPIO17.\n\nValue on reset: 0"]
631#[derive(Clone, Copy, Debug, PartialEq, Eq)]
632pub enum GPIO17INTERRUPT_STATUS_A {
633    #[doc = "0: `0`"]
634    RESET = 0,
635    #[doc = "1: `1`"]
636    SET = 1,
637}
638impl From<GPIO17INTERRUPT_STATUS_A> for bool {
639    #[inline(always)]
640    fn from(variant: GPIO17INTERRUPT_STATUS_A) -> Self {
641        variant as u8 != 0
642    }
643}
644impl REG_GPIO_17_INTERRUPT_STATUS_R {
645    #[doc = "Get enumerated values variant"]
646    #[inline(always)]
647    pub fn variant(&self) -> GPIO17INTERRUPT_STATUS_A {
648        match self.bits {
649            false => GPIO17INTERRUPT_STATUS_A::RESET,
650            true => GPIO17INTERRUPT_STATUS_A::SET,
651        }
652    }
653    #[doc = "Checks if the value of the field is `RESET`"]
654    #[inline(always)]
655    pub fn is_reset(&self) -> bool {
656        *self == GPIO17INTERRUPT_STATUS_A::RESET
657    }
658    #[doc = "Checks if the value of the field is `SET`"]
659    #[inline(always)]
660    pub fn is_set(&self) -> bool {
661        *self == GPIO17INTERRUPT_STATUS_A::SET
662    }
663}
664#[doc = "Field `reg_gpio_18_interrupt_status` reader - Interrupt status register for GPIO18."]
665pub type REG_GPIO_18_INTERRUPT_STATUS_R = crate::BitReader<GPIO18INTERRUPT_STATUS_A>;
666#[doc = "Interrupt status register for GPIO18.\n\nValue on reset: 0"]
667#[derive(Clone, Copy, Debug, PartialEq, Eq)]
668pub enum GPIO18INTERRUPT_STATUS_A {
669    #[doc = "0: `0`"]
670    RESET = 0,
671    #[doc = "1: `1`"]
672    SET = 1,
673}
674impl From<GPIO18INTERRUPT_STATUS_A> for bool {
675    #[inline(always)]
676    fn from(variant: GPIO18INTERRUPT_STATUS_A) -> Self {
677        variant as u8 != 0
678    }
679}
680impl REG_GPIO_18_INTERRUPT_STATUS_R {
681    #[doc = "Get enumerated values variant"]
682    #[inline(always)]
683    pub fn variant(&self) -> GPIO18INTERRUPT_STATUS_A {
684        match self.bits {
685            false => GPIO18INTERRUPT_STATUS_A::RESET,
686            true => GPIO18INTERRUPT_STATUS_A::SET,
687        }
688    }
689    #[doc = "Checks if the value of the field is `RESET`"]
690    #[inline(always)]
691    pub fn is_reset(&self) -> bool {
692        *self == GPIO18INTERRUPT_STATUS_A::RESET
693    }
694    #[doc = "Checks if the value of the field is `SET`"]
695    #[inline(always)]
696    pub fn is_set(&self) -> bool {
697        *self == GPIO18INTERRUPT_STATUS_A::SET
698    }
699}
700#[doc = "Field `reg_gpio_19_interrupt_status` reader - Interrupt status register for GPIO19."]
701pub type REG_GPIO_19_INTERRUPT_STATUS_R = crate::BitReader<GPIO19INTERRUPT_STATUS_A>;
702#[doc = "Interrupt status register for GPIO19.\n\nValue on reset: 0"]
703#[derive(Clone, Copy, Debug, PartialEq, Eq)]
704pub enum GPIO19INTERRUPT_STATUS_A {
705    #[doc = "0: `0`"]
706    RESET = 0,
707    #[doc = "1: `1`"]
708    SET = 1,
709}
710impl From<GPIO19INTERRUPT_STATUS_A> for bool {
711    #[inline(always)]
712    fn from(variant: GPIO19INTERRUPT_STATUS_A) -> Self {
713        variant as u8 != 0
714    }
715}
716impl REG_GPIO_19_INTERRUPT_STATUS_R {
717    #[doc = "Get enumerated values variant"]
718    #[inline(always)]
719    pub fn variant(&self) -> GPIO19INTERRUPT_STATUS_A {
720        match self.bits {
721            false => GPIO19INTERRUPT_STATUS_A::RESET,
722            true => GPIO19INTERRUPT_STATUS_A::SET,
723        }
724    }
725    #[doc = "Checks if the value of the field is `RESET`"]
726    #[inline(always)]
727    pub fn is_reset(&self) -> bool {
728        *self == GPIO19INTERRUPT_STATUS_A::RESET
729    }
730    #[doc = "Checks if the value of the field is `SET`"]
731    #[inline(always)]
732    pub fn is_set(&self) -> bool {
733        *self == GPIO19INTERRUPT_STATUS_A::SET
734    }
735}
736#[doc = "Field `reg_gpio_20_interrupt_status` reader - Interrupt status register for GPIO20."]
737pub type REG_GPIO_20_INTERRUPT_STATUS_R = crate::BitReader<GPIO20INTERRUPT_STATUS_A>;
738#[doc = "Interrupt status register for GPIO20.\n\nValue on reset: 0"]
739#[derive(Clone, Copy, Debug, PartialEq, Eq)]
740pub enum GPIO20INTERRUPT_STATUS_A {
741    #[doc = "0: `0`"]
742    RESET = 0,
743    #[doc = "1: `1`"]
744    SET = 1,
745}
746impl From<GPIO20INTERRUPT_STATUS_A> for bool {
747    #[inline(always)]
748    fn from(variant: GPIO20INTERRUPT_STATUS_A) -> Self {
749        variant as u8 != 0
750    }
751}
752impl REG_GPIO_20_INTERRUPT_STATUS_R {
753    #[doc = "Get enumerated values variant"]
754    #[inline(always)]
755    pub fn variant(&self) -> GPIO20INTERRUPT_STATUS_A {
756        match self.bits {
757            false => GPIO20INTERRUPT_STATUS_A::RESET,
758            true => GPIO20INTERRUPT_STATUS_A::SET,
759        }
760    }
761    #[doc = "Checks if the value of the field is `RESET`"]
762    #[inline(always)]
763    pub fn is_reset(&self) -> bool {
764        *self == GPIO20INTERRUPT_STATUS_A::RESET
765    }
766    #[doc = "Checks if the value of the field is `SET`"]
767    #[inline(always)]
768    pub fn is_set(&self) -> bool {
769        *self == GPIO20INTERRUPT_STATUS_A::SET
770    }
771}
772#[doc = "Field `reg_gpio_21_interrupt_status` reader - Interrupt status register for GPIO21."]
773pub type REG_GPIO_21_INTERRUPT_STATUS_R = crate::BitReader<GPIO21INTERRUPT_STATUS_A>;
774#[doc = "Interrupt status register for GPIO21.\n\nValue on reset: 0"]
775#[derive(Clone, Copy, Debug, PartialEq, Eq)]
776pub enum GPIO21INTERRUPT_STATUS_A {
777    #[doc = "0: `0`"]
778    RESET = 0,
779    #[doc = "1: `1`"]
780    SET = 1,
781}
782impl From<GPIO21INTERRUPT_STATUS_A> for bool {
783    #[inline(always)]
784    fn from(variant: GPIO21INTERRUPT_STATUS_A) -> Self {
785        variant as u8 != 0
786    }
787}
788impl REG_GPIO_21_INTERRUPT_STATUS_R {
789    #[doc = "Get enumerated values variant"]
790    #[inline(always)]
791    pub fn variant(&self) -> GPIO21INTERRUPT_STATUS_A {
792        match self.bits {
793            false => GPIO21INTERRUPT_STATUS_A::RESET,
794            true => GPIO21INTERRUPT_STATUS_A::SET,
795        }
796    }
797    #[doc = "Checks if the value of the field is `RESET`"]
798    #[inline(always)]
799    pub fn is_reset(&self) -> bool {
800        *self == GPIO21INTERRUPT_STATUS_A::RESET
801    }
802    #[doc = "Checks if the value of the field is `SET`"]
803    #[inline(always)]
804    pub fn is_set(&self) -> bool {
805        *self == GPIO21INTERRUPT_STATUS_A::SET
806    }
807}
808#[doc = "Field `reg_gpio_22_interrupt_status` reader - Interrupt status register for GPIO22."]
809pub type REG_GPIO_22_INTERRUPT_STATUS_R = crate::BitReader<GPIO22INTERRUPT_STATUS_A>;
810#[doc = "Interrupt status register for GPIO22.\n\nValue on reset: 0"]
811#[derive(Clone, Copy, Debug, PartialEq, Eq)]
812pub enum GPIO22INTERRUPT_STATUS_A {
813    #[doc = "0: `0`"]
814    RESET = 0,
815    #[doc = "1: `1`"]
816    SET = 1,
817}
818impl From<GPIO22INTERRUPT_STATUS_A> for bool {
819    #[inline(always)]
820    fn from(variant: GPIO22INTERRUPT_STATUS_A) -> Self {
821        variant as u8 != 0
822    }
823}
824impl REG_GPIO_22_INTERRUPT_STATUS_R {
825    #[doc = "Get enumerated values variant"]
826    #[inline(always)]
827    pub fn variant(&self) -> GPIO22INTERRUPT_STATUS_A {
828        match self.bits {
829            false => GPIO22INTERRUPT_STATUS_A::RESET,
830            true => GPIO22INTERRUPT_STATUS_A::SET,
831        }
832    }
833    #[doc = "Checks if the value of the field is `RESET`"]
834    #[inline(always)]
835    pub fn is_reset(&self) -> bool {
836        *self == GPIO22INTERRUPT_STATUS_A::RESET
837    }
838    #[doc = "Checks if the value of the field is `SET`"]
839    #[inline(always)]
840    pub fn is_set(&self) -> bool {
841        *self == GPIO22INTERRUPT_STATUS_A::SET
842    }
843}
844#[doc = "Field `reg_gpio_23_interrupt_status` reader - Interrupt status register for GPIO23."]
845pub type REG_GPIO_23_INTERRUPT_STATUS_R = crate::BitReader<GPIO23INTERRUPT_STATUS_A>;
846#[doc = "Interrupt status register for GPIO23.\n\nValue on reset: 0"]
847#[derive(Clone, Copy, Debug, PartialEq, Eq)]
848pub enum GPIO23INTERRUPT_STATUS_A {
849    #[doc = "0: `0`"]
850    RESET = 0,
851    #[doc = "1: `1`"]
852    SET = 1,
853}
854impl From<GPIO23INTERRUPT_STATUS_A> for bool {
855    #[inline(always)]
856    fn from(variant: GPIO23INTERRUPT_STATUS_A) -> Self {
857        variant as u8 != 0
858    }
859}
860impl REG_GPIO_23_INTERRUPT_STATUS_R {
861    #[doc = "Get enumerated values variant"]
862    #[inline(always)]
863    pub fn variant(&self) -> GPIO23INTERRUPT_STATUS_A {
864        match self.bits {
865            false => GPIO23INTERRUPT_STATUS_A::RESET,
866            true => GPIO23INTERRUPT_STATUS_A::SET,
867        }
868    }
869    #[doc = "Checks if the value of the field is `RESET`"]
870    #[inline(always)]
871    pub fn is_reset(&self) -> bool {
872        *self == GPIO23INTERRUPT_STATUS_A::RESET
873    }
874    #[doc = "Checks if the value of the field is `SET`"]
875    #[inline(always)]
876    pub fn is_set(&self) -> bool {
877        *self == GPIO23INTERRUPT_STATUS_A::SET
878    }
879}
880#[doc = "Field `reg_gpio_24_interrupt_status` reader - Interrupt status register for GPIO24."]
881pub type REG_GPIO_24_INTERRUPT_STATUS_R = crate::BitReader<GPIO24INTERRUPT_STATUS_A>;
882#[doc = "Interrupt status register for GPIO24.\n\nValue on reset: 0"]
883#[derive(Clone, Copy, Debug, PartialEq, Eq)]
884pub enum GPIO24INTERRUPT_STATUS_A {
885    #[doc = "0: `0`"]
886    RESET = 0,
887    #[doc = "1: `1`"]
888    SET = 1,
889}
890impl From<GPIO24INTERRUPT_STATUS_A> for bool {
891    #[inline(always)]
892    fn from(variant: GPIO24INTERRUPT_STATUS_A) -> Self {
893        variant as u8 != 0
894    }
895}
896impl REG_GPIO_24_INTERRUPT_STATUS_R {
897    #[doc = "Get enumerated values variant"]
898    #[inline(always)]
899    pub fn variant(&self) -> GPIO24INTERRUPT_STATUS_A {
900        match self.bits {
901            false => GPIO24INTERRUPT_STATUS_A::RESET,
902            true => GPIO24INTERRUPT_STATUS_A::SET,
903        }
904    }
905    #[doc = "Checks if the value of the field is `RESET`"]
906    #[inline(always)]
907    pub fn is_reset(&self) -> bool {
908        *self == GPIO24INTERRUPT_STATUS_A::RESET
909    }
910    #[doc = "Checks if the value of the field is `SET`"]
911    #[inline(always)]
912    pub fn is_set(&self) -> bool {
913        *self == GPIO24INTERRUPT_STATUS_A::SET
914    }
915}
916#[doc = "Field `reg_gpio_25_interrupt_status` reader - Interrupt status register for GPIO25."]
917pub type REG_GPIO_25_INTERRUPT_STATUS_R = crate::BitReader<GPIO25INTERRUPT_STATUS_A>;
918#[doc = "Interrupt status register for GPIO25.\n\nValue on reset: 0"]
919#[derive(Clone, Copy, Debug, PartialEq, Eq)]
920pub enum GPIO25INTERRUPT_STATUS_A {
921    #[doc = "0: `0`"]
922    RESET = 0,
923    #[doc = "1: `1`"]
924    SET = 1,
925}
926impl From<GPIO25INTERRUPT_STATUS_A> for bool {
927    #[inline(always)]
928    fn from(variant: GPIO25INTERRUPT_STATUS_A) -> Self {
929        variant as u8 != 0
930    }
931}
932impl REG_GPIO_25_INTERRUPT_STATUS_R {
933    #[doc = "Get enumerated values variant"]
934    #[inline(always)]
935    pub fn variant(&self) -> GPIO25INTERRUPT_STATUS_A {
936        match self.bits {
937            false => GPIO25INTERRUPT_STATUS_A::RESET,
938            true => GPIO25INTERRUPT_STATUS_A::SET,
939        }
940    }
941    #[doc = "Checks if the value of the field is `RESET`"]
942    #[inline(always)]
943    pub fn is_reset(&self) -> bool {
944        *self == GPIO25INTERRUPT_STATUS_A::RESET
945    }
946    #[doc = "Checks if the value of the field is `SET`"]
947    #[inline(always)]
948    pub fn is_set(&self) -> bool {
949        *self == GPIO25INTERRUPT_STATUS_A::SET
950    }
951}
952#[doc = "Field `reg_gpio_26_interrupt_status` reader - Interrupt status register for GPIO26."]
953pub type REG_GPIO_26_INTERRUPT_STATUS_R = crate::BitReader<GPIO26INTERRUPT_STATUS_A>;
954#[doc = "Interrupt status register for GPIO26.\n\nValue on reset: 0"]
955#[derive(Clone, Copy, Debug, PartialEq, Eq)]
956pub enum GPIO26INTERRUPT_STATUS_A {
957    #[doc = "0: `0`"]
958    RESET = 0,
959    #[doc = "1: `1`"]
960    SET = 1,
961}
962impl From<GPIO26INTERRUPT_STATUS_A> for bool {
963    #[inline(always)]
964    fn from(variant: GPIO26INTERRUPT_STATUS_A) -> Self {
965        variant as u8 != 0
966    }
967}
968impl REG_GPIO_26_INTERRUPT_STATUS_R {
969    #[doc = "Get enumerated values variant"]
970    #[inline(always)]
971    pub fn variant(&self) -> GPIO26INTERRUPT_STATUS_A {
972        match self.bits {
973            false => GPIO26INTERRUPT_STATUS_A::RESET,
974            true => GPIO26INTERRUPT_STATUS_A::SET,
975        }
976    }
977    #[doc = "Checks if the value of the field is `RESET`"]
978    #[inline(always)]
979    pub fn is_reset(&self) -> bool {
980        *self == GPIO26INTERRUPT_STATUS_A::RESET
981    }
982    #[doc = "Checks if the value of the field is `SET`"]
983    #[inline(always)]
984    pub fn is_set(&self) -> bool {
985        *self == GPIO26INTERRUPT_STATUS_A::SET
986    }
987}
988#[doc = "Field `reg_gpio_27_interrupt_status` reader - Interrupt status register for GPIO27."]
989pub type REG_GPIO_27_INTERRUPT_STATUS_R = crate::BitReader<GPIO27INTERRUPT_STATUS_A>;
990#[doc = "Interrupt status register for GPIO27.\n\nValue on reset: 0"]
991#[derive(Clone, Copy, Debug, PartialEq, Eq)]
992pub enum GPIO27INTERRUPT_STATUS_A {
993    #[doc = "0: `0`"]
994    RESET = 0,
995    #[doc = "1: `1`"]
996    SET = 1,
997}
998impl From<GPIO27INTERRUPT_STATUS_A> for bool {
999    #[inline(always)]
1000    fn from(variant: GPIO27INTERRUPT_STATUS_A) -> Self {
1001        variant as u8 != 0
1002    }
1003}
1004impl REG_GPIO_27_INTERRUPT_STATUS_R {
1005    #[doc = "Get enumerated values variant"]
1006    #[inline(always)]
1007    pub fn variant(&self) -> GPIO27INTERRUPT_STATUS_A {
1008        match self.bits {
1009            false => GPIO27INTERRUPT_STATUS_A::RESET,
1010            true => GPIO27INTERRUPT_STATUS_A::SET,
1011        }
1012    }
1013    #[doc = "Checks if the value of the field is `RESET`"]
1014    #[inline(always)]
1015    pub fn is_reset(&self) -> bool {
1016        *self == GPIO27INTERRUPT_STATUS_A::RESET
1017    }
1018    #[doc = "Checks if the value of the field is `SET`"]
1019    #[inline(always)]
1020    pub fn is_set(&self) -> bool {
1021        *self == GPIO27INTERRUPT_STATUS_A::SET
1022    }
1023}
1024#[doc = "Field `reg_gpio_28_interrupt_status` reader - Interrupt status register for GPIO28."]
1025pub type REG_GPIO_28_INTERRUPT_STATUS_R = crate::BitReader<GPIO28INTERRUPT_STATUS_A>;
1026#[doc = "Interrupt status register for GPIO28.\n\nValue on reset: 0"]
1027#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1028pub enum GPIO28INTERRUPT_STATUS_A {
1029    #[doc = "0: `0`"]
1030    RESET = 0,
1031    #[doc = "1: `1`"]
1032    SET = 1,
1033}
1034impl From<GPIO28INTERRUPT_STATUS_A> for bool {
1035    #[inline(always)]
1036    fn from(variant: GPIO28INTERRUPT_STATUS_A) -> Self {
1037        variant as u8 != 0
1038    }
1039}
1040impl REG_GPIO_28_INTERRUPT_STATUS_R {
1041    #[doc = "Get enumerated values variant"]
1042    #[inline(always)]
1043    pub fn variant(&self) -> GPIO28INTERRUPT_STATUS_A {
1044        match self.bits {
1045            false => GPIO28INTERRUPT_STATUS_A::RESET,
1046            true => GPIO28INTERRUPT_STATUS_A::SET,
1047        }
1048    }
1049    #[doc = "Checks if the value of the field is `RESET`"]
1050    #[inline(always)]
1051    pub fn is_reset(&self) -> bool {
1052        *self == GPIO28INTERRUPT_STATUS_A::RESET
1053    }
1054    #[doc = "Checks if the value of the field is `SET`"]
1055    #[inline(always)]
1056    pub fn is_set(&self) -> bool {
1057        *self == GPIO28INTERRUPT_STATUS_A::SET
1058    }
1059}
1060impl R {
1061    #[doc = "Bit 0 - Interrupt status register for GPIO0."]
1062    #[inline(always)]
1063    pub fn reg_gpio_0_interrupt_status(&self) -> REG_GPIO_0_INTERRUPT_STATUS_R {
1064        REG_GPIO_0_INTERRUPT_STATUS_R::new((self.bits & 1) != 0)
1065    }
1066    #[doc = "Bit 1 - Interrupt status register for GPIO1."]
1067    #[inline(always)]
1068    pub fn reg_gpio_1_interrupt_status(&self) -> REG_GPIO_1_INTERRUPT_STATUS_R {
1069        REG_GPIO_1_INTERRUPT_STATUS_R::new(((self.bits >> 1) & 1) != 0)
1070    }
1071    #[doc = "Bit 2 - Interrupt status register for GPIO2."]
1072    #[inline(always)]
1073    pub fn reg_gpio_2_interrupt_status(&self) -> REG_GPIO_2_INTERRUPT_STATUS_R {
1074        REG_GPIO_2_INTERRUPT_STATUS_R::new(((self.bits >> 2) & 1) != 0)
1075    }
1076    #[doc = "Bit 3 - Interrupt status register for GPIO3."]
1077    #[inline(always)]
1078    pub fn reg_gpio_3_interrupt_status(&self) -> REG_GPIO_3_INTERRUPT_STATUS_R {
1079        REG_GPIO_3_INTERRUPT_STATUS_R::new(((self.bits >> 3) & 1) != 0)
1080    }
1081    #[doc = "Bit 4 - Interrupt status register for GPIO4."]
1082    #[inline(always)]
1083    pub fn reg_gpio_4_interrupt_status(&self) -> REG_GPIO_4_INTERRUPT_STATUS_R {
1084        REG_GPIO_4_INTERRUPT_STATUS_R::new(((self.bits >> 4) & 1) != 0)
1085    }
1086    #[doc = "Bit 5 - Interrupt status register for GPIO5."]
1087    #[inline(always)]
1088    pub fn reg_gpio_5_interrupt_status(&self) -> REG_GPIO_5_INTERRUPT_STATUS_R {
1089        REG_GPIO_5_INTERRUPT_STATUS_R::new(((self.bits >> 5) & 1) != 0)
1090    }
1091    #[doc = "Bit 6 - Interrupt status register for GPIO6."]
1092    #[inline(always)]
1093    pub fn reg_gpio_6_interrupt_status(&self) -> REG_GPIO_6_INTERRUPT_STATUS_R {
1094        REG_GPIO_6_INTERRUPT_STATUS_R::new(((self.bits >> 6) & 1) != 0)
1095    }
1096    #[doc = "Bit 7 - Interrupt status register for GPIO7."]
1097    #[inline(always)]
1098    pub fn reg_gpio_7_interrupt_status(&self) -> REG_GPIO_7_INTERRUPT_STATUS_R {
1099        REG_GPIO_7_INTERRUPT_STATUS_R::new(((self.bits >> 7) & 1) != 0)
1100    }
1101    #[doc = "Bit 8 - Interrupt status register for GPIO8."]
1102    #[inline(always)]
1103    pub fn reg_gpio_8_interrupt_status(&self) -> REG_GPIO_8_INTERRUPT_STATUS_R {
1104        REG_GPIO_8_INTERRUPT_STATUS_R::new(((self.bits >> 8) & 1) != 0)
1105    }
1106    #[doc = "Bit 9 - Interrupt status register for GPIO9."]
1107    #[inline(always)]
1108    pub fn reg_gpio_9_interrupt_status(&self) -> REG_GPIO_9_INTERRUPT_STATUS_R {
1109        REG_GPIO_9_INTERRUPT_STATUS_R::new(((self.bits >> 9) & 1) != 0)
1110    }
1111    #[doc = "Bit 10 - Interrupt status register for GPIO10."]
1112    #[inline(always)]
1113    pub fn reg_gpio_10_interrupt_status(&self) -> REG_GPIO_10_INTERRUPT_STATUS_R {
1114        REG_GPIO_10_INTERRUPT_STATUS_R::new(((self.bits >> 10) & 1) != 0)
1115    }
1116    #[doc = "Bit 11 - Interrupt status register for GPIO11."]
1117    #[inline(always)]
1118    pub fn reg_gpio_11_interrupt_status(&self) -> REG_GPIO_11_INTERRUPT_STATUS_R {
1119        REG_GPIO_11_INTERRUPT_STATUS_R::new(((self.bits >> 11) & 1) != 0)
1120    }
1121    #[doc = "Bit 12 - Interrupt status register for GPIO12."]
1122    #[inline(always)]
1123    pub fn reg_gpio_12_interrupt_status(&self) -> REG_GPIO_12_INTERRUPT_STATUS_R {
1124        REG_GPIO_12_INTERRUPT_STATUS_R::new(((self.bits >> 12) & 1) != 0)
1125    }
1126    #[doc = "Bit 13 - Interrupt status register for GPIO13."]
1127    #[inline(always)]
1128    pub fn reg_gpio_13_interrupt_status(&self) -> REG_GPIO_13_INTERRUPT_STATUS_R {
1129        REG_GPIO_13_INTERRUPT_STATUS_R::new(((self.bits >> 13) & 1) != 0)
1130    }
1131    #[doc = "Bit 14 - Interrupt status register for GPIO14."]
1132    #[inline(always)]
1133    pub fn reg_gpio_14_interrupt_status(&self) -> REG_GPIO_14_INTERRUPT_STATUS_R {
1134        REG_GPIO_14_INTERRUPT_STATUS_R::new(((self.bits >> 14) & 1) != 0)
1135    }
1136    #[doc = "Bit 15 - Interrupt status register for GPIO15."]
1137    #[inline(always)]
1138    pub fn reg_gpio_15_interrupt_status(&self) -> REG_GPIO_15_INTERRUPT_STATUS_R {
1139        REG_GPIO_15_INTERRUPT_STATUS_R::new(((self.bits >> 15) & 1) != 0)
1140    }
1141    #[doc = "Bit 16 - Interrupt status register for GPIO16."]
1142    #[inline(always)]
1143    pub fn reg_gpio_16_interrupt_status(&self) -> REG_GPIO_16_INTERRUPT_STATUS_R {
1144        REG_GPIO_16_INTERRUPT_STATUS_R::new(((self.bits >> 16) & 1) != 0)
1145    }
1146    #[doc = "Bit 17 - Interrupt status register for GPIO17."]
1147    #[inline(always)]
1148    pub fn reg_gpio_17_interrupt_status(&self) -> REG_GPIO_17_INTERRUPT_STATUS_R {
1149        REG_GPIO_17_INTERRUPT_STATUS_R::new(((self.bits >> 17) & 1) != 0)
1150    }
1151    #[doc = "Bit 18 - Interrupt status register for GPIO18."]
1152    #[inline(always)]
1153    pub fn reg_gpio_18_interrupt_status(&self) -> REG_GPIO_18_INTERRUPT_STATUS_R {
1154        REG_GPIO_18_INTERRUPT_STATUS_R::new(((self.bits >> 18) & 1) != 0)
1155    }
1156    #[doc = "Bit 19 - Interrupt status register for GPIO19."]
1157    #[inline(always)]
1158    pub fn reg_gpio_19_interrupt_status(&self) -> REG_GPIO_19_INTERRUPT_STATUS_R {
1159        REG_GPIO_19_INTERRUPT_STATUS_R::new(((self.bits >> 19) & 1) != 0)
1160    }
1161    #[doc = "Bit 20 - Interrupt status register for GPIO20."]
1162    #[inline(always)]
1163    pub fn reg_gpio_20_interrupt_status(&self) -> REG_GPIO_20_INTERRUPT_STATUS_R {
1164        REG_GPIO_20_INTERRUPT_STATUS_R::new(((self.bits >> 20) & 1) != 0)
1165    }
1166    #[doc = "Bit 21 - Interrupt status register for GPIO21."]
1167    #[inline(always)]
1168    pub fn reg_gpio_21_interrupt_status(&self) -> REG_GPIO_21_INTERRUPT_STATUS_R {
1169        REG_GPIO_21_INTERRUPT_STATUS_R::new(((self.bits >> 21) & 1) != 0)
1170    }
1171    #[doc = "Bit 22 - Interrupt status register for GPIO22."]
1172    #[inline(always)]
1173    pub fn reg_gpio_22_interrupt_status(&self) -> REG_GPIO_22_INTERRUPT_STATUS_R {
1174        REG_GPIO_22_INTERRUPT_STATUS_R::new(((self.bits >> 22) & 1) != 0)
1175    }
1176    #[doc = "Bit 23 - Interrupt status register for GPIO23."]
1177    #[inline(always)]
1178    pub fn reg_gpio_23_interrupt_status(&self) -> REG_GPIO_23_INTERRUPT_STATUS_R {
1179        REG_GPIO_23_INTERRUPT_STATUS_R::new(((self.bits >> 23) & 1) != 0)
1180    }
1181    #[doc = "Bit 24 - Interrupt status register for GPIO24."]
1182    #[inline(always)]
1183    pub fn reg_gpio_24_interrupt_status(&self) -> REG_GPIO_24_INTERRUPT_STATUS_R {
1184        REG_GPIO_24_INTERRUPT_STATUS_R::new(((self.bits >> 24) & 1) != 0)
1185    }
1186    #[doc = "Bit 25 - Interrupt status register for GPIO25."]
1187    #[inline(always)]
1188    pub fn reg_gpio_25_interrupt_status(&self) -> REG_GPIO_25_INTERRUPT_STATUS_R {
1189        REG_GPIO_25_INTERRUPT_STATUS_R::new(((self.bits >> 25) & 1) != 0)
1190    }
1191    #[doc = "Bit 26 - Interrupt status register for GPIO26."]
1192    #[inline(always)]
1193    pub fn reg_gpio_26_interrupt_status(&self) -> REG_GPIO_26_INTERRUPT_STATUS_R {
1194        REG_GPIO_26_INTERRUPT_STATUS_R::new(((self.bits >> 26) & 1) != 0)
1195    }
1196    #[doc = "Bit 27 - Interrupt status register for GPIO27."]
1197    #[inline(always)]
1198    pub fn reg_gpio_27_interrupt_status(&self) -> REG_GPIO_27_INTERRUPT_STATUS_R {
1199        REG_GPIO_27_INTERRUPT_STATUS_R::new(((self.bits >> 27) & 1) != 0)
1200    }
1201    #[doc = "Bit 28 - Interrupt status register for GPIO28."]
1202    #[inline(always)]
1203    pub fn reg_gpio_28_interrupt_status(&self) -> REG_GPIO_28_INTERRUPT_STATUS_R {
1204        REG_GPIO_28_INTERRUPT_STATUS_R::new(((self.bits >> 28) & 1) != 0)
1205    }
1206}
1207#[doc = "Interrupt status register. The SDK limits the GPIO pins to < 32 although the docs do not mention more than 28 GPIO pins.\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 [gpio_int_stat1](index.html) module"]
1208pub struct GPIO_INT_STAT1_SPEC;
1209impl crate::RegisterSpec for GPIO_INT_STAT1_SPEC {
1210    type Ux = u32;
1211}
1212#[doc = "`read()` method returns [gpio_int_stat1::R](R) reader structure"]
1213impl crate::Readable for GPIO_INT_STAT1_SPEC {
1214    type Reader = R;
1215}
1216#[doc = "`reset()` method sets GPIO_INT_STAT1 to value 0"]
1217impl crate::Resettable for GPIO_INT_STAT1_SPEC {
1218    const RESET_VALUE: Self::Ux = 0;
1219}
bl602_pac/glb/gpio_int_stat1.rs

bl602_pac/glb/
gpio_int_stat1.rs
