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