nrf52840_pac/p0/
outclr.rs

Help
1#[doc = "Register `OUTCLR` reader"]
2pub struct R(crate::R<OUTCLR_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<OUTCLR_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<OUTCLR_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<OUTCLR_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `OUTCLR` writer"]
17pub struct W(crate::W<OUTCLR_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<OUTCLR_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<OUTCLR_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<OUTCLR_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Field `PIN0` reader - Pin 0"]
38pub type PIN0_R = crate::BitReader<PIN0_A>;
39#[doc = "Pin 0\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq)]
41pub enum PIN0_A {
42    #[doc = "0: Read: pin driver is low"]
43    LOW = 0,
44    #[doc = "1: Read: pin driver is high"]
45    HIGH = 1,
46}
47impl From<PIN0_A> for bool {
48    #[inline(always)]
49    fn from(variant: PIN0_A) -> Self {
50        variant as u8 != 0
51    }
52}
53impl PIN0_R {
54    #[doc = "Get enumerated values variant"]
55    #[inline(always)]
56    pub fn variant(&self) -> PIN0_A {
57        match self.bits {
58            false => PIN0_A::LOW,
59            true => PIN0_A::HIGH,
60        }
61    }
62    #[doc = "Checks if the value of the field is `LOW`"]
63    #[inline(always)]
64    pub fn is_low(&self) -> bool {
65        *self == PIN0_A::LOW
66    }
67    #[doc = "Checks if the value of the field is `HIGH`"]
68    #[inline(always)]
69    pub fn is_high(&self) -> bool {
70        *self == PIN0_A::HIGH
71    }
72}
73#[doc = "Pin 0\n\nValue on reset: 0"]
74#[derive(Clone, Copy, Debug, PartialEq)]
75pub enum PIN0_AW {
76    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
77    CLEAR = 1,
78}
79impl From<PIN0_AW> for bool {
80    #[inline(always)]
81    fn from(variant: PIN0_AW) -> Self {
82        variant as u8 != 0
83    }
84}
85#[doc = "Field `PIN0` writer - Pin 0"]
86pub type PIN0_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN0_AW, O>;
87impl<'a, const O: u8> PIN0_W<'a, O> {
88    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
89    #[inline(always)]
90    pub fn clear(self) -> &'a mut W {
91        self.variant(PIN0_AW::CLEAR)
92    }
93}
94#[doc = "Field `PIN1` reader - Pin 1"]
95pub type PIN1_R = crate::BitReader<PIN1_A>;
96#[doc = "Pin 1\n\nValue on reset: 0"]
97#[derive(Clone, Copy, Debug, PartialEq)]
98pub enum PIN1_A {
99    #[doc = "0: Read: pin driver is low"]
100    LOW = 0,
101    #[doc = "1: Read: pin driver is high"]
102    HIGH = 1,
103}
104impl From<PIN1_A> for bool {
105    #[inline(always)]
106    fn from(variant: PIN1_A) -> Self {
107        variant as u8 != 0
108    }
109}
110impl PIN1_R {
111    #[doc = "Get enumerated values variant"]
112    #[inline(always)]
113    pub fn variant(&self) -> PIN1_A {
114        match self.bits {
115            false => PIN1_A::LOW,
116            true => PIN1_A::HIGH,
117        }
118    }
119    #[doc = "Checks if the value of the field is `LOW`"]
120    #[inline(always)]
121    pub fn is_low(&self) -> bool {
122        *self == PIN1_A::LOW
123    }
124    #[doc = "Checks if the value of the field is `HIGH`"]
125    #[inline(always)]
126    pub fn is_high(&self) -> bool {
127        *self == PIN1_A::HIGH
128    }
129}
130#[doc = "Pin 1\n\nValue on reset: 0"]
131#[derive(Clone, Copy, Debug, PartialEq)]
132pub enum PIN1_AW {
133    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
134    CLEAR = 1,
135}
136impl From<PIN1_AW> for bool {
137    #[inline(always)]
138    fn from(variant: PIN1_AW) -> Self {
139        variant as u8 != 0
140    }
141}
142#[doc = "Field `PIN1` writer - Pin 1"]
143pub type PIN1_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN1_AW, O>;
144impl<'a, const O: u8> PIN1_W<'a, O> {
145    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
146    #[inline(always)]
147    pub fn clear(self) -> &'a mut W {
148        self.variant(PIN1_AW::CLEAR)
149    }
150}
151#[doc = "Field `PIN2` reader - Pin 2"]
152pub type PIN2_R = crate::BitReader<PIN2_A>;
153#[doc = "Pin 2\n\nValue on reset: 0"]
154#[derive(Clone, Copy, Debug, PartialEq)]
155pub enum PIN2_A {
156    #[doc = "0: Read: pin driver is low"]
157    LOW = 0,
158    #[doc = "1: Read: pin driver is high"]
159    HIGH = 1,
160}
161impl From<PIN2_A> for bool {
162    #[inline(always)]
163    fn from(variant: PIN2_A) -> Self {
164        variant as u8 != 0
165    }
166}
167impl PIN2_R {
168    #[doc = "Get enumerated values variant"]
169    #[inline(always)]
170    pub fn variant(&self) -> PIN2_A {
171        match self.bits {
172            false => PIN2_A::LOW,
173            true => PIN2_A::HIGH,
174        }
175    }
176    #[doc = "Checks if the value of the field is `LOW`"]
177    #[inline(always)]
178    pub fn is_low(&self) -> bool {
179        *self == PIN2_A::LOW
180    }
181    #[doc = "Checks if the value of the field is `HIGH`"]
182    #[inline(always)]
183    pub fn is_high(&self) -> bool {
184        *self == PIN2_A::HIGH
185    }
186}
187#[doc = "Pin 2\n\nValue on reset: 0"]
188#[derive(Clone, Copy, Debug, PartialEq)]
189pub enum PIN2_AW {
190    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
191    CLEAR = 1,
192}
193impl From<PIN2_AW> for bool {
194    #[inline(always)]
195    fn from(variant: PIN2_AW) -> Self {
196        variant as u8 != 0
197    }
198}
199#[doc = "Field `PIN2` writer - Pin 2"]
200pub type PIN2_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN2_AW, O>;
201impl<'a, const O: u8> PIN2_W<'a, O> {
202    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
203    #[inline(always)]
204    pub fn clear(self) -> &'a mut W {
205        self.variant(PIN2_AW::CLEAR)
206    }
207}
208#[doc = "Field `PIN3` reader - Pin 3"]
209pub type PIN3_R = crate::BitReader<PIN3_A>;
210#[doc = "Pin 3\n\nValue on reset: 0"]
211#[derive(Clone, Copy, Debug, PartialEq)]
212pub enum PIN3_A {
213    #[doc = "0: Read: pin driver is low"]
214    LOW = 0,
215    #[doc = "1: Read: pin driver is high"]
216    HIGH = 1,
217}
218impl From<PIN3_A> for bool {
219    #[inline(always)]
220    fn from(variant: PIN3_A) -> Self {
221        variant as u8 != 0
222    }
223}
224impl PIN3_R {
225    #[doc = "Get enumerated values variant"]
226    #[inline(always)]
227    pub fn variant(&self) -> PIN3_A {
228        match self.bits {
229            false => PIN3_A::LOW,
230            true => PIN3_A::HIGH,
231        }
232    }
233    #[doc = "Checks if the value of the field is `LOW`"]
234    #[inline(always)]
235    pub fn is_low(&self) -> bool {
236        *self == PIN3_A::LOW
237    }
238    #[doc = "Checks if the value of the field is `HIGH`"]
239    #[inline(always)]
240    pub fn is_high(&self) -> bool {
241        *self == PIN3_A::HIGH
242    }
243}
244#[doc = "Pin 3\n\nValue on reset: 0"]
245#[derive(Clone, Copy, Debug, PartialEq)]
246pub enum PIN3_AW {
247    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
248    CLEAR = 1,
249}
250impl From<PIN3_AW> for bool {
251    #[inline(always)]
252    fn from(variant: PIN3_AW) -> Self {
253        variant as u8 != 0
254    }
255}
256#[doc = "Field `PIN3` writer - Pin 3"]
257pub type PIN3_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN3_AW, O>;
258impl<'a, const O: u8> PIN3_W<'a, O> {
259    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
260    #[inline(always)]
261    pub fn clear(self) -> &'a mut W {
262        self.variant(PIN3_AW::CLEAR)
263    }
264}
265#[doc = "Field `PIN4` reader - Pin 4"]
266pub type PIN4_R = crate::BitReader<PIN4_A>;
267#[doc = "Pin 4\n\nValue on reset: 0"]
268#[derive(Clone, Copy, Debug, PartialEq)]
269pub enum PIN4_A {
270    #[doc = "0: Read: pin driver is low"]
271    LOW = 0,
272    #[doc = "1: Read: pin driver is high"]
273    HIGH = 1,
274}
275impl From<PIN4_A> for bool {
276    #[inline(always)]
277    fn from(variant: PIN4_A) -> Self {
278        variant as u8 != 0
279    }
280}
281impl PIN4_R {
282    #[doc = "Get enumerated values variant"]
283    #[inline(always)]
284    pub fn variant(&self) -> PIN4_A {
285        match self.bits {
286            false => PIN4_A::LOW,
287            true => PIN4_A::HIGH,
288        }
289    }
290    #[doc = "Checks if the value of the field is `LOW`"]
291    #[inline(always)]
292    pub fn is_low(&self) -> bool {
293        *self == PIN4_A::LOW
294    }
295    #[doc = "Checks if the value of the field is `HIGH`"]
296    #[inline(always)]
297    pub fn is_high(&self) -> bool {
298        *self == PIN4_A::HIGH
299    }
300}
301#[doc = "Pin 4\n\nValue on reset: 0"]
302#[derive(Clone, Copy, Debug, PartialEq)]
303pub enum PIN4_AW {
304    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
305    CLEAR = 1,
306}
307impl From<PIN4_AW> for bool {
308    #[inline(always)]
309    fn from(variant: PIN4_AW) -> Self {
310        variant as u8 != 0
311    }
312}
313#[doc = "Field `PIN4` writer - Pin 4"]
314pub type PIN4_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN4_AW, O>;
315impl<'a, const O: u8> PIN4_W<'a, O> {
316    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
317    #[inline(always)]
318    pub fn clear(self) -> &'a mut W {
319        self.variant(PIN4_AW::CLEAR)
320    }
321}
322#[doc = "Field `PIN5` reader - Pin 5"]
323pub type PIN5_R = crate::BitReader<PIN5_A>;
324#[doc = "Pin 5\n\nValue on reset: 0"]
325#[derive(Clone, Copy, Debug, PartialEq)]
326pub enum PIN5_A {
327    #[doc = "0: Read: pin driver is low"]
328    LOW = 0,
329    #[doc = "1: Read: pin driver is high"]
330    HIGH = 1,
331}
332impl From<PIN5_A> for bool {
333    #[inline(always)]
334    fn from(variant: PIN5_A) -> Self {
335        variant as u8 != 0
336    }
337}
338impl PIN5_R {
339    #[doc = "Get enumerated values variant"]
340    #[inline(always)]
341    pub fn variant(&self) -> PIN5_A {
342        match self.bits {
343            false => PIN5_A::LOW,
344            true => PIN5_A::HIGH,
345        }
346    }
347    #[doc = "Checks if the value of the field is `LOW`"]
348    #[inline(always)]
349    pub fn is_low(&self) -> bool {
350        *self == PIN5_A::LOW
351    }
352    #[doc = "Checks if the value of the field is `HIGH`"]
353    #[inline(always)]
354    pub fn is_high(&self) -> bool {
355        *self == PIN5_A::HIGH
356    }
357}
358#[doc = "Pin 5\n\nValue on reset: 0"]
359#[derive(Clone, Copy, Debug, PartialEq)]
360pub enum PIN5_AW {
361    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
362    CLEAR = 1,
363}
364impl From<PIN5_AW> for bool {
365    #[inline(always)]
366    fn from(variant: PIN5_AW) -> Self {
367        variant as u8 != 0
368    }
369}
370#[doc = "Field `PIN5` writer - Pin 5"]
371pub type PIN5_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN5_AW, O>;
372impl<'a, const O: u8> PIN5_W<'a, O> {
373    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
374    #[inline(always)]
375    pub fn clear(self) -> &'a mut W {
376        self.variant(PIN5_AW::CLEAR)
377    }
378}
379#[doc = "Field `PIN6` reader - Pin 6"]
380pub type PIN6_R = crate::BitReader<PIN6_A>;
381#[doc = "Pin 6\n\nValue on reset: 0"]
382#[derive(Clone, Copy, Debug, PartialEq)]
383pub enum PIN6_A {
384    #[doc = "0: Read: pin driver is low"]
385    LOW = 0,
386    #[doc = "1: Read: pin driver is high"]
387    HIGH = 1,
388}
389impl From<PIN6_A> for bool {
390    #[inline(always)]
391    fn from(variant: PIN6_A) -> Self {
392        variant as u8 != 0
393    }
394}
395impl PIN6_R {
396    #[doc = "Get enumerated values variant"]
397    #[inline(always)]
398    pub fn variant(&self) -> PIN6_A {
399        match self.bits {
400            false => PIN6_A::LOW,
401            true => PIN6_A::HIGH,
402        }
403    }
404    #[doc = "Checks if the value of the field is `LOW`"]
405    #[inline(always)]
406    pub fn is_low(&self) -> bool {
407        *self == PIN6_A::LOW
408    }
409    #[doc = "Checks if the value of the field is `HIGH`"]
410    #[inline(always)]
411    pub fn is_high(&self) -> bool {
412        *self == PIN6_A::HIGH
413    }
414}
415#[doc = "Pin 6\n\nValue on reset: 0"]
416#[derive(Clone, Copy, Debug, PartialEq)]
417pub enum PIN6_AW {
418    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
419    CLEAR = 1,
420}
421impl From<PIN6_AW> for bool {
422    #[inline(always)]
423    fn from(variant: PIN6_AW) -> Self {
424        variant as u8 != 0
425    }
426}
427#[doc = "Field `PIN6` writer - Pin 6"]
428pub type PIN6_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN6_AW, O>;
429impl<'a, const O: u8> PIN6_W<'a, O> {
430    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
431    #[inline(always)]
432    pub fn clear(self) -> &'a mut W {
433        self.variant(PIN6_AW::CLEAR)
434    }
435}
436#[doc = "Field `PIN7` reader - Pin 7"]
437pub type PIN7_R = crate::BitReader<PIN7_A>;
438#[doc = "Pin 7\n\nValue on reset: 0"]
439#[derive(Clone, Copy, Debug, PartialEq)]
440pub enum PIN7_A {
441    #[doc = "0: Read: pin driver is low"]
442    LOW = 0,
443    #[doc = "1: Read: pin driver is high"]
444    HIGH = 1,
445}
446impl From<PIN7_A> for bool {
447    #[inline(always)]
448    fn from(variant: PIN7_A) -> Self {
449        variant as u8 != 0
450    }
451}
452impl PIN7_R {
453    #[doc = "Get enumerated values variant"]
454    #[inline(always)]
455    pub fn variant(&self) -> PIN7_A {
456        match self.bits {
457            false => PIN7_A::LOW,
458            true => PIN7_A::HIGH,
459        }
460    }
461    #[doc = "Checks if the value of the field is `LOW`"]
462    #[inline(always)]
463    pub fn is_low(&self) -> bool {
464        *self == PIN7_A::LOW
465    }
466    #[doc = "Checks if the value of the field is `HIGH`"]
467    #[inline(always)]
468    pub fn is_high(&self) -> bool {
469        *self == PIN7_A::HIGH
470    }
471}
472#[doc = "Pin 7\n\nValue on reset: 0"]
473#[derive(Clone, Copy, Debug, PartialEq)]
474pub enum PIN7_AW {
475    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
476    CLEAR = 1,
477}
478impl From<PIN7_AW> for bool {
479    #[inline(always)]
480    fn from(variant: PIN7_AW) -> Self {
481        variant as u8 != 0
482    }
483}
484#[doc = "Field `PIN7` writer - Pin 7"]
485pub type PIN7_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN7_AW, O>;
486impl<'a, const O: u8> PIN7_W<'a, O> {
487    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
488    #[inline(always)]
489    pub fn clear(self) -> &'a mut W {
490        self.variant(PIN7_AW::CLEAR)
491    }
492}
493#[doc = "Field `PIN8` reader - Pin 8"]
494pub type PIN8_R = crate::BitReader<PIN8_A>;
495#[doc = "Pin 8\n\nValue on reset: 0"]
496#[derive(Clone, Copy, Debug, PartialEq)]
497pub enum PIN8_A {
498    #[doc = "0: Read: pin driver is low"]
499    LOW = 0,
500    #[doc = "1: Read: pin driver is high"]
501    HIGH = 1,
502}
503impl From<PIN8_A> for bool {
504    #[inline(always)]
505    fn from(variant: PIN8_A) -> Self {
506        variant as u8 != 0
507    }
508}
509impl PIN8_R {
510    #[doc = "Get enumerated values variant"]
511    #[inline(always)]
512    pub fn variant(&self) -> PIN8_A {
513        match self.bits {
514            false => PIN8_A::LOW,
515            true => PIN8_A::HIGH,
516        }
517    }
518    #[doc = "Checks if the value of the field is `LOW`"]
519    #[inline(always)]
520    pub fn is_low(&self) -> bool {
521        *self == PIN8_A::LOW
522    }
523    #[doc = "Checks if the value of the field is `HIGH`"]
524    #[inline(always)]
525    pub fn is_high(&self) -> bool {
526        *self == PIN8_A::HIGH
527    }
528}
529#[doc = "Pin 8\n\nValue on reset: 0"]
530#[derive(Clone, Copy, Debug, PartialEq)]
531pub enum PIN8_AW {
532    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
533    CLEAR = 1,
534}
535impl From<PIN8_AW> for bool {
536    #[inline(always)]
537    fn from(variant: PIN8_AW) -> Self {
538        variant as u8 != 0
539    }
540}
541#[doc = "Field `PIN8` writer - Pin 8"]
542pub type PIN8_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN8_AW, O>;
543impl<'a, const O: u8> PIN8_W<'a, O> {
544    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
545    #[inline(always)]
546    pub fn clear(self) -> &'a mut W {
547        self.variant(PIN8_AW::CLEAR)
548    }
549}
550#[doc = "Field `PIN9` reader - Pin 9"]
551pub type PIN9_R = crate::BitReader<PIN9_A>;
552#[doc = "Pin 9\n\nValue on reset: 0"]
553#[derive(Clone, Copy, Debug, PartialEq)]
554pub enum PIN9_A {
555    #[doc = "0: Read: pin driver is low"]
556    LOW = 0,
557    #[doc = "1: Read: pin driver is high"]
558    HIGH = 1,
559}
560impl From<PIN9_A> for bool {
561    #[inline(always)]
562    fn from(variant: PIN9_A) -> Self {
563        variant as u8 != 0
564    }
565}
566impl PIN9_R {
567    #[doc = "Get enumerated values variant"]
568    #[inline(always)]
569    pub fn variant(&self) -> PIN9_A {
570        match self.bits {
571            false => PIN9_A::LOW,
572            true => PIN9_A::HIGH,
573        }
574    }
575    #[doc = "Checks if the value of the field is `LOW`"]
576    #[inline(always)]
577    pub fn is_low(&self) -> bool {
578        *self == PIN9_A::LOW
579    }
580    #[doc = "Checks if the value of the field is `HIGH`"]
581    #[inline(always)]
582    pub fn is_high(&self) -> bool {
583        *self == PIN9_A::HIGH
584    }
585}
586#[doc = "Pin 9\n\nValue on reset: 0"]
587#[derive(Clone, Copy, Debug, PartialEq)]
588pub enum PIN9_AW {
589    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
590    CLEAR = 1,
591}
592impl From<PIN9_AW> for bool {
593    #[inline(always)]
594    fn from(variant: PIN9_AW) -> Self {
595        variant as u8 != 0
596    }
597}
598#[doc = "Field `PIN9` writer - Pin 9"]
599pub type PIN9_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN9_AW, O>;
600impl<'a, const O: u8> PIN9_W<'a, O> {
601    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
602    #[inline(always)]
603    pub fn clear(self) -> &'a mut W {
604        self.variant(PIN9_AW::CLEAR)
605    }
606}
607#[doc = "Field `PIN10` reader - Pin 10"]
608pub type PIN10_R = crate::BitReader<PIN10_A>;
609#[doc = "Pin 10\n\nValue on reset: 0"]
610#[derive(Clone, Copy, Debug, PartialEq)]
611pub enum PIN10_A {
612    #[doc = "0: Read: pin driver is low"]
613    LOW = 0,
614    #[doc = "1: Read: pin driver is high"]
615    HIGH = 1,
616}
617impl From<PIN10_A> for bool {
618    #[inline(always)]
619    fn from(variant: PIN10_A) -> Self {
620        variant as u8 != 0
621    }
622}
623impl PIN10_R {
624    #[doc = "Get enumerated values variant"]
625    #[inline(always)]
626    pub fn variant(&self) -> PIN10_A {
627        match self.bits {
628            false => PIN10_A::LOW,
629            true => PIN10_A::HIGH,
630        }
631    }
632    #[doc = "Checks if the value of the field is `LOW`"]
633    #[inline(always)]
634    pub fn is_low(&self) -> bool {
635        *self == PIN10_A::LOW
636    }
637    #[doc = "Checks if the value of the field is `HIGH`"]
638    #[inline(always)]
639    pub fn is_high(&self) -> bool {
640        *self == PIN10_A::HIGH
641    }
642}
643#[doc = "Pin 10\n\nValue on reset: 0"]
644#[derive(Clone, Copy, Debug, PartialEq)]
645pub enum PIN10_AW {
646    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
647    CLEAR = 1,
648}
649impl From<PIN10_AW> for bool {
650    #[inline(always)]
651    fn from(variant: PIN10_AW) -> Self {
652        variant as u8 != 0
653    }
654}
655#[doc = "Field `PIN10` writer - Pin 10"]
656pub type PIN10_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN10_AW, O>;
657impl<'a, const O: u8> PIN10_W<'a, O> {
658    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
659    #[inline(always)]
660    pub fn clear(self) -> &'a mut W {
661        self.variant(PIN10_AW::CLEAR)
662    }
663}
664#[doc = "Field `PIN11` reader - Pin 11"]
665pub type PIN11_R = crate::BitReader<PIN11_A>;
666#[doc = "Pin 11\n\nValue on reset: 0"]
667#[derive(Clone, Copy, Debug, PartialEq)]
668pub enum PIN11_A {
669    #[doc = "0: Read: pin driver is low"]
670    LOW = 0,
671    #[doc = "1: Read: pin driver is high"]
672    HIGH = 1,
673}
674impl From<PIN11_A> for bool {
675    #[inline(always)]
676    fn from(variant: PIN11_A) -> Self {
677        variant as u8 != 0
678    }
679}
680impl PIN11_R {
681    #[doc = "Get enumerated values variant"]
682    #[inline(always)]
683    pub fn variant(&self) -> PIN11_A {
684        match self.bits {
685            false => PIN11_A::LOW,
686            true => PIN11_A::HIGH,
687        }
688    }
689    #[doc = "Checks if the value of the field is `LOW`"]
690    #[inline(always)]
691    pub fn is_low(&self) -> bool {
692        *self == PIN11_A::LOW
693    }
694    #[doc = "Checks if the value of the field is `HIGH`"]
695    #[inline(always)]
696    pub fn is_high(&self) -> bool {
697        *self == PIN11_A::HIGH
698    }
699}
700#[doc = "Pin 11\n\nValue on reset: 0"]
701#[derive(Clone, Copy, Debug, PartialEq)]
702pub enum PIN11_AW {
703    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
704    CLEAR = 1,
705}
706impl From<PIN11_AW> for bool {
707    #[inline(always)]
708    fn from(variant: PIN11_AW) -> Self {
709        variant as u8 != 0
710    }
711}
712#[doc = "Field `PIN11` writer - Pin 11"]
713pub type PIN11_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN11_AW, O>;
714impl<'a, const O: u8> PIN11_W<'a, O> {
715    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
716    #[inline(always)]
717    pub fn clear(self) -> &'a mut W {
718        self.variant(PIN11_AW::CLEAR)
719    }
720}
721#[doc = "Field `PIN12` reader - Pin 12"]
722pub type PIN12_R = crate::BitReader<PIN12_A>;
723#[doc = "Pin 12\n\nValue on reset: 0"]
724#[derive(Clone, Copy, Debug, PartialEq)]
725pub enum PIN12_A {
726    #[doc = "0: Read: pin driver is low"]
727    LOW = 0,
728    #[doc = "1: Read: pin driver is high"]
729    HIGH = 1,
730}
731impl From<PIN12_A> for bool {
732    #[inline(always)]
733    fn from(variant: PIN12_A) -> Self {
734        variant as u8 != 0
735    }
736}
737impl PIN12_R {
738    #[doc = "Get enumerated values variant"]
739    #[inline(always)]
740    pub fn variant(&self) -> PIN12_A {
741        match self.bits {
742            false => PIN12_A::LOW,
743            true => PIN12_A::HIGH,
744        }
745    }
746    #[doc = "Checks if the value of the field is `LOW`"]
747    #[inline(always)]
748    pub fn is_low(&self) -> bool {
749        *self == PIN12_A::LOW
750    }
751    #[doc = "Checks if the value of the field is `HIGH`"]
752    #[inline(always)]
753    pub fn is_high(&self) -> bool {
754        *self == PIN12_A::HIGH
755    }
756}
757#[doc = "Pin 12\n\nValue on reset: 0"]
758#[derive(Clone, Copy, Debug, PartialEq)]
759pub enum PIN12_AW {
760    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
761    CLEAR = 1,
762}
763impl From<PIN12_AW> for bool {
764    #[inline(always)]
765    fn from(variant: PIN12_AW) -> Self {
766        variant as u8 != 0
767    }
768}
769#[doc = "Field `PIN12` writer - Pin 12"]
770pub type PIN12_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN12_AW, O>;
771impl<'a, const O: u8> PIN12_W<'a, O> {
772    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
773    #[inline(always)]
774    pub fn clear(self) -> &'a mut W {
775        self.variant(PIN12_AW::CLEAR)
776    }
777}
778#[doc = "Field `PIN13` reader - Pin 13"]
779pub type PIN13_R = crate::BitReader<PIN13_A>;
780#[doc = "Pin 13\n\nValue on reset: 0"]
781#[derive(Clone, Copy, Debug, PartialEq)]
782pub enum PIN13_A {
783    #[doc = "0: Read: pin driver is low"]
784    LOW = 0,
785    #[doc = "1: Read: pin driver is high"]
786    HIGH = 1,
787}
788impl From<PIN13_A> for bool {
789    #[inline(always)]
790    fn from(variant: PIN13_A) -> Self {
791        variant as u8 != 0
792    }
793}
794impl PIN13_R {
795    #[doc = "Get enumerated values variant"]
796    #[inline(always)]
797    pub fn variant(&self) -> PIN13_A {
798        match self.bits {
799            false => PIN13_A::LOW,
800            true => PIN13_A::HIGH,
801        }
802    }
803    #[doc = "Checks if the value of the field is `LOW`"]
804    #[inline(always)]
805    pub fn is_low(&self) -> bool {
806        *self == PIN13_A::LOW
807    }
808    #[doc = "Checks if the value of the field is `HIGH`"]
809    #[inline(always)]
810    pub fn is_high(&self) -> bool {
811        *self == PIN13_A::HIGH
812    }
813}
814#[doc = "Pin 13\n\nValue on reset: 0"]
815#[derive(Clone, Copy, Debug, PartialEq)]
816pub enum PIN13_AW {
817    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
818    CLEAR = 1,
819}
820impl From<PIN13_AW> for bool {
821    #[inline(always)]
822    fn from(variant: PIN13_AW) -> Self {
823        variant as u8 != 0
824    }
825}
826#[doc = "Field `PIN13` writer - Pin 13"]
827pub type PIN13_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN13_AW, O>;
828impl<'a, const O: u8> PIN13_W<'a, O> {
829    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
830    #[inline(always)]
831    pub fn clear(self) -> &'a mut W {
832        self.variant(PIN13_AW::CLEAR)
833    }
834}
835#[doc = "Field `PIN14` reader - Pin 14"]
836pub type PIN14_R = crate::BitReader<PIN14_A>;
837#[doc = "Pin 14\n\nValue on reset: 0"]
838#[derive(Clone, Copy, Debug, PartialEq)]
839pub enum PIN14_A {
840    #[doc = "0: Read: pin driver is low"]
841    LOW = 0,
842    #[doc = "1: Read: pin driver is high"]
843    HIGH = 1,
844}
845impl From<PIN14_A> for bool {
846    #[inline(always)]
847    fn from(variant: PIN14_A) -> Self {
848        variant as u8 != 0
849    }
850}
851impl PIN14_R {
852    #[doc = "Get enumerated values variant"]
853    #[inline(always)]
854    pub fn variant(&self) -> PIN14_A {
855        match self.bits {
856            false => PIN14_A::LOW,
857            true => PIN14_A::HIGH,
858        }
859    }
860    #[doc = "Checks if the value of the field is `LOW`"]
861    #[inline(always)]
862    pub fn is_low(&self) -> bool {
863        *self == PIN14_A::LOW
864    }
865    #[doc = "Checks if the value of the field is `HIGH`"]
866    #[inline(always)]
867    pub fn is_high(&self) -> bool {
868        *self == PIN14_A::HIGH
869    }
870}
871#[doc = "Pin 14\n\nValue on reset: 0"]
872#[derive(Clone, Copy, Debug, PartialEq)]
873pub enum PIN14_AW {
874    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
875    CLEAR = 1,
876}
877impl From<PIN14_AW> for bool {
878    #[inline(always)]
879    fn from(variant: PIN14_AW) -> Self {
880        variant as u8 != 0
881    }
882}
883#[doc = "Field `PIN14` writer - Pin 14"]
884pub type PIN14_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN14_AW, O>;
885impl<'a, const O: u8> PIN14_W<'a, O> {
886    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
887    #[inline(always)]
888    pub fn clear(self) -> &'a mut W {
889        self.variant(PIN14_AW::CLEAR)
890    }
891}
892#[doc = "Field `PIN15` reader - Pin 15"]
893pub type PIN15_R = crate::BitReader<PIN15_A>;
894#[doc = "Pin 15\n\nValue on reset: 0"]
895#[derive(Clone, Copy, Debug, PartialEq)]
896pub enum PIN15_A {
897    #[doc = "0: Read: pin driver is low"]
898    LOW = 0,
899    #[doc = "1: Read: pin driver is high"]
900    HIGH = 1,
901}
902impl From<PIN15_A> for bool {
903    #[inline(always)]
904    fn from(variant: PIN15_A) -> Self {
905        variant as u8 != 0
906    }
907}
908impl PIN15_R {
909    #[doc = "Get enumerated values variant"]
910    #[inline(always)]
911    pub fn variant(&self) -> PIN15_A {
912        match self.bits {
913            false => PIN15_A::LOW,
914            true => PIN15_A::HIGH,
915        }
916    }
917    #[doc = "Checks if the value of the field is `LOW`"]
918    #[inline(always)]
919    pub fn is_low(&self) -> bool {
920        *self == PIN15_A::LOW
921    }
922    #[doc = "Checks if the value of the field is `HIGH`"]
923    #[inline(always)]
924    pub fn is_high(&self) -> bool {
925        *self == PIN15_A::HIGH
926    }
927}
928#[doc = "Pin 15\n\nValue on reset: 0"]
929#[derive(Clone, Copy, Debug, PartialEq)]
930pub enum PIN15_AW {
931    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
932    CLEAR = 1,
933}
934impl From<PIN15_AW> for bool {
935    #[inline(always)]
936    fn from(variant: PIN15_AW) -> Self {
937        variant as u8 != 0
938    }
939}
940#[doc = "Field `PIN15` writer - Pin 15"]
941pub type PIN15_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN15_AW, O>;
942impl<'a, const O: u8> PIN15_W<'a, O> {
943    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
944    #[inline(always)]
945    pub fn clear(self) -> &'a mut W {
946        self.variant(PIN15_AW::CLEAR)
947    }
948}
949#[doc = "Field `PIN16` reader - Pin 16"]
950pub type PIN16_R = crate::BitReader<PIN16_A>;
951#[doc = "Pin 16\n\nValue on reset: 0"]
952#[derive(Clone, Copy, Debug, PartialEq)]
953pub enum PIN16_A {
954    #[doc = "0: Read: pin driver is low"]
955    LOW = 0,
956    #[doc = "1: Read: pin driver is high"]
957    HIGH = 1,
958}
959impl From<PIN16_A> for bool {
960    #[inline(always)]
961    fn from(variant: PIN16_A) -> Self {
962        variant as u8 != 0
963    }
964}
965impl PIN16_R {
966    #[doc = "Get enumerated values variant"]
967    #[inline(always)]
968    pub fn variant(&self) -> PIN16_A {
969        match self.bits {
970            false => PIN16_A::LOW,
971            true => PIN16_A::HIGH,
972        }
973    }
974    #[doc = "Checks if the value of the field is `LOW`"]
975    #[inline(always)]
976    pub fn is_low(&self) -> bool {
977        *self == PIN16_A::LOW
978    }
979    #[doc = "Checks if the value of the field is `HIGH`"]
980    #[inline(always)]
981    pub fn is_high(&self) -> bool {
982        *self == PIN16_A::HIGH
983    }
984}
985#[doc = "Pin 16\n\nValue on reset: 0"]
986#[derive(Clone, Copy, Debug, PartialEq)]
987pub enum PIN16_AW {
988    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
989    CLEAR = 1,
990}
991impl From<PIN16_AW> for bool {
992    #[inline(always)]
993    fn from(variant: PIN16_AW) -> Self {
994        variant as u8 != 0
995    }
996}
997#[doc = "Field `PIN16` writer - Pin 16"]
998pub type PIN16_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN16_AW, O>;
999impl<'a, const O: u8> PIN16_W<'a, O> {
1000    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1001    #[inline(always)]
1002    pub fn clear(self) -> &'a mut W {
1003        self.variant(PIN16_AW::CLEAR)
1004    }
1005}
1006#[doc = "Field `PIN17` reader - Pin 17"]
1007pub type PIN17_R = crate::BitReader<PIN17_A>;
1008#[doc = "Pin 17\n\nValue on reset: 0"]
1009#[derive(Clone, Copy, Debug, PartialEq)]
1010pub enum PIN17_A {
1011    #[doc = "0: Read: pin driver is low"]
1012    LOW = 0,
1013    #[doc = "1: Read: pin driver is high"]
1014    HIGH = 1,
1015}
1016impl From<PIN17_A> for bool {
1017    #[inline(always)]
1018    fn from(variant: PIN17_A) -> Self {
1019        variant as u8 != 0
1020    }
1021}
1022impl PIN17_R {
1023    #[doc = "Get enumerated values variant"]
1024    #[inline(always)]
1025    pub fn variant(&self) -> PIN17_A {
1026        match self.bits {
1027            false => PIN17_A::LOW,
1028            true => PIN17_A::HIGH,
1029        }
1030    }
1031    #[doc = "Checks if the value of the field is `LOW`"]
1032    #[inline(always)]
1033    pub fn is_low(&self) -> bool {
1034        *self == PIN17_A::LOW
1035    }
1036    #[doc = "Checks if the value of the field is `HIGH`"]
1037    #[inline(always)]
1038    pub fn is_high(&self) -> bool {
1039        *self == PIN17_A::HIGH
1040    }
1041}
1042#[doc = "Pin 17\n\nValue on reset: 0"]
1043#[derive(Clone, Copy, Debug, PartialEq)]
1044pub enum PIN17_AW {
1045    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1046    CLEAR = 1,
1047}
1048impl From<PIN17_AW> for bool {
1049    #[inline(always)]
1050    fn from(variant: PIN17_AW) -> Self {
1051        variant as u8 != 0
1052    }
1053}
1054#[doc = "Field `PIN17` writer - Pin 17"]
1055pub type PIN17_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN17_AW, O>;
1056impl<'a, const O: u8> PIN17_W<'a, O> {
1057    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1058    #[inline(always)]
1059    pub fn clear(self) -> &'a mut W {
1060        self.variant(PIN17_AW::CLEAR)
1061    }
1062}
1063#[doc = "Field `PIN18` reader - Pin 18"]
1064pub type PIN18_R = crate::BitReader<PIN18_A>;
1065#[doc = "Pin 18\n\nValue on reset: 0"]
1066#[derive(Clone, Copy, Debug, PartialEq)]
1067pub enum PIN18_A {
1068    #[doc = "0: Read: pin driver is low"]
1069    LOW = 0,
1070    #[doc = "1: Read: pin driver is high"]
1071    HIGH = 1,
1072}
1073impl From<PIN18_A> for bool {
1074    #[inline(always)]
1075    fn from(variant: PIN18_A) -> Self {
1076        variant as u8 != 0
1077    }
1078}
1079impl PIN18_R {
1080    #[doc = "Get enumerated values variant"]
1081    #[inline(always)]
1082    pub fn variant(&self) -> PIN18_A {
1083        match self.bits {
1084            false => PIN18_A::LOW,
1085            true => PIN18_A::HIGH,
1086        }
1087    }
1088    #[doc = "Checks if the value of the field is `LOW`"]
1089    #[inline(always)]
1090    pub fn is_low(&self) -> bool {
1091        *self == PIN18_A::LOW
1092    }
1093    #[doc = "Checks if the value of the field is `HIGH`"]
1094    #[inline(always)]
1095    pub fn is_high(&self) -> bool {
1096        *self == PIN18_A::HIGH
1097    }
1098}
1099#[doc = "Pin 18\n\nValue on reset: 0"]
1100#[derive(Clone, Copy, Debug, PartialEq)]
1101pub enum PIN18_AW {
1102    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1103    CLEAR = 1,
1104}
1105impl From<PIN18_AW> for bool {
1106    #[inline(always)]
1107    fn from(variant: PIN18_AW) -> Self {
1108        variant as u8 != 0
1109    }
1110}
1111#[doc = "Field `PIN18` writer - Pin 18"]
1112pub type PIN18_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN18_AW, O>;
1113impl<'a, const O: u8> PIN18_W<'a, O> {
1114    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1115    #[inline(always)]
1116    pub fn clear(self) -> &'a mut W {
1117        self.variant(PIN18_AW::CLEAR)
1118    }
1119}
1120#[doc = "Field `PIN19` reader - Pin 19"]
1121pub type PIN19_R = crate::BitReader<PIN19_A>;
1122#[doc = "Pin 19\n\nValue on reset: 0"]
1123#[derive(Clone, Copy, Debug, PartialEq)]
1124pub enum PIN19_A {
1125    #[doc = "0: Read: pin driver is low"]
1126    LOW = 0,
1127    #[doc = "1: Read: pin driver is high"]
1128    HIGH = 1,
1129}
1130impl From<PIN19_A> for bool {
1131    #[inline(always)]
1132    fn from(variant: PIN19_A) -> Self {
1133        variant as u8 != 0
1134    }
1135}
1136impl PIN19_R {
1137    #[doc = "Get enumerated values variant"]
1138    #[inline(always)]
1139    pub fn variant(&self) -> PIN19_A {
1140        match self.bits {
1141            false => PIN19_A::LOW,
1142            true => PIN19_A::HIGH,
1143        }
1144    }
1145    #[doc = "Checks if the value of the field is `LOW`"]
1146    #[inline(always)]
1147    pub fn is_low(&self) -> bool {
1148        *self == PIN19_A::LOW
1149    }
1150    #[doc = "Checks if the value of the field is `HIGH`"]
1151    #[inline(always)]
1152    pub fn is_high(&self) -> bool {
1153        *self == PIN19_A::HIGH
1154    }
1155}
1156#[doc = "Pin 19\n\nValue on reset: 0"]
1157#[derive(Clone, Copy, Debug, PartialEq)]
1158pub enum PIN19_AW {
1159    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1160    CLEAR = 1,
1161}
1162impl From<PIN19_AW> for bool {
1163    #[inline(always)]
1164    fn from(variant: PIN19_AW) -> Self {
1165        variant as u8 != 0
1166    }
1167}
1168#[doc = "Field `PIN19` writer - Pin 19"]
1169pub type PIN19_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN19_AW, O>;
1170impl<'a, const O: u8> PIN19_W<'a, O> {
1171    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1172    #[inline(always)]
1173    pub fn clear(self) -> &'a mut W {
1174        self.variant(PIN19_AW::CLEAR)
1175    }
1176}
1177#[doc = "Field `PIN20` reader - Pin 20"]
1178pub type PIN20_R = crate::BitReader<PIN20_A>;
1179#[doc = "Pin 20\n\nValue on reset: 0"]
1180#[derive(Clone, Copy, Debug, PartialEq)]
1181pub enum PIN20_A {
1182    #[doc = "0: Read: pin driver is low"]
1183    LOW = 0,
1184    #[doc = "1: Read: pin driver is high"]
1185    HIGH = 1,
1186}
1187impl From<PIN20_A> for bool {
1188    #[inline(always)]
1189    fn from(variant: PIN20_A) -> Self {
1190        variant as u8 != 0
1191    }
1192}
1193impl PIN20_R {
1194    #[doc = "Get enumerated values variant"]
1195    #[inline(always)]
1196    pub fn variant(&self) -> PIN20_A {
1197        match self.bits {
1198            false => PIN20_A::LOW,
1199            true => PIN20_A::HIGH,
1200        }
1201    }
1202    #[doc = "Checks if the value of the field is `LOW`"]
1203    #[inline(always)]
1204    pub fn is_low(&self) -> bool {
1205        *self == PIN20_A::LOW
1206    }
1207    #[doc = "Checks if the value of the field is `HIGH`"]
1208    #[inline(always)]
1209    pub fn is_high(&self) -> bool {
1210        *self == PIN20_A::HIGH
1211    }
1212}
1213#[doc = "Pin 20\n\nValue on reset: 0"]
1214#[derive(Clone, Copy, Debug, PartialEq)]
1215pub enum PIN20_AW {
1216    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1217    CLEAR = 1,
1218}
1219impl From<PIN20_AW> for bool {
1220    #[inline(always)]
1221    fn from(variant: PIN20_AW) -> Self {
1222        variant as u8 != 0
1223    }
1224}
1225#[doc = "Field `PIN20` writer - Pin 20"]
1226pub type PIN20_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN20_AW, O>;
1227impl<'a, const O: u8> PIN20_W<'a, O> {
1228    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1229    #[inline(always)]
1230    pub fn clear(self) -> &'a mut W {
1231        self.variant(PIN20_AW::CLEAR)
1232    }
1233}
1234#[doc = "Field `PIN21` reader - Pin 21"]
1235pub type PIN21_R = crate::BitReader<PIN21_A>;
1236#[doc = "Pin 21\n\nValue on reset: 0"]
1237#[derive(Clone, Copy, Debug, PartialEq)]
1238pub enum PIN21_A {
1239    #[doc = "0: Read: pin driver is low"]
1240    LOW = 0,
1241    #[doc = "1: Read: pin driver is high"]
1242    HIGH = 1,
1243}
1244impl From<PIN21_A> for bool {
1245    #[inline(always)]
1246    fn from(variant: PIN21_A) -> Self {
1247        variant as u8 != 0
1248    }
1249}
1250impl PIN21_R {
1251    #[doc = "Get enumerated values variant"]
1252    #[inline(always)]
1253    pub fn variant(&self) -> PIN21_A {
1254        match self.bits {
1255            false => PIN21_A::LOW,
1256            true => PIN21_A::HIGH,
1257        }
1258    }
1259    #[doc = "Checks if the value of the field is `LOW`"]
1260    #[inline(always)]
1261    pub fn is_low(&self) -> bool {
1262        *self == PIN21_A::LOW
1263    }
1264    #[doc = "Checks if the value of the field is `HIGH`"]
1265    #[inline(always)]
1266    pub fn is_high(&self) -> bool {
1267        *self == PIN21_A::HIGH
1268    }
1269}
1270#[doc = "Pin 21\n\nValue on reset: 0"]
1271#[derive(Clone, Copy, Debug, PartialEq)]
1272pub enum PIN21_AW {
1273    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1274    CLEAR = 1,
1275}
1276impl From<PIN21_AW> for bool {
1277    #[inline(always)]
1278    fn from(variant: PIN21_AW) -> Self {
1279        variant as u8 != 0
1280    }
1281}
1282#[doc = "Field `PIN21` writer - Pin 21"]
1283pub type PIN21_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN21_AW, O>;
1284impl<'a, const O: u8> PIN21_W<'a, O> {
1285    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1286    #[inline(always)]
1287    pub fn clear(self) -> &'a mut W {
1288        self.variant(PIN21_AW::CLEAR)
1289    }
1290}
1291#[doc = "Field `PIN22` reader - Pin 22"]
1292pub type PIN22_R = crate::BitReader<PIN22_A>;
1293#[doc = "Pin 22\n\nValue on reset: 0"]
1294#[derive(Clone, Copy, Debug, PartialEq)]
1295pub enum PIN22_A {
1296    #[doc = "0: Read: pin driver is low"]
1297    LOW = 0,
1298    #[doc = "1: Read: pin driver is high"]
1299    HIGH = 1,
1300}
1301impl From<PIN22_A> for bool {
1302    #[inline(always)]
1303    fn from(variant: PIN22_A) -> Self {
1304        variant as u8 != 0
1305    }
1306}
1307impl PIN22_R {
1308    #[doc = "Get enumerated values variant"]
1309    #[inline(always)]
1310    pub fn variant(&self) -> PIN22_A {
1311        match self.bits {
1312            false => PIN22_A::LOW,
1313            true => PIN22_A::HIGH,
1314        }
1315    }
1316    #[doc = "Checks if the value of the field is `LOW`"]
1317    #[inline(always)]
1318    pub fn is_low(&self) -> bool {
1319        *self == PIN22_A::LOW
1320    }
1321    #[doc = "Checks if the value of the field is `HIGH`"]
1322    #[inline(always)]
1323    pub fn is_high(&self) -> bool {
1324        *self == PIN22_A::HIGH
1325    }
1326}
1327#[doc = "Pin 22\n\nValue on reset: 0"]
1328#[derive(Clone, Copy, Debug, PartialEq)]
1329pub enum PIN22_AW {
1330    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1331    CLEAR = 1,
1332}
1333impl From<PIN22_AW> for bool {
1334    #[inline(always)]
1335    fn from(variant: PIN22_AW) -> Self {
1336        variant as u8 != 0
1337    }
1338}
1339#[doc = "Field `PIN22` writer - Pin 22"]
1340pub type PIN22_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN22_AW, O>;
1341impl<'a, const O: u8> PIN22_W<'a, O> {
1342    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1343    #[inline(always)]
1344    pub fn clear(self) -> &'a mut W {
1345        self.variant(PIN22_AW::CLEAR)
1346    }
1347}
1348#[doc = "Field `PIN23` reader - Pin 23"]
1349pub type PIN23_R = crate::BitReader<PIN23_A>;
1350#[doc = "Pin 23\n\nValue on reset: 0"]
1351#[derive(Clone, Copy, Debug, PartialEq)]
1352pub enum PIN23_A {
1353    #[doc = "0: Read: pin driver is low"]
1354    LOW = 0,
1355    #[doc = "1: Read: pin driver is high"]
1356    HIGH = 1,
1357}
1358impl From<PIN23_A> for bool {
1359    #[inline(always)]
1360    fn from(variant: PIN23_A) -> Self {
1361        variant as u8 != 0
1362    }
1363}
1364impl PIN23_R {
1365    #[doc = "Get enumerated values variant"]
1366    #[inline(always)]
1367    pub fn variant(&self) -> PIN23_A {
1368        match self.bits {
1369            false => PIN23_A::LOW,
1370            true => PIN23_A::HIGH,
1371        }
1372    }
1373    #[doc = "Checks if the value of the field is `LOW`"]
1374    #[inline(always)]
1375    pub fn is_low(&self) -> bool {
1376        *self == PIN23_A::LOW
1377    }
1378    #[doc = "Checks if the value of the field is `HIGH`"]
1379    #[inline(always)]
1380    pub fn is_high(&self) -> bool {
1381        *self == PIN23_A::HIGH
1382    }
1383}
1384#[doc = "Pin 23\n\nValue on reset: 0"]
1385#[derive(Clone, Copy, Debug, PartialEq)]
1386pub enum PIN23_AW {
1387    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1388    CLEAR = 1,
1389}
1390impl From<PIN23_AW> for bool {
1391    #[inline(always)]
1392    fn from(variant: PIN23_AW) -> Self {
1393        variant as u8 != 0
1394    }
1395}
1396#[doc = "Field `PIN23` writer - Pin 23"]
1397pub type PIN23_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN23_AW, O>;
1398impl<'a, const O: u8> PIN23_W<'a, O> {
1399    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1400    #[inline(always)]
1401    pub fn clear(self) -> &'a mut W {
1402        self.variant(PIN23_AW::CLEAR)
1403    }
1404}
1405#[doc = "Field `PIN24` reader - Pin 24"]
1406pub type PIN24_R = crate::BitReader<PIN24_A>;
1407#[doc = "Pin 24\n\nValue on reset: 0"]
1408#[derive(Clone, Copy, Debug, PartialEq)]
1409pub enum PIN24_A {
1410    #[doc = "0: Read: pin driver is low"]
1411    LOW = 0,
1412    #[doc = "1: Read: pin driver is high"]
1413    HIGH = 1,
1414}
1415impl From<PIN24_A> for bool {
1416    #[inline(always)]
1417    fn from(variant: PIN24_A) -> Self {
1418        variant as u8 != 0
1419    }
1420}
1421impl PIN24_R {
1422    #[doc = "Get enumerated values variant"]
1423    #[inline(always)]
1424    pub fn variant(&self) -> PIN24_A {
1425        match self.bits {
1426            false => PIN24_A::LOW,
1427            true => PIN24_A::HIGH,
1428        }
1429    }
1430    #[doc = "Checks if the value of the field is `LOW`"]
1431    #[inline(always)]
1432    pub fn is_low(&self) -> bool {
1433        *self == PIN24_A::LOW
1434    }
1435    #[doc = "Checks if the value of the field is `HIGH`"]
1436    #[inline(always)]
1437    pub fn is_high(&self) -> bool {
1438        *self == PIN24_A::HIGH
1439    }
1440}
1441#[doc = "Pin 24\n\nValue on reset: 0"]
1442#[derive(Clone, Copy, Debug, PartialEq)]
1443pub enum PIN24_AW {
1444    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1445    CLEAR = 1,
1446}
1447impl From<PIN24_AW> for bool {
1448    #[inline(always)]
1449    fn from(variant: PIN24_AW) -> Self {
1450        variant as u8 != 0
1451    }
1452}
1453#[doc = "Field `PIN24` writer - Pin 24"]
1454pub type PIN24_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN24_AW, O>;
1455impl<'a, const O: u8> PIN24_W<'a, O> {
1456    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1457    #[inline(always)]
1458    pub fn clear(self) -> &'a mut W {
1459        self.variant(PIN24_AW::CLEAR)
1460    }
1461}
1462#[doc = "Field `PIN25` reader - Pin 25"]
1463pub type PIN25_R = crate::BitReader<PIN25_A>;
1464#[doc = "Pin 25\n\nValue on reset: 0"]
1465#[derive(Clone, Copy, Debug, PartialEq)]
1466pub enum PIN25_A {
1467    #[doc = "0: Read: pin driver is low"]
1468    LOW = 0,
1469    #[doc = "1: Read: pin driver is high"]
1470    HIGH = 1,
1471}
1472impl From<PIN25_A> for bool {
1473    #[inline(always)]
1474    fn from(variant: PIN25_A) -> Self {
1475        variant as u8 != 0
1476    }
1477}
1478impl PIN25_R {
1479    #[doc = "Get enumerated values variant"]
1480    #[inline(always)]
1481    pub fn variant(&self) -> PIN25_A {
1482        match self.bits {
1483            false => PIN25_A::LOW,
1484            true => PIN25_A::HIGH,
1485        }
1486    }
1487    #[doc = "Checks if the value of the field is `LOW`"]
1488    #[inline(always)]
1489    pub fn is_low(&self) -> bool {
1490        *self == PIN25_A::LOW
1491    }
1492    #[doc = "Checks if the value of the field is `HIGH`"]
1493    #[inline(always)]
1494    pub fn is_high(&self) -> bool {
1495        *self == PIN25_A::HIGH
1496    }
1497}
1498#[doc = "Pin 25\n\nValue on reset: 0"]
1499#[derive(Clone, Copy, Debug, PartialEq)]
1500pub enum PIN25_AW {
1501    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1502    CLEAR = 1,
1503}
1504impl From<PIN25_AW> for bool {
1505    #[inline(always)]
1506    fn from(variant: PIN25_AW) -> Self {
1507        variant as u8 != 0
1508    }
1509}
1510#[doc = "Field `PIN25` writer - Pin 25"]
1511pub type PIN25_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN25_AW, O>;
1512impl<'a, const O: u8> PIN25_W<'a, O> {
1513    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1514    #[inline(always)]
1515    pub fn clear(self) -> &'a mut W {
1516        self.variant(PIN25_AW::CLEAR)
1517    }
1518}
1519#[doc = "Field `PIN26` reader - Pin 26"]
1520pub type PIN26_R = crate::BitReader<PIN26_A>;
1521#[doc = "Pin 26\n\nValue on reset: 0"]
1522#[derive(Clone, Copy, Debug, PartialEq)]
1523pub enum PIN26_A {
1524    #[doc = "0: Read: pin driver is low"]
1525    LOW = 0,
1526    #[doc = "1: Read: pin driver is high"]
1527    HIGH = 1,
1528}
1529impl From<PIN26_A> for bool {
1530    #[inline(always)]
1531    fn from(variant: PIN26_A) -> Self {
1532        variant as u8 != 0
1533    }
1534}
1535impl PIN26_R {
1536    #[doc = "Get enumerated values variant"]
1537    #[inline(always)]
1538    pub fn variant(&self) -> PIN26_A {
1539        match self.bits {
1540            false => PIN26_A::LOW,
1541            true => PIN26_A::HIGH,
1542        }
1543    }
1544    #[doc = "Checks if the value of the field is `LOW`"]
1545    #[inline(always)]
1546    pub fn is_low(&self) -> bool {
1547        *self == PIN26_A::LOW
1548    }
1549    #[doc = "Checks if the value of the field is `HIGH`"]
1550    #[inline(always)]
1551    pub fn is_high(&self) -> bool {
1552        *self == PIN26_A::HIGH
1553    }
1554}
1555#[doc = "Pin 26\n\nValue on reset: 0"]
1556#[derive(Clone, Copy, Debug, PartialEq)]
1557pub enum PIN26_AW {
1558    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1559    CLEAR = 1,
1560}
1561impl From<PIN26_AW> for bool {
1562    #[inline(always)]
1563    fn from(variant: PIN26_AW) -> Self {
1564        variant as u8 != 0
1565    }
1566}
1567#[doc = "Field `PIN26` writer - Pin 26"]
1568pub type PIN26_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN26_AW, O>;
1569impl<'a, const O: u8> PIN26_W<'a, O> {
1570    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1571    #[inline(always)]
1572    pub fn clear(self) -> &'a mut W {
1573        self.variant(PIN26_AW::CLEAR)
1574    }
1575}
1576#[doc = "Field `PIN27` reader - Pin 27"]
1577pub type PIN27_R = crate::BitReader<PIN27_A>;
1578#[doc = "Pin 27\n\nValue on reset: 0"]
1579#[derive(Clone, Copy, Debug, PartialEq)]
1580pub enum PIN27_A {
1581    #[doc = "0: Read: pin driver is low"]
1582    LOW = 0,
1583    #[doc = "1: Read: pin driver is high"]
1584    HIGH = 1,
1585}
1586impl From<PIN27_A> for bool {
1587    #[inline(always)]
1588    fn from(variant: PIN27_A) -> Self {
1589        variant as u8 != 0
1590    }
1591}
1592impl PIN27_R {
1593    #[doc = "Get enumerated values variant"]
1594    #[inline(always)]
1595    pub fn variant(&self) -> PIN27_A {
1596        match self.bits {
1597            false => PIN27_A::LOW,
1598            true => PIN27_A::HIGH,
1599        }
1600    }
1601    #[doc = "Checks if the value of the field is `LOW`"]
1602    #[inline(always)]
1603    pub fn is_low(&self) -> bool {
1604        *self == PIN27_A::LOW
1605    }
1606    #[doc = "Checks if the value of the field is `HIGH`"]
1607    #[inline(always)]
1608    pub fn is_high(&self) -> bool {
1609        *self == PIN27_A::HIGH
1610    }
1611}
1612#[doc = "Pin 27\n\nValue on reset: 0"]
1613#[derive(Clone, Copy, Debug, PartialEq)]
1614pub enum PIN27_AW {
1615    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1616    CLEAR = 1,
1617}
1618impl From<PIN27_AW> for bool {
1619    #[inline(always)]
1620    fn from(variant: PIN27_AW) -> Self {
1621        variant as u8 != 0
1622    }
1623}
1624#[doc = "Field `PIN27` writer - Pin 27"]
1625pub type PIN27_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN27_AW, O>;
1626impl<'a, const O: u8> PIN27_W<'a, O> {
1627    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1628    #[inline(always)]
1629    pub fn clear(self) -> &'a mut W {
1630        self.variant(PIN27_AW::CLEAR)
1631    }
1632}
1633#[doc = "Field `PIN28` reader - Pin 28"]
1634pub type PIN28_R = crate::BitReader<PIN28_A>;
1635#[doc = "Pin 28\n\nValue on reset: 0"]
1636#[derive(Clone, Copy, Debug, PartialEq)]
1637pub enum PIN28_A {
1638    #[doc = "0: Read: pin driver is low"]
1639    LOW = 0,
1640    #[doc = "1: Read: pin driver is high"]
1641    HIGH = 1,
1642}
1643impl From<PIN28_A> for bool {
1644    #[inline(always)]
1645    fn from(variant: PIN28_A) -> Self {
1646        variant as u8 != 0
1647    }
1648}
1649impl PIN28_R {
1650    #[doc = "Get enumerated values variant"]
1651    #[inline(always)]
1652    pub fn variant(&self) -> PIN28_A {
1653        match self.bits {
1654            false => PIN28_A::LOW,
1655            true => PIN28_A::HIGH,
1656        }
1657    }
1658    #[doc = "Checks if the value of the field is `LOW`"]
1659    #[inline(always)]
1660    pub fn is_low(&self) -> bool {
1661        *self == PIN28_A::LOW
1662    }
1663    #[doc = "Checks if the value of the field is `HIGH`"]
1664    #[inline(always)]
1665    pub fn is_high(&self) -> bool {
1666        *self == PIN28_A::HIGH
1667    }
1668}
1669#[doc = "Pin 28\n\nValue on reset: 0"]
1670#[derive(Clone, Copy, Debug, PartialEq)]
1671pub enum PIN28_AW {
1672    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1673    CLEAR = 1,
1674}
1675impl From<PIN28_AW> for bool {
1676    #[inline(always)]
1677    fn from(variant: PIN28_AW) -> Self {
1678        variant as u8 != 0
1679    }
1680}
1681#[doc = "Field `PIN28` writer - Pin 28"]
1682pub type PIN28_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN28_AW, O>;
1683impl<'a, const O: u8> PIN28_W<'a, O> {
1684    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1685    #[inline(always)]
1686    pub fn clear(self) -> &'a mut W {
1687        self.variant(PIN28_AW::CLEAR)
1688    }
1689}
1690#[doc = "Field `PIN29` reader - Pin 29"]
1691pub type PIN29_R = crate::BitReader<PIN29_A>;
1692#[doc = "Pin 29\n\nValue on reset: 0"]
1693#[derive(Clone, Copy, Debug, PartialEq)]
1694pub enum PIN29_A {
1695    #[doc = "0: Read: pin driver is low"]
1696    LOW = 0,
1697    #[doc = "1: Read: pin driver is high"]
1698    HIGH = 1,
1699}
1700impl From<PIN29_A> for bool {
1701    #[inline(always)]
1702    fn from(variant: PIN29_A) -> Self {
1703        variant as u8 != 0
1704    }
1705}
1706impl PIN29_R {
1707    #[doc = "Get enumerated values variant"]
1708    #[inline(always)]
1709    pub fn variant(&self) -> PIN29_A {
1710        match self.bits {
1711            false => PIN29_A::LOW,
1712            true => PIN29_A::HIGH,
1713        }
1714    }
1715    #[doc = "Checks if the value of the field is `LOW`"]
1716    #[inline(always)]
1717    pub fn is_low(&self) -> bool {
1718        *self == PIN29_A::LOW
1719    }
1720    #[doc = "Checks if the value of the field is `HIGH`"]
1721    #[inline(always)]
1722    pub fn is_high(&self) -> bool {
1723        *self == PIN29_A::HIGH
1724    }
1725}
1726#[doc = "Pin 29\n\nValue on reset: 0"]
1727#[derive(Clone, Copy, Debug, PartialEq)]
1728pub enum PIN29_AW {
1729    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1730    CLEAR = 1,
1731}
1732impl From<PIN29_AW> for bool {
1733    #[inline(always)]
1734    fn from(variant: PIN29_AW) -> Self {
1735        variant as u8 != 0
1736    }
1737}
1738#[doc = "Field `PIN29` writer - Pin 29"]
1739pub type PIN29_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN29_AW, O>;
1740impl<'a, const O: u8> PIN29_W<'a, O> {
1741    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1742    #[inline(always)]
1743    pub fn clear(self) -> &'a mut W {
1744        self.variant(PIN29_AW::CLEAR)
1745    }
1746}
1747#[doc = "Field `PIN30` reader - Pin 30"]
1748pub type PIN30_R = crate::BitReader<PIN30_A>;
1749#[doc = "Pin 30\n\nValue on reset: 0"]
1750#[derive(Clone, Copy, Debug, PartialEq)]
1751pub enum PIN30_A {
1752    #[doc = "0: Read: pin driver is low"]
1753    LOW = 0,
1754    #[doc = "1: Read: pin driver is high"]
1755    HIGH = 1,
1756}
1757impl From<PIN30_A> for bool {
1758    #[inline(always)]
1759    fn from(variant: PIN30_A) -> Self {
1760        variant as u8 != 0
1761    }
1762}
1763impl PIN30_R {
1764    #[doc = "Get enumerated values variant"]
1765    #[inline(always)]
1766    pub fn variant(&self) -> PIN30_A {
1767        match self.bits {
1768            false => PIN30_A::LOW,
1769            true => PIN30_A::HIGH,
1770        }
1771    }
1772    #[doc = "Checks if the value of the field is `LOW`"]
1773    #[inline(always)]
1774    pub fn is_low(&self) -> bool {
1775        *self == PIN30_A::LOW
1776    }
1777    #[doc = "Checks if the value of the field is `HIGH`"]
1778    #[inline(always)]
1779    pub fn is_high(&self) -> bool {
1780        *self == PIN30_A::HIGH
1781    }
1782}
1783#[doc = "Pin 30\n\nValue on reset: 0"]
1784#[derive(Clone, Copy, Debug, PartialEq)]
1785pub enum PIN30_AW {
1786    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1787    CLEAR = 1,
1788}
1789impl From<PIN30_AW> for bool {
1790    #[inline(always)]
1791    fn from(variant: PIN30_AW) -> Self {
1792        variant as u8 != 0
1793    }
1794}
1795#[doc = "Field `PIN30` writer - Pin 30"]
1796pub type PIN30_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN30_AW, O>;
1797impl<'a, const O: u8> PIN30_W<'a, O> {
1798    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1799    #[inline(always)]
1800    pub fn clear(self) -> &'a mut W {
1801        self.variant(PIN30_AW::CLEAR)
1802    }
1803}
1804#[doc = "Field `PIN31` reader - Pin 31"]
1805pub type PIN31_R = crate::BitReader<PIN31_A>;
1806#[doc = "Pin 31\n\nValue on reset: 0"]
1807#[derive(Clone, Copy, Debug, PartialEq)]
1808pub enum PIN31_A {
1809    #[doc = "0: Read: pin driver is low"]
1810    LOW = 0,
1811    #[doc = "1: Read: pin driver is high"]
1812    HIGH = 1,
1813}
1814impl From<PIN31_A> for bool {
1815    #[inline(always)]
1816    fn from(variant: PIN31_A) -> Self {
1817        variant as u8 != 0
1818    }
1819}
1820impl PIN31_R {
1821    #[doc = "Get enumerated values variant"]
1822    #[inline(always)]
1823    pub fn variant(&self) -> PIN31_A {
1824        match self.bits {
1825            false => PIN31_A::LOW,
1826            true => PIN31_A::HIGH,
1827        }
1828    }
1829    #[doc = "Checks if the value of the field is `LOW`"]
1830    #[inline(always)]
1831    pub fn is_low(&self) -> bool {
1832        *self == PIN31_A::LOW
1833    }
1834    #[doc = "Checks if the value of the field is `HIGH`"]
1835    #[inline(always)]
1836    pub fn is_high(&self) -> bool {
1837        *self == PIN31_A::HIGH
1838    }
1839}
1840#[doc = "Pin 31\n\nValue on reset: 0"]
1841#[derive(Clone, Copy, Debug, PartialEq)]
1842pub enum PIN31_AW {
1843    #[doc = "1: Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1844    CLEAR = 1,
1845}
1846impl From<PIN31_AW> for bool {
1847    #[inline(always)]
1848    fn from(variant: PIN31_AW) -> Self {
1849        variant as u8 != 0
1850    }
1851}
1852#[doc = "Field `PIN31` writer - Pin 31"]
1853pub type PIN31_W<'a, const O: u8> = crate::BitWriter1C<'a, u32, OUTCLR_SPEC, PIN31_AW, O>;
1854impl<'a, const O: u8> PIN31_W<'a, O> {
1855    #[doc = "Write: writing a '1' sets the pin low; writing a '0' has no effect"]
1856    #[inline(always)]
1857    pub fn clear(self) -> &'a mut W {
1858        self.variant(PIN31_AW::CLEAR)
1859    }
1860}
1861impl R {
1862    #[doc = "Bit 0 - Pin 0"]
1863    #[inline(always)]
1864    pub fn pin0(&self) -> PIN0_R {
1865        PIN0_R::new((self.bits & 1) != 0)
1866    }
1867    #[doc = "Bit 1 - Pin 1"]
1868    #[inline(always)]
1869    pub fn pin1(&self) -> PIN1_R {
1870        PIN1_R::new(((self.bits >> 1) & 1) != 0)
1871    }
1872    #[doc = "Bit 2 - Pin 2"]
1873    #[inline(always)]
1874    pub fn pin2(&self) -> PIN2_R {
1875        PIN2_R::new(((self.bits >> 2) & 1) != 0)
1876    }
1877    #[doc = "Bit 3 - Pin 3"]
1878    #[inline(always)]
1879    pub fn pin3(&self) -> PIN3_R {
1880        PIN3_R::new(((self.bits >> 3) & 1) != 0)
1881    }
1882    #[doc = "Bit 4 - Pin 4"]
1883    #[inline(always)]
1884    pub fn pin4(&self) -> PIN4_R {
1885        PIN4_R::new(((self.bits >> 4) & 1) != 0)
1886    }
1887    #[doc = "Bit 5 - Pin 5"]
1888    #[inline(always)]
1889    pub fn pin5(&self) -> PIN5_R {
1890        PIN5_R::new(((self.bits >> 5) & 1) != 0)
1891    }
1892    #[doc = "Bit 6 - Pin 6"]
1893    #[inline(always)]
1894    pub fn pin6(&self) -> PIN6_R {
1895        PIN6_R::new(((self.bits >> 6) & 1) != 0)
1896    }
1897    #[doc = "Bit 7 - Pin 7"]
1898    #[inline(always)]
1899    pub fn pin7(&self) -> PIN7_R {
1900        PIN7_R::new(((self.bits >> 7) & 1) != 0)
1901    }
1902    #[doc = "Bit 8 - Pin 8"]
1903    #[inline(always)]
1904    pub fn pin8(&self) -> PIN8_R {
1905        PIN8_R::new(((self.bits >> 8) & 1) != 0)
1906    }
1907    #[doc = "Bit 9 - Pin 9"]
1908    #[inline(always)]
1909    pub fn pin9(&self) -> PIN9_R {
1910        PIN9_R::new(((self.bits >> 9) & 1) != 0)
1911    }
1912    #[doc = "Bit 10 - Pin 10"]
1913    #[inline(always)]
1914    pub fn pin10(&self) -> PIN10_R {
1915        PIN10_R::new(((self.bits >> 10) & 1) != 0)
1916    }
1917    #[doc = "Bit 11 - Pin 11"]
1918    #[inline(always)]
1919    pub fn pin11(&self) -> PIN11_R {
1920        PIN11_R::new(((self.bits >> 11) & 1) != 0)
1921    }
1922    #[doc = "Bit 12 - Pin 12"]
1923    #[inline(always)]
1924    pub fn pin12(&self) -> PIN12_R {
1925        PIN12_R::new(((self.bits >> 12) & 1) != 0)
1926    }
1927    #[doc = "Bit 13 - Pin 13"]
1928    #[inline(always)]
1929    pub fn pin13(&self) -> PIN13_R {
1930        PIN13_R::new(((self.bits >> 13) & 1) != 0)
1931    }
1932    #[doc = "Bit 14 - Pin 14"]
1933    #[inline(always)]
1934    pub fn pin14(&self) -> PIN14_R {
1935        PIN14_R::new(((self.bits >> 14) & 1) != 0)
1936    }
1937    #[doc = "Bit 15 - Pin 15"]
1938    #[inline(always)]
1939    pub fn pin15(&self) -> PIN15_R {
1940        PIN15_R::new(((self.bits >> 15) & 1) != 0)
1941    }
1942    #[doc = "Bit 16 - Pin 16"]
1943    #[inline(always)]
1944    pub fn pin16(&self) -> PIN16_R {
1945        PIN16_R::new(((self.bits >> 16) & 1) != 0)
1946    }
1947    #[doc = "Bit 17 - Pin 17"]
1948    #[inline(always)]
1949    pub fn pin17(&self) -> PIN17_R {
1950        PIN17_R::new(((self.bits >> 17) & 1) != 0)
1951    }
1952    #[doc = "Bit 18 - Pin 18"]
1953    #[inline(always)]
1954    pub fn pin18(&self) -> PIN18_R {
1955        PIN18_R::new(((self.bits >> 18) & 1) != 0)
1956    }
1957    #[doc = "Bit 19 - Pin 19"]
1958    #[inline(always)]
1959    pub fn pin19(&self) -> PIN19_R {
1960        PIN19_R::new(((self.bits >> 19) & 1) != 0)
1961    }
1962    #[doc = "Bit 20 - Pin 20"]
1963    #[inline(always)]
1964    pub fn pin20(&self) -> PIN20_R {
1965        PIN20_R::new(((self.bits >> 20) & 1) != 0)
1966    }
1967    #[doc = "Bit 21 - Pin 21"]
1968    #[inline(always)]
1969    pub fn pin21(&self) -> PIN21_R {
1970        PIN21_R::new(((self.bits >> 21) & 1) != 0)
1971    }
1972    #[doc = "Bit 22 - Pin 22"]
1973    #[inline(always)]
1974    pub fn pin22(&self) -> PIN22_R {
1975        PIN22_R::new(((self.bits >> 22) & 1) != 0)
1976    }
1977    #[doc = "Bit 23 - Pin 23"]
1978    #[inline(always)]
1979    pub fn pin23(&self) -> PIN23_R {
1980        PIN23_R::new(((self.bits >> 23) & 1) != 0)
1981    }
1982    #[doc = "Bit 24 - Pin 24"]
1983    #[inline(always)]
1984    pub fn pin24(&self) -> PIN24_R {
1985        PIN24_R::new(((self.bits >> 24) & 1) != 0)
1986    }
1987    #[doc = "Bit 25 - Pin 25"]
1988    #[inline(always)]
1989    pub fn pin25(&self) -> PIN25_R {
1990        PIN25_R::new(((self.bits >> 25) & 1) != 0)
1991    }
1992    #[doc = "Bit 26 - Pin 26"]
1993    #[inline(always)]
1994    pub fn pin26(&self) -> PIN26_R {
1995        PIN26_R::new(((self.bits >> 26) & 1) != 0)
1996    }
1997    #[doc = "Bit 27 - Pin 27"]
1998    #[inline(always)]
1999    pub fn pin27(&self) -> PIN27_R {
2000        PIN27_R::new(((self.bits >> 27) & 1) != 0)
2001    }
2002    #[doc = "Bit 28 - Pin 28"]
2003    #[inline(always)]
2004    pub fn pin28(&self) -> PIN28_R {
2005        PIN28_R::new(((self.bits >> 28) & 1) != 0)
2006    }
2007    #[doc = "Bit 29 - Pin 29"]
2008    #[inline(always)]
2009    pub fn pin29(&self) -> PIN29_R {
2010        PIN29_R::new(((self.bits >> 29) & 1) != 0)
2011    }
2012    #[doc = "Bit 30 - Pin 30"]
2013    #[inline(always)]
2014    pub fn pin30(&self) -> PIN30_R {
2015        PIN30_R::new(((self.bits >> 30) & 1) != 0)
2016    }
2017    #[doc = "Bit 31 - Pin 31"]
2018    #[inline(always)]
2019    pub fn pin31(&self) -> PIN31_R {
2020        PIN31_R::new(((self.bits >> 31) & 1) != 0)
2021    }
2022}
2023impl W {
2024    #[doc = "Bit 0 - Pin 0"]
2025    #[inline(always)]
2026    pub fn pin0(&mut self) -> PIN0_W<0> {
2027        PIN0_W::new(self)
2028    }
2029    #[doc = "Bit 1 - Pin 1"]
2030    #[inline(always)]
2031    pub fn pin1(&mut self) -> PIN1_W<1> {
2032        PIN1_W::new(self)
2033    }
2034    #[doc = "Bit 2 - Pin 2"]
2035    #[inline(always)]
2036    pub fn pin2(&mut self) -> PIN2_W<2> {
2037        PIN2_W::new(self)
2038    }
2039    #[doc = "Bit 3 - Pin 3"]
2040    #[inline(always)]
2041    pub fn pin3(&mut self) -> PIN3_W<3> {
2042        PIN3_W::new(self)
2043    }
2044    #[doc = "Bit 4 - Pin 4"]
2045    #[inline(always)]
2046    pub fn pin4(&mut self) -> PIN4_W<4> {
2047        PIN4_W::new(self)
2048    }
2049    #[doc = "Bit 5 - Pin 5"]
2050    #[inline(always)]
2051    pub fn pin5(&mut self) -> PIN5_W<5> {
2052        PIN5_W::new(self)
2053    }
2054    #[doc = "Bit 6 - Pin 6"]
2055    #[inline(always)]
2056    pub fn pin6(&mut self) -> PIN6_W<6> {
2057        PIN6_W::new(self)
2058    }
2059    #[doc = "Bit 7 - Pin 7"]
2060    #[inline(always)]
2061    pub fn pin7(&mut self) -> PIN7_W<7> {
2062        PIN7_W::new(self)
2063    }
2064    #[doc = "Bit 8 - Pin 8"]
2065    #[inline(always)]
2066    pub fn pin8(&mut self) -> PIN8_W<8> {
2067        PIN8_W::new(self)
2068    }
2069    #[doc = "Bit 9 - Pin 9"]
2070    #[inline(always)]
2071    pub fn pin9(&mut self) -> PIN9_W<9> {
2072        PIN9_W::new(self)
2073    }
2074    #[doc = "Bit 10 - Pin 10"]
2075    #[inline(always)]
2076    pub fn pin10(&mut self) -> PIN10_W<10> {
2077        PIN10_W::new(self)
2078    }
2079    #[doc = "Bit 11 - Pin 11"]
2080    #[inline(always)]
2081    pub fn pin11(&mut self) -> PIN11_W<11> {
2082        PIN11_W::new(self)
2083    }
2084    #[doc = "Bit 12 - Pin 12"]
2085    #[inline(always)]
2086    pub fn pin12(&mut self) -> PIN12_W<12> {
2087        PIN12_W::new(self)
2088    }
2089    #[doc = "Bit 13 - Pin 13"]
2090    #[inline(always)]
2091    pub fn pin13(&mut self) -> PIN13_W<13> {
2092        PIN13_W::new(self)
2093    }
2094    #[doc = "Bit 14 - Pin 14"]
2095    #[inline(always)]
2096    pub fn pin14(&mut self) -> PIN14_W<14> {
2097        PIN14_W::new(self)
2098    }
2099    #[doc = "Bit 15 - Pin 15"]
2100    #[inline(always)]
2101    pub fn pin15(&mut self) -> PIN15_W<15> {
2102        PIN15_W::new(self)
2103    }
2104    #[doc = "Bit 16 - Pin 16"]
2105    #[inline(always)]
2106    pub fn pin16(&mut self) -> PIN16_W<16> {
2107        PIN16_W::new(self)
2108    }
2109    #[doc = "Bit 17 - Pin 17"]
2110    #[inline(always)]
2111    pub fn pin17(&mut self) -> PIN17_W<17> {
2112        PIN17_W::new(self)
2113    }
2114    #[doc = "Bit 18 - Pin 18"]
2115    #[inline(always)]
2116    pub fn pin18(&mut self) -> PIN18_W<18> {
2117        PIN18_W::new(self)
2118    }
2119    #[doc = "Bit 19 - Pin 19"]
2120    #[inline(always)]
2121    pub fn pin19(&mut self) -> PIN19_W<19> {
2122        PIN19_W::new(self)
2123    }
2124    #[doc = "Bit 20 - Pin 20"]
2125    #[inline(always)]
2126    pub fn pin20(&mut self) -> PIN20_W<20> {
2127        PIN20_W::new(self)
2128    }
2129    #[doc = "Bit 21 - Pin 21"]
2130    #[inline(always)]
2131    pub fn pin21(&mut self) -> PIN21_W<21> {
2132        PIN21_W::new(self)
2133    }
2134    #[doc = "Bit 22 - Pin 22"]
2135    #[inline(always)]
2136    pub fn pin22(&mut self) -> PIN22_W<22> {
2137        PIN22_W::new(self)
2138    }
2139    #[doc = "Bit 23 - Pin 23"]
2140    #[inline(always)]
2141    pub fn pin23(&mut self) -> PIN23_W<23> {
2142        PIN23_W::new(self)
2143    }
2144    #[doc = "Bit 24 - Pin 24"]
2145    #[inline(always)]
2146    pub fn pin24(&mut self) -> PIN24_W<24> {
2147        PIN24_W::new(self)
2148    }
2149    #[doc = "Bit 25 - Pin 25"]
2150    #[inline(always)]
2151    pub fn pin25(&mut self) -> PIN25_W<25> {
2152        PIN25_W::new(self)
2153    }
2154    #[doc = "Bit 26 - Pin 26"]
2155    #[inline(always)]
2156    pub fn pin26(&mut self) -> PIN26_W<26> {
2157        PIN26_W::new(self)
2158    }
2159    #[doc = "Bit 27 - Pin 27"]
2160    #[inline(always)]
2161    pub fn pin27(&mut self) -> PIN27_W<27> {
2162        PIN27_W::new(self)
2163    }
2164    #[doc = "Bit 28 - Pin 28"]
2165    #[inline(always)]
2166    pub fn pin28(&mut self) -> PIN28_W<28> {
2167        PIN28_W::new(self)
2168    }
2169    #[doc = "Bit 29 - Pin 29"]
2170    #[inline(always)]
2171    pub fn pin29(&mut self) -> PIN29_W<29> {
2172        PIN29_W::new(self)
2173    }
2174    #[doc = "Bit 30 - Pin 30"]
2175    #[inline(always)]
2176    pub fn pin30(&mut self) -> PIN30_W<30> {
2177        PIN30_W::new(self)
2178    }
2179    #[doc = "Bit 31 - Pin 31"]
2180    #[inline(always)]
2181    pub fn pin31(&mut self) -> PIN31_W<31> {
2182        PIN31_W::new(self)
2183    }
2184    #[doc = "Writes raw bits to the register."]
2185    #[inline(always)]
2186    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
2187        self.0.bits(bits);
2188        self
2189    }
2190}
2191#[doc = "Clear individual bits in GPIO port\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 [outclr](index.html) module"]
2192pub struct OUTCLR_SPEC;
2193impl crate::RegisterSpec for OUTCLR_SPEC {
2194    type Ux = u32;
2195}
2196#[doc = "`read()` method returns [outclr::R](R) reader structure"]
2197impl crate::Readable for OUTCLR_SPEC {
2198    type Reader = R;
2199}
2200#[doc = "`write(|w| ..)` method takes [outclr::W](W) writer structure"]
2201impl crate::Writable for OUTCLR_SPEC {
2202    type Writer = W;
2203}
2204#[doc = "`reset()` method sets OUTCLR to value 0"]
2205impl crate::Resettable for OUTCLR_SPEC {
2206    #[inline(always)]
2207    fn reset_value() -> Self::Ux {
2208        0
2209    }
2210}
nrf52840_pac/p0/outclr.rs

nrf52840_pac/p0/
outclr.rs
