xmc1000/comparator/orcctrl/
mod.rs

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

xmc1000/comparator/orcctrl/
mod.rs
