1#[doc = "Register `INTENCLR` reader"]
2pub struct R(crate::R<INTENCLR_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<INTENCLR_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<INTENCLR_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<INTENCLR_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `INTENCLR` writer"]
17pub struct W(crate::W<INTENCLR_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<INTENCLR_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<INTENCLR_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<INTENCLR_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Field `TRIGGERED0` reader - Write '1' to disable interrupt for event TRIGGERED\\[0\\]"]
38pub type TRIGGERED0_R = crate::BitReader<TRIGGERED0_A>;
39#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[0\\]\n\nValue on reset: 0"]
40#[derive(Clone, Copy, Debug, PartialEq)]
41pub enum TRIGGERED0_A {
42 #[doc = "0: Read: Disabled"]
43 DISABLED = 0,
44 #[doc = "1: Read: Enabled"]
45 ENABLED = 1,
46}
47impl From<TRIGGERED0_A> for bool {
48 #[inline(always)]
49 fn from(variant: TRIGGERED0_A) -> Self {
50 variant as u8 != 0
51 }
52}
53impl TRIGGERED0_R {
54 #[doc = "Get enumerated values variant"]
55 #[inline(always)]
56 pub fn variant(&self) -> TRIGGERED0_A {
57 match self.bits {
58 false => TRIGGERED0_A::DISABLED,
59 true => TRIGGERED0_A::ENABLED,
60 }
61 }
62 #[doc = "Checks if the value of the field is `DISABLED`"]
63 #[inline(always)]
64 pub fn is_disabled(&self) -> bool {
65 *self == TRIGGERED0_A::DISABLED
66 }
67 #[doc = "Checks if the value of the field is `ENABLED`"]
68 #[inline(always)]
69 pub fn is_enabled(&self) -> bool {
70 *self == TRIGGERED0_A::ENABLED
71 }
72}
73#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[0\\]\n\nValue on reset: 0"]
74#[derive(Clone, Copy, Debug, PartialEq)]
75pub enum TRIGGERED0_AW {
76 #[doc = "1: Disable"]
77 CLEAR = 1,
78}
79impl From<TRIGGERED0_AW> for bool {
80 #[inline(always)]
81 fn from(variant: TRIGGERED0_AW) -> Self {
82 variant as u8 != 0
83 }
84}
85#[doc = "Field `TRIGGERED0` writer - Write '1' to disable interrupt for event TRIGGERED\\[0\\]"]
86pub type TRIGGERED0_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED0_AW, O>;
87impl<'a, const O: u8> TRIGGERED0_W<'a, O> {
88 #[doc = "Disable"]
89 #[inline(always)]
90 pub fn clear(self) -> &'a mut W {
91 self.variant(TRIGGERED0_AW::CLEAR)
92 }
93}
94#[doc = "Field `TRIGGERED1` reader - Write '1' to disable interrupt for event TRIGGERED\\[1\\]"]
95pub type TRIGGERED1_R = crate::BitReader<TRIGGERED1_A>;
96#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[1\\]\n\nValue on reset: 0"]
97#[derive(Clone, Copy, Debug, PartialEq)]
98pub enum TRIGGERED1_A {
99 #[doc = "0: Read: Disabled"]
100 DISABLED = 0,
101 #[doc = "1: Read: Enabled"]
102 ENABLED = 1,
103}
104impl From<TRIGGERED1_A> for bool {
105 #[inline(always)]
106 fn from(variant: TRIGGERED1_A) -> Self {
107 variant as u8 != 0
108 }
109}
110impl TRIGGERED1_R {
111 #[doc = "Get enumerated values variant"]
112 #[inline(always)]
113 pub fn variant(&self) -> TRIGGERED1_A {
114 match self.bits {
115 false => TRIGGERED1_A::DISABLED,
116 true => TRIGGERED1_A::ENABLED,
117 }
118 }
119 #[doc = "Checks if the value of the field is `DISABLED`"]
120 #[inline(always)]
121 pub fn is_disabled(&self) -> bool {
122 *self == TRIGGERED1_A::DISABLED
123 }
124 #[doc = "Checks if the value of the field is `ENABLED`"]
125 #[inline(always)]
126 pub fn is_enabled(&self) -> bool {
127 *self == TRIGGERED1_A::ENABLED
128 }
129}
130#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[1\\]\n\nValue on reset: 0"]
131#[derive(Clone, Copy, Debug, PartialEq)]
132pub enum TRIGGERED1_AW {
133 #[doc = "1: Disable"]
134 CLEAR = 1,
135}
136impl From<TRIGGERED1_AW> for bool {
137 #[inline(always)]
138 fn from(variant: TRIGGERED1_AW) -> Self {
139 variant as u8 != 0
140 }
141}
142#[doc = "Field `TRIGGERED1` writer - Write '1' to disable interrupt for event TRIGGERED\\[1\\]"]
143pub type TRIGGERED1_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED1_AW, O>;
144impl<'a, const O: u8> TRIGGERED1_W<'a, O> {
145 #[doc = "Disable"]
146 #[inline(always)]
147 pub fn clear(self) -> &'a mut W {
148 self.variant(TRIGGERED1_AW::CLEAR)
149 }
150}
151#[doc = "Field `TRIGGERED2` reader - Write '1' to disable interrupt for event TRIGGERED\\[2\\]"]
152pub type TRIGGERED2_R = crate::BitReader<TRIGGERED2_A>;
153#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[2\\]\n\nValue on reset: 0"]
154#[derive(Clone, Copy, Debug, PartialEq)]
155pub enum TRIGGERED2_A {
156 #[doc = "0: Read: Disabled"]
157 DISABLED = 0,
158 #[doc = "1: Read: Enabled"]
159 ENABLED = 1,
160}
161impl From<TRIGGERED2_A> for bool {
162 #[inline(always)]
163 fn from(variant: TRIGGERED2_A) -> Self {
164 variant as u8 != 0
165 }
166}
167impl TRIGGERED2_R {
168 #[doc = "Get enumerated values variant"]
169 #[inline(always)]
170 pub fn variant(&self) -> TRIGGERED2_A {
171 match self.bits {
172 false => TRIGGERED2_A::DISABLED,
173 true => TRIGGERED2_A::ENABLED,
174 }
175 }
176 #[doc = "Checks if the value of the field is `DISABLED`"]
177 #[inline(always)]
178 pub fn is_disabled(&self) -> bool {
179 *self == TRIGGERED2_A::DISABLED
180 }
181 #[doc = "Checks if the value of the field is `ENABLED`"]
182 #[inline(always)]
183 pub fn is_enabled(&self) -> bool {
184 *self == TRIGGERED2_A::ENABLED
185 }
186}
187#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[2\\]\n\nValue on reset: 0"]
188#[derive(Clone, Copy, Debug, PartialEq)]
189pub enum TRIGGERED2_AW {
190 #[doc = "1: Disable"]
191 CLEAR = 1,
192}
193impl From<TRIGGERED2_AW> for bool {
194 #[inline(always)]
195 fn from(variant: TRIGGERED2_AW) -> Self {
196 variant as u8 != 0
197 }
198}
199#[doc = "Field `TRIGGERED2` writer - Write '1' to disable interrupt for event TRIGGERED\\[2\\]"]
200pub type TRIGGERED2_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED2_AW, O>;
201impl<'a, const O: u8> TRIGGERED2_W<'a, O> {
202 #[doc = "Disable"]
203 #[inline(always)]
204 pub fn clear(self) -> &'a mut W {
205 self.variant(TRIGGERED2_AW::CLEAR)
206 }
207}
208#[doc = "Field `TRIGGERED3` reader - Write '1' to disable interrupt for event TRIGGERED\\[3\\]"]
209pub type TRIGGERED3_R = crate::BitReader<TRIGGERED3_A>;
210#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[3\\]\n\nValue on reset: 0"]
211#[derive(Clone, Copy, Debug, PartialEq)]
212pub enum TRIGGERED3_A {
213 #[doc = "0: Read: Disabled"]
214 DISABLED = 0,
215 #[doc = "1: Read: Enabled"]
216 ENABLED = 1,
217}
218impl From<TRIGGERED3_A> for bool {
219 #[inline(always)]
220 fn from(variant: TRIGGERED3_A) -> Self {
221 variant as u8 != 0
222 }
223}
224impl TRIGGERED3_R {
225 #[doc = "Get enumerated values variant"]
226 #[inline(always)]
227 pub fn variant(&self) -> TRIGGERED3_A {
228 match self.bits {
229 false => TRIGGERED3_A::DISABLED,
230 true => TRIGGERED3_A::ENABLED,
231 }
232 }
233 #[doc = "Checks if the value of the field is `DISABLED`"]
234 #[inline(always)]
235 pub fn is_disabled(&self) -> bool {
236 *self == TRIGGERED3_A::DISABLED
237 }
238 #[doc = "Checks if the value of the field is `ENABLED`"]
239 #[inline(always)]
240 pub fn is_enabled(&self) -> bool {
241 *self == TRIGGERED3_A::ENABLED
242 }
243}
244#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[3\\]\n\nValue on reset: 0"]
245#[derive(Clone, Copy, Debug, PartialEq)]
246pub enum TRIGGERED3_AW {
247 #[doc = "1: Disable"]
248 CLEAR = 1,
249}
250impl From<TRIGGERED3_AW> for bool {
251 #[inline(always)]
252 fn from(variant: TRIGGERED3_AW) -> Self {
253 variant as u8 != 0
254 }
255}
256#[doc = "Field `TRIGGERED3` writer - Write '1' to disable interrupt for event TRIGGERED\\[3\\]"]
257pub type TRIGGERED3_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED3_AW, O>;
258impl<'a, const O: u8> TRIGGERED3_W<'a, O> {
259 #[doc = "Disable"]
260 #[inline(always)]
261 pub fn clear(self) -> &'a mut W {
262 self.variant(TRIGGERED3_AW::CLEAR)
263 }
264}
265#[doc = "Field `TRIGGERED4` reader - Write '1' to disable interrupt for event TRIGGERED\\[4\\]"]
266pub type TRIGGERED4_R = crate::BitReader<TRIGGERED4_A>;
267#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[4\\]\n\nValue on reset: 0"]
268#[derive(Clone, Copy, Debug, PartialEq)]
269pub enum TRIGGERED4_A {
270 #[doc = "0: Read: Disabled"]
271 DISABLED = 0,
272 #[doc = "1: Read: Enabled"]
273 ENABLED = 1,
274}
275impl From<TRIGGERED4_A> for bool {
276 #[inline(always)]
277 fn from(variant: TRIGGERED4_A) -> Self {
278 variant as u8 != 0
279 }
280}
281impl TRIGGERED4_R {
282 #[doc = "Get enumerated values variant"]
283 #[inline(always)]
284 pub fn variant(&self) -> TRIGGERED4_A {
285 match self.bits {
286 false => TRIGGERED4_A::DISABLED,
287 true => TRIGGERED4_A::ENABLED,
288 }
289 }
290 #[doc = "Checks if the value of the field is `DISABLED`"]
291 #[inline(always)]
292 pub fn is_disabled(&self) -> bool {
293 *self == TRIGGERED4_A::DISABLED
294 }
295 #[doc = "Checks if the value of the field is `ENABLED`"]
296 #[inline(always)]
297 pub fn is_enabled(&self) -> bool {
298 *self == TRIGGERED4_A::ENABLED
299 }
300}
301#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[4\\]\n\nValue on reset: 0"]
302#[derive(Clone, Copy, Debug, PartialEq)]
303pub enum TRIGGERED4_AW {
304 #[doc = "1: Disable"]
305 CLEAR = 1,
306}
307impl From<TRIGGERED4_AW> for bool {
308 #[inline(always)]
309 fn from(variant: TRIGGERED4_AW) -> Self {
310 variant as u8 != 0
311 }
312}
313#[doc = "Field `TRIGGERED4` writer - Write '1' to disable interrupt for event TRIGGERED\\[4\\]"]
314pub type TRIGGERED4_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED4_AW, O>;
315impl<'a, const O: u8> TRIGGERED4_W<'a, O> {
316 #[doc = "Disable"]
317 #[inline(always)]
318 pub fn clear(self) -> &'a mut W {
319 self.variant(TRIGGERED4_AW::CLEAR)
320 }
321}
322#[doc = "Field `TRIGGERED5` reader - Write '1' to disable interrupt for event TRIGGERED\\[5\\]"]
323pub type TRIGGERED5_R = crate::BitReader<TRIGGERED5_A>;
324#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[5\\]\n\nValue on reset: 0"]
325#[derive(Clone, Copy, Debug, PartialEq)]
326pub enum TRIGGERED5_A {
327 #[doc = "0: Read: Disabled"]
328 DISABLED = 0,
329 #[doc = "1: Read: Enabled"]
330 ENABLED = 1,
331}
332impl From<TRIGGERED5_A> for bool {
333 #[inline(always)]
334 fn from(variant: TRIGGERED5_A) -> Self {
335 variant as u8 != 0
336 }
337}
338impl TRIGGERED5_R {
339 #[doc = "Get enumerated values variant"]
340 #[inline(always)]
341 pub fn variant(&self) -> TRIGGERED5_A {
342 match self.bits {
343 false => TRIGGERED5_A::DISABLED,
344 true => TRIGGERED5_A::ENABLED,
345 }
346 }
347 #[doc = "Checks if the value of the field is `DISABLED`"]
348 #[inline(always)]
349 pub fn is_disabled(&self) -> bool {
350 *self == TRIGGERED5_A::DISABLED
351 }
352 #[doc = "Checks if the value of the field is `ENABLED`"]
353 #[inline(always)]
354 pub fn is_enabled(&self) -> bool {
355 *self == TRIGGERED5_A::ENABLED
356 }
357}
358#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[5\\]\n\nValue on reset: 0"]
359#[derive(Clone, Copy, Debug, PartialEq)]
360pub enum TRIGGERED5_AW {
361 #[doc = "1: Disable"]
362 CLEAR = 1,
363}
364impl From<TRIGGERED5_AW> for bool {
365 #[inline(always)]
366 fn from(variant: TRIGGERED5_AW) -> Self {
367 variant as u8 != 0
368 }
369}
370#[doc = "Field `TRIGGERED5` writer - Write '1' to disable interrupt for event TRIGGERED\\[5\\]"]
371pub type TRIGGERED5_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED5_AW, O>;
372impl<'a, const O: u8> TRIGGERED5_W<'a, O> {
373 #[doc = "Disable"]
374 #[inline(always)]
375 pub fn clear(self) -> &'a mut W {
376 self.variant(TRIGGERED5_AW::CLEAR)
377 }
378}
379#[doc = "Field `TRIGGERED6` reader - Write '1' to disable interrupt for event TRIGGERED\\[6\\]"]
380pub type TRIGGERED6_R = crate::BitReader<TRIGGERED6_A>;
381#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[6\\]\n\nValue on reset: 0"]
382#[derive(Clone, Copy, Debug, PartialEq)]
383pub enum TRIGGERED6_A {
384 #[doc = "0: Read: Disabled"]
385 DISABLED = 0,
386 #[doc = "1: Read: Enabled"]
387 ENABLED = 1,
388}
389impl From<TRIGGERED6_A> for bool {
390 #[inline(always)]
391 fn from(variant: TRIGGERED6_A) -> Self {
392 variant as u8 != 0
393 }
394}
395impl TRIGGERED6_R {
396 #[doc = "Get enumerated values variant"]
397 #[inline(always)]
398 pub fn variant(&self) -> TRIGGERED6_A {
399 match self.bits {
400 false => TRIGGERED6_A::DISABLED,
401 true => TRIGGERED6_A::ENABLED,
402 }
403 }
404 #[doc = "Checks if the value of the field is `DISABLED`"]
405 #[inline(always)]
406 pub fn is_disabled(&self) -> bool {
407 *self == TRIGGERED6_A::DISABLED
408 }
409 #[doc = "Checks if the value of the field is `ENABLED`"]
410 #[inline(always)]
411 pub fn is_enabled(&self) -> bool {
412 *self == TRIGGERED6_A::ENABLED
413 }
414}
415#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[6\\]\n\nValue on reset: 0"]
416#[derive(Clone, Copy, Debug, PartialEq)]
417pub enum TRIGGERED6_AW {
418 #[doc = "1: Disable"]
419 CLEAR = 1,
420}
421impl From<TRIGGERED6_AW> for bool {
422 #[inline(always)]
423 fn from(variant: TRIGGERED6_AW) -> Self {
424 variant as u8 != 0
425 }
426}
427#[doc = "Field `TRIGGERED6` writer - Write '1' to disable interrupt for event TRIGGERED\\[6\\]"]
428pub type TRIGGERED6_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED6_AW, O>;
429impl<'a, const O: u8> TRIGGERED6_W<'a, O> {
430 #[doc = "Disable"]
431 #[inline(always)]
432 pub fn clear(self) -> &'a mut W {
433 self.variant(TRIGGERED6_AW::CLEAR)
434 }
435}
436#[doc = "Field `TRIGGERED7` reader - Write '1' to disable interrupt for event TRIGGERED\\[7\\]"]
437pub type TRIGGERED7_R = crate::BitReader<TRIGGERED7_A>;
438#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[7\\]\n\nValue on reset: 0"]
439#[derive(Clone, Copy, Debug, PartialEq)]
440pub enum TRIGGERED7_A {
441 #[doc = "0: Read: Disabled"]
442 DISABLED = 0,
443 #[doc = "1: Read: Enabled"]
444 ENABLED = 1,
445}
446impl From<TRIGGERED7_A> for bool {
447 #[inline(always)]
448 fn from(variant: TRIGGERED7_A) -> Self {
449 variant as u8 != 0
450 }
451}
452impl TRIGGERED7_R {
453 #[doc = "Get enumerated values variant"]
454 #[inline(always)]
455 pub fn variant(&self) -> TRIGGERED7_A {
456 match self.bits {
457 false => TRIGGERED7_A::DISABLED,
458 true => TRIGGERED7_A::ENABLED,
459 }
460 }
461 #[doc = "Checks if the value of the field is `DISABLED`"]
462 #[inline(always)]
463 pub fn is_disabled(&self) -> bool {
464 *self == TRIGGERED7_A::DISABLED
465 }
466 #[doc = "Checks if the value of the field is `ENABLED`"]
467 #[inline(always)]
468 pub fn is_enabled(&self) -> bool {
469 *self == TRIGGERED7_A::ENABLED
470 }
471}
472#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[7\\]\n\nValue on reset: 0"]
473#[derive(Clone, Copy, Debug, PartialEq)]
474pub enum TRIGGERED7_AW {
475 #[doc = "1: Disable"]
476 CLEAR = 1,
477}
478impl From<TRIGGERED7_AW> for bool {
479 #[inline(always)]
480 fn from(variant: TRIGGERED7_AW) -> Self {
481 variant as u8 != 0
482 }
483}
484#[doc = "Field `TRIGGERED7` writer - Write '1' to disable interrupt for event TRIGGERED\\[7\\]"]
485pub type TRIGGERED7_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED7_AW, O>;
486impl<'a, const O: u8> TRIGGERED7_W<'a, O> {
487 #[doc = "Disable"]
488 #[inline(always)]
489 pub fn clear(self) -> &'a mut W {
490 self.variant(TRIGGERED7_AW::CLEAR)
491 }
492}
493#[doc = "Field `TRIGGERED8` reader - Write '1' to disable interrupt for event TRIGGERED\\[8\\]"]
494pub type TRIGGERED8_R = crate::BitReader<TRIGGERED8_A>;
495#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[8\\]\n\nValue on reset: 0"]
496#[derive(Clone, Copy, Debug, PartialEq)]
497pub enum TRIGGERED8_A {
498 #[doc = "0: Read: Disabled"]
499 DISABLED = 0,
500 #[doc = "1: Read: Enabled"]
501 ENABLED = 1,
502}
503impl From<TRIGGERED8_A> for bool {
504 #[inline(always)]
505 fn from(variant: TRIGGERED8_A) -> Self {
506 variant as u8 != 0
507 }
508}
509impl TRIGGERED8_R {
510 #[doc = "Get enumerated values variant"]
511 #[inline(always)]
512 pub fn variant(&self) -> TRIGGERED8_A {
513 match self.bits {
514 false => TRIGGERED8_A::DISABLED,
515 true => TRIGGERED8_A::ENABLED,
516 }
517 }
518 #[doc = "Checks if the value of the field is `DISABLED`"]
519 #[inline(always)]
520 pub fn is_disabled(&self) -> bool {
521 *self == TRIGGERED8_A::DISABLED
522 }
523 #[doc = "Checks if the value of the field is `ENABLED`"]
524 #[inline(always)]
525 pub fn is_enabled(&self) -> bool {
526 *self == TRIGGERED8_A::ENABLED
527 }
528}
529#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[8\\]\n\nValue on reset: 0"]
530#[derive(Clone, Copy, Debug, PartialEq)]
531pub enum TRIGGERED8_AW {
532 #[doc = "1: Disable"]
533 CLEAR = 1,
534}
535impl From<TRIGGERED8_AW> for bool {
536 #[inline(always)]
537 fn from(variant: TRIGGERED8_AW) -> Self {
538 variant as u8 != 0
539 }
540}
541#[doc = "Field `TRIGGERED8` writer - Write '1' to disable interrupt for event TRIGGERED\\[8\\]"]
542pub type TRIGGERED8_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED8_AW, O>;
543impl<'a, const O: u8> TRIGGERED8_W<'a, O> {
544 #[doc = "Disable"]
545 #[inline(always)]
546 pub fn clear(self) -> &'a mut W {
547 self.variant(TRIGGERED8_AW::CLEAR)
548 }
549}
550#[doc = "Field `TRIGGERED9` reader - Write '1' to disable interrupt for event TRIGGERED\\[9\\]"]
551pub type TRIGGERED9_R = crate::BitReader<TRIGGERED9_A>;
552#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[9\\]\n\nValue on reset: 0"]
553#[derive(Clone, Copy, Debug, PartialEq)]
554pub enum TRIGGERED9_A {
555 #[doc = "0: Read: Disabled"]
556 DISABLED = 0,
557 #[doc = "1: Read: Enabled"]
558 ENABLED = 1,
559}
560impl From<TRIGGERED9_A> for bool {
561 #[inline(always)]
562 fn from(variant: TRIGGERED9_A) -> Self {
563 variant as u8 != 0
564 }
565}
566impl TRIGGERED9_R {
567 #[doc = "Get enumerated values variant"]
568 #[inline(always)]
569 pub fn variant(&self) -> TRIGGERED9_A {
570 match self.bits {
571 false => TRIGGERED9_A::DISABLED,
572 true => TRIGGERED9_A::ENABLED,
573 }
574 }
575 #[doc = "Checks if the value of the field is `DISABLED`"]
576 #[inline(always)]
577 pub fn is_disabled(&self) -> bool {
578 *self == TRIGGERED9_A::DISABLED
579 }
580 #[doc = "Checks if the value of the field is `ENABLED`"]
581 #[inline(always)]
582 pub fn is_enabled(&self) -> bool {
583 *self == TRIGGERED9_A::ENABLED
584 }
585}
586#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[9\\]\n\nValue on reset: 0"]
587#[derive(Clone, Copy, Debug, PartialEq)]
588pub enum TRIGGERED9_AW {
589 #[doc = "1: Disable"]
590 CLEAR = 1,
591}
592impl From<TRIGGERED9_AW> for bool {
593 #[inline(always)]
594 fn from(variant: TRIGGERED9_AW) -> Self {
595 variant as u8 != 0
596 }
597}
598#[doc = "Field `TRIGGERED9` writer - Write '1' to disable interrupt for event TRIGGERED\\[9\\]"]
599pub type TRIGGERED9_W<'a, const O: u8> = crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED9_AW, O>;
600impl<'a, const O: u8> TRIGGERED9_W<'a, O> {
601 #[doc = "Disable"]
602 #[inline(always)]
603 pub fn clear(self) -> &'a mut W {
604 self.variant(TRIGGERED9_AW::CLEAR)
605 }
606}
607#[doc = "Field `TRIGGERED10` reader - Write '1' to disable interrupt for event TRIGGERED\\[10\\]"]
608pub type TRIGGERED10_R = crate::BitReader<TRIGGERED10_A>;
609#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[10\\]\n\nValue on reset: 0"]
610#[derive(Clone, Copy, Debug, PartialEq)]
611pub enum TRIGGERED10_A {
612 #[doc = "0: Read: Disabled"]
613 DISABLED = 0,
614 #[doc = "1: Read: Enabled"]
615 ENABLED = 1,
616}
617impl From<TRIGGERED10_A> for bool {
618 #[inline(always)]
619 fn from(variant: TRIGGERED10_A) -> Self {
620 variant as u8 != 0
621 }
622}
623impl TRIGGERED10_R {
624 #[doc = "Get enumerated values variant"]
625 #[inline(always)]
626 pub fn variant(&self) -> TRIGGERED10_A {
627 match self.bits {
628 false => TRIGGERED10_A::DISABLED,
629 true => TRIGGERED10_A::ENABLED,
630 }
631 }
632 #[doc = "Checks if the value of the field is `DISABLED`"]
633 #[inline(always)]
634 pub fn is_disabled(&self) -> bool {
635 *self == TRIGGERED10_A::DISABLED
636 }
637 #[doc = "Checks if the value of the field is `ENABLED`"]
638 #[inline(always)]
639 pub fn is_enabled(&self) -> bool {
640 *self == TRIGGERED10_A::ENABLED
641 }
642}
643#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[10\\]\n\nValue on reset: 0"]
644#[derive(Clone, Copy, Debug, PartialEq)]
645pub enum TRIGGERED10_AW {
646 #[doc = "1: Disable"]
647 CLEAR = 1,
648}
649impl From<TRIGGERED10_AW> for bool {
650 #[inline(always)]
651 fn from(variant: TRIGGERED10_AW) -> Self {
652 variant as u8 != 0
653 }
654}
655#[doc = "Field `TRIGGERED10` writer - Write '1' to disable interrupt for event TRIGGERED\\[10\\]"]
656pub type TRIGGERED10_W<'a, const O: u8> =
657 crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED10_AW, O>;
658impl<'a, const O: u8> TRIGGERED10_W<'a, O> {
659 #[doc = "Disable"]
660 #[inline(always)]
661 pub fn clear(self) -> &'a mut W {
662 self.variant(TRIGGERED10_AW::CLEAR)
663 }
664}
665#[doc = "Field `TRIGGERED11` reader - Write '1' to disable interrupt for event TRIGGERED\\[11\\]"]
666pub type TRIGGERED11_R = crate::BitReader<TRIGGERED11_A>;
667#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[11\\]\n\nValue on reset: 0"]
668#[derive(Clone, Copy, Debug, PartialEq)]
669pub enum TRIGGERED11_A {
670 #[doc = "0: Read: Disabled"]
671 DISABLED = 0,
672 #[doc = "1: Read: Enabled"]
673 ENABLED = 1,
674}
675impl From<TRIGGERED11_A> for bool {
676 #[inline(always)]
677 fn from(variant: TRIGGERED11_A) -> Self {
678 variant as u8 != 0
679 }
680}
681impl TRIGGERED11_R {
682 #[doc = "Get enumerated values variant"]
683 #[inline(always)]
684 pub fn variant(&self) -> TRIGGERED11_A {
685 match self.bits {
686 false => TRIGGERED11_A::DISABLED,
687 true => TRIGGERED11_A::ENABLED,
688 }
689 }
690 #[doc = "Checks if the value of the field is `DISABLED`"]
691 #[inline(always)]
692 pub fn is_disabled(&self) -> bool {
693 *self == TRIGGERED11_A::DISABLED
694 }
695 #[doc = "Checks if the value of the field is `ENABLED`"]
696 #[inline(always)]
697 pub fn is_enabled(&self) -> bool {
698 *self == TRIGGERED11_A::ENABLED
699 }
700}
701#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[11\\]\n\nValue on reset: 0"]
702#[derive(Clone, Copy, Debug, PartialEq)]
703pub enum TRIGGERED11_AW {
704 #[doc = "1: Disable"]
705 CLEAR = 1,
706}
707impl From<TRIGGERED11_AW> for bool {
708 #[inline(always)]
709 fn from(variant: TRIGGERED11_AW) -> Self {
710 variant as u8 != 0
711 }
712}
713#[doc = "Field `TRIGGERED11` writer - Write '1' to disable interrupt for event TRIGGERED\\[11\\]"]
714pub type TRIGGERED11_W<'a, const O: u8> =
715 crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED11_AW, O>;
716impl<'a, const O: u8> TRIGGERED11_W<'a, O> {
717 #[doc = "Disable"]
718 #[inline(always)]
719 pub fn clear(self) -> &'a mut W {
720 self.variant(TRIGGERED11_AW::CLEAR)
721 }
722}
723#[doc = "Field `TRIGGERED12` reader - Write '1' to disable interrupt for event TRIGGERED\\[12\\]"]
724pub type TRIGGERED12_R = crate::BitReader<TRIGGERED12_A>;
725#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[12\\]\n\nValue on reset: 0"]
726#[derive(Clone, Copy, Debug, PartialEq)]
727pub enum TRIGGERED12_A {
728 #[doc = "0: Read: Disabled"]
729 DISABLED = 0,
730 #[doc = "1: Read: Enabled"]
731 ENABLED = 1,
732}
733impl From<TRIGGERED12_A> for bool {
734 #[inline(always)]
735 fn from(variant: TRIGGERED12_A) -> Self {
736 variant as u8 != 0
737 }
738}
739impl TRIGGERED12_R {
740 #[doc = "Get enumerated values variant"]
741 #[inline(always)]
742 pub fn variant(&self) -> TRIGGERED12_A {
743 match self.bits {
744 false => TRIGGERED12_A::DISABLED,
745 true => TRIGGERED12_A::ENABLED,
746 }
747 }
748 #[doc = "Checks if the value of the field is `DISABLED`"]
749 #[inline(always)]
750 pub fn is_disabled(&self) -> bool {
751 *self == TRIGGERED12_A::DISABLED
752 }
753 #[doc = "Checks if the value of the field is `ENABLED`"]
754 #[inline(always)]
755 pub fn is_enabled(&self) -> bool {
756 *self == TRIGGERED12_A::ENABLED
757 }
758}
759#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[12\\]\n\nValue on reset: 0"]
760#[derive(Clone, Copy, Debug, PartialEq)]
761pub enum TRIGGERED12_AW {
762 #[doc = "1: Disable"]
763 CLEAR = 1,
764}
765impl From<TRIGGERED12_AW> for bool {
766 #[inline(always)]
767 fn from(variant: TRIGGERED12_AW) -> Self {
768 variant as u8 != 0
769 }
770}
771#[doc = "Field `TRIGGERED12` writer - Write '1' to disable interrupt for event TRIGGERED\\[12\\]"]
772pub type TRIGGERED12_W<'a, const O: u8> =
773 crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED12_AW, O>;
774impl<'a, const O: u8> TRIGGERED12_W<'a, O> {
775 #[doc = "Disable"]
776 #[inline(always)]
777 pub fn clear(self) -> &'a mut W {
778 self.variant(TRIGGERED12_AW::CLEAR)
779 }
780}
781#[doc = "Field `TRIGGERED13` reader - Write '1' to disable interrupt for event TRIGGERED\\[13\\]"]
782pub type TRIGGERED13_R = crate::BitReader<TRIGGERED13_A>;
783#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[13\\]\n\nValue on reset: 0"]
784#[derive(Clone, Copy, Debug, PartialEq)]
785pub enum TRIGGERED13_A {
786 #[doc = "0: Read: Disabled"]
787 DISABLED = 0,
788 #[doc = "1: Read: Enabled"]
789 ENABLED = 1,
790}
791impl From<TRIGGERED13_A> for bool {
792 #[inline(always)]
793 fn from(variant: TRIGGERED13_A) -> Self {
794 variant as u8 != 0
795 }
796}
797impl TRIGGERED13_R {
798 #[doc = "Get enumerated values variant"]
799 #[inline(always)]
800 pub fn variant(&self) -> TRIGGERED13_A {
801 match self.bits {
802 false => TRIGGERED13_A::DISABLED,
803 true => TRIGGERED13_A::ENABLED,
804 }
805 }
806 #[doc = "Checks if the value of the field is `DISABLED`"]
807 #[inline(always)]
808 pub fn is_disabled(&self) -> bool {
809 *self == TRIGGERED13_A::DISABLED
810 }
811 #[doc = "Checks if the value of the field is `ENABLED`"]
812 #[inline(always)]
813 pub fn is_enabled(&self) -> bool {
814 *self == TRIGGERED13_A::ENABLED
815 }
816}
817#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[13\\]\n\nValue on reset: 0"]
818#[derive(Clone, Copy, Debug, PartialEq)]
819pub enum TRIGGERED13_AW {
820 #[doc = "1: Disable"]
821 CLEAR = 1,
822}
823impl From<TRIGGERED13_AW> for bool {
824 #[inline(always)]
825 fn from(variant: TRIGGERED13_AW) -> Self {
826 variant as u8 != 0
827 }
828}
829#[doc = "Field `TRIGGERED13` writer - Write '1' to disable interrupt for event TRIGGERED\\[13\\]"]
830pub type TRIGGERED13_W<'a, const O: u8> =
831 crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED13_AW, O>;
832impl<'a, const O: u8> TRIGGERED13_W<'a, O> {
833 #[doc = "Disable"]
834 #[inline(always)]
835 pub fn clear(self) -> &'a mut W {
836 self.variant(TRIGGERED13_AW::CLEAR)
837 }
838}
839#[doc = "Field `TRIGGERED14` reader - Write '1' to disable interrupt for event TRIGGERED\\[14\\]"]
840pub type TRIGGERED14_R = crate::BitReader<TRIGGERED14_A>;
841#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[14\\]\n\nValue on reset: 0"]
842#[derive(Clone, Copy, Debug, PartialEq)]
843pub enum TRIGGERED14_A {
844 #[doc = "0: Read: Disabled"]
845 DISABLED = 0,
846 #[doc = "1: Read: Enabled"]
847 ENABLED = 1,
848}
849impl From<TRIGGERED14_A> for bool {
850 #[inline(always)]
851 fn from(variant: TRIGGERED14_A) -> Self {
852 variant as u8 != 0
853 }
854}
855impl TRIGGERED14_R {
856 #[doc = "Get enumerated values variant"]
857 #[inline(always)]
858 pub fn variant(&self) -> TRIGGERED14_A {
859 match self.bits {
860 false => TRIGGERED14_A::DISABLED,
861 true => TRIGGERED14_A::ENABLED,
862 }
863 }
864 #[doc = "Checks if the value of the field is `DISABLED`"]
865 #[inline(always)]
866 pub fn is_disabled(&self) -> bool {
867 *self == TRIGGERED14_A::DISABLED
868 }
869 #[doc = "Checks if the value of the field is `ENABLED`"]
870 #[inline(always)]
871 pub fn is_enabled(&self) -> bool {
872 *self == TRIGGERED14_A::ENABLED
873 }
874}
875#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[14\\]\n\nValue on reset: 0"]
876#[derive(Clone, Copy, Debug, PartialEq)]
877pub enum TRIGGERED14_AW {
878 #[doc = "1: Disable"]
879 CLEAR = 1,
880}
881impl From<TRIGGERED14_AW> for bool {
882 #[inline(always)]
883 fn from(variant: TRIGGERED14_AW) -> Self {
884 variant as u8 != 0
885 }
886}
887#[doc = "Field `TRIGGERED14` writer - Write '1' to disable interrupt for event TRIGGERED\\[14\\]"]
888pub type TRIGGERED14_W<'a, const O: u8> =
889 crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED14_AW, O>;
890impl<'a, const O: u8> TRIGGERED14_W<'a, O> {
891 #[doc = "Disable"]
892 #[inline(always)]
893 pub fn clear(self) -> &'a mut W {
894 self.variant(TRIGGERED14_AW::CLEAR)
895 }
896}
897#[doc = "Field `TRIGGERED15` reader - Write '1' to disable interrupt for event TRIGGERED\\[15\\]"]
898pub type TRIGGERED15_R = crate::BitReader<TRIGGERED15_A>;
899#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[15\\]\n\nValue on reset: 0"]
900#[derive(Clone, Copy, Debug, PartialEq)]
901pub enum TRIGGERED15_A {
902 #[doc = "0: Read: Disabled"]
903 DISABLED = 0,
904 #[doc = "1: Read: Enabled"]
905 ENABLED = 1,
906}
907impl From<TRIGGERED15_A> for bool {
908 #[inline(always)]
909 fn from(variant: TRIGGERED15_A) -> Self {
910 variant as u8 != 0
911 }
912}
913impl TRIGGERED15_R {
914 #[doc = "Get enumerated values variant"]
915 #[inline(always)]
916 pub fn variant(&self) -> TRIGGERED15_A {
917 match self.bits {
918 false => TRIGGERED15_A::DISABLED,
919 true => TRIGGERED15_A::ENABLED,
920 }
921 }
922 #[doc = "Checks if the value of the field is `DISABLED`"]
923 #[inline(always)]
924 pub fn is_disabled(&self) -> bool {
925 *self == TRIGGERED15_A::DISABLED
926 }
927 #[doc = "Checks if the value of the field is `ENABLED`"]
928 #[inline(always)]
929 pub fn is_enabled(&self) -> bool {
930 *self == TRIGGERED15_A::ENABLED
931 }
932}
933#[doc = "Write '1' to disable interrupt for event TRIGGERED\\[15\\]\n\nValue on reset: 0"]
934#[derive(Clone, Copy, Debug, PartialEq)]
935pub enum TRIGGERED15_AW {
936 #[doc = "1: Disable"]
937 CLEAR = 1,
938}
939impl From<TRIGGERED15_AW> for bool {
940 #[inline(always)]
941 fn from(variant: TRIGGERED15_AW) -> Self {
942 variant as u8 != 0
943 }
944}
945#[doc = "Field `TRIGGERED15` writer - Write '1' to disable interrupt for event TRIGGERED\\[15\\]"]
946pub type TRIGGERED15_W<'a, const O: u8> =
947 crate::BitWriter<'a, u32, INTENCLR_SPEC, TRIGGERED15_AW, O>;
948impl<'a, const O: u8> TRIGGERED15_W<'a, O> {
949 #[doc = "Disable"]
950 #[inline(always)]
951 pub fn clear(self) -> &'a mut W {
952 self.variant(TRIGGERED15_AW::CLEAR)
953 }
954}
955impl R {
956 #[doc = "Bit 0 - Write '1' to disable interrupt for event TRIGGERED\\[0\\]"]
957 #[inline(always)]
958 pub fn triggered0(&self) -> TRIGGERED0_R {
959 TRIGGERED0_R::new((self.bits & 1) != 0)
960 }
961 #[doc = "Bit 1 - Write '1' to disable interrupt for event TRIGGERED\\[1\\]"]
962 #[inline(always)]
963 pub fn triggered1(&self) -> TRIGGERED1_R {
964 TRIGGERED1_R::new(((self.bits >> 1) & 1) != 0)
965 }
966 #[doc = "Bit 2 - Write '1' to disable interrupt for event TRIGGERED\\[2\\]"]
967 #[inline(always)]
968 pub fn triggered2(&self) -> TRIGGERED2_R {
969 TRIGGERED2_R::new(((self.bits >> 2) & 1) != 0)
970 }
971 #[doc = "Bit 3 - Write '1' to disable interrupt for event TRIGGERED\\[3\\]"]
972 #[inline(always)]
973 pub fn triggered3(&self) -> TRIGGERED3_R {
974 TRIGGERED3_R::new(((self.bits >> 3) & 1) != 0)
975 }
976 #[doc = "Bit 4 - Write '1' to disable interrupt for event TRIGGERED\\[4\\]"]
977 #[inline(always)]
978 pub fn triggered4(&self) -> TRIGGERED4_R {
979 TRIGGERED4_R::new(((self.bits >> 4) & 1) != 0)
980 }
981 #[doc = "Bit 5 - Write '1' to disable interrupt for event TRIGGERED\\[5\\]"]
982 #[inline(always)]
983 pub fn triggered5(&self) -> TRIGGERED5_R {
984 TRIGGERED5_R::new(((self.bits >> 5) & 1) != 0)
985 }
986 #[doc = "Bit 6 - Write '1' to disable interrupt for event TRIGGERED\\[6\\]"]
987 #[inline(always)]
988 pub fn triggered6(&self) -> TRIGGERED6_R {
989 TRIGGERED6_R::new(((self.bits >> 6) & 1) != 0)
990 }
991 #[doc = "Bit 7 - Write '1' to disable interrupt for event TRIGGERED\\[7\\]"]
992 #[inline(always)]
993 pub fn triggered7(&self) -> TRIGGERED7_R {
994 TRIGGERED7_R::new(((self.bits >> 7) & 1) != 0)
995 }
996 #[doc = "Bit 8 - Write '1' to disable interrupt for event TRIGGERED\\[8\\]"]
997 #[inline(always)]
998 pub fn triggered8(&self) -> TRIGGERED8_R {
999 TRIGGERED8_R::new(((self.bits >> 8) & 1) != 0)
1000 }
1001 #[doc = "Bit 9 - Write '1' to disable interrupt for event TRIGGERED\\[9\\]"]
1002 #[inline(always)]
1003 pub fn triggered9(&self) -> TRIGGERED9_R {
1004 TRIGGERED9_R::new(((self.bits >> 9) & 1) != 0)
1005 }
1006 #[doc = "Bit 10 - Write '1' to disable interrupt for event TRIGGERED\\[10\\]"]
1007 #[inline(always)]
1008 pub fn triggered10(&self) -> TRIGGERED10_R {
1009 TRIGGERED10_R::new(((self.bits >> 10) & 1) != 0)
1010 }
1011 #[doc = "Bit 11 - Write '1' to disable interrupt for event TRIGGERED\\[11\\]"]
1012 #[inline(always)]
1013 pub fn triggered11(&self) -> TRIGGERED11_R {
1014 TRIGGERED11_R::new(((self.bits >> 11) & 1) != 0)
1015 }
1016 #[doc = "Bit 12 - Write '1' to disable interrupt for event TRIGGERED\\[12\\]"]
1017 #[inline(always)]
1018 pub fn triggered12(&self) -> TRIGGERED12_R {
1019 TRIGGERED12_R::new(((self.bits >> 12) & 1) != 0)
1020 }
1021 #[doc = "Bit 13 - Write '1' to disable interrupt for event TRIGGERED\\[13\\]"]
1022 #[inline(always)]
1023 pub fn triggered13(&self) -> TRIGGERED13_R {
1024 TRIGGERED13_R::new(((self.bits >> 13) & 1) != 0)
1025 }
1026 #[doc = "Bit 14 - Write '1' to disable interrupt for event TRIGGERED\\[14\\]"]
1027 #[inline(always)]
1028 pub fn triggered14(&self) -> TRIGGERED14_R {
1029 TRIGGERED14_R::new(((self.bits >> 14) & 1) != 0)
1030 }
1031 #[doc = "Bit 15 - Write '1' to disable interrupt for event TRIGGERED\\[15\\]"]
1032 #[inline(always)]
1033 pub fn triggered15(&self) -> TRIGGERED15_R {
1034 TRIGGERED15_R::new(((self.bits >> 15) & 1) != 0)
1035 }
1036}
1037impl W {
1038 #[doc = "Bit 0 - Write '1' to disable interrupt for event TRIGGERED\\[0\\]"]
1039 #[inline(always)]
1040 pub fn triggered0(&mut self) -> TRIGGERED0_W<0> {
1041 TRIGGERED0_W::new(self)
1042 }
1043 #[doc = "Bit 1 - Write '1' to disable interrupt for event TRIGGERED\\[1\\]"]
1044 #[inline(always)]
1045 pub fn triggered1(&mut self) -> TRIGGERED1_W<1> {
1046 TRIGGERED1_W::new(self)
1047 }
1048 #[doc = "Bit 2 - Write '1' to disable interrupt for event TRIGGERED\\[2\\]"]
1049 #[inline(always)]
1050 pub fn triggered2(&mut self) -> TRIGGERED2_W<2> {
1051 TRIGGERED2_W::new(self)
1052 }
1053 #[doc = "Bit 3 - Write '1' to disable interrupt for event TRIGGERED\\[3\\]"]
1054 #[inline(always)]
1055 pub fn triggered3(&mut self) -> TRIGGERED3_W<3> {
1056 TRIGGERED3_W::new(self)
1057 }
1058 #[doc = "Bit 4 - Write '1' to disable interrupt for event TRIGGERED\\[4\\]"]
1059 #[inline(always)]
1060 pub fn triggered4(&mut self) -> TRIGGERED4_W<4> {
1061 TRIGGERED4_W::new(self)
1062 }
1063 #[doc = "Bit 5 - Write '1' to disable interrupt for event TRIGGERED\\[5\\]"]
1064 #[inline(always)]
1065 pub fn triggered5(&mut self) -> TRIGGERED5_W<5> {
1066 TRIGGERED5_W::new(self)
1067 }
1068 #[doc = "Bit 6 - Write '1' to disable interrupt for event TRIGGERED\\[6\\]"]
1069 #[inline(always)]
1070 pub fn triggered6(&mut self) -> TRIGGERED6_W<6> {
1071 TRIGGERED6_W::new(self)
1072 }
1073 #[doc = "Bit 7 - Write '1' to disable interrupt for event TRIGGERED\\[7\\]"]
1074 #[inline(always)]
1075 pub fn triggered7(&mut self) -> TRIGGERED7_W<7> {
1076 TRIGGERED7_W::new(self)
1077 }
1078 #[doc = "Bit 8 - Write '1' to disable interrupt for event TRIGGERED\\[8\\]"]
1079 #[inline(always)]
1080 pub fn triggered8(&mut self) -> TRIGGERED8_W<8> {
1081 TRIGGERED8_W::new(self)
1082 }
1083 #[doc = "Bit 9 - Write '1' to disable interrupt for event TRIGGERED\\[9\\]"]
1084 #[inline(always)]
1085 pub fn triggered9(&mut self) -> TRIGGERED9_W<9> {
1086 TRIGGERED9_W::new(self)
1087 }
1088 #[doc = "Bit 10 - Write '1' to disable interrupt for event TRIGGERED\\[10\\]"]
1089 #[inline(always)]
1090 pub fn triggered10(&mut self) -> TRIGGERED10_W<10> {
1091 TRIGGERED10_W::new(self)
1092 }
1093 #[doc = "Bit 11 - Write '1' to disable interrupt for event TRIGGERED\\[11\\]"]
1094 #[inline(always)]
1095 pub fn triggered11(&mut self) -> TRIGGERED11_W<11> {
1096 TRIGGERED11_W::new(self)
1097 }
1098 #[doc = "Bit 12 - Write '1' to disable interrupt for event TRIGGERED\\[12\\]"]
1099 #[inline(always)]
1100 pub fn triggered12(&mut self) -> TRIGGERED12_W<12> {
1101 TRIGGERED12_W::new(self)
1102 }
1103 #[doc = "Bit 13 - Write '1' to disable interrupt for event TRIGGERED\\[13\\]"]
1104 #[inline(always)]
1105 pub fn triggered13(&mut self) -> TRIGGERED13_W<13> {
1106 TRIGGERED13_W::new(self)
1107 }
1108 #[doc = "Bit 14 - Write '1' to disable interrupt for event TRIGGERED\\[14\\]"]
1109 #[inline(always)]
1110 pub fn triggered14(&mut self) -> TRIGGERED14_W<14> {
1111 TRIGGERED14_W::new(self)
1112 }
1113 #[doc = "Bit 15 - Write '1' to disable interrupt for event TRIGGERED\\[15\\]"]
1114 #[inline(always)]
1115 pub fn triggered15(&mut self) -> TRIGGERED15_W<15> {
1116 TRIGGERED15_W::new(self)
1117 }
1118 #[doc = "Writes raw bits to the register."]
1119 #[inline(always)]
1120 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1121 self.0.bits(bits);
1122 self
1123 }
1124}
1125#[doc = "Disable interrupt\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 [intenclr](index.html) module"]
1126pub struct INTENCLR_SPEC;
1127impl crate::RegisterSpec for INTENCLR_SPEC {
1128 type Ux = u32;
1129}
1130#[doc = "`read()` method returns [intenclr::R](R) reader structure"]
1131impl crate::Readable for INTENCLR_SPEC {
1132 type Reader = R;
1133}
1134#[doc = "`write(|w| ..)` method takes [intenclr::W](W) writer structure"]
1135impl crate::Writable for INTENCLR_SPEC {
1136 type Writer = W;
1137}
1138#[doc = "`reset()` method sets INTENCLR to value 0"]
1139impl crate::Resettable for INTENCLR_SPEC {
1140 #[inline(always)]
1141 fn reset_value() -> Self::Ux {
1142 0
1143 }
1144}