efm32pg12_pac/gpio/
extipinsell.rs

1#[doc = "Reader of register EXTIPINSELL"]
2pub type R = crate::R<u32, super::EXTIPINSELL>;
3#[doc = "Writer for register EXTIPINSELL"]
4pub type W = crate::W<u32, super::EXTIPINSELL>;
5#[doc = "Register EXTIPINSELL `reset()`'s with value 0x3210_3210"]
6impl crate::ResetValue for super::EXTIPINSELL {
7    type Type = u32;
8    #[inline(always)]
9    fn reset_value() -> Self::Type {
10        0x3210_3210
11    }
12}
13#[doc = "External Interrupt 0 Pin Select\n\nValue on reset: 0"]
14#[derive(Clone, Copy, Debug, PartialEq)]
15#[repr(u8)]
16pub enum EXTIPINSEL0_A {
17    #[doc = "0: Pin 0"]
18    PIN0 = 0,
19    #[doc = "1: Pin 1"]
20    PIN1 = 1,
21    #[doc = "2: Pin 2"]
22    PIN2 = 2,
23    #[doc = "3: Pin 3"]
24    PIN3 = 3,
25}
26impl From<EXTIPINSEL0_A> for u8 {
27    #[inline(always)]
28    fn from(variant: EXTIPINSEL0_A) -> Self {
29        variant as _
30    }
31}
32#[doc = "Reader of field `EXTIPINSEL0`"]
33pub type EXTIPINSEL0_R = crate::R<u8, EXTIPINSEL0_A>;
34impl EXTIPINSEL0_R {
35    #[doc = r"Get enumerated values variant"]
36    #[inline(always)]
37    pub fn variant(&self) -> EXTIPINSEL0_A {
38        match self.bits {
39            0 => EXTIPINSEL0_A::PIN0,
40            1 => EXTIPINSEL0_A::PIN1,
41            2 => EXTIPINSEL0_A::PIN2,
42            3 => EXTIPINSEL0_A::PIN3,
43            _ => unreachable!(),
44        }
45    }
46    #[doc = "Checks if the value of the field is `PIN0`"]
47    #[inline(always)]
48    pub fn is_pin0(&self) -> bool {
49        *self == EXTIPINSEL0_A::PIN0
50    }
51    #[doc = "Checks if the value of the field is `PIN1`"]
52    #[inline(always)]
53    pub fn is_pin1(&self) -> bool {
54        *self == EXTIPINSEL0_A::PIN1
55    }
56    #[doc = "Checks if the value of the field is `PIN2`"]
57    #[inline(always)]
58    pub fn is_pin2(&self) -> bool {
59        *self == EXTIPINSEL0_A::PIN2
60    }
61    #[doc = "Checks if the value of the field is `PIN3`"]
62    #[inline(always)]
63    pub fn is_pin3(&self) -> bool {
64        *self == EXTIPINSEL0_A::PIN3
65    }
66}
67#[doc = "Write proxy for field `EXTIPINSEL0`"]
68pub struct EXTIPINSEL0_W<'a> {
69    w: &'a mut W,
70}
71impl<'a> EXTIPINSEL0_W<'a> {
72    #[doc = r"Writes `variant` to the field"]
73    #[inline(always)]
74    pub fn variant(self, variant: EXTIPINSEL0_A) -> &'a mut W {
75        {
76            self.bits(variant.into())
77        }
78    }
79    #[doc = "Pin 0"]
80    #[inline(always)]
81    pub fn pin0(self) -> &'a mut W {
82        self.variant(EXTIPINSEL0_A::PIN0)
83    }
84    #[doc = "Pin 1"]
85    #[inline(always)]
86    pub fn pin1(self) -> &'a mut W {
87        self.variant(EXTIPINSEL0_A::PIN1)
88    }
89    #[doc = "Pin 2"]
90    #[inline(always)]
91    pub fn pin2(self) -> &'a mut W {
92        self.variant(EXTIPINSEL0_A::PIN2)
93    }
94    #[doc = "Pin 3"]
95    #[inline(always)]
96    pub fn pin3(self) -> &'a mut W {
97        self.variant(EXTIPINSEL0_A::PIN3)
98    }
99    #[doc = r"Writes raw bits to the field"]
100    #[inline(always)]
101    pub fn bits(self, value: u8) -> &'a mut W {
102        self.w.bits = (self.w.bits & !0x03) | ((value as u32) & 0x03);
103        self.w
104    }
105}
106#[doc = "External Interrupt 1 Pin Select\n\nValue on reset: 1"]
107#[derive(Clone, Copy, Debug, PartialEq)]
108#[repr(u8)]
109pub enum EXTIPINSEL1_A {
110    #[doc = "0: Pin 0"]
111    PIN0 = 0,
112    #[doc = "1: Pin 1"]
113    PIN1 = 1,
114    #[doc = "2: Pin 2"]
115    PIN2 = 2,
116    #[doc = "3: Pin 3"]
117    PIN3 = 3,
118}
119impl From<EXTIPINSEL1_A> for u8 {
120    #[inline(always)]
121    fn from(variant: EXTIPINSEL1_A) -> Self {
122        variant as _
123    }
124}
125#[doc = "Reader of field `EXTIPINSEL1`"]
126pub type EXTIPINSEL1_R = crate::R<u8, EXTIPINSEL1_A>;
127impl EXTIPINSEL1_R {
128    #[doc = r"Get enumerated values variant"]
129    #[inline(always)]
130    pub fn variant(&self) -> EXTIPINSEL1_A {
131        match self.bits {
132            0 => EXTIPINSEL1_A::PIN0,
133            1 => EXTIPINSEL1_A::PIN1,
134            2 => EXTIPINSEL1_A::PIN2,
135            3 => EXTIPINSEL1_A::PIN3,
136            _ => unreachable!(),
137        }
138    }
139    #[doc = "Checks if the value of the field is `PIN0`"]
140    #[inline(always)]
141    pub fn is_pin0(&self) -> bool {
142        *self == EXTIPINSEL1_A::PIN0
143    }
144    #[doc = "Checks if the value of the field is `PIN1`"]
145    #[inline(always)]
146    pub fn is_pin1(&self) -> bool {
147        *self == EXTIPINSEL1_A::PIN1
148    }
149    #[doc = "Checks if the value of the field is `PIN2`"]
150    #[inline(always)]
151    pub fn is_pin2(&self) -> bool {
152        *self == EXTIPINSEL1_A::PIN2
153    }
154    #[doc = "Checks if the value of the field is `PIN3`"]
155    #[inline(always)]
156    pub fn is_pin3(&self) -> bool {
157        *self == EXTIPINSEL1_A::PIN3
158    }
159}
160#[doc = "Write proxy for field `EXTIPINSEL1`"]
161pub struct EXTIPINSEL1_W<'a> {
162    w: &'a mut W,
163}
164impl<'a> EXTIPINSEL1_W<'a> {
165    #[doc = r"Writes `variant` to the field"]
166    #[inline(always)]
167    pub fn variant(self, variant: EXTIPINSEL1_A) -> &'a mut W {
168        {
169            self.bits(variant.into())
170        }
171    }
172    #[doc = "Pin 0"]
173    #[inline(always)]
174    pub fn pin0(self) -> &'a mut W {
175        self.variant(EXTIPINSEL1_A::PIN0)
176    }
177    #[doc = "Pin 1"]
178    #[inline(always)]
179    pub fn pin1(self) -> &'a mut W {
180        self.variant(EXTIPINSEL1_A::PIN1)
181    }
182    #[doc = "Pin 2"]
183    #[inline(always)]
184    pub fn pin2(self) -> &'a mut W {
185        self.variant(EXTIPINSEL1_A::PIN2)
186    }
187    #[doc = "Pin 3"]
188    #[inline(always)]
189    pub fn pin3(self) -> &'a mut W {
190        self.variant(EXTIPINSEL1_A::PIN3)
191    }
192    #[doc = r"Writes raw bits to the field"]
193    #[inline(always)]
194    pub fn bits(self, value: u8) -> &'a mut W {
195        self.w.bits = (self.w.bits & !(0x03 << 4)) | (((value as u32) & 0x03) << 4);
196        self.w
197    }
198}
199#[doc = "External Interrupt 2 Pin Select\n\nValue on reset: 2"]
200#[derive(Clone, Copy, Debug, PartialEq)]
201#[repr(u8)]
202pub enum EXTIPINSEL2_A {
203    #[doc = "0: Pin 0"]
204    PIN0 = 0,
205    #[doc = "1: Pin 1"]
206    PIN1 = 1,
207    #[doc = "2: Pin 2"]
208    PIN2 = 2,
209    #[doc = "3: Pin 3"]
210    PIN3 = 3,
211}
212impl From<EXTIPINSEL2_A> for u8 {
213    #[inline(always)]
214    fn from(variant: EXTIPINSEL2_A) -> Self {
215        variant as _
216    }
217}
218#[doc = "Reader of field `EXTIPINSEL2`"]
219pub type EXTIPINSEL2_R = crate::R<u8, EXTIPINSEL2_A>;
220impl EXTIPINSEL2_R {
221    #[doc = r"Get enumerated values variant"]
222    #[inline(always)]
223    pub fn variant(&self) -> EXTIPINSEL2_A {
224        match self.bits {
225            0 => EXTIPINSEL2_A::PIN0,
226            1 => EXTIPINSEL2_A::PIN1,
227            2 => EXTIPINSEL2_A::PIN2,
228            3 => EXTIPINSEL2_A::PIN3,
229            _ => unreachable!(),
230        }
231    }
232    #[doc = "Checks if the value of the field is `PIN0`"]
233    #[inline(always)]
234    pub fn is_pin0(&self) -> bool {
235        *self == EXTIPINSEL2_A::PIN0
236    }
237    #[doc = "Checks if the value of the field is `PIN1`"]
238    #[inline(always)]
239    pub fn is_pin1(&self) -> bool {
240        *self == EXTIPINSEL2_A::PIN1
241    }
242    #[doc = "Checks if the value of the field is `PIN2`"]
243    #[inline(always)]
244    pub fn is_pin2(&self) -> bool {
245        *self == EXTIPINSEL2_A::PIN2
246    }
247    #[doc = "Checks if the value of the field is `PIN3`"]
248    #[inline(always)]
249    pub fn is_pin3(&self) -> bool {
250        *self == EXTIPINSEL2_A::PIN3
251    }
252}
253#[doc = "Write proxy for field `EXTIPINSEL2`"]
254pub struct EXTIPINSEL2_W<'a> {
255    w: &'a mut W,
256}
257impl<'a> EXTIPINSEL2_W<'a> {
258    #[doc = r"Writes `variant` to the field"]
259    #[inline(always)]
260    pub fn variant(self, variant: EXTIPINSEL2_A) -> &'a mut W {
261        {
262            self.bits(variant.into())
263        }
264    }
265    #[doc = "Pin 0"]
266    #[inline(always)]
267    pub fn pin0(self) -> &'a mut W {
268        self.variant(EXTIPINSEL2_A::PIN0)
269    }
270    #[doc = "Pin 1"]
271    #[inline(always)]
272    pub fn pin1(self) -> &'a mut W {
273        self.variant(EXTIPINSEL2_A::PIN1)
274    }
275    #[doc = "Pin 2"]
276    #[inline(always)]
277    pub fn pin2(self) -> &'a mut W {
278        self.variant(EXTIPINSEL2_A::PIN2)
279    }
280    #[doc = "Pin 3"]
281    #[inline(always)]
282    pub fn pin3(self) -> &'a mut W {
283        self.variant(EXTIPINSEL2_A::PIN3)
284    }
285    #[doc = r"Writes raw bits to the field"]
286    #[inline(always)]
287    pub fn bits(self, value: u8) -> &'a mut W {
288        self.w.bits = (self.w.bits & !(0x03 << 8)) | (((value as u32) & 0x03) << 8);
289        self.w
290    }
291}
292#[doc = "External Interrupt 3 Pin Select\n\nValue on reset: 3"]
293#[derive(Clone, Copy, Debug, PartialEq)]
294#[repr(u8)]
295pub enum EXTIPINSEL3_A {
296    #[doc = "0: Pin 0"]
297    PIN0 = 0,
298    #[doc = "1: Pin 1"]
299    PIN1 = 1,
300    #[doc = "2: Pin 2"]
301    PIN2 = 2,
302    #[doc = "3: Pin 3"]
303    PIN3 = 3,
304}
305impl From<EXTIPINSEL3_A> for u8 {
306    #[inline(always)]
307    fn from(variant: EXTIPINSEL3_A) -> Self {
308        variant as _
309    }
310}
311#[doc = "Reader of field `EXTIPINSEL3`"]
312pub type EXTIPINSEL3_R = crate::R<u8, EXTIPINSEL3_A>;
313impl EXTIPINSEL3_R {
314    #[doc = r"Get enumerated values variant"]
315    #[inline(always)]
316    pub fn variant(&self) -> EXTIPINSEL3_A {
317        match self.bits {
318            0 => EXTIPINSEL3_A::PIN0,
319            1 => EXTIPINSEL3_A::PIN1,
320            2 => EXTIPINSEL3_A::PIN2,
321            3 => EXTIPINSEL3_A::PIN3,
322            _ => unreachable!(),
323        }
324    }
325    #[doc = "Checks if the value of the field is `PIN0`"]
326    #[inline(always)]
327    pub fn is_pin0(&self) -> bool {
328        *self == EXTIPINSEL3_A::PIN0
329    }
330    #[doc = "Checks if the value of the field is `PIN1`"]
331    #[inline(always)]
332    pub fn is_pin1(&self) -> bool {
333        *self == EXTIPINSEL3_A::PIN1
334    }
335    #[doc = "Checks if the value of the field is `PIN2`"]
336    #[inline(always)]
337    pub fn is_pin2(&self) -> bool {
338        *self == EXTIPINSEL3_A::PIN2
339    }
340    #[doc = "Checks if the value of the field is `PIN3`"]
341    #[inline(always)]
342    pub fn is_pin3(&self) -> bool {
343        *self == EXTIPINSEL3_A::PIN3
344    }
345}
346#[doc = "Write proxy for field `EXTIPINSEL3`"]
347pub struct EXTIPINSEL3_W<'a> {
348    w: &'a mut W,
349}
350impl<'a> EXTIPINSEL3_W<'a> {
351    #[doc = r"Writes `variant` to the field"]
352    #[inline(always)]
353    pub fn variant(self, variant: EXTIPINSEL3_A) -> &'a mut W {
354        {
355            self.bits(variant.into())
356        }
357    }
358    #[doc = "Pin 0"]
359    #[inline(always)]
360    pub fn pin0(self) -> &'a mut W {
361        self.variant(EXTIPINSEL3_A::PIN0)
362    }
363    #[doc = "Pin 1"]
364    #[inline(always)]
365    pub fn pin1(self) -> &'a mut W {
366        self.variant(EXTIPINSEL3_A::PIN1)
367    }
368    #[doc = "Pin 2"]
369    #[inline(always)]
370    pub fn pin2(self) -> &'a mut W {
371        self.variant(EXTIPINSEL3_A::PIN2)
372    }
373    #[doc = "Pin 3"]
374    #[inline(always)]
375    pub fn pin3(self) -> &'a mut W {
376        self.variant(EXTIPINSEL3_A::PIN3)
377    }
378    #[doc = r"Writes raw bits to the field"]
379    #[inline(always)]
380    pub fn bits(self, value: u8) -> &'a mut W {
381        self.w.bits = (self.w.bits & !(0x03 << 12)) | (((value as u32) & 0x03) << 12);
382        self.w
383    }
384}
385#[doc = "External Interrupt 4 Pin Select\n\nValue on reset: 0"]
386#[derive(Clone, Copy, Debug, PartialEq)]
387#[repr(u8)]
388pub enum EXTIPINSEL4_A {
389    #[doc = "0: Pin 4"]
390    PIN4 = 0,
391    #[doc = "1: Pin 5"]
392    PIN5 = 1,
393    #[doc = "2: Pin 6"]
394    PIN6 = 2,
395    #[doc = "3: Pin 7"]
396    PIN7 = 3,
397}
398impl From<EXTIPINSEL4_A> for u8 {
399    #[inline(always)]
400    fn from(variant: EXTIPINSEL4_A) -> Self {
401        variant as _
402    }
403}
404#[doc = "Reader of field `EXTIPINSEL4`"]
405pub type EXTIPINSEL4_R = crate::R<u8, EXTIPINSEL4_A>;
406impl EXTIPINSEL4_R {
407    #[doc = r"Get enumerated values variant"]
408    #[inline(always)]
409    pub fn variant(&self) -> EXTIPINSEL4_A {
410        match self.bits {
411            0 => EXTIPINSEL4_A::PIN4,
412            1 => EXTIPINSEL4_A::PIN5,
413            2 => EXTIPINSEL4_A::PIN6,
414            3 => EXTIPINSEL4_A::PIN7,
415            _ => unreachable!(),
416        }
417    }
418    #[doc = "Checks if the value of the field is `PIN4`"]
419    #[inline(always)]
420    pub fn is_pin4(&self) -> bool {
421        *self == EXTIPINSEL4_A::PIN4
422    }
423    #[doc = "Checks if the value of the field is `PIN5`"]
424    #[inline(always)]
425    pub fn is_pin5(&self) -> bool {
426        *self == EXTIPINSEL4_A::PIN5
427    }
428    #[doc = "Checks if the value of the field is `PIN6`"]
429    #[inline(always)]
430    pub fn is_pin6(&self) -> bool {
431        *self == EXTIPINSEL4_A::PIN6
432    }
433    #[doc = "Checks if the value of the field is `PIN7`"]
434    #[inline(always)]
435    pub fn is_pin7(&self) -> bool {
436        *self == EXTIPINSEL4_A::PIN7
437    }
438}
439#[doc = "Write proxy for field `EXTIPINSEL4`"]
440pub struct EXTIPINSEL4_W<'a> {
441    w: &'a mut W,
442}
443impl<'a> EXTIPINSEL4_W<'a> {
444    #[doc = r"Writes `variant` to the field"]
445    #[inline(always)]
446    pub fn variant(self, variant: EXTIPINSEL4_A) -> &'a mut W {
447        {
448            self.bits(variant.into())
449        }
450    }
451    #[doc = "Pin 4"]
452    #[inline(always)]
453    pub fn pin4(self) -> &'a mut W {
454        self.variant(EXTIPINSEL4_A::PIN4)
455    }
456    #[doc = "Pin 5"]
457    #[inline(always)]
458    pub fn pin5(self) -> &'a mut W {
459        self.variant(EXTIPINSEL4_A::PIN5)
460    }
461    #[doc = "Pin 6"]
462    #[inline(always)]
463    pub fn pin6(self) -> &'a mut W {
464        self.variant(EXTIPINSEL4_A::PIN6)
465    }
466    #[doc = "Pin 7"]
467    #[inline(always)]
468    pub fn pin7(self) -> &'a mut W {
469        self.variant(EXTIPINSEL4_A::PIN7)
470    }
471    #[doc = r"Writes raw bits to the field"]
472    #[inline(always)]
473    pub fn bits(self, value: u8) -> &'a mut W {
474        self.w.bits = (self.w.bits & !(0x03 << 16)) | (((value as u32) & 0x03) << 16);
475        self.w
476    }
477}
478#[doc = "External Interrupt 5 Pin Select\n\nValue on reset: 1"]
479#[derive(Clone, Copy, Debug, PartialEq)]
480#[repr(u8)]
481pub enum EXTIPINSEL5_A {
482    #[doc = "0: Pin 4"]
483    PIN4 = 0,
484    #[doc = "1: Pin 5"]
485    PIN5 = 1,
486    #[doc = "2: Pin 6"]
487    PIN6 = 2,
488    #[doc = "3: Pin 7"]
489    PIN7 = 3,
490}
491impl From<EXTIPINSEL5_A> for u8 {
492    #[inline(always)]
493    fn from(variant: EXTIPINSEL5_A) -> Self {
494        variant as _
495    }
496}
497#[doc = "Reader of field `EXTIPINSEL5`"]
498pub type EXTIPINSEL5_R = crate::R<u8, EXTIPINSEL5_A>;
499impl EXTIPINSEL5_R {
500    #[doc = r"Get enumerated values variant"]
501    #[inline(always)]
502    pub fn variant(&self) -> EXTIPINSEL5_A {
503        match self.bits {
504            0 => EXTIPINSEL5_A::PIN4,
505            1 => EXTIPINSEL5_A::PIN5,
506            2 => EXTIPINSEL5_A::PIN6,
507            3 => EXTIPINSEL5_A::PIN7,
508            _ => unreachable!(),
509        }
510    }
511    #[doc = "Checks if the value of the field is `PIN4`"]
512    #[inline(always)]
513    pub fn is_pin4(&self) -> bool {
514        *self == EXTIPINSEL5_A::PIN4
515    }
516    #[doc = "Checks if the value of the field is `PIN5`"]
517    #[inline(always)]
518    pub fn is_pin5(&self) -> bool {
519        *self == EXTIPINSEL5_A::PIN5
520    }
521    #[doc = "Checks if the value of the field is `PIN6`"]
522    #[inline(always)]
523    pub fn is_pin6(&self) -> bool {
524        *self == EXTIPINSEL5_A::PIN6
525    }
526    #[doc = "Checks if the value of the field is `PIN7`"]
527    #[inline(always)]
528    pub fn is_pin7(&self) -> bool {
529        *self == EXTIPINSEL5_A::PIN7
530    }
531}
532#[doc = "Write proxy for field `EXTIPINSEL5`"]
533pub struct EXTIPINSEL5_W<'a> {
534    w: &'a mut W,
535}
536impl<'a> EXTIPINSEL5_W<'a> {
537    #[doc = r"Writes `variant` to the field"]
538    #[inline(always)]
539    pub fn variant(self, variant: EXTIPINSEL5_A) -> &'a mut W {
540        {
541            self.bits(variant.into())
542        }
543    }
544    #[doc = "Pin 4"]
545    #[inline(always)]
546    pub fn pin4(self) -> &'a mut W {
547        self.variant(EXTIPINSEL5_A::PIN4)
548    }
549    #[doc = "Pin 5"]
550    #[inline(always)]
551    pub fn pin5(self) -> &'a mut W {
552        self.variant(EXTIPINSEL5_A::PIN5)
553    }
554    #[doc = "Pin 6"]
555    #[inline(always)]
556    pub fn pin6(self) -> &'a mut W {
557        self.variant(EXTIPINSEL5_A::PIN6)
558    }
559    #[doc = "Pin 7"]
560    #[inline(always)]
561    pub fn pin7(self) -> &'a mut W {
562        self.variant(EXTIPINSEL5_A::PIN7)
563    }
564    #[doc = r"Writes raw bits to the field"]
565    #[inline(always)]
566    pub fn bits(self, value: u8) -> &'a mut W {
567        self.w.bits = (self.w.bits & !(0x03 << 20)) | (((value as u32) & 0x03) << 20);
568        self.w
569    }
570}
571#[doc = "External Interrupt 6 Pin Select\n\nValue on reset: 2"]
572#[derive(Clone, Copy, Debug, PartialEq)]
573#[repr(u8)]
574pub enum EXTIPINSEL6_A {
575    #[doc = "0: Pin 4"]
576    PIN4 = 0,
577    #[doc = "1: Pin 5"]
578    PIN5 = 1,
579    #[doc = "2: Pin 6"]
580    PIN6 = 2,
581    #[doc = "3: Pin 7"]
582    PIN7 = 3,
583}
584impl From<EXTIPINSEL6_A> for u8 {
585    #[inline(always)]
586    fn from(variant: EXTIPINSEL6_A) -> Self {
587        variant as _
588    }
589}
590#[doc = "Reader of field `EXTIPINSEL6`"]
591pub type EXTIPINSEL6_R = crate::R<u8, EXTIPINSEL6_A>;
592impl EXTIPINSEL6_R {
593    #[doc = r"Get enumerated values variant"]
594    #[inline(always)]
595    pub fn variant(&self) -> EXTIPINSEL6_A {
596        match self.bits {
597            0 => EXTIPINSEL6_A::PIN4,
598            1 => EXTIPINSEL6_A::PIN5,
599            2 => EXTIPINSEL6_A::PIN6,
600            3 => EXTIPINSEL6_A::PIN7,
601            _ => unreachable!(),
602        }
603    }
604    #[doc = "Checks if the value of the field is `PIN4`"]
605    #[inline(always)]
606    pub fn is_pin4(&self) -> bool {
607        *self == EXTIPINSEL6_A::PIN4
608    }
609    #[doc = "Checks if the value of the field is `PIN5`"]
610    #[inline(always)]
611    pub fn is_pin5(&self) -> bool {
612        *self == EXTIPINSEL6_A::PIN5
613    }
614    #[doc = "Checks if the value of the field is `PIN6`"]
615    #[inline(always)]
616    pub fn is_pin6(&self) -> bool {
617        *self == EXTIPINSEL6_A::PIN6
618    }
619    #[doc = "Checks if the value of the field is `PIN7`"]
620    #[inline(always)]
621    pub fn is_pin7(&self) -> bool {
622        *self == EXTIPINSEL6_A::PIN7
623    }
624}
625#[doc = "Write proxy for field `EXTIPINSEL6`"]
626pub struct EXTIPINSEL6_W<'a> {
627    w: &'a mut W,
628}
629impl<'a> EXTIPINSEL6_W<'a> {
630    #[doc = r"Writes `variant` to the field"]
631    #[inline(always)]
632    pub fn variant(self, variant: EXTIPINSEL6_A) -> &'a mut W {
633        {
634            self.bits(variant.into())
635        }
636    }
637    #[doc = "Pin 4"]
638    #[inline(always)]
639    pub fn pin4(self) -> &'a mut W {
640        self.variant(EXTIPINSEL6_A::PIN4)
641    }
642    #[doc = "Pin 5"]
643    #[inline(always)]
644    pub fn pin5(self) -> &'a mut W {
645        self.variant(EXTIPINSEL6_A::PIN5)
646    }
647    #[doc = "Pin 6"]
648    #[inline(always)]
649    pub fn pin6(self) -> &'a mut W {
650        self.variant(EXTIPINSEL6_A::PIN6)
651    }
652    #[doc = "Pin 7"]
653    #[inline(always)]
654    pub fn pin7(self) -> &'a mut W {
655        self.variant(EXTIPINSEL6_A::PIN7)
656    }
657    #[doc = r"Writes raw bits to the field"]
658    #[inline(always)]
659    pub fn bits(self, value: u8) -> &'a mut W {
660        self.w.bits = (self.w.bits & !(0x03 << 24)) | (((value as u32) & 0x03) << 24);
661        self.w
662    }
663}
664#[doc = "External Interrupt 7 Pin Select\n\nValue on reset: 3"]
665#[derive(Clone, Copy, Debug, PartialEq)]
666#[repr(u8)]
667pub enum EXTIPINSEL7_A {
668    #[doc = "0: Pin 4"]
669    PIN4 = 0,
670    #[doc = "1: Pin 5"]
671    PIN5 = 1,
672    #[doc = "2: Pin 6"]
673    PIN6 = 2,
674    #[doc = "3: Pin 7"]
675    PIN7 = 3,
676}
677impl From<EXTIPINSEL7_A> for u8 {
678    #[inline(always)]
679    fn from(variant: EXTIPINSEL7_A) -> Self {
680        variant as _
681    }
682}
683#[doc = "Reader of field `EXTIPINSEL7`"]
684pub type EXTIPINSEL7_R = crate::R<u8, EXTIPINSEL7_A>;
685impl EXTIPINSEL7_R {
686    #[doc = r"Get enumerated values variant"]
687    #[inline(always)]
688    pub fn variant(&self) -> EXTIPINSEL7_A {
689        match self.bits {
690            0 => EXTIPINSEL7_A::PIN4,
691            1 => EXTIPINSEL7_A::PIN5,
692            2 => EXTIPINSEL7_A::PIN6,
693            3 => EXTIPINSEL7_A::PIN7,
694            _ => unreachable!(),
695        }
696    }
697    #[doc = "Checks if the value of the field is `PIN4`"]
698    #[inline(always)]
699    pub fn is_pin4(&self) -> bool {
700        *self == EXTIPINSEL7_A::PIN4
701    }
702    #[doc = "Checks if the value of the field is `PIN5`"]
703    #[inline(always)]
704    pub fn is_pin5(&self) -> bool {
705        *self == EXTIPINSEL7_A::PIN5
706    }
707    #[doc = "Checks if the value of the field is `PIN6`"]
708    #[inline(always)]
709    pub fn is_pin6(&self) -> bool {
710        *self == EXTIPINSEL7_A::PIN6
711    }
712    #[doc = "Checks if the value of the field is `PIN7`"]
713    #[inline(always)]
714    pub fn is_pin7(&self) -> bool {
715        *self == EXTIPINSEL7_A::PIN7
716    }
717}
718#[doc = "Write proxy for field `EXTIPINSEL7`"]
719pub struct EXTIPINSEL7_W<'a> {
720    w: &'a mut W,
721}
722impl<'a> EXTIPINSEL7_W<'a> {
723    #[doc = r"Writes `variant` to the field"]
724    #[inline(always)]
725    pub fn variant(self, variant: EXTIPINSEL7_A) -> &'a mut W {
726        {
727            self.bits(variant.into())
728        }
729    }
730    #[doc = "Pin 4"]
731    #[inline(always)]
732    pub fn pin4(self) -> &'a mut W {
733        self.variant(EXTIPINSEL7_A::PIN4)
734    }
735    #[doc = "Pin 5"]
736    #[inline(always)]
737    pub fn pin5(self) -> &'a mut W {
738        self.variant(EXTIPINSEL7_A::PIN5)
739    }
740    #[doc = "Pin 6"]
741    #[inline(always)]
742    pub fn pin6(self) -> &'a mut W {
743        self.variant(EXTIPINSEL7_A::PIN6)
744    }
745    #[doc = "Pin 7"]
746    #[inline(always)]
747    pub fn pin7(self) -> &'a mut W {
748        self.variant(EXTIPINSEL7_A::PIN7)
749    }
750    #[doc = r"Writes raw bits to the field"]
751    #[inline(always)]
752    pub fn bits(self, value: u8) -> &'a mut W {
753        self.w.bits = (self.w.bits & !(0x03 << 28)) | (((value as u32) & 0x03) << 28);
754        self.w
755    }
756}
757impl R {
758    #[doc = "Bits 0:1 - External Interrupt 0 Pin Select"]
759    #[inline(always)]
760    pub fn extipinsel0(&self) -> EXTIPINSEL0_R {
761        EXTIPINSEL0_R::new((self.bits & 0x03) as u8)
762    }
763    #[doc = "Bits 4:5 - External Interrupt 1 Pin Select"]
764    #[inline(always)]
765    pub fn extipinsel1(&self) -> EXTIPINSEL1_R {
766        EXTIPINSEL1_R::new(((self.bits >> 4) & 0x03) as u8)
767    }
768    #[doc = "Bits 8:9 - External Interrupt 2 Pin Select"]
769    #[inline(always)]
770    pub fn extipinsel2(&self) -> EXTIPINSEL2_R {
771        EXTIPINSEL2_R::new(((self.bits >> 8) & 0x03) as u8)
772    }
773    #[doc = "Bits 12:13 - External Interrupt 3 Pin Select"]
774    #[inline(always)]
775    pub fn extipinsel3(&self) -> EXTIPINSEL3_R {
776        EXTIPINSEL3_R::new(((self.bits >> 12) & 0x03) as u8)
777    }
778    #[doc = "Bits 16:17 - External Interrupt 4 Pin Select"]
779    #[inline(always)]
780    pub fn extipinsel4(&self) -> EXTIPINSEL4_R {
781        EXTIPINSEL4_R::new(((self.bits >> 16) & 0x03) as u8)
782    }
783    #[doc = "Bits 20:21 - External Interrupt 5 Pin Select"]
784    #[inline(always)]
785    pub fn extipinsel5(&self) -> EXTIPINSEL5_R {
786        EXTIPINSEL5_R::new(((self.bits >> 20) & 0x03) as u8)
787    }
788    #[doc = "Bits 24:25 - External Interrupt 6 Pin Select"]
789    #[inline(always)]
790    pub fn extipinsel6(&self) -> EXTIPINSEL6_R {
791        EXTIPINSEL6_R::new(((self.bits >> 24) & 0x03) as u8)
792    }
793    #[doc = "Bits 28:29 - External Interrupt 7 Pin Select"]
794    #[inline(always)]
795    pub fn extipinsel7(&self) -> EXTIPINSEL7_R {
796        EXTIPINSEL7_R::new(((self.bits >> 28) & 0x03) as u8)
797    }
798}
799impl W {
800    #[doc = "Bits 0:1 - External Interrupt 0 Pin Select"]
801    #[inline(always)]
802    pub fn extipinsel0(&mut self) -> EXTIPINSEL0_W {
803        EXTIPINSEL0_W { w: self }
804    }
805    #[doc = "Bits 4:5 - External Interrupt 1 Pin Select"]
806    #[inline(always)]
807    pub fn extipinsel1(&mut self) -> EXTIPINSEL1_W {
808        EXTIPINSEL1_W { w: self }
809    }
810    #[doc = "Bits 8:9 - External Interrupt 2 Pin Select"]
811    #[inline(always)]
812    pub fn extipinsel2(&mut self) -> EXTIPINSEL2_W {
813        EXTIPINSEL2_W { w: self }
814    }
815    #[doc = "Bits 12:13 - External Interrupt 3 Pin Select"]
816    #[inline(always)]
817    pub fn extipinsel3(&mut self) -> EXTIPINSEL3_W {
818        EXTIPINSEL3_W { w: self }
819    }
820    #[doc = "Bits 16:17 - External Interrupt 4 Pin Select"]
821    #[inline(always)]
822    pub fn extipinsel4(&mut self) -> EXTIPINSEL4_W {
823        EXTIPINSEL4_W { w: self }
824    }
825    #[doc = "Bits 20:21 - External Interrupt 5 Pin Select"]
826    #[inline(always)]
827    pub fn extipinsel5(&mut self) -> EXTIPINSEL5_W {
828        EXTIPINSEL5_W { w: self }
829    }
830    #[doc = "Bits 24:25 - External Interrupt 6 Pin Select"]
831    #[inline(always)]
832    pub fn extipinsel6(&mut self) -> EXTIPINSEL6_W {
833        EXTIPINSEL6_W { w: self }
834    }
835    #[doc = "Bits 28:29 - External Interrupt 7 Pin Select"]
836    #[inline(always)]
837    pub fn extipinsel7(&mut self) -> EXTIPINSEL7_W {
838        EXTIPINSEL7_W { w: self }
839    }
840}
efm32pg12_pac/gpio/extipinsell.rs

efm32pg12_pac/gpio/
extipinsell.rs
