efm32pg12_pac/gpio/
extipinselh.rs

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

efm32pg12_pac/gpio/
extipinselh.rs
