lpc55_pac/sct0/
res.rs

1#[doc = "Register `RES` reader"]
2pub struct R(crate::R<RES_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<RES_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<RES_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<RES_SPEC>) -> Self {
13        R(reader)
14    }
15}
16#[doc = "Register `RES` writer"]
17pub struct W(crate::W<RES_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<RES_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<RES_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<RES_SPEC>) -> Self {
34        W(writer)
35    }
36}
37#[doc = "Effect of simultaneous set and clear on output 0.\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39#[repr(u8)]
40pub enum O0RES_A {
41    #[doc = "0: No change."]
42    NO_CHANGE = 0,
43    #[doc = "1: Set output (or clear based on the SETCLR0 field in the OUTPUTDIRCTRL register)."]
44    SET = 1,
45    #[doc = "2: Clear output (or set based on the SETCLR0 field)."]
46    CLEAR = 2,
47    #[doc = "3: Toggle output."]
48    TOGGLE_OUTPUT = 3,
49}
50impl From<O0RES_A> for u8 {
51    #[inline(always)]
52    fn from(variant: O0RES_A) -> Self {
53        variant as _
54    }
55}
56#[doc = "Field `O0RES` reader - Effect of simultaneous set and clear on output 0."]
57pub struct O0RES_R(crate::FieldReader<u8, O0RES_A>);
58impl O0RES_R {
59    #[inline(always)]
60    pub(crate) fn new(bits: u8) -> Self {
61        O0RES_R(crate::FieldReader::new(bits))
62    }
63    #[doc = r"Get enumerated values variant"]
64    #[inline(always)]
65    pub fn variant(&self) -> O0RES_A {
66        match self.bits {
67            0 => O0RES_A::NO_CHANGE,
68            1 => O0RES_A::SET,
69            2 => O0RES_A::CLEAR,
70            3 => O0RES_A::TOGGLE_OUTPUT,
71            _ => unreachable!(),
72        }
73    }
74    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
75    #[inline(always)]
76    pub fn is_no_change(&self) -> bool {
77        **self == O0RES_A::NO_CHANGE
78    }
79    #[doc = "Checks if the value of the field is `SET`"]
80    #[inline(always)]
81    pub fn is_set(&self) -> bool {
82        **self == O0RES_A::SET
83    }
84    #[doc = "Checks if the value of the field is `CLEAR`"]
85    #[inline(always)]
86    pub fn is_clear(&self) -> bool {
87        **self == O0RES_A::CLEAR
88    }
89    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
90    #[inline(always)]
91    pub fn is_toggle_output(&self) -> bool {
92        **self == O0RES_A::TOGGLE_OUTPUT
93    }
94}
95impl core::ops::Deref for O0RES_R {
96    type Target = crate::FieldReader<u8, O0RES_A>;
97    #[inline(always)]
98    fn deref(&self) -> &Self::Target {
99        &self.0
100    }
101}
102#[doc = "Field `O0RES` writer - Effect of simultaneous set and clear on output 0."]
103pub struct O0RES_W<'a> {
104    w: &'a mut W,
105}
106impl<'a> O0RES_W<'a> {
107    #[doc = r"Writes `variant` to the field"]
108    #[inline(always)]
109    pub fn variant(self, variant: O0RES_A) -> &'a mut W {
110        self.bits(variant.into())
111    }
112    #[doc = "No change."]
113    #[inline(always)]
114    pub fn no_change(self) -> &'a mut W {
115        self.variant(O0RES_A::NO_CHANGE)
116    }
117    #[doc = "Set output (or clear based on the SETCLR0 field in the OUTPUTDIRCTRL register)."]
118    #[inline(always)]
119    pub fn set(self) -> &'a mut W {
120        self.variant(O0RES_A::SET)
121    }
122    #[doc = "Clear output (or set based on the SETCLR0 field)."]
123    #[inline(always)]
124    pub fn clear(self) -> &'a mut W {
125        self.variant(O0RES_A::CLEAR)
126    }
127    #[doc = "Toggle output."]
128    #[inline(always)]
129    pub fn toggle_output(self) -> &'a mut W {
130        self.variant(O0RES_A::TOGGLE_OUTPUT)
131    }
132    #[doc = r"Writes raw bits to the field"]
133    #[inline(always)]
134    pub fn bits(self, value: u8) -> &'a mut W {
135        self.w.bits = (self.w.bits & !0x03) | (value as u32 & 0x03);
136        self.w
137    }
138}
139#[doc = "Effect of simultaneous set and clear on output 1.\n\nValue on reset: 0"]
140#[derive(Clone, Copy, Debug, PartialEq)]
141#[repr(u8)]
142pub enum O1RES_A {
143    #[doc = "0: No change."]
144    NO_CHANGE = 0,
145    #[doc = "1: Set output (or clear based on the SETCLR1 field in the OUTPUTDIRCTRL register)."]
146    SET = 1,
147    #[doc = "2: Clear output (or set based on the SETCLR1 field)."]
148    CLEAR = 2,
149    #[doc = "3: Toggle output."]
150    TOGGLE_OUTPUT = 3,
151}
152impl From<O1RES_A> for u8 {
153    #[inline(always)]
154    fn from(variant: O1RES_A) -> Self {
155        variant as _
156    }
157}
158#[doc = "Field `O1RES` reader - Effect of simultaneous set and clear on output 1."]
159pub struct O1RES_R(crate::FieldReader<u8, O1RES_A>);
160impl O1RES_R {
161    #[inline(always)]
162    pub(crate) fn new(bits: u8) -> Self {
163        O1RES_R(crate::FieldReader::new(bits))
164    }
165    #[doc = r"Get enumerated values variant"]
166    #[inline(always)]
167    pub fn variant(&self) -> O1RES_A {
168        match self.bits {
169            0 => O1RES_A::NO_CHANGE,
170            1 => O1RES_A::SET,
171            2 => O1RES_A::CLEAR,
172            3 => O1RES_A::TOGGLE_OUTPUT,
173            _ => unreachable!(),
174        }
175    }
176    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
177    #[inline(always)]
178    pub fn is_no_change(&self) -> bool {
179        **self == O1RES_A::NO_CHANGE
180    }
181    #[doc = "Checks if the value of the field is `SET`"]
182    #[inline(always)]
183    pub fn is_set(&self) -> bool {
184        **self == O1RES_A::SET
185    }
186    #[doc = "Checks if the value of the field is `CLEAR`"]
187    #[inline(always)]
188    pub fn is_clear(&self) -> bool {
189        **self == O1RES_A::CLEAR
190    }
191    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
192    #[inline(always)]
193    pub fn is_toggle_output(&self) -> bool {
194        **self == O1RES_A::TOGGLE_OUTPUT
195    }
196}
197impl core::ops::Deref for O1RES_R {
198    type Target = crate::FieldReader<u8, O1RES_A>;
199    #[inline(always)]
200    fn deref(&self) -> &Self::Target {
201        &self.0
202    }
203}
204#[doc = "Field `O1RES` writer - Effect of simultaneous set and clear on output 1."]
205pub struct O1RES_W<'a> {
206    w: &'a mut W,
207}
208impl<'a> O1RES_W<'a> {
209    #[doc = r"Writes `variant` to the field"]
210    #[inline(always)]
211    pub fn variant(self, variant: O1RES_A) -> &'a mut W {
212        self.bits(variant.into())
213    }
214    #[doc = "No change."]
215    #[inline(always)]
216    pub fn no_change(self) -> &'a mut W {
217        self.variant(O1RES_A::NO_CHANGE)
218    }
219    #[doc = "Set output (or clear based on the SETCLR1 field in the OUTPUTDIRCTRL register)."]
220    #[inline(always)]
221    pub fn set(self) -> &'a mut W {
222        self.variant(O1RES_A::SET)
223    }
224    #[doc = "Clear output (or set based on the SETCLR1 field)."]
225    #[inline(always)]
226    pub fn clear(self) -> &'a mut W {
227        self.variant(O1RES_A::CLEAR)
228    }
229    #[doc = "Toggle output."]
230    #[inline(always)]
231    pub fn toggle_output(self) -> &'a mut W {
232        self.variant(O1RES_A::TOGGLE_OUTPUT)
233    }
234    #[doc = r"Writes raw bits to the field"]
235    #[inline(always)]
236    pub fn bits(self, value: u8) -> &'a mut W {
237        self.w.bits = (self.w.bits & !(0x03 << 2)) | ((value as u32 & 0x03) << 2);
238        self.w
239    }
240}
241#[doc = "Effect of simultaneous set and clear on output 2.\n\nValue on reset: 0"]
242#[derive(Clone, Copy, Debug, PartialEq)]
243#[repr(u8)]
244pub enum O2RES_A {
245    #[doc = "0: No change."]
246    NO_CHANGE = 0,
247    #[doc = "1: Set output (or clear based on the SETCLR2 field in the OUTPUTDIRCTRL register)."]
248    SET = 1,
249    #[doc = "2: Clear output n (or set based on the SETCLR2 field)."]
250    CLEAR = 2,
251    #[doc = "3: Toggle output."]
252    TOGGLE_OUTPUT = 3,
253}
254impl From<O2RES_A> for u8 {
255    #[inline(always)]
256    fn from(variant: O2RES_A) -> Self {
257        variant as _
258    }
259}
260#[doc = "Field `O2RES` reader - Effect of simultaneous set and clear on output 2."]
261pub struct O2RES_R(crate::FieldReader<u8, O2RES_A>);
262impl O2RES_R {
263    #[inline(always)]
264    pub(crate) fn new(bits: u8) -> Self {
265        O2RES_R(crate::FieldReader::new(bits))
266    }
267    #[doc = r"Get enumerated values variant"]
268    #[inline(always)]
269    pub fn variant(&self) -> O2RES_A {
270        match self.bits {
271            0 => O2RES_A::NO_CHANGE,
272            1 => O2RES_A::SET,
273            2 => O2RES_A::CLEAR,
274            3 => O2RES_A::TOGGLE_OUTPUT,
275            _ => unreachable!(),
276        }
277    }
278    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
279    #[inline(always)]
280    pub fn is_no_change(&self) -> bool {
281        **self == O2RES_A::NO_CHANGE
282    }
283    #[doc = "Checks if the value of the field is `SET`"]
284    #[inline(always)]
285    pub fn is_set(&self) -> bool {
286        **self == O2RES_A::SET
287    }
288    #[doc = "Checks if the value of the field is `CLEAR`"]
289    #[inline(always)]
290    pub fn is_clear(&self) -> bool {
291        **self == O2RES_A::CLEAR
292    }
293    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
294    #[inline(always)]
295    pub fn is_toggle_output(&self) -> bool {
296        **self == O2RES_A::TOGGLE_OUTPUT
297    }
298}
299impl core::ops::Deref for O2RES_R {
300    type Target = crate::FieldReader<u8, O2RES_A>;
301    #[inline(always)]
302    fn deref(&self) -> &Self::Target {
303        &self.0
304    }
305}
306#[doc = "Field `O2RES` writer - Effect of simultaneous set and clear on output 2."]
307pub struct O2RES_W<'a> {
308    w: &'a mut W,
309}
310impl<'a> O2RES_W<'a> {
311    #[doc = r"Writes `variant` to the field"]
312    #[inline(always)]
313    pub fn variant(self, variant: O2RES_A) -> &'a mut W {
314        self.bits(variant.into())
315    }
316    #[doc = "No change."]
317    #[inline(always)]
318    pub fn no_change(self) -> &'a mut W {
319        self.variant(O2RES_A::NO_CHANGE)
320    }
321    #[doc = "Set output (or clear based on the SETCLR2 field in the OUTPUTDIRCTRL register)."]
322    #[inline(always)]
323    pub fn set(self) -> &'a mut W {
324        self.variant(O2RES_A::SET)
325    }
326    #[doc = "Clear output n (or set based on the SETCLR2 field)."]
327    #[inline(always)]
328    pub fn clear(self) -> &'a mut W {
329        self.variant(O2RES_A::CLEAR)
330    }
331    #[doc = "Toggle output."]
332    #[inline(always)]
333    pub fn toggle_output(self) -> &'a mut W {
334        self.variant(O2RES_A::TOGGLE_OUTPUT)
335    }
336    #[doc = r"Writes raw bits to the field"]
337    #[inline(always)]
338    pub fn bits(self, value: u8) -> &'a mut W {
339        self.w.bits = (self.w.bits & !(0x03 << 4)) | ((value as u32 & 0x03) << 4);
340        self.w
341    }
342}
343#[doc = "Effect of simultaneous set and clear on output 3.\n\nValue on reset: 0"]
344#[derive(Clone, Copy, Debug, PartialEq)]
345#[repr(u8)]
346pub enum O3RES_A {
347    #[doc = "0: No change."]
348    NO_CHANGE = 0,
349    #[doc = "1: Set output (or clear based on the SETCLR3 field in the OUTPUTDIRCTRL register)."]
350    SET = 1,
351    #[doc = "2: Clear output (or set based on the SETCLR3 field)."]
352    CLEAR = 2,
353    #[doc = "3: Toggle output."]
354    TOGGLE_OUTPUT = 3,
355}
356impl From<O3RES_A> for u8 {
357    #[inline(always)]
358    fn from(variant: O3RES_A) -> Self {
359        variant as _
360    }
361}
362#[doc = "Field `O3RES` reader - Effect of simultaneous set and clear on output 3."]
363pub struct O3RES_R(crate::FieldReader<u8, O3RES_A>);
364impl O3RES_R {
365    #[inline(always)]
366    pub(crate) fn new(bits: u8) -> Self {
367        O3RES_R(crate::FieldReader::new(bits))
368    }
369    #[doc = r"Get enumerated values variant"]
370    #[inline(always)]
371    pub fn variant(&self) -> O3RES_A {
372        match self.bits {
373            0 => O3RES_A::NO_CHANGE,
374            1 => O3RES_A::SET,
375            2 => O3RES_A::CLEAR,
376            3 => O3RES_A::TOGGLE_OUTPUT,
377            _ => unreachable!(),
378        }
379    }
380    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
381    #[inline(always)]
382    pub fn is_no_change(&self) -> bool {
383        **self == O3RES_A::NO_CHANGE
384    }
385    #[doc = "Checks if the value of the field is `SET`"]
386    #[inline(always)]
387    pub fn is_set(&self) -> bool {
388        **self == O3RES_A::SET
389    }
390    #[doc = "Checks if the value of the field is `CLEAR`"]
391    #[inline(always)]
392    pub fn is_clear(&self) -> bool {
393        **self == O3RES_A::CLEAR
394    }
395    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
396    #[inline(always)]
397    pub fn is_toggle_output(&self) -> bool {
398        **self == O3RES_A::TOGGLE_OUTPUT
399    }
400}
401impl core::ops::Deref for O3RES_R {
402    type Target = crate::FieldReader<u8, O3RES_A>;
403    #[inline(always)]
404    fn deref(&self) -> &Self::Target {
405        &self.0
406    }
407}
408#[doc = "Field `O3RES` writer - Effect of simultaneous set and clear on output 3."]
409pub struct O3RES_W<'a> {
410    w: &'a mut W,
411}
412impl<'a> O3RES_W<'a> {
413    #[doc = r"Writes `variant` to the field"]
414    #[inline(always)]
415    pub fn variant(self, variant: O3RES_A) -> &'a mut W {
416        self.bits(variant.into())
417    }
418    #[doc = "No change."]
419    #[inline(always)]
420    pub fn no_change(self) -> &'a mut W {
421        self.variant(O3RES_A::NO_CHANGE)
422    }
423    #[doc = "Set output (or clear based on the SETCLR3 field in the OUTPUTDIRCTRL register)."]
424    #[inline(always)]
425    pub fn set(self) -> &'a mut W {
426        self.variant(O3RES_A::SET)
427    }
428    #[doc = "Clear output (or set based on the SETCLR3 field)."]
429    #[inline(always)]
430    pub fn clear(self) -> &'a mut W {
431        self.variant(O3RES_A::CLEAR)
432    }
433    #[doc = "Toggle output."]
434    #[inline(always)]
435    pub fn toggle_output(self) -> &'a mut W {
436        self.variant(O3RES_A::TOGGLE_OUTPUT)
437    }
438    #[doc = r"Writes raw bits to the field"]
439    #[inline(always)]
440    pub fn bits(self, value: u8) -> &'a mut W {
441        self.w.bits = (self.w.bits & !(0x03 << 6)) | ((value as u32 & 0x03) << 6);
442        self.w
443    }
444}
445#[doc = "Effect of simultaneous set and clear on output 4.\n\nValue on reset: 0"]
446#[derive(Clone, Copy, Debug, PartialEq)]
447#[repr(u8)]
448pub enum O4RES_A {
449    #[doc = "0: No change."]
450    NO_CHANGE = 0,
451    #[doc = "1: Set output (or clear based on the SETCLR4 field in the OUTPUTDIRCTRL register)."]
452    SET = 1,
453    #[doc = "2: Clear output (or set based on the SETCLR4 field)."]
454    CLEAR = 2,
455    #[doc = "3: Toggle output."]
456    TOGGLE_OUTPUT = 3,
457}
458impl From<O4RES_A> for u8 {
459    #[inline(always)]
460    fn from(variant: O4RES_A) -> Self {
461        variant as _
462    }
463}
464#[doc = "Field `O4RES` reader - Effect of simultaneous set and clear on output 4."]
465pub struct O4RES_R(crate::FieldReader<u8, O4RES_A>);
466impl O4RES_R {
467    #[inline(always)]
468    pub(crate) fn new(bits: u8) -> Self {
469        O4RES_R(crate::FieldReader::new(bits))
470    }
471    #[doc = r"Get enumerated values variant"]
472    #[inline(always)]
473    pub fn variant(&self) -> O4RES_A {
474        match self.bits {
475            0 => O4RES_A::NO_CHANGE,
476            1 => O4RES_A::SET,
477            2 => O4RES_A::CLEAR,
478            3 => O4RES_A::TOGGLE_OUTPUT,
479            _ => unreachable!(),
480        }
481    }
482    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
483    #[inline(always)]
484    pub fn is_no_change(&self) -> bool {
485        **self == O4RES_A::NO_CHANGE
486    }
487    #[doc = "Checks if the value of the field is `SET`"]
488    #[inline(always)]
489    pub fn is_set(&self) -> bool {
490        **self == O4RES_A::SET
491    }
492    #[doc = "Checks if the value of the field is `CLEAR`"]
493    #[inline(always)]
494    pub fn is_clear(&self) -> bool {
495        **self == O4RES_A::CLEAR
496    }
497    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
498    #[inline(always)]
499    pub fn is_toggle_output(&self) -> bool {
500        **self == O4RES_A::TOGGLE_OUTPUT
501    }
502}
503impl core::ops::Deref for O4RES_R {
504    type Target = crate::FieldReader<u8, O4RES_A>;
505    #[inline(always)]
506    fn deref(&self) -> &Self::Target {
507        &self.0
508    }
509}
510#[doc = "Field `O4RES` writer - Effect of simultaneous set and clear on output 4."]
511pub struct O4RES_W<'a> {
512    w: &'a mut W,
513}
514impl<'a> O4RES_W<'a> {
515    #[doc = r"Writes `variant` to the field"]
516    #[inline(always)]
517    pub fn variant(self, variant: O4RES_A) -> &'a mut W {
518        self.bits(variant.into())
519    }
520    #[doc = "No change."]
521    #[inline(always)]
522    pub fn no_change(self) -> &'a mut W {
523        self.variant(O4RES_A::NO_CHANGE)
524    }
525    #[doc = "Set output (or clear based on the SETCLR4 field in the OUTPUTDIRCTRL register)."]
526    #[inline(always)]
527    pub fn set(self) -> &'a mut W {
528        self.variant(O4RES_A::SET)
529    }
530    #[doc = "Clear output (or set based on the SETCLR4 field)."]
531    #[inline(always)]
532    pub fn clear(self) -> &'a mut W {
533        self.variant(O4RES_A::CLEAR)
534    }
535    #[doc = "Toggle output."]
536    #[inline(always)]
537    pub fn toggle_output(self) -> &'a mut W {
538        self.variant(O4RES_A::TOGGLE_OUTPUT)
539    }
540    #[doc = r"Writes raw bits to the field"]
541    #[inline(always)]
542    pub fn bits(self, value: u8) -> &'a mut W {
543        self.w.bits = (self.w.bits & !(0x03 << 8)) | ((value as u32 & 0x03) << 8);
544        self.w
545    }
546}
547#[doc = "Effect of simultaneous set and clear on output 5.\n\nValue on reset: 0"]
548#[derive(Clone, Copy, Debug, PartialEq)]
549#[repr(u8)]
550pub enum O5RES_A {
551    #[doc = "0: No change."]
552    NO_CHANGE = 0,
553    #[doc = "1: Set output (or clear based on the SETCLR5 field in the OUTPUTDIRCTRL register)."]
554    SET = 1,
555    #[doc = "2: Clear output (or set based on the SETCLR5 field)."]
556    CLEAR = 2,
557    #[doc = "3: Toggle output."]
558    TOGGLE_OUTPUT = 3,
559}
560impl From<O5RES_A> for u8 {
561    #[inline(always)]
562    fn from(variant: O5RES_A) -> Self {
563        variant as _
564    }
565}
566#[doc = "Field `O5RES` reader - Effect of simultaneous set and clear on output 5."]
567pub struct O5RES_R(crate::FieldReader<u8, O5RES_A>);
568impl O5RES_R {
569    #[inline(always)]
570    pub(crate) fn new(bits: u8) -> Self {
571        O5RES_R(crate::FieldReader::new(bits))
572    }
573    #[doc = r"Get enumerated values variant"]
574    #[inline(always)]
575    pub fn variant(&self) -> O5RES_A {
576        match self.bits {
577            0 => O5RES_A::NO_CHANGE,
578            1 => O5RES_A::SET,
579            2 => O5RES_A::CLEAR,
580            3 => O5RES_A::TOGGLE_OUTPUT,
581            _ => unreachable!(),
582        }
583    }
584    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
585    #[inline(always)]
586    pub fn is_no_change(&self) -> bool {
587        **self == O5RES_A::NO_CHANGE
588    }
589    #[doc = "Checks if the value of the field is `SET`"]
590    #[inline(always)]
591    pub fn is_set(&self) -> bool {
592        **self == O5RES_A::SET
593    }
594    #[doc = "Checks if the value of the field is `CLEAR`"]
595    #[inline(always)]
596    pub fn is_clear(&self) -> bool {
597        **self == O5RES_A::CLEAR
598    }
599    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
600    #[inline(always)]
601    pub fn is_toggle_output(&self) -> bool {
602        **self == O5RES_A::TOGGLE_OUTPUT
603    }
604}
605impl core::ops::Deref for O5RES_R {
606    type Target = crate::FieldReader<u8, O5RES_A>;
607    #[inline(always)]
608    fn deref(&self) -> &Self::Target {
609        &self.0
610    }
611}
612#[doc = "Field `O5RES` writer - Effect of simultaneous set and clear on output 5."]
613pub struct O5RES_W<'a> {
614    w: &'a mut W,
615}
616impl<'a> O5RES_W<'a> {
617    #[doc = r"Writes `variant` to the field"]
618    #[inline(always)]
619    pub fn variant(self, variant: O5RES_A) -> &'a mut W {
620        self.bits(variant.into())
621    }
622    #[doc = "No change."]
623    #[inline(always)]
624    pub fn no_change(self) -> &'a mut W {
625        self.variant(O5RES_A::NO_CHANGE)
626    }
627    #[doc = "Set output (or clear based on the SETCLR5 field in the OUTPUTDIRCTRL register)."]
628    #[inline(always)]
629    pub fn set(self) -> &'a mut W {
630        self.variant(O5RES_A::SET)
631    }
632    #[doc = "Clear output (or set based on the SETCLR5 field)."]
633    #[inline(always)]
634    pub fn clear(self) -> &'a mut W {
635        self.variant(O5RES_A::CLEAR)
636    }
637    #[doc = "Toggle output."]
638    #[inline(always)]
639    pub fn toggle_output(self) -> &'a mut W {
640        self.variant(O5RES_A::TOGGLE_OUTPUT)
641    }
642    #[doc = r"Writes raw bits to the field"]
643    #[inline(always)]
644    pub fn bits(self, value: u8) -> &'a mut W {
645        self.w.bits = (self.w.bits & !(0x03 << 10)) | ((value as u32 & 0x03) << 10);
646        self.w
647    }
648}
649#[doc = "Effect of simultaneous set and clear on output 6.\n\nValue on reset: 0"]
650#[derive(Clone, Copy, Debug, PartialEq)]
651#[repr(u8)]
652pub enum O6RES_A {
653    #[doc = "0: No change."]
654    NO_CHANGE = 0,
655    #[doc = "1: Set output (or clear based on the SETCLR6 field in the OUTPUTDIRCTRL register)."]
656    SET = 1,
657    #[doc = "2: Clear output (or set based on the SETCLR6 field)."]
658    CLEAR = 2,
659    #[doc = "3: Toggle output."]
660    TOGGLE_OUTPUT = 3,
661}
662impl From<O6RES_A> for u8 {
663    #[inline(always)]
664    fn from(variant: O6RES_A) -> Self {
665        variant as _
666    }
667}
668#[doc = "Field `O6RES` reader - Effect of simultaneous set and clear on output 6."]
669pub struct O6RES_R(crate::FieldReader<u8, O6RES_A>);
670impl O6RES_R {
671    #[inline(always)]
672    pub(crate) fn new(bits: u8) -> Self {
673        O6RES_R(crate::FieldReader::new(bits))
674    }
675    #[doc = r"Get enumerated values variant"]
676    #[inline(always)]
677    pub fn variant(&self) -> O6RES_A {
678        match self.bits {
679            0 => O6RES_A::NO_CHANGE,
680            1 => O6RES_A::SET,
681            2 => O6RES_A::CLEAR,
682            3 => O6RES_A::TOGGLE_OUTPUT,
683            _ => unreachable!(),
684        }
685    }
686    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
687    #[inline(always)]
688    pub fn is_no_change(&self) -> bool {
689        **self == O6RES_A::NO_CHANGE
690    }
691    #[doc = "Checks if the value of the field is `SET`"]
692    #[inline(always)]
693    pub fn is_set(&self) -> bool {
694        **self == O6RES_A::SET
695    }
696    #[doc = "Checks if the value of the field is `CLEAR`"]
697    #[inline(always)]
698    pub fn is_clear(&self) -> bool {
699        **self == O6RES_A::CLEAR
700    }
701    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
702    #[inline(always)]
703    pub fn is_toggle_output(&self) -> bool {
704        **self == O6RES_A::TOGGLE_OUTPUT
705    }
706}
707impl core::ops::Deref for O6RES_R {
708    type Target = crate::FieldReader<u8, O6RES_A>;
709    #[inline(always)]
710    fn deref(&self) -> &Self::Target {
711        &self.0
712    }
713}
714#[doc = "Field `O6RES` writer - Effect of simultaneous set and clear on output 6."]
715pub struct O6RES_W<'a> {
716    w: &'a mut W,
717}
718impl<'a> O6RES_W<'a> {
719    #[doc = r"Writes `variant` to the field"]
720    #[inline(always)]
721    pub fn variant(self, variant: O6RES_A) -> &'a mut W {
722        self.bits(variant.into())
723    }
724    #[doc = "No change."]
725    #[inline(always)]
726    pub fn no_change(self) -> &'a mut W {
727        self.variant(O6RES_A::NO_CHANGE)
728    }
729    #[doc = "Set output (or clear based on the SETCLR6 field in the OUTPUTDIRCTRL register)."]
730    #[inline(always)]
731    pub fn set(self) -> &'a mut W {
732        self.variant(O6RES_A::SET)
733    }
734    #[doc = "Clear output (or set based on the SETCLR6 field)."]
735    #[inline(always)]
736    pub fn clear(self) -> &'a mut W {
737        self.variant(O6RES_A::CLEAR)
738    }
739    #[doc = "Toggle output."]
740    #[inline(always)]
741    pub fn toggle_output(self) -> &'a mut W {
742        self.variant(O6RES_A::TOGGLE_OUTPUT)
743    }
744    #[doc = r"Writes raw bits to the field"]
745    #[inline(always)]
746    pub fn bits(self, value: u8) -> &'a mut W {
747        self.w.bits = (self.w.bits & !(0x03 << 12)) | ((value as u32 & 0x03) << 12);
748        self.w
749    }
750}
751#[doc = "Effect of simultaneous set and clear on output 7.\n\nValue on reset: 0"]
752#[derive(Clone, Copy, Debug, PartialEq)]
753#[repr(u8)]
754pub enum O7RES_A {
755    #[doc = "0: No change."]
756    NO_CHANGE = 0,
757    #[doc = "1: Set output (or clear based on the SETCLR7 field in the OUTPUTDIRCTRL register)."]
758    SET = 1,
759    #[doc = "2: Clear output n (or set based on the SETCLR7 field)."]
760    CLEAR = 2,
761    #[doc = "3: Toggle output."]
762    TOGGLE_OUTPUT = 3,
763}
764impl From<O7RES_A> for u8 {
765    #[inline(always)]
766    fn from(variant: O7RES_A) -> Self {
767        variant as _
768    }
769}
770#[doc = "Field `O7RES` reader - Effect of simultaneous set and clear on output 7."]
771pub struct O7RES_R(crate::FieldReader<u8, O7RES_A>);
772impl O7RES_R {
773    #[inline(always)]
774    pub(crate) fn new(bits: u8) -> Self {
775        O7RES_R(crate::FieldReader::new(bits))
776    }
777    #[doc = r"Get enumerated values variant"]
778    #[inline(always)]
779    pub fn variant(&self) -> O7RES_A {
780        match self.bits {
781            0 => O7RES_A::NO_CHANGE,
782            1 => O7RES_A::SET,
783            2 => O7RES_A::CLEAR,
784            3 => O7RES_A::TOGGLE_OUTPUT,
785            _ => unreachable!(),
786        }
787    }
788    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
789    #[inline(always)]
790    pub fn is_no_change(&self) -> bool {
791        **self == O7RES_A::NO_CHANGE
792    }
793    #[doc = "Checks if the value of the field is `SET`"]
794    #[inline(always)]
795    pub fn is_set(&self) -> bool {
796        **self == O7RES_A::SET
797    }
798    #[doc = "Checks if the value of the field is `CLEAR`"]
799    #[inline(always)]
800    pub fn is_clear(&self) -> bool {
801        **self == O7RES_A::CLEAR
802    }
803    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
804    #[inline(always)]
805    pub fn is_toggle_output(&self) -> bool {
806        **self == O7RES_A::TOGGLE_OUTPUT
807    }
808}
809impl core::ops::Deref for O7RES_R {
810    type Target = crate::FieldReader<u8, O7RES_A>;
811    #[inline(always)]
812    fn deref(&self) -> &Self::Target {
813        &self.0
814    }
815}
816#[doc = "Field `O7RES` writer - Effect of simultaneous set and clear on output 7."]
817pub struct O7RES_W<'a> {
818    w: &'a mut W,
819}
820impl<'a> O7RES_W<'a> {
821    #[doc = r"Writes `variant` to the field"]
822    #[inline(always)]
823    pub fn variant(self, variant: O7RES_A) -> &'a mut W {
824        self.bits(variant.into())
825    }
826    #[doc = "No change."]
827    #[inline(always)]
828    pub fn no_change(self) -> &'a mut W {
829        self.variant(O7RES_A::NO_CHANGE)
830    }
831    #[doc = "Set output (or clear based on the SETCLR7 field in the OUTPUTDIRCTRL register)."]
832    #[inline(always)]
833    pub fn set(self) -> &'a mut W {
834        self.variant(O7RES_A::SET)
835    }
836    #[doc = "Clear output n (or set based on the SETCLR7 field)."]
837    #[inline(always)]
838    pub fn clear(self) -> &'a mut W {
839        self.variant(O7RES_A::CLEAR)
840    }
841    #[doc = "Toggle output."]
842    #[inline(always)]
843    pub fn toggle_output(self) -> &'a mut W {
844        self.variant(O7RES_A::TOGGLE_OUTPUT)
845    }
846    #[doc = r"Writes raw bits to the field"]
847    #[inline(always)]
848    pub fn bits(self, value: u8) -> &'a mut W {
849        self.w.bits = (self.w.bits & !(0x03 << 14)) | ((value as u32 & 0x03) << 14);
850        self.w
851    }
852}
853#[doc = "Effect of simultaneous set and clear on output 8.\n\nValue on reset: 0"]
854#[derive(Clone, Copy, Debug, PartialEq)]
855#[repr(u8)]
856pub enum O8RES_A {
857    #[doc = "0: No change."]
858    NO_CHANGE = 0,
859    #[doc = "1: Set output (or clear based on the SETCLR8 field in the OUTPUTDIRCTRL register)."]
860    SET = 1,
861    #[doc = "2: Clear output (or set based on the SETCLR8 field)."]
862    CLEAR = 2,
863    #[doc = "3: Toggle output."]
864    TOGGLE_OUTPUT = 3,
865}
866impl From<O8RES_A> for u8 {
867    #[inline(always)]
868    fn from(variant: O8RES_A) -> Self {
869        variant as _
870    }
871}
872#[doc = "Field `O8RES` reader - Effect of simultaneous set and clear on output 8."]
873pub struct O8RES_R(crate::FieldReader<u8, O8RES_A>);
874impl O8RES_R {
875    #[inline(always)]
876    pub(crate) fn new(bits: u8) -> Self {
877        O8RES_R(crate::FieldReader::new(bits))
878    }
879    #[doc = r"Get enumerated values variant"]
880    #[inline(always)]
881    pub fn variant(&self) -> O8RES_A {
882        match self.bits {
883            0 => O8RES_A::NO_CHANGE,
884            1 => O8RES_A::SET,
885            2 => O8RES_A::CLEAR,
886            3 => O8RES_A::TOGGLE_OUTPUT,
887            _ => unreachable!(),
888        }
889    }
890    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
891    #[inline(always)]
892    pub fn is_no_change(&self) -> bool {
893        **self == O8RES_A::NO_CHANGE
894    }
895    #[doc = "Checks if the value of the field is `SET`"]
896    #[inline(always)]
897    pub fn is_set(&self) -> bool {
898        **self == O8RES_A::SET
899    }
900    #[doc = "Checks if the value of the field is `CLEAR`"]
901    #[inline(always)]
902    pub fn is_clear(&self) -> bool {
903        **self == O8RES_A::CLEAR
904    }
905    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
906    #[inline(always)]
907    pub fn is_toggle_output(&self) -> bool {
908        **self == O8RES_A::TOGGLE_OUTPUT
909    }
910}
911impl core::ops::Deref for O8RES_R {
912    type Target = crate::FieldReader<u8, O8RES_A>;
913    #[inline(always)]
914    fn deref(&self) -> &Self::Target {
915        &self.0
916    }
917}
918#[doc = "Field `O8RES` writer - Effect of simultaneous set and clear on output 8."]
919pub struct O8RES_W<'a> {
920    w: &'a mut W,
921}
922impl<'a> O8RES_W<'a> {
923    #[doc = r"Writes `variant` to the field"]
924    #[inline(always)]
925    pub fn variant(self, variant: O8RES_A) -> &'a mut W {
926        self.bits(variant.into())
927    }
928    #[doc = "No change."]
929    #[inline(always)]
930    pub fn no_change(self) -> &'a mut W {
931        self.variant(O8RES_A::NO_CHANGE)
932    }
933    #[doc = "Set output (or clear based on the SETCLR8 field in the OUTPUTDIRCTRL register)."]
934    #[inline(always)]
935    pub fn set(self) -> &'a mut W {
936        self.variant(O8RES_A::SET)
937    }
938    #[doc = "Clear output (or set based on the SETCLR8 field)."]
939    #[inline(always)]
940    pub fn clear(self) -> &'a mut W {
941        self.variant(O8RES_A::CLEAR)
942    }
943    #[doc = "Toggle output."]
944    #[inline(always)]
945    pub fn toggle_output(self) -> &'a mut W {
946        self.variant(O8RES_A::TOGGLE_OUTPUT)
947    }
948    #[doc = r"Writes raw bits to the field"]
949    #[inline(always)]
950    pub fn bits(self, value: u8) -> &'a mut W {
951        self.w.bits = (self.w.bits & !(0x03 << 16)) | ((value as u32 & 0x03) << 16);
952        self.w
953    }
954}
955#[doc = "Effect of simultaneous set and clear on output 9.\n\nValue on reset: 0"]
956#[derive(Clone, Copy, Debug, PartialEq)]
957#[repr(u8)]
958pub enum O9RES_A {
959    #[doc = "0: No change."]
960    NO_CHANGE = 0,
961    #[doc = "1: Set output (or clear based on the SETCLR9 field in the OUTPUTDIRCTRL register)."]
962    SET = 1,
963    #[doc = "2: Clear output (or set based on the SETCLR9 field)."]
964    CLEAR = 2,
965    #[doc = "3: Toggle output."]
966    TOGGLE_OUTPUT = 3,
967}
968impl From<O9RES_A> for u8 {
969    #[inline(always)]
970    fn from(variant: O9RES_A) -> Self {
971        variant as _
972    }
973}
974#[doc = "Field `O9RES` reader - Effect of simultaneous set and clear on output 9."]
975pub struct O9RES_R(crate::FieldReader<u8, O9RES_A>);
976impl O9RES_R {
977    #[inline(always)]
978    pub(crate) fn new(bits: u8) -> Self {
979        O9RES_R(crate::FieldReader::new(bits))
980    }
981    #[doc = r"Get enumerated values variant"]
982    #[inline(always)]
983    pub fn variant(&self) -> O9RES_A {
984        match self.bits {
985            0 => O9RES_A::NO_CHANGE,
986            1 => O9RES_A::SET,
987            2 => O9RES_A::CLEAR,
988            3 => O9RES_A::TOGGLE_OUTPUT,
989            _ => unreachable!(),
990        }
991    }
992    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
993    #[inline(always)]
994    pub fn is_no_change(&self) -> bool {
995        **self == O9RES_A::NO_CHANGE
996    }
997    #[doc = "Checks if the value of the field is `SET`"]
998    #[inline(always)]
999    pub fn is_set(&self) -> bool {
1000        **self == O9RES_A::SET
1001    }
1002    #[doc = "Checks if the value of the field is `CLEAR`"]
1003    #[inline(always)]
1004    pub fn is_clear(&self) -> bool {
1005        **self == O9RES_A::CLEAR
1006    }
1007    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1008    #[inline(always)]
1009    pub fn is_toggle_output(&self) -> bool {
1010        **self == O9RES_A::TOGGLE_OUTPUT
1011    }
1012}
1013impl core::ops::Deref for O9RES_R {
1014    type Target = crate::FieldReader<u8, O9RES_A>;
1015    #[inline(always)]
1016    fn deref(&self) -> &Self::Target {
1017        &self.0
1018    }
1019}
1020#[doc = "Field `O9RES` writer - Effect of simultaneous set and clear on output 9."]
1021pub struct O9RES_W<'a> {
1022    w: &'a mut W,
1023}
1024impl<'a> O9RES_W<'a> {
1025    #[doc = r"Writes `variant` to the field"]
1026    #[inline(always)]
1027    pub fn variant(self, variant: O9RES_A) -> &'a mut W {
1028        self.bits(variant.into())
1029    }
1030    #[doc = "No change."]
1031    #[inline(always)]
1032    pub fn no_change(self) -> &'a mut W {
1033        self.variant(O9RES_A::NO_CHANGE)
1034    }
1035    #[doc = "Set output (or clear based on the SETCLR9 field in the OUTPUTDIRCTRL register)."]
1036    #[inline(always)]
1037    pub fn set(self) -> &'a mut W {
1038        self.variant(O9RES_A::SET)
1039    }
1040    #[doc = "Clear output (or set based on the SETCLR9 field)."]
1041    #[inline(always)]
1042    pub fn clear(self) -> &'a mut W {
1043        self.variant(O9RES_A::CLEAR)
1044    }
1045    #[doc = "Toggle output."]
1046    #[inline(always)]
1047    pub fn toggle_output(self) -> &'a mut W {
1048        self.variant(O9RES_A::TOGGLE_OUTPUT)
1049    }
1050    #[doc = r"Writes raw bits to the field"]
1051    #[inline(always)]
1052    pub fn bits(self, value: u8) -> &'a mut W {
1053        self.w.bits = (self.w.bits & !(0x03 << 18)) | ((value as u32 & 0x03) << 18);
1054        self.w
1055    }
1056}
1057#[doc = "Effect of simultaneous set and clear on output 10.\n\nValue on reset: 0"]
1058#[derive(Clone, Copy, Debug, PartialEq)]
1059#[repr(u8)]
1060pub enum O10RES_A {
1061    #[doc = "0: No change."]
1062    NO_CHANGE = 0,
1063    #[doc = "1: Set output (or clear based on the SETCLR10 field in the OUTPUTDIRCTRL register)."]
1064    SET = 1,
1065    #[doc = "2: Clear output (or set based on the SETCLR10 field)."]
1066    CLEAR = 2,
1067    #[doc = "3: Toggle output."]
1068    TOGGLE_OUTPUT = 3,
1069}
1070impl From<O10RES_A> for u8 {
1071    #[inline(always)]
1072    fn from(variant: O10RES_A) -> Self {
1073        variant as _
1074    }
1075}
1076#[doc = "Field `O10RES` reader - Effect of simultaneous set and clear on output 10."]
1077pub struct O10RES_R(crate::FieldReader<u8, O10RES_A>);
1078impl O10RES_R {
1079    #[inline(always)]
1080    pub(crate) fn new(bits: u8) -> Self {
1081        O10RES_R(crate::FieldReader::new(bits))
1082    }
1083    #[doc = r"Get enumerated values variant"]
1084    #[inline(always)]
1085    pub fn variant(&self) -> O10RES_A {
1086        match self.bits {
1087            0 => O10RES_A::NO_CHANGE,
1088            1 => O10RES_A::SET,
1089            2 => O10RES_A::CLEAR,
1090            3 => O10RES_A::TOGGLE_OUTPUT,
1091            _ => unreachable!(),
1092        }
1093    }
1094    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
1095    #[inline(always)]
1096    pub fn is_no_change(&self) -> bool {
1097        **self == O10RES_A::NO_CHANGE
1098    }
1099    #[doc = "Checks if the value of the field is `SET`"]
1100    #[inline(always)]
1101    pub fn is_set(&self) -> bool {
1102        **self == O10RES_A::SET
1103    }
1104    #[doc = "Checks if the value of the field is `CLEAR`"]
1105    #[inline(always)]
1106    pub fn is_clear(&self) -> bool {
1107        **self == O10RES_A::CLEAR
1108    }
1109    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1110    #[inline(always)]
1111    pub fn is_toggle_output(&self) -> bool {
1112        **self == O10RES_A::TOGGLE_OUTPUT
1113    }
1114}
1115impl core::ops::Deref for O10RES_R {
1116    type Target = crate::FieldReader<u8, O10RES_A>;
1117    #[inline(always)]
1118    fn deref(&self) -> &Self::Target {
1119        &self.0
1120    }
1121}
1122#[doc = "Field `O10RES` writer - Effect of simultaneous set and clear on output 10."]
1123pub struct O10RES_W<'a> {
1124    w: &'a mut W,
1125}
1126impl<'a> O10RES_W<'a> {
1127    #[doc = r"Writes `variant` to the field"]
1128    #[inline(always)]
1129    pub fn variant(self, variant: O10RES_A) -> &'a mut W {
1130        self.bits(variant.into())
1131    }
1132    #[doc = "No change."]
1133    #[inline(always)]
1134    pub fn no_change(self) -> &'a mut W {
1135        self.variant(O10RES_A::NO_CHANGE)
1136    }
1137    #[doc = "Set output (or clear based on the SETCLR10 field in the OUTPUTDIRCTRL register)."]
1138    #[inline(always)]
1139    pub fn set(self) -> &'a mut W {
1140        self.variant(O10RES_A::SET)
1141    }
1142    #[doc = "Clear output (or set based on the SETCLR10 field)."]
1143    #[inline(always)]
1144    pub fn clear(self) -> &'a mut W {
1145        self.variant(O10RES_A::CLEAR)
1146    }
1147    #[doc = "Toggle output."]
1148    #[inline(always)]
1149    pub fn toggle_output(self) -> &'a mut W {
1150        self.variant(O10RES_A::TOGGLE_OUTPUT)
1151    }
1152    #[doc = r"Writes raw bits to the field"]
1153    #[inline(always)]
1154    pub fn bits(self, value: u8) -> &'a mut W {
1155        self.w.bits = (self.w.bits & !(0x03 << 20)) | ((value as u32 & 0x03) << 20);
1156        self.w
1157    }
1158}
1159#[doc = "Effect of simultaneous set and clear on output 11.\n\nValue on reset: 0"]
1160#[derive(Clone, Copy, Debug, PartialEq)]
1161#[repr(u8)]
1162pub enum O11RES_A {
1163    #[doc = "0: No change."]
1164    NO_CHANGE = 0,
1165    #[doc = "1: Set output (or clear based on the SETCLR11 field in the OUTPUTDIRCTRL register)."]
1166    SET = 1,
1167    #[doc = "2: Clear output (or set based on the SETCLR11 field)."]
1168    CLEAR = 2,
1169    #[doc = "3: Toggle output."]
1170    TOGGLE_OUTPUT = 3,
1171}
1172impl From<O11RES_A> for u8 {
1173    #[inline(always)]
1174    fn from(variant: O11RES_A) -> Self {
1175        variant as _
1176    }
1177}
1178#[doc = "Field `O11RES` reader - Effect of simultaneous set and clear on output 11."]
1179pub struct O11RES_R(crate::FieldReader<u8, O11RES_A>);
1180impl O11RES_R {
1181    #[inline(always)]
1182    pub(crate) fn new(bits: u8) -> Self {
1183        O11RES_R(crate::FieldReader::new(bits))
1184    }
1185    #[doc = r"Get enumerated values variant"]
1186    #[inline(always)]
1187    pub fn variant(&self) -> O11RES_A {
1188        match self.bits {
1189            0 => O11RES_A::NO_CHANGE,
1190            1 => O11RES_A::SET,
1191            2 => O11RES_A::CLEAR,
1192            3 => O11RES_A::TOGGLE_OUTPUT,
1193            _ => unreachable!(),
1194        }
1195    }
1196    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
1197    #[inline(always)]
1198    pub fn is_no_change(&self) -> bool {
1199        **self == O11RES_A::NO_CHANGE
1200    }
1201    #[doc = "Checks if the value of the field is `SET`"]
1202    #[inline(always)]
1203    pub fn is_set(&self) -> bool {
1204        **self == O11RES_A::SET
1205    }
1206    #[doc = "Checks if the value of the field is `CLEAR`"]
1207    #[inline(always)]
1208    pub fn is_clear(&self) -> bool {
1209        **self == O11RES_A::CLEAR
1210    }
1211    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1212    #[inline(always)]
1213    pub fn is_toggle_output(&self) -> bool {
1214        **self == O11RES_A::TOGGLE_OUTPUT
1215    }
1216}
1217impl core::ops::Deref for O11RES_R {
1218    type Target = crate::FieldReader<u8, O11RES_A>;
1219    #[inline(always)]
1220    fn deref(&self) -> &Self::Target {
1221        &self.0
1222    }
1223}
1224#[doc = "Field `O11RES` writer - Effect of simultaneous set and clear on output 11."]
1225pub struct O11RES_W<'a> {
1226    w: &'a mut W,
1227}
1228impl<'a> O11RES_W<'a> {
1229    #[doc = r"Writes `variant` to the field"]
1230    #[inline(always)]
1231    pub fn variant(self, variant: O11RES_A) -> &'a mut W {
1232        self.bits(variant.into())
1233    }
1234    #[doc = "No change."]
1235    #[inline(always)]
1236    pub fn no_change(self) -> &'a mut W {
1237        self.variant(O11RES_A::NO_CHANGE)
1238    }
1239    #[doc = "Set output (or clear based on the SETCLR11 field in the OUTPUTDIRCTRL register)."]
1240    #[inline(always)]
1241    pub fn set(self) -> &'a mut W {
1242        self.variant(O11RES_A::SET)
1243    }
1244    #[doc = "Clear output (or set based on the SETCLR11 field)."]
1245    #[inline(always)]
1246    pub fn clear(self) -> &'a mut W {
1247        self.variant(O11RES_A::CLEAR)
1248    }
1249    #[doc = "Toggle output."]
1250    #[inline(always)]
1251    pub fn toggle_output(self) -> &'a mut W {
1252        self.variant(O11RES_A::TOGGLE_OUTPUT)
1253    }
1254    #[doc = r"Writes raw bits to the field"]
1255    #[inline(always)]
1256    pub fn bits(self, value: u8) -> &'a mut W {
1257        self.w.bits = (self.w.bits & !(0x03 << 22)) | ((value as u32 & 0x03) << 22);
1258        self.w
1259    }
1260}
1261#[doc = "Effect of simultaneous set and clear on output 12.\n\nValue on reset: 0"]
1262#[derive(Clone, Copy, Debug, PartialEq)]
1263#[repr(u8)]
1264pub enum O12RES_A {
1265    #[doc = "0: No change."]
1266    NO_CHANGE = 0,
1267    #[doc = "1: Set output (or clear based on the SETCLR12 field in the OUTPUTDIRCTRL register)."]
1268    SET = 1,
1269    #[doc = "2: Clear output (or set based on the SETCLR12 field)."]
1270    CLEAR = 2,
1271    #[doc = "3: Toggle output."]
1272    TOGGLE_OUTPUT = 3,
1273}
1274impl From<O12RES_A> for u8 {
1275    #[inline(always)]
1276    fn from(variant: O12RES_A) -> Self {
1277        variant as _
1278    }
1279}
1280#[doc = "Field `O12RES` reader - Effect of simultaneous set and clear on output 12."]
1281pub struct O12RES_R(crate::FieldReader<u8, O12RES_A>);
1282impl O12RES_R {
1283    #[inline(always)]
1284    pub(crate) fn new(bits: u8) -> Self {
1285        O12RES_R(crate::FieldReader::new(bits))
1286    }
1287    #[doc = r"Get enumerated values variant"]
1288    #[inline(always)]
1289    pub fn variant(&self) -> O12RES_A {
1290        match self.bits {
1291            0 => O12RES_A::NO_CHANGE,
1292            1 => O12RES_A::SET,
1293            2 => O12RES_A::CLEAR,
1294            3 => O12RES_A::TOGGLE_OUTPUT,
1295            _ => unreachable!(),
1296        }
1297    }
1298    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
1299    #[inline(always)]
1300    pub fn is_no_change(&self) -> bool {
1301        **self == O12RES_A::NO_CHANGE
1302    }
1303    #[doc = "Checks if the value of the field is `SET`"]
1304    #[inline(always)]
1305    pub fn is_set(&self) -> bool {
1306        **self == O12RES_A::SET
1307    }
1308    #[doc = "Checks if the value of the field is `CLEAR`"]
1309    #[inline(always)]
1310    pub fn is_clear(&self) -> bool {
1311        **self == O12RES_A::CLEAR
1312    }
1313    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1314    #[inline(always)]
1315    pub fn is_toggle_output(&self) -> bool {
1316        **self == O12RES_A::TOGGLE_OUTPUT
1317    }
1318}
1319impl core::ops::Deref for O12RES_R {
1320    type Target = crate::FieldReader<u8, O12RES_A>;
1321    #[inline(always)]
1322    fn deref(&self) -> &Self::Target {
1323        &self.0
1324    }
1325}
1326#[doc = "Field `O12RES` writer - Effect of simultaneous set and clear on output 12."]
1327pub struct O12RES_W<'a> {
1328    w: &'a mut W,
1329}
1330impl<'a> O12RES_W<'a> {
1331    #[doc = r"Writes `variant` to the field"]
1332    #[inline(always)]
1333    pub fn variant(self, variant: O12RES_A) -> &'a mut W {
1334        self.bits(variant.into())
1335    }
1336    #[doc = "No change."]
1337    #[inline(always)]
1338    pub fn no_change(self) -> &'a mut W {
1339        self.variant(O12RES_A::NO_CHANGE)
1340    }
1341    #[doc = "Set output (or clear based on the SETCLR12 field in the OUTPUTDIRCTRL register)."]
1342    #[inline(always)]
1343    pub fn set(self) -> &'a mut W {
1344        self.variant(O12RES_A::SET)
1345    }
1346    #[doc = "Clear output (or set based on the SETCLR12 field)."]
1347    #[inline(always)]
1348    pub fn clear(self) -> &'a mut W {
1349        self.variant(O12RES_A::CLEAR)
1350    }
1351    #[doc = "Toggle output."]
1352    #[inline(always)]
1353    pub fn toggle_output(self) -> &'a mut W {
1354        self.variant(O12RES_A::TOGGLE_OUTPUT)
1355    }
1356    #[doc = r"Writes raw bits to the field"]
1357    #[inline(always)]
1358    pub fn bits(self, value: u8) -> &'a mut W {
1359        self.w.bits = (self.w.bits & !(0x03 << 24)) | ((value as u32 & 0x03) << 24);
1360        self.w
1361    }
1362}
1363#[doc = "Effect of simultaneous set and clear on output 13.\n\nValue on reset: 0"]
1364#[derive(Clone, Copy, Debug, PartialEq)]
1365#[repr(u8)]
1366pub enum O13RES_A {
1367    #[doc = "0: No change."]
1368    NO_CHANGE = 0,
1369    #[doc = "1: Set output (or clear based on the SETCLR13 field in the OUTPUTDIRCTRL register)."]
1370    SET = 1,
1371    #[doc = "2: Clear output (or set based on the SETCLR13 field)."]
1372    CLEAR = 2,
1373    #[doc = "3: Toggle output."]
1374    TOGGLE_OUTPUT = 3,
1375}
1376impl From<O13RES_A> for u8 {
1377    #[inline(always)]
1378    fn from(variant: O13RES_A) -> Self {
1379        variant as _
1380    }
1381}
1382#[doc = "Field `O13RES` reader - Effect of simultaneous set and clear on output 13."]
1383pub struct O13RES_R(crate::FieldReader<u8, O13RES_A>);
1384impl O13RES_R {
1385    #[inline(always)]
1386    pub(crate) fn new(bits: u8) -> Self {
1387        O13RES_R(crate::FieldReader::new(bits))
1388    }
1389    #[doc = r"Get enumerated values variant"]
1390    #[inline(always)]
1391    pub fn variant(&self) -> O13RES_A {
1392        match self.bits {
1393            0 => O13RES_A::NO_CHANGE,
1394            1 => O13RES_A::SET,
1395            2 => O13RES_A::CLEAR,
1396            3 => O13RES_A::TOGGLE_OUTPUT,
1397            _ => unreachable!(),
1398        }
1399    }
1400    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
1401    #[inline(always)]
1402    pub fn is_no_change(&self) -> bool {
1403        **self == O13RES_A::NO_CHANGE
1404    }
1405    #[doc = "Checks if the value of the field is `SET`"]
1406    #[inline(always)]
1407    pub fn is_set(&self) -> bool {
1408        **self == O13RES_A::SET
1409    }
1410    #[doc = "Checks if the value of the field is `CLEAR`"]
1411    #[inline(always)]
1412    pub fn is_clear(&self) -> bool {
1413        **self == O13RES_A::CLEAR
1414    }
1415    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1416    #[inline(always)]
1417    pub fn is_toggle_output(&self) -> bool {
1418        **self == O13RES_A::TOGGLE_OUTPUT
1419    }
1420}
1421impl core::ops::Deref for O13RES_R {
1422    type Target = crate::FieldReader<u8, O13RES_A>;
1423    #[inline(always)]
1424    fn deref(&self) -> &Self::Target {
1425        &self.0
1426    }
1427}
1428#[doc = "Field `O13RES` writer - Effect of simultaneous set and clear on output 13."]
1429pub struct O13RES_W<'a> {
1430    w: &'a mut W,
1431}
1432impl<'a> O13RES_W<'a> {
1433    #[doc = r"Writes `variant` to the field"]
1434    #[inline(always)]
1435    pub fn variant(self, variant: O13RES_A) -> &'a mut W {
1436        self.bits(variant.into())
1437    }
1438    #[doc = "No change."]
1439    #[inline(always)]
1440    pub fn no_change(self) -> &'a mut W {
1441        self.variant(O13RES_A::NO_CHANGE)
1442    }
1443    #[doc = "Set output (or clear based on the SETCLR13 field in the OUTPUTDIRCTRL register)."]
1444    #[inline(always)]
1445    pub fn set(self) -> &'a mut W {
1446        self.variant(O13RES_A::SET)
1447    }
1448    #[doc = "Clear output (or set based on the SETCLR13 field)."]
1449    #[inline(always)]
1450    pub fn clear(self) -> &'a mut W {
1451        self.variant(O13RES_A::CLEAR)
1452    }
1453    #[doc = "Toggle output."]
1454    #[inline(always)]
1455    pub fn toggle_output(self) -> &'a mut W {
1456        self.variant(O13RES_A::TOGGLE_OUTPUT)
1457    }
1458    #[doc = r"Writes raw bits to the field"]
1459    #[inline(always)]
1460    pub fn bits(self, value: u8) -> &'a mut W {
1461        self.w.bits = (self.w.bits & !(0x03 << 26)) | ((value as u32 & 0x03) << 26);
1462        self.w
1463    }
1464}
1465#[doc = "Effect of simultaneous set and clear on output 14.\n\nValue on reset: 0"]
1466#[derive(Clone, Copy, Debug, PartialEq)]
1467#[repr(u8)]
1468pub enum O14RES_A {
1469    #[doc = "0: No change."]
1470    NO_CHANGE = 0,
1471    #[doc = "1: Set output (or clear based on the SETCLR14 field in the OUTPUTDIRCTRL register)."]
1472    SET = 1,
1473    #[doc = "2: Clear output (or set based on the SETCLR14 field)."]
1474    CLEAR = 2,
1475    #[doc = "3: Toggle output."]
1476    TOGGLE_OUTPUT = 3,
1477}
1478impl From<O14RES_A> for u8 {
1479    #[inline(always)]
1480    fn from(variant: O14RES_A) -> Self {
1481        variant as _
1482    }
1483}
1484#[doc = "Field `O14RES` reader - Effect of simultaneous set and clear on output 14."]
1485pub struct O14RES_R(crate::FieldReader<u8, O14RES_A>);
1486impl O14RES_R {
1487    #[inline(always)]
1488    pub(crate) fn new(bits: u8) -> Self {
1489        O14RES_R(crate::FieldReader::new(bits))
1490    }
1491    #[doc = r"Get enumerated values variant"]
1492    #[inline(always)]
1493    pub fn variant(&self) -> O14RES_A {
1494        match self.bits {
1495            0 => O14RES_A::NO_CHANGE,
1496            1 => O14RES_A::SET,
1497            2 => O14RES_A::CLEAR,
1498            3 => O14RES_A::TOGGLE_OUTPUT,
1499            _ => unreachable!(),
1500        }
1501    }
1502    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
1503    #[inline(always)]
1504    pub fn is_no_change(&self) -> bool {
1505        **self == O14RES_A::NO_CHANGE
1506    }
1507    #[doc = "Checks if the value of the field is `SET`"]
1508    #[inline(always)]
1509    pub fn is_set(&self) -> bool {
1510        **self == O14RES_A::SET
1511    }
1512    #[doc = "Checks if the value of the field is `CLEAR`"]
1513    #[inline(always)]
1514    pub fn is_clear(&self) -> bool {
1515        **self == O14RES_A::CLEAR
1516    }
1517    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1518    #[inline(always)]
1519    pub fn is_toggle_output(&self) -> bool {
1520        **self == O14RES_A::TOGGLE_OUTPUT
1521    }
1522}
1523impl core::ops::Deref for O14RES_R {
1524    type Target = crate::FieldReader<u8, O14RES_A>;
1525    #[inline(always)]
1526    fn deref(&self) -> &Self::Target {
1527        &self.0
1528    }
1529}
1530#[doc = "Field `O14RES` writer - Effect of simultaneous set and clear on output 14."]
1531pub struct O14RES_W<'a> {
1532    w: &'a mut W,
1533}
1534impl<'a> O14RES_W<'a> {
1535    #[doc = r"Writes `variant` to the field"]
1536    #[inline(always)]
1537    pub fn variant(self, variant: O14RES_A) -> &'a mut W {
1538        self.bits(variant.into())
1539    }
1540    #[doc = "No change."]
1541    #[inline(always)]
1542    pub fn no_change(self) -> &'a mut W {
1543        self.variant(O14RES_A::NO_CHANGE)
1544    }
1545    #[doc = "Set output (or clear based on the SETCLR14 field in the OUTPUTDIRCTRL register)."]
1546    #[inline(always)]
1547    pub fn set(self) -> &'a mut W {
1548        self.variant(O14RES_A::SET)
1549    }
1550    #[doc = "Clear output (or set based on the SETCLR14 field)."]
1551    #[inline(always)]
1552    pub fn clear(self) -> &'a mut W {
1553        self.variant(O14RES_A::CLEAR)
1554    }
1555    #[doc = "Toggle output."]
1556    #[inline(always)]
1557    pub fn toggle_output(self) -> &'a mut W {
1558        self.variant(O14RES_A::TOGGLE_OUTPUT)
1559    }
1560    #[doc = r"Writes raw bits to the field"]
1561    #[inline(always)]
1562    pub fn bits(self, value: u8) -> &'a mut W {
1563        self.w.bits = (self.w.bits & !(0x03 << 28)) | ((value as u32 & 0x03) << 28);
1564        self.w
1565    }
1566}
1567#[doc = "Effect of simultaneous set and clear on output 15.\n\nValue on reset: 0"]
1568#[derive(Clone, Copy, Debug, PartialEq)]
1569#[repr(u8)]
1570pub enum O15RES_A {
1571    #[doc = "0: No change."]
1572    NO_CHANGE = 0,
1573    #[doc = "1: Set output (or clear based on the SETCLR15 field in the OUTPUTDIRCTRL register)."]
1574    SET = 1,
1575    #[doc = "2: Clear output (or set based on the SETCLR15 field)."]
1576    CLEAR = 2,
1577    #[doc = "3: Toggle output."]
1578    TOGGLE_OUTPUT = 3,
1579}
1580impl From<O15RES_A> for u8 {
1581    #[inline(always)]
1582    fn from(variant: O15RES_A) -> Self {
1583        variant as _
1584    }
1585}
1586#[doc = "Field `O15RES` reader - Effect of simultaneous set and clear on output 15."]
1587pub struct O15RES_R(crate::FieldReader<u8, O15RES_A>);
1588impl O15RES_R {
1589    #[inline(always)]
1590    pub(crate) fn new(bits: u8) -> Self {
1591        O15RES_R(crate::FieldReader::new(bits))
1592    }
1593    #[doc = r"Get enumerated values variant"]
1594    #[inline(always)]
1595    pub fn variant(&self) -> O15RES_A {
1596        match self.bits {
1597            0 => O15RES_A::NO_CHANGE,
1598            1 => O15RES_A::SET,
1599            2 => O15RES_A::CLEAR,
1600            3 => O15RES_A::TOGGLE_OUTPUT,
1601            _ => unreachable!(),
1602        }
1603    }
1604    #[doc = "Checks if the value of the field is `NO_CHANGE`"]
1605    #[inline(always)]
1606    pub fn is_no_change(&self) -> bool {
1607        **self == O15RES_A::NO_CHANGE
1608    }
1609    #[doc = "Checks if the value of the field is `SET`"]
1610    #[inline(always)]
1611    pub fn is_set(&self) -> bool {
1612        **self == O15RES_A::SET
1613    }
1614    #[doc = "Checks if the value of the field is `CLEAR`"]
1615    #[inline(always)]
1616    pub fn is_clear(&self) -> bool {
1617        **self == O15RES_A::CLEAR
1618    }
1619    #[doc = "Checks if the value of the field is `TOGGLE_OUTPUT`"]
1620    #[inline(always)]
1621    pub fn is_toggle_output(&self) -> bool {
1622        **self == O15RES_A::TOGGLE_OUTPUT
1623    }
1624}
1625impl core::ops::Deref for O15RES_R {
1626    type Target = crate::FieldReader<u8, O15RES_A>;
1627    #[inline(always)]
1628    fn deref(&self) -> &Self::Target {
1629        &self.0
1630    }
1631}
1632#[doc = "Field `O15RES` writer - Effect of simultaneous set and clear on output 15."]
1633pub struct O15RES_W<'a> {
1634    w: &'a mut W,
1635}
1636impl<'a> O15RES_W<'a> {
1637    #[doc = r"Writes `variant` to the field"]
1638    #[inline(always)]
1639    pub fn variant(self, variant: O15RES_A) -> &'a mut W {
1640        self.bits(variant.into())
1641    }
1642    #[doc = "No change."]
1643    #[inline(always)]
1644    pub fn no_change(self) -> &'a mut W {
1645        self.variant(O15RES_A::NO_CHANGE)
1646    }
1647    #[doc = "Set output (or clear based on the SETCLR15 field in the OUTPUTDIRCTRL register)."]
1648    #[inline(always)]
1649    pub fn set(self) -> &'a mut W {
1650        self.variant(O15RES_A::SET)
1651    }
1652    #[doc = "Clear output (or set based on the SETCLR15 field)."]
1653    #[inline(always)]
1654    pub fn clear(self) -> &'a mut W {
1655        self.variant(O15RES_A::CLEAR)
1656    }
1657    #[doc = "Toggle output."]
1658    #[inline(always)]
1659    pub fn toggle_output(self) -> &'a mut W {
1660        self.variant(O15RES_A::TOGGLE_OUTPUT)
1661    }
1662    #[doc = r"Writes raw bits to the field"]
1663    #[inline(always)]
1664    pub fn bits(self, value: u8) -> &'a mut W {
1665        self.w.bits = (self.w.bits & !(0x03 << 30)) | ((value as u32 & 0x03) << 30);
1666        self.w
1667    }
1668}
1669impl R {
1670    #[doc = "Bits 0:1 - Effect of simultaneous set and clear on output 0."]
1671    #[inline(always)]
1672    pub fn o0res(&self) -> O0RES_R {
1673        O0RES_R::new((self.bits & 0x03) as u8)
1674    }
1675    #[doc = "Bits 2:3 - Effect of simultaneous set and clear on output 1."]
1676    #[inline(always)]
1677    pub fn o1res(&self) -> O1RES_R {
1678        O1RES_R::new(((self.bits >> 2) & 0x03) as u8)
1679    }
1680    #[doc = "Bits 4:5 - Effect of simultaneous set and clear on output 2."]
1681    #[inline(always)]
1682    pub fn o2res(&self) -> O2RES_R {
1683        O2RES_R::new(((self.bits >> 4) & 0x03) as u8)
1684    }
1685    #[doc = "Bits 6:7 - Effect of simultaneous set and clear on output 3."]
1686    #[inline(always)]
1687    pub fn o3res(&self) -> O3RES_R {
1688        O3RES_R::new(((self.bits >> 6) & 0x03) as u8)
1689    }
1690    #[doc = "Bits 8:9 - Effect of simultaneous set and clear on output 4."]
1691    #[inline(always)]
1692    pub fn o4res(&self) -> O4RES_R {
1693        O4RES_R::new(((self.bits >> 8) & 0x03) as u8)
1694    }
1695    #[doc = "Bits 10:11 - Effect of simultaneous set and clear on output 5."]
1696    #[inline(always)]
1697    pub fn o5res(&self) -> O5RES_R {
1698        O5RES_R::new(((self.bits >> 10) & 0x03) as u8)
1699    }
1700    #[doc = "Bits 12:13 - Effect of simultaneous set and clear on output 6."]
1701    #[inline(always)]
1702    pub fn o6res(&self) -> O6RES_R {
1703        O6RES_R::new(((self.bits >> 12) & 0x03) as u8)
1704    }
1705    #[doc = "Bits 14:15 - Effect of simultaneous set and clear on output 7."]
1706    #[inline(always)]
1707    pub fn o7res(&self) -> O7RES_R {
1708        O7RES_R::new(((self.bits >> 14) & 0x03) as u8)
1709    }
1710    #[doc = "Bits 16:17 - Effect of simultaneous set and clear on output 8."]
1711    #[inline(always)]
1712    pub fn o8res(&self) -> O8RES_R {
1713        O8RES_R::new(((self.bits >> 16) & 0x03) as u8)
1714    }
1715    #[doc = "Bits 18:19 - Effect of simultaneous set and clear on output 9."]
1716    #[inline(always)]
1717    pub fn o9res(&self) -> O9RES_R {
1718        O9RES_R::new(((self.bits >> 18) & 0x03) as u8)
1719    }
1720    #[doc = "Bits 20:21 - Effect of simultaneous set and clear on output 10."]
1721    #[inline(always)]
1722    pub fn o10res(&self) -> O10RES_R {
1723        O10RES_R::new(((self.bits >> 20) & 0x03) as u8)
1724    }
1725    #[doc = "Bits 22:23 - Effect of simultaneous set and clear on output 11."]
1726    #[inline(always)]
1727    pub fn o11res(&self) -> O11RES_R {
1728        O11RES_R::new(((self.bits >> 22) & 0x03) as u8)
1729    }
1730    #[doc = "Bits 24:25 - Effect of simultaneous set and clear on output 12."]
1731    #[inline(always)]
1732    pub fn o12res(&self) -> O12RES_R {
1733        O12RES_R::new(((self.bits >> 24) & 0x03) as u8)
1734    }
1735    #[doc = "Bits 26:27 - Effect of simultaneous set and clear on output 13."]
1736    #[inline(always)]
1737    pub fn o13res(&self) -> O13RES_R {
1738        O13RES_R::new(((self.bits >> 26) & 0x03) as u8)
1739    }
1740    #[doc = "Bits 28:29 - Effect of simultaneous set and clear on output 14."]
1741    #[inline(always)]
1742    pub fn o14res(&self) -> O14RES_R {
1743        O14RES_R::new(((self.bits >> 28) & 0x03) as u8)
1744    }
1745    #[doc = "Bits 30:31 - Effect of simultaneous set and clear on output 15."]
1746    #[inline(always)]
1747    pub fn o15res(&self) -> O15RES_R {
1748        O15RES_R::new(((self.bits >> 30) & 0x03) as u8)
1749    }
1750}
1751impl W {
1752    #[doc = "Bits 0:1 - Effect of simultaneous set and clear on output 0."]
1753    #[inline(always)]
1754    pub fn o0res(&mut self) -> O0RES_W {
1755        O0RES_W { w: self }
1756    }
1757    #[doc = "Bits 2:3 - Effect of simultaneous set and clear on output 1."]
1758    #[inline(always)]
1759    pub fn o1res(&mut self) -> O1RES_W {
1760        O1RES_W { w: self }
1761    }
1762    #[doc = "Bits 4:5 - Effect of simultaneous set and clear on output 2."]
1763    #[inline(always)]
1764    pub fn o2res(&mut self) -> O2RES_W {
1765        O2RES_W { w: self }
1766    }
1767    #[doc = "Bits 6:7 - Effect of simultaneous set and clear on output 3."]
1768    #[inline(always)]
1769    pub fn o3res(&mut self) -> O3RES_W {
1770        O3RES_W { w: self }
1771    }
1772    #[doc = "Bits 8:9 - Effect of simultaneous set and clear on output 4."]
1773    #[inline(always)]
1774    pub fn o4res(&mut self) -> O4RES_W {
1775        O4RES_W { w: self }
1776    }
1777    #[doc = "Bits 10:11 - Effect of simultaneous set and clear on output 5."]
1778    #[inline(always)]
1779    pub fn o5res(&mut self) -> O5RES_W {
1780        O5RES_W { w: self }
1781    }
1782    #[doc = "Bits 12:13 - Effect of simultaneous set and clear on output 6."]
1783    #[inline(always)]
1784    pub fn o6res(&mut self) -> O6RES_W {
1785        O6RES_W { w: self }
1786    }
1787    #[doc = "Bits 14:15 - Effect of simultaneous set and clear on output 7."]
1788    #[inline(always)]
1789    pub fn o7res(&mut self) -> O7RES_W {
1790        O7RES_W { w: self }
1791    }
1792    #[doc = "Bits 16:17 - Effect of simultaneous set and clear on output 8."]
1793    #[inline(always)]
1794    pub fn o8res(&mut self) -> O8RES_W {
1795        O8RES_W { w: self }
1796    }
1797    #[doc = "Bits 18:19 - Effect of simultaneous set and clear on output 9."]
1798    #[inline(always)]
1799    pub fn o9res(&mut self) -> O9RES_W {
1800        O9RES_W { w: self }
1801    }
1802    #[doc = "Bits 20:21 - Effect of simultaneous set and clear on output 10."]
1803    #[inline(always)]
1804    pub fn o10res(&mut self) -> O10RES_W {
1805        O10RES_W { w: self }
1806    }
1807    #[doc = "Bits 22:23 - Effect of simultaneous set and clear on output 11."]
1808    #[inline(always)]
1809    pub fn o11res(&mut self) -> O11RES_W {
1810        O11RES_W { w: self }
1811    }
1812    #[doc = "Bits 24:25 - Effect of simultaneous set and clear on output 12."]
1813    #[inline(always)]
1814    pub fn o12res(&mut self) -> O12RES_W {
1815        O12RES_W { w: self }
1816    }
1817    #[doc = "Bits 26:27 - Effect of simultaneous set and clear on output 13."]
1818    #[inline(always)]
1819    pub fn o13res(&mut self) -> O13RES_W {
1820        O13RES_W { w: self }
1821    }
1822    #[doc = "Bits 28:29 - Effect of simultaneous set and clear on output 14."]
1823    #[inline(always)]
1824    pub fn o14res(&mut self) -> O14RES_W {
1825        O14RES_W { w: self }
1826    }
1827    #[doc = "Bits 30:31 - Effect of simultaneous set and clear on output 15."]
1828    #[inline(always)]
1829    pub fn o15res(&mut self) -> O15RES_W {
1830        O15RES_W { w: self }
1831    }
1832    #[doc = "Writes raw bits to the register."]
1833    #[inline(always)]
1834    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
1835        self.0.bits(bits);
1836        self
1837    }
1838}
1839#[doc = "SCT conflict resolution register\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 [res](index.html) module"]
1840pub struct RES_SPEC;
1841impl crate::RegisterSpec for RES_SPEC {
1842    type Ux = u32;
1843}
1844#[doc = "`read()` method returns [res::R](R) reader structure"]
1845impl crate::Readable for RES_SPEC {
1846    type Reader = R;
1847}
1848#[doc = "`write(|w| ..)` method takes [res::W](W) writer structure"]
1849impl crate::Writable for RES_SPEC {
1850    type Writer = W;
1851}
1852#[doc = "`reset()` method sets RES to value 0"]
1853impl crate::Resettable for RES_SPEC {
1854    #[inline(always)]
1855    fn reset_value() -> Self::Ux {
1856        0
1857    }
1858}
lpc55_pac/sct0/res.rs

lpc55_pac/sct0/
res.rs
