bl602_pac/glb/
gpio_int_clr1.rs

1#[doc = "Register `GPIO_INT_CLR1` reader"]
2pub struct R(crate::R<GPIO_INT_CLR1_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<GPIO_INT_CLR1_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<GPIO_INT_CLR1_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<GPIO_INT_CLR1_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `GPIO_INT_CLR1` writer"]
17pub struct W(crate::W<GPIO_INT_CLR1_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<GPIO_INT_CLR1_SPEC>;
20    #[inline(always)]
21    fn deref(&self) -> &Self::Target {
22        &self.0
23    }
24}
25impl core::ops::DerefMut for W {
26    #[inline(always)]
27    fn deref_mut(&mut self) -> &mut Self::Target {
28        &mut self.0
29    }
30}
31impl From<crate::W<GPIO_INT_CLR1_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<GPIO_INT_CLR1_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `reg_gpio_0_interrupt_clear` reader - Interrupt clearing register for GPIO0."]
38pub type REG_GPIO_0_INTERRUPT_CLEAR_R = crate::BitReader<GPIO0INTERRUPT_CLEAR_A>;
39#[doc = "Interrupt clearing register for GPIO0.\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq, Eq)]
41pub enum GPIO0INTERRUPT_CLEAR_A {
42    #[doc = "0: `0`"]
43    NO_CLEAR = 0,
44    #[doc = "1: `1`"]
45    CLEAR = 1,
46}
47impl From<GPIO0INTERRUPT_CLEAR_A> for bool {
48    #[inline(always)]
49    fn from(variant: GPIO0INTERRUPT_CLEAR_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl REG_GPIO_0_INTERRUPT_CLEAR_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> GPIO0INTERRUPT_CLEAR_A {
57        match self.bits {
58            false => GPIO0INTERRUPT_CLEAR_A::NO_CLEAR,
59            true => GPIO0INTERRUPT_CLEAR_A::CLEAR,
60        }
61    }
62    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
63    #[inline(always)]
64    pub fn is_no_clear(&self) -> bool {
65        *self == GPIO0INTERRUPT_CLEAR_A::NO_CLEAR
66    }
67    #[doc = "Checks if the value of the field is `CLEAR`"]
68    #[inline(always)]
69    pub fn is_clear(&self) -> bool {
70        *self == GPIO0INTERRUPT_CLEAR_A::CLEAR
71    }
72}
73#[doc = "Field `reg_gpio_0_interrupt_clear` writer - Interrupt clearing register for GPIO0."]
74pub type REG_GPIO_0_INTERRUPT_CLEAR_W<'a, const O: u8> =
75    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO0INTERRUPT_CLEAR_A, O>;
76impl<'a, const O: u8> REG_GPIO_0_INTERRUPT_CLEAR_W<'a, O> {
77    #[doc = "`0`"]
78    #[inline(always)]
79    pub fn no_clear(self) -> &'a mut W {
80        self.variant(GPIO0INTERRUPT_CLEAR_A::NO_CLEAR)
81    }
82    #[doc = "`1`"]
83    #[inline(always)]
84    pub fn clear(self) -> &'a mut W {
85        self.variant(GPIO0INTERRUPT_CLEAR_A::CLEAR)
86    }
87}
88#[doc = "Field `reg_gpio_1_interrupt_clear` reader - Interrupt clearing register for GPIO1."]
89pub type REG_GPIO_1_INTERRUPT_CLEAR_R = crate::BitReader<GPIO1INTERRUPT_CLEAR_A>;
90#[doc = "Interrupt clearing register for GPIO1.\n\nValue on reset: 0"]
91#[derive(Clone, Copy, Debug, PartialEq, Eq)]
92pub enum GPIO1INTERRUPT_CLEAR_A {
93    #[doc = "0: `0`"]
94    NO_CLEAR = 0,
95    #[doc = "1: `1`"]
96    CLEAR = 1,
97}
98impl From<GPIO1INTERRUPT_CLEAR_A> for bool {
99    #[inline(always)]
100    fn from(variant: GPIO1INTERRUPT_CLEAR_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl REG_GPIO_1_INTERRUPT_CLEAR_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> GPIO1INTERRUPT_CLEAR_A {
108        match self.bits {
109            false => GPIO1INTERRUPT_CLEAR_A::NO_CLEAR,
110            true => GPIO1INTERRUPT_CLEAR_A::CLEAR,
111        }
112    }
113    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
114    #[inline(always)]
115    pub fn is_no_clear(&self) -> bool {
116        *self == GPIO1INTERRUPT_CLEAR_A::NO_CLEAR
117    }
118    #[doc = "Checks if the value of the field is `CLEAR`"]
119    #[inline(always)]
120    pub fn is_clear(&self) -> bool {
121        *self == GPIO1INTERRUPT_CLEAR_A::CLEAR
122    }
123}
124#[doc = "Field `reg_gpio_1_interrupt_clear` writer - Interrupt clearing register for GPIO1."]
125pub type REG_GPIO_1_INTERRUPT_CLEAR_W<'a, const O: u8> =
126    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO1INTERRUPT_CLEAR_A, O>;
127impl<'a, const O: u8> REG_GPIO_1_INTERRUPT_CLEAR_W<'a, O> {
128    #[doc = "`0`"]
129    #[inline(always)]
130    pub fn no_clear(self) -> &'a mut W {
131        self.variant(GPIO1INTERRUPT_CLEAR_A::NO_CLEAR)
132    }
133    #[doc = "`1`"]
134    #[inline(always)]
135    pub fn clear(self) -> &'a mut W {
136        self.variant(GPIO1INTERRUPT_CLEAR_A::CLEAR)
137    }
138}
139#[doc = "Field `reg_gpio_2_interrupt_clear` reader - Interrupt clearing register for GPIO2."]
140pub type REG_GPIO_2_INTERRUPT_CLEAR_R = crate::BitReader<GPIO2INTERRUPT_CLEAR_A>;
141#[doc = "Interrupt clearing register for GPIO2.\n\nValue on reset: 0"]
142#[derive(Clone, Copy, Debug, PartialEq, Eq)]
143pub enum GPIO2INTERRUPT_CLEAR_A {
144    #[doc = "0: `0`"]
145    NO_CLEAR = 0,
146    #[doc = "1: `1`"]
147    CLEAR = 1,
148}
149impl From<GPIO2INTERRUPT_CLEAR_A> for bool {
150    #[inline(always)]
151    fn from(variant: GPIO2INTERRUPT_CLEAR_A) -> Self {
152        variant as u8 != 0
153    }
154}
155impl REG_GPIO_2_INTERRUPT_CLEAR_R {
156    #[doc = "Get enumerated values variant"]
157    #[inline(always)]
158    pub fn variant(&self) -> GPIO2INTERRUPT_CLEAR_A {
159        match self.bits {
160            false => GPIO2INTERRUPT_CLEAR_A::NO_CLEAR,
161            true => GPIO2INTERRUPT_CLEAR_A::CLEAR,
162        }
163    }
164    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
165    #[inline(always)]
166    pub fn is_no_clear(&self) -> bool {
167        *self == GPIO2INTERRUPT_CLEAR_A::NO_CLEAR
168    }
169    #[doc = "Checks if the value of the field is `CLEAR`"]
170    #[inline(always)]
171    pub fn is_clear(&self) -> bool {
172        *self == GPIO2INTERRUPT_CLEAR_A::CLEAR
173    }
174}
175#[doc = "Field `reg_gpio_2_interrupt_clear` writer - Interrupt clearing register for GPIO2."]
176pub type REG_GPIO_2_INTERRUPT_CLEAR_W<'a, const O: u8> =
177    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO2INTERRUPT_CLEAR_A, O>;
178impl<'a, const O: u8> REG_GPIO_2_INTERRUPT_CLEAR_W<'a, O> {
179    #[doc = "`0`"]
180    #[inline(always)]
181    pub fn no_clear(self) -> &'a mut W {
182        self.variant(GPIO2INTERRUPT_CLEAR_A::NO_CLEAR)
183    }
184    #[doc = "`1`"]
185    #[inline(always)]
186    pub fn clear(self) -> &'a mut W {
187        self.variant(GPIO2INTERRUPT_CLEAR_A::CLEAR)
188    }
189}
190#[doc = "Field `reg_gpio_3_interrupt_clear` reader - Interrupt clearing register for GPIO3."]
191pub type REG_GPIO_3_INTERRUPT_CLEAR_R = crate::BitReader<GPIO3INTERRUPT_CLEAR_A>;
192#[doc = "Interrupt clearing register for GPIO3.\n\nValue on reset: 0"]
193#[derive(Clone, Copy, Debug, PartialEq, Eq)]
194pub enum GPIO3INTERRUPT_CLEAR_A {
195    #[doc = "0: `0`"]
196    NO_CLEAR = 0,
197    #[doc = "1: `1`"]
198    CLEAR = 1,
199}
200impl From<GPIO3INTERRUPT_CLEAR_A> for bool {
201    #[inline(always)]
202    fn from(variant: GPIO3INTERRUPT_CLEAR_A) -> Self {
203        variant as u8 != 0
204    }
205}
206impl REG_GPIO_3_INTERRUPT_CLEAR_R {
207    #[doc = "Get enumerated values variant"]
208    #[inline(always)]
209    pub fn variant(&self) -> GPIO3INTERRUPT_CLEAR_A {
210        match self.bits {
211            false => GPIO3INTERRUPT_CLEAR_A::NO_CLEAR,
212            true => GPIO3INTERRUPT_CLEAR_A::CLEAR,
213        }
214    }
215    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
216    #[inline(always)]
217    pub fn is_no_clear(&self) -> bool {
218        *self == GPIO3INTERRUPT_CLEAR_A::NO_CLEAR
219    }
220    #[doc = "Checks if the value of the field is `CLEAR`"]
221    #[inline(always)]
222    pub fn is_clear(&self) -> bool {
223        *self == GPIO3INTERRUPT_CLEAR_A::CLEAR
224    }
225}
226#[doc = "Field `reg_gpio_3_interrupt_clear` writer - Interrupt clearing register for GPIO3."]
227pub type REG_GPIO_3_INTERRUPT_CLEAR_W<'a, const O: u8> =
228    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO3INTERRUPT_CLEAR_A, O>;
229impl<'a, const O: u8> REG_GPIO_3_INTERRUPT_CLEAR_W<'a, O> {
230    #[doc = "`0`"]
231    #[inline(always)]
232    pub fn no_clear(self) -> &'a mut W {
233        self.variant(GPIO3INTERRUPT_CLEAR_A::NO_CLEAR)
234    }
235    #[doc = "`1`"]
236    #[inline(always)]
237    pub fn clear(self) -> &'a mut W {
238        self.variant(GPIO3INTERRUPT_CLEAR_A::CLEAR)
239    }
240}
241#[doc = "Field `reg_gpio_4_interrupt_clear` reader - Interrupt clearing register for GPIO4."]
242pub type REG_GPIO_4_INTERRUPT_CLEAR_R = crate::BitReader<GPIO4INTERRUPT_CLEAR_A>;
243#[doc = "Interrupt clearing register for GPIO4.\n\nValue on reset: 0"]
244#[derive(Clone, Copy, Debug, PartialEq, Eq)]
245pub enum GPIO4INTERRUPT_CLEAR_A {
246    #[doc = "0: `0`"]
247    NO_CLEAR = 0,
248    #[doc = "1: `1`"]
249    CLEAR = 1,
250}
251impl From<GPIO4INTERRUPT_CLEAR_A> for bool {
252    #[inline(always)]
253    fn from(variant: GPIO4INTERRUPT_CLEAR_A) -> Self {
254        variant as u8 != 0
255    }
256}
257impl REG_GPIO_4_INTERRUPT_CLEAR_R {
258    #[doc = "Get enumerated values variant"]
259    #[inline(always)]
260    pub fn variant(&self) -> GPIO4INTERRUPT_CLEAR_A {
261        match self.bits {
262            false => GPIO4INTERRUPT_CLEAR_A::NO_CLEAR,
263            true => GPIO4INTERRUPT_CLEAR_A::CLEAR,
264        }
265    }
266    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
267    #[inline(always)]
268    pub fn is_no_clear(&self) -> bool {
269        *self == GPIO4INTERRUPT_CLEAR_A::NO_CLEAR
270    }
271    #[doc = "Checks if the value of the field is `CLEAR`"]
272    #[inline(always)]
273    pub fn is_clear(&self) -> bool {
274        *self == GPIO4INTERRUPT_CLEAR_A::CLEAR
275    }
276}
277#[doc = "Field `reg_gpio_4_interrupt_clear` writer - Interrupt clearing register for GPIO4."]
278pub type REG_GPIO_4_INTERRUPT_CLEAR_W<'a, const O: u8> =
279    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO4INTERRUPT_CLEAR_A, O>;
280impl<'a, const O: u8> REG_GPIO_4_INTERRUPT_CLEAR_W<'a, O> {
281    #[doc = "`0`"]
282    #[inline(always)]
283    pub fn no_clear(self) -> &'a mut W {
284        self.variant(GPIO4INTERRUPT_CLEAR_A::NO_CLEAR)
285    }
286    #[doc = "`1`"]
287    #[inline(always)]
288    pub fn clear(self) -> &'a mut W {
289        self.variant(GPIO4INTERRUPT_CLEAR_A::CLEAR)
290    }
291}
292#[doc = "Field `reg_gpio_5_interrupt_clear` reader - Interrupt clearing register for GPIO5."]
293pub type REG_GPIO_5_INTERRUPT_CLEAR_R = crate::BitReader<GPIO5INTERRUPT_CLEAR_A>;
294#[doc = "Interrupt clearing register for GPIO5.\n\nValue on reset: 0"]
295#[derive(Clone, Copy, Debug, PartialEq, Eq)]
296pub enum GPIO5INTERRUPT_CLEAR_A {
297    #[doc = "0: `0`"]
298    NO_CLEAR = 0,
299    #[doc = "1: `1`"]
300    CLEAR = 1,
301}
302impl From<GPIO5INTERRUPT_CLEAR_A> for bool {
303    #[inline(always)]
304    fn from(variant: GPIO5INTERRUPT_CLEAR_A) -> Self {
305        variant as u8 != 0
306    }
307}
308impl REG_GPIO_5_INTERRUPT_CLEAR_R {
309    #[doc = "Get enumerated values variant"]
310    #[inline(always)]
311    pub fn variant(&self) -> GPIO5INTERRUPT_CLEAR_A {
312        match self.bits {
313            false => GPIO5INTERRUPT_CLEAR_A::NO_CLEAR,
314            true => GPIO5INTERRUPT_CLEAR_A::CLEAR,
315        }
316    }
317    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
318    #[inline(always)]
319    pub fn is_no_clear(&self) -> bool {
320        *self == GPIO5INTERRUPT_CLEAR_A::NO_CLEAR
321    }
322    #[doc = "Checks if the value of the field is `CLEAR`"]
323    #[inline(always)]
324    pub fn is_clear(&self) -> bool {
325        *self == GPIO5INTERRUPT_CLEAR_A::CLEAR
326    }
327}
328#[doc = "Field `reg_gpio_5_interrupt_clear` writer - Interrupt clearing register for GPIO5."]
329pub type REG_GPIO_5_INTERRUPT_CLEAR_W<'a, const O: u8> =
330    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO5INTERRUPT_CLEAR_A, O>;
331impl<'a, const O: u8> REG_GPIO_5_INTERRUPT_CLEAR_W<'a, O> {
332    #[doc = "`0`"]
333    #[inline(always)]
334    pub fn no_clear(self) -> &'a mut W {
335        self.variant(GPIO5INTERRUPT_CLEAR_A::NO_CLEAR)
336    }
337    #[doc = "`1`"]
338    #[inline(always)]
339    pub fn clear(self) -> &'a mut W {
340        self.variant(GPIO5INTERRUPT_CLEAR_A::CLEAR)
341    }
342}
343#[doc = "Field `reg_gpio_6_interrupt_clear` reader - Interrupt clearing register for GPIO6."]
344pub type REG_GPIO_6_INTERRUPT_CLEAR_R = crate::BitReader<GPIO6INTERRUPT_CLEAR_A>;
345#[doc = "Interrupt clearing register for GPIO6.\n\nValue on reset: 0"]
346#[derive(Clone, Copy, Debug, PartialEq, Eq)]
347pub enum GPIO6INTERRUPT_CLEAR_A {
348    #[doc = "0: `0`"]
349    NO_CLEAR = 0,
350    #[doc = "1: `1`"]
351    CLEAR = 1,
352}
353impl From<GPIO6INTERRUPT_CLEAR_A> for bool {
354    #[inline(always)]
355    fn from(variant: GPIO6INTERRUPT_CLEAR_A) -> Self {
356        variant as u8 != 0
357    }
358}
359impl REG_GPIO_6_INTERRUPT_CLEAR_R {
360    #[doc = "Get enumerated values variant"]
361    #[inline(always)]
362    pub fn variant(&self) -> GPIO6INTERRUPT_CLEAR_A {
363        match self.bits {
364            false => GPIO6INTERRUPT_CLEAR_A::NO_CLEAR,
365            true => GPIO6INTERRUPT_CLEAR_A::CLEAR,
366        }
367    }
368    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
369    #[inline(always)]
370    pub fn is_no_clear(&self) -> bool {
371        *self == GPIO6INTERRUPT_CLEAR_A::NO_CLEAR
372    }
373    #[doc = "Checks if the value of the field is `CLEAR`"]
374    #[inline(always)]
375    pub fn is_clear(&self) -> bool {
376        *self == GPIO6INTERRUPT_CLEAR_A::CLEAR
377    }
378}
379#[doc = "Field `reg_gpio_6_interrupt_clear` writer - Interrupt clearing register for GPIO6."]
380pub type REG_GPIO_6_INTERRUPT_CLEAR_W<'a, const O: u8> =
381    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO6INTERRUPT_CLEAR_A, O>;
382impl<'a, const O: u8> REG_GPIO_6_INTERRUPT_CLEAR_W<'a, O> {
383    #[doc = "`0`"]
384    #[inline(always)]
385    pub fn no_clear(self) -> &'a mut W {
386        self.variant(GPIO6INTERRUPT_CLEAR_A::NO_CLEAR)
387    }
388    #[doc = "`1`"]
389    #[inline(always)]
390    pub fn clear(self) -> &'a mut W {
391        self.variant(GPIO6INTERRUPT_CLEAR_A::CLEAR)
392    }
393}
394#[doc = "Field `reg_gpio_7_interrupt_clear` reader - Interrupt clearing register for GPIO7."]
395pub type REG_GPIO_7_INTERRUPT_CLEAR_R = crate::BitReader<GPIO7INTERRUPT_CLEAR_A>;
396#[doc = "Interrupt clearing register for GPIO7.\n\nValue on reset: 0"]
397#[derive(Clone, Copy, Debug, PartialEq, Eq)]
398pub enum GPIO7INTERRUPT_CLEAR_A {
399    #[doc = "0: `0`"]
400    NO_CLEAR = 0,
401    #[doc = "1: `1`"]
402    CLEAR = 1,
403}
404impl From<GPIO7INTERRUPT_CLEAR_A> for bool {
405    #[inline(always)]
406    fn from(variant: GPIO7INTERRUPT_CLEAR_A) -> Self {
407        variant as u8 != 0
408    }
409}
410impl REG_GPIO_7_INTERRUPT_CLEAR_R {
411    #[doc = "Get enumerated values variant"]
412    #[inline(always)]
413    pub fn variant(&self) -> GPIO7INTERRUPT_CLEAR_A {
414        match self.bits {
415            false => GPIO7INTERRUPT_CLEAR_A::NO_CLEAR,
416            true => GPIO7INTERRUPT_CLEAR_A::CLEAR,
417        }
418    }
419    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
420    #[inline(always)]
421    pub fn is_no_clear(&self) -> bool {
422        *self == GPIO7INTERRUPT_CLEAR_A::NO_CLEAR
423    }
424    #[doc = "Checks if the value of the field is `CLEAR`"]
425    #[inline(always)]
426    pub fn is_clear(&self) -> bool {
427        *self == GPIO7INTERRUPT_CLEAR_A::CLEAR
428    }
429}
430#[doc = "Field `reg_gpio_7_interrupt_clear` writer - Interrupt clearing register for GPIO7."]
431pub type REG_GPIO_7_INTERRUPT_CLEAR_W<'a, const O: u8> =
432    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO7INTERRUPT_CLEAR_A, O>;
433impl<'a, const O: u8> REG_GPIO_7_INTERRUPT_CLEAR_W<'a, O> {
434    #[doc = "`0`"]
435    #[inline(always)]
436    pub fn no_clear(self) -> &'a mut W {
437        self.variant(GPIO7INTERRUPT_CLEAR_A::NO_CLEAR)
438    }
439    #[doc = "`1`"]
440    #[inline(always)]
441    pub fn clear(self) -> &'a mut W {
442        self.variant(GPIO7INTERRUPT_CLEAR_A::CLEAR)
443    }
444}
445#[doc = "Field `reg_gpio_8_interrupt_clear` reader - Interrupt clearing register for GPIO8."]
446pub type REG_GPIO_8_INTERRUPT_CLEAR_R = crate::BitReader<GPIO8INTERRUPT_CLEAR_A>;
447#[doc = "Interrupt clearing register for GPIO8.\n\nValue on reset: 0"]
448#[derive(Clone, Copy, Debug, PartialEq, Eq)]
449pub enum GPIO8INTERRUPT_CLEAR_A {
450    #[doc = "0: `0`"]
451    NO_CLEAR = 0,
452    #[doc = "1: `1`"]
453    CLEAR = 1,
454}
455impl From<GPIO8INTERRUPT_CLEAR_A> for bool {
456    #[inline(always)]
457    fn from(variant: GPIO8INTERRUPT_CLEAR_A) -> Self {
458        variant as u8 != 0
459    }
460}
461impl REG_GPIO_8_INTERRUPT_CLEAR_R {
462    #[doc = "Get enumerated values variant"]
463    #[inline(always)]
464    pub fn variant(&self) -> GPIO8INTERRUPT_CLEAR_A {
465        match self.bits {
466            false => GPIO8INTERRUPT_CLEAR_A::NO_CLEAR,
467            true => GPIO8INTERRUPT_CLEAR_A::CLEAR,
468        }
469    }
470    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
471    #[inline(always)]
472    pub fn is_no_clear(&self) -> bool {
473        *self == GPIO8INTERRUPT_CLEAR_A::NO_CLEAR
474    }
475    #[doc = "Checks if the value of the field is `CLEAR`"]
476    #[inline(always)]
477    pub fn is_clear(&self) -> bool {
478        *self == GPIO8INTERRUPT_CLEAR_A::CLEAR
479    }
480}
481#[doc = "Field `reg_gpio_8_interrupt_clear` writer - Interrupt clearing register for GPIO8."]
482pub type REG_GPIO_8_INTERRUPT_CLEAR_W<'a, const O: u8> =
483    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO8INTERRUPT_CLEAR_A, O>;
484impl<'a, const O: u8> REG_GPIO_8_INTERRUPT_CLEAR_W<'a, O> {
485    #[doc = "`0`"]
486    #[inline(always)]
487    pub fn no_clear(self) -> &'a mut W {
488        self.variant(GPIO8INTERRUPT_CLEAR_A::NO_CLEAR)
489    }
490    #[doc = "`1`"]
491    #[inline(always)]
492    pub fn clear(self) -> &'a mut W {
493        self.variant(GPIO8INTERRUPT_CLEAR_A::CLEAR)
494    }
495}
496#[doc = "Field `reg_gpio_9_interrupt_clear` reader - Interrupt clearing register for GPIO9."]
497pub type REG_GPIO_9_INTERRUPT_CLEAR_R = crate::BitReader<GPIO9INTERRUPT_CLEAR_A>;
498#[doc = "Interrupt clearing register for GPIO9.\n\nValue on reset: 0"]
499#[derive(Clone, Copy, Debug, PartialEq, Eq)]
500pub enum GPIO9INTERRUPT_CLEAR_A {
501    #[doc = "0: `0`"]
502    NO_CLEAR = 0,
503    #[doc = "1: `1`"]
504    CLEAR = 1,
505}
506impl From<GPIO9INTERRUPT_CLEAR_A> for bool {
507    #[inline(always)]
508    fn from(variant: GPIO9INTERRUPT_CLEAR_A) -> Self {
509        variant as u8 != 0
510    }
511}
512impl REG_GPIO_9_INTERRUPT_CLEAR_R {
513    #[doc = "Get enumerated values variant"]
514    #[inline(always)]
515    pub fn variant(&self) -> GPIO9INTERRUPT_CLEAR_A {
516        match self.bits {
517            false => GPIO9INTERRUPT_CLEAR_A::NO_CLEAR,
518            true => GPIO9INTERRUPT_CLEAR_A::CLEAR,
519        }
520    }
521    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
522    #[inline(always)]
523    pub fn is_no_clear(&self) -> bool {
524        *self == GPIO9INTERRUPT_CLEAR_A::NO_CLEAR
525    }
526    #[doc = "Checks if the value of the field is `CLEAR`"]
527    #[inline(always)]
528    pub fn is_clear(&self) -> bool {
529        *self == GPIO9INTERRUPT_CLEAR_A::CLEAR
530    }
531}
532#[doc = "Field `reg_gpio_9_interrupt_clear` writer - Interrupt clearing register for GPIO9."]
533pub type REG_GPIO_9_INTERRUPT_CLEAR_W<'a, const O: u8> =
534    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO9INTERRUPT_CLEAR_A, O>;
535impl<'a, const O: u8> REG_GPIO_9_INTERRUPT_CLEAR_W<'a, O> {
536    #[doc = "`0`"]
537    #[inline(always)]
538    pub fn no_clear(self) -> &'a mut W {
539        self.variant(GPIO9INTERRUPT_CLEAR_A::NO_CLEAR)
540    }
541    #[doc = "`1`"]
542    #[inline(always)]
543    pub fn clear(self) -> &'a mut W {
544        self.variant(GPIO9INTERRUPT_CLEAR_A::CLEAR)
545    }
546}
547#[doc = "Field `reg_gpio_10_interrupt_clear` reader - Interrupt clearing register for GPIO10."]
548pub type REG_GPIO_10_INTERRUPT_CLEAR_R = crate::BitReader<GPIO10INTERRUPT_CLEAR_A>;
549#[doc = "Interrupt clearing register for GPIO10.\n\nValue on reset: 0"]
550#[derive(Clone, Copy, Debug, PartialEq, Eq)]
551pub enum GPIO10INTERRUPT_CLEAR_A {
552    #[doc = "0: `0`"]
553    NO_CLEAR = 0,
554    #[doc = "1: `1`"]
555    CLEAR = 1,
556}
557impl From<GPIO10INTERRUPT_CLEAR_A> for bool {
558    #[inline(always)]
559    fn from(variant: GPIO10INTERRUPT_CLEAR_A) -> Self {
560        variant as u8 != 0
561    }
562}
563impl REG_GPIO_10_INTERRUPT_CLEAR_R {
564    #[doc = "Get enumerated values variant"]
565    #[inline(always)]
566    pub fn variant(&self) -> GPIO10INTERRUPT_CLEAR_A {
567        match self.bits {
568            false => GPIO10INTERRUPT_CLEAR_A::NO_CLEAR,
569            true => GPIO10INTERRUPT_CLEAR_A::CLEAR,
570        }
571    }
572    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
573    #[inline(always)]
574    pub fn is_no_clear(&self) -> bool {
575        *self == GPIO10INTERRUPT_CLEAR_A::NO_CLEAR
576    }
577    #[doc = "Checks if the value of the field is `CLEAR`"]
578    #[inline(always)]
579    pub fn is_clear(&self) -> bool {
580        *self == GPIO10INTERRUPT_CLEAR_A::CLEAR
581    }
582}
583#[doc = "Field `reg_gpio_10_interrupt_clear` writer - Interrupt clearing register for GPIO10."]
584pub type REG_GPIO_10_INTERRUPT_CLEAR_W<'a, const O: u8> =
585    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO10INTERRUPT_CLEAR_A, O>;
586impl<'a, const O: u8> REG_GPIO_10_INTERRUPT_CLEAR_W<'a, O> {
587    #[doc = "`0`"]
588    #[inline(always)]
589    pub fn no_clear(self) -> &'a mut W {
590        self.variant(GPIO10INTERRUPT_CLEAR_A::NO_CLEAR)
591    }
592    #[doc = "`1`"]
593    #[inline(always)]
594    pub fn clear(self) -> &'a mut W {
595        self.variant(GPIO10INTERRUPT_CLEAR_A::CLEAR)
596    }
597}
598#[doc = "Field `reg_gpio_11_interrupt_clear` reader - Interrupt clearing register for GPIO11."]
599pub type REG_GPIO_11_INTERRUPT_CLEAR_R = crate::BitReader<GPIO11INTERRUPT_CLEAR_A>;
600#[doc = "Interrupt clearing register for GPIO11.\n\nValue on reset: 0"]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum GPIO11INTERRUPT_CLEAR_A {
603    #[doc = "0: `0`"]
604    NO_CLEAR = 0,
605    #[doc = "1: `1`"]
606    CLEAR = 1,
607}
608impl From<GPIO11INTERRUPT_CLEAR_A> for bool {
609    #[inline(always)]
610    fn from(variant: GPIO11INTERRUPT_CLEAR_A) -> Self {
611        variant as u8 != 0
612    }
613}
614impl REG_GPIO_11_INTERRUPT_CLEAR_R {
615    #[doc = "Get enumerated values variant"]
616    #[inline(always)]
617    pub fn variant(&self) -> GPIO11INTERRUPT_CLEAR_A {
618        match self.bits {
619            false => GPIO11INTERRUPT_CLEAR_A::NO_CLEAR,
620            true => GPIO11INTERRUPT_CLEAR_A::CLEAR,
621        }
622    }
623    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
624    #[inline(always)]
625    pub fn is_no_clear(&self) -> bool {
626        *self == GPIO11INTERRUPT_CLEAR_A::NO_CLEAR
627    }
628    #[doc = "Checks if the value of the field is `CLEAR`"]
629    #[inline(always)]
630    pub fn is_clear(&self) -> bool {
631        *self == GPIO11INTERRUPT_CLEAR_A::CLEAR
632    }
633}
634#[doc = "Field `reg_gpio_11_interrupt_clear` writer - Interrupt clearing register for GPIO11."]
635pub type REG_GPIO_11_INTERRUPT_CLEAR_W<'a, const O: u8> =
636    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO11INTERRUPT_CLEAR_A, O>;
637impl<'a, const O: u8> REG_GPIO_11_INTERRUPT_CLEAR_W<'a, O> {
638    #[doc = "`0`"]
639    #[inline(always)]
640    pub fn no_clear(self) -> &'a mut W {
641        self.variant(GPIO11INTERRUPT_CLEAR_A::NO_CLEAR)
642    }
643    #[doc = "`1`"]
644    #[inline(always)]
645    pub fn clear(self) -> &'a mut W {
646        self.variant(GPIO11INTERRUPT_CLEAR_A::CLEAR)
647    }
648}
649#[doc = "Field `reg_gpio_12_interrupt_clear` reader - Interrupt clearing register for GPIO12."]
650pub type REG_GPIO_12_INTERRUPT_CLEAR_R = crate::BitReader<GPIO12INTERRUPT_CLEAR_A>;
651#[doc = "Interrupt clearing register for GPIO12.\n\nValue on reset: 0"]
652#[derive(Clone, Copy, Debug, PartialEq, Eq)]
653pub enum GPIO12INTERRUPT_CLEAR_A {
654    #[doc = "0: `0`"]
655    NO_CLEAR = 0,
656    #[doc = "1: `1`"]
657    CLEAR = 1,
658}
659impl From<GPIO12INTERRUPT_CLEAR_A> for bool {
660    #[inline(always)]
661    fn from(variant: GPIO12INTERRUPT_CLEAR_A) -> Self {
662        variant as u8 != 0
663    }
664}
665impl REG_GPIO_12_INTERRUPT_CLEAR_R {
666    #[doc = "Get enumerated values variant"]
667    #[inline(always)]
668    pub fn variant(&self) -> GPIO12INTERRUPT_CLEAR_A {
669        match self.bits {
670            false => GPIO12INTERRUPT_CLEAR_A::NO_CLEAR,
671            true => GPIO12INTERRUPT_CLEAR_A::CLEAR,
672        }
673    }
674    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
675    #[inline(always)]
676    pub fn is_no_clear(&self) -> bool {
677        *self == GPIO12INTERRUPT_CLEAR_A::NO_CLEAR
678    }
679    #[doc = "Checks if the value of the field is `CLEAR`"]
680    #[inline(always)]
681    pub fn is_clear(&self) -> bool {
682        *self == GPIO12INTERRUPT_CLEAR_A::CLEAR
683    }
684}
685#[doc = "Field `reg_gpio_12_interrupt_clear` writer - Interrupt clearing register for GPIO12."]
686pub type REG_GPIO_12_INTERRUPT_CLEAR_W<'a, const O: u8> =
687    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO12INTERRUPT_CLEAR_A, O>;
688impl<'a, const O: u8> REG_GPIO_12_INTERRUPT_CLEAR_W<'a, O> {
689    #[doc = "`0`"]
690    #[inline(always)]
691    pub fn no_clear(self) -> &'a mut W {
692        self.variant(GPIO12INTERRUPT_CLEAR_A::NO_CLEAR)
693    }
694    #[doc = "`1`"]
695    #[inline(always)]
696    pub fn clear(self) -> &'a mut W {
697        self.variant(GPIO12INTERRUPT_CLEAR_A::CLEAR)
698    }
699}
700#[doc = "Field `reg_gpio_13_interrupt_clear` reader - Interrupt clearing register for GPIO13."]
701pub type REG_GPIO_13_INTERRUPT_CLEAR_R = crate::BitReader<GPIO13INTERRUPT_CLEAR_A>;
702#[doc = "Interrupt clearing register for GPIO13.\n\nValue on reset: 0"]
703#[derive(Clone, Copy, Debug, PartialEq, Eq)]
704pub enum GPIO13INTERRUPT_CLEAR_A {
705    #[doc = "0: `0`"]
706    NO_CLEAR = 0,
707    #[doc = "1: `1`"]
708    CLEAR = 1,
709}
710impl From<GPIO13INTERRUPT_CLEAR_A> for bool {
711    #[inline(always)]
712    fn from(variant: GPIO13INTERRUPT_CLEAR_A) -> Self {
713        variant as u8 != 0
714    }
715}
716impl REG_GPIO_13_INTERRUPT_CLEAR_R {
717    #[doc = "Get enumerated values variant"]
718    #[inline(always)]
719    pub fn variant(&self) -> GPIO13INTERRUPT_CLEAR_A {
720        match self.bits {
721            false => GPIO13INTERRUPT_CLEAR_A::NO_CLEAR,
722            true => GPIO13INTERRUPT_CLEAR_A::CLEAR,
723        }
724    }
725    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
726    #[inline(always)]
727    pub fn is_no_clear(&self) -> bool {
728        *self == GPIO13INTERRUPT_CLEAR_A::NO_CLEAR
729    }
730    #[doc = "Checks if the value of the field is `CLEAR`"]
731    #[inline(always)]
732    pub fn is_clear(&self) -> bool {
733        *self == GPIO13INTERRUPT_CLEAR_A::CLEAR
734    }
735}
736#[doc = "Field `reg_gpio_13_interrupt_clear` writer - Interrupt clearing register for GPIO13."]
737pub type REG_GPIO_13_INTERRUPT_CLEAR_W<'a, const O: u8> =
738    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO13INTERRUPT_CLEAR_A, O>;
739impl<'a, const O: u8> REG_GPIO_13_INTERRUPT_CLEAR_W<'a, O> {
740    #[doc = "`0`"]
741    #[inline(always)]
742    pub fn no_clear(self) -> &'a mut W {
743        self.variant(GPIO13INTERRUPT_CLEAR_A::NO_CLEAR)
744    }
745    #[doc = "`1`"]
746    #[inline(always)]
747    pub fn clear(self) -> &'a mut W {
748        self.variant(GPIO13INTERRUPT_CLEAR_A::CLEAR)
749    }
750}
751#[doc = "Field `reg_gpio_14_interrupt_clear` reader - Interrupt clearing register for GPIO14."]
752pub type REG_GPIO_14_INTERRUPT_CLEAR_R = crate::BitReader<GPIO14INTERRUPT_CLEAR_A>;
753#[doc = "Interrupt clearing register for GPIO14.\n\nValue on reset: 0"]
754#[derive(Clone, Copy, Debug, PartialEq, Eq)]
755pub enum GPIO14INTERRUPT_CLEAR_A {
756    #[doc = "0: `0`"]
757    NO_CLEAR = 0,
758    #[doc = "1: `1`"]
759    CLEAR = 1,
760}
761impl From<GPIO14INTERRUPT_CLEAR_A> for bool {
762    #[inline(always)]
763    fn from(variant: GPIO14INTERRUPT_CLEAR_A) -> Self {
764        variant as u8 != 0
765    }
766}
767impl REG_GPIO_14_INTERRUPT_CLEAR_R {
768    #[doc = "Get enumerated values variant"]
769    #[inline(always)]
770    pub fn variant(&self) -> GPIO14INTERRUPT_CLEAR_A {
771        match self.bits {
772            false => GPIO14INTERRUPT_CLEAR_A::NO_CLEAR,
773            true => GPIO14INTERRUPT_CLEAR_A::CLEAR,
774        }
775    }
776    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
777    #[inline(always)]
778    pub fn is_no_clear(&self) -> bool {
779        *self == GPIO14INTERRUPT_CLEAR_A::NO_CLEAR
780    }
781    #[doc = "Checks if the value of the field is `CLEAR`"]
782    #[inline(always)]
783    pub fn is_clear(&self) -> bool {
784        *self == GPIO14INTERRUPT_CLEAR_A::CLEAR
785    }
786}
787#[doc = "Field `reg_gpio_14_interrupt_clear` writer - Interrupt clearing register for GPIO14."]
788pub type REG_GPIO_14_INTERRUPT_CLEAR_W<'a, const O: u8> =
789    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO14INTERRUPT_CLEAR_A, O>;
790impl<'a, const O: u8> REG_GPIO_14_INTERRUPT_CLEAR_W<'a, O> {
791    #[doc = "`0`"]
792    #[inline(always)]
793    pub fn no_clear(self) -> &'a mut W {
794        self.variant(GPIO14INTERRUPT_CLEAR_A::NO_CLEAR)
795    }
796    #[doc = "`1`"]
797    #[inline(always)]
798    pub fn clear(self) -> &'a mut W {
799        self.variant(GPIO14INTERRUPT_CLEAR_A::CLEAR)
800    }
801}
802#[doc = "Field `reg_gpio_15_interrupt_clear` reader - Interrupt clearing register for GPIO15."]
803pub type REG_GPIO_15_INTERRUPT_CLEAR_R = crate::BitReader<GPIO15INTERRUPT_CLEAR_A>;
804#[doc = "Interrupt clearing register for GPIO15.\n\nValue on reset: 0"]
805#[derive(Clone, Copy, Debug, PartialEq, Eq)]
806pub enum GPIO15INTERRUPT_CLEAR_A {
807    #[doc = "0: `0`"]
808    NO_CLEAR = 0,
809    #[doc = "1: `1`"]
810    CLEAR = 1,
811}
812impl From<GPIO15INTERRUPT_CLEAR_A> for bool {
813    #[inline(always)]
814    fn from(variant: GPIO15INTERRUPT_CLEAR_A) -> Self {
815        variant as u8 != 0
816    }
817}
818impl REG_GPIO_15_INTERRUPT_CLEAR_R {
819    #[doc = "Get enumerated values variant"]
820    #[inline(always)]
821    pub fn variant(&self) -> GPIO15INTERRUPT_CLEAR_A {
822        match self.bits {
823            false => GPIO15INTERRUPT_CLEAR_A::NO_CLEAR,
824            true => GPIO15INTERRUPT_CLEAR_A::CLEAR,
825        }
826    }
827    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
828    #[inline(always)]
829    pub fn is_no_clear(&self) -> bool {
830        *self == GPIO15INTERRUPT_CLEAR_A::NO_CLEAR
831    }
832    #[doc = "Checks if the value of the field is `CLEAR`"]
833    #[inline(always)]
834    pub fn is_clear(&self) -> bool {
835        *self == GPIO15INTERRUPT_CLEAR_A::CLEAR
836    }
837}
838#[doc = "Field `reg_gpio_15_interrupt_clear` writer - Interrupt clearing register for GPIO15."]
839pub type REG_GPIO_15_INTERRUPT_CLEAR_W<'a, const O: u8> =
840    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO15INTERRUPT_CLEAR_A, O>;
841impl<'a, const O: u8> REG_GPIO_15_INTERRUPT_CLEAR_W<'a, O> {
842    #[doc = "`0`"]
843    #[inline(always)]
844    pub fn no_clear(self) -> &'a mut W {
845        self.variant(GPIO15INTERRUPT_CLEAR_A::NO_CLEAR)
846    }
847    #[doc = "`1`"]
848    #[inline(always)]
849    pub fn clear(self) -> &'a mut W {
850        self.variant(GPIO15INTERRUPT_CLEAR_A::CLEAR)
851    }
852}
853#[doc = "Field `reg_gpio_16_interrupt_clear` reader - Interrupt clearing register for GPIO16."]
854pub type REG_GPIO_16_INTERRUPT_CLEAR_R = crate::BitReader<GPIO16INTERRUPT_CLEAR_A>;
855#[doc = "Interrupt clearing register for GPIO16.\n\nValue on reset: 0"]
856#[derive(Clone, Copy, Debug, PartialEq, Eq)]
857pub enum GPIO16INTERRUPT_CLEAR_A {
858    #[doc = "0: `0`"]
859    NO_CLEAR = 0,
860    #[doc = "1: `1`"]
861    CLEAR = 1,
862}
863impl From<GPIO16INTERRUPT_CLEAR_A> for bool {
864    #[inline(always)]
865    fn from(variant: GPIO16INTERRUPT_CLEAR_A) -> Self {
866        variant as u8 != 0
867    }
868}
869impl REG_GPIO_16_INTERRUPT_CLEAR_R {
870    #[doc = "Get enumerated values variant"]
871    #[inline(always)]
872    pub fn variant(&self) -> GPIO16INTERRUPT_CLEAR_A {
873        match self.bits {
874            false => GPIO16INTERRUPT_CLEAR_A::NO_CLEAR,
875            true => GPIO16INTERRUPT_CLEAR_A::CLEAR,
876        }
877    }
878    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
879    #[inline(always)]
880    pub fn is_no_clear(&self) -> bool {
881        *self == GPIO16INTERRUPT_CLEAR_A::NO_CLEAR
882    }
883    #[doc = "Checks if the value of the field is `CLEAR`"]
884    #[inline(always)]
885    pub fn is_clear(&self) -> bool {
886        *self == GPIO16INTERRUPT_CLEAR_A::CLEAR
887    }
888}
889#[doc = "Field `reg_gpio_16_interrupt_clear` writer - Interrupt clearing register for GPIO16."]
890pub type REG_GPIO_16_INTERRUPT_CLEAR_W<'a, const O: u8> =
891    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO16INTERRUPT_CLEAR_A, O>;
892impl<'a, const O: u8> REG_GPIO_16_INTERRUPT_CLEAR_W<'a, O> {
893    #[doc = "`0`"]
894    #[inline(always)]
895    pub fn no_clear(self) -> &'a mut W {
896        self.variant(GPIO16INTERRUPT_CLEAR_A::NO_CLEAR)
897    }
898    #[doc = "`1`"]
899    #[inline(always)]
900    pub fn clear(self) -> &'a mut W {
901        self.variant(GPIO16INTERRUPT_CLEAR_A::CLEAR)
902    }
903}
904#[doc = "Field `reg_gpio_17_interrupt_clear` reader - Interrupt clearing register for GPIO17."]
905pub type REG_GPIO_17_INTERRUPT_CLEAR_R = crate::BitReader<GPIO17INTERRUPT_CLEAR_A>;
906#[doc = "Interrupt clearing register for GPIO17.\n\nValue on reset: 0"]
907#[derive(Clone, Copy, Debug, PartialEq, Eq)]
908pub enum GPIO17INTERRUPT_CLEAR_A {
909    #[doc = "0: `0`"]
910    NO_CLEAR = 0,
911    #[doc = "1: `1`"]
912    CLEAR = 1,
913}
914impl From<GPIO17INTERRUPT_CLEAR_A> for bool {
915    #[inline(always)]
916    fn from(variant: GPIO17INTERRUPT_CLEAR_A) -> Self {
917        variant as u8 != 0
918    }
919}
920impl REG_GPIO_17_INTERRUPT_CLEAR_R {
921    #[doc = "Get enumerated values variant"]
922    #[inline(always)]
923    pub fn variant(&self) -> GPIO17INTERRUPT_CLEAR_A {
924        match self.bits {
925            false => GPIO17INTERRUPT_CLEAR_A::NO_CLEAR,
926            true => GPIO17INTERRUPT_CLEAR_A::CLEAR,
927        }
928    }
929    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
930    #[inline(always)]
931    pub fn is_no_clear(&self) -> bool {
932        *self == GPIO17INTERRUPT_CLEAR_A::NO_CLEAR
933    }
934    #[doc = "Checks if the value of the field is `CLEAR`"]
935    #[inline(always)]
936    pub fn is_clear(&self) -> bool {
937        *self == GPIO17INTERRUPT_CLEAR_A::CLEAR
938    }
939}
940#[doc = "Field `reg_gpio_17_interrupt_clear` writer - Interrupt clearing register for GPIO17."]
941pub type REG_GPIO_17_INTERRUPT_CLEAR_W<'a, const O: u8> =
942    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO17INTERRUPT_CLEAR_A, O>;
943impl<'a, const O: u8> REG_GPIO_17_INTERRUPT_CLEAR_W<'a, O> {
944    #[doc = "`0`"]
945    #[inline(always)]
946    pub fn no_clear(self) -> &'a mut W {
947        self.variant(GPIO17INTERRUPT_CLEAR_A::NO_CLEAR)
948    }
949    #[doc = "`1`"]
950    #[inline(always)]
951    pub fn clear(self) -> &'a mut W {
952        self.variant(GPIO17INTERRUPT_CLEAR_A::CLEAR)
953    }
954}
955#[doc = "Field `reg_gpio_18_interrupt_clear` reader - Interrupt clearing register for GPIO18."]
956pub type REG_GPIO_18_INTERRUPT_CLEAR_R = crate::BitReader<GPIO18INTERRUPT_CLEAR_A>;
957#[doc = "Interrupt clearing register for GPIO18.\n\nValue on reset: 0"]
958#[derive(Clone, Copy, Debug, PartialEq, Eq)]
959pub enum GPIO18INTERRUPT_CLEAR_A {
960    #[doc = "0: `0`"]
961    NO_CLEAR = 0,
962    #[doc = "1: `1`"]
963    CLEAR = 1,
964}
965impl From<GPIO18INTERRUPT_CLEAR_A> for bool {
966    #[inline(always)]
967    fn from(variant: GPIO18INTERRUPT_CLEAR_A) -> Self {
968        variant as u8 != 0
969    }
970}
971impl REG_GPIO_18_INTERRUPT_CLEAR_R {
972    #[doc = "Get enumerated values variant"]
973    #[inline(always)]
974    pub fn variant(&self) -> GPIO18INTERRUPT_CLEAR_A {
975        match self.bits {
976            false => GPIO18INTERRUPT_CLEAR_A::NO_CLEAR,
977            true => GPIO18INTERRUPT_CLEAR_A::CLEAR,
978        }
979    }
980    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
981    #[inline(always)]
982    pub fn is_no_clear(&self) -> bool {
983        *self == GPIO18INTERRUPT_CLEAR_A::NO_CLEAR
984    }
985    #[doc = "Checks if the value of the field is `CLEAR`"]
986    #[inline(always)]
987    pub fn is_clear(&self) -> bool {
988        *self == GPIO18INTERRUPT_CLEAR_A::CLEAR
989    }
990}
991#[doc = "Field `reg_gpio_18_interrupt_clear` writer - Interrupt clearing register for GPIO18."]
992pub type REG_GPIO_18_INTERRUPT_CLEAR_W<'a, const O: u8> =
993    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO18INTERRUPT_CLEAR_A, O>;
994impl<'a, const O: u8> REG_GPIO_18_INTERRUPT_CLEAR_W<'a, O> {
995    #[doc = "`0`"]
996    #[inline(always)]
997    pub fn no_clear(self) -> &'a mut W {
998        self.variant(GPIO18INTERRUPT_CLEAR_A::NO_CLEAR)
999    }
1000    #[doc = "`1`"]
1001    #[inline(always)]
1002    pub fn clear(self) -> &'a mut W {
1003        self.variant(GPIO18INTERRUPT_CLEAR_A::CLEAR)
1004    }
1005}
1006#[doc = "Field `reg_gpio_19_interrupt_clear` reader - Interrupt clearing register for GPIO19."]
1007pub type REG_GPIO_19_INTERRUPT_CLEAR_R = crate::BitReader<GPIO19INTERRUPT_CLEAR_A>;
1008#[doc = "Interrupt clearing register for GPIO19.\n\nValue on reset: 0"]
1009#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1010pub enum GPIO19INTERRUPT_CLEAR_A {
1011    #[doc = "0: `0`"]
1012    NO_CLEAR = 0,
1013    #[doc = "1: `1`"]
1014    CLEAR = 1,
1015}
1016impl From<GPIO19INTERRUPT_CLEAR_A> for bool {
1017    #[inline(always)]
1018    fn from(variant: GPIO19INTERRUPT_CLEAR_A) -> Self {
1019        variant as u8 != 0
1020    }
1021}
1022impl REG_GPIO_19_INTERRUPT_CLEAR_R {
1023    #[doc = "Get enumerated values variant"]
1024    #[inline(always)]
1025    pub fn variant(&self) -> GPIO19INTERRUPT_CLEAR_A {
1026        match self.bits {
1027            false => GPIO19INTERRUPT_CLEAR_A::NO_CLEAR,
1028            true => GPIO19INTERRUPT_CLEAR_A::CLEAR,
1029        }
1030    }
1031    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1032    #[inline(always)]
1033    pub fn is_no_clear(&self) -> bool {
1034        *self == GPIO19INTERRUPT_CLEAR_A::NO_CLEAR
1035    }
1036    #[doc = "Checks if the value of the field is `CLEAR`"]
1037    #[inline(always)]
1038    pub fn is_clear(&self) -> bool {
1039        *self == GPIO19INTERRUPT_CLEAR_A::CLEAR
1040    }
1041}
1042#[doc = "Field `reg_gpio_19_interrupt_clear` writer - Interrupt clearing register for GPIO19."]
1043pub type REG_GPIO_19_INTERRUPT_CLEAR_W<'a, const O: u8> =
1044    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO19INTERRUPT_CLEAR_A, O>;
1045impl<'a, const O: u8> REG_GPIO_19_INTERRUPT_CLEAR_W<'a, O> {
1046    #[doc = "`0`"]
1047    #[inline(always)]
1048    pub fn no_clear(self) -> &'a mut W {
1049        self.variant(GPIO19INTERRUPT_CLEAR_A::NO_CLEAR)
1050    }
1051    #[doc = "`1`"]
1052    #[inline(always)]
1053    pub fn clear(self) -> &'a mut W {
1054        self.variant(GPIO19INTERRUPT_CLEAR_A::CLEAR)
1055    }
1056}
1057#[doc = "Field `reg_gpio_20_interrupt_clear` reader - Interrupt clearing register for GPIO20."]
1058pub type REG_GPIO_20_INTERRUPT_CLEAR_R = crate::BitReader<GPIO20INTERRUPT_CLEAR_A>;
1059#[doc = "Interrupt clearing register for GPIO20.\n\nValue on reset: 0"]
1060#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1061pub enum GPIO20INTERRUPT_CLEAR_A {
1062    #[doc = "0: `0`"]
1063    NO_CLEAR = 0,
1064    #[doc = "1: `1`"]
1065    CLEAR = 1,
1066}
1067impl From<GPIO20INTERRUPT_CLEAR_A> for bool {
1068    #[inline(always)]
1069    fn from(variant: GPIO20INTERRUPT_CLEAR_A) -> Self {
1070        variant as u8 != 0
1071    }
1072}
1073impl REG_GPIO_20_INTERRUPT_CLEAR_R {
1074    #[doc = "Get enumerated values variant"]
1075    #[inline(always)]
1076    pub fn variant(&self) -> GPIO20INTERRUPT_CLEAR_A {
1077        match self.bits {
1078            false => GPIO20INTERRUPT_CLEAR_A::NO_CLEAR,
1079            true => GPIO20INTERRUPT_CLEAR_A::CLEAR,
1080        }
1081    }
1082    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1083    #[inline(always)]
1084    pub fn is_no_clear(&self) -> bool {
1085        *self == GPIO20INTERRUPT_CLEAR_A::NO_CLEAR
1086    }
1087    #[doc = "Checks if the value of the field is `CLEAR`"]
1088    #[inline(always)]
1089    pub fn is_clear(&self) -> bool {
1090        *self == GPIO20INTERRUPT_CLEAR_A::CLEAR
1091    }
1092}
1093#[doc = "Field `reg_gpio_20_interrupt_clear` writer - Interrupt clearing register for GPIO20."]
1094pub type REG_GPIO_20_INTERRUPT_CLEAR_W<'a, const O: u8> =
1095    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO20INTERRUPT_CLEAR_A, O>;
1096impl<'a, const O: u8> REG_GPIO_20_INTERRUPT_CLEAR_W<'a, O> {
1097    #[doc = "`0`"]
1098    #[inline(always)]
1099    pub fn no_clear(self) -> &'a mut W {
1100        self.variant(GPIO20INTERRUPT_CLEAR_A::NO_CLEAR)
1101    }
1102    #[doc = "`1`"]
1103    #[inline(always)]
1104    pub fn clear(self) -> &'a mut W {
1105        self.variant(GPIO20INTERRUPT_CLEAR_A::CLEAR)
1106    }
1107}
1108#[doc = "Field `reg_gpio_21_interrupt_clear` reader - Interrupt clearing register for GPIO21."]
1109pub type REG_GPIO_21_INTERRUPT_CLEAR_R = crate::BitReader<GPIO21INTERRUPT_CLEAR_A>;
1110#[doc = "Interrupt clearing register for GPIO21.\n\nValue on reset: 0"]
1111#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1112pub enum GPIO21INTERRUPT_CLEAR_A {
1113    #[doc = "0: `0`"]
1114    NO_CLEAR = 0,
1115    #[doc = "1: `1`"]
1116    CLEAR = 1,
1117}
1118impl From<GPIO21INTERRUPT_CLEAR_A> for bool {
1119    #[inline(always)]
1120    fn from(variant: GPIO21INTERRUPT_CLEAR_A) -> Self {
1121        variant as u8 != 0
1122    }
1123}
1124impl REG_GPIO_21_INTERRUPT_CLEAR_R {
1125    #[doc = "Get enumerated values variant"]
1126    #[inline(always)]
1127    pub fn variant(&self) -> GPIO21INTERRUPT_CLEAR_A {
1128        match self.bits {
1129            false => GPIO21INTERRUPT_CLEAR_A::NO_CLEAR,
1130            true => GPIO21INTERRUPT_CLEAR_A::CLEAR,
1131        }
1132    }
1133    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1134    #[inline(always)]
1135    pub fn is_no_clear(&self) -> bool {
1136        *self == GPIO21INTERRUPT_CLEAR_A::NO_CLEAR
1137    }
1138    #[doc = "Checks if the value of the field is `CLEAR`"]
1139    #[inline(always)]
1140    pub fn is_clear(&self) -> bool {
1141        *self == GPIO21INTERRUPT_CLEAR_A::CLEAR
1142    }
1143}
1144#[doc = "Field `reg_gpio_21_interrupt_clear` writer - Interrupt clearing register for GPIO21."]
1145pub type REG_GPIO_21_INTERRUPT_CLEAR_W<'a, const O: u8> =
1146    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO21INTERRUPT_CLEAR_A, O>;
1147impl<'a, const O: u8> REG_GPIO_21_INTERRUPT_CLEAR_W<'a, O> {
1148    #[doc = "`0`"]
1149    #[inline(always)]
1150    pub fn no_clear(self) -> &'a mut W {
1151        self.variant(GPIO21INTERRUPT_CLEAR_A::NO_CLEAR)
1152    }
1153    #[doc = "`1`"]
1154    #[inline(always)]
1155    pub fn clear(self) -> &'a mut W {
1156        self.variant(GPIO21INTERRUPT_CLEAR_A::CLEAR)
1157    }
1158}
1159#[doc = "Field `reg_gpio_22_interrupt_clear` reader - Interrupt clearing register for GPIO22."]
1160pub type REG_GPIO_22_INTERRUPT_CLEAR_R = crate::BitReader<GPIO22INTERRUPT_CLEAR_A>;
1161#[doc = "Interrupt clearing register for GPIO22.\n\nValue on reset: 0"]
1162#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1163pub enum GPIO22INTERRUPT_CLEAR_A {
1164    #[doc = "0: `0`"]
1165    NO_CLEAR = 0,
1166    #[doc = "1: `1`"]
1167    CLEAR = 1,
1168}
1169impl From<GPIO22INTERRUPT_CLEAR_A> for bool {
1170    #[inline(always)]
1171    fn from(variant: GPIO22INTERRUPT_CLEAR_A) -> Self {
1172        variant as u8 != 0
1173    }
1174}
1175impl REG_GPIO_22_INTERRUPT_CLEAR_R {
1176    #[doc = "Get enumerated values variant"]
1177    #[inline(always)]
1178    pub fn variant(&self) -> GPIO22INTERRUPT_CLEAR_A {
1179        match self.bits {
1180            false => GPIO22INTERRUPT_CLEAR_A::NO_CLEAR,
1181            true => GPIO22INTERRUPT_CLEAR_A::CLEAR,
1182        }
1183    }
1184    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1185    #[inline(always)]
1186    pub fn is_no_clear(&self) -> bool {
1187        *self == GPIO22INTERRUPT_CLEAR_A::NO_CLEAR
1188    }
1189    #[doc = "Checks if the value of the field is `CLEAR`"]
1190    #[inline(always)]
1191    pub fn is_clear(&self) -> bool {
1192        *self == GPIO22INTERRUPT_CLEAR_A::CLEAR
1193    }
1194}
1195#[doc = "Field `reg_gpio_22_interrupt_clear` writer - Interrupt clearing register for GPIO22."]
1196pub type REG_GPIO_22_INTERRUPT_CLEAR_W<'a, const O: u8> =
1197    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO22INTERRUPT_CLEAR_A, O>;
1198impl<'a, const O: u8> REG_GPIO_22_INTERRUPT_CLEAR_W<'a, O> {
1199    #[doc = "`0`"]
1200    #[inline(always)]
1201    pub fn no_clear(self) -> &'a mut W {
1202        self.variant(GPIO22INTERRUPT_CLEAR_A::NO_CLEAR)
1203    }
1204    #[doc = "`1`"]
1205    #[inline(always)]
1206    pub fn clear(self) -> &'a mut W {
1207        self.variant(GPIO22INTERRUPT_CLEAR_A::CLEAR)
1208    }
1209}
1210#[doc = "Field `reg_gpio_23_interrupt_clear` reader - Interrupt clearing register for GPIO23."]
1211pub type REG_GPIO_23_INTERRUPT_CLEAR_R = crate::BitReader<GPIO23INTERRUPT_CLEAR_A>;
1212#[doc = "Interrupt clearing register for GPIO23.\n\nValue on reset: 0"]
1213#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1214pub enum GPIO23INTERRUPT_CLEAR_A {
1215    #[doc = "0: `0`"]
1216    NO_CLEAR = 0,
1217    #[doc = "1: `1`"]
1218    CLEAR = 1,
1219}
1220impl From<GPIO23INTERRUPT_CLEAR_A> for bool {
1221    #[inline(always)]
1222    fn from(variant: GPIO23INTERRUPT_CLEAR_A) -> Self {
1223        variant as u8 != 0
1224    }
1225}
1226impl REG_GPIO_23_INTERRUPT_CLEAR_R {
1227    #[doc = "Get enumerated values variant"]
1228    #[inline(always)]
1229    pub fn variant(&self) -> GPIO23INTERRUPT_CLEAR_A {
1230        match self.bits {
1231            false => GPIO23INTERRUPT_CLEAR_A::NO_CLEAR,
1232            true => GPIO23INTERRUPT_CLEAR_A::CLEAR,
1233        }
1234    }
1235    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1236    #[inline(always)]
1237    pub fn is_no_clear(&self) -> bool {
1238        *self == GPIO23INTERRUPT_CLEAR_A::NO_CLEAR
1239    }
1240    #[doc = "Checks if the value of the field is `CLEAR`"]
1241    #[inline(always)]
1242    pub fn is_clear(&self) -> bool {
1243        *self == GPIO23INTERRUPT_CLEAR_A::CLEAR
1244    }
1245}
1246#[doc = "Field `reg_gpio_23_interrupt_clear` writer - Interrupt clearing register for GPIO23."]
1247pub type REG_GPIO_23_INTERRUPT_CLEAR_W<'a, const O: u8> =
1248    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO23INTERRUPT_CLEAR_A, O>;
1249impl<'a, const O: u8> REG_GPIO_23_INTERRUPT_CLEAR_W<'a, O> {
1250    #[doc = "`0`"]
1251    #[inline(always)]
1252    pub fn no_clear(self) -> &'a mut W {
1253        self.variant(GPIO23INTERRUPT_CLEAR_A::NO_CLEAR)
1254    }
1255    #[doc = "`1`"]
1256    #[inline(always)]
1257    pub fn clear(self) -> &'a mut W {
1258        self.variant(GPIO23INTERRUPT_CLEAR_A::CLEAR)
1259    }
1260}
1261#[doc = "Field `reg_gpio_24_interrupt_clear` reader - Interrupt clearing register for GPIO24."]
1262pub type REG_GPIO_24_INTERRUPT_CLEAR_R = crate::BitReader<GPIO24INTERRUPT_CLEAR_A>;
1263#[doc = "Interrupt clearing register for GPIO24.\n\nValue on reset: 0"]
1264#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1265pub enum GPIO24INTERRUPT_CLEAR_A {
1266    #[doc = "0: `0`"]
1267    NO_CLEAR = 0,
1268    #[doc = "1: `1`"]
1269    CLEAR = 1,
1270}
1271impl From<GPIO24INTERRUPT_CLEAR_A> for bool {
1272    #[inline(always)]
1273    fn from(variant: GPIO24INTERRUPT_CLEAR_A) -> Self {
1274        variant as u8 != 0
1275    }
1276}
1277impl REG_GPIO_24_INTERRUPT_CLEAR_R {
1278    #[doc = "Get enumerated values variant"]
1279    #[inline(always)]
1280    pub fn variant(&self) -> GPIO24INTERRUPT_CLEAR_A {
1281        match self.bits {
1282            false => GPIO24INTERRUPT_CLEAR_A::NO_CLEAR,
1283            true => GPIO24INTERRUPT_CLEAR_A::CLEAR,
1284        }
1285    }
1286    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1287    #[inline(always)]
1288    pub fn is_no_clear(&self) -> bool {
1289        *self == GPIO24INTERRUPT_CLEAR_A::NO_CLEAR
1290    }
1291    #[doc = "Checks if the value of the field is `CLEAR`"]
1292    #[inline(always)]
1293    pub fn is_clear(&self) -> bool {
1294        *self == GPIO24INTERRUPT_CLEAR_A::CLEAR
1295    }
1296}
1297#[doc = "Field `reg_gpio_24_interrupt_clear` writer - Interrupt clearing register for GPIO24."]
1298pub type REG_GPIO_24_INTERRUPT_CLEAR_W<'a, const O: u8> =
1299    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO24INTERRUPT_CLEAR_A, O>;
1300impl<'a, const O: u8> REG_GPIO_24_INTERRUPT_CLEAR_W<'a, O> {
1301    #[doc = "`0`"]
1302    #[inline(always)]
1303    pub fn no_clear(self) -> &'a mut W {
1304        self.variant(GPIO24INTERRUPT_CLEAR_A::NO_CLEAR)
1305    }
1306    #[doc = "`1`"]
1307    #[inline(always)]
1308    pub fn clear(self) -> &'a mut W {
1309        self.variant(GPIO24INTERRUPT_CLEAR_A::CLEAR)
1310    }
1311}
1312#[doc = "Field `reg_gpio_25_interrupt_clear` reader - Interrupt clearing register for GPIO25."]
1313pub type REG_GPIO_25_INTERRUPT_CLEAR_R = crate::BitReader<GPIO25INTERRUPT_CLEAR_A>;
1314#[doc = "Interrupt clearing register for GPIO25.\n\nValue on reset: 0"]
1315#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1316pub enum GPIO25INTERRUPT_CLEAR_A {
1317    #[doc = "0: `0`"]
1318    NO_CLEAR = 0,
1319    #[doc = "1: `1`"]
1320    CLEAR = 1,
1321}
1322impl From<GPIO25INTERRUPT_CLEAR_A> for bool {
1323    #[inline(always)]
1324    fn from(variant: GPIO25INTERRUPT_CLEAR_A) -> Self {
1325        variant as u8 != 0
1326    }
1327}
1328impl REG_GPIO_25_INTERRUPT_CLEAR_R {
1329    #[doc = "Get enumerated values variant"]
1330    #[inline(always)]
1331    pub fn variant(&self) -> GPIO25INTERRUPT_CLEAR_A {
1332        match self.bits {
1333            false => GPIO25INTERRUPT_CLEAR_A::NO_CLEAR,
1334            true => GPIO25INTERRUPT_CLEAR_A::CLEAR,
1335        }
1336    }
1337    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1338    #[inline(always)]
1339    pub fn is_no_clear(&self) -> bool {
1340        *self == GPIO25INTERRUPT_CLEAR_A::NO_CLEAR
1341    }
1342    #[doc = "Checks if the value of the field is `CLEAR`"]
1343    #[inline(always)]
1344    pub fn is_clear(&self) -> bool {
1345        *self == GPIO25INTERRUPT_CLEAR_A::CLEAR
1346    }
1347}
1348#[doc = "Field `reg_gpio_25_interrupt_clear` writer - Interrupt clearing register for GPIO25."]
1349pub type REG_GPIO_25_INTERRUPT_CLEAR_W<'a, const O: u8> =
1350    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO25INTERRUPT_CLEAR_A, O>;
1351impl<'a, const O: u8> REG_GPIO_25_INTERRUPT_CLEAR_W<'a, O> {
1352    #[doc = "`0`"]
1353    #[inline(always)]
1354    pub fn no_clear(self) -> &'a mut W {
1355        self.variant(GPIO25INTERRUPT_CLEAR_A::NO_CLEAR)
1356    }
1357    #[doc = "`1`"]
1358    #[inline(always)]
1359    pub fn clear(self) -> &'a mut W {
1360        self.variant(GPIO25INTERRUPT_CLEAR_A::CLEAR)
1361    }
1362}
1363#[doc = "Field `reg_gpio_26_interrupt_clear` reader - Interrupt clearing register for GPIO26."]
1364pub type REG_GPIO_26_INTERRUPT_CLEAR_R = crate::BitReader<GPIO26INTERRUPT_CLEAR_A>;
1365#[doc = "Interrupt clearing register for GPIO26.\n\nValue on reset: 0"]
1366#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1367pub enum GPIO26INTERRUPT_CLEAR_A {
1368    #[doc = "0: `0`"]
1369    NO_CLEAR = 0,
1370    #[doc = "1: `1`"]
1371    CLEAR = 1,
1372}
1373impl From<GPIO26INTERRUPT_CLEAR_A> for bool {
1374    #[inline(always)]
1375    fn from(variant: GPIO26INTERRUPT_CLEAR_A) -> Self {
1376        variant as u8 != 0
1377    }
1378}
1379impl REG_GPIO_26_INTERRUPT_CLEAR_R {
1380    #[doc = "Get enumerated values variant"]
1381    #[inline(always)]
1382    pub fn variant(&self) -> GPIO26INTERRUPT_CLEAR_A {
1383        match self.bits {
1384            false => GPIO26INTERRUPT_CLEAR_A::NO_CLEAR,
1385            true => GPIO26INTERRUPT_CLEAR_A::CLEAR,
1386        }
1387    }
1388    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1389    #[inline(always)]
1390    pub fn is_no_clear(&self) -> bool {
1391        *self == GPIO26INTERRUPT_CLEAR_A::NO_CLEAR
1392    }
1393    #[doc = "Checks if the value of the field is `CLEAR`"]
1394    #[inline(always)]
1395    pub fn is_clear(&self) -> bool {
1396        *self == GPIO26INTERRUPT_CLEAR_A::CLEAR
1397    }
1398}
1399#[doc = "Field `reg_gpio_26_interrupt_clear` writer - Interrupt clearing register for GPIO26."]
1400pub type REG_GPIO_26_INTERRUPT_CLEAR_W<'a, const O: u8> =
1401    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO26INTERRUPT_CLEAR_A, O>;
1402impl<'a, const O: u8> REG_GPIO_26_INTERRUPT_CLEAR_W<'a, O> {
1403    #[doc = "`0`"]
1404    #[inline(always)]
1405    pub fn no_clear(self) -> &'a mut W {
1406        self.variant(GPIO26INTERRUPT_CLEAR_A::NO_CLEAR)
1407    }
1408    #[doc = "`1`"]
1409    #[inline(always)]
1410    pub fn clear(self) -> &'a mut W {
1411        self.variant(GPIO26INTERRUPT_CLEAR_A::CLEAR)
1412    }
1413}
1414#[doc = "Field `reg_gpio_27_interrupt_clear` reader - Interrupt clearing register for GPIO27."]
1415pub type REG_GPIO_27_INTERRUPT_CLEAR_R = crate::BitReader<GPIO27INTERRUPT_CLEAR_A>;
1416#[doc = "Interrupt clearing register for GPIO27.\n\nValue on reset: 0"]
1417#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1418pub enum GPIO27INTERRUPT_CLEAR_A {
1419    #[doc = "0: `0`"]
1420    NO_CLEAR = 0,
1421    #[doc = "1: `1`"]
1422    CLEAR = 1,
1423}
1424impl From<GPIO27INTERRUPT_CLEAR_A> for bool {
1425    #[inline(always)]
1426    fn from(variant: GPIO27INTERRUPT_CLEAR_A) -> Self {
1427        variant as u8 != 0
1428    }
1429}
1430impl REG_GPIO_27_INTERRUPT_CLEAR_R {
1431    #[doc = "Get enumerated values variant"]
1432    #[inline(always)]
1433    pub fn variant(&self) -> GPIO27INTERRUPT_CLEAR_A {
1434        match self.bits {
1435            false => GPIO27INTERRUPT_CLEAR_A::NO_CLEAR,
1436            true => GPIO27INTERRUPT_CLEAR_A::CLEAR,
1437        }
1438    }
1439    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1440    #[inline(always)]
1441    pub fn is_no_clear(&self) -> bool {
1442        *self == GPIO27INTERRUPT_CLEAR_A::NO_CLEAR
1443    }
1444    #[doc = "Checks if the value of the field is `CLEAR`"]
1445    #[inline(always)]
1446    pub fn is_clear(&self) -> bool {
1447        *self == GPIO27INTERRUPT_CLEAR_A::CLEAR
1448    }
1449}
1450#[doc = "Field `reg_gpio_27_interrupt_clear` writer - Interrupt clearing register for GPIO27."]
1451pub type REG_GPIO_27_INTERRUPT_CLEAR_W<'a, const O: u8> =
1452    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO27INTERRUPT_CLEAR_A, O>;
1453impl<'a, const O: u8> REG_GPIO_27_INTERRUPT_CLEAR_W<'a, O> {
1454    #[doc = "`0`"]
1455    #[inline(always)]
1456    pub fn no_clear(self) -> &'a mut W {
1457        self.variant(GPIO27INTERRUPT_CLEAR_A::NO_CLEAR)
1458    }
1459    #[doc = "`1`"]
1460    #[inline(always)]
1461    pub fn clear(self) -> &'a mut W {
1462        self.variant(GPIO27INTERRUPT_CLEAR_A::CLEAR)
1463    }
1464}
1465#[doc = "Field `reg_gpio_28_interrupt_clear` reader - Interrupt clearing register for GPIO28."]
1466pub type REG_GPIO_28_INTERRUPT_CLEAR_R = crate::BitReader<GPIO28INTERRUPT_CLEAR_A>;
1467#[doc = "Interrupt clearing register for GPIO28.\n\nValue on reset: 0"]
1468#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1469pub enum GPIO28INTERRUPT_CLEAR_A {
1470    #[doc = "0: `0`"]
1471    NO_CLEAR = 0,
1472    #[doc = "1: `1`"]
1473    CLEAR = 1,
1474}
1475impl From<GPIO28INTERRUPT_CLEAR_A> for bool {
1476    #[inline(always)]
1477    fn from(variant: GPIO28INTERRUPT_CLEAR_A) -> Self {
1478        variant as u8 != 0
1479    }
1480}
1481impl REG_GPIO_28_INTERRUPT_CLEAR_R {
1482    #[doc = "Get enumerated values variant"]
1483    #[inline(always)]
1484    pub fn variant(&self) -> GPIO28INTERRUPT_CLEAR_A {
1485        match self.bits {
1486            false => GPIO28INTERRUPT_CLEAR_A::NO_CLEAR,
1487            true => GPIO28INTERRUPT_CLEAR_A::CLEAR,
1488        }
1489    }
1490    #[doc = "Checks if the value of the field is `NO_CLEAR`"]
1491    #[inline(always)]
1492    pub fn is_no_clear(&self) -> bool {
1493        *self == GPIO28INTERRUPT_CLEAR_A::NO_CLEAR
1494    }
1495    #[doc = "Checks if the value of the field is `CLEAR`"]
1496    #[inline(always)]
1497    pub fn is_clear(&self) -> bool {
1498        *self == GPIO28INTERRUPT_CLEAR_A::CLEAR
1499    }
1500}
1501#[doc = "Field `reg_gpio_28_interrupt_clear` writer - Interrupt clearing register for GPIO28."]
1502pub type REG_GPIO_28_INTERRUPT_CLEAR_W<'a, const O: u8> =
1503    crate::BitWriter<'a, u32, GPIO_INT_CLR1_SPEC, GPIO28INTERRUPT_CLEAR_A, O>;
1504impl<'a, const O: u8> REG_GPIO_28_INTERRUPT_CLEAR_W<'a, O> {
1505    #[doc = "`0`"]
1506    #[inline(always)]
1507    pub fn no_clear(self) -> &'a mut W {
1508        self.variant(GPIO28INTERRUPT_CLEAR_A::NO_CLEAR)
1509    }
1510    #[doc = "`1`"]
1511    #[inline(always)]
1512    pub fn clear(self) -> &'a mut W {
1513        self.variant(GPIO28INTERRUPT_CLEAR_A::CLEAR)
1514    }
1515}
1516impl R {
1517    #[doc = "Bit 0 - Interrupt clearing register for GPIO0."]
1518    #[inline(always)]
1519    pub fn reg_gpio_0_interrupt_clear(&self) -> REG_GPIO_0_INTERRUPT_CLEAR_R {
1520        REG_GPIO_0_INTERRUPT_CLEAR_R::new((self.bits & 1) != 0)
1521    }
1522    #[doc = "Bit 1 - Interrupt clearing register for GPIO1."]
1523    #[inline(always)]
1524    pub fn reg_gpio_1_interrupt_clear(&self) -> REG_GPIO_1_INTERRUPT_CLEAR_R {
1525        REG_GPIO_1_INTERRUPT_CLEAR_R::new(((self.bits >> 1) & 1) != 0)
1526    }
1527    #[doc = "Bit 2 - Interrupt clearing register for GPIO2."]
1528    #[inline(always)]
1529    pub fn reg_gpio_2_interrupt_clear(&self) -> REG_GPIO_2_INTERRUPT_CLEAR_R {
1530        REG_GPIO_2_INTERRUPT_CLEAR_R::new(((self.bits >> 2) & 1) != 0)
1531    }
1532    #[doc = "Bit 3 - Interrupt clearing register for GPIO3."]
1533    #[inline(always)]
1534    pub fn reg_gpio_3_interrupt_clear(&self) -> REG_GPIO_3_INTERRUPT_CLEAR_R {
1535        REG_GPIO_3_INTERRUPT_CLEAR_R::new(((self.bits >> 3) & 1) != 0)
1536    }
1537    #[doc = "Bit 4 - Interrupt clearing register for GPIO4."]
1538    #[inline(always)]
1539    pub fn reg_gpio_4_interrupt_clear(&self) -> REG_GPIO_4_INTERRUPT_CLEAR_R {
1540        REG_GPIO_4_INTERRUPT_CLEAR_R::new(((self.bits >> 4) & 1) != 0)
1541    }
1542    #[doc = "Bit 5 - Interrupt clearing register for GPIO5."]
1543    #[inline(always)]
1544    pub fn reg_gpio_5_interrupt_clear(&self) -> REG_GPIO_5_INTERRUPT_CLEAR_R {
1545        REG_GPIO_5_INTERRUPT_CLEAR_R::new(((self.bits >> 5) & 1) != 0)
1546    }
1547    #[doc = "Bit 6 - Interrupt clearing register for GPIO6."]
1548    #[inline(always)]
1549    pub fn reg_gpio_6_interrupt_clear(&self) -> REG_GPIO_6_INTERRUPT_CLEAR_R {
1550        REG_GPIO_6_INTERRUPT_CLEAR_R::new(((self.bits >> 6) & 1) != 0)
1551    }
1552    #[doc = "Bit 7 - Interrupt clearing register for GPIO7."]
1553    #[inline(always)]
1554    pub fn reg_gpio_7_interrupt_clear(&self) -> REG_GPIO_7_INTERRUPT_CLEAR_R {
1555        REG_GPIO_7_INTERRUPT_CLEAR_R::new(((self.bits >> 7) & 1) != 0)
1556    }
1557    #[doc = "Bit 8 - Interrupt clearing register for GPIO8."]
1558    #[inline(always)]
1559    pub fn reg_gpio_8_interrupt_clear(&self) -> REG_GPIO_8_INTERRUPT_CLEAR_R {
1560        REG_GPIO_8_INTERRUPT_CLEAR_R::new(((self.bits >> 8) & 1) != 0)
1561    }
1562    #[doc = "Bit 9 - Interrupt clearing register for GPIO9."]
1563    #[inline(always)]
1564    pub fn reg_gpio_9_interrupt_clear(&self) -> REG_GPIO_9_INTERRUPT_CLEAR_R {
1565        REG_GPIO_9_INTERRUPT_CLEAR_R::new(((self.bits >> 9) & 1) != 0)
1566    }
1567    #[doc = "Bit 10 - Interrupt clearing register for GPIO10."]
1568    #[inline(always)]
1569    pub fn reg_gpio_10_interrupt_clear(&self) -> REG_GPIO_10_INTERRUPT_CLEAR_R {
1570        REG_GPIO_10_INTERRUPT_CLEAR_R::new(((self.bits >> 10) & 1) != 0)
1571    }
1572    #[doc = "Bit 11 - Interrupt clearing register for GPIO11."]
1573    #[inline(always)]
1574    pub fn reg_gpio_11_interrupt_clear(&self) -> REG_GPIO_11_INTERRUPT_CLEAR_R {
1575        REG_GPIO_11_INTERRUPT_CLEAR_R::new(((self.bits >> 11) & 1) != 0)
1576    }
1577    #[doc = "Bit 12 - Interrupt clearing register for GPIO12."]
1578    #[inline(always)]
1579    pub fn reg_gpio_12_interrupt_clear(&self) -> REG_GPIO_12_INTERRUPT_CLEAR_R {
1580        REG_GPIO_12_INTERRUPT_CLEAR_R::new(((self.bits >> 12) & 1) != 0)
1581    }
1582    #[doc = "Bit 13 - Interrupt clearing register for GPIO13."]
1583    #[inline(always)]
1584    pub fn reg_gpio_13_interrupt_clear(&self) -> REG_GPIO_13_INTERRUPT_CLEAR_R {
1585        REG_GPIO_13_INTERRUPT_CLEAR_R::new(((self.bits >> 13) & 1) != 0)
1586    }
1587    #[doc = "Bit 14 - Interrupt clearing register for GPIO14."]
1588    #[inline(always)]
1589    pub fn reg_gpio_14_interrupt_clear(&self) -> REG_GPIO_14_INTERRUPT_CLEAR_R {
1590        REG_GPIO_14_INTERRUPT_CLEAR_R::new(((self.bits >> 14) & 1) != 0)
1591    }
1592    #[doc = "Bit 15 - Interrupt clearing register for GPIO15."]
1593    #[inline(always)]
1594    pub fn reg_gpio_15_interrupt_clear(&self) -> REG_GPIO_15_INTERRUPT_CLEAR_R {
1595        REG_GPIO_15_INTERRUPT_CLEAR_R::new(((self.bits >> 15) & 1) != 0)
1596    }
1597    #[doc = "Bit 16 - Interrupt clearing register for GPIO16."]
1598    #[inline(always)]
1599    pub fn reg_gpio_16_interrupt_clear(&self) -> REG_GPIO_16_INTERRUPT_CLEAR_R {
1600        REG_GPIO_16_INTERRUPT_CLEAR_R::new(((self.bits >> 16) & 1) != 0)
1601    }
1602    #[doc = "Bit 17 - Interrupt clearing register for GPIO17."]
1603    #[inline(always)]
1604    pub fn reg_gpio_17_interrupt_clear(&self) -> REG_GPIO_17_INTERRUPT_CLEAR_R {
1605        REG_GPIO_17_INTERRUPT_CLEAR_R::new(((self.bits >> 17) & 1) != 0)
1606    }
1607    #[doc = "Bit 18 - Interrupt clearing register for GPIO18."]
1608    #[inline(always)]
1609    pub fn reg_gpio_18_interrupt_clear(&self) -> REG_GPIO_18_INTERRUPT_CLEAR_R {
1610        REG_GPIO_18_INTERRUPT_CLEAR_R::new(((self.bits >> 18) & 1) != 0)
1611    }
1612    #[doc = "Bit 19 - Interrupt clearing register for GPIO19."]
1613    #[inline(always)]
1614    pub fn reg_gpio_19_interrupt_clear(&self) -> REG_GPIO_19_INTERRUPT_CLEAR_R {
1615        REG_GPIO_19_INTERRUPT_CLEAR_R::new(((self.bits >> 19) & 1) != 0)
1616    }
1617    #[doc = "Bit 20 - Interrupt clearing register for GPIO20."]
1618    #[inline(always)]
1619    pub fn reg_gpio_20_interrupt_clear(&self) -> REG_GPIO_20_INTERRUPT_CLEAR_R {
1620        REG_GPIO_20_INTERRUPT_CLEAR_R::new(((self.bits >> 20) & 1) != 0)
1621    }
1622    #[doc = "Bit 21 - Interrupt clearing register for GPIO21."]
1623    #[inline(always)]
1624    pub fn reg_gpio_21_interrupt_clear(&self) -> REG_GPIO_21_INTERRUPT_CLEAR_R {
1625        REG_GPIO_21_INTERRUPT_CLEAR_R::new(((self.bits >> 21) & 1) != 0)
1626    }
1627    #[doc = "Bit 22 - Interrupt clearing register for GPIO22."]
1628    #[inline(always)]
1629    pub fn reg_gpio_22_interrupt_clear(&self) -> REG_GPIO_22_INTERRUPT_CLEAR_R {
1630        REG_GPIO_22_INTERRUPT_CLEAR_R::new(((self.bits >> 22) & 1) != 0)
1631    }
1632    #[doc = "Bit 23 - Interrupt clearing register for GPIO23."]
1633    #[inline(always)]
1634    pub fn reg_gpio_23_interrupt_clear(&self) -> REG_GPIO_23_INTERRUPT_CLEAR_R {
1635        REG_GPIO_23_INTERRUPT_CLEAR_R::new(((self.bits >> 23) & 1) != 0)
1636    }
1637    #[doc = "Bit 24 - Interrupt clearing register for GPIO24."]
1638    #[inline(always)]
1639    pub fn reg_gpio_24_interrupt_clear(&self) -> REG_GPIO_24_INTERRUPT_CLEAR_R {
1640        REG_GPIO_24_INTERRUPT_CLEAR_R::new(((self.bits >> 24) & 1) != 0)
1641    }
1642    #[doc = "Bit 25 - Interrupt clearing register for GPIO25."]
1643    #[inline(always)]
1644    pub fn reg_gpio_25_interrupt_clear(&self) -> REG_GPIO_25_INTERRUPT_CLEAR_R {
1645        REG_GPIO_25_INTERRUPT_CLEAR_R::new(((self.bits >> 25) & 1) != 0)
1646    }
1647    #[doc = "Bit 26 - Interrupt clearing register for GPIO26."]
1648    #[inline(always)]
1649    pub fn reg_gpio_26_interrupt_clear(&self) -> REG_GPIO_26_INTERRUPT_CLEAR_R {
1650        REG_GPIO_26_INTERRUPT_CLEAR_R::new(((self.bits >> 26) & 1) != 0)
1651    }
1652    #[doc = "Bit 27 - Interrupt clearing register for GPIO27."]
1653    #[inline(always)]
1654    pub fn reg_gpio_27_interrupt_clear(&self) -> REG_GPIO_27_INTERRUPT_CLEAR_R {
1655        REG_GPIO_27_INTERRUPT_CLEAR_R::new(((self.bits >> 27) & 1) != 0)
1656    }
1657    #[doc = "Bit 28 - Interrupt clearing register for GPIO28."]
1658    #[inline(always)]
1659    pub fn reg_gpio_28_interrupt_clear(&self) -> REG_GPIO_28_INTERRUPT_CLEAR_R {
1660        REG_GPIO_28_INTERRUPT_CLEAR_R::new(((self.bits >> 28) & 1) != 0)
1661    }
1662}
1663impl W {
1664    #[doc = "Bit 0 - Interrupt clearing register for GPIO0."]
1665    #[inline(always)]
1666    #[must_use]
1667    pub fn reg_gpio_0_interrupt_clear(&mut self) -> REG_GPIO_0_INTERRUPT_CLEAR_W<0> {
1668        REG_GPIO_0_INTERRUPT_CLEAR_W::new(self)
1669    }
1670    #[doc = "Bit 1 - Interrupt clearing register for GPIO1."]
1671    #[inline(always)]
1672    #[must_use]
1673    pub fn reg_gpio_1_interrupt_clear(&mut self) -> REG_GPIO_1_INTERRUPT_CLEAR_W<1> {
1674        REG_GPIO_1_INTERRUPT_CLEAR_W::new(self)
1675    }
1676    #[doc = "Bit 2 - Interrupt clearing register for GPIO2."]
1677    #[inline(always)]
1678    #[must_use]
1679    pub fn reg_gpio_2_interrupt_clear(&mut self) -> REG_GPIO_2_INTERRUPT_CLEAR_W<2> {
1680        REG_GPIO_2_INTERRUPT_CLEAR_W::new(self)
1681    }
1682    #[doc = "Bit 3 - Interrupt clearing register for GPIO3."]
1683    #[inline(always)]
1684    #[must_use]
1685    pub fn reg_gpio_3_interrupt_clear(&mut self) -> REG_GPIO_3_INTERRUPT_CLEAR_W<3> {
1686        REG_GPIO_3_INTERRUPT_CLEAR_W::new(self)
1687    }
1688    #[doc = "Bit 4 - Interrupt clearing register for GPIO4."]
1689    #[inline(always)]
1690    #[must_use]
1691    pub fn reg_gpio_4_interrupt_clear(&mut self) -> REG_GPIO_4_INTERRUPT_CLEAR_W<4> {
1692        REG_GPIO_4_INTERRUPT_CLEAR_W::new(self)
1693    }
1694    #[doc = "Bit 5 - Interrupt clearing register for GPIO5."]
1695    #[inline(always)]
1696    #[must_use]
1697    pub fn reg_gpio_5_interrupt_clear(&mut self) -> REG_GPIO_5_INTERRUPT_CLEAR_W<5> {
1698        REG_GPIO_5_INTERRUPT_CLEAR_W::new(self)
1699    }
1700    #[doc = "Bit 6 - Interrupt clearing register for GPIO6."]
1701    #[inline(always)]
1702    #[must_use]
1703    pub fn reg_gpio_6_interrupt_clear(&mut self) -> REG_GPIO_6_INTERRUPT_CLEAR_W<6> {
1704        REG_GPIO_6_INTERRUPT_CLEAR_W::new(self)
1705    }
1706    #[doc = "Bit 7 - Interrupt clearing register for GPIO7."]
1707    #[inline(always)]
1708    #[must_use]
1709    pub fn reg_gpio_7_interrupt_clear(&mut self) -> REG_GPIO_7_INTERRUPT_CLEAR_W<7> {
1710        REG_GPIO_7_INTERRUPT_CLEAR_W::new(self)
1711    }
1712    #[doc = "Bit 8 - Interrupt clearing register for GPIO8."]
1713    #[inline(always)]
1714    #[must_use]
1715    pub fn reg_gpio_8_interrupt_clear(&mut self) -> REG_GPIO_8_INTERRUPT_CLEAR_W<8> {
1716        REG_GPIO_8_INTERRUPT_CLEAR_W::new(self)
1717    }
1718    #[doc = "Bit 9 - Interrupt clearing register for GPIO9."]
1719    #[inline(always)]
1720    #[must_use]
1721    pub fn reg_gpio_9_interrupt_clear(&mut self) -> REG_GPIO_9_INTERRUPT_CLEAR_W<9> {
1722        REG_GPIO_9_INTERRUPT_CLEAR_W::new(self)
1723    }
1724    #[doc = "Bit 10 - Interrupt clearing register for GPIO10."]
1725    #[inline(always)]
1726    #[must_use]
1727    pub fn reg_gpio_10_interrupt_clear(&mut self) -> REG_GPIO_10_INTERRUPT_CLEAR_W<10> {
1728        REG_GPIO_10_INTERRUPT_CLEAR_W::new(self)
1729    }
1730    #[doc = "Bit 11 - Interrupt clearing register for GPIO11."]
1731    #[inline(always)]
1732    #[must_use]
1733    pub fn reg_gpio_11_interrupt_clear(&mut self) -> REG_GPIO_11_INTERRUPT_CLEAR_W<11> {
1734        REG_GPIO_11_INTERRUPT_CLEAR_W::new(self)
1735    }
1736    #[doc = "Bit 12 - Interrupt clearing register for GPIO12."]
1737    #[inline(always)]
1738    #[must_use]
1739    pub fn reg_gpio_12_interrupt_clear(&mut self) -> REG_GPIO_12_INTERRUPT_CLEAR_W<12> {
1740        REG_GPIO_12_INTERRUPT_CLEAR_W::new(self)
1741    }
1742    #[doc = "Bit 13 - Interrupt clearing register for GPIO13."]
1743    #[inline(always)]
1744    #[must_use]
1745    pub fn reg_gpio_13_interrupt_clear(&mut self) -> REG_GPIO_13_INTERRUPT_CLEAR_W<13> {
1746        REG_GPIO_13_INTERRUPT_CLEAR_W::new(self)
1747    }
1748    #[doc = "Bit 14 - Interrupt clearing register for GPIO14."]
1749    #[inline(always)]
1750    #[must_use]
1751    pub fn reg_gpio_14_interrupt_clear(&mut self) -> REG_GPIO_14_INTERRUPT_CLEAR_W<14> {
1752        REG_GPIO_14_INTERRUPT_CLEAR_W::new(self)
1753    }
1754    #[doc = "Bit 15 - Interrupt clearing register for GPIO15."]
1755    #[inline(always)]
1756    #[must_use]
1757    pub fn reg_gpio_15_interrupt_clear(&mut self) -> REG_GPIO_15_INTERRUPT_CLEAR_W<15> {
1758        REG_GPIO_15_INTERRUPT_CLEAR_W::new(self)
1759    }
1760    #[doc = "Bit 16 - Interrupt clearing register for GPIO16."]
1761    #[inline(always)]
1762    #[must_use]
1763    pub fn reg_gpio_16_interrupt_clear(&mut self) -> REG_GPIO_16_INTERRUPT_CLEAR_W<16> {
1764        REG_GPIO_16_INTERRUPT_CLEAR_W::new(self)
1765    }
1766    #[doc = "Bit 17 - Interrupt clearing register for GPIO17."]
1767    #[inline(always)]
1768    #[must_use]
1769    pub fn reg_gpio_17_interrupt_clear(&mut self) -> REG_GPIO_17_INTERRUPT_CLEAR_W<17> {
1770        REG_GPIO_17_INTERRUPT_CLEAR_W::new(self)
1771    }
1772    #[doc = "Bit 18 - Interrupt clearing register for GPIO18."]
1773    #[inline(always)]
1774    #[must_use]
1775    pub fn reg_gpio_18_interrupt_clear(&mut self) -> REG_GPIO_18_INTERRUPT_CLEAR_W<18> {
1776        REG_GPIO_18_INTERRUPT_CLEAR_W::new(self)
1777    }
1778    #[doc = "Bit 19 - Interrupt clearing register for GPIO19."]
1779    #[inline(always)]
1780    #[must_use]
1781    pub fn reg_gpio_19_interrupt_clear(&mut self) -> REG_GPIO_19_INTERRUPT_CLEAR_W<19> {
1782        REG_GPIO_19_INTERRUPT_CLEAR_W::new(self)
1783    }
1784    #[doc = "Bit 20 - Interrupt clearing register for GPIO20."]
1785    #[inline(always)]
1786    #[must_use]
1787    pub fn reg_gpio_20_interrupt_clear(&mut self) -> REG_GPIO_20_INTERRUPT_CLEAR_W<20> {
1788        REG_GPIO_20_INTERRUPT_CLEAR_W::new(self)
1789    }
1790    #[doc = "Bit 21 - Interrupt clearing register for GPIO21."]
1791    #[inline(always)]
1792    #[must_use]
1793    pub fn reg_gpio_21_interrupt_clear(&mut self) -> REG_GPIO_21_INTERRUPT_CLEAR_W<21> {
1794        REG_GPIO_21_INTERRUPT_CLEAR_W::new(self)
1795    }
1796    #[doc = "Bit 22 - Interrupt clearing register for GPIO22."]
1797    #[inline(always)]
1798    #[must_use]
1799    pub fn reg_gpio_22_interrupt_clear(&mut self) -> REG_GPIO_22_INTERRUPT_CLEAR_W<22> {
1800        REG_GPIO_22_INTERRUPT_CLEAR_W::new(self)
1801    }
1802    #[doc = "Bit 23 - Interrupt clearing register for GPIO23."]
1803    #[inline(always)]
1804    #[must_use]
1805    pub fn reg_gpio_23_interrupt_clear(&mut self) -> REG_GPIO_23_INTERRUPT_CLEAR_W<23> {
1806        REG_GPIO_23_INTERRUPT_CLEAR_W::new(self)
1807    }
1808    #[doc = "Bit 24 - Interrupt clearing register for GPIO24."]
1809    #[inline(always)]
1810    #[must_use]
1811    pub fn reg_gpio_24_interrupt_clear(&mut self) -> REG_GPIO_24_INTERRUPT_CLEAR_W<24> {
1812        REG_GPIO_24_INTERRUPT_CLEAR_W::new(self)
1813    }
1814    #[doc = "Bit 25 - Interrupt clearing register for GPIO25."]
1815    #[inline(always)]
1816    #[must_use]
1817    pub fn reg_gpio_25_interrupt_clear(&mut self) -> REG_GPIO_25_INTERRUPT_CLEAR_W<25> {
1818        REG_GPIO_25_INTERRUPT_CLEAR_W::new(self)
1819    }
1820    #[doc = "Bit 26 - Interrupt clearing register for GPIO26."]
1821    #[inline(always)]
1822    #[must_use]
1823    pub fn reg_gpio_26_interrupt_clear(&mut self) -> REG_GPIO_26_INTERRUPT_CLEAR_W<26> {
1824        REG_GPIO_26_INTERRUPT_CLEAR_W::new(self)
1825    }
1826    #[doc = "Bit 27 - Interrupt clearing register for GPIO27."]
1827    #[inline(always)]
1828    #[must_use]
1829    pub fn reg_gpio_27_interrupt_clear(&mut self) -> REG_GPIO_27_INTERRUPT_CLEAR_W<27> {
1830        REG_GPIO_27_INTERRUPT_CLEAR_W::new(self)
1831    }
1832    #[doc = "Bit 28 - Interrupt clearing register for GPIO28."]
1833    #[inline(always)]
1834    #[must_use]
1835    pub fn reg_gpio_28_interrupt_clear(&mut self) -> REG_GPIO_28_INTERRUPT_CLEAR_W<28> {
1836        REG_GPIO_28_INTERRUPT_CLEAR_W::new(self)
1837    }
1838    #[doc = "Writes raw bits to the register."]
1839    #[inline(always)]
1840    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1841        self.0.bits(bits);
1842        self
1843    }
1844}
1845#[doc = "Interrupt clearing register.\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [gpio_int_clr1](index.html) module"]
1846pub struct GPIO_INT_CLR1_SPEC;
1847impl crate::RegisterSpec for GPIO_INT_CLR1_SPEC {
1848    type Ux = u32;
1849}
1850#[doc = "`read()` method returns [gpio_int_clr1::R](R) reader structure"]
1851impl crate::Readable for GPIO_INT_CLR1_SPEC {
1852    type Reader = R;
1853}
1854#[doc = "`write(|w| ..)` method takes [gpio_int_clr1::W](W) writer structure"]
1855impl crate::Writable for GPIO_INT_CLR1_SPEC {
1856    type Writer = W;
1857    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1858    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
1859}
1860#[doc = "`reset()` method sets GPIO_INT_CLR1 to value 0"]
1861impl crate::Resettable for GPIO_INT_CLR1_SPEC {
1862    const RESET_VALUE: Self::Ux = 0;
1863}
bl602_pac/glb/gpio_int_clr1.rs

bl602_pac/glb/
gpio_int_clr1.rs
