1#[doc = "Register `PMC` reader"]
2pub type R = crate::R<PmcSpec>;
3#[doc = "Register `PMC` writer"]
4pub type W = crate::W<PmcSpec>;
5#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
6#[cfg_attr(feature = "defmt", derive(defmt::Format))]
7#[derive(Clone, Copy, Debug, PartialEq, Eq)]
8pub enum Wupmc0 {
9 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
10 LowPwrOnly = 0,
11 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
12 AnyPwr = 1,
13}
14impl From<Wupmc0> for bool {
15 #[inline(always)]
16 fn from(variant: Wupmc0) -> Self {
17 variant as u8 != 0
18 }
19}
20#[doc = "Field `WUPMC0` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
21pub type Wupmc0R = crate::BitReader<Wupmc0>;
22impl Wupmc0R {
23 #[doc = "Get enumerated values variant"]
24 #[inline(always)]
25 pub const fn variant(&self) -> Wupmc0 {
26 match self.bits {
27 false => Wupmc0::LowPwrOnly,
28 true => Wupmc0::AnyPwr,
29 }
30 }
31 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
32 #[inline(always)]
33 pub fn is_low_pwr_only(&self) -> bool {
34 *self == Wupmc0::LowPwrOnly
35 }
36 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
37 #[inline(always)]
38 pub fn is_any_pwr(&self) -> bool {
39 *self == Wupmc0::AnyPwr
40 }
41}
42#[doc = "Field `WUPMC0` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
43pub type Wupmc0W<'a, REG> = crate::BitWriter<'a, REG, Wupmc0>;
44impl<'a, REG> Wupmc0W<'a, REG>
45where
46 REG: crate::Writable + crate::RegisterSpec,
47{
48 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
49 #[inline(always)]
50 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
51 self.variant(Wupmc0::LowPwrOnly)
52 }
53 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
54 #[inline(always)]
55 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
56 self.variant(Wupmc0::AnyPwr)
57 }
58}
59#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
60#[cfg_attr(feature = "defmt", derive(defmt::Format))]
61#[derive(Clone, Copy, Debug, PartialEq, Eq)]
62pub enum Wupmc1 {
63 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
64 LowPwrOnly = 0,
65 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
66 AnyPwr = 1,
67}
68impl From<Wupmc1> for bool {
69 #[inline(always)]
70 fn from(variant: Wupmc1) -> Self {
71 variant as u8 != 0
72 }
73}
74#[doc = "Field `WUPMC1` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
75pub type Wupmc1R = crate::BitReader<Wupmc1>;
76impl Wupmc1R {
77 #[doc = "Get enumerated values variant"]
78 #[inline(always)]
79 pub const fn variant(&self) -> Wupmc1 {
80 match self.bits {
81 false => Wupmc1::LowPwrOnly,
82 true => Wupmc1::AnyPwr,
83 }
84 }
85 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
86 #[inline(always)]
87 pub fn is_low_pwr_only(&self) -> bool {
88 *self == Wupmc1::LowPwrOnly
89 }
90 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
91 #[inline(always)]
92 pub fn is_any_pwr(&self) -> bool {
93 *self == Wupmc1::AnyPwr
94 }
95}
96#[doc = "Field `WUPMC1` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
97pub type Wupmc1W<'a, REG> = crate::BitWriter<'a, REG, Wupmc1>;
98impl<'a, REG> Wupmc1W<'a, REG>
99where
100 REG: crate::Writable + crate::RegisterSpec,
101{
102 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
103 #[inline(always)]
104 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
105 self.variant(Wupmc1::LowPwrOnly)
106 }
107 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
108 #[inline(always)]
109 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
110 self.variant(Wupmc1::AnyPwr)
111 }
112}
113#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
114#[cfg_attr(feature = "defmt", derive(defmt::Format))]
115#[derive(Clone, Copy, Debug, PartialEq, Eq)]
116pub enum Wupmc2 {
117 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
118 LowPwrOnly = 0,
119 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
120 AnyPwr = 1,
121}
122impl From<Wupmc2> for bool {
123 #[inline(always)]
124 fn from(variant: Wupmc2) -> Self {
125 variant as u8 != 0
126 }
127}
128#[doc = "Field `WUPMC2` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
129pub type Wupmc2R = crate::BitReader<Wupmc2>;
130impl Wupmc2R {
131 #[doc = "Get enumerated values variant"]
132 #[inline(always)]
133 pub const fn variant(&self) -> Wupmc2 {
134 match self.bits {
135 false => Wupmc2::LowPwrOnly,
136 true => Wupmc2::AnyPwr,
137 }
138 }
139 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
140 #[inline(always)]
141 pub fn is_low_pwr_only(&self) -> bool {
142 *self == Wupmc2::LowPwrOnly
143 }
144 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
145 #[inline(always)]
146 pub fn is_any_pwr(&self) -> bool {
147 *self == Wupmc2::AnyPwr
148 }
149}
150#[doc = "Field `WUPMC2` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
151pub type Wupmc2W<'a, REG> = crate::BitWriter<'a, REG, Wupmc2>;
152impl<'a, REG> Wupmc2W<'a, REG>
153where
154 REG: crate::Writable + crate::RegisterSpec,
155{
156 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
157 #[inline(always)]
158 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
159 self.variant(Wupmc2::LowPwrOnly)
160 }
161 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
162 #[inline(always)]
163 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
164 self.variant(Wupmc2::AnyPwr)
165 }
166}
167#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
168#[cfg_attr(feature = "defmt", derive(defmt::Format))]
169#[derive(Clone, Copy, Debug, PartialEq, Eq)]
170pub enum Wupmc3 {
171 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
172 LowPwrOnly = 0,
173 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
174 AnyPwr = 1,
175}
176impl From<Wupmc3> for bool {
177 #[inline(always)]
178 fn from(variant: Wupmc3) -> Self {
179 variant as u8 != 0
180 }
181}
182#[doc = "Field `WUPMC3` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
183pub type Wupmc3R = crate::BitReader<Wupmc3>;
184impl Wupmc3R {
185 #[doc = "Get enumerated values variant"]
186 #[inline(always)]
187 pub const fn variant(&self) -> Wupmc3 {
188 match self.bits {
189 false => Wupmc3::LowPwrOnly,
190 true => Wupmc3::AnyPwr,
191 }
192 }
193 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
194 #[inline(always)]
195 pub fn is_low_pwr_only(&self) -> bool {
196 *self == Wupmc3::LowPwrOnly
197 }
198 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
199 #[inline(always)]
200 pub fn is_any_pwr(&self) -> bool {
201 *self == Wupmc3::AnyPwr
202 }
203}
204#[doc = "Field `WUPMC3` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
205pub type Wupmc3W<'a, REG> = crate::BitWriter<'a, REG, Wupmc3>;
206impl<'a, REG> Wupmc3W<'a, REG>
207where
208 REG: crate::Writable + crate::RegisterSpec,
209{
210 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
211 #[inline(always)]
212 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
213 self.variant(Wupmc3::LowPwrOnly)
214 }
215 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
216 #[inline(always)]
217 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
218 self.variant(Wupmc3::AnyPwr)
219 }
220}
221#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
222#[cfg_attr(feature = "defmt", derive(defmt::Format))]
223#[derive(Clone, Copy, Debug, PartialEq, Eq)]
224pub enum Wupmc4 {
225 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
226 LowPwrOnly = 0,
227 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
228 AnyPwr = 1,
229}
230impl From<Wupmc4> for bool {
231 #[inline(always)]
232 fn from(variant: Wupmc4) -> Self {
233 variant as u8 != 0
234 }
235}
236#[doc = "Field `WUPMC4` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
237pub type Wupmc4R = crate::BitReader<Wupmc4>;
238impl Wupmc4R {
239 #[doc = "Get enumerated values variant"]
240 #[inline(always)]
241 pub const fn variant(&self) -> Wupmc4 {
242 match self.bits {
243 false => Wupmc4::LowPwrOnly,
244 true => Wupmc4::AnyPwr,
245 }
246 }
247 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
248 #[inline(always)]
249 pub fn is_low_pwr_only(&self) -> bool {
250 *self == Wupmc4::LowPwrOnly
251 }
252 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
253 #[inline(always)]
254 pub fn is_any_pwr(&self) -> bool {
255 *self == Wupmc4::AnyPwr
256 }
257}
258#[doc = "Field `WUPMC4` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
259pub type Wupmc4W<'a, REG> = crate::BitWriter<'a, REG, Wupmc4>;
260impl<'a, REG> Wupmc4W<'a, REG>
261where
262 REG: crate::Writable + crate::RegisterSpec,
263{
264 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
265 #[inline(always)]
266 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
267 self.variant(Wupmc4::LowPwrOnly)
268 }
269 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
270 #[inline(always)]
271 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
272 self.variant(Wupmc4::AnyPwr)
273 }
274}
275#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
276#[cfg_attr(feature = "defmt", derive(defmt::Format))]
277#[derive(Clone, Copy, Debug, PartialEq, Eq)]
278pub enum Wupmc5 {
279 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
280 LowPwrOnly = 0,
281 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
282 AnyPwr = 1,
283}
284impl From<Wupmc5> for bool {
285 #[inline(always)]
286 fn from(variant: Wupmc5) -> Self {
287 variant as u8 != 0
288 }
289}
290#[doc = "Field `WUPMC5` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
291pub type Wupmc5R = crate::BitReader<Wupmc5>;
292impl Wupmc5R {
293 #[doc = "Get enumerated values variant"]
294 #[inline(always)]
295 pub const fn variant(&self) -> Wupmc5 {
296 match self.bits {
297 false => Wupmc5::LowPwrOnly,
298 true => Wupmc5::AnyPwr,
299 }
300 }
301 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
302 #[inline(always)]
303 pub fn is_low_pwr_only(&self) -> bool {
304 *self == Wupmc5::LowPwrOnly
305 }
306 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
307 #[inline(always)]
308 pub fn is_any_pwr(&self) -> bool {
309 *self == Wupmc5::AnyPwr
310 }
311}
312#[doc = "Field `WUPMC5` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
313pub type Wupmc5W<'a, REG> = crate::BitWriter<'a, REG, Wupmc5>;
314impl<'a, REG> Wupmc5W<'a, REG>
315where
316 REG: crate::Writable + crate::RegisterSpec,
317{
318 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
319 #[inline(always)]
320 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
321 self.variant(Wupmc5::LowPwrOnly)
322 }
323 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
324 #[inline(always)]
325 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
326 self.variant(Wupmc5::AnyPwr)
327 }
328}
329#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
330#[cfg_attr(feature = "defmt", derive(defmt::Format))]
331#[derive(Clone, Copy, Debug, PartialEq, Eq)]
332pub enum Wupmc6 {
333 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
334 LowPwrOnly = 0,
335 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
336 AnyPwr = 1,
337}
338impl From<Wupmc6> for bool {
339 #[inline(always)]
340 fn from(variant: Wupmc6) -> Self {
341 variant as u8 != 0
342 }
343}
344#[doc = "Field `WUPMC6` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
345pub type Wupmc6R = crate::BitReader<Wupmc6>;
346impl Wupmc6R {
347 #[doc = "Get enumerated values variant"]
348 #[inline(always)]
349 pub const fn variant(&self) -> Wupmc6 {
350 match self.bits {
351 false => Wupmc6::LowPwrOnly,
352 true => Wupmc6::AnyPwr,
353 }
354 }
355 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
356 #[inline(always)]
357 pub fn is_low_pwr_only(&self) -> bool {
358 *self == Wupmc6::LowPwrOnly
359 }
360 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
361 #[inline(always)]
362 pub fn is_any_pwr(&self) -> bool {
363 *self == Wupmc6::AnyPwr
364 }
365}
366#[doc = "Field `WUPMC6` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
367pub type Wupmc6W<'a, REG> = crate::BitWriter<'a, REG, Wupmc6>;
368impl<'a, REG> Wupmc6W<'a, REG>
369where
370 REG: crate::Writable + crate::RegisterSpec,
371{
372 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
373 #[inline(always)]
374 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
375 self.variant(Wupmc6::LowPwrOnly)
376 }
377 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
378 #[inline(always)]
379 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
380 self.variant(Wupmc6::AnyPwr)
381 }
382}
383#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
384#[cfg_attr(feature = "defmt", derive(defmt::Format))]
385#[derive(Clone, Copy, Debug, PartialEq, Eq)]
386pub enum Wupmc7 {
387 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
388 LowPwrOnly = 0,
389 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
390 AnyPwr = 1,
391}
392impl From<Wupmc7> for bool {
393 #[inline(always)]
394 fn from(variant: Wupmc7) -> Self {
395 variant as u8 != 0
396 }
397}
398#[doc = "Field `WUPMC7` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
399pub type Wupmc7R = crate::BitReader<Wupmc7>;
400impl Wupmc7R {
401 #[doc = "Get enumerated values variant"]
402 #[inline(always)]
403 pub const fn variant(&self) -> Wupmc7 {
404 match self.bits {
405 false => Wupmc7::LowPwrOnly,
406 true => Wupmc7::AnyPwr,
407 }
408 }
409 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
410 #[inline(always)]
411 pub fn is_low_pwr_only(&self) -> bool {
412 *self == Wupmc7::LowPwrOnly
413 }
414 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
415 #[inline(always)]
416 pub fn is_any_pwr(&self) -> bool {
417 *self == Wupmc7::AnyPwr
418 }
419}
420#[doc = "Field `WUPMC7` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
421pub type Wupmc7W<'a, REG> = crate::BitWriter<'a, REG, Wupmc7>;
422impl<'a, REG> Wupmc7W<'a, REG>
423where
424 REG: crate::Writable + crate::RegisterSpec,
425{
426 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
427 #[inline(always)]
428 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
429 self.variant(Wupmc7::LowPwrOnly)
430 }
431 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
432 #[inline(always)]
433 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
434 self.variant(Wupmc7::AnyPwr)
435 }
436}
437#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
438#[cfg_attr(feature = "defmt", derive(defmt::Format))]
439#[derive(Clone, Copy, Debug, PartialEq, Eq)]
440pub enum Wupmc8 {
441 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
442 LowPwrOnly = 0,
443 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
444 AnyPwr = 1,
445}
446impl From<Wupmc8> for bool {
447 #[inline(always)]
448 fn from(variant: Wupmc8) -> Self {
449 variant as u8 != 0
450 }
451}
452#[doc = "Field `WUPMC8` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
453pub type Wupmc8R = crate::BitReader<Wupmc8>;
454impl Wupmc8R {
455 #[doc = "Get enumerated values variant"]
456 #[inline(always)]
457 pub const fn variant(&self) -> Wupmc8 {
458 match self.bits {
459 false => Wupmc8::LowPwrOnly,
460 true => Wupmc8::AnyPwr,
461 }
462 }
463 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
464 #[inline(always)]
465 pub fn is_low_pwr_only(&self) -> bool {
466 *self == Wupmc8::LowPwrOnly
467 }
468 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
469 #[inline(always)]
470 pub fn is_any_pwr(&self) -> bool {
471 *self == Wupmc8::AnyPwr
472 }
473}
474#[doc = "Field `WUPMC8` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
475pub type Wupmc8W<'a, REG> = crate::BitWriter<'a, REG, Wupmc8>;
476impl<'a, REG> Wupmc8W<'a, REG>
477where
478 REG: crate::Writable + crate::RegisterSpec,
479{
480 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
481 #[inline(always)]
482 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
483 self.variant(Wupmc8::LowPwrOnly)
484 }
485 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
486 #[inline(always)]
487 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
488 self.variant(Wupmc8::AnyPwr)
489 }
490}
491#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
492#[cfg_attr(feature = "defmt", derive(defmt::Format))]
493#[derive(Clone, Copy, Debug, PartialEq, Eq)]
494pub enum Wupmc9 {
495 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
496 LowPwrOnly = 0,
497 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
498 AnyPwr = 1,
499}
500impl From<Wupmc9> for bool {
501 #[inline(always)]
502 fn from(variant: Wupmc9) -> Self {
503 variant as u8 != 0
504 }
505}
506#[doc = "Field `WUPMC9` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
507pub type Wupmc9R = crate::BitReader<Wupmc9>;
508impl Wupmc9R {
509 #[doc = "Get enumerated values variant"]
510 #[inline(always)]
511 pub const fn variant(&self) -> Wupmc9 {
512 match self.bits {
513 false => Wupmc9::LowPwrOnly,
514 true => Wupmc9::AnyPwr,
515 }
516 }
517 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
518 #[inline(always)]
519 pub fn is_low_pwr_only(&self) -> bool {
520 *self == Wupmc9::LowPwrOnly
521 }
522 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
523 #[inline(always)]
524 pub fn is_any_pwr(&self) -> bool {
525 *self == Wupmc9::AnyPwr
526 }
527}
528#[doc = "Field `WUPMC9` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
529pub type Wupmc9W<'a, REG> = crate::BitWriter<'a, REG, Wupmc9>;
530impl<'a, REG> Wupmc9W<'a, REG>
531where
532 REG: crate::Writable + crate::RegisterSpec,
533{
534 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
535 #[inline(always)]
536 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
537 self.variant(Wupmc9::LowPwrOnly)
538 }
539 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
540 #[inline(always)]
541 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
542 self.variant(Wupmc9::AnyPwr)
543 }
544}
545#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
546#[cfg_attr(feature = "defmt", derive(defmt::Format))]
547#[derive(Clone, Copy, Debug, PartialEq, Eq)]
548pub enum Wupmc10 {
549 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
550 LowPwrOnly = 0,
551 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
552 AnyPwr = 1,
553}
554impl From<Wupmc10> for bool {
555 #[inline(always)]
556 fn from(variant: Wupmc10) -> Self {
557 variant as u8 != 0
558 }
559}
560#[doc = "Field `WUPMC10` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
561pub type Wupmc10R = crate::BitReader<Wupmc10>;
562impl Wupmc10R {
563 #[doc = "Get enumerated values variant"]
564 #[inline(always)]
565 pub const fn variant(&self) -> Wupmc10 {
566 match self.bits {
567 false => Wupmc10::LowPwrOnly,
568 true => Wupmc10::AnyPwr,
569 }
570 }
571 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
572 #[inline(always)]
573 pub fn is_low_pwr_only(&self) -> bool {
574 *self == Wupmc10::LowPwrOnly
575 }
576 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
577 #[inline(always)]
578 pub fn is_any_pwr(&self) -> bool {
579 *self == Wupmc10::AnyPwr
580 }
581}
582#[doc = "Field `WUPMC10` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
583pub type Wupmc10W<'a, REG> = crate::BitWriter<'a, REG, Wupmc10>;
584impl<'a, REG> Wupmc10W<'a, REG>
585where
586 REG: crate::Writable + crate::RegisterSpec,
587{
588 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
589 #[inline(always)]
590 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
591 self.variant(Wupmc10::LowPwrOnly)
592 }
593 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
594 #[inline(always)]
595 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
596 self.variant(Wupmc10::AnyPwr)
597 }
598}
599#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
600#[cfg_attr(feature = "defmt", derive(defmt::Format))]
601#[derive(Clone, Copy, Debug, PartialEq, Eq)]
602pub enum Wupmc11 {
603 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
604 LowPwrOnly = 0,
605 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
606 AnyPwr = 1,
607}
608impl From<Wupmc11> for bool {
609 #[inline(always)]
610 fn from(variant: Wupmc11) -> Self {
611 variant as u8 != 0
612 }
613}
614#[doc = "Field `WUPMC11` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
615pub type Wupmc11R = crate::BitReader<Wupmc11>;
616impl Wupmc11R {
617 #[doc = "Get enumerated values variant"]
618 #[inline(always)]
619 pub const fn variant(&self) -> Wupmc11 {
620 match self.bits {
621 false => Wupmc11::LowPwrOnly,
622 true => Wupmc11::AnyPwr,
623 }
624 }
625 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
626 #[inline(always)]
627 pub fn is_low_pwr_only(&self) -> bool {
628 *self == Wupmc11::LowPwrOnly
629 }
630 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
631 #[inline(always)]
632 pub fn is_any_pwr(&self) -> bool {
633 *self == Wupmc11::AnyPwr
634 }
635}
636#[doc = "Field `WUPMC11` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
637pub type Wupmc11W<'a, REG> = crate::BitWriter<'a, REG, Wupmc11>;
638impl<'a, REG> Wupmc11W<'a, REG>
639where
640 REG: crate::Writable + crate::RegisterSpec,
641{
642 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
643 #[inline(always)]
644 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
645 self.variant(Wupmc11::LowPwrOnly)
646 }
647 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
648 #[inline(always)]
649 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
650 self.variant(Wupmc11::AnyPwr)
651 }
652}
653#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
654#[cfg_attr(feature = "defmt", derive(defmt::Format))]
655#[derive(Clone, Copy, Debug, PartialEq, Eq)]
656pub enum Wupmc12 {
657 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
658 LowPwrOnly = 0,
659 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
660 AnyPwr = 1,
661}
662impl From<Wupmc12> for bool {
663 #[inline(always)]
664 fn from(variant: Wupmc12) -> Self {
665 variant as u8 != 0
666 }
667}
668#[doc = "Field `WUPMC12` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
669pub type Wupmc12R = crate::BitReader<Wupmc12>;
670impl Wupmc12R {
671 #[doc = "Get enumerated values variant"]
672 #[inline(always)]
673 pub const fn variant(&self) -> Wupmc12 {
674 match self.bits {
675 false => Wupmc12::LowPwrOnly,
676 true => Wupmc12::AnyPwr,
677 }
678 }
679 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
680 #[inline(always)]
681 pub fn is_low_pwr_only(&self) -> bool {
682 *self == Wupmc12::LowPwrOnly
683 }
684 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
685 #[inline(always)]
686 pub fn is_any_pwr(&self) -> bool {
687 *self == Wupmc12::AnyPwr
688 }
689}
690#[doc = "Field `WUPMC12` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
691pub type Wupmc12W<'a, REG> = crate::BitWriter<'a, REG, Wupmc12>;
692impl<'a, REG> Wupmc12W<'a, REG>
693where
694 REG: crate::Writable + crate::RegisterSpec,
695{
696 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
697 #[inline(always)]
698 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
699 self.variant(Wupmc12::LowPwrOnly)
700 }
701 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
702 #[inline(always)]
703 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
704 self.variant(Wupmc12::AnyPwr)
705 }
706}
707#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
708#[cfg_attr(feature = "defmt", derive(defmt::Format))]
709#[derive(Clone, Copy, Debug, PartialEq, Eq)]
710pub enum Wupmc13 {
711 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
712 LowPwrOnly = 0,
713 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
714 AnyPwr = 1,
715}
716impl From<Wupmc13> for bool {
717 #[inline(always)]
718 fn from(variant: Wupmc13) -> Self {
719 variant as u8 != 0
720 }
721}
722#[doc = "Field `WUPMC13` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
723pub type Wupmc13R = crate::BitReader<Wupmc13>;
724impl Wupmc13R {
725 #[doc = "Get enumerated values variant"]
726 #[inline(always)]
727 pub const fn variant(&self) -> Wupmc13 {
728 match self.bits {
729 false => Wupmc13::LowPwrOnly,
730 true => Wupmc13::AnyPwr,
731 }
732 }
733 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
734 #[inline(always)]
735 pub fn is_low_pwr_only(&self) -> bool {
736 *self == Wupmc13::LowPwrOnly
737 }
738 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
739 #[inline(always)]
740 pub fn is_any_pwr(&self) -> bool {
741 *self == Wupmc13::AnyPwr
742 }
743}
744#[doc = "Field `WUPMC13` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
745pub type Wupmc13W<'a, REG> = crate::BitWriter<'a, REG, Wupmc13>;
746impl<'a, REG> Wupmc13W<'a, REG>
747where
748 REG: crate::Writable + crate::RegisterSpec,
749{
750 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
751 #[inline(always)]
752 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
753 self.variant(Wupmc13::LowPwrOnly)
754 }
755 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
756 #[inline(always)]
757 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
758 self.variant(Wupmc13::AnyPwr)
759 }
760}
761#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
762#[cfg_attr(feature = "defmt", derive(defmt::Format))]
763#[derive(Clone, Copy, Debug, PartialEq, Eq)]
764pub enum Wupmc14 {
765 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
766 LowPwrOnly = 0,
767 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
768 AnyPwr = 1,
769}
770impl From<Wupmc14> for bool {
771 #[inline(always)]
772 fn from(variant: Wupmc14) -> Self {
773 variant as u8 != 0
774 }
775}
776#[doc = "Field `WUPMC14` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
777pub type Wupmc14R = crate::BitReader<Wupmc14>;
778impl Wupmc14R {
779 #[doc = "Get enumerated values variant"]
780 #[inline(always)]
781 pub const fn variant(&self) -> Wupmc14 {
782 match self.bits {
783 false => Wupmc14::LowPwrOnly,
784 true => Wupmc14::AnyPwr,
785 }
786 }
787 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
788 #[inline(always)]
789 pub fn is_low_pwr_only(&self) -> bool {
790 *self == Wupmc14::LowPwrOnly
791 }
792 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
793 #[inline(always)]
794 pub fn is_any_pwr(&self) -> bool {
795 *self == Wupmc14::AnyPwr
796 }
797}
798#[doc = "Field `WUPMC14` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
799pub type Wupmc14W<'a, REG> = crate::BitWriter<'a, REG, Wupmc14>;
800impl<'a, REG> Wupmc14W<'a, REG>
801where
802 REG: crate::Writable + crate::RegisterSpec,
803{
804 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
805 #[inline(always)]
806 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
807 self.variant(Wupmc14::LowPwrOnly)
808 }
809 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
810 #[inline(always)]
811 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
812 self.variant(Wupmc14::AnyPwr)
813 }
814}
815#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
816#[cfg_attr(feature = "defmt", derive(defmt::Format))]
817#[derive(Clone, Copy, Debug, PartialEq, Eq)]
818pub enum Wupmc15 {
819 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
820 LowPwrOnly = 0,
821 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
822 AnyPwr = 1,
823}
824impl From<Wupmc15> for bool {
825 #[inline(always)]
826 fn from(variant: Wupmc15) -> Self {
827 variant as u8 != 0
828 }
829}
830#[doc = "Field `WUPMC15` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
831pub type Wupmc15R = crate::BitReader<Wupmc15>;
832impl Wupmc15R {
833 #[doc = "Get enumerated values variant"]
834 #[inline(always)]
835 pub const fn variant(&self) -> Wupmc15 {
836 match self.bits {
837 false => Wupmc15::LowPwrOnly,
838 true => Wupmc15::AnyPwr,
839 }
840 }
841 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
842 #[inline(always)]
843 pub fn is_low_pwr_only(&self) -> bool {
844 *self == Wupmc15::LowPwrOnly
845 }
846 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
847 #[inline(always)]
848 pub fn is_any_pwr(&self) -> bool {
849 *self == Wupmc15::AnyPwr
850 }
851}
852#[doc = "Field `WUPMC15` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
853pub type Wupmc15W<'a, REG> = crate::BitWriter<'a, REG, Wupmc15>;
854impl<'a, REG> Wupmc15W<'a, REG>
855where
856 REG: crate::Writable + crate::RegisterSpec,
857{
858 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
859 #[inline(always)]
860 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
861 self.variant(Wupmc15::LowPwrOnly)
862 }
863 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
864 #[inline(always)]
865 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
866 self.variant(Wupmc15::AnyPwr)
867 }
868}
869#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
870#[cfg_attr(feature = "defmt", derive(defmt::Format))]
871#[derive(Clone, Copy, Debug, PartialEq, Eq)]
872pub enum Wupmc16 {
873 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
874 LowPwrOnly = 0,
875 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
876 AnyPwr = 1,
877}
878impl From<Wupmc16> for bool {
879 #[inline(always)]
880 fn from(variant: Wupmc16) -> Self {
881 variant as u8 != 0
882 }
883}
884#[doc = "Field `WUPMC16` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
885pub type Wupmc16R = crate::BitReader<Wupmc16>;
886impl Wupmc16R {
887 #[doc = "Get enumerated values variant"]
888 #[inline(always)]
889 pub const fn variant(&self) -> Wupmc16 {
890 match self.bits {
891 false => Wupmc16::LowPwrOnly,
892 true => Wupmc16::AnyPwr,
893 }
894 }
895 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
896 #[inline(always)]
897 pub fn is_low_pwr_only(&self) -> bool {
898 *self == Wupmc16::LowPwrOnly
899 }
900 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
901 #[inline(always)]
902 pub fn is_any_pwr(&self) -> bool {
903 *self == Wupmc16::AnyPwr
904 }
905}
906#[doc = "Field `WUPMC16` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
907pub type Wupmc16W<'a, REG> = crate::BitWriter<'a, REG, Wupmc16>;
908impl<'a, REG> Wupmc16W<'a, REG>
909where
910 REG: crate::Writable + crate::RegisterSpec,
911{
912 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
913 #[inline(always)]
914 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
915 self.variant(Wupmc16::LowPwrOnly)
916 }
917 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
918 #[inline(always)]
919 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
920 self.variant(Wupmc16::AnyPwr)
921 }
922}
923#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
924#[cfg_attr(feature = "defmt", derive(defmt::Format))]
925#[derive(Clone, Copy, Debug, PartialEq, Eq)]
926pub enum Wupmc17 {
927 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
928 LowPwrOnly = 0,
929 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
930 AnyPwr = 1,
931}
932impl From<Wupmc17> for bool {
933 #[inline(always)]
934 fn from(variant: Wupmc17) -> Self {
935 variant as u8 != 0
936 }
937}
938#[doc = "Field `WUPMC17` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
939pub type Wupmc17R = crate::BitReader<Wupmc17>;
940impl Wupmc17R {
941 #[doc = "Get enumerated values variant"]
942 #[inline(always)]
943 pub const fn variant(&self) -> Wupmc17 {
944 match self.bits {
945 false => Wupmc17::LowPwrOnly,
946 true => Wupmc17::AnyPwr,
947 }
948 }
949 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
950 #[inline(always)]
951 pub fn is_low_pwr_only(&self) -> bool {
952 *self == Wupmc17::LowPwrOnly
953 }
954 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
955 #[inline(always)]
956 pub fn is_any_pwr(&self) -> bool {
957 *self == Wupmc17::AnyPwr
958 }
959}
960#[doc = "Field `WUPMC17` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
961pub type Wupmc17W<'a, REG> = crate::BitWriter<'a, REG, Wupmc17>;
962impl<'a, REG> Wupmc17W<'a, REG>
963where
964 REG: crate::Writable + crate::RegisterSpec,
965{
966 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
967 #[inline(always)]
968 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
969 self.variant(Wupmc17::LowPwrOnly)
970 }
971 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
972 #[inline(always)]
973 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
974 self.variant(Wupmc17::AnyPwr)
975 }
976}
977#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
978#[cfg_attr(feature = "defmt", derive(defmt::Format))]
979#[derive(Clone, Copy, Debug, PartialEq, Eq)]
980pub enum Wupmc18 {
981 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
982 LowPwrOnly = 0,
983 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
984 AnyPwr = 1,
985}
986impl From<Wupmc18> for bool {
987 #[inline(always)]
988 fn from(variant: Wupmc18) -> Self {
989 variant as u8 != 0
990 }
991}
992#[doc = "Field `WUPMC18` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
993pub type Wupmc18R = crate::BitReader<Wupmc18>;
994impl Wupmc18R {
995 #[doc = "Get enumerated values variant"]
996 #[inline(always)]
997 pub const fn variant(&self) -> Wupmc18 {
998 match self.bits {
999 false => Wupmc18::LowPwrOnly,
1000 true => Wupmc18::AnyPwr,
1001 }
1002 }
1003 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1004 #[inline(always)]
1005 pub fn is_low_pwr_only(&self) -> bool {
1006 *self == Wupmc18::LowPwrOnly
1007 }
1008 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1009 #[inline(always)]
1010 pub fn is_any_pwr(&self) -> bool {
1011 *self == Wupmc18::AnyPwr
1012 }
1013}
1014#[doc = "Field `WUPMC18` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1015pub type Wupmc18W<'a, REG> = crate::BitWriter<'a, REG, Wupmc18>;
1016impl<'a, REG> Wupmc18W<'a, REG>
1017where
1018 REG: crate::Writable + crate::RegisterSpec,
1019{
1020 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1021 #[inline(always)]
1022 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1023 self.variant(Wupmc18::LowPwrOnly)
1024 }
1025 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1026 #[inline(always)]
1027 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1028 self.variant(Wupmc18::AnyPwr)
1029 }
1030}
1031#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1032#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1033#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1034pub enum Wupmc19 {
1035 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1036 LowPwrOnly = 0,
1037 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1038 AnyPwr = 1,
1039}
1040impl From<Wupmc19> for bool {
1041 #[inline(always)]
1042 fn from(variant: Wupmc19) -> Self {
1043 variant as u8 != 0
1044 }
1045}
1046#[doc = "Field `WUPMC19` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1047pub type Wupmc19R = crate::BitReader<Wupmc19>;
1048impl Wupmc19R {
1049 #[doc = "Get enumerated values variant"]
1050 #[inline(always)]
1051 pub const fn variant(&self) -> Wupmc19 {
1052 match self.bits {
1053 false => Wupmc19::LowPwrOnly,
1054 true => Wupmc19::AnyPwr,
1055 }
1056 }
1057 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1058 #[inline(always)]
1059 pub fn is_low_pwr_only(&self) -> bool {
1060 *self == Wupmc19::LowPwrOnly
1061 }
1062 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1063 #[inline(always)]
1064 pub fn is_any_pwr(&self) -> bool {
1065 *self == Wupmc19::AnyPwr
1066 }
1067}
1068#[doc = "Field `WUPMC19` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1069pub type Wupmc19W<'a, REG> = crate::BitWriter<'a, REG, Wupmc19>;
1070impl<'a, REG> Wupmc19W<'a, REG>
1071where
1072 REG: crate::Writable + crate::RegisterSpec,
1073{
1074 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1075 #[inline(always)]
1076 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1077 self.variant(Wupmc19::LowPwrOnly)
1078 }
1079 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1080 #[inline(always)]
1081 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1082 self.variant(Wupmc19::AnyPwr)
1083 }
1084}
1085#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1086#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1087#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1088pub enum Wupmc20 {
1089 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1090 LowPwrOnly = 0,
1091 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1092 AnyPwr = 1,
1093}
1094impl From<Wupmc20> for bool {
1095 #[inline(always)]
1096 fn from(variant: Wupmc20) -> Self {
1097 variant as u8 != 0
1098 }
1099}
1100#[doc = "Field `WUPMC20` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1101pub type Wupmc20R = crate::BitReader<Wupmc20>;
1102impl Wupmc20R {
1103 #[doc = "Get enumerated values variant"]
1104 #[inline(always)]
1105 pub const fn variant(&self) -> Wupmc20 {
1106 match self.bits {
1107 false => Wupmc20::LowPwrOnly,
1108 true => Wupmc20::AnyPwr,
1109 }
1110 }
1111 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1112 #[inline(always)]
1113 pub fn is_low_pwr_only(&self) -> bool {
1114 *self == Wupmc20::LowPwrOnly
1115 }
1116 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1117 #[inline(always)]
1118 pub fn is_any_pwr(&self) -> bool {
1119 *self == Wupmc20::AnyPwr
1120 }
1121}
1122#[doc = "Field `WUPMC20` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1123pub type Wupmc20W<'a, REG> = crate::BitWriter<'a, REG, Wupmc20>;
1124impl<'a, REG> Wupmc20W<'a, REG>
1125where
1126 REG: crate::Writable + crate::RegisterSpec,
1127{
1128 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1129 #[inline(always)]
1130 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1131 self.variant(Wupmc20::LowPwrOnly)
1132 }
1133 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1134 #[inline(always)]
1135 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1136 self.variant(Wupmc20::AnyPwr)
1137 }
1138}
1139#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1140#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1141#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1142pub enum Wupmc21 {
1143 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1144 LowPwrOnly = 0,
1145 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1146 AnyPwr = 1,
1147}
1148impl From<Wupmc21> for bool {
1149 #[inline(always)]
1150 fn from(variant: Wupmc21) -> Self {
1151 variant as u8 != 0
1152 }
1153}
1154#[doc = "Field `WUPMC21` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1155pub type Wupmc21R = crate::BitReader<Wupmc21>;
1156impl Wupmc21R {
1157 #[doc = "Get enumerated values variant"]
1158 #[inline(always)]
1159 pub const fn variant(&self) -> Wupmc21 {
1160 match self.bits {
1161 false => Wupmc21::LowPwrOnly,
1162 true => Wupmc21::AnyPwr,
1163 }
1164 }
1165 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1166 #[inline(always)]
1167 pub fn is_low_pwr_only(&self) -> bool {
1168 *self == Wupmc21::LowPwrOnly
1169 }
1170 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1171 #[inline(always)]
1172 pub fn is_any_pwr(&self) -> bool {
1173 *self == Wupmc21::AnyPwr
1174 }
1175}
1176#[doc = "Field `WUPMC21` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1177pub type Wupmc21W<'a, REG> = crate::BitWriter<'a, REG, Wupmc21>;
1178impl<'a, REG> Wupmc21W<'a, REG>
1179where
1180 REG: crate::Writable + crate::RegisterSpec,
1181{
1182 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1183 #[inline(always)]
1184 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1185 self.variant(Wupmc21::LowPwrOnly)
1186 }
1187 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1188 #[inline(always)]
1189 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1190 self.variant(Wupmc21::AnyPwr)
1191 }
1192}
1193#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1194#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1195#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1196pub enum Wupmc22 {
1197 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1198 LowPwrOnly = 0,
1199 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1200 AnyPwr = 1,
1201}
1202impl From<Wupmc22> for bool {
1203 #[inline(always)]
1204 fn from(variant: Wupmc22) -> Self {
1205 variant as u8 != 0
1206 }
1207}
1208#[doc = "Field `WUPMC22` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1209pub type Wupmc22R = crate::BitReader<Wupmc22>;
1210impl Wupmc22R {
1211 #[doc = "Get enumerated values variant"]
1212 #[inline(always)]
1213 pub const fn variant(&self) -> Wupmc22 {
1214 match self.bits {
1215 false => Wupmc22::LowPwrOnly,
1216 true => Wupmc22::AnyPwr,
1217 }
1218 }
1219 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1220 #[inline(always)]
1221 pub fn is_low_pwr_only(&self) -> bool {
1222 *self == Wupmc22::LowPwrOnly
1223 }
1224 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1225 #[inline(always)]
1226 pub fn is_any_pwr(&self) -> bool {
1227 *self == Wupmc22::AnyPwr
1228 }
1229}
1230#[doc = "Field `WUPMC22` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1231pub type Wupmc22W<'a, REG> = crate::BitWriter<'a, REG, Wupmc22>;
1232impl<'a, REG> Wupmc22W<'a, REG>
1233where
1234 REG: crate::Writable + crate::RegisterSpec,
1235{
1236 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1237 #[inline(always)]
1238 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1239 self.variant(Wupmc22::LowPwrOnly)
1240 }
1241 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1242 #[inline(always)]
1243 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1244 self.variant(Wupmc22::AnyPwr)
1245 }
1246}
1247#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1248#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1249#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1250pub enum Wupmc23 {
1251 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1252 LowPwrOnly = 0,
1253 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1254 AnyPwr = 1,
1255}
1256impl From<Wupmc23> for bool {
1257 #[inline(always)]
1258 fn from(variant: Wupmc23) -> Self {
1259 variant as u8 != 0
1260 }
1261}
1262#[doc = "Field `WUPMC23` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1263pub type Wupmc23R = crate::BitReader<Wupmc23>;
1264impl Wupmc23R {
1265 #[doc = "Get enumerated values variant"]
1266 #[inline(always)]
1267 pub const fn variant(&self) -> Wupmc23 {
1268 match self.bits {
1269 false => Wupmc23::LowPwrOnly,
1270 true => Wupmc23::AnyPwr,
1271 }
1272 }
1273 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1274 #[inline(always)]
1275 pub fn is_low_pwr_only(&self) -> bool {
1276 *self == Wupmc23::LowPwrOnly
1277 }
1278 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1279 #[inline(always)]
1280 pub fn is_any_pwr(&self) -> bool {
1281 *self == Wupmc23::AnyPwr
1282 }
1283}
1284#[doc = "Field `WUPMC23` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1285pub type Wupmc23W<'a, REG> = crate::BitWriter<'a, REG, Wupmc23>;
1286impl<'a, REG> Wupmc23W<'a, REG>
1287where
1288 REG: crate::Writable + crate::RegisterSpec,
1289{
1290 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1291 #[inline(always)]
1292 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1293 self.variant(Wupmc23::LowPwrOnly)
1294 }
1295 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1296 #[inline(always)]
1297 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1298 self.variant(Wupmc23::AnyPwr)
1299 }
1300}
1301#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1302#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1303#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1304pub enum Wupmc24 {
1305 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1306 LowPwrOnly = 0,
1307 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1308 AnyPwr = 1,
1309}
1310impl From<Wupmc24> for bool {
1311 #[inline(always)]
1312 fn from(variant: Wupmc24) -> Self {
1313 variant as u8 != 0
1314 }
1315}
1316#[doc = "Field `WUPMC24` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1317pub type Wupmc24R = crate::BitReader<Wupmc24>;
1318impl Wupmc24R {
1319 #[doc = "Get enumerated values variant"]
1320 #[inline(always)]
1321 pub const fn variant(&self) -> Wupmc24 {
1322 match self.bits {
1323 false => Wupmc24::LowPwrOnly,
1324 true => Wupmc24::AnyPwr,
1325 }
1326 }
1327 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1328 #[inline(always)]
1329 pub fn is_low_pwr_only(&self) -> bool {
1330 *self == Wupmc24::LowPwrOnly
1331 }
1332 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1333 #[inline(always)]
1334 pub fn is_any_pwr(&self) -> bool {
1335 *self == Wupmc24::AnyPwr
1336 }
1337}
1338#[doc = "Field `WUPMC24` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1339pub type Wupmc24W<'a, REG> = crate::BitWriter<'a, REG, Wupmc24>;
1340impl<'a, REG> Wupmc24W<'a, REG>
1341where
1342 REG: crate::Writable + crate::RegisterSpec,
1343{
1344 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1345 #[inline(always)]
1346 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1347 self.variant(Wupmc24::LowPwrOnly)
1348 }
1349 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1350 #[inline(always)]
1351 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1352 self.variant(Wupmc24::AnyPwr)
1353 }
1354}
1355#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1356#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1357#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1358pub enum Wupmc25 {
1359 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1360 LowPwrOnly = 0,
1361 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1362 AnyPwr = 1,
1363}
1364impl From<Wupmc25> for bool {
1365 #[inline(always)]
1366 fn from(variant: Wupmc25) -> Self {
1367 variant as u8 != 0
1368 }
1369}
1370#[doc = "Field `WUPMC25` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1371pub type Wupmc25R = crate::BitReader<Wupmc25>;
1372impl Wupmc25R {
1373 #[doc = "Get enumerated values variant"]
1374 #[inline(always)]
1375 pub const fn variant(&self) -> Wupmc25 {
1376 match self.bits {
1377 false => Wupmc25::LowPwrOnly,
1378 true => Wupmc25::AnyPwr,
1379 }
1380 }
1381 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1382 #[inline(always)]
1383 pub fn is_low_pwr_only(&self) -> bool {
1384 *self == Wupmc25::LowPwrOnly
1385 }
1386 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1387 #[inline(always)]
1388 pub fn is_any_pwr(&self) -> bool {
1389 *self == Wupmc25::AnyPwr
1390 }
1391}
1392#[doc = "Field `WUPMC25` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1393pub type Wupmc25W<'a, REG> = crate::BitWriter<'a, REG, Wupmc25>;
1394impl<'a, REG> Wupmc25W<'a, REG>
1395where
1396 REG: crate::Writable + crate::RegisterSpec,
1397{
1398 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1399 #[inline(always)]
1400 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1401 self.variant(Wupmc25::LowPwrOnly)
1402 }
1403 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1404 #[inline(always)]
1405 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1406 self.variant(Wupmc25::AnyPwr)
1407 }
1408}
1409#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1410#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1411#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1412pub enum Wupmc26 {
1413 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1414 LowPwrOnly = 0,
1415 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1416 AnyPwr = 1,
1417}
1418impl From<Wupmc26> for bool {
1419 #[inline(always)]
1420 fn from(variant: Wupmc26) -> Self {
1421 variant as u8 != 0
1422 }
1423}
1424#[doc = "Field `WUPMC26` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1425pub type Wupmc26R = crate::BitReader<Wupmc26>;
1426impl Wupmc26R {
1427 #[doc = "Get enumerated values variant"]
1428 #[inline(always)]
1429 pub const fn variant(&self) -> Wupmc26 {
1430 match self.bits {
1431 false => Wupmc26::LowPwrOnly,
1432 true => Wupmc26::AnyPwr,
1433 }
1434 }
1435 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1436 #[inline(always)]
1437 pub fn is_low_pwr_only(&self) -> bool {
1438 *self == Wupmc26::LowPwrOnly
1439 }
1440 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1441 #[inline(always)]
1442 pub fn is_any_pwr(&self) -> bool {
1443 *self == Wupmc26::AnyPwr
1444 }
1445}
1446#[doc = "Field `WUPMC26` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1447pub type Wupmc26W<'a, REG> = crate::BitWriter<'a, REG, Wupmc26>;
1448impl<'a, REG> Wupmc26W<'a, REG>
1449where
1450 REG: crate::Writable + crate::RegisterSpec,
1451{
1452 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1453 #[inline(always)]
1454 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1455 self.variant(Wupmc26::LowPwrOnly)
1456 }
1457 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1458 #[inline(always)]
1459 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1460 self.variant(Wupmc26::AnyPwr)
1461 }
1462}
1463#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1464#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1465#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1466pub enum Wupmc27 {
1467 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1468 LowPwrOnly = 0,
1469 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1470 AnyPwr = 1,
1471}
1472impl From<Wupmc27> for bool {
1473 #[inline(always)]
1474 fn from(variant: Wupmc27) -> Self {
1475 variant as u8 != 0
1476 }
1477}
1478#[doc = "Field `WUPMC27` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1479pub type Wupmc27R = crate::BitReader<Wupmc27>;
1480impl Wupmc27R {
1481 #[doc = "Get enumerated values variant"]
1482 #[inline(always)]
1483 pub const fn variant(&self) -> Wupmc27 {
1484 match self.bits {
1485 false => Wupmc27::LowPwrOnly,
1486 true => Wupmc27::AnyPwr,
1487 }
1488 }
1489 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1490 #[inline(always)]
1491 pub fn is_low_pwr_only(&self) -> bool {
1492 *self == Wupmc27::LowPwrOnly
1493 }
1494 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1495 #[inline(always)]
1496 pub fn is_any_pwr(&self) -> bool {
1497 *self == Wupmc27::AnyPwr
1498 }
1499}
1500#[doc = "Field `WUPMC27` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1501pub type Wupmc27W<'a, REG> = crate::BitWriter<'a, REG, Wupmc27>;
1502impl<'a, REG> Wupmc27W<'a, REG>
1503where
1504 REG: crate::Writable + crate::RegisterSpec,
1505{
1506 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1507 #[inline(always)]
1508 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1509 self.variant(Wupmc27::LowPwrOnly)
1510 }
1511 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1512 #[inline(always)]
1513 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1514 self.variant(Wupmc27::AnyPwr)
1515 }
1516}
1517#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1518#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1519#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1520pub enum Wupmc28 {
1521 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1522 LowPwrOnly = 0,
1523 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1524 AnyPwr = 1,
1525}
1526impl From<Wupmc28> for bool {
1527 #[inline(always)]
1528 fn from(variant: Wupmc28) -> Self {
1529 variant as u8 != 0
1530 }
1531}
1532#[doc = "Field `WUPMC28` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1533pub type Wupmc28R = crate::BitReader<Wupmc28>;
1534impl Wupmc28R {
1535 #[doc = "Get enumerated values variant"]
1536 #[inline(always)]
1537 pub const fn variant(&self) -> Wupmc28 {
1538 match self.bits {
1539 false => Wupmc28::LowPwrOnly,
1540 true => Wupmc28::AnyPwr,
1541 }
1542 }
1543 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1544 #[inline(always)]
1545 pub fn is_low_pwr_only(&self) -> bool {
1546 *self == Wupmc28::LowPwrOnly
1547 }
1548 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1549 #[inline(always)]
1550 pub fn is_any_pwr(&self) -> bool {
1551 *self == Wupmc28::AnyPwr
1552 }
1553}
1554#[doc = "Field `WUPMC28` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1555pub type Wupmc28W<'a, REG> = crate::BitWriter<'a, REG, Wupmc28>;
1556impl<'a, REG> Wupmc28W<'a, REG>
1557where
1558 REG: crate::Writable + crate::RegisterSpec,
1559{
1560 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1561 #[inline(always)]
1562 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1563 self.variant(Wupmc28::LowPwrOnly)
1564 }
1565 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1566 #[inline(always)]
1567 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1568 self.variant(Wupmc28::AnyPwr)
1569 }
1570}
1571#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1572#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1573#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1574pub enum Wupmc29 {
1575 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1576 LowPwrOnly = 0,
1577 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1578 AnyPwr = 1,
1579}
1580impl From<Wupmc29> for bool {
1581 #[inline(always)]
1582 fn from(variant: Wupmc29) -> Self {
1583 variant as u8 != 0
1584 }
1585}
1586#[doc = "Field `WUPMC29` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1587pub type Wupmc29R = crate::BitReader<Wupmc29>;
1588impl Wupmc29R {
1589 #[doc = "Get enumerated values variant"]
1590 #[inline(always)]
1591 pub const fn variant(&self) -> Wupmc29 {
1592 match self.bits {
1593 false => Wupmc29::LowPwrOnly,
1594 true => Wupmc29::AnyPwr,
1595 }
1596 }
1597 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1598 #[inline(always)]
1599 pub fn is_low_pwr_only(&self) -> bool {
1600 *self == Wupmc29::LowPwrOnly
1601 }
1602 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1603 #[inline(always)]
1604 pub fn is_any_pwr(&self) -> bool {
1605 *self == Wupmc29::AnyPwr
1606 }
1607}
1608#[doc = "Field `WUPMC29` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1609pub type Wupmc29W<'a, REG> = crate::BitWriter<'a, REG, Wupmc29>;
1610impl<'a, REG> Wupmc29W<'a, REG>
1611where
1612 REG: crate::Writable + crate::RegisterSpec,
1613{
1614 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1615 #[inline(always)]
1616 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1617 self.variant(Wupmc29::LowPwrOnly)
1618 }
1619 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1620 #[inline(always)]
1621 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1622 self.variant(Wupmc29::AnyPwr)
1623 }
1624}
1625#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1626#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1627#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1628pub enum Wupmc30 {
1629 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1630 LowPwrOnly = 0,
1631 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1632 AnyPwr = 1,
1633}
1634impl From<Wupmc30> for bool {
1635 #[inline(always)]
1636 fn from(variant: Wupmc30) -> Self {
1637 variant as u8 != 0
1638 }
1639}
1640#[doc = "Field `WUPMC30` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1641pub type Wupmc30R = crate::BitReader<Wupmc30>;
1642impl Wupmc30R {
1643 #[doc = "Get enumerated values variant"]
1644 #[inline(always)]
1645 pub const fn variant(&self) -> Wupmc30 {
1646 match self.bits {
1647 false => Wupmc30::LowPwrOnly,
1648 true => Wupmc30::AnyPwr,
1649 }
1650 }
1651 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1652 #[inline(always)]
1653 pub fn is_low_pwr_only(&self) -> bool {
1654 *self == Wupmc30::LowPwrOnly
1655 }
1656 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1657 #[inline(always)]
1658 pub fn is_any_pwr(&self) -> bool {
1659 *self == Wupmc30::AnyPwr
1660 }
1661}
1662#[doc = "Field `WUPMC30` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1663pub type Wupmc30W<'a, REG> = crate::BitWriter<'a, REG, Wupmc30>;
1664impl<'a, REG> Wupmc30W<'a, REG>
1665where
1666 REG: crate::Writable + crate::RegisterSpec,
1667{
1668 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1669 #[inline(always)]
1670 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1671 self.variant(Wupmc30::LowPwrOnly)
1672 }
1673 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1674 #[inline(always)]
1675 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1676 self.variant(Wupmc30::AnyPwr)
1677 }
1678}
1679#[doc = "Wake-up Pin Mode Configuration for WUU_Pn\n\nValue on reset: 0"]
1680#[cfg_attr(feature = "defmt", derive(defmt::Format))]
1681#[derive(Clone, Copy, Debug, PartialEq, Eq)]
1682pub enum Wupmc31 {
1683 #[doc = "0: Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1684 LowPwrOnly = 0,
1685 #[doc = "1: Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1686 AnyPwr = 1,
1687}
1688impl From<Wupmc31> for bool {
1689 #[inline(always)]
1690 fn from(variant: Wupmc31) -> Self {
1691 variant as u8 != 0
1692 }
1693}
1694#[doc = "Field `WUPMC31` reader - Wake-up Pin Mode Configuration for WUU_Pn"]
1695pub type Wupmc31R = crate::BitReader<Wupmc31>;
1696impl Wupmc31R {
1697 #[doc = "Get enumerated values variant"]
1698 #[inline(always)]
1699 pub const fn variant(&self) -> Wupmc31 {
1700 match self.bits {
1701 false => Wupmc31::LowPwrOnly,
1702 true => Wupmc31::AnyPwr,
1703 }
1704 }
1705 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1706 #[inline(always)]
1707 pub fn is_low_pwr_only(&self) -> bool {
1708 *self == Wupmc31::LowPwrOnly
1709 }
1710 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1711 #[inline(always)]
1712 pub fn is_any_pwr(&self) -> bool {
1713 *self == Wupmc31::AnyPwr
1714 }
1715}
1716#[doc = "Field `WUPMC31` writer - Wake-up Pin Mode Configuration for WUU_Pn"]
1717pub type Wupmc31W<'a, REG> = crate::BitWriter<'a, REG, Wupmc31>;
1718impl<'a, REG> Wupmc31W<'a, REG>
1719where
1720 REG: crate::Writable + crate::RegisterSpec,
1721{
1722 #[doc = "Active only during a low-leakage mode. You can modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1723 #[inline(always)]
1724 pub fn low_pwr_only(self) -> &'a mut crate::W<REG> {
1725 self.variant(Wupmc31::LowPwrOnly)
1726 }
1727 #[doc = "Active during all power modes. Do not modify the corresponding fields within Pin Enable (PEn) or Pin DMA/Trigger Configuration (PDCn)."]
1728 #[inline(always)]
1729 pub fn any_pwr(self) -> &'a mut crate::W<REG> {
1730 self.variant(Wupmc31::AnyPwr)
1731 }
1732}
1733impl R {
1734 #[doc = "Bit 0 - Wake-up Pin Mode Configuration for WUU_Pn"]
1735 #[inline(always)]
1736 pub fn wupmc0(&self) -> Wupmc0R {
1737 Wupmc0R::new((self.bits & 1) != 0)
1738 }
1739 #[doc = "Bit 1 - Wake-up Pin Mode Configuration for WUU_Pn"]
1740 #[inline(always)]
1741 pub fn wupmc1(&self) -> Wupmc1R {
1742 Wupmc1R::new(((self.bits >> 1) & 1) != 0)
1743 }
1744 #[doc = "Bit 2 - Wake-up Pin Mode Configuration for WUU_Pn"]
1745 #[inline(always)]
1746 pub fn wupmc2(&self) -> Wupmc2R {
1747 Wupmc2R::new(((self.bits >> 2) & 1) != 0)
1748 }
1749 #[doc = "Bit 3 - Wake-up Pin Mode Configuration for WUU_Pn"]
1750 #[inline(always)]
1751 pub fn wupmc3(&self) -> Wupmc3R {
1752 Wupmc3R::new(((self.bits >> 3) & 1) != 0)
1753 }
1754 #[doc = "Bit 4 - Wake-up Pin Mode Configuration for WUU_Pn"]
1755 #[inline(always)]
1756 pub fn wupmc4(&self) -> Wupmc4R {
1757 Wupmc4R::new(((self.bits >> 4) & 1) != 0)
1758 }
1759 #[doc = "Bit 5 - Wake-up Pin Mode Configuration for WUU_Pn"]
1760 #[inline(always)]
1761 pub fn wupmc5(&self) -> Wupmc5R {
1762 Wupmc5R::new(((self.bits >> 5) & 1) != 0)
1763 }
1764 #[doc = "Bit 6 - Wake-up Pin Mode Configuration for WUU_Pn"]
1765 #[inline(always)]
1766 pub fn wupmc6(&self) -> Wupmc6R {
1767 Wupmc6R::new(((self.bits >> 6) & 1) != 0)
1768 }
1769 #[doc = "Bit 7 - Wake-up Pin Mode Configuration for WUU_Pn"]
1770 #[inline(always)]
1771 pub fn wupmc7(&self) -> Wupmc7R {
1772 Wupmc7R::new(((self.bits >> 7) & 1) != 0)
1773 }
1774 #[doc = "Bit 8 - Wake-up Pin Mode Configuration for WUU_Pn"]
1775 #[inline(always)]
1776 pub fn wupmc8(&self) -> Wupmc8R {
1777 Wupmc8R::new(((self.bits >> 8) & 1) != 0)
1778 }
1779 #[doc = "Bit 9 - Wake-up Pin Mode Configuration for WUU_Pn"]
1780 #[inline(always)]
1781 pub fn wupmc9(&self) -> Wupmc9R {
1782 Wupmc9R::new(((self.bits >> 9) & 1) != 0)
1783 }
1784 #[doc = "Bit 10 - Wake-up Pin Mode Configuration for WUU_Pn"]
1785 #[inline(always)]
1786 pub fn wupmc10(&self) -> Wupmc10R {
1787 Wupmc10R::new(((self.bits >> 10) & 1) != 0)
1788 }
1789 #[doc = "Bit 11 - Wake-up Pin Mode Configuration for WUU_Pn"]
1790 #[inline(always)]
1791 pub fn wupmc11(&self) -> Wupmc11R {
1792 Wupmc11R::new(((self.bits >> 11) & 1) != 0)
1793 }
1794 #[doc = "Bit 12 - Wake-up Pin Mode Configuration for WUU_Pn"]
1795 #[inline(always)]
1796 pub fn wupmc12(&self) -> Wupmc12R {
1797 Wupmc12R::new(((self.bits >> 12) & 1) != 0)
1798 }
1799 #[doc = "Bit 13 - Wake-up Pin Mode Configuration for WUU_Pn"]
1800 #[inline(always)]
1801 pub fn wupmc13(&self) -> Wupmc13R {
1802 Wupmc13R::new(((self.bits >> 13) & 1) != 0)
1803 }
1804 #[doc = "Bit 14 - Wake-up Pin Mode Configuration for WUU_Pn"]
1805 #[inline(always)]
1806 pub fn wupmc14(&self) -> Wupmc14R {
1807 Wupmc14R::new(((self.bits >> 14) & 1) != 0)
1808 }
1809 #[doc = "Bit 15 - Wake-up Pin Mode Configuration for WUU_Pn"]
1810 #[inline(always)]
1811 pub fn wupmc15(&self) -> Wupmc15R {
1812 Wupmc15R::new(((self.bits >> 15) & 1) != 0)
1813 }
1814 #[doc = "Bit 16 - Wake-up Pin Mode Configuration for WUU_Pn"]
1815 #[inline(always)]
1816 pub fn wupmc16(&self) -> Wupmc16R {
1817 Wupmc16R::new(((self.bits >> 16) & 1) != 0)
1818 }
1819 #[doc = "Bit 17 - Wake-up Pin Mode Configuration for WUU_Pn"]
1820 #[inline(always)]
1821 pub fn wupmc17(&self) -> Wupmc17R {
1822 Wupmc17R::new(((self.bits >> 17) & 1) != 0)
1823 }
1824 #[doc = "Bit 18 - Wake-up Pin Mode Configuration for WUU_Pn"]
1825 #[inline(always)]
1826 pub fn wupmc18(&self) -> Wupmc18R {
1827 Wupmc18R::new(((self.bits >> 18) & 1) != 0)
1828 }
1829 #[doc = "Bit 19 - Wake-up Pin Mode Configuration for WUU_Pn"]
1830 #[inline(always)]
1831 pub fn wupmc19(&self) -> Wupmc19R {
1832 Wupmc19R::new(((self.bits >> 19) & 1) != 0)
1833 }
1834 #[doc = "Bit 20 - Wake-up Pin Mode Configuration for WUU_Pn"]
1835 #[inline(always)]
1836 pub fn wupmc20(&self) -> Wupmc20R {
1837 Wupmc20R::new(((self.bits >> 20) & 1) != 0)
1838 }
1839 #[doc = "Bit 21 - Wake-up Pin Mode Configuration for WUU_Pn"]
1840 #[inline(always)]
1841 pub fn wupmc21(&self) -> Wupmc21R {
1842 Wupmc21R::new(((self.bits >> 21) & 1) != 0)
1843 }
1844 #[doc = "Bit 22 - Wake-up Pin Mode Configuration for WUU_Pn"]
1845 #[inline(always)]
1846 pub fn wupmc22(&self) -> Wupmc22R {
1847 Wupmc22R::new(((self.bits >> 22) & 1) != 0)
1848 }
1849 #[doc = "Bit 23 - Wake-up Pin Mode Configuration for WUU_Pn"]
1850 #[inline(always)]
1851 pub fn wupmc23(&self) -> Wupmc23R {
1852 Wupmc23R::new(((self.bits >> 23) & 1) != 0)
1853 }
1854 #[doc = "Bit 24 - Wake-up Pin Mode Configuration for WUU_Pn"]
1855 #[inline(always)]
1856 pub fn wupmc24(&self) -> Wupmc24R {
1857 Wupmc24R::new(((self.bits >> 24) & 1) != 0)
1858 }
1859 #[doc = "Bit 25 - Wake-up Pin Mode Configuration for WUU_Pn"]
1860 #[inline(always)]
1861 pub fn wupmc25(&self) -> Wupmc25R {
1862 Wupmc25R::new(((self.bits >> 25) & 1) != 0)
1863 }
1864 #[doc = "Bit 26 - Wake-up Pin Mode Configuration for WUU_Pn"]
1865 #[inline(always)]
1866 pub fn wupmc26(&self) -> Wupmc26R {
1867 Wupmc26R::new(((self.bits >> 26) & 1) != 0)
1868 }
1869 #[doc = "Bit 27 - Wake-up Pin Mode Configuration for WUU_Pn"]
1870 #[inline(always)]
1871 pub fn wupmc27(&self) -> Wupmc27R {
1872 Wupmc27R::new(((self.bits >> 27) & 1) != 0)
1873 }
1874 #[doc = "Bit 28 - Wake-up Pin Mode Configuration for WUU_Pn"]
1875 #[inline(always)]
1876 pub fn wupmc28(&self) -> Wupmc28R {
1877 Wupmc28R::new(((self.bits >> 28) & 1) != 0)
1878 }
1879 #[doc = "Bit 29 - Wake-up Pin Mode Configuration for WUU_Pn"]
1880 #[inline(always)]
1881 pub fn wupmc29(&self) -> Wupmc29R {
1882 Wupmc29R::new(((self.bits >> 29) & 1) != 0)
1883 }
1884 #[doc = "Bit 30 - Wake-up Pin Mode Configuration for WUU_Pn"]
1885 #[inline(always)]
1886 pub fn wupmc30(&self) -> Wupmc30R {
1887 Wupmc30R::new(((self.bits >> 30) & 1) != 0)
1888 }
1889 #[doc = "Bit 31 - Wake-up Pin Mode Configuration for WUU_Pn"]
1890 #[inline(always)]
1891 pub fn wupmc31(&self) -> Wupmc31R {
1892 Wupmc31R::new(((self.bits >> 31) & 1) != 0)
1893 }
1894}
1895#[cfg(feature = "debug")]
1896impl core::fmt::Debug for R {
1897 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1898 f.debug_struct("PMC")
1899 .field("wupmc0", &self.wupmc0())
1900 .field("wupmc1", &self.wupmc1())
1901 .field("wupmc2", &self.wupmc2())
1902 .field("wupmc3", &self.wupmc3())
1903 .field("wupmc4", &self.wupmc4())
1904 .field("wupmc5", &self.wupmc5())
1905 .field("wupmc6", &self.wupmc6())
1906 .field("wupmc7", &self.wupmc7())
1907 .field("wupmc8", &self.wupmc8())
1908 .field("wupmc9", &self.wupmc9())
1909 .field("wupmc10", &self.wupmc10())
1910 .field("wupmc11", &self.wupmc11())
1911 .field("wupmc12", &self.wupmc12())
1912 .field("wupmc13", &self.wupmc13())
1913 .field("wupmc14", &self.wupmc14())
1914 .field("wupmc15", &self.wupmc15())
1915 .field("wupmc16", &self.wupmc16())
1916 .field("wupmc17", &self.wupmc17())
1917 .field("wupmc18", &self.wupmc18())
1918 .field("wupmc19", &self.wupmc19())
1919 .field("wupmc20", &self.wupmc20())
1920 .field("wupmc21", &self.wupmc21())
1921 .field("wupmc22", &self.wupmc22())
1922 .field("wupmc23", &self.wupmc23())
1923 .field("wupmc24", &self.wupmc24())
1924 .field("wupmc25", &self.wupmc25())
1925 .field("wupmc26", &self.wupmc26())
1926 .field("wupmc27", &self.wupmc27())
1927 .field("wupmc28", &self.wupmc28())
1928 .field("wupmc29", &self.wupmc29())
1929 .field("wupmc30", &self.wupmc30())
1930 .field("wupmc31", &self.wupmc31())
1931 .finish()
1932 }
1933}
1934impl W {
1935 #[doc = "Bit 0 - Wake-up Pin Mode Configuration for WUU_Pn"]
1936 #[inline(always)]
1937 pub fn wupmc0(&mut self) -> Wupmc0W<'_, PmcSpec> {
1938 Wupmc0W::new(self, 0)
1939 }
1940 #[doc = "Bit 1 - Wake-up Pin Mode Configuration for WUU_Pn"]
1941 #[inline(always)]
1942 pub fn wupmc1(&mut self) -> Wupmc1W<'_, PmcSpec> {
1943 Wupmc1W::new(self, 1)
1944 }
1945 #[doc = "Bit 2 - Wake-up Pin Mode Configuration for WUU_Pn"]
1946 #[inline(always)]
1947 pub fn wupmc2(&mut self) -> Wupmc2W<'_, PmcSpec> {
1948 Wupmc2W::new(self, 2)
1949 }
1950 #[doc = "Bit 3 - Wake-up Pin Mode Configuration for WUU_Pn"]
1951 #[inline(always)]
1952 pub fn wupmc3(&mut self) -> Wupmc3W<'_, PmcSpec> {
1953 Wupmc3W::new(self, 3)
1954 }
1955 #[doc = "Bit 4 - Wake-up Pin Mode Configuration for WUU_Pn"]
1956 #[inline(always)]
1957 pub fn wupmc4(&mut self) -> Wupmc4W<'_, PmcSpec> {
1958 Wupmc4W::new(self, 4)
1959 }
1960 #[doc = "Bit 5 - Wake-up Pin Mode Configuration for WUU_Pn"]
1961 #[inline(always)]
1962 pub fn wupmc5(&mut self) -> Wupmc5W<'_, PmcSpec> {
1963 Wupmc5W::new(self, 5)
1964 }
1965 #[doc = "Bit 6 - Wake-up Pin Mode Configuration for WUU_Pn"]
1966 #[inline(always)]
1967 pub fn wupmc6(&mut self) -> Wupmc6W<'_, PmcSpec> {
1968 Wupmc6W::new(self, 6)
1969 }
1970 #[doc = "Bit 7 - Wake-up Pin Mode Configuration for WUU_Pn"]
1971 #[inline(always)]
1972 pub fn wupmc7(&mut self) -> Wupmc7W<'_, PmcSpec> {
1973 Wupmc7W::new(self, 7)
1974 }
1975 #[doc = "Bit 8 - Wake-up Pin Mode Configuration for WUU_Pn"]
1976 #[inline(always)]
1977 pub fn wupmc8(&mut self) -> Wupmc8W<'_, PmcSpec> {
1978 Wupmc8W::new(self, 8)
1979 }
1980 #[doc = "Bit 9 - Wake-up Pin Mode Configuration for WUU_Pn"]
1981 #[inline(always)]
1982 pub fn wupmc9(&mut self) -> Wupmc9W<'_, PmcSpec> {
1983 Wupmc9W::new(self, 9)
1984 }
1985 #[doc = "Bit 10 - Wake-up Pin Mode Configuration for WUU_Pn"]
1986 #[inline(always)]
1987 pub fn wupmc10(&mut self) -> Wupmc10W<'_, PmcSpec> {
1988 Wupmc10W::new(self, 10)
1989 }
1990 #[doc = "Bit 11 - Wake-up Pin Mode Configuration for WUU_Pn"]
1991 #[inline(always)]
1992 pub fn wupmc11(&mut self) -> Wupmc11W<'_, PmcSpec> {
1993 Wupmc11W::new(self, 11)
1994 }
1995 #[doc = "Bit 12 - Wake-up Pin Mode Configuration for WUU_Pn"]
1996 #[inline(always)]
1997 pub fn wupmc12(&mut self) -> Wupmc12W<'_, PmcSpec> {
1998 Wupmc12W::new(self, 12)
1999 }
2000 #[doc = "Bit 13 - Wake-up Pin Mode Configuration for WUU_Pn"]
2001 #[inline(always)]
2002 pub fn wupmc13(&mut self) -> Wupmc13W<'_, PmcSpec> {
2003 Wupmc13W::new(self, 13)
2004 }
2005 #[doc = "Bit 14 - Wake-up Pin Mode Configuration for WUU_Pn"]
2006 #[inline(always)]
2007 pub fn wupmc14(&mut self) -> Wupmc14W<'_, PmcSpec> {
2008 Wupmc14W::new(self, 14)
2009 }
2010 #[doc = "Bit 15 - Wake-up Pin Mode Configuration for WUU_Pn"]
2011 #[inline(always)]
2012 pub fn wupmc15(&mut self) -> Wupmc15W<'_, PmcSpec> {
2013 Wupmc15W::new(self, 15)
2014 }
2015 #[doc = "Bit 16 - Wake-up Pin Mode Configuration for WUU_Pn"]
2016 #[inline(always)]
2017 pub fn wupmc16(&mut self) -> Wupmc16W<'_, PmcSpec> {
2018 Wupmc16W::new(self, 16)
2019 }
2020 #[doc = "Bit 17 - Wake-up Pin Mode Configuration for WUU_Pn"]
2021 #[inline(always)]
2022 pub fn wupmc17(&mut self) -> Wupmc17W<'_, PmcSpec> {
2023 Wupmc17W::new(self, 17)
2024 }
2025 #[doc = "Bit 18 - Wake-up Pin Mode Configuration for WUU_Pn"]
2026 #[inline(always)]
2027 pub fn wupmc18(&mut self) -> Wupmc18W<'_, PmcSpec> {
2028 Wupmc18W::new(self, 18)
2029 }
2030 #[doc = "Bit 19 - Wake-up Pin Mode Configuration for WUU_Pn"]
2031 #[inline(always)]
2032 pub fn wupmc19(&mut self) -> Wupmc19W<'_, PmcSpec> {
2033 Wupmc19W::new(self, 19)
2034 }
2035 #[doc = "Bit 20 - Wake-up Pin Mode Configuration for WUU_Pn"]
2036 #[inline(always)]
2037 pub fn wupmc20(&mut self) -> Wupmc20W<'_, PmcSpec> {
2038 Wupmc20W::new(self, 20)
2039 }
2040 #[doc = "Bit 21 - Wake-up Pin Mode Configuration for WUU_Pn"]
2041 #[inline(always)]
2042 pub fn wupmc21(&mut self) -> Wupmc21W<'_, PmcSpec> {
2043 Wupmc21W::new(self, 21)
2044 }
2045 #[doc = "Bit 22 - Wake-up Pin Mode Configuration for WUU_Pn"]
2046 #[inline(always)]
2047 pub fn wupmc22(&mut self) -> Wupmc22W<'_, PmcSpec> {
2048 Wupmc22W::new(self, 22)
2049 }
2050 #[doc = "Bit 23 - Wake-up Pin Mode Configuration for WUU_Pn"]
2051 #[inline(always)]
2052 pub fn wupmc23(&mut self) -> Wupmc23W<'_, PmcSpec> {
2053 Wupmc23W::new(self, 23)
2054 }
2055 #[doc = "Bit 24 - Wake-up Pin Mode Configuration for WUU_Pn"]
2056 #[inline(always)]
2057 pub fn wupmc24(&mut self) -> Wupmc24W<'_, PmcSpec> {
2058 Wupmc24W::new(self, 24)
2059 }
2060 #[doc = "Bit 25 - Wake-up Pin Mode Configuration for WUU_Pn"]
2061 #[inline(always)]
2062 pub fn wupmc25(&mut self) -> Wupmc25W<'_, PmcSpec> {
2063 Wupmc25W::new(self, 25)
2064 }
2065 #[doc = "Bit 26 - Wake-up Pin Mode Configuration for WUU_Pn"]
2066 #[inline(always)]
2067 pub fn wupmc26(&mut self) -> Wupmc26W<'_, PmcSpec> {
2068 Wupmc26W::new(self, 26)
2069 }
2070 #[doc = "Bit 27 - Wake-up Pin Mode Configuration for WUU_Pn"]
2071 #[inline(always)]
2072 pub fn wupmc27(&mut self) -> Wupmc27W<'_, PmcSpec> {
2073 Wupmc27W::new(self, 27)
2074 }
2075 #[doc = "Bit 28 - Wake-up Pin Mode Configuration for WUU_Pn"]
2076 #[inline(always)]
2077 pub fn wupmc28(&mut self) -> Wupmc28W<'_, PmcSpec> {
2078 Wupmc28W::new(self, 28)
2079 }
2080 #[doc = "Bit 29 - Wake-up Pin Mode Configuration for WUU_Pn"]
2081 #[inline(always)]
2082 pub fn wupmc29(&mut self) -> Wupmc29W<'_, PmcSpec> {
2083 Wupmc29W::new(self, 29)
2084 }
2085 #[doc = "Bit 30 - Wake-up Pin Mode Configuration for WUU_Pn"]
2086 #[inline(always)]
2087 pub fn wupmc30(&mut self) -> Wupmc30W<'_, PmcSpec> {
2088 Wupmc30W::new(self, 30)
2089 }
2090 #[doc = "Bit 31 - Wake-up Pin Mode Configuration for WUU_Pn"]
2091 #[inline(always)]
2092 pub fn wupmc31(&mut self) -> Wupmc31W<'_, PmcSpec> {
2093 Wupmc31W::new(self, 31)
2094 }
2095}
2096#[doc = "Pin Mode Configuration\n\nYou can [`read`](crate::Reg::read) this register and get [`pmc::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`pmc::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api)."]
2097pub struct PmcSpec;
2098impl crate::RegisterSpec for PmcSpec {
2099 type Ux = u32;
2100}
2101#[doc = "`read()` method returns [`pmc::R`](R) reader structure"]
2102impl crate::Readable for PmcSpec {}
2103#[doc = "`write(|w| ..)` method takes [`pmc::W`](W) writer structure"]
2104impl crate::Writable for PmcSpec {
2105 type Safety = crate::Unsafe;
2106}
2107#[doc = "`reset()` method sets PMC to value 0"]
2108impl crate::Resettable for PmcSpec {}