nrf52840_pac/p0/
in_.rs

Help
1#[doc = "Register `IN` reader"]
2pub struct R(crate::R<IN_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<IN_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<IN_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<IN_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Field `PIN0` reader - Pin 0"]
17pub type PIN0_R = crate::BitReader<PIN0_A>;
18#[doc = "Pin 0\n\nValue on reset: 0"]
19#[derive(Clone, Copy, Debug, PartialEq)]
20pub enum PIN0_A {
21    #[doc = "0: Pin input is low"]
22    LOW = 0,
23    #[doc = "1: Pin input is high"]
24    HIGH = 1,
25}
26impl From<PIN0_A> for bool {
27    #[inline(always)]
28    fn from(variant: PIN0_A) -> Self {
29        variant as u8 != 0
30    }
31}
32impl PIN0_R {
33    #[doc = "Get enumerated values variant"]
34    #[inline(always)]
35    pub fn variant(&self) -> PIN0_A {
36        match self.bits {
37            false => PIN0_A::LOW,
38            true => PIN0_A::HIGH,
39        }
40    }
41    #[doc = "Checks if the value of the field is `LOW`"]
42    #[inline(always)]
43    pub fn is_low(&self) -> bool {
44        *self == PIN0_A::LOW
45    }
46    #[doc = "Checks if the value of the field is `HIGH`"]
47    #[inline(always)]
48    pub fn is_high(&self) -> bool {
49        *self == PIN0_A::HIGH
50    }
51}
52#[doc = "Field `PIN1` reader - Pin 1"]
53pub type PIN1_R = crate::BitReader<PIN1_A>;
54#[doc = "Pin 1\n\nValue on reset: 0"]
55#[derive(Clone, Copy, Debug, PartialEq)]
56pub enum PIN1_A {
57    #[doc = "0: Pin input is low"]
58    LOW = 0,
59    #[doc = "1: Pin input is high"]
60    HIGH = 1,
61}
62impl From<PIN1_A> for bool {
63    #[inline(always)]
64    fn from(variant: PIN1_A) -> Self {
65        variant as u8 != 0
66    }
67}
68impl PIN1_R {
69    #[doc = "Get enumerated values variant"]
70    #[inline(always)]
71    pub fn variant(&self) -> PIN1_A {
72        match self.bits {
73            false => PIN1_A::LOW,
74            true => PIN1_A::HIGH,
75        }
76    }
77    #[doc = "Checks if the value of the field is `LOW`"]
78    #[inline(always)]
79    pub fn is_low(&self) -> bool {
80        *self == PIN1_A::LOW
81    }
82    #[doc = "Checks if the value of the field is `HIGH`"]
83    #[inline(always)]
84    pub fn is_high(&self) -> bool {
85        *self == PIN1_A::HIGH
86    }
87}
88#[doc = "Field `PIN2` reader - Pin 2"]
89pub type PIN2_R = crate::BitReader<PIN2_A>;
90#[doc = "Pin 2\n\nValue on reset: 0"]
91#[derive(Clone, Copy, Debug, PartialEq)]
92pub enum PIN2_A {
93    #[doc = "0: Pin input is low"]
94    LOW = 0,
95    #[doc = "1: Pin input is high"]
96    HIGH = 1,
97}
98impl From<PIN2_A> for bool {
99    #[inline(always)]
100    fn from(variant: PIN2_A) -> Self {
101        variant as u8 != 0
102    }
103}
104impl PIN2_R {
105    #[doc = "Get enumerated values variant"]
106    #[inline(always)]
107    pub fn variant(&self) -> PIN2_A {
108        match self.bits {
109            false => PIN2_A::LOW,
110            true => PIN2_A::HIGH,
111        }
112    }
113    #[doc = "Checks if the value of the field is `LOW`"]
114    #[inline(always)]
115    pub fn is_low(&self) -> bool {
116        *self == PIN2_A::LOW
117    }
118    #[doc = "Checks if the value of the field is `HIGH`"]
119    #[inline(always)]
120    pub fn is_high(&self) -> bool {
121        *self == PIN2_A::HIGH
122    }
123}
124#[doc = "Field `PIN3` reader - Pin 3"]
125pub type PIN3_R = crate::BitReader<PIN3_A>;
126#[doc = "Pin 3\n\nValue on reset: 0"]
127#[derive(Clone, Copy, Debug, PartialEq)]
128pub enum PIN3_A {
129    #[doc = "0: Pin input is low"]
130    LOW = 0,
131    #[doc = "1: Pin input is high"]
132    HIGH = 1,
133}
134impl From<PIN3_A> for bool {
135    #[inline(always)]
136    fn from(variant: PIN3_A) -> Self {
137        variant as u8 != 0
138    }
139}
140impl PIN3_R {
141    #[doc = "Get enumerated values variant"]
142    #[inline(always)]
143    pub fn variant(&self) -> PIN3_A {
144        match self.bits {
145            false => PIN3_A::LOW,
146            true => PIN3_A::HIGH,
147        }
148    }
149    #[doc = "Checks if the value of the field is `LOW`"]
150    #[inline(always)]
151    pub fn is_low(&self) -> bool {
152        *self == PIN3_A::LOW
153    }
154    #[doc = "Checks if the value of the field is `HIGH`"]
155    #[inline(always)]
156    pub fn is_high(&self) -> bool {
157        *self == PIN3_A::HIGH
158    }
159}
160#[doc = "Field `PIN4` reader - Pin 4"]
161pub type PIN4_R = crate::BitReader<PIN4_A>;
162#[doc = "Pin 4\n\nValue on reset: 0"]
163#[derive(Clone, Copy, Debug, PartialEq)]
164pub enum PIN4_A {
165    #[doc = "0: Pin input is low"]
166    LOW = 0,
167    #[doc = "1: Pin input is high"]
168    HIGH = 1,
169}
170impl From<PIN4_A> for bool {
171    #[inline(always)]
172    fn from(variant: PIN4_A) -> Self {
173        variant as u8 != 0
174    }
175}
176impl PIN4_R {
177    #[doc = "Get enumerated values variant"]
178    #[inline(always)]
179    pub fn variant(&self) -> PIN4_A {
180        match self.bits {
181            false => PIN4_A::LOW,
182            true => PIN4_A::HIGH,
183        }
184    }
185    #[doc = "Checks if the value of the field is `LOW`"]
186    #[inline(always)]
187    pub fn is_low(&self) -> bool {
188        *self == PIN4_A::LOW
189    }
190    #[doc = "Checks if the value of the field is `HIGH`"]
191    #[inline(always)]
192    pub fn is_high(&self) -> bool {
193        *self == PIN4_A::HIGH
194    }
195}
196#[doc = "Field `PIN5` reader - Pin 5"]
197pub type PIN5_R = crate::BitReader<PIN5_A>;
198#[doc = "Pin 5\n\nValue on reset: 0"]
199#[derive(Clone, Copy, Debug, PartialEq)]
200pub enum PIN5_A {
201    #[doc = "0: Pin input is low"]
202    LOW = 0,
203    #[doc = "1: Pin input is high"]
204    HIGH = 1,
205}
206impl From<PIN5_A> for bool {
207    #[inline(always)]
208    fn from(variant: PIN5_A) -> Self {
209        variant as u8 != 0
210    }
211}
212impl PIN5_R {
213    #[doc = "Get enumerated values variant"]
214    #[inline(always)]
215    pub fn variant(&self) -> PIN5_A {
216        match self.bits {
217            false => PIN5_A::LOW,
218            true => PIN5_A::HIGH,
219        }
220    }
221    #[doc = "Checks if the value of the field is `LOW`"]
222    #[inline(always)]
223    pub fn is_low(&self) -> bool {
224        *self == PIN5_A::LOW
225    }
226    #[doc = "Checks if the value of the field is `HIGH`"]
227    #[inline(always)]
228    pub fn is_high(&self) -> bool {
229        *self == PIN5_A::HIGH
230    }
231}
232#[doc = "Field `PIN6` reader - Pin 6"]
233pub type PIN6_R = crate::BitReader<PIN6_A>;
234#[doc = "Pin 6\n\nValue on reset: 0"]
235#[derive(Clone, Copy, Debug, PartialEq)]
236pub enum PIN6_A {
237    #[doc = "0: Pin input is low"]
238    LOW = 0,
239    #[doc = "1: Pin input is high"]
240    HIGH = 1,
241}
242impl From<PIN6_A> for bool {
243    #[inline(always)]
244    fn from(variant: PIN6_A) -> Self {
245        variant as u8 != 0
246    }
247}
248impl PIN6_R {
249    #[doc = "Get enumerated values variant"]
250    #[inline(always)]
251    pub fn variant(&self) -> PIN6_A {
252        match self.bits {
253            false => PIN6_A::LOW,
254            true => PIN6_A::HIGH,
255        }
256    }
257    #[doc = "Checks if the value of the field is `LOW`"]
258    #[inline(always)]
259    pub fn is_low(&self) -> bool {
260        *self == PIN6_A::LOW
261    }
262    #[doc = "Checks if the value of the field is `HIGH`"]
263    #[inline(always)]
264    pub fn is_high(&self) -> bool {
265        *self == PIN6_A::HIGH
266    }
267}
268#[doc = "Field `PIN7` reader - Pin 7"]
269pub type PIN7_R = crate::BitReader<PIN7_A>;
270#[doc = "Pin 7\n\nValue on reset: 0"]
271#[derive(Clone, Copy, Debug, PartialEq)]
272pub enum PIN7_A {
273    #[doc = "0: Pin input is low"]
274    LOW = 0,
275    #[doc = "1: Pin input is high"]
276    HIGH = 1,
277}
278impl From<PIN7_A> for bool {
279    #[inline(always)]
280    fn from(variant: PIN7_A) -> Self {
281        variant as u8 != 0
282    }
283}
284impl PIN7_R {
285    #[doc = "Get enumerated values variant"]
286    #[inline(always)]
287    pub fn variant(&self) -> PIN7_A {
288        match self.bits {
289            false => PIN7_A::LOW,
290            true => PIN7_A::HIGH,
291        }
292    }
293    #[doc = "Checks if the value of the field is `LOW`"]
294    #[inline(always)]
295    pub fn is_low(&self) -> bool {
296        *self == PIN7_A::LOW
297    }
298    #[doc = "Checks if the value of the field is `HIGH`"]
299    #[inline(always)]
300    pub fn is_high(&self) -> bool {
301        *self == PIN7_A::HIGH
302    }
303}
304#[doc = "Field `PIN8` reader - Pin 8"]
305pub type PIN8_R = crate::BitReader<PIN8_A>;
306#[doc = "Pin 8\n\nValue on reset: 0"]
307#[derive(Clone, Copy, Debug, PartialEq)]
308pub enum PIN8_A {
309    #[doc = "0: Pin input is low"]
310    LOW = 0,
311    #[doc = "1: Pin input is high"]
312    HIGH = 1,
313}
314impl From<PIN8_A> for bool {
315    #[inline(always)]
316    fn from(variant: PIN8_A) -> Self {
317        variant as u8 != 0
318    }
319}
320impl PIN8_R {
321    #[doc = "Get enumerated values variant"]
322    #[inline(always)]
323    pub fn variant(&self) -> PIN8_A {
324        match self.bits {
325            false => PIN8_A::LOW,
326            true => PIN8_A::HIGH,
327        }
328    }
329    #[doc = "Checks if the value of the field is `LOW`"]
330    #[inline(always)]
331    pub fn is_low(&self) -> bool {
332        *self == PIN8_A::LOW
333    }
334    #[doc = "Checks if the value of the field is `HIGH`"]
335    #[inline(always)]
336    pub fn is_high(&self) -> bool {
337        *self == PIN8_A::HIGH
338    }
339}
340#[doc = "Field `PIN9` reader - Pin 9"]
341pub type PIN9_R = crate::BitReader<PIN9_A>;
342#[doc = "Pin 9\n\nValue on reset: 0"]
343#[derive(Clone, Copy, Debug, PartialEq)]
344pub enum PIN9_A {
345    #[doc = "0: Pin input is low"]
346    LOW = 0,
347    #[doc = "1: Pin input is high"]
348    HIGH = 1,
349}
350impl From<PIN9_A> for bool {
351    #[inline(always)]
352    fn from(variant: PIN9_A) -> Self {
353        variant as u8 != 0
354    }
355}
356impl PIN9_R {
357    #[doc = "Get enumerated values variant"]
358    #[inline(always)]
359    pub fn variant(&self) -> PIN9_A {
360        match self.bits {
361            false => PIN9_A::LOW,
362            true => PIN9_A::HIGH,
363        }
364    }
365    #[doc = "Checks if the value of the field is `LOW`"]
366    #[inline(always)]
367    pub fn is_low(&self) -> bool {
368        *self == PIN9_A::LOW
369    }
370    #[doc = "Checks if the value of the field is `HIGH`"]
371    #[inline(always)]
372    pub fn is_high(&self) -> bool {
373        *self == PIN9_A::HIGH
374    }
375}
376#[doc = "Field `PIN10` reader - Pin 10"]
377pub type PIN10_R = crate::BitReader<PIN10_A>;
378#[doc = "Pin 10\n\nValue on reset: 0"]
379#[derive(Clone, Copy, Debug, PartialEq)]
380pub enum PIN10_A {
381    #[doc = "0: Pin input is low"]
382    LOW = 0,
383    #[doc = "1: Pin input is high"]
384    HIGH = 1,
385}
386impl From<PIN10_A> for bool {
387    #[inline(always)]
388    fn from(variant: PIN10_A) -> Self {
389        variant as u8 != 0
390    }
391}
392impl PIN10_R {
393    #[doc = "Get enumerated values variant"]
394    #[inline(always)]
395    pub fn variant(&self) -> PIN10_A {
396        match self.bits {
397            false => PIN10_A::LOW,
398            true => PIN10_A::HIGH,
399        }
400    }
401    #[doc = "Checks if the value of the field is `LOW`"]
402    #[inline(always)]
403    pub fn is_low(&self) -> bool {
404        *self == PIN10_A::LOW
405    }
406    #[doc = "Checks if the value of the field is `HIGH`"]
407    #[inline(always)]
408    pub fn is_high(&self) -> bool {
409        *self == PIN10_A::HIGH
410    }
411}
412#[doc = "Field `PIN11` reader - Pin 11"]
413pub type PIN11_R = crate::BitReader<PIN11_A>;
414#[doc = "Pin 11\n\nValue on reset: 0"]
415#[derive(Clone, Copy, Debug, PartialEq)]
416pub enum PIN11_A {
417    #[doc = "0: Pin input is low"]
418    LOW = 0,
419    #[doc = "1: Pin input is high"]
420    HIGH = 1,
421}
422impl From<PIN11_A> for bool {
423    #[inline(always)]
424    fn from(variant: PIN11_A) -> Self {
425        variant as u8 != 0
426    }
427}
428impl PIN11_R {
429    #[doc = "Get enumerated values variant"]
430    #[inline(always)]
431    pub fn variant(&self) -> PIN11_A {
432        match self.bits {
433            false => PIN11_A::LOW,
434            true => PIN11_A::HIGH,
435        }
436    }
437    #[doc = "Checks if the value of the field is `LOW`"]
438    #[inline(always)]
439    pub fn is_low(&self) -> bool {
440        *self == PIN11_A::LOW
441    }
442    #[doc = "Checks if the value of the field is `HIGH`"]
443    #[inline(always)]
444    pub fn is_high(&self) -> bool {
445        *self == PIN11_A::HIGH
446    }
447}
448#[doc = "Field `PIN12` reader - Pin 12"]
449pub type PIN12_R = crate::BitReader<PIN12_A>;
450#[doc = "Pin 12\n\nValue on reset: 0"]
451#[derive(Clone, Copy, Debug, PartialEq)]
452pub enum PIN12_A {
453    #[doc = "0: Pin input is low"]
454    LOW = 0,
455    #[doc = "1: Pin input is high"]
456    HIGH = 1,
457}
458impl From<PIN12_A> for bool {
459    #[inline(always)]
460    fn from(variant: PIN12_A) -> Self {
461        variant as u8 != 0
462    }
463}
464impl PIN12_R {
465    #[doc = "Get enumerated values variant"]
466    #[inline(always)]
467    pub fn variant(&self) -> PIN12_A {
468        match self.bits {
469            false => PIN12_A::LOW,
470            true => PIN12_A::HIGH,
471        }
472    }
473    #[doc = "Checks if the value of the field is `LOW`"]
474    #[inline(always)]
475    pub fn is_low(&self) -> bool {
476        *self == PIN12_A::LOW
477    }
478    #[doc = "Checks if the value of the field is `HIGH`"]
479    #[inline(always)]
480    pub fn is_high(&self) -> bool {
481        *self == PIN12_A::HIGH
482    }
483}
484#[doc = "Field `PIN13` reader - Pin 13"]
485pub type PIN13_R = crate::BitReader<PIN13_A>;
486#[doc = "Pin 13\n\nValue on reset: 0"]
487#[derive(Clone, Copy, Debug, PartialEq)]
488pub enum PIN13_A {
489    #[doc = "0: Pin input is low"]
490    LOW = 0,
491    #[doc = "1: Pin input is high"]
492    HIGH = 1,
493}
494impl From<PIN13_A> for bool {
495    #[inline(always)]
496    fn from(variant: PIN13_A) -> Self {
497        variant as u8 != 0
498    }
499}
500impl PIN13_R {
501    #[doc = "Get enumerated values variant"]
502    #[inline(always)]
503    pub fn variant(&self) -> PIN13_A {
504        match self.bits {
505            false => PIN13_A::LOW,
506            true => PIN13_A::HIGH,
507        }
508    }
509    #[doc = "Checks if the value of the field is `LOW`"]
510    #[inline(always)]
511    pub fn is_low(&self) -> bool {
512        *self == PIN13_A::LOW
513    }
514    #[doc = "Checks if the value of the field is `HIGH`"]
515    #[inline(always)]
516    pub fn is_high(&self) -> bool {
517        *self == PIN13_A::HIGH
518    }
519}
520#[doc = "Field `PIN14` reader - Pin 14"]
521pub type PIN14_R = crate::BitReader<PIN14_A>;
522#[doc = "Pin 14\n\nValue on reset: 0"]
523#[derive(Clone, Copy, Debug, PartialEq)]
524pub enum PIN14_A {
525    #[doc = "0: Pin input is low"]
526    LOW = 0,
527    #[doc = "1: Pin input is high"]
528    HIGH = 1,
529}
530impl From<PIN14_A> for bool {
531    #[inline(always)]
532    fn from(variant: PIN14_A) -> Self {
533        variant as u8 != 0
534    }
535}
536impl PIN14_R {
537    #[doc = "Get enumerated values variant"]
538    #[inline(always)]
539    pub fn variant(&self) -> PIN14_A {
540        match self.bits {
541            false => PIN14_A::LOW,
542            true => PIN14_A::HIGH,
543        }
544    }
545    #[doc = "Checks if the value of the field is `LOW`"]
546    #[inline(always)]
547    pub fn is_low(&self) -> bool {
548        *self == PIN14_A::LOW
549    }
550    #[doc = "Checks if the value of the field is `HIGH`"]
551    #[inline(always)]
552    pub fn is_high(&self) -> bool {
553        *self == PIN14_A::HIGH
554    }
555}
556#[doc = "Field `PIN15` reader - Pin 15"]
557pub type PIN15_R = crate::BitReader<PIN15_A>;
558#[doc = "Pin 15\n\nValue on reset: 0"]
559#[derive(Clone, Copy, Debug, PartialEq)]
560pub enum PIN15_A {
561    #[doc = "0: Pin input is low"]
562    LOW = 0,
563    #[doc = "1: Pin input is high"]
564    HIGH = 1,
565}
566impl From<PIN15_A> for bool {
567    #[inline(always)]
568    fn from(variant: PIN15_A) -> Self {
569        variant as u8 != 0
570    }
571}
572impl PIN15_R {
573    #[doc = "Get enumerated values variant"]
574    #[inline(always)]
575    pub fn variant(&self) -> PIN15_A {
576        match self.bits {
577            false => PIN15_A::LOW,
578            true => PIN15_A::HIGH,
579        }
580    }
581    #[doc = "Checks if the value of the field is `LOW`"]
582    #[inline(always)]
583    pub fn is_low(&self) -> bool {
584        *self == PIN15_A::LOW
585    }
586    #[doc = "Checks if the value of the field is `HIGH`"]
587    #[inline(always)]
588    pub fn is_high(&self) -> bool {
589        *self == PIN15_A::HIGH
590    }
591}
592#[doc = "Field `PIN16` reader - Pin 16"]
593pub type PIN16_R = crate::BitReader<PIN16_A>;
594#[doc = "Pin 16\n\nValue on reset: 0"]
595#[derive(Clone, Copy, Debug, PartialEq)]
596pub enum PIN16_A {
597    #[doc = "0: Pin input is low"]
598    LOW = 0,
599    #[doc = "1: Pin input is high"]
600    HIGH = 1,
601}
602impl From<PIN16_A> for bool {
603    #[inline(always)]
604    fn from(variant: PIN16_A) -> Self {
605        variant as u8 != 0
606    }
607}
608impl PIN16_R {
609    #[doc = "Get enumerated values variant"]
610    #[inline(always)]
611    pub fn variant(&self) -> PIN16_A {
612        match self.bits {
613            false => PIN16_A::LOW,
614            true => PIN16_A::HIGH,
615        }
616    }
617    #[doc = "Checks if the value of the field is `LOW`"]
618    #[inline(always)]
619    pub fn is_low(&self) -> bool {
620        *self == PIN16_A::LOW
621    }
622    #[doc = "Checks if the value of the field is `HIGH`"]
623    #[inline(always)]
624    pub fn is_high(&self) -> bool {
625        *self == PIN16_A::HIGH
626    }
627}
628#[doc = "Field `PIN17` reader - Pin 17"]
629pub type PIN17_R = crate::BitReader<PIN17_A>;
630#[doc = "Pin 17\n\nValue on reset: 0"]
631#[derive(Clone, Copy, Debug, PartialEq)]
632pub enum PIN17_A {
633    #[doc = "0: Pin input is low"]
634    LOW = 0,
635    #[doc = "1: Pin input is high"]
636    HIGH = 1,
637}
638impl From<PIN17_A> for bool {
639    #[inline(always)]
640    fn from(variant: PIN17_A) -> Self {
641        variant as u8 != 0
642    }
643}
644impl PIN17_R {
645    #[doc = "Get enumerated values variant"]
646    #[inline(always)]
647    pub fn variant(&self) -> PIN17_A {
648        match self.bits {
649            false => PIN17_A::LOW,
650            true => PIN17_A::HIGH,
651        }
652    }
653    #[doc = "Checks if the value of the field is `LOW`"]
654    #[inline(always)]
655    pub fn is_low(&self) -> bool {
656        *self == PIN17_A::LOW
657    }
658    #[doc = "Checks if the value of the field is `HIGH`"]
659    #[inline(always)]
660    pub fn is_high(&self) -> bool {
661        *self == PIN17_A::HIGH
662    }
663}
664#[doc = "Field `PIN18` reader - Pin 18"]
665pub type PIN18_R = crate::BitReader<PIN18_A>;
666#[doc = "Pin 18\n\nValue on reset: 0"]
667#[derive(Clone, Copy, Debug, PartialEq)]
668pub enum PIN18_A {
669    #[doc = "0: Pin input is low"]
670    LOW = 0,
671    #[doc = "1: Pin input is high"]
672    HIGH = 1,
673}
674impl From<PIN18_A> for bool {
675    #[inline(always)]
676    fn from(variant: PIN18_A) -> Self {
677        variant as u8 != 0
678    }
679}
680impl PIN18_R {
681    #[doc = "Get enumerated values variant"]
682    #[inline(always)]
683    pub fn variant(&self) -> PIN18_A {
684        match self.bits {
685            false => PIN18_A::LOW,
686            true => PIN18_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 == PIN18_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 == PIN18_A::HIGH
698    }
699}
700#[doc = "Field `PIN19` reader - Pin 19"]
701pub type PIN19_R = crate::BitReader<PIN19_A>;
702#[doc = "Pin 19\n\nValue on reset: 0"]
703#[derive(Clone, Copy, Debug, PartialEq)]
704pub enum PIN19_A {
705    #[doc = "0: Pin input is low"]
706    LOW = 0,
707    #[doc = "1: Pin input is high"]
708    HIGH = 1,
709}
710impl From<PIN19_A> for bool {
711    #[inline(always)]
712    fn from(variant: PIN19_A) -> Self {
713        variant as u8 != 0
714    }
715}
716impl PIN19_R {
717    #[doc = "Get enumerated values variant"]
718    #[inline(always)]
719    pub fn variant(&self) -> PIN19_A {
720        match self.bits {
721            false => PIN19_A::LOW,
722            true => PIN19_A::HIGH,
723        }
724    }
725    #[doc = "Checks if the value of the field is `LOW`"]
726    #[inline(always)]
727    pub fn is_low(&self) -> bool {
728        *self == PIN19_A::LOW
729    }
730    #[doc = "Checks if the value of the field is `HIGH`"]
731    #[inline(always)]
732    pub fn is_high(&self) -> bool {
733        *self == PIN19_A::HIGH
734    }
735}
736#[doc = "Field `PIN20` reader - Pin 20"]
737pub type PIN20_R = crate::BitReader<PIN20_A>;
738#[doc = "Pin 20\n\nValue on reset: 0"]
739#[derive(Clone, Copy, Debug, PartialEq)]
740pub enum PIN20_A {
741    #[doc = "0: Pin input is low"]
742    LOW = 0,
743    #[doc = "1: Pin input is high"]
744    HIGH = 1,
745}
746impl From<PIN20_A> for bool {
747    #[inline(always)]
748    fn from(variant: PIN20_A) -> Self {
749        variant as u8 != 0
750    }
751}
752impl PIN20_R {
753    #[doc = "Get enumerated values variant"]
754    #[inline(always)]
755    pub fn variant(&self) -> PIN20_A {
756        match self.bits {
757            false => PIN20_A::LOW,
758            true => PIN20_A::HIGH,
759        }
760    }
761    #[doc = "Checks if the value of the field is `LOW`"]
762    #[inline(always)]
763    pub fn is_low(&self) -> bool {
764        *self == PIN20_A::LOW
765    }
766    #[doc = "Checks if the value of the field is `HIGH`"]
767    #[inline(always)]
768    pub fn is_high(&self) -> bool {
769        *self == PIN20_A::HIGH
770    }
771}
772#[doc = "Field `PIN21` reader - Pin 21"]
773pub type PIN21_R = crate::BitReader<PIN21_A>;
774#[doc = "Pin 21\n\nValue on reset: 0"]
775#[derive(Clone, Copy, Debug, PartialEq)]
776pub enum PIN21_A {
777    #[doc = "0: Pin input is low"]
778    LOW = 0,
779    #[doc = "1: Pin input is high"]
780    HIGH = 1,
781}
782impl From<PIN21_A> for bool {
783    #[inline(always)]
784    fn from(variant: PIN21_A) -> Self {
785        variant as u8 != 0
786    }
787}
788impl PIN21_R {
789    #[doc = "Get enumerated values variant"]
790    #[inline(always)]
791    pub fn variant(&self) -> PIN21_A {
792        match self.bits {
793            false => PIN21_A::LOW,
794            true => PIN21_A::HIGH,
795        }
796    }
797    #[doc = "Checks if the value of the field is `LOW`"]
798    #[inline(always)]
799    pub fn is_low(&self) -> bool {
800        *self == PIN21_A::LOW
801    }
802    #[doc = "Checks if the value of the field is `HIGH`"]
803    #[inline(always)]
804    pub fn is_high(&self) -> bool {
805        *self == PIN21_A::HIGH
806    }
807}
808#[doc = "Field `PIN22` reader - Pin 22"]
809pub type PIN22_R = crate::BitReader<PIN22_A>;
810#[doc = "Pin 22\n\nValue on reset: 0"]
811#[derive(Clone, Copy, Debug, PartialEq)]
812pub enum PIN22_A {
813    #[doc = "0: Pin input is low"]
814    LOW = 0,
815    #[doc = "1: Pin input is high"]
816    HIGH = 1,
817}
818impl From<PIN22_A> for bool {
819    #[inline(always)]
820    fn from(variant: PIN22_A) -> Self {
821        variant as u8 != 0
822    }
823}
824impl PIN22_R {
825    #[doc = "Get enumerated values variant"]
826    #[inline(always)]
827    pub fn variant(&self) -> PIN22_A {
828        match self.bits {
829            false => PIN22_A::LOW,
830            true => PIN22_A::HIGH,
831        }
832    }
833    #[doc = "Checks if the value of the field is `LOW`"]
834    #[inline(always)]
835    pub fn is_low(&self) -> bool {
836        *self == PIN22_A::LOW
837    }
838    #[doc = "Checks if the value of the field is `HIGH`"]
839    #[inline(always)]
840    pub fn is_high(&self) -> bool {
841        *self == PIN22_A::HIGH
842    }
843}
844#[doc = "Field `PIN23` reader - Pin 23"]
845pub type PIN23_R = crate::BitReader<PIN23_A>;
846#[doc = "Pin 23\n\nValue on reset: 0"]
847#[derive(Clone, Copy, Debug, PartialEq)]
848pub enum PIN23_A {
849    #[doc = "0: Pin input is low"]
850    LOW = 0,
851    #[doc = "1: Pin input is high"]
852    HIGH = 1,
853}
854impl From<PIN23_A> for bool {
855    #[inline(always)]
856    fn from(variant: PIN23_A) -> Self {
857        variant as u8 != 0
858    }
859}
860impl PIN23_R {
861    #[doc = "Get enumerated values variant"]
862    #[inline(always)]
863    pub fn variant(&self) -> PIN23_A {
864        match self.bits {
865            false => PIN23_A::LOW,
866            true => PIN23_A::HIGH,
867        }
868    }
869    #[doc = "Checks if the value of the field is `LOW`"]
870    #[inline(always)]
871    pub fn is_low(&self) -> bool {
872        *self == PIN23_A::LOW
873    }
874    #[doc = "Checks if the value of the field is `HIGH`"]
875    #[inline(always)]
876    pub fn is_high(&self) -> bool {
877        *self == PIN23_A::HIGH
878    }
879}
880#[doc = "Field `PIN24` reader - Pin 24"]
881pub type PIN24_R = crate::BitReader<PIN24_A>;
882#[doc = "Pin 24\n\nValue on reset: 0"]
883#[derive(Clone, Copy, Debug, PartialEq)]
884pub enum PIN24_A {
885    #[doc = "0: Pin input is low"]
886    LOW = 0,
887    #[doc = "1: Pin input is high"]
888    HIGH = 1,
889}
890impl From<PIN24_A> for bool {
891    #[inline(always)]
892    fn from(variant: PIN24_A) -> Self {
893        variant as u8 != 0
894    }
895}
896impl PIN24_R {
897    #[doc = "Get enumerated values variant"]
898    #[inline(always)]
899    pub fn variant(&self) -> PIN24_A {
900        match self.bits {
901            false => PIN24_A::LOW,
902            true => PIN24_A::HIGH,
903        }
904    }
905    #[doc = "Checks if the value of the field is `LOW`"]
906    #[inline(always)]
907    pub fn is_low(&self) -> bool {
908        *self == PIN24_A::LOW
909    }
910    #[doc = "Checks if the value of the field is `HIGH`"]
911    #[inline(always)]
912    pub fn is_high(&self) -> bool {
913        *self == PIN24_A::HIGH
914    }
915}
916#[doc = "Field `PIN25` reader - Pin 25"]
917pub type PIN25_R = crate::BitReader<PIN25_A>;
918#[doc = "Pin 25\n\nValue on reset: 0"]
919#[derive(Clone, Copy, Debug, PartialEq)]
920pub enum PIN25_A {
921    #[doc = "0: Pin input is low"]
922    LOW = 0,
923    #[doc = "1: Pin input is high"]
924    HIGH = 1,
925}
926impl From<PIN25_A> for bool {
927    #[inline(always)]
928    fn from(variant: PIN25_A) -> Self {
929        variant as u8 != 0
930    }
931}
932impl PIN25_R {
933    #[doc = "Get enumerated values variant"]
934    #[inline(always)]
935    pub fn variant(&self) -> PIN25_A {
936        match self.bits {
937            false => PIN25_A::LOW,
938            true => PIN25_A::HIGH,
939        }
940    }
941    #[doc = "Checks if the value of the field is `LOW`"]
942    #[inline(always)]
943    pub fn is_low(&self) -> bool {
944        *self == PIN25_A::LOW
945    }
946    #[doc = "Checks if the value of the field is `HIGH`"]
947    #[inline(always)]
948    pub fn is_high(&self) -> bool {
949        *self == PIN25_A::HIGH
950    }
951}
952#[doc = "Field `PIN26` reader - Pin 26"]
953pub type PIN26_R = crate::BitReader<PIN26_A>;
954#[doc = "Pin 26\n\nValue on reset: 0"]
955#[derive(Clone, Copy, Debug, PartialEq)]
956pub enum PIN26_A {
957    #[doc = "0: Pin input is low"]
958    LOW = 0,
959    #[doc = "1: Pin input is high"]
960    HIGH = 1,
961}
962impl From<PIN26_A> for bool {
963    #[inline(always)]
964    fn from(variant: PIN26_A) -> Self {
965        variant as u8 != 0
966    }
967}
968impl PIN26_R {
969    #[doc = "Get enumerated values variant"]
970    #[inline(always)]
971    pub fn variant(&self) -> PIN26_A {
972        match self.bits {
973            false => PIN26_A::LOW,
974            true => PIN26_A::HIGH,
975        }
976    }
977    #[doc = "Checks if the value of the field is `LOW`"]
978    #[inline(always)]
979    pub fn is_low(&self) -> bool {
980        *self == PIN26_A::LOW
981    }
982    #[doc = "Checks if the value of the field is `HIGH`"]
983    #[inline(always)]
984    pub fn is_high(&self) -> bool {
985        *self == PIN26_A::HIGH
986    }
987}
988#[doc = "Field `PIN27` reader - Pin 27"]
989pub type PIN27_R = crate::BitReader<PIN27_A>;
990#[doc = "Pin 27\n\nValue on reset: 0"]
991#[derive(Clone, Copy, Debug, PartialEq)]
992pub enum PIN27_A {
993    #[doc = "0: Pin input is low"]
994    LOW = 0,
995    #[doc = "1: Pin input is high"]
996    HIGH = 1,
997}
998impl From<PIN27_A> for bool {
999    #[inline(always)]
1000    fn from(variant: PIN27_A) -> Self {
1001        variant as u8 != 0
1002    }
1003}
1004impl PIN27_R {
1005    #[doc = "Get enumerated values variant"]
1006    #[inline(always)]
1007    pub fn variant(&self) -> PIN27_A {
1008        match self.bits {
1009            false => PIN27_A::LOW,
1010            true => PIN27_A::HIGH,
1011        }
1012    }
1013    #[doc = "Checks if the value of the field is `LOW`"]
1014    #[inline(always)]
1015    pub fn is_low(&self) -> bool {
1016        *self == PIN27_A::LOW
1017    }
1018    #[doc = "Checks if the value of the field is `HIGH`"]
1019    #[inline(always)]
1020    pub fn is_high(&self) -> bool {
1021        *self == PIN27_A::HIGH
1022    }
1023}
1024#[doc = "Field `PIN28` reader - Pin 28"]
1025pub type PIN28_R = crate::BitReader<PIN28_A>;
1026#[doc = "Pin 28\n\nValue on reset: 0"]
1027#[derive(Clone, Copy, Debug, PartialEq)]
1028pub enum PIN28_A {
1029    #[doc = "0: Pin input is low"]
1030    LOW = 0,
1031    #[doc = "1: Pin input is high"]
1032    HIGH = 1,
1033}
1034impl From<PIN28_A> for bool {
1035    #[inline(always)]
1036    fn from(variant: PIN28_A) -> Self {
1037        variant as u8 != 0
1038    }
1039}
1040impl PIN28_R {
1041    #[doc = "Get enumerated values variant"]
1042    #[inline(always)]
1043    pub fn variant(&self) -> PIN28_A {
1044        match self.bits {
1045            false => PIN28_A::LOW,
1046            true => PIN28_A::HIGH,
1047        }
1048    }
1049    #[doc = "Checks if the value of the field is `LOW`"]
1050    #[inline(always)]
1051    pub fn is_low(&self) -> bool {
1052        *self == PIN28_A::LOW
1053    }
1054    #[doc = "Checks if the value of the field is `HIGH`"]
1055    #[inline(always)]
1056    pub fn is_high(&self) -> bool {
1057        *self == PIN28_A::HIGH
1058    }
1059}
1060#[doc = "Field `PIN29` reader - Pin 29"]
1061pub type PIN29_R = crate::BitReader<PIN29_A>;
1062#[doc = "Pin 29\n\nValue on reset: 0"]
1063#[derive(Clone, Copy, Debug, PartialEq)]
1064pub enum PIN29_A {
1065    #[doc = "0: Pin input is low"]
1066    LOW = 0,
1067    #[doc = "1: Pin input is high"]
1068    HIGH = 1,
1069}
1070impl From<PIN29_A> for bool {
1071    #[inline(always)]
1072    fn from(variant: PIN29_A) -> Self {
1073        variant as u8 != 0
1074    }
1075}
1076impl PIN29_R {
1077    #[doc = "Get enumerated values variant"]
1078    #[inline(always)]
1079    pub fn variant(&self) -> PIN29_A {
1080        match self.bits {
1081            false => PIN29_A::LOW,
1082            true => PIN29_A::HIGH,
1083        }
1084    }
1085    #[doc = "Checks if the value of the field is `LOW`"]
1086    #[inline(always)]
1087    pub fn is_low(&self) -> bool {
1088        *self == PIN29_A::LOW
1089    }
1090    #[doc = "Checks if the value of the field is `HIGH`"]
1091    #[inline(always)]
1092    pub fn is_high(&self) -> bool {
1093        *self == PIN29_A::HIGH
1094    }
1095}
1096#[doc = "Field `PIN30` reader - Pin 30"]
1097pub type PIN30_R = crate::BitReader<PIN30_A>;
1098#[doc = "Pin 30\n\nValue on reset: 0"]
1099#[derive(Clone, Copy, Debug, PartialEq)]
1100pub enum PIN30_A {
1101    #[doc = "0: Pin input is low"]
1102    LOW = 0,
1103    #[doc = "1: Pin input is high"]
1104    HIGH = 1,
1105}
1106impl From<PIN30_A> for bool {
1107    #[inline(always)]
1108    fn from(variant: PIN30_A) -> Self {
1109        variant as u8 != 0
1110    }
1111}
1112impl PIN30_R {
1113    #[doc = "Get enumerated values variant"]
1114    #[inline(always)]
1115    pub fn variant(&self) -> PIN30_A {
1116        match self.bits {
1117            false => PIN30_A::LOW,
1118            true => PIN30_A::HIGH,
1119        }
1120    }
1121    #[doc = "Checks if the value of the field is `LOW`"]
1122    #[inline(always)]
1123    pub fn is_low(&self) -> bool {
1124        *self == PIN30_A::LOW
1125    }
1126    #[doc = "Checks if the value of the field is `HIGH`"]
1127    #[inline(always)]
1128    pub fn is_high(&self) -> bool {
1129        *self == PIN30_A::HIGH
1130    }
1131}
1132#[doc = "Field `PIN31` reader - Pin 31"]
1133pub type PIN31_R = crate::BitReader<PIN31_A>;
1134#[doc = "Pin 31\n\nValue on reset: 0"]
1135#[derive(Clone, Copy, Debug, PartialEq)]
1136pub enum PIN31_A {
1137    #[doc = "0: Pin input is low"]
1138    LOW = 0,
1139    #[doc = "1: Pin input is high"]
1140    HIGH = 1,
1141}
1142impl From<PIN31_A> for bool {
1143    #[inline(always)]
1144    fn from(variant: PIN31_A) -> Self {
1145        variant as u8 != 0
1146    }
1147}
1148impl PIN31_R {
1149    #[doc = "Get enumerated values variant"]
1150    #[inline(always)]
1151    pub fn variant(&self) -> PIN31_A {
1152        match self.bits {
1153            false => PIN31_A::LOW,
1154            true => PIN31_A::HIGH,
1155        }
1156    }
1157    #[doc = "Checks if the value of the field is `LOW`"]
1158    #[inline(always)]
1159    pub fn is_low(&self) -> bool {
1160        *self == PIN31_A::LOW
1161    }
1162    #[doc = "Checks if the value of the field is `HIGH`"]
1163    #[inline(always)]
1164    pub fn is_high(&self) -> bool {
1165        *self == PIN31_A::HIGH
1166    }
1167}
1168impl R {
1169    #[doc = "Bit 0 - Pin 0"]
1170    #[inline(always)]
1171    pub fn pin0(&self) -> PIN0_R {
1172        PIN0_R::new((self.bits & 1) != 0)
1173    }
1174    #[doc = "Bit 1 - Pin 1"]
1175    #[inline(always)]
1176    pub fn pin1(&self) -> PIN1_R {
1177        PIN1_R::new(((self.bits >> 1) & 1) != 0)
1178    }
1179    #[doc = "Bit 2 - Pin 2"]
1180    #[inline(always)]
1181    pub fn pin2(&self) -> PIN2_R {
1182        PIN2_R::new(((self.bits >> 2) & 1) != 0)
1183    }
1184    #[doc = "Bit 3 - Pin 3"]
1185    #[inline(always)]
1186    pub fn pin3(&self) -> PIN3_R {
1187        PIN3_R::new(((self.bits >> 3) & 1) != 0)
1188    }
1189    #[doc = "Bit 4 - Pin 4"]
1190    #[inline(always)]
1191    pub fn pin4(&self) -> PIN4_R {
1192        PIN4_R::new(((self.bits >> 4) & 1) != 0)
1193    }
1194    #[doc = "Bit 5 - Pin 5"]
1195    #[inline(always)]
1196    pub fn pin5(&self) -> PIN5_R {
1197        PIN5_R::new(((self.bits >> 5) & 1) != 0)
1198    }
1199    #[doc = "Bit 6 - Pin 6"]
1200    #[inline(always)]
1201    pub fn pin6(&self) -> PIN6_R {
1202        PIN6_R::new(((self.bits >> 6) & 1) != 0)
1203    }
1204    #[doc = "Bit 7 - Pin 7"]
1205    #[inline(always)]
1206    pub fn pin7(&self) -> PIN7_R {
1207        PIN7_R::new(((self.bits >> 7) & 1) != 0)
1208    }
1209    #[doc = "Bit 8 - Pin 8"]
1210    #[inline(always)]
1211    pub fn pin8(&self) -> PIN8_R {
1212        PIN8_R::new(((self.bits >> 8) & 1) != 0)
1213    }
1214    #[doc = "Bit 9 - Pin 9"]
1215    #[inline(always)]
1216    pub fn pin9(&self) -> PIN9_R {
1217        PIN9_R::new(((self.bits >> 9) & 1) != 0)
1218    }
1219    #[doc = "Bit 10 - Pin 10"]
1220    #[inline(always)]
1221    pub fn pin10(&self) -> PIN10_R {
1222        PIN10_R::new(((self.bits >> 10) & 1) != 0)
1223    }
1224    #[doc = "Bit 11 - Pin 11"]
1225    #[inline(always)]
1226    pub fn pin11(&self) -> PIN11_R {
1227        PIN11_R::new(((self.bits >> 11) & 1) != 0)
1228    }
1229    #[doc = "Bit 12 - Pin 12"]
1230    #[inline(always)]
1231    pub fn pin12(&self) -> PIN12_R {
1232        PIN12_R::new(((self.bits >> 12) & 1) != 0)
1233    }
1234    #[doc = "Bit 13 - Pin 13"]
1235    #[inline(always)]
1236    pub fn pin13(&self) -> PIN13_R {
1237        PIN13_R::new(((self.bits >> 13) & 1) != 0)
1238    }
1239    #[doc = "Bit 14 - Pin 14"]
1240    #[inline(always)]
1241    pub fn pin14(&self) -> PIN14_R {
1242        PIN14_R::new(((self.bits >> 14) & 1) != 0)
1243    }
1244    #[doc = "Bit 15 - Pin 15"]
1245    #[inline(always)]
1246    pub fn pin15(&self) -> PIN15_R {
1247        PIN15_R::new(((self.bits >> 15) & 1) != 0)
1248    }
1249    #[doc = "Bit 16 - Pin 16"]
1250    #[inline(always)]
1251    pub fn pin16(&self) -> PIN16_R {
1252        PIN16_R::new(((self.bits >> 16) & 1) != 0)
1253    }
1254    #[doc = "Bit 17 - Pin 17"]
1255    #[inline(always)]
1256    pub fn pin17(&self) -> PIN17_R {
1257        PIN17_R::new(((self.bits >> 17) & 1) != 0)
1258    }
1259    #[doc = "Bit 18 - Pin 18"]
1260    #[inline(always)]
1261    pub fn pin18(&self) -> PIN18_R {
1262        PIN18_R::new(((self.bits >> 18) & 1) != 0)
1263    }
1264    #[doc = "Bit 19 - Pin 19"]
1265    #[inline(always)]
1266    pub fn pin19(&self) -> PIN19_R {
1267        PIN19_R::new(((self.bits >> 19) & 1) != 0)
1268    }
1269    #[doc = "Bit 20 - Pin 20"]
1270    #[inline(always)]
1271    pub fn pin20(&self) -> PIN20_R {
1272        PIN20_R::new(((self.bits >> 20) & 1) != 0)
1273    }
1274    #[doc = "Bit 21 - Pin 21"]
1275    #[inline(always)]
1276    pub fn pin21(&self) -> PIN21_R {
1277        PIN21_R::new(((self.bits >> 21) & 1) != 0)
1278    }
1279    #[doc = "Bit 22 - Pin 22"]
1280    #[inline(always)]
1281    pub fn pin22(&self) -> PIN22_R {
1282        PIN22_R::new(((self.bits >> 22) & 1) != 0)
1283    }
1284    #[doc = "Bit 23 - Pin 23"]
1285    #[inline(always)]
1286    pub fn pin23(&self) -> PIN23_R {
1287        PIN23_R::new(((self.bits >> 23) & 1) != 0)
1288    }
1289    #[doc = "Bit 24 - Pin 24"]
1290    #[inline(always)]
1291    pub fn pin24(&self) -> PIN24_R {
1292        PIN24_R::new(((self.bits >> 24) & 1) != 0)
1293    }
1294    #[doc = "Bit 25 - Pin 25"]
1295    #[inline(always)]
1296    pub fn pin25(&self) -> PIN25_R {
1297        PIN25_R::new(((self.bits >> 25) & 1) != 0)
1298    }
1299    #[doc = "Bit 26 - Pin 26"]
1300    #[inline(always)]
1301    pub fn pin26(&self) -> PIN26_R {
1302        PIN26_R::new(((self.bits >> 26) & 1) != 0)
1303    }
1304    #[doc = "Bit 27 - Pin 27"]
1305    #[inline(always)]
1306    pub fn pin27(&self) -> PIN27_R {
1307        PIN27_R::new(((self.bits >> 27) & 1) != 0)
1308    }
1309    #[doc = "Bit 28 - Pin 28"]
1310    #[inline(always)]
1311    pub fn pin28(&self) -> PIN28_R {
1312        PIN28_R::new(((self.bits >> 28) & 1) != 0)
1313    }
1314    #[doc = "Bit 29 - Pin 29"]
1315    #[inline(always)]
1316    pub fn pin29(&self) -> PIN29_R {
1317        PIN29_R::new(((self.bits >> 29) & 1) != 0)
1318    }
1319    #[doc = "Bit 30 - Pin 30"]
1320    #[inline(always)]
1321    pub fn pin30(&self) -> PIN30_R {
1322        PIN30_R::new(((self.bits >> 30) & 1) != 0)
1323    }
1324    #[doc = "Bit 31 - Pin 31"]
1325    #[inline(always)]
1326    pub fn pin31(&self) -> PIN31_R {
1327        PIN31_R::new(((self.bits >> 31) & 1) != 0)
1328    }
1329}
1330#[doc = "Read GPIO port\n\nThis register you can [`read`](crate::generic::Reg::read). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [in_](index.html) module"]
1331pub struct IN_SPEC;
1332impl crate::RegisterSpec for IN_SPEC {
1333    type Ux = u32;
1334}
1335#[doc = "`read()` method returns [in_::R](R) reader structure"]
1336impl crate::Readable for IN_SPEC {
1337    type Reader = R;
1338}
1339#[doc = "`reset()` method sets IN to value 0"]
1340impl crate::Resettable for IN_SPEC {
1341    #[inline(always)]
1342    fn reset_value() -> Self::Ux {
1343        0
1344    }
1345}
nrf52840_pac/p0/in_.rs

nrf52840_pac/p0/
in_.rs
