ra2l1_pac/
adc120.rs

1/*
2DISCLAIMER
3This software is supplied by Renesas Electronics Corporation and is only intended for use with Renesas products.
4No other uses are authorized. This software is owned by Renesas Electronics Corporation and is protected under all
5applicable laws, including copyright laws.
6THIS SOFTWARE IS PROVIDED "AS IS" AND RENESAS MAKES NO WARRANTIES REGARDING THIS SOFTWARE, WHETHER EXPRESS, IMPLIED
7OR STATUTORY, INCLUDING BUT NOT LIMITED TO WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
8NON-INFRINGEMENT.  ALL SUCH WARRANTIES ARE EXPRESSLY DISCLAIMED.TO THE MAXIMUM EXTENT PERMITTED NOT PROHIBITED BY
9LAW, NEITHER RENESAS ELECTRONICS CORPORATION NOR ANY OF ITS AFFILIATED COMPANIES SHALL BE LIABLE FOR ANY DIRECT,
10INDIRECT, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES FOR ANY REASON RELATED TO THIS SOFTWARE, EVEN IF RENESAS OR
11ITS AFFILIATES HAVE BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES.
12Renesas reserves the right, without notice, to make changes to this software and to discontinue the availability
13of this software. By using this software, you agree to the additional terms and conditions found by accessing the
14following link:
15http://www.renesas.com/disclaimer
16
17*/
18// Generated from SVD 1.50.00, with svd2pac 0.6.1 on Sun, 15 Mar 2026 07:03:37 +0000
19
20#![allow(clippy::identity_op)]
21#![allow(clippy::module_inception)]
22#![allow(clippy::derivable_impls)]
23#[allow(unused_imports)]
24use crate::common::sealed;
25#[allow(unused_imports)]
26use crate::common::*;
27#[doc = r"12-bit A/D Converter"]
28unsafe impl ::core::marker::Send for super::Adc120 {}
29unsafe impl ::core::marker::Sync for super::Adc120 {}
30impl super::Adc120 {
31    #[allow(unused)]
32    #[inline(always)]
33    pub(crate) const fn _svd2pac_as_ptr(&self) -> *mut u8 {
34        self.ptr
35    }
36
37    #[doc = "A/D Control Register"]
38    #[inline(always)]
39    pub const fn adcsr(&self) -> &'static crate::common::Reg<self::Adcsr_SPEC, crate::common::RW> {
40        unsafe {
41            crate::common::Reg::<self::Adcsr_SPEC, crate::common::RW>::from_ptr(
42                self._svd2pac_as_ptr().add(0usize),
43            )
44        }
45    }
46
47    #[doc = "A/D Channel Select Register A0"]
48    #[inline(always)]
49    pub const fn adansa0(
50        &self,
51    ) -> &'static crate::common::Reg<self::Adansa0_SPEC, crate::common::RW> {
52        unsafe {
53            crate::common::Reg::<self::Adansa0_SPEC, crate::common::RW>::from_ptr(
54                self._svd2pac_as_ptr().add(4usize),
55            )
56        }
57    }
58
59    #[doc = "A/D Channel Select Register A1"]
60    #[inline(always)]
61    pub const fn adansa1(
62        &self,
63    ) -> &'static crate::common::Reg<self::Adansa1_SPEC, crate::common::RW> {
64        unsafe {
65            crate::common::Reg::<self::Adansa1_SPEC, crate::common::RW>::from_ptr(
66                self._svd2pac_as_ptr().add(6usize),
67            )
68        }
69    }
70
71    #[doc = "A/D-Converted Value Addition/Average Channel Select Register 0"]
72    #[inline(always)]
73    pub const fn adads0(
74        &self,
75    ) -> &'static crate::common::Reg<self::Adads0_SPEC, crate::common::RW> {
76        unsafe {
77            crate::common::Reg::<self::Adads0_SPEC, crate::common::RW>::from_ptr(
78                self._svd2pac_as_ptr().add(8usize),
79            )
80        }
81    }
82
83    #[doc = "A/D-Converted Value Addition/Average Channel Select Register 1"]
84    #[inline(always)]
85    pub const fn adads1(
86        &self,
87    ) -> &'static crate::common::Reg<self::Adads1_SPEC, crate::common::RW> {
88        unsafe {
89            crate::common::Reg::<self::Adads1_SPEC, crate::common::RW>::from_ptr(
90                self._svd2pac_as_ptr().add(10usize),
91            )
92        }
93    }
94
95    #[doc = "A/D-Converted Value Addition/Average Count Select Register"]
96    #[inline(always)]
97    pub const fn adadc(&self) -> &'static crate::common::Reg<self::Adadc_SPEC, crate::common::RW> {
98        unsafe {
99            crate::common::Reg::<self::Adadc_SPEC, crate::common::RW>::from_ptr(
100                self._svd2pac_as_ptr().add(12usize),
101            )
102        }
103    }
104
105    #[doc = "A/D Control Extended Register"]
106    #[inline(always)]
107    pub const fn adcer(&self) -> &'static crate::common::Reg<self::Adcer_SPEC, crate::common::RW> {
108        unsafe {
109            crate::common::Reg::<self::Adcer_SPEC, crate::common::RW>::from_ptr(
110                self._svd2pac_as_ptr().add(14usize),
111            )
112        }
113    }
114
115    #[doc = "A/D Conversion Start Trigger Select Register"]
116    #[inline(always)]
117    pub const fn adstrgr(
118        &self,
119    ) -> &'static crate::common::Reg<self::Adstrgr_SPEC, crate::common::RW> {
120        unsafe {
121            crate::common::Reg::<self::Adstrgr_SPEC, crate::common::RW>::from_ptr(
122                self._svd2pac_as_ptr().add(16usize),
123            )
124        }
125    }
126
127    #[doc = "A/D Conversion Extended Input Control Registers"]
128    #[inline(always)]
129    pub const fn adexicr(
130        &self,
131    ) -> &'static crate::common::Reg<self::Adexicr_SPEC, crate::common::RW> {
132        unsafe {
133            crate::common::Reg::<self::Adexicr_SPEC, crate::common::RW>::from_ptr(
134                self._svd2pac_as_ptr().add(18usize),
135            )
136        }
137    }
138
139    #[doc = "A/D Channel Select Register B0"]
140    #[inline(always)]
141    pub const fn adansb0(
142        &self,
143    ) -> &'static crate::common::Reg<self::Adansb0_SPEC, crate::common::RW> {
144        unsafe {
145            crate::common::Reg::<self::Adansb0_SPEC, crate::common::RW>::from_ptr(
146                self._svd2pac_as_ptr().add(20usize),
147            )
148        }
149    }
150
151    #[doc = "A/D Channel Select Register B1"]
152    #[inline(always)]
153    pub const fn adansb1(
154        &self,
155    ) -> &'static crate::common::Reg<self::Adansb1_SPEC, crate::common::RW> {
156        unsafe {
157            crate::common::Reg::<self::Adansb1_SPEC, crate::common::RW>::from_ptr(
158                self._svd2pac_as_ptr().add(22usize),
159            )
160        }
161    }
162
163    #[doc = "A/D Data Duplexing Register"]
164    #[inline(always)]
165    pub const fn addbldr(
166        &self,
167    ) -> &'static crate::common::Reg<self::Addbldr_SPEC, crate::common::R> {
168        unsafe {
169            crate::common::Reg::<self::Addbldr_SPEC, crate::common::R>::from_ptr(
170                self._svd2pac_as_ptr().add(24usize),
171            )
172        }
173    }
174
175    #[doc = "A/D Temperature Sensor Data Register"]
176    #[inline(always)]
177    pub const fn adtsdr(&self) -> &'static crate::common::Reg<self::Adtsdr_SPEC, crate::common::R> {
178        unsafe {
179            crate::common::Reg::<self::Adtsdr_SPEC, crate::common::R>::from_ptr(
180                self._svd2pac_as_ptr().add(26usize),
181            )
182        }
183    }
184
185    #[doc = "A/D Internal Reference Voltage Data Register"]
186    #[inline(always)]
187    pub const fn adocdr(&self) -> &'static crate::common::Reg<self::Adocdr_SPEC, crate::common::R> {
188        unsafe {
189            crate::common::Reg::<self::Adocdr_SPEC, crate::common::R>::from_ptr(
190                self._svd2pac_as_ptr().add(28usize),
191            )
192        }
193    }
194
195    #[doc = "A/D Self-Diagnosis Data Register"]
196    #[inline(always)]
197    pub const fn adrd(&self) -> &'static crate::common::Reg<self::Adrd_SPEC, crate::common::R> {
198        unsafe {
199            crate::common::Reg::<self::Adrd_SPEC, crate::common::R>::from_ptr(
200                self._svd2pac_as_ptr().add(30usize),
201            )
202        }
203    }
204
205    #[doc = "A/D CTSU TSCAP Voltage Data Register"]
206    #[inline(always)]
207    pub const fn adctdr(&self) -> &'static crate::common::Reg<self::Adctdr_SPEC, crate::common::R> {
208        unsafe {
209            crate::common::Reg::<self::Adctdr_SPEC, crate::common::R>::from_ptr(
210                self._svd2pac_as_ptr().add(64usize),
211            )
212        }
213    }
214
215    #[doc = "A/D Data Registers %s"]
216    #[inline(always)]
217    pub const fn addr(
218        &self,
219    ) -> &'static crate::common::ClusterRegisterArray<
220        crate::common::Reg<self::Addr_SPEC, crate::common::R>,
221        4,
222        0x2,
223    > {
224        unsafe {
225            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0x42usize))
226        }
227    }
228    #[inline(always)]
229    pub const fn addr17(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
230        unsafe {
231            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
232                self._svd2pac_as_ptr().add(0x42usize),
233            )
234        }
235    }
236    #[inline(always)]
237    pub const fn addr18(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
238        unsafe {
239            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
240                self._svd2pac_as_ptr().add(0x44usize),
241            )
242        }
243    }
244    #[inline(always)]
245    pub const fn addr19(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
246        unsafe {
247            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
248                self._svd2pac_as_ptr().add(0x46usize),
249            )
250        }
251    }
252    #[inline(always)]
253    pub const fn addr20(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
254        unsafe {
255            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
256                self._svd2pac_as_ptr().add(0x48usize),
257            )
258        }
259    }
260
261    #[doc = "A/D Disconnection Detection Control Register"]
262    #[inline(always)]
263    pub const fn addiscr(
264        &self,
265    ) -> &'static crate::common::Reg<self::Addiscr_SPEC, crate::common::RW> {
266        unsafe {
267            crate::common::Reg::<self::Addiscr_SPEC, crate::common::RW>::from_ptr(
268                self._svd2pac_as_ptr().add(122usize),
269            )
270        }
271    }
272
273    #[doc = "A/D Conversion Operation Mode Select Register"]
274    #[inline(always)]
275    pub const fn adacsr(
276        &self,
277    ) -> &'static crate::common::Reg<self::Adacsr_SPEC, crate::common::RW> {
278        unsafe {
279            crate::common::Reg::<self::Adacsr_SPEC, crate::common::RW>::from_ptr(
280                self._svd2pac_as_ptr().add(126usize),
281            )
282        }
283    }
284
285    #[doc = "A/D Group Scan Priority Control Register"]
286    #[inline(always)]
287    pub const fn adgspcr(
288        &self,
289    ) -> &'static crate::common::Reg<self::Adgspcr_SPEC, crate::common::RW> {
290        unsafe {
291            crate::common::Reg::<self::Adgspcr_SPEC, crate::common::RW>::from_ptr(
292                self._svd2pac_as_ptr().add(128usize),
293            )
294        }
295    }
296
297    #[doc = "A/D Data Duplexing Register A"]
298    #[inline(always)]
299    pub const fn addbldra(
300        &self,
301    ) -> &'static crate::common::Reg<self::Addbldra_SPEC, crate::common::R> {
302        unsafe {
303            crate::common::Reg::<self::Addbldra_SPEC, crate::common::R>::from_ptr(
304                self._svd2pac_as_ptr().add(132usize),
305            )
306        }
307    }
308
309    #[doc = "A/D Data Duplexing Register B"]
310    #[inline(always)]
311    pub const fn addbldrb(
312        &self,
313    ) -> &'static crate::common::Reg<self::Addbldrb_SPEC, crate::common::R> {
314        unsafe {
315            crate::common::Reg::<self::Addbldrb_SPEC, crate::common::R>::from_ptr(
316                self._svd2pac_as_ptr().add(134usize),
317            )
318        }
319    }
320
321    #[doc = "A/D High-Potential/Low-Potential Reference Voltage Control Register"]
322    #[inline(always)]
323    pub const fn adhvrefcnt(
324        &self,
325    ) -> &'static crate::common::Reg<self::Adhvrefcnt_SPEC, crate::common::RW> {
326        unsafe {
327            crate::common::Reg::<self::Adhvrefcnt_SPEC, crate::common::RW>::from_ptr(
328                self._svd2pac_as_ptr().add(138usize),
329            )
330        }
331    }
332
333    #[doc = "A/D Compare Function Window A/B Status Monitor Register"]
334    #[inline(always)]
335    pub const fn adwinmon(
336        &self,
337    ) -> &'static crate::common::Reg<self::Adwinmon_SPEC, crate::common::R> {
338        unsafe {
339            crate::common::Reg::<self::Adwinmon_SPEC, crate::common::R>::from_ptr(
340                self._svd2pac_as_ptr().add(140usize),
341            )
342        }
343    }
344
345    #[doc = "A/D Compare Function Control Register"]
346    #[inline(always)]
347    pub const fn adcmpcr(
348        &self,
349    ) -> &'static crate::common::Reg<self::Adcmpcr_SPEC, crate::common::RW> {
350        unsafe {
351            crate::common::Reg::<self::Adcmpcr_SPEC, crate::common::RW>::from_ptr(
352                self._svd2pac_as_ptr().add(144usize),
353            )
354        }
355    }
356
357    #[doc = "A/D Compare Function Window A Extended Input Select Register"]
358    #[inline(always)]
359    pub const fn adcmpanser(
360        &self,
361    ) -> &'static crate::common::Reg<self::Adcmpanser_SPEC, crate::common::RW> {
362        unsafe {
363            crate::common::Reg::<self::Adcmpanser_SPEC, crate::common::RW>::from_ptr(
364                self._svd2pac_as_ptr().add(146usize),
365            )
366        }
367    }
368
369    #[doc = "A/D Compare Function Window A Extended Input Comparison Condition Setting Register"]
370    #[inline(always)]
371    pub const fn adcmpler(
372        &self,
373    ) -> &'static crate::common::Reg<self::Adcmpler_SPEC, crate::common::RW> {
374        unsafe {
375            crate::common::Reg::<self::Adcmpler_SPEC, crate::common::RW>::from_ptr(
376                self._svd2pac_as_ptr().add(147usize),
377            )
378        }
379    }
380
381    #[doc = "A/D Compare Function Window A Channel Select Register 0"]
382    #[inline(always)]
383    pub const fn adcmpansr0(
384        &self,
385    ) -> &'static crate::common::Reg<self::Adcmpansr0_SPEC, crate::common::RW> {
386        unsafe {
387            crate::common::Reg::<self::Adcmpansr0_SPEC, crate::common::RW>::from_ptr(
388                self._svd2pac_as_ptr().add(148usize),
389            )
390        }
391    }
392
393    #[doc = "A/D Compare Function Window A Channel Select Register 1"]
394    #[inline(always)]
395    pub const fn adcmpansr1(
396        &self,
397    ) -> &'static crate::common::Reg<self::Adcmpansr1_SPEC, crate::common::RW> {
398        unsafe {
399            crate::common::Reg::<self::Adcmpansr1_SPEC, crate::common::RW>::from_ptr(
400                self._svd2pac_as_ptr().add(150usize),
401            )
402        }
403    }
404
405    #[doc = "A/D Compare Function Window A Comparison Condition Setting Register 0"]
406    #[inline(always)]
407    pub const fn adcmplr0(
408        &self,
409    ) -> &'static crate::common::Reg<self::Adcmplr0_SPEC, crate::common::RW> {
410        unsafe {
411            crate::common::Reg::<self::Adcmplr0_SPEC, crate::common::RW>::from_ptr(
412                self._svd2pac_as_ptr().add(152usize),
413            )
414        }
415    }
416
417    #[doc = "A/D Compare Function Window A Comparison Condition Setting Register 1"]
418    #[inline(always)]
419    pub const fn adcmplr1(
420        &self,
421    ) -> &'static crate::common::Reg<self::Adcmplr1_SPEC, crate::common::RW> {
422        unsafe {
423            crate::common::Reg::<self::Adcmplr1_SPEC, crate::common::RW>::from_ptr(
424                self._svd2pac_as_ptr().add(154usize),
425            )
426        }
427    }
428
429    #[doc = "A/D Compare Function Window A Lower-Side/Upper-Side Level Setting Register"]
430    #[inline(always)]
431    pub const fn adcmpdr(
432        &self,
433    ) -> &'static crate::common::ClusterRegisterArray<
434        crate::common::Reg<self::Adcmpdr_SPEC, crate::common::RW>,
435        2,
436        0x2,
437    > {
438        unsafe {
439            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0x9cusize))
440        }
441    }
442    #[inline(always)]
443    pub const fn adcmpdr0(
444        &self,
445    ) -> &'static crate::common::Reg<self::Adcmpdr_SPEC, crate::common::RW> {
446        unsafe {
447            crate::common::Reg::<self::Adcmpdr_SPEC, crate::common::RW>::from_ptr(
448                self._svd2pac_as_ptr().add(0x9cusize),
449            )
450        }
451    }
452    #[inline(always)]
453    pub const fn adcmpdr1(
454        &self,
455    ) -> &'static crate::common::Reg<self::Adcmpdr_SPEC, crate::common::RW> {
456        unsafe {
457            crate::common::Reg::<self::Adcmpdr_SPEC, crate::common::RW>::from_ptr(
458                self._svd2pac_as_ptr().add(0x9eusize),
459            )
460        }
461    }
462
463    #[doc = "A/D Compare Function Window A Channel Status Register 0"]
464    #[inline(always)]
465    pub const fn adcmpsr0(
466        &self,
467    ) -> &'static crate::common::Reg<self::Adcmpsr0_SPEC, crate::common::RW> {
468        unsafe {
469            crate::common::Reg::<self::Adcmpsr0_SPEC, crate::common::RW>::from_ptr(
470                self._svd2pac_as_ptr().add(160usize),
471            )
472        }
473    }
474
475    #[doc = "A/D Compare Function Window A Channel Status Register1"]
476    #[inline(always)]
477    pub const fn adcmpsr1(
478        &self,
479    ) -> &'static crate::common::Reg<self::Adcmpsr1_SPEC, crate::common::RW> {
480        unsafe {
481            crate::common::Reg::<self::Adcmpsr1_SPEC, crate::common::RW>::from_ptr(
482                self._svd2pac_as_ptr().add(162usize),
483            )
484        }
485    }
486
487    #[doc = "A/D Compare Function Window A Extended Input Channel Status Register"]
488    #[inline(always)]
489    pub const fn adcmpser(
490        &self,
491    ) -> &'static crate::common::Reg<self::Adcmpser_SPEC, crate::common::RW> {
492        unsafe {
493            crate::common::Reg::<self::Adcmpser_SPEC, crate::common::RW>::from_ptr(
494                self._svd2pac_as_ptr().add(164usize),
495            )
496        }
497    }
498
499    #[doc = "A/D Compare Function Window B Channel Select Register"]
500    #[inline(always)]
501    pub const fn adcmpbnsr(
502        &self,
503    ) -> &'static crate::common::Reg<self::Adcmpbnsr_SPEC, crate::common::RW> {
504        unsafe {
505            crate::common::Reg::<self::Adcmpbnsr_SPEC, crate::common::RW>::from_ptr(
506                self._svd2pac_as_ptr().add(166usize),
507            )
508        }
509    }
510
511    #[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
512    #[inline(always)]
513    pub const fn adwinllb(
514        &self,
515    ) -> &'static crate::common::Reg<self::Adwinllb_SPEC, crate::common::RW> {
516        unsafe {
517            crate::common::Reg::<self::Adwinllb_SPEC, crate::common::RW>::from_ptr(
518                self._svd2pac_as_ptr().add(168usize),
519            )
520        }
521    }
522
523    #[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
524    #[inline(always)]
525    pub const fn adwinulb(
526        &self,
527    ) -> &'static crate::common::Reg<self::Adwinulb_SPEC, crate::common::RW> {
528        unsafe {
529            crate::common::Reg::<self::Adwinulb_SPEC, crate::common::RW>::from_ptr(
530                self._svd2pac_as_ptr().add(170usize),
531            )
532        }
533    }
534
535    #[doc = "A/D Compare Function Window B Status Register"]
536    #[inline(always)]
537    pub const fn adcmpbsr(
538        &self,
539    ) -> &'static crate::common::Reg<self::Adcmpbsr_SPEC, crate::common::RW> {
540        unsafe {
541            crate::common::Reg::<self::Adcmpbsr_SPEC, crate::common::RW>::from_ptr(
542                self._svd2pac_as_ptr().add(172usize),
543            )
544        }
545    }
546
547    #[doc = "A/D Sampling State Register"]
548    #[inline(always)]
549    pub const fn adsstrl(
550        &self,
551    ) -> &'static crate::common::Reg<self::Adsstrl_SPEC, crate::common::RW> {
552        unsafe {
553            crate::common::Reg::<self::Adsstrl_SPEC, crate::common::RW>::from_ptr(
554                self._svd2pac_as_ptr().add(221usize),
555            )
556        }
557    }
558
559    #[doc = "A/D Sampling State Register"]
560    #[inline(always)]
561    pub const fn adsstrt(
562        &self,
563    ) -> &'static crate::common::Reg<self::Adsstrt_SPEC, crate::common::RW> {
564        unsafe {
565            crate::common::Reg::<self::Adsstrt_SPEC, crate::common::RW>::from_ptr(
566                self._svd2pac_as_ptr().add(222usize),
567            )
568        }
569    }
570
571    #[doc = "A/D Sampling State Register"]
572    #[inline(always)]
573    pub const fn adsstro(
574        &self,
575    ) -> &'static crate::common::Reg<self::Adsstro_SPEC, crate::common::RW> {
576        unsafe {
577            crate::common::Reg::<self::Adsstro_SPEC, crate::common::RW>::from_ptr(
578                self._svd2pac_as_ptr().add(223usize),
579            )
580        }
581    }
582
583    #[doc = "A/D Sampling State Register"]
584    #[inline(always)]
585    pub const fn adsstr(
586        &self,
587    ) -> &'static crate::common::ClusterRegisterArray<
588        crate::common::Reg<self::Adsstr_SPEC, crate::common::RW>,
589        15,
590        0x1,
591    > {
592        unsafe {
593            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0xe0usize))
594        }
595    }
596    #[inline(always)]
597    pub const fn adsstr0(
598        &self,
599    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
600        unsafe {
601            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
602                self._svd2pac_as_ptr().add(0xe0usize),
603            )
604        }
605    }
606    #[inline(always)]
607    pub const fn adsstr1(
608        &self,
609    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
610        unsafe {
611            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
612                self._svd2pac_as_ptr().add(0xe1usize),
613            )
614        }
615    }
616    #[inline(always)]
617    pub const fn adsstr2(
618        &self,
619    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
620        unsafe {
621            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
622                self._svd2pac_as_ptr().add(0xe2usize),
623            )
624        }
625    }
626    #[inline(always)]
627    pub const fn adsstr3(
628        &self,
629    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
630        unsafe {
631            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
632                self._svd2pac_as_ptr().add(0xe3usize),
633            )
634        }
635    }
636    #[inline(always)]
637    pub const fn adsstr4(
638        &self,
639    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
640        unsafe {
641            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
642                self._svd2pac_as_ptr().add(0xe4usize),
643            )
644        }
645    }
646    #[inline(always)]
647    pub const fn adsstr5(
648        &self,
649    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
650        unsafe {
651            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
652                self._svd2pac_as_ptr().add(0xe5usize),
653            )
654        }
655    }
656    #[inline(always)]
657    pub const fn adsstr6(
658        &self,
659    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
660        unsafe {
661            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
662                self._svd2pac_as_ptr().add(0xe6usize),
663            )
664        }
665    }
666    #[inline(always)]
667    pub const fn adsstr7(
668        &self,
669    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
670        unsafe {
671            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
672                self._svd2pac_as_ptr().add(0xe7usize),
673            )
674        }
675    }
676    #[inline(always)]
677    pub const fn adsstr8(
678        &self,
679    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
680        unsafe {
681            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
682                self._svd2pac_as_ptr().add(0xe8usize),
683            )
684        }
685    }
686    #[inline(always)]
687    pub const fn adsstr9(
688        &self,
689    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
690        unsafe {
691            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
692                self._svd2pac_as_ptr().add(0xe9usize),
693            )
694        }
695    }
696    #[inline(always)]
697    pub const fn adsstr10(
698        &self,
699    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
700        unsafe {
701            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
702                self._svd2pac_as_ptr().add(0xeausize),
703            )
704        }
705    }
706    #[inline(always)]
707    pub const fn adsstr11(
708        &self,
709    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
710        unsafe {
711            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
712                self._svd2pac_as_ptr().add(0xebusize),
713            )
714        }
715    }
716    #[inline(always)]
717    pub const fn adsstr12(
718        &self,
719    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
720        unsafe {
721            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
722                self._svd2pac_as_ptr().add(0xecusize),
723            )
724        }
725    }
726    #[inline(always)]
727    pub const fn adsstr13(
728        &self,
729    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
730        unsafe {
731            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
732                self._svd2pac_as_ptr().add(0xedusize),
733            )
734        }
735    }
736    #[inline(always)]
737    pub const fn adsstr14(
738        &self,
739    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
740        unsafe {
741            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
742                self._svd2pac_as_ptr().add(0xeeusize),
743            )
744        }
745    }
746}
747#[doc(hidden)]
748#[derive(Copy, Clone, Eq, PartialEq)]
749pub struct Adcsr_SPEC;
750impl crate::sealed::RegSpec for Adcsr_SPEC {
751    type DataType = u16;
752}
753
754#[doc = "A/D Control Register"]
755pub type Adcsr = crate::RegValueT<Adcsr_SPEC>;
756
757impl Adcsr {
758    #[doc = "Double Trigger Channel Select"]
759    #[inline(always)]
760    pub fn dblans(
761        self,
762    ) -> crate::common::RegisterField<0, 0x1f, 1, 0, u8, u8, Adcsr_SPEC, crate::common::RW> {
763        crate::common::RegisterField::<0,0x1f,1,0,u8,u8,Adcsr_SPEC,crate::common::RW>::from_register(self,0)
764    }
765
766    #[doc = "Group B Scan End Interrupt and ELC Event Enable"]
767    #[inline(always)]
768    pub fn gbadie(
769        self,
770    ) -> crate::common::RegisterField<
771        6,
772        0x1,
773        1,
774        0,
775        adcsr::Gbadie,
776        adcsr::Gbadie,
777        Adcsr_SPEC,
778        crate::common::RW,
779    > {
780        crate::common::RegisterField::<
781            6,
782            0x1,
783            1,
784            0,
785            adcsr::Gbadie,
786            adcsr::Gbadie,
787            Adcsr_SPEC,
788            crate::common::RW,
789        >::from_register(self, 0)
790    }
791
792    #[doc = "Double Trigger Mode Select"]
793    #[inline(always)]
794    pub fn dble(
795        self,
796    ) -> crate::common::RegisterField<
797        7,
798        0x1,
799        1,
800        0,
801        adcsr::Dble,
802        adcsr::Dble,
803        Adcsr_SPEC,
804        crate::common::RW,
805    > {
806        crate::common::RegisterField::<
807            7,
808            0x1,
809            1,
810            0,
811            adcsr::Dble,
812            adcsr::Dble,
813            Adcsr_SPEC,
814            crate::common::RW,
815        >::from_register(self, 0)
816    }
817
818    #[doc = "Trigger Select"]
819    #[inline(always)]
820    pub fn extrg(
821        self,
822    ) -> crate::common::RegisterField<
823        8,
824        0x1,
825        1,
826        0,
827        adcsr::Extrg,
828        adcsr::Extrg,
829        Adcsr_SPEC,
830        crate::common::RW,
831    > {
832        crate::common::RegisterField::<
833            8,
834            0x1,
835            1,
836            0,
837            adcsr::Extrg,
838            adcsr::Extrg,
839            Adcsr_SPEC,
840            crate::common::RW,
841        >::from_register(self, 0)
842    }
843
844    #[doc = "Trigger Start Enable"]
845    #[inline(always)]
846    pub fn trge(
847        self,
848    ) -> crate::common::RegisterField<
849        9,
850        0x1,
851        1,
852        0,
853        adcsr::Trge,
854        adcsr::Trge,
855        Adcsr_SPEC,
856        crate::common::RW,
857    > {
858        crate::common::RegisterField::<
859            9,
860            0x1,
861            1,
862            0,
863            adcsr::Trge,
864            adcsr::Trge,
865            Adcsr_SPEC,
866            crate::common::RW,
867        >::from_register(self, 0)
868    }
869
870    #[doc = "A/D Conversion Mode Select"]
871    #[inline(always)]
872    pub fn adhsc(
873        self,
874    ) -> crate::common::RegisterField<
875        10,
876        0x1,
877        1,
878        0,
879        adcsr::Adhsc,
880        adcsr::Adhsc,
881        Adcsr_SPEC,
882        crate::common::RW,
883    > {
884        crate::common::RegisterField::<
885            10,
886            0x1,
887            1,
888            0,
889            adcsr::Adhsc,
890            adcsr::Adhsc,
891            Adcsr_SPEC,
892            crate::common::RW,
893        >::from_register(self, 0)
894    }
895
896    #[doc = "Scan Mode Select"]
897    #[inline(always)]
898    pub fn adcs(
899        self,
900    ) -> crate::common::RegisterField<
901        13,
902        0x3,
903        1,
904        0,
905        adcsr::Adcs,
906        adcsr::Adcs,
907        Adcsr_SPEC,
908        crate::common::RW,
909    > {
910        crate::common::RegisterField::<
911            13,
912            0x3,
913            1,
914            0,
915            adcsr::Adcs,
916            adcsr::Adcs,
917            Adcsr_SPEC,
918            crate::common::RW,
919        >::from_register(self, 0)
920    }
921
922    #[doc = "A/D Conversion Start"]
923    #[inline(always)]
924    pub fn adst(
925        self,
926    ) -> crate::common::RegisterField<
927        15,
928        0x1,
929        1,
930        0,
931        adcsr::Adst,
932        adcsr::Adst,
933        Adcsr_SPEC,
934        crate::common::RW,
935    > {
936        crate::common::RegisterField::<
937            15,
938            0x1,
939            1,
940            0,
941            adcsr::Adst,
942            adcsr::Adst,
943            Adcsr_SPEC,
944            crate::common::RW,
945        >::from_register(self, 0)
946    }
947}
948impl ::core::default::Default for Adcsr {
949    #[inline(always)]
950    fn default() -> Adcsr {
951        <crate::RegValueT<Adcsr_SPEC> as RegisterValue<_>>::new(0)
952    }
953}
954pub mod adcsr {
955
956    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
957    pub struct Gbadie_SPEC;
958    pub type Gbadie = crate::EnumBitfieldStruct<u8, Gbadie_SPEC>;
959    impl Gbadie {
960        #[doc = "Disable ADC120_GBADI interrupt generation on group B scan completion."]
961        pub const _0: Self = Self::new(0);
962
963        #[doc = "Enable ADC120_GBADI interrupt generation on group B scan completion."]
964        pub const _1: Self = Self::new(1);
965    }
966    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
967    pub struct Dble_SPEC;
968    pub type Dble = crate::EnumBitfieldStruct<u8, Dble_SPEC>;
969    impl Dble {
970        #[doc = "Deselect double-trigger mode."]
971        pub const _0: Self = Self::new(0);
972
973        #[doc = "Select double-trigger mode."]
974        pub const _1: Self = Self::new(1);
975    }
976    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
977    pub struct Extrg_SPEC;
978    pub type Extrg = crate::EnumBitfieldStruct<u8, Extrg_SPEC>;
979    impl Extrg {
980        #[doc = "Start A/D conversion by the synchronous trigger (ELC)."]
981        pub const _0: Self = Self::new(0);
982
983        #[doc = "Start A/D conversion by the asynchronous trigger (ADTRG0)."]
984        pub const _1: Self = Self::new(1);
985    }
986    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
987    pub struct Trge_SPEC;
988    pub type Trge = crate::EnumBitfieldStruct<u8, Trge_SPEC>;
989    impl Trge {
990        #[doc = "Disable A/D conversion to be started by the synchronous or asynchronous trigger"]
991        pub const _0: Self = Self::new(0);
992
993        #[doc = "Enable A/D conversion to be started by the synchronous or asynchronous trigger"]
994        pub const _1: Self = Self::new(1);
995    }
996    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
997    pub struct Adhsc_SPEC;
998    pub type Adhsc = crate::EnumBitfieldStruct<u8, Adhsc_SPEC>;
999    impl Adhsc {
1000        #[doc = "High-speed A/D conversion mode"]
1001        pub const _0: Self = Self::new(0);
1002
1003        #[doc = "Low-power A/D conversion mode"]
1004        pub const _1: Self = Self::new(1);
1005    }
1006    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1007    pub struct Adcs_SPEC;
1008    pub type Adcs = crate::EnumBitfieldStruct<u8, Adcs_SPEC>;
1009    impl Adcs {
1010        #[doc = "Single scan mode"]
1011        pub const _00: Self = Self::new(0);
1012
1013        #[doc = "Group scan mode"]
1014        pub const _01: Self = Self::new(1);
1015
1016        #[doc = "Continuous scan mode"]
1017        pub const _10: Self = Self::new(2);
1018
1019        #[doc = "Setting prohibited"]
1020        pub const _11: Self = Self::new(3);
1021    }
1022    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1023    pub struct Adst_SPEC;
1024    pub type Adst = crate::EnumBitfieldStruct<u8, Adst_SPEC>;
1025    impl Adst {
1026        #[doc = "Stop A/D conversion process."]
1027        pub const _0: Self = Self::new(0);
1028
1029        #[doc = "Start A/D conversion process."]
1030        pub const _1: Self = Self::new(1);
1031    }
1032}
1033#[doc(hidden)]
1034#[derive(Copy, Clone, Eq, PartialEq)]
1035pub struct Adansa0_SPEC;
1036impl crate::sealed::RegSpec for Adansa0_SPEC {
1037    type DataType = u16;
1038}
1039
1040#[doc = "A/D Channel Select Register A0"]
1041pub type Adansa0 = crate::RegValueT<Adansa0_SPEC>;
1042
1043impl Adansa0 {
1044    #[doc = "A/D Conversion Channels Select"]
1045    #[inline(always)]
1046    pub fn ansa00(
1047        self,
1048    ) -> crate::common::RegisterField<
1049        0,
1050        0x1,
1051        1,
1052        0,
1053        adansa0::Ansa00,
1054        adansa0::Ansa00,
1055        Adansa0_SPEC,
1056        crate::common::RW,
1057    > {
1058        crate::common::RegisterField::<
1059            0,
1060            0x1,
1061            1,
1062            0,
1063            adansa0::Ansa00,
1064            adansa0::Ansa00,
1065            Adansa0_SPEC,
1066            crate::common::RW,
1067        >::from_register(self, 0)
1068    }
1069
1070    #[doc = "A/D Conversion Channels Select"]
1071    #[inline(always)]
1072    pub fn ansa01(
1073        self,
1074    ) -> crate::common::RegisterField<
1075        1,
1076        0x1,
1077        1,
1078        0,
1079        adansa0::Ansa01,
1080        adansa0::Ansa01,
1081        Adansa0_SPEC,
1082        crate::common::RW,
1083    > {
1084        crate::common::RegisterField::<
1085            1,
1086            0x1,
1087            1,
1088            0,
1089            adansa0::Ansa01,
1090            adansa0::Ansa01,
1091            Adansa0_SPEC,
1092            crate::common::RW,
1093        >::from_register(self, 0)
1094    }
1095
1096    #[doc = "A/D Conversion Channels Select"]
1097    #[inline(always)]
1098    pub fn ansa02(
1099        self,
1100    ) -> crate::common::RegisterField<
1101        2,
1102        0x1,
1103        1,
1104        0,
1105        adansa0::Ansa02,
1106        adansa0::Ansa02,
1107        Adansa0_SPEC,
1108        crate::common::RW,
1109    > {
1110        crate::common::RegisterField::<
1111            2,
1112            0x1,
1113            1,
1114            0,
1115            adansa0::Ansa02,
1116            adansa0::Ansa02,
1117            Adansa0_SPEC,
1118            crate::common::RW,
1119        >::from_register(self, 0)
1120    }
1121
1122    #[doc = "A/D Conversion Channels Select"]
1123    #[inline(always)]
1124    pub fn ansa03(
1125        self,
1126    ) -> crate::common::RegisterField<
1127        3,
1128        0x1,
1129        1,
1130        0,
1131        adansa0::Ansa03,
1132        adansa0::Ansa03,
1133        Adansa0_SPEC,
1134        crate::common::RW,
1135    > {
1136        crate::common::RegisterField::<
1137            3,
1138            0x1,
1139            1,
1140            0,
1141            adansa0::Ansa03,
1142            adansa0::Ansa03,
1143            Adansa0_SPEC,
1144            crate::common::RW,
1145        >::from_register(self, 0)
1146    }
1147
1148    #[doc = "A/D Conversion Channels Select"]
1149    #[inline(always)]
1150    pub fn ansa04(
1151        self,
1152    ) -> crate::common::RegisterField<
1153        4,
1154        0x1,
1155        1,
1156        0,
1157        adansa0::Ansa04,
1158        adansa0::Ansa04,
1159        Adansa0_SPEC,
1160        crate::common::RW,
1161    > {
1162        crate::common::RegisterField::<
1163            4,
1164            0x1,
1165            1,
1166            0,
1167            adansa0::Ansa04,
1168            adansa0::Ansa04,
1169            Adansa0_SPEC,
1170            crate::common::RW,
1171        >::from_register(self, 0)
1172    }
1173
1174    #[doc = "A/D Conversion Channels Select"]
1175    #[inline(always)]
1176    pub fn ansa05(
1177        self,
1178    ) -> crate::common::RegisterField<
1179        5,
1180        0x1,
1181        1,
1182        0,
1183        adansa0::Ansa05,
1184        adansa0::Ansa05,
1185        Adansa0_SPEC,
1186        crate::common::RW,
1187    > {
1188        crate::common::RegisterField::<
1189            5,
1190            0x1,
1191            1,
1192            0,
1193            adansa0::Ansa05,
1194            adansa0::Ansa05,
1195            Adansa0_SPEC,
1196            crate::common::RW,
1197        >::from_register(self, 0)
1198    }
1199
1200    #[doc = "A/D Conversion Channels Select"]
1201    #[inline(always)]
1202    pub fn ansa06(
1203        self,
1204    ) -> crate::common::RegisterField<
1205        6,
1206        0x1,
1207        1,
1208        0,
1209        adansa0::Ansa06,
1210        adansa0::Ansa06,
1211        Adansa0_SPEC,
1212        crate::common::RW,
1213    > {
1214        crate::common::RegisterField::<
1215            6,
1216            0x1,
1217            1,
1218            0,
1219            adansa0::Ansa06,
1220            adansa0::Ansa06,
1221            Adansa0_SPEC,
1222            crate::common::RW,
1223        >::from_register(self, 0)
1224    }
1225
1226    #[doc = "A/D Conversion Channels Select"]
1227    #[inline(always)]
1228    pub fn ansa07(
1229        self,
1230    ) -> crate::common::RegisterField<
1231        7,
1232        0x1,
1233        1,
1234        0,
1235        adansa0::Ansa07,
1236        adansa0::Ansa07,
1237        Adansa0_SPEC,
1238        crate::common::RW,
1239    > {
1240        crate::common::RegisterField::<
1241            7,
1242            0x1,
1243            1,
1244            0,
1245            adansa0::Ansa07,
1246            adansa0::Ansa07,
1247            Adansa0_SPEC,
1248            crate::common::RW,
1249        >::from_register(self, 0)
1250    }
1251
1252    #[doc = "A/D Conversion Channels Select"]
1253    #[inline(always)]
1254    pub fn ansa08(
1255        self,
1256    ) -> crate::common::RegisterField<
1257        8,
1258        0x1,
1259        1,
1260        0,
1261        adansa0::Ansa08,
1262        adansa0::Ansa08,
1263        Adansa0_SPEC,
1264        crate::common::RW,
1265    > {
1266        crate::common::RegisterField::<
1267            8,
1268            0x1,
1269            1,
1270            0,
1271            adansa0::Ansa08,
1272            adansa0::Ansa08,
1273            Adansa0_SPEC,
1274            crate::common::RW,
1275        >::from_register(self, 0)
1276    }
1277
1278    #[doc = "A/D Conversion Channels Select"]
1279    #[inline(always)]
1280    pub fn ansa09(
1281        self,
1282    ) -> crate::common::RegisterField<
1283        9,
1284        0x1,
1285        1,
1286        0,
1287        adansa0::Ansa09,
1288        adansa0::Ansa09,
1289        Adansa0_SPEC,
1290        crate::common::RW,
1291    > {
1292        crate::common::RegisterField::<
1293            9,
1294            0x1,
1295            1,
1296            0,
1297            adansa0::Ansa09,
1298            adansa0::Ansa09,
1299            Adansa0_SPEC,
1300            crate::common::RW,
1301        >::from_register(self, 0)
1302    }
1303
1304    #[doc = "A/D Conversion Channels Select"]
1305    #[inline(always)]
1306    pub fn ansa10(
1307        self,
1308    ) -> crate::common::RegisterField<
1309        10,
1310        0x1,
1311        1,
1312        0,
1313        adansa0::Ansa10,
1314        adansa0::Ansa10,
1315        Adansa0_SPEC,
1316        crate::common::RW,
1317    > {
1318        crate::common::RegisterField::<
1319            10,
1320            0x1,
1321            1,
1322            0,
1323            adansa0::Ansa10,
1324            adansa0::Ansa10,
1325            Adansa0_SPEC,
1326            crate::common::RW,
1327        >::from_register(self, 0)
1328    }
1329
1330    #[doc = "A/D Conversion Channels Select"]
1331    #[inline(always)]
1332    pub fn ansa11(
1333        self,
1334    ) -> crate::common::RegisterField<
1335        11,
1336        0x1,
1337        1,
1338        0,
1339        adansa0::Ansa11,
1340        adansa0::Ansa11,
1341        Adansa0_SPEC,
1342        crate::common::RW,
1343    > {
1344        crate::common::RegisterField::<
1345            11,
1346            0x1,
1347            1,
1348            0,
1349            adansa0::Ansa11,
1350            adansa0::Ansa11,
1351            Adansa0_SPEC,
1352            crate::common::RW,
1353        >::from_register(self, 0)
1354    }
1355
1356    #[doc = "A/D Conversion Channels Select"]
1357    #[inline(always)]
1358    pub fn ansa12(
1359        self,
1360    ) -> crate::common::RegisterField<
1361        12,
1362        0x1,
1363        1,
1364        0,
1365        adansa0::Ansa12,
1366        adansa0::Ansa12,
1367        Adansa0_SPEC,
1368        crate::common::RW,
1369    > {
1370        crate::common::RegisterField::<
1371            12,
1372            0x1,
1373            1,
1374            0,
1375            adansa0::Ansa12,
1376            adansa0::Ansa12,
1377            Adansa0_SPEC,
1378            crate::common::RW,
1379        >::from_register(self, 0)
1380    }
1381
1382    #[doc = "A/D Conversion Channels Select"]
1383    #[inline(always)]
1384    pub fn ansa13(
1385        self,
1386    ) -> crate::common::RegisterField<
1387        13,
1388        0x1,
1389        1,
1390        0,
1391        adansa0::Ansa13,
1392        adansa0::Ansa13,
1393        Adansa0_SPEC,
1394        crate::common::RW,
1395    > {
1396        crate::common::RegisterField::<
1397            13,
1398            0x1,
1399            1,
1400            0,
1401            adansa0::Ansa13,
1402            adansa0::Ansa13,
1403            Adansa0_SPEC,
1404            crate::common::RW,
1405        >::from_register(self, 0)
1406    }
1407
1408    #[doc = "A/D Conversion Channels Select"]
1409    #[inline(always)]
1410    pub fn ansa14(
1411        self,
1412    ) -> crate::common::RegisterField<
1413        14,
1414        0x1,
1415        1,
1416        0,
1417        adansa0::Ansa14,
1418        adansa0::Ansa14,
1419        Adansa0_SPEC,
1420        crate::common::RW,
1421    > {
1422        crate::common::RegisterField::<
1423            14,
1424            0x1,
1425            1,
1426            0,
1427            adansa0::Ansa14,
1428            adansa0::Ansa14,
1429            Adansa0_SPEC,
1430            crate::common::RW,
1431        >::from_register(self, 0)
1432    }
1433
1434    #[doc = "A/D Conversion Channels Select"]
1435    #[inline(always)]
1436    pub fn ansa15(
1437        self,
1438    ) -> crate::common::RegisterField<
1439        15,
1440        0x1,
1441        1,
1442        0,
1443        adansa0::Ansa15,
1444        adansa0::Ansa15,
1445        Adansa0_SPEC,
1446        crate::common::RW,
1447    > {
1448        crate::common::RegisterField::<
1449            15,
1450            0x1,
1451            1,
1452            0,
1453            adansa0::Ansa15,
1454            adansa0::Ansa15,
1455            Adansa0_SPEC,
1456            crate::common::RW,
1457        >::from_register(self, 0)
1458    }
1459}
1460impl ::core::default::Default for Adansa0 {
1461    #[inline(always)]
1462    fn default() -> Adansa0 {
1463        <crate::RegValueT<Adansa0_SPEC> as RegisterValue<_>>::new(0)
1464    }
1465}
1466pub mod adansa0 {
1467
1468    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1469    pub struct Ansa00_SPEC;
1470    pub type Ansa00 = crate::EnumBitfieldStruct<u8, Ansa00_SPEC>;
1471    impl Ansa00 {
1472        #[doc = "Do not select associated input channel."]
1473        pub const _0: Self = Self::new(0);
1474
1475        #[doc = "Select associated input channel."]
1476        pub const _1: Self = Self::new(1);
1477    }
1478    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1479    pub struct Ansa01_SPEC;
1480    pub type Ansa01 = crate::EnumBitfieldStruct<u8, Ansa01_SPEC>;
1481    impl Ansa01 {
1482        #[doc = "Do not select associated input channel."]
1483        pub const _0: Self = Self::new(0);
1484
1485        #[doc = "Select associated input channel."]
1486        pub const _1: Self = Self::new(1);
1487    }
1488    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1489    pub struct Ansa02_SPEC;
1490    pub type Ansa02 = crate::EnumBitfieldStruct<u8, Ansa02_SPEC>;
1491    impl Ansa02 {
1492        #[doc = "Do not select associated input channel."]
1493        pub const _0: Self = Self::new(0);
1494
1495        #[doc = "Select associated input channel."]
1496        pub const _1: Self = Self::new(1);
1497    }
1498    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1499    pub struct Ansa03_SPEC;
1500    pub type Ansa03 = crate::EnumBitfieldStruct<u8, Ansa03_SPEC>;
1501    impl Ansa03 {
1502        #[doc = "Do not select associated input channel."]
1503        pub const _0: Self = Self::new(0);
1504
1505        #[doc = "Select associated input channel."]
1506        pub const _1: Self = Self::new(1);
1507    }
1508    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1509    pub struct Ansa04_SPEC;
1510    pub type Ansa04 = crate::EnumBitfieldStruct<u8, Ansa04_SPEC>;
1511    impl Ansa04 {
1512        #[doc = "Do not select associated input channel."]
1513        pub const _0: Self = Self::new(0);
1514
1515        #[doc = "Select associated input channel."]
1516        pub const _1: Self = Self::new(1);
1517    }
1518    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1519    pub struct Ansa05_SPEC;
1520    pub type Ansa05 = crate::EnumBitfieldStruct<u8, Ansa05_SPEC>;
1521    impl Ansa05 {
1522        #[doc = "Do not select associated input channel."]
1523        pub const _0: Self = Self::new(0);
1524
1525        #[doc = "Select associated input channel."]
1526        pub const _1: Self = Self::new(1);
1527    }
1528    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1529    pub struct Ansa06_SPEC;
1530    pub type Ansa06 = crate::EnumBitfieldStruct<u8, Ansa06_SPEC>;
1531    impl Ansa06 {
1532        #[doc = "Do not select associated input channel."]
1533        pub const _0: Self = Self::new(0);
1534
1535        #[doc = "Select associated input channel."]
1536        pub const _1: Self = Self::new(1);
1537    }
1538    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1539    pub struct Ansa07_SPEC;
1540    pub type Ansa07 = crate::EnumBitfieldStruct<u8, Ansa07_SPEC>;
1541    impl Ansa07 {
1542        #[doc = "Do not select associated input channel."]
1543        pub const _0: Self = Self::new(0);
1544
1545        #[doc = "Select associated input channel."]
1546        pub const _1: Self = Self::new(1);
1547    }
1548    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1549    pub struct Ansa08_SPEC;
1550    pub type Ansa08 = crate::EnumBitfieldStruct<u8, Ansa08_SPEC>;
1551    impl Ansa08 {
1552        #[doc = "Do not select associated input channel."]
1553        pub const _0: Self = Self::new(0);
1554
1555        #[doc = "Select associated input channel."]
1556        pub const _1: Self = Self::new(1);
1557    }
1558    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1559    pub struct Ansa09_SPEC;
1560    pub type Ansa09 = crate::EnumBitfieldStruct<u8, Ansa09_SPEC>;
1561    impl Ansa09 {
1562        #[doc = "Do not select associated input channel."]
1563        pub const _0: Self = Self::new(0);
1564
1565        #[doc = "Select associated input channel."]
1566        pub const _1: Self = Self::new(1);
1567    }
1568    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1569    pub struct Ansa10_SPEC;
1570    pub type Ansa10 = crate::EnumBitfieldStruct<u8, Ansa10_SPEC>;
1571    impl Ansa10 {
1572        #[doc = "Do not select associated input channel."]
1573        pub const _0: Self = Self::new(0);
1574
1575        #[doc = "Select associated input channel."]
1576        pub const _1: Self = Self::new(1);
1577    }
1578    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1579    pub struct Ansa11_SPEC;
1580    pub type Ansa11 = crate::EnumBitfieldStruct<u8, Ansa11_SPEC>;
1581    impl Ansa11 {
1582        #[doc = "Do not select associated input channel."]
1583        pub const _0: Self = Self::new(0);
1584
1585        #[doc = "Select associated input channel."]
1586        pub const _1: Self = Self::new(1);
1587    }
1588    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1589    pub struct Ansa12_SPEC;
1590    pub type Ansa12 = crate::EnumBitfieldStruct<u8, Ansa12_SPEC>;
1591    impl Ansa12 {
1592        #[doc = "Do not select associated input channel."]
1593        pub const _0: Self = Self::new(0);
1594
1595        #[doc = "Select associated input channel."]
1596        pub const _1: Self = Self::new(1);
1597    }
1598    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1599    pub struct Ansa13_SPEC;
1600    pub type Ansa13 = crate::EnumBitfieldStruct<u8, Ansa13_SPEC>;
1601    impl Ansa13 {
1602        #[doc = "Do not select associated input channel."]
1603        pub const _0: Self = Self::new(0);
1604
1605        #[doc = "Select associated input channel."]
1606        pub const _1: Self = Self::new(1);
1607    }
1608    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1609    pub struct Ansa14_SPEC;
1610    pub type Ansa14 = crate::EnumBitfieldStruct<u8, Ansa14_SPEC>;
1611    impl Ansa14 {
1612        #[doc = "Do not select associated input channel."]
1613        pub const _0: Self = Self::new(0);
1614
1615        #[doc = "Select associated input channel."]
1616        pub const _1: Self = Self::new(1);
1617    }
1618    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1619    pub struct Ansa15_SPEC;
1620    pub type Ansa15 = crate::EnumBitfieldStruct<u8, Ansa15_SPEC>;
1621    impl Ansa15 {
1622        #[doc = "Do not select associated input channel."]
1623        pub const _0: Self = Self::new(0);
1624
1625        #[doc = "Select associated input channel."]
1626        pub const _1: Self = Self::new(1);
1627    }
1628}
1629#[doc(hidden)]
1630#[derive(Copy, Clone, Eq, PartialEq)]
1631pub struct Adansa1_SPEC;
1632impl crate::sealed::RegSpec for Adansa1_SPEC {
1633    type DataType = u16;
1634}
1635
1636#[doc = "A/D Channel Select Register A1"]
1637pub type Adansa1 = crate::RegValueT<Adansa1_SPEC>;
1638
1639impl Adansa1 {
1640    #[doc = "A/D Conversion Channels Select"]
1641    #[inline(always)]
1642    pub fn ansa16(
1643        self,
1644    ) -> crate::common::RegisterField<
1645        0,
1646        0x1,
1647        1,
1648        0,
1649        adansa1::Ansa16,
1650        adansa1::Ansa16,
1651        Adansa1_SPEC,
1652        crate::common::RW,
1653    > {
1654        crate::common::RegisterField::<
1655            0,
1656            0x1,
1657            1,
1658            0,
1659            adansa1::Ansa16,
1660            adansa1::Ansa16,
1661            Adansa1_SPEC,
1662            crate::common::RW,
1663        >::from_register(self, 0)
1664    }
1665
1666    #[doc = "A/D Conversion Channels Select"]
1667    #[inline(always)]
1668    pub fn ansa17(
1669        self,
1670    ) -> crate::common::RegisterField<
1671        1,
1672        0x1,
1673        1,
1674        0,
1675        adansa1::Ansa17,
1676        adansa1::Ansa17,
1677        Adansa1_SPEC,
1678        crate::common::RW,
1679    > {
1680        crate::common::RegisterField::<
1681            1,
1682            0x1,
1683            1,
1684            0,
1685            adansa1::Ansa17,
1686            adansa1::Ansa17,
1687            Adansa1_SPEC,
1688            crate::common::RW,
1689        >::from_register(self, 0)
1690    }
1691
1692    #[doc = "A/D Conversion Channels Select"]
1693    #[inline(always)]
1694    pub fn ansa18(
1695        self,
1696    ) -> crate::common::RegisterField<
1697        2,
1698        0x1,
1699        1,
1700        0,
1701        adansa1::Ansa18,
1702        adansa1::Ansa18,
1703        Adansa1_SPEC,
1704        crate::common::RW,
1705    > {
1706        crate::common::RegisterField::<
1707            2,
1708            0x1,
1709            1,
1710            0,
1711            adansa1::Ansa18,
1712            adansa1::Ansa18,
1713            Adansa1_SPEC,
1714            crate::common::RW,
1715        >::from_register(self, 0)
1716    }
1717
1718    #[doc = "A/D Conversion Channels Select"]
1719    #[inline(always)]
1720    pub fn ansa19(
1721        self,
1722    ) -> crate::common::RegisterField<
1723        3,
1724        0x1,
1725        1,
1726        0,
1727        adansa1::Ansa19,
1728        adansa1::Ansa19,
1729        Adansa1_SPEC,
1730        crate::common::RW,
1731    > {
1732        crate::common::RegisterField::<
1733            3,
1734            0x1,
1735            1,
1736            0,
1737            adansa1::Ansa19,
1738            adansa1::Ansa19,
1739            Adansa1_SPEC,
1740            crate::common::RW,
1741        >::from_register(self, 0)
1742    }
1743
1744    #[doc = "A/D Conversion Channels Select"]
1745    #[inline(always)]
1746    pub fn ansa20(
1747        self,
1748    ) -> crate::common::RegisterField<
1749        4,
1750        0x1,
1751        1,
1752        0,
1753        adansa1::Ansa20,
1754        adansa1::Ansa20,
1755        Adansa1_SPEC,
1756        crate::common::RW,
1757    > {
1758        crate::common::RegisterField::<
1759            4,
1760            0x1,
1761            1,
1762            0,
1763            adansa1::Ansa20,
1764            adansa1::Ansa20,
1765            Adansa1_SPEC,
1766            crate::common::RW,
1767        >::from_register(self, 0)
1768    }
1769
1770    #[doc = "A/D Conversion Channels Select"]
1771    #[inline(always)]
1772    pub fn ansa21(
1773        self,
1774    ) -> crate::common::RegisterField<
1775        5,
1776        0x1,
1777        1,
1778        0,
1779        adansa1::Ansa21,
1780        adansa1::Ansa21,
1781        Adansa1_SPEC,
1782        crate::common::RW,
1783    > {
1784        crate::common::RegisterField::<
1785            5,
1786            0x1,
1787            1,
1788            0,
1789            adansa1::Ansa21,
1790            adansa1::Ansa21,
1791            Adansa1_SPEC,
1792            crate::common::RW,
1793        >::from_register(self, 0)
1794    }
1795
1796    #[doc = "A/D Conversion Channels Select"]
1797    #[inline(always)]
1798    pub fn ansa22(
1799        self,
1800    ) -> crate::common::RegisterField<
1801        6,
1802        0x1,
1803        1,
1804        0,
1805        adansa1::Ansa22,
1806        adansa1::Ansa22,
1807        Adansa1_SPEC,
1808        crate::common::RW,
1809    > {
1810        crate::common::RegisterField::<
1811            6,
1812            0x1,
1813            1,
1814            0,
1815            adansa1::Ansa22,
1816            adansa1::Ansa22,
1817            Adansa1_SPEC,
1818            crate::common::RW,
1819        >::from_register(self, 0)
1820    }
1821
1822    #[doc = "A/D Conversion Channels Select"]
1823    #[inline(always)]
1824    pub fn ansa23(
1825        self,
1826    ) -> crate::common::RegisterField<
1827        7,
1828        0x1,
1829        1,
1830        0,
1831        adansa1::Ansa23,
1832        adansa1::Ansa23,
1833        Adansa1_SPEC,
1834        crate::common::RW,
1835    > {
1836        crate::common::RegisterField::<
1837            7,
1838            0x1,
1839            1,
1840            0,
1841            adansa1::Ansa23,
1842            adansa1::Ansa23,
1843            Adansa1_SPEC,
1844            crate::common::RW,
1845        >::from_register(self, 0)
1846    }
1847
1848    #[doc = "A/D Conversion Channels Select"]
1849    #[inline(always)]
1850    pub fn ansa24(
1851        self,
1852    ) -> crate::common::RegisterField<
1853        8,
1854        0x1,
1855        1,
1856        0,
1857        adansa1::Ansa24,
1858        adansa1::Ansa24,
1859        Adansa1_SPEC,
1860        crate::common::RW,
1861    > {
1862        crate::common::RegisterField::<
1863            8,
1864            0x1,
1865            1,
1866            0,
1867            adansa1::Ansa24,
1868            adansa1::Ansa24,
1869            Adansa1_SPEC,
1870            crate::common::RW,
1871        >::from_register(self, 0)
1872    }
1873
1874    #[doc = "A/D Conversion Channels Select"]
1875    #[inline(always)]
1876    pub fn ansa25(
1877        self,
1878    ) -> crate::common::RegisterField<
1879        9,
1880        0x1,
1881        1,
1882        0,
1883        adansa1::Ansa25,
1884        adansa1::Ansa25,
1885        Adansa1_SPEC,
1886        crate::common::RW,
1887    > {
1888        crate::common::RegisterField::<
1889            9,
1890            0x1,
1891            1,
1892            0,
1893            adansa1::Ansa25,
1894            adansa1::Ansa25,
1895            Adansa1_SPEC,
1896            crate::common::RW,
1897        >::from_register(self, 0)
1898    }
1899
1900    #[doc = "A/D Conversion Channels Select"]
1901    #[inline(always)]
1902    pub fn ansa26(
1903        self,
1904    ) -> crate::common::RegisterField<
1905        10,
1906        0x1,
1907        1,
1908        0,
1909        adansa1::Ansa26,
1910        adansa1::Ansa26,
1911        Adansa1_SPEC,
1912        crate::common::RW,
1913    > {
1914        crate::common::RegisterField::<
1915            10,
1916            0x1,
1917            1,
1918            0,
1919            adansa1::Ansa26,
1920            adansa1::Ansa26,
1921            Adansa1_SPEC,
1922            crate::common::RW,
1923        >::from_register(self, 0)
1924    }
1925
1926    #[doc = "A/D Conversion Channels Select"]
1927    #[inline(always)]
1928    pub fn ansa27(
1929        self,
1930    ) -> crate::common::RegisterField<
1931        11,
1932        0x1,
1933        1,
1934        0,
1935        adansa1::Ansa27,
1936        adansa1::Ansa27,
1937        Adansa1_SPEC,
1938        crate::common::RW,
1939    > {
1940        crate::common::RegisterField::<
1941            11,
1942            0x1,
1943            1,
1944            0,
1945            adansa1::Ansa27,
1946            adansa1::Ansa27,
1947            Adansa1_SPEC,
1948            crate::common::RW,
1949        >::from_register(self, 0)
1950    }
1951
1952    #[doc = "A/D Conversion Channels Select"]
1953    #[inline(always)]
1954    pub fn ansa28(
1955        self,
1956    ) -> crate::common::RegisterField<
1957        12,
1958        0x1,
1959        1,
1960        0,
1961        adansa1::Ansa28,
1962        adansa1::Ansa28,
1963        Adansa1_SPEC,
1964        crate::common::RW,
1965    > {
1966        crate::common::RegisterField::<
1967            12,
1968            0x1,
1969            1,
1970            0,
1971            adansa1::Ansa28,
1972            adansa1::Ansa28,
1973            Adansa1_SPEC,
1974            crate::common::RW,
1975        >::from_register(self, 0)
1976    }
1977
1978    #[doc = "A/D Conversion Channels Select"]
1979    #[inline(always)]
1980    pub fn ansa29(
1981        self,
1982    ) -> crate::common::RegisterField<
1983        13,
1984        0x1,
1985        1,
1986        0,
1987        adansa1::Ansa29,
1988        adansa1::Ansa29,
1989        Adansa1_SPEC,
1990        crate::common::RW,
1991    > {
1992        crate::common::RegisterField::<
1993            13,
1994            0x1,
1995            1,
1996            0,
1997            adansa1::Ansa29,
1998            adansa1::Ansa29,
1999            Adansa1_SPEC,
2000            crate::common::RW,
2001        >::from_register(self, 0)
2002    }
2003
2004    #[doc = "A/D Conversion Channels Select"]
2005    #[inline(always)]
2006    pub fn ansa30(
2007        self,
2008    ) -> crate::common::RegisterField<
2009        14,
2010        0x1,
2011        1,
2012        0,
2013        adansa1::Ansa30,
2014        adansa1::Ansa30,
2015        Adansa1_SPEC,
2016        crate::common::RW,
2017    > {
2018        crate::common::RegisterField::<
2019            14,
2020            0x1,
2021            1,
2022            0,
2023            adansa1::Ansa30,
2024            adansa1::Ansa30,
2025            Adansa1_SPEC,
2026            crate::common::RW,
2027        >::from_register(self, 0)
2028    }
2029
2030    #[doc = "A/D Conversion Channels Select"]
2031    #[inline(always)]
2032    pub fn ansa31(
2033        self,
2034    ) -> crate::common::RegisterField<
2035        15,
2036        0x1,
2037        1,
2038        0,
2039        adansa1::Ansa31,
2040        adansa1::Ansa31,
2041        Adansa1_SPEC,
2042        crate::common::RW,
2043    > {
2044        crate::common::RegisterField::<
2045            15,
2046            0x1,
2047            1,
2048            0,
2049            adansa1::Ansa31,
2050            adansa1::Ansa31,
2051            Adansa1_SPEC,
2052            crate::common::RW,
2053        >::from_register(self, 0)
2054    }
2055}
2056impl ::core::default::Default for Adansa1 {
2057    #[inline(always)]
2058    fn default() -> Adansa1 {
2059        <crate::RegValueT<Adansa1_SPEC> as RegisterValue<_>>::new(0)
2060    }
2061}
2062pub mod adansa1 {
2063
2064    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2065    pub struct Ansa16_SPEC;
2066    pub type Ansa16 = crate::EnumBitfieldStruct<u8, Ansa16_SPEC>;
2067    impl Ansa16 {
2068        #[doc = "Do not select associated input channel."]
2069        pub const _0: Self = Self::new(0);
2070
2071        #[doc = "Select associated input channel."]
2072        pub const _1: Self = Self::new(1);
2073    }
2074    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2075    pub struct Ansa17_SPEC;
2076    pub type Ansa17 = crate::EnumBitfieldStruct<u8, Ansa17_SPEC>;
2077    impl Ansa17 {
2078        #[doc = "Do not select associated input channel."]
2079        pub const _0: Self = Self::new(0);
2080
2081        #[doc = "Select associated input channel."]
2082        pub const _1: Self = Self::new(1);
2083    }
2084    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2085    pub struct Ansa18_SPEC;
2086    pub type Ansa18 = crate::EnumBitfieldStruct<u8, Ansa18_SPEC>;
2087    impl Ansa18 {
2088        #[doc = "Do not select associated input channel."]
2089        pub const _0: Self = Self::new(0);
2090
2091        #[doc = "Select associated input channel."]
2092        pub const _1: Self = Self::new(1);
2093    }
2094    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2095    pub struct Ansa19_SPEC;
2096    pub type Ansa19 = crate::EnumBitfieldStruct<u8, Ansa19_SPEC>;
2097    impl Ansa19 {
2098        #[doc = "Do not select associated input channel."]
2099        pub const _0: Self = Self::new(0);
2100
2101        #[doc = "Select associated input channel."]
2102        pub const _1: Self = Self::new(1);
2103    }
2104    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2105    pub struct Ansa20_SPEC;
2106    pub type Ansa20 = crate::EnumBitfieldStruct<u8, Ansa20_SPEC>;
2107    impl Ansa20 {
2108        #[doc = "Do not select associated input channel."]
2109        pub const _0: Self = Self::new(0);
2110
2111        #[doc = "Select associated input channel."]
2112        pub const _1: Self = Self::new(1);
2113    }
2114    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2115    pub struct Ansa21_SPEC;
2116    pub type Ansa21 = crate::EnumBitfieldStruct<u8, Ansa21_SPEC>;
2117    impl Ansa21 {
2118        #[doc = "Do not select associated input channel."]
2119        pub const _0: Self = Self::new(0);
2120
2121        #[doc = "Select associated input channel."]
2122        pub const _1: Self = Self::new(1);
2123    }
2124    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2125    pub struct Ansa22_SPEC;
2126    pub type Ansa22 = crate::EnumBitfieldStruct<u8, Ansa22_SPEC>;
2127    impl Ansa22 {
2128        #[doc = "Do not select associated input channel."]
2129        pub const _0: Self = Self::new(0);
2130
2131        #[doc = "Select associated input channel."]
2132        pub const _1: Self = Self::new(1);
2133    }
2134    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2135    pub struct Ansa23_SPEC;
2136    pub type Ansa23 = crate::EnumBitfieldStruct<u8, Ansa23_SPEC>;
2137    impl Ansa23 {
2138        #[doc = "Do not select associated input channel."]
2139        pub const _0: Self = Self::new(0);
2140
2141        #[doc = "Select associated input channel."]
2142        pub const _1: Self = Self::new(1);
2143    }
2144    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2145    pub struct Ansa24_SPEC;
2146    pub type Ansa24 = crate::EnumBitfieldStruct<u8, Ansa24_SPEC>;
2147    impl Ansa24 {
2148        #[doc = "Do not select associated input channel."]
2149        pub const _0: Self = Self::new(0);
2150
2151        #[doc = "Select associated input channel."]
2152        pub const _1: Self = Self::new(1);
2153    }
2154    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2155    pub struct Ansa25_SPEC;
2156    pub type Ansa25 = crate::EnumBitfieldStruct<u8, Ansa25_SPEC>;
2157    impl Ansa25 {
2158        #[doc = "Do not select associated input channel."]
2159        pub const _0: Self = Self::new(0);
2160
2161        #[doc = "Select associated input channel."]
2162        pub const _1: Self = Self::new(1);
2163    }
2164    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2165    pub struct Ansa26_SPEC;
2166    pub type Ansa26 = crate::EnumBitfieldStruct<u8, Ansa26_SPEC>;
2167    impl Ansa26 {
2168        #[doc = "Do not select associated input channel."]
2169        pub const _0: Self = Self::new(0);
2170
2171        #[doc = "Select associated input channel."]
2172        pub const _1: Self = Self::new(1);
2173    }
2174    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2175    pub struct Ansa27_SPEC;
2176    pub type Ansa27 = crate::EnumBitfieldStruct<u8, Ansa27_SPEC>;
2177    impl Ansa27 {
2178        #[doc = "Do not select associated input channel."]
2179        pub const _0: Self = Self::new(0);
2180
2181        #[doc = "Select associated input channel."]
2182        pub const _1: Self = Self::new(1);
2183    }
2184    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2185    pub struct Ansa28_SPEC;
2186    pub type Ansa28 = crate::EnumBitfieldStruct<u8, Ansa28_SPEC>;
2187    impl Ansa28 {
2188        #[doc = "Do not select associated input channel."]
2189        pub const _0: Self = Self::new(0);
2190
2191        #[doc = "Select associated input channel."]
2192        pub const _1: Self = Self::new(1);
2193    }
2194    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2195    pub struct Ansa29_SPEC;
2196    pub type Ansa29 = crate::EnumBitfieldStruct<u8, Ansa29_SPEC>;
2197    impl Ansa29 {
2198        #[doc = "Do not select associated input channel."]
2199        pub const _0: Self = Self::new(0);
2200
2201        #[doc = "Select associated input channel."]
2202        pub const _1: Self = Self::new(1);
2203    }
2204    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2205    pub struct Ansa30_SPEC;
2206    pub type Ansa30 = crate::EnumBitfieldStruct<u8, Ansa30_SPEC>;
2207    impl Ansa30 {
2208        #[doc = "Do not select associated input channel."]
2209        pub const _0: Self = Self::new(0);
2210
2211        #[doc = "Select associated input channel."]
2212        pub const _1: Self = Self::new(1);
2213    }
2214    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2215    pub struct Ansa31_SPEC;
2216    pub type Ansa31 = crate::EnumBitfieldStruct<u8, Ansa31_SPEC>;
2217    impl Ansa31 {
2218        #[doc = "Do not select associated input channel."]
2219        pub const _0: Self = Self::new(0);
2220
2221        #[doc = "Select associated input channel."]
2222        pub const _1: Self = Self::new(1);
2223    }
2224}
2225#[doc(hidden)]
2226#[derive(Copy, Clone, Eq, PartialEq)]
2227pub struct Adads0_SPEC;
2228impl crate::sealed::RegSpec for Adads0_SPEC {
2229    type DataType = u16;
2230}
2231
2232#[doc = "A/D-Converted Value Addition/Average Channel Select Register 0"]
2233pub type Adads0 = crate::RegValueT<Adads0_SPEC>;
2234
2235impl Adads0 {
2236    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2237    #[inline(always)]
2238    pub fn ads00(
2239        self,
2240    ) -> crate::common::RegisterField<
2241        0,
2242        0x1,
2243        1,
2244        0,
2245        adads0::Ads00,
2246        adads0::Ads00,
2247        Adads0_SPEC,
2248        crate::common::RW,
2249    > {
2250        crate::common::RegisterField::<
2251            0,
2252            0x1,
2253            1,
2254            0,
2255            adads0::Ads00,
2256            adads0::Ads00,
2257            Adads0_SPEC,
2258            crate::common::RW,
2259        >::from_register(self, 0)
2260    }
2261
2262    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2263    #[inline(always)]
2264    pub fn ads01(
2265        self,
2266    ) -> crate::common::RegisterField<
2267        1,
2268        0x1,
2269        1,
2270        0,
2271        adads0::Ads01,
2272        adads0::Ads01,
2273        Adads0_SPEC,
2274        crate::common::RW,
2275    > {
2276        crate::common::RegisterField::<
2277            1,
2278            0x1,
2279            1,
2280            0,
2281            adads0::Ads01,
2282            adads0::Ads01,
2283            Adads0_SPEC,
2284            crate::common::RW,
2285        >::from_register(self, 0)
2286    }
2287
2288    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2289    #[inline(always)]
2290    pub fn ads02(
2291        self,
2292    ) -> crate::common::RegisterField<
2293        2,
2294        0x1,
2295        1,
2296        0,
2297        adads0::Ads02,
2298        adads0::Ads02,
2299        Adads0_SPEC,
2300        crate::common::RW,
2301    > {
2302        crate::common::RegisterField::<
2303            2,
2304            0x1,
2305            1,
2306            0,
2307            adads0::Ads02,
2308            adads0::Ads02,
2309            Adads0_SPEC,
2310            crate::common::RW,
2311        >::from_register(self, 0)
2312    }
2313
2314    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2315    #[inline(always)]
2316    pub fn ads03(
2317        self,
2318    ) -> crate::common::RegisterField<
2319        3,
2320        0x1,
2321        1,
2322        0,
2323        adads0::Ads03,
2324        adads0::Ads03,
2325        Adads0_SPEC,
2326        crate::common::RW,
2327    > {
2328        crate::common::RegisterField::<
2329            3,
2330            0x1,
2331            1,
2332            0,
2333            adads0::Ads03,
2334            adads0::Ads03,
2335            Adads0_SPEC,
2336            crate::common::RW,
2337        >::from_register(self, 0)
2338    }
2339
2340    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2341    #[inline(always)]
2342    pub fn ads04(
2343        self,
2344    ) -> crate::common::RegisterField<
2345        4,
2346        0x1,
2347        1,
2348        0,
2349        adads0::Ads04,
2350        adads0::Ads04,
2351        Adads0_SPEC,
2352        crate::common::RW,
2353    > {
2354        crate::common::RegisterField::<
2355            4,
2356            0x1,
2357            1,
2358            0,
2359            adads0::Ads04,
2360            adads0::Ads04,
2361            Adads0_SPEC,
2362            crate::common::RW,
2363        >::from_register(self, 0)
2364    }
2365
2366    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2367    #[inline(always)]
2368    pub fn ads05(
2369        self,
2370    ) -> crate::common::RegisterField<
2371        5,
2372        0x1,
2373        1,
2374        0,
2375        adads0::Ads05,
2376        adads0::Ads05,
2377        Adads0_SPEC,
2378        crate::common::RW,
2379    > {
2380        crate::common::RegisterField::<
2381            5,
2382            0x1,
2383            1,
2384            0,
2385            adads0::Ads05,
2386            adads0::Ads05,
2387            Adads0_SPEC,
2388            crate::common::RW,
2389        >::from_register(self, 0)
2390    }
2391
2392    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2393    #[inline(always)]
2394    pub fn ads06(
2395        self,
2396    ) -> crate::common::RegisterField<
2397        6,
2398        0x1,
2399        1,
2400        0,
2401        adads0::Ads06,
2402        adads0::Ads06,
2403        Adads0_SPEC,
2404        crate::common::RW,
2405    > {
2406        crate::common::RegisterField::<
2407            6,
2408            0x1,
2409            1,
2410            0,
2411            adads0::Ads06,
2412            adads0::Ads06,
2413            Adads0_SPEC,
2414            crate::common::RW,
2415        >::from_register(self, 0)
2416    }
2417
2418    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2419    #[inline(always)]
2420    pub fn ads07(
2421        self,
2422    ) -> crate::common::RegisterField<
2423        7,
2424        0x1,
2425        1,
2426        0,
2427        adads0::Ads07,
2428        adads0::Ads07,
2429        Adads0_SPEC,
2430        crate::common::RW,
2431    > {
2432        crate::common::RegisterField::<
2433            7,
2434            0x1,
2435            1,
2436            0,
2437            adads0::Ads07,
2438            adads0::Ads07,
2439            Adads0_SPEC,
2440            crate::common::RW,
2441        >::from_register(self, 0)
2442    }
2443
2444    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2445    #[inline(always)]
2446    pub fn ads08(
2447        self,
2448    ) -> crate::common::RegisterField<
2449        8,
2450        0x1,
2451        1,
2452        0,
2453        adads0::Ads08,
2454        adads0::Ads08,
2455        Adads0_SPEC,
2456        crate::common::RW,
2457    > {
2458        crate::common::RegisterField::<
2459            8,
2460            0x1,
2461            1,
2462            0,
2463            adads0::Ads08,
2464            adads0::Ads08,
2465            Adads0_SPEC,
2466            crate::common::RW,
2467        >::from_register(self, 0)
2468    }
2469
2470    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2471    #[inline(always)]
2472    pub fn ads09(
2473        self,
2474    ) -> crate::common::RegisterField<
2475        9,
2476        0x1,
2477        1,
2478        0,
2479        adads0::Ads09,
2480        adads0::Ads09,
2481        Adads0_SPEC,
2482        crate::common::RW,
2483    > {
2484        crate::common::RegisterField::<
2485            9,
2486            0x1,
2487            1,
2488            0,
2489            adads0::Ads09,
2490            adads0::Ads09,
2491            Adads0_SPEC,
2492            crate::common::RW,
2493        >::from_register(self, 0)
2494    }
2495
2496    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2497    #[inline(always)]
2498    pub fn ads10(
2499        self,
2500    ) -> crate::common::RegisterField<
2501        10,
2502        0x1,
2503        1,
2504        0,
2505        adads0::Ads10,
2506        adads0::Ads10,
2507        Adads0_SPEC,
2508        crate::common::RW,
2509    > {
2510        crate::common::RegisterField::<
2511            10,
2512            0x1,
2513            1,
2514            0,
2515            adads0::Ads10,
2516            adads0::Ads10,
2517            Adads0_SPEC,
2518            crate::common::RW,
2519        >::from_register(self, 0)
2520    }
2521
2522    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2523    #[inline(always)]
2524    pub fn ads11(
2525        self,
2526    ) -> crate::common::RegisterField<
2527        11,
2528        0x1,
2529        1,
2530        0,
2531        adads0::Ads11,
2532        adads0::Ads11,
2533        Adads0_SPEC,
2534        crate::common::RW,
2535    > {
2536        crate::common::RegisterField::<
2537            11,
2538            0x1,
2539            1,
2540            0,
2541            adads0::Ads11,
2542            adads0::Ads11,
2543            Adads0_SPEC,
2544            crate::common::RW,
2545        >::from_register(self, 0)
2546    }
2547
2548    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2549    #[inline(always)]
2550    pub fn ads12(
2551        self,
2552    ) -> crate::common::RegisterField<
2553        12,
2554        0x1,
2555        1,
2556        0,
2557        adads0::Ads12,
2558        adads0::Ads12,
2559        Adads0_SPEC,
2560        crate::common::RW,
2561    > {
2562        crate::common::RegisterField::<
2563            12,
2564            0x1,
2565            1,
2566            0,
2567            adads0::Ads12,
2568            adads0::Ads12,
2569            Adads0_SPEC,
2570            crate::common::RW,
2571        >::from_register(self, 0)
2572    }
2573
2574    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2575    #[inline(always)]
2576    pub fn ads13(
2577        self,
2578    ) -> crate::common::RegisterField<
2579        13,
2580        0x1,
2581        1,
2582        0,
2583        adads0::Ads13,
2584        adads0::Ads13,
2585        Adads0_SPEC,
2586        crate::common::RW,
2587    > {
2588        crate::common::RegisterField::<
2589            13,
2590            0x1,
2591            1,
2592            0,
2593            adads0::Ads13,
2594            adads0::Ads13,
2595            Adads0_SPEC,
2596            crate::common::RW,
2597        >::from_register(self, 0)
2598    }
2599
2600    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2601    #[inline(always)]
2602    pub fn ads14(
2603        self,
2604    ) -> crate::common::RegisterField<
2605        14,
2606        0x1,
2607        1,
2608        0,
2609        adads0::Ads14,
2610        adads0::Ads14,
2611        Adads0_SPEC,
2612        crate::common::RW,
2613    > {
2614        crate::common::RegisterField::<
2615            14,
2616            0x1,
2617            1,
2618            0,
2619            adads0::Ads14,
2620            adads0::Ads14,
2621            Adads0_SPEC,
2622            crate::common::RW,
2623        >::from_register(self, 0)
2624    }
2625
2626    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2627    #[inline(always)]
2628    pub fn ads15(
2629        self,
2630    ) -> crate::common::RegisterField<
2631        15,
2632        0x1,
2633        1,
2634        0,
2635        adads0::Ads15,
2636        adads0::Ads15,
2637        Adads0_SPEC,
2638        crate::common::RW,
2639    > {
2640        crate::common::RegisterField::<
2641            15,
2642            0x1,
2643            1,
2644            0,
2645            adads0::Ads15,
2646            adads0::Ads15,
2647            Adads0_SPEC,
2648            crate::common::RW,
2649        >::from_register(self, 0)
2650    }
2651}
2652impl ::core::default::Default for Adads0 {
2653    #[inline(always)]
2654    fn default() -> Adads0 {
2655        <crate::RegValueT<Adads0_SPEC> as RegisterValue<_>>::new(0)
2656    }
2657}
2658pub mod adads0 {
2659
2660    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2661    pub struct Ads00_SPEC;
2662    pub type Ads00 = crate::EnumBitfieldStruct<u8, Ads00_SPEC>;
2663    impl Ads00 {
2664        #[doc = "Do not select associated input channel."]
2665        pub const _0: Self = Self::new(0);
2666
2667        #[doc = "Select associated input channel."]
2668        pub const _1: Self = Self::new(1);
2669    }
2670    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2671    pub struct Ads01_SPEC;
2672    pub type Ads01 = crate::EnumBitfieldStruct<u8, Ads01_SPEC>;
2673    impl Ads01 {
2674        #[doc = "Do not select associated input channel."]
2675        pub const _0: Self = Self::new(0);
2676
2677        #[doc = "Select associated input channel."]
2678        pub const _1: Self = Self::new(1);
2679    }
2680    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2681    pub struct Ads02_SPEC;
2682    pub type Ads02 = crate::EnumBitfieldStruct<u8, Ads02_SPEC>;
2683    impl Ads02 {
2684        #[doc = "Do not select associated input channel."]
2685        pub const _0: Self = Self::new(0);
2686
2687        #[doc = "Select associated input channel."]
2688        pub const _1: Self = Self::new(1);
2689    }
2690    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2691    pub struct Ads03_SPEC;
2692    pub type Ads03 = crate::EnumBitfieldStruct<u8, Ads03_SPEC>;
2693    impl Ads03 {
2694        #[doc = "Do not select associated input channel."]
2695        pub const _0: Self = Self::new(0);
2696
2697        #[doc = "Select associated input channel."]
2698        pub const _1: Self = Self::new(1);
2699    }
2700    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2701    pub struct Ads04_SPEC;
2702    pub type Ads04 = crate::EnumBitfieldStruct<u8, Ads04_SPEC>;
2703    impl Ads04 {
2704        #[doc = "Do not select associated input channel."]
2705        pub const _0: Self = Self::new(0);
2706
2707        #[doc = "Select associated input channel."]
2708        pub const _1: Self = Self::new(1);
2709    }
2710    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2711    pub struct Ads05_SPEC;
2712    pub type Ads05 = crate::EnumBitfieldStruct<u8, Ads05_SPEC>;
2713    impl Ads05 {
2714        #[doc = "Do not select associated input channel."]
2715        pub const _0: Self = Self::new(0);
2716
2717        #[doc = "Select associated input channel."]
2718        pub const _1: Self = Self::new(1);
2719    }
2720    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2721    pub struct Ads06_SPEC;
2722    pub type Ads06 = crate::EnumBitfieldStruct<u8, Ads06_SPEC>;
2723    impl Ads06 {
2724        #[doc = "Do not select associated input channel."]
2725        pub const _0: Self = Self::new(0);
2726
2727        #[doc = "Select associated input channel."]
2728        pub const _1: Self = Self::new(1);
2729    }
2730    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2731    pub struct Ads07_SPEC;
2732    pub type Ads07 = crate::EnumBitfieldStruct<u8, Ads07_SPEC>;
2733    impl Ads07 {
2734        #[doc = "Do not select associated input channel."]
2735        pub const _0: Self = Self::new(0);
2736
2737        #[doc = "Select associated input channel."]
2738        pub const _1: Self = Self::new(1);
2739    }
2740    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2741    pub struct Ads08_SPEC;
2742    pub type Ads08 = crate::EnumBitfieldStruct<u8, Ads08_SPEC>;
2743    impl Ads08 {
2744        #[doc = "Do not select associated input channel."]
2745        pub const _0: Self = Self::new(0);
2746
2747        #[doc = "Select associated input channel."]
2748        pub const _1: Self = Self::new(1);
2749    }
2750    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2751    pub struct Ads09_SPEC;
2752    pub type Ads09 = crate::EnumBitfieldStruct<u8, Ads09_SPEC>;
2753    impl Ads09 {
2754        #[doc = "Do not select associated input channel."]
2755        pub const _0: Self = Self::new(0);
2756
2757        #[doc = "Select associated input channel."]
2758        pub const _1: Self = Self::new(1);
2759    }
2760    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2761    pub struct Ads10_SPEC;
2762    pub type Ads10 = crate::EnumBitfieldStruct<u8, Ads10_SPEC>;
2763    impl Ads10 {
2764        #[doc = "Do not select associated input channel."]
2765        pub const _0: Self = Self::new(0);
2766
2767        #[doc = "Select associated input channel."]
2768        pub const _1: Self = Self::new(1);
2769    }
2770    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2771    pub struct Ads11_SPEC;
2772    pub type Ads11 = crate::EnumBitfieldStruct<u8, Ads11_SPEC>;
2773    impl Ads11 {
2774        #[doc = "Do not select associated input channel."]
2775        pub const _0: Self = Self::new(0);
2776
2777        #[doc = "Select associated input channel."]
2778        pub const _1: Self = Self::new(1);
2779    }
2780    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2781    pub struct Ads12_SPEC;
2782    pub type Ads12 = crate::EnumBitfieldStruct<u8, Ads12_SPEC>;
2783    impl Ads12 {
2784        #[doc = "Do not select associated input channel."]
2785        pub const _0: Self = Self::new(0);
2786
2787        #[doc = "Select associated input channel."]
2788        pub const _1: Self = Self::new(1);
2789    }
2790    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2791    pub struct Ads13_SPEC;
2792    pub type Ads13 = crate::EnumBitfieldStruct<u8, Ads13_SPEC>;
2793    impl Ads13 {
2794        #[doc = "Do not select associated input channel."]
2795        pub const _0: Self = Self::new(0);
2796
2797        #[doc = "Select associated input channel."]
2798        pub const _1: Self = Self::new(1);
2799    }
2800    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2801    pub struct Ads14_SPEC;
2802    pub type Ads14 = crate::EnumBitfieldStruct<u8, Ads14_SPEC>;
2803    impl Ads14 {
2804        #[doc = "Do not select associated input channel."]
2805        pub const _0: Self = Self::new(0);
2806
2807        #[doc = "Select associated input channel."]
2808        pub const _1: Self = Self::new(1);
2809    }
2810    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2811    pub struct Ads15_SPEC;
2812    pub type Ads15 = crate::EnumBitfieldStruct<u8, Ads15_SPEC>;
2813    impl Ads15 {
2814        #[doc = "Do not select associated input channel."]
2815        pub const _0: Self = Self::new(0);
2816
2817        #[doc = "Select associated input channel."]
2818        pub const _1: Self = Self::new(1);
2819    }
2820}
2821#[doc(hidden)]
2822#[derive(Copy, Clone, Eq, PartialEq)]
2823pub struct Adads1_SPEC;
2824impl crate::sealed::RegSpec for Adads1_SPEC {
2825    type DataType = u16;
2826}
2827
2828#[doc = "A/D-Converted Value Addition/Average Channel Select Register 1"]
2829pub type Adads1 = crate::RegValueT<Adads1_SPEC>;
2830
2831impl Adads1 {
2832    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2833    #[inline(always)]
2834    pub fn ads16(
2835        self,
2836    ) -> crate::common::RegisterField<
2837        0,
2838        0x1,
2839        1,
2840        0,
2841        adads1::Ads16,
2842        adads1::Ads16,
2843        Adads1_SPEC,
2844        crate::common::RW,
2845    > {
2846        crate::common::RegisterField::<
2847            0,
2848            0x1,
2849            1,
2850            0,
2851            adads1::Ads16,
2852            adads1::Ads16,
2853            Adads1_SPEC,
2854            crate::common::RW,
2855        >::from_register(self, 0)
2856    }
2857
2858    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2859    #[inline(always)]
2860    pub fn ads17(
2861        self,
2862    ) -> crate::common::RegisterField<
2863        1,
2864        0x1,
2865        1,
2866        0,
2867        adads1::Ads17,
2868        adads1::Ads17,
2869        Adads1_SPEC,
2870        crate::common::RW,
2871    > {
2872        crate::common::RegisterField::<
2873            1,
2874            0x1,
2875            1,
2876            0,
2877            adads1::Ads17,
2878            adads1::Ads17,
2879            Adads1_SPEC,
2880            crate::common::RW,
2881        >::from_register(self, 0)
2882    }
2883
2884    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2885    #[inline(always)]
2886    pub fn ads18(
2887        self,
2888    ) -> crate::common::RegisterField<
2889        2,
2890        0x1,
2891        1,
2892        0,
2893        adads1::Ads18,
2894        adads1::Ads18,
2895        Adads1_SPEC,
2896        crate::common::RW,
2897    > {
2898        crate::common::RegisterField::<
2899            2,
2900            0x1,
2901            1,
2902            0,
2903            adads1::Ads18,
2904            adads1::Ads18,
2905            Adads1_SPEC,
2906            crate::common::RW,
2907        >::from_register(self, 0)
2908    }
2909
2910    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2911    #[inline(always)]
2912    pub fn ads19(
2913        self,
2914    ) -> crate::common::RegisterField<
2915        3,
2916        0x1,
2917        1,
2918        0,
2919        adads1::Ads19,
2920        adads1::Ads19,
2921        Adads1_SPEC,
2922        crate::common::RW,
2923    > {
2924        crate::common::RegisterField::<
2925            3,
2926            0x1,
2927            1,
2928            0,
2929            adads1::Ads19,
2930            adads1::Ads19,
2931            Adads1_SPEC,
2932            crate::common::RW,
2933        >::from_register(self, 0)
2934    }
2935
2936    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2937    #[inline(always)]
2938    pub fn ads20(
2939        self,
2940    ) -> crate::common::RegisterField<
2941        4,
2942        0x1,
2943        1,
2944        0,
2945        adads1::Ads20,
2946        adads1::Ads20,
2947        Adads1_SPEC,
2948        crate::common::RW,
2949    > {
2950        crate::common::RegisterField::<
2951            4,
2952            0x1,
2953            1,
2954            0,
2955            adads1::Ads20,
2956            adads1::Ads20,
2957            Adads1_SPEC,
2958            crate::common::RW,
2959        >::from_register(self, 0)
2960    }
2961
2962    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2963    #[inline(always)]
2964    pub fn ads21(
2965        self,
2966    ) -> crate::common::RegisterField<
2967        5,
2968        0x1,
2969        1,
2970        0,
2971        adads1::Ads21,
2972        adads1::Ads21,
2973        Adads1_SPEC,
2974        crate::common::RW,
2975    > {
2976        crate::common::RegisterField::<
2977            5,
2978            0x1,
2979            1,
2980            0,
2981            adads1::Ads21,
2982            adads1::Ads21,
2983            Adads1_SPEC,
2984            crate::common::RW,
2985        >::from_register(self, 0)
2986    }
2987
2988    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
2989    #[inline(always)]
2990    pub fn ads22(
2991        self,
2992    ) -> crate::common::RegisterField<
2993        6,
2994        0x1,
2995        1,
2996        0,
2997        adads1::Ads22,
2998        adads1::Ads22,
2999        Adads1_SPEC,
3000        crate::common::RW,
3001    > {
3002        crate::common::RegisterField::<
3003            6,
3004            0x1,
3005            1,
3006            0,
3007            adads1::Ads22,
3008            adads1::Ads22,
3009            Adads1_SPEC,
3010            crate::common::RW,
3011        >::from_register(self, 0)
3012    }
3013
3014    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3015    #[inline(always)]
3016    pub fn ads23(
3017        self,
3018    ) -> crate::common::RegisterField<
3019        7,
3020        0x1,
3021        1,
3022        0,
3023        adads1::Ads23,
3024        adads1::Ads23,
3025        Adads1_SPEC,
3026        crate::common::RW,
3027    > {
3028        crate::common::RegisterField::<
3029            7,
3030            0x1,
3031            1,
3032            0,
3033            adads1::Ads23,
3034            adads1::Ads23,
3035            Adads1_SPEC,
3036            crate::common::RW,
3037        >::from_register(self, 0)
3038    }
3039
3040    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3041    #[inline(always)]
3042    pub fn ads24(
3043        self,
3044    ) -> crate::common::RegisterField<
3045        8,
3046        0x1,
3047        1,
3048        0,
3049        adads1::Ads24,
3050        adads1::Ads24,
3051        Adads1_SPEC,
3052        crate::common::RW,
3053    > {
3054        crate::common::RegisterField::<
3055            8,
3056            0x1,
3057            1,
3058            0,
3059            adads1::Ads24,
3060            adads1::Ads24,
3061            Adads1_SPEC,
3062            crate::common::RW,
3063        >::from_register(self, 0)
3064    }
3065
3066    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3067    #[inline(always)]
3068    pub fn ads25(
3069        self,
3070    ) -> crate::common::RegisterField<
3071        9,
3072        0x1,
3073        1,
3074        0,
3075        adads1::Ads25,
3076        adads1::Ads25,
3077        Adads1_SPEC,
3078        crate::common::RW,
3079    > {
3080        crate::common::RegisterField::<
3081            9,
3082            0x1,
3083            1,
3084            0,
3085            adads1::Ads25,
3086            adads1::Ads25,
3087            Adads1_SPEC,
3088            crate::common::RW,
3089        >::from_register(self, 0)
3090    }
3091
3092    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3093    #[inline(always)]
3094    pub fn ads26(
3095        self,
3096    ) -> crate::common::RegisterField<
3097        10,
3098        0x1,
3099        1,
3100        0,
3101        adads1::Ads26,
3102        adads1::Ads26,
3103        Adads1_SPEC,
3104        crate::common::RW,
3105    > {
3106        crate::common::RegisterField::<
3107            10,
3108            0x1,
3109            1,
3110            0,
3111            adads1::Ads26,
3112            adads1::Ads26,
3113            Adads1_SPEC,
3114            crate::common::RW,
3115        >::from_register(self, 0)
3116    }
3117
3118    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3119    #[inline(always)]
3120    pub fn ads27(
3121        self,
3122    ) -> crate::common::RegisterField<
3123        11,
3124        0x1,
3125        1,
3126        0,
3127        adads1::Ads27,
3128        adads1::Ads27,
3129        Adads1_SPEC,
3130        crate::common::RW,
3131    > {
3132        crate::common::RegisterField::<
3133            11,
3134            0x1,
3135            1,
3136            0,
3137            adads1::Ads27,
3138            adads1::Ads27,
3139            Adads1_SPEC,
3140            crate::common::RW,
3141        >::from_register(self, 0)
3142    }
3143
3144    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3145    #[inline(always)]
3146    pub fn ads28(
3147        self,
3148    ) -> crate::common::RegisterField<
3149        12,
3150        0x1,
3151        1,
3152        0,
3153        adads1::Ads28,
3154        adads1::Ads28,
3155        Adads1_SPEC,
3156        crate::common::RW,
3157    > {
3158        crate::common::RegisterField::<
3159            12,
3160            0x1,
3161            1,
3162            0,
3163            adads1::Ads28,
3164            adads1::Ads28,
3165            Adads1_SPEC,
3166            crate::common::RW,
3167        >::from_register(self, 0)
3168    }
3169
3170    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3171    #[inline(always)]
3172    pub fn ads29(
3173        self,
3174    ) -> crate::common::RegisterField<
3175        13,
3176        0x1,
3177        1,
3178        0,
3179        adads1::Ads29,
3180        adads1::Ads29,
3181        Adads1_SPEC,
3182        crate::common::RW,
3183    > {
3184        crate::common::RegisterField::<
3185            13,
3186            0x1,
3187            1,
3188            0,
3189            adads1::Ads29,
3190            adads1::Ads29,
3191            Adads1_SPEC,
3192            crate::common::RW,
3193        >::from_register(self, 0)
3194    }
3195
3196    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3197    #[inline(always)]
3198    pub fn ads30(
3199        self,
3200    ) -> crate::common::RegisterField<
3201        14,
3202        0x1,
3203        1,
3204        0,
3205        adads1::Ads30,
3206        adads1::Ads30,
3207        Adads1_SPEC,
3208        crate::common::RW,
3209    > {
3210        crate::common::RegisterField::<
3211            14,
3212            0x1,
3213            1,
3214            0,
3215            adads1::Ads30,
3216            adads1::Ads30,
3217            Adads1_SPEC,
3218            crate::common::RW,
3219        >::from_register(self, 0)
3220    }
3221
3222    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
3223    #[inline(always)]
3224    pub fn ads31(
3225        self,
3226    ) -> crate::common::RegisterField<
3227        15,
3228        0x1,
3229        1,
3230        0,
3231        adads1::Ads31,
3232        adads1::Ads31,
3233        Adads1_SPEC,
3234        crate::common::RW,
3235    > {
3236        crate::common::RegisterField::<
3237            15,
3238            0x1,
3239            1,
3240            0,
3241            adads1::Ads31,
3242            adads1::Ads31,
3243            Adads1_SPEC,
3244            crate::common::RW,
3245        >::from_register(self, 0)
3246    }
3247}
3248impl ::core::default::Default for Adads1 {
3249    #[inline(always)]
3250    fn default() -> Adads1 {
3251        <crate::RegValueT<Adads1_SPEC> as RegisterValue<_>>::new(0)
3252    }
3253}
3254pub mod adads1 {
3255
3256    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3257    pub struct Ads16_SPEC;
3258    pub type Ads16 = crate::EnumBitfieldStruct<u8, Ads16_SPEC>;
3259    impl Ads16 {
3260        #[doc = "Do not select associated input channel."]
3261        pub const _0: Self = Self::new(0);
3262
3263        #[doc = "Select associated input channel."]
3264        pub const _1: Self = Self::new(1);
3265    }
3266    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3267    pub struct Ads17_SPEC;
3268    pub type Ads17 = crate::EnumBitfieldStruct<u8, Ads17_SPEC>;
3269    impl Ads17 {
3270        #[doc = "Do not select associated input channel."]
3271        pub const _0: Self = Self::new(0);
3272
3273        #[doc = "Select associated input channel."]
3274        pub const _1: Self = Self::new(1);
3275    }
3276    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3277    pub struct Ads18_SPEC;
3278    pub type Ads18 = crate::EnumBitfieldStruct<u8, Ads18_SPEC>;
3279    impl Ads18 {
3280        #[doc = "Do not select associated input channel."]
3281        pub const _0: Self = Self::new(0);
3282
3283        #[doc = "Select associated input channel."]
3284        pub const _1: Self = Self::new(1);
3285    }
3286    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3287    pub struct Ads19_SPEC;
3288    pub type Ads19 = crate::EnumBitfieldStruct<u8, Ads19_SPEC>;
3289    impl Ads19 {
3290        #[doc = "Do not select associated input channel."]
3291        pub const _0: Self = Self::new(0);
3292
3293        #[doc = "Select associated input channel."]
3294        pub const _1: Self = Self::new(1);
3295    }
3296    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3297    pub struct Ads20_SPEC;
3298    pub type Ads20 = crate::EnumBitfieldStruct<u8, Ads20_SPEC>;
3299    impl Ads20 {
3300        #[doc = "Do not select associated input channel."]
3301        pub const _0: Self = Self::new(0);
3302
3303        #[doc = "Select associated input channel."]
3304        pub const _1: Self = Self::new(1);
3305    }
3306    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3307    pub struct Ads21_SPEC;
3308    pub type Ads21 = crate::EnumBitfieldStruct<u8, Ads21_SPEC>;
3309    impl Ads21 {
3310        #[doc = "Do not select associated input channel."]
3311        pub const _0: Self = Self::new(0);
3312
3313        #[doc = "Select associated input channel."]
3314        pub const _1: Self = Self::new(1);
3315    }
3316    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3317    pub struct Ads22_SPEC;
3318    pub type Ads22 = crate::EnumBitfieldStruct<u8, Ads22_SPEC>;
3319    impl Ads22 {
3320        #[doc = "Do not select associated input channel."]
3321        pub const _0: Self = Self::new(0);
3322
3323        #[doc = "Select associated input channel."]
3324        pub const _1: Self = Self::new(1);
3325    }
3326    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3327    pub struct Ads23_SPEC;
3328    pub type Ads23 = crate::EnumBitfieldStruct<u8, Ads23_SPEC>;
3329    impl Ads23 {
3330        #[doc = "Do not select associated input channel."]
3331        pub const _0: Self = Self::new(0);
3332
3333        #[doc = "Select associated input channel."]
3334        pub const _1: Self = Self::new(1);
3335    }
3336    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3337    pub struct Ads24_SPEC;
3338    pub type Ads24 = crate::EnumBitfieldStruct<u8, Ads24_SPEC>;
3339    impl Ads24 {
3340        #[doc = "Do not select associated input channel."]
3341        pub const _0: Self = Self::new(0);
3342
3343        #[doc = "Select associated input channel."]
3344        pub const _1: Self = Self::new(1);
3345    }
3346    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3347    pub struct Ads25_SPEC;
3348    pub type Ads25 = crate::EnumBitfieldStruct<u8, Ads25_SPEC>;
3349    impl Ads25 {
3350        #[doc = "Do not select associated input channel."]
3351        pub const _0: Self = Self::new(0);
3352
3353        #[doc = "Select associated input channel."]
3354        pub const _1: Self = Self::new(1);
3355    }
3356    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3357    pub struct Ads26_SPEC;
3358    pub type Ads26 = crate::EnumBitfieldStruct<u8, Ads26_SPEC>;
3359    impl Ads26 {
3360        #[doc = "Do not select associated input channel."]
3361        pub const _0: Self = Self::new(0);
3362
3363        #[doc = "Select associated input channel."]
3364        pub const _1: Self = Self::new(1);
3365    }
3366    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3367    pub struct Ads27_SPEC;
3368    pub type Ads27 = crate::EnumBitfieldStruct<u8, Ads27_SPEC>;
3369    impl Ads27 {
3370        #[doc = "Do not select associated input channel."]
3371        pub const _0: Self = Self::new(0);
3372
3373        #[doc = "Select associated input channel."]
3374        pub const _1: Self = Self::new(1);
3375    }
3376    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3377    pub struct Ads28_SPEC;
3378    pub type Ads28 = crate::EnumBitfieldStruct<u8, Ads28_SPEC>;
3379    impl Ads28 {
3380        #[doc = "Do not select associated input channel."]
3381        pub const _0: Self = Self::new(0);
3382
3383        #[doc = "Select associated input channel."]
3384        pub const _1: Self = Self::new(1);
3385    }
3386    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3387    pub struct Ads29_SPEC;
3388    pub type Ads29 = crate::EnumBitfieldStruct<u8, Ads29_SPEC>;
3389    impl Ads29 {
3390        #[doc = "Do not select associated input channel."]
3391        pub const _0: Self = Self::new(0);
3392
3393        #[doc = "Select associated input channel."]
3394        pub const _1: Self = Self::new(1);
3395    }
3396    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3397    pub struct Ads30_SPEC;
3398    pub type Ads30 = crate::EnumBitfieldStruct<u8, Ads30_SPEC>;
3399    impl Ads30 {
3400        #[doc = "Do not select associated input channel."]
3401        pub const _0: Self = Self::new(0);
3402
3403        #[doc = "Select associated input channel."]
3404        pub const _1: Self = Self::new(1);
3405    }
3406    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3407    pub struct Ads31_SPEC;
3408    pub type Ads31 = crate::EnumBitfieldStruct<u8, Ads31_SPEC>;
3409    impl Ads31 {
3410        #[doc = "Do not select associated input channel."]
3411        pub const _0: Self = Self::new(0);
3412
3413        #[doc = "Select associated input channel."]
3414        pub const _1: Self = Self::new(1);
3415    }
3416}
3417#[doc(hidden)]
3418#[derive(Copy, Clone, Eq, PartialEq)]
3419pub struct Adadc_SPEC;
3420impl crate::sealed::RegSpec for Adadc_SPEC {
3421    type DataType = u8;
3422}
3423
3424#[doc = "A/D-Converted Value Addition/Average Count Select Register"]
3425pub type Adadc = crate::RegValueT<Adadc_SPEC>;
3426
3427impl Adadc {
3428    #[doc = "Addition/Average Count Select"]
3429    #[inline(always)]
3430    pub fn adc(
3431        self,
3432    ) -> crate::common::RegisterField<
3433        0,
3434        0x7,
3435        1,
3436        0,
3437        adadc::Adc,
3438        adadc::Adc,
3439        Adadc_SPEC,
3440        crate::common::RW,
3441    > {
3442        crate::common::RegisterField::<
3443            0,
3444            0x7,
3445            1,
3446            0,
3447            adadc::Adc,
3448            adadc::Adc,
3449            Adadc_SPEC,
3450            crate::common::RW,
3451        >::from_register(self, 0)
3452    }
3453
3454    #[doc = "Average Mode Select"]
3455    #[inline(always)]
3456    pub fn avee(
3457        self,
3458    ) -> crate::common::RegisterField<
3459        7,
3460        0x1,
3461        1,
3462        0,
3463        adadc::Avee,
3464        adadc::Avee,
3465        Adadc_SPEC,
3466        crate::common::RW,
3467    > {
3468        crate::common::RegisterField::<
3469            7,
3470            0x1,
3471            1,
3472            0,
3473            adadc::Avee,
3474            adadc::Avee,
3475            Adadc_SPEC,
3476            crate::common::RW,
3477        >::from_register(self, 0)
3478    }
3479}
3480impl ::core::default::Default for Adadc {
3481    #[inline(always)]
3482    fn default() -> Adadc {
3483        <crate::RegValueT<Adadc_SPEC> as RegisterValue<_>>::new(0)
3484    }
3485}
3486pub mod adadc {
3487
3488    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3489    pub struct Adc_SPEC;
3490    pub type Adc = crate::EnumBitfieldStruct<u8, Adc_SPEC>;
3491    impl Adc {
3492        #[doc = "1-time conversion (no addition, same as normal conversion)"]
3493        pub const _000: Self = Self::new(0);
3494
3495        #[doc = "2-time conversion (1 addition)"]
3496        pub const _001: Self = Self::new(1);
3497
3498        #[doc = "3-time conversion (2 additions)"]
3499        pub const _010: Self = Self::new(2);
3500
3501        #[doc = "4-time conversion (3 additions)"]
3502        pub const _011: Self = Self::new(3);
3503
3504        #[doc = "16-time conversion (15 additions)"]
3505        pub const _101: Self = Self::new(5);
3506    }
3507    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3508    pub struct Avee_SPEC;
3509    pub type Avee = crate::EnumBitfieldStruct<u8, Avee_SPEC>;
3510    impl Avee {
3511        #[doc = "Enable addition mode"]
3512        pub const _0: Self = Self::new(0);
3513
3514        #[doc = "Enable average mode"]
3515        pub const _1: Self = Self::new(1);
3516    }
3517}
3518#[doc(hidden)]
3519#[derive(Copy, Clone, Eq, PartialEq)]
3520pub struct Adcer_SPEC;
3521impl crate::sealed::RegSpec for Adcer_SPEC {
3522    type DataType = u16;
3523}
3524
3525#[doc = "A/D Control Extended Register"]
3526pub type Adcer = crate::RegValueT<Adcer_SPEC>;
3527
3528impl Adcer {
3529    #[doc = "A/D Data Register Automatic Clearing Enable"]
3530    #[inline(always)]
3531    pub fn ace(
3532        self,
3533    ) -> crate::common::RegisterField<
3534        5,
3535        0x1,
3536        1,
3537        0,
3538        adcer::Ace,
3539        adcer::Ace,
3540        Adcer_SPEC,
3541        crate::common::RW,
3542    > {
3543        crate::common::RegisterField::<
3544            5,
3545            0x1,
3546            1,
3547            0,
3548            adcer::Ace,
3549            adcer::Ace,
3550            Adcer_SPEC,
3551            crate::common::RW,
3552        >::from_register(self, 0)
3553    }
3554
3555    #[doc = "Self-Diagnosis Conversion Voltage Select"]
3556    #[inline(always)]
3557    pub fn diagval(
3558        self,
3559    ) -> crate::common::RegisterField<
3560        8,
3561        0x3,
3562        1,
3563        0,
3564        adcer::Diagval,
3565        adcer::Diagval,
3566        Adcer_SPEC,
3567        crate::common::RW,
3568    > {
3569        crate::common::RegisterField::<
3570            8,
3571            0x3,
3572            1,
3573            0,
3574            adcer::Diagval,
3575            adcer::Diagval,
3576            Adcer_SPEC,
3577            crate::common::RW,
3578        >::from_register(self, 0)
3579    }
3580
3581    #[doc = "Self-Diagnosis Mode Select"]
3582    #[inline(always)]
3583    pub fn diagld(
3584        self,
3585    ) -> crate::common::RegisterField<
3586        10,
3587        0x1,
3588        1,
3589        0,
3590        adcer::Diagld,
3591        adcer::Diagld,
3592        Adcer_SPEC,
3593        crate::common::RW,
3594    > {
3595        crate::common::RegisterField::<
3596            10,
3597            0x1,
3598            1,
3599            0,
3600            adcer::Diagld,
3601            adcer::Diagld,
3602            Adcer_SPEC,
3603            crate::common::RW,
3604        >::from_register(self, 0)
3605    }
3606
3607    #[doc = "Self-Diagnosis Enable"]
3608    #[inline(always)]
3609    pub fn diagm(
3610        self,
3611    ) -> crate::common::RegisterField<
3612        11,
3613        0x1,
3614        1,
3615        0,
3616        adcer::Diagm,
3617        adcer::Diagm,
3618        Adcer_SPEC,
3619        crate::common::RW,
3620    > {
3621        crate::common::RegisterField::<
3622            11,
3623            0x1,
3624            1,
3625            0,
3626            adcer::Diagm,
3627            adcer::Diagm,
3628            Adcer_SPEC,
3629            crate::common::RW,
3630        >::from_register(self, 0)
3631    }
3632
3633    #[doc = "A/D Data Register Format Select"]
3634    #[inline(always)]
3635    pub fn adrfmt(
3636        self,
3637    ) -> crate::common::RegisterField<
3638        15,
3639        0x1,
3640        1,
3641        0,
3642        adcer::Adrfmt,
3643        adcer::Adrfmt,
3644        Adcer_SPEC,
3645        crate::common::RW,
3646    > {
3647        crate::common::RegisterField::<
3648            15,
3649            0x1,
3650            1,
3651            0,
3652            adcer::Adrfmt,
3653            adcer::Adrfmt,
3654            Adcer_SPEC,
3655            crate::common::RW,
3656        >::from_register(self, 0)
3657    }
3658}
3659impl ::core::default::Default for Adcer {
3660    #[inline(always)]
3661    fn default() -> Adcer {
3662        <crate::RegValueT<Adcer_SPEC> as RegisterValue<_>>::new(0)
3663    }
3664}
3665pub mod adcer {
3666
3667    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3668    pub struct Ace_SPEC;
3669    pub type Ace = crate::EnumBitfieldStruct<u8, Ace_SPEC>;
3670    impl Ace {
3671        #[doc = "Disable automatic clearing"]
3672        pub const _0: Self = Self::new(0);
3673
3674        #[doc = "Enable automatic clearing"]
3675        pub const _1: Self = Self::new(1);
3676    }
3677    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3678    pub struct Diagval_SPEC;
3679    pub type Diagval = crate::EnumBitfieldStruct<u8, Diagval_SPEC>;
3680    impl Diagval {
3681        #[doc = "Setting prohibited when self-diagnosis is enabled"]
3682        pub const _00: Self = Self::new(0);
3683
3684        #[doc = "0 volts"]
3685        pub const _01: Self = Self::new(1);
3686
3687        #[doc = "Reference voltage × 1/2"]
3688        pub const _10: Self = Self::new(2);
3689
3690        #[doc = "Reference voltage"]
3691        pub const _11: Self = Self::new(3);
3692    }
3693    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3694    pub struct Diagld_SPEC;
3695    pub type Diagld = crate::EnumBitfieldStruct<u8, Diagld_SPEC>;
3696    impl Diagld {
3697        #[doc = "Select rotation mode for self-diagnosis voltage"]
3698        pub const _0: Self = Self::new(0);
3699
3700        #[doc = "Select mixed mode for self-diagnosis voltage"]
3701        pub const _1: Self = Self::new(1);
3702    }
3703    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3704    pub struct Diagm_SPEC;
3705    pub type Diagm = crate::EnumBitfieldStruct<u8, Diagm_SPEC>;
3706    impl Diagm {
3707        #[doc = "Disable ADC12 self-diagnosis"]
3708        pub const _0: Self = Self::new(0);
3709
3710        #[doc = "Enable ADC12 self-diagnosis"]
3711        pub const _1: Self = Self::new(1);
3712    }
3713    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3714    pub struct Adrfmt_SPEC;
3715    pub type Adrfmt = crate::EnumBitfieldStruct<u8, Adrfmt_SPEC>;
3716    impl Adrfmt {
3717        #[doc = "Select right-justified for the A/D data register format"]
3718        pub const _0: Self = Self::new(0);
3719
3720        #[doc = "Select left-justified for the A/D data register format"]
3721        pub const _1: Self = Self::new(1);
3722    }
3723}
3724#[doc(hidden)]
3725#[derive(Copy, Clone, Eq, PartialEq)]
3726pub struct Adstrgr_SPEC;
3727impl crate::sealed::RegSpec for Adstrgr_SPEC {
3728    type DataType = u16;
3729}
3730
3731#[doc = "A/D Conversion Start Trigger Select Register"]
3732pub type Adstrgr = crate::RegValueT<Adstrgr_SPEC>;
3733
3734impl Adstrgr {
3735    #[doc = "A/D Conversion Start Trigger Select for Group B"]
3736    #[inline(always)]
3737    pub fn trsb(
3738        self,
3739    ) -> crate::common::RegisterField<0, 0x3f, 1, 0, u8, u8, Adstrgr_SPEC, crate::common::RW> {
3740        crate::common::RegisterField::<0,0x3f,1,0,u8,u8,Adstrgr_SPEC,crate::common::RW>::from_register(self,0)
3741    }
3742
3743    #[doc = "A/D Conversion Start Trigger Select"]
3744    #[inline(always)]
3745    pub fn trsa(
3746        self,
3747    ) -> crate::common::RegisterField<8, 0x3f, 1, 0, u8, u8, Adstrgr_SPEC, crate::common::RW> {
3748        crate::common::RegisterField::<8,0x3f,1,0,u8,u8,Adstrgr_SPEC,crate::common::RW>::from_register(self,0)
3749    }
3750}
3751impl ::core::default::Default for Adstrgr {
3752    #[inline(always)]
3753    fn default() -> Adstrgr {
3754        <crate::RegValueT<Adstrgr_SPEC> as RegisterValue<_>>::new(0)
3755    }
3756}
3757
3758#[doc(hidden)]
3759#[derive(Copy, Clone, Eq, PartialEq)]
3760pub struct Adexicr_SPEC;
3761impl crate::sealed::RegSpec for Adexicr_SPEC {
3762    type DataType = u16;
3763}
3764
3765#[doc = "A/D Conversion Extended Input Control Registers"]
3766pub type Adexicr = crate::RegValueT<Adexicr_SPEC>;
3767
3768impl Adexicr {
3769    #[doc = "Temperature Sensor Output A/D-Converted Value Addition/Average Mode Select"]
3770    #[inline(always)]
3771    pub fn tssad(
3772        self,
3773    ) -> crate::common::RegisterField<
3774        0,
3775        0x1,
3776        1,
3777        0,
3778        adexicr::Tssad,
3779        adexicr::Tssad,
3780        Adexicr_SPEC,
3781        crate::common::RW,
3782    > {
3783        crate::common::RegisterField::<
3784            0,
3785            0x1,
3786            1,
3787            0,
3788            adexicr::Tssad,
3789            adexicr::Tssad,
3790            Adexicr_SPEC,
3791            crate::common::RW,
3792        >::from_register(self, 0)
3793    }
3794
3795    #[doc = "Internal Reference Voltage A/D-Converted Value Addition/Average Mode Select"]
3796    #[inline(always)]
3797    pub fn ocsad(
3798        self,
3799    ) -> crate::common::RegisterField<
3800        1,
3801        0x1,
3802        1,
3803        0,
3804        adexicr::Ocsad,
3805        adexicr::Ocsad,
3806        Adexicr_SPEC,
3807        crate::common::RW,
3808    > {
3809        crate::common::RegisterField::<
3810            1,
3811            0x1,
3812            1,
3813            0,
3814            adexicr::Ocsad,
3815            adexicr::Ocsad,
3816            Adexicr_SPEC,
3817            crate::common::RW,
3818        >::from_register(self, 0)
3819    }
3820
3821    #[doc = "Temperature Sensor Output A/D Conversion Select"]
3822    #[inline(always)]
3823    pub fn tssa(
3824        self,
3825    ) -> crate::common::RegisterField<
3826        8,
3827        0x1,
3828        1,
3829        0,
3830        adexicr::Tssa,
3831        adexicr::Tssa,
3832        Adexicr_SPEC,
3833        crate::common::RW,
3834    > {
3835        crate::common::RegisterField::<
3836            8,
3837            0x1,
3838            1,
3839            0,
3840            adexicr::Tssa,
3841            adexicr::Tssa,
3842            Adexicr_SPEC,
3843            crate::common::RW,
3844        >::from_register(self, 0)
3845    }
3846
3847    #[doc = "Internal Reference Voltage A/D Conversion Select"]
3848    #[inline(always)]
3849    pub fn ocsa(
3850        self,
3851    ) -> crate::common::RegisterField<
3852        9,
3853        0x1,
3854        1,
3855        0,
3856        adexicr::Ocsa,
3857        adexicr::Ocsa,
3858        Adexicr_SPEC,
3859        crate::common::RW,
3860    > {
3861        crate::common::RegisterField::<
3862            9,
3863            0x1,
3864            1,
3865            0,
3866            adexicr::Ocsa,
3867            adexicr::Ocsa,
3868            Adexicr_SPEC,
3869            crate::common::RW,
3870        >::from_register(self, 0)
3871    }
3872}
3873impl ::core::default::Default for Adexicr {
3874    #[inline(always)]
3875    fn default() -> Adexicr {
3876        <crate::RegValueT<Adexicr_SPEC> as RegisterValue<_>>::new(0)
3877    }
3878}
3879pub mod adexicr {
3880
3881    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3882    pub struct Tssad_SPEC;
3883    pub type Tssad = crate::EnumBitfieldStruct<u8, Tssad_SPEC>;
3884    impl Tssad {
3885        #[doc = "Do not select addition/average mode for temperature sensor output."]
3886        pub const _0: Self = Self::new(0);
3887
3888        #[doc = "Select addition/average mode for temperature sensor output."]
3889        pub const _1: Self = Self::new(1);
3890    }
3891    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3892    pub struct Ocsad_SPEC;
3893    pub type Ocsad = crate::EnumBitfieldStruct<u8, Ocsad_SPEC>;
3894    impl Ocsad {
3895        #[doc = "Do not select addition/average mode for internal reference voltage."]
3896        pub const _0: Self = Self::new(0);
3897
3898        #[doc = "Select addition/average mode for internal reference voltage."]
3899        pub const _1: Self = Self::new(1);
3900    }
3901    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3902    pub struct Tssa_SPEC;
3903    pub type Tssa = crate::EnumBitfieldStruct<u8, Tssa_SPEC>;
3904    impl Tssa {
3905        #[doc = "Disable A/D conversion of temperature sensor output"]
3906        pub const _0: Self = Self::new(0);
3907
3908        #[doc = "Enable A/D conversion of temperature sensor output"]
3909        pub const _1: Self = Self::new(1);
3910    }
3911    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3912    pub struct Ocsa_SPEC;
3913    pub type Ocsa = crate::EnumBitfieldStruct<u8, Ocsa_SPEC>;
3914    impl Ocsa {
3915        #[doc = "Disable A/D conversion of internal reference voltage"]
3916        pub const _0: Self = Self::new(0);
3917
3918        #[doc = "Enable A/D conversion of internal reference voltage"]
3919        pub const _1: Self = Self::new(1);
3920    }
3921}
3922#[doc(hidden)]
3923#[derive(Copy, Clone, Eq, PartialEq)]
3924pub struct Adansb0_SPEC;
3925impl crate::sealed::RegSpec for Adansb0_SPEC {
3926    type DataType = u16;
3927}
3928
3929#[doc = "A/D Channel Select Register B0"]
3930pub type Adansb0 = crate::RegValueT<Adansb0_SPEC>;
3931
3932impl Adansb0 {
3933    #[doc = "A/D Conversion Channels Select"]
3934    #[inline(always)]
3935    pub fn ansb00(
3936        self,
3937    ) -> crate::common::RegisterField<
3938        0,
3939        0x1,
3940        1,
3941        0,
3942        adansb0::Ansb00,
3943        adansb0::Ansb00,
3944        Adansb0_SPEC,
3945        crate::common::RW,
3946    > {
3947        crate::common::RegisterField::<
3948            0,
3949            0x1,
3950            1,
3951            0,
3952            adansb0::Ansb00,
3953            adansb0::Ansb00,
3954            Adansb0_SPEC,
3955            crate::common::RW,
3956        >::from_register(self, 0)
3957    }
3958
3959    #[doc = "A/D Conversion Channels Select"]
3960    #[inline(always)]
3961    pub fn ansb01(
3962        self,
3963    ) -> crate::common::RegisterField<
3964        1,
3965        0x1,
3966        1,
3967        0,
3968        adansb0::Ansb01,
3969        adansb0::Ansb01,
3970        Adansb0_SPEC,
3971        crate::common::RW,
3972    > {
3973        crate::common::RegisterField::<
3974            1,
3975            0x1,
3976            1,
3977            0,
3978            adansb0::Ansb01,
3979            adansb0::Ansb01,
3980            Adansb0_SPEC,
3981            crate::common::RW,
3982        >::from_register(self, 0)
3983    }
3984
3985    #[doc = "A/D Conversion Channels Select"]
3986    #[inline(always)]
3987    pub fn ansb02(
3988        self,
3989    ) -> crate::common::RegisterField<
3990        2,
3991        0x1,
3992        1,
3993        0,
3994        adansb0::Ansb02,
3995        adansb0::Ansb02,
3996        Adansb0_SPEC,
3997        crate::common::RW,
3998    > {
3999        crate::common::RegisterField::<
4000            2,
4001            0x1,
4002            1,
4003            0,
4004            adansb0::Ansb02,
4005            adansb0::Ansb02,
4006            Adansb0_SPEC,
4007            crate::common::RW,
4008        >::from_register(self, 0)
4009    }
4010
4011    #[doc = "A/D Conversion Channels Select"]
4012    #[inline(always)]
4013    pub fn ansb03(
4014        self,
4015    ) -> crate::common::RegisterField<
4016        3,
4017        0x1,
4018        1,
4019        0,
4020        adansb0::Ansb03,
4021        adansb0::Ansb03,
4022        Adansb0_SPEC,
4023        crate::common::RW,
4024    > {
4025        crate::common::RegisterField::<
4026            3,
4027            0x1,
4028            1,
4029            0,
4030            adansb0::Ansb03,
4031            adansb0::Ansb03,
4032            Adansb0_SPEC,
4033            crate::common::RW,
4034        >::from_register(self, 0)
4035    }
4036
4037    #[doc = "A/D Conversion Channels Select"]
4038    #[inline(always)]
4039    pub fn ansb04(
4040        self,
4041    ) -> crate::common::RegisterField<
4042        4,
4043        0x1,
4044        1,
4045        0,
4046        adansb0::Ansb04,
4047        adansb0::Ansb04,
4048        Adansb0_SPEC,
4049        crate::common::RW,
4050    > {
4051        crate::common::RegisterField::<
4052            4,
4053            0x1,
4054            1,
4055            0,
4056            adansb0::Ansb04,
4057            adansb0::Ansb04,
4058            Adansb0_SPEC,
4059            crate::common::RW,
4060        >::from_register(self, 0)
4061    }
4062
4063    #[doc = "A/D Conversion Channels Select"]
4064    #[inline(always)]
4065    pub fn ansb05(
4066        self,
4067    ) -> crate::common::RegisterField<
4068        5,
4069        0x1,
4070        1,
4071        0,
4072        adansb0::Ansb05,
4073        adansb0::Ansb05,
4074        Adansb0_SPEC,
4075        crate::common::RW,
4076    > {
4077        crate::common::RegisterField::<
4078            5,
4079            0x1,
4080            1,
4081            0,
4082            adansb0::Ansb05,
4083            adansb0::Ansb05,
4084            Adansb0_SPEC,
4085            crate::common::RW,
4086        >::from_register(self, 0)
4087    }
4088
4089    #[doc = "A/D Conversion Channels Select"]
4090    #[inline(always)]
4091    pub fn ansb06(
4092        self,
4093    ) -> crate::common::RegisterField<
4094        6,
4095        0x1,
4096        1,
4097        0,
4098        adansb0::Ansb06,
4099        adansb0::Ansb06,
4100        Adansb0_SPEC,
4101        crate::common::RW,
4102    > {
4103        crate::common::RegisterField::<
4104            6,
4105            0x1,
4106            1,
4107            0,
4108            adansb0::Ansb06,
4109            adansb0::Ansb06,
4110            Adansb0_SPEC,
4111            crate::common::RW,
4112        >::from_register(self, 0)
4113    }
4114
4115    #[doc = "A/D Conversion Channels Select"]
4116    #[inline(always)]
4117    pub fn ansb07(
4118        self,
4119    ) -> crate::common::RegisterField<
4120        7,
4121        0x1,
4122        1,
4123        0,
4124        adansb0::Ansb07,
4125        adansb0::Ansb07,
4126        Adansb0_SPEC,
4127        crate::common::RW,
4128    > {
4129        crate::common::RegisterField::<
4130            7,
4131            0x1,
4132            1,
4133            0,
4134            adansb0::Ansb07,
4135            adansb0::Ansb07,
4136            Adansb0_SPEC,
4137            crate::common::RW,
4138        >::from_register(self, 0)
4139    }
4140
4141    #[doc = "A/D Conversion Channels Select"]
4142    #[inline(always)]
4143    pub fn ansb08(
4144        self,
4145    ) -> crate::common::RegisterField<
4146        8,
4147        0x1,
4148        1,
4149        0,
4150        adansb0::Ansb08,
4151        adansb0::Ansb08,
4152        Adansb0_SPEC,
4153        crate::common::RW,
4154    > {
4155        crate::common::RegisterField::<
4156            8,
4157            0x1,
4158            1,
4159            0,
4160            adansb0::Ansb08,
4161            adansb0::Ansb08,
4162            Adansb0_SPEC,
4163            crate::common::RW,
4164        >::from_register(self, 0)
4165    }
4166
4167    #[doc = "A/D Conversion Channels Select"]
4168    #[inline(always)]
4169    pub fn ansb09(
4170        self,
4171    ) -> crate::common::RegisterField<
4172        9,
4173        0x1,
4174        1,
4175        0,
4176        adansb0::Ansb09,
4177        adansb0::Ansb09,
4178        Adansb0_SPEC,
4179        crate::common::RW,
4180    > {
4181        crate::common::RegisterField::<
4182            9,
4183            0x1,
4184            1,
4185            0,
4186            adansb0::Ansb09,
4187            adansb0::Ansb09,
4188            Adansb0_SPEC,
4189            crate::common::RW,
4190        >::from_register(self, 0)
4191    }
4192
4193    #[doc = "A/D Conversion Channels Select"]
4194    #[inline(always)]
4195    pub fn ansb10(
4196        self,
4197    ) -> crate::common::RegisterField<
4198        10,
4199        0x1,
4200        1,
4201        0,
4202        adansb0::Ansb10,
4203        adansb0::Ansb10,
4204        Adansb0_SPEC,
4205        crate::common::RW,
4206    > {
4207        crate::common::RegisterField::<
4208            10,
4209            0x1,
4210            1,
4211            0,
4212            adansb0::Ansb10,
4213            adansb0::Ansb10,
4214            Adansb0_SPEC,
4215            crate::common::RW,
4216        >::from_register(self, 0)
4217    }
4218
4219    #[doc = "A/D Conversion Channels Select"]
4220    #[inline(always)]
4221    pub fn ansb11(
4222        self,
4223    ) -> crate::common::RegisterField<
4224        11,
4225        0x1,
4226        1,
4227        0,
4228        adansb0::Ansb11,
4229        adansb0::Ansb11,
4230        Adansb0_SPEC,
4231        crate::common::RW,
4232    > {
4233        crate::common::RegisterField::<
4234            11,
4235            0x1,
4236            1,
4237            0,
4238            adansb0::Ansb11,
4239            adansb0::Ansb11,
4240            Adansb0_SPEC,
4241            crate::common::RW,
4242        >::from_register(self, 0)
4243    }
4244
4245    #[doc = "A/D Conversion Channels Select"]
4246    #[inline(always)]
4247    pub fn ansb12(
4248        self,
4249    ) -> crate::common::RegisterField<
4250        12,
4251        0x1,
4252        1,
4253        0,
4254        adansb0::Ansb12,
4255        adansb0::Ansb12,
4256        Adansb0_SPEC,
4257        crate::common::RW,
4258    > {
4259        crate::common::RegisterField::<
4260            12,
4261            0x1,
4262            1,
4263            0,
4264            adansb0::Ansb12,
4265            adansb0::Ansb12,
4266            Adansb0_SPEC,
4267            crate::common::RW,
4268        >::from_register(self, 0)
4269    }
4270
4271    #[doc = "A/D Conversion Channels Select"]
4272    #[inline(always)]
4273    pub fn ansb13(
4274        self,
4275    ) -> crate::common::RegisterField<
4276        13,
4277        0x1,
4278        1,
4279        0,
4280        adansb0::Ansb13,
4281        adansb0::Ansb13,
4282        Adansb0_SPEC,
4283        crate::common::RW,
4284    > {
4285        crate::common::RegisterField::<
4286            13,
4287            0x1,
4288            1,
4289            0,
4290            adansb0::Ansb13,
4291            adansb0::Ansb13,
4292            Adansb0_SPEC,
4293            crate::common::RW,
4294        >::from_register(self, 0)
4295    }
4296
4297    #[doc = "A/D Conversion Channels Select"]
4298    #[inline(always)]
4299    pub fn ansb14(
4300        self,
4301    ) -> crate::common::RegisterField<
4302        14,
4303        0x1,
4304        1,
4305        0,
4306        adansb0::Ansb14,
4307        adansb0::Ansb14,
4308        Adansb0_SPEC,
4309        crate::common::RW,
4310    > {
4311        crate::common::RegisterField::<
4312            14,
4313            0x1,
4314            1,
4315            0,
4316            adansb0::Ansb14,
4317            adansb0::Ansb14,
4318            Adansb0_SPEC,
4319            crate::common::RW,
4320        >::from_register(self, 0)
4321    }
4322
4323    #[doc = "A/D Conversion Channels Select"]
4324    #[inline(always)]
4325    pub fn ansb15(
4326        self,
4327    ) -> crate::common::RegisterField<
4328        15,
4329        0x1,
4330        1,
4331        0,
4332        adansb0::Ansb15,
4333        adansb0::Ansb15,
4334        Adansb0_SPEC,
4335        crate::common::RW,
4336    > {
4337        crate::common::RegisterField::<
4338            15,
4339            0x1,
4340            1,
4341            0,
4342            adansb0::Ansb15,
4343            adansb0::Ansb15,
4344            Adansb0_SPEC,
4345            crate::common::RW,
4346        >::from_register(self, 0)
4347    }
4348}
4349impl ::core::default::Default for Adansb0 {
4350    #[inline(always)]
4351    fn default() -> Adansb0 {
4352        <crate::RegValueT<Adansb0_SPEC> as RegisterValue<_>>::new(0)
4353    }
4354}
4355pub mod adansb0 {
4356
4357    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4358    pub struct Ansb00_SPEC;
4359    pub type Ansb00 = crate::EnumBitfieldStruct<u8, Ansb00_SPEC>;
4360    impl Ansb00 {
4361        #[doc = "Do not select associated input channel."]
4362        pub const _0: Self = Self::new(0);
4363
4364        #[doc = "Select associated input channel."]
4365        pub const _1: Self = Self::new(1);
4366    }
4367    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4368    pub struct Ansb01_SPEC;
4369    pub type Ansb01 = crate::EnumBitfieldStruct<u8, Ansb01_SPEC>;
4370    impl Ansb01 {
4371        #[doc = "Do not select associated input channel."]
4372        pub const _0: Self = Self::new(0);
4373
4374        #[doc = "Select associated input channel."]
4375        pub const _1: Self = Self::new(1);
4376    }
4377    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4378    pub struct Ansb02_SPEC;
4379    pub type Ansb02 = crate::EnumBitfieldStruct<u8, Ansb02_SPEC>;
4380    impl Ansb02 {
4381        #[doc = "Do not select associated input channel."]
4382        pub const _0: Self = Self::new(0);
4383
4384        #[doc = "Select associated input channel."]
4385        pub const _1: Self = Self::new(1);
4386    }
4387    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4388    pub struct Ansb03_SPEC;
4389    pub type Ansb03 = crate::EnumBitfieldStruct<u8, Ansb03_SPEC>;
4390    impl Ansb03 {
4391        #[doc = "Do not select associated input channel."]
4392        pub const _0: Self = Self::new(0);
4393
4394        #[doc = "Select associated input channel."]
4395        pub const _1: Self = Self::new(1);
4396    }
4397    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4398    pub struct Ansb04_SPEC;
4399    pub type Ansb04 = crate::EnumBitfieldStruct<u8, Ansb04_SPEC>;
4400    impl Ansb04 {
4401        #[doc = "Do not select associated input channel."]
4402        pub const _0: Self = Self::new(0);
4403
4404        #[doc = "Select associated input channel."]
4405        pub const _1: Self = Self::new(1);
4406    }
4407    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4408    pub struct Ansb05_SPEC;
4409    pub type Ansb05 = crate::EnumBitfieldStruct<u8, Ansb05_SPEC>;
4410    impl Ansb05 {
4411        #[doc = "Do not select associated input channel."]
4412        pub const _0: Self = Self::new(0);
4413
4414        #[doc = "Select associated input channel."]
4415        pub const _1: Self = Self::new(1);
4416    }
4417    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4418    pub struct Ansb06_SPEC;
4419    pub type Ansb06 = crate::EnumBitfieldStruct<u8, Ansb06_SPEC>;
4420    impl Ansb06 {
4421        #[doc = "Do not select associated input channel."]
4422        pub const _0: Self = Self::new(0);
4423
4424        #[doc = "Select associated input channel."]
4425        pub const _1: Self = Self::new(1);
4426    }
4427    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4428    pub struct Ansb07_SPEC;
4429    pub type Ansb07 = crate::EnumBitfieldStruct<u8, Ansb07_SPEC>;
4430    impl Ansb07 {
4431        #[doc = "Do not select associated input channel."]
4432        pub const _0: Self = Self::new(0);
4433
4434        #[doc = "Select associated input channel."]
4435        pub const _1: Self = Self::new(1);
4436    }
4437    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4438    pub struct Ansb08_SPEC;
4439    pub type Ansb08 = crate::EnumBitfieldStruct<u8, Ansb08_SPEC>;
4440    impl Ansb08 {
4441        #[doc = "Do not select associated input channel."]
4442        pub const _0: Self = Self::new(0);
4443
4444        #[doc = "Select associated input channel."]
4445        pub const _1: Self = Self::new(1);
4446    }
4447    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4448    pub struct Ansb09_SPEC;
4449    pub type Ansb09 = crate::EnumBitfieldStruct<u8, Ansb09_SPEC>;
4450    impl Ansb09 {
4451        #[doc = "Do not select associated input channel."]
4452        pub const _0: Self = Self::new(0);
4453
4454        #[doc = "Select associated input channel."]
4455        pub const _1: Self = Self::new(1);
4456    }
4457    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4458    pub struct Ansb10_SPEC;
4459    pub type Ansb10 = crate::EnumBitfieldStruct<u8, Ansb10_SPEC>;
4460    impl Ansb10 {
4461        #[doc = "Do not select associated input channel."]
4462        pub const _0: Self = Self::new(0);
4463
4464        #[doc = "Select associated input channel."]
4465        pub const _1: Self = Self::new(1);
4466    }
4467    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4468    pub struct Ansb11_SPEC;
4469    pub type Ansb11 = crate::EnumBitfieldStruct<u8, Ansb11_SPEC>;
4470    impl Ansb11 {
4471        #[doc = "Do not select associated input channel."]
4472        pub const _0: Self = Self::new(0);
4473
4474        #[doc = "Select associated input channel."]
4475        pub const _1: Self = Self::new(1);
4476    }
4477    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4478    pub struct Ansb12_SPEC;
4479    pub type Ansb12 = crate::EnumBitfieldStruct<u8, Ansb12_SPEC>;
4480    impl Ansb12 {
4481        #[doc = "Do not select associated input channel."]
4482        pub const _0: Self = Self::new(0);
4483
4484        #[doc = "Select associated input channel."]
4485        pub const _1: Self = Self::new(1);
4486    }
4487    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4488    pub struct Ansb13_SPEC;
4489    pub type Ansb13 = crate::EnumBitfieldStruct<u8, Ansb13_SPEC>;
4490    impl Ansb13 {
4491        #[doc = "Do not select associated input channel."]
4492        pub const _0: Self = Self::new(0);
4493
4494        #[doc = "Select associated input channel."]
4495        pub const _1: Self = Self::new(1);
4496    }
4497    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4498    pub struct Ansb14_SPEC;
4499    pub type Ansb14 = crate::EnumBitfieldStruct<u8, Ansb14_SPEC>;
4500    impl Ansb14 {
4501        #[doc = "Do not select associated input channel."]
4502        pub const _0: Self = Self::new(0);
4503
4504        #[doc = "Select associated input channel."]
4505        pub const _1: Self = Self::new(1);
4506    }
4507    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4508    pub struct Ansb15_SPEC;
4509    pub type Ansb15 = crate::EnumBitfieldStruct<u8, Ansb15_SPEC>;
4510    impl Ansb15 {
4511        #[doc = "Do not select associated input channel."]
4512        pub const _0: Self = Self::new(0);
4513
4514        #[doc = "Select associated input channel."]
4515        pub const _1: Self = Self::new(1);
4516    }
4517}
4518#[doc(hidden)]
4519#[derive(Copy, Clone, Eq, PartialEq)]
4520pub struct Adansb1_SPEC;
4521impl crate::sealed::RegSpec for Adansb1_SPEC {
4522    type DataType = u16;
4523}
4524
4525#[doc = "A/D Channel Select Register B1"]
4526pub type Adansb1 = crate::RegValueT<Adansb1_SPEC>;
4527
4528impl Adansb1 {
4529    #[doc = "A/D Conversion Channels Select"]
4530    #[inline(always)]
4531    pub fn ansb16(
4532        self,
4533    ) -> crate::common::RegisterField<
4534        0,
4535        0x1,
4536        1,
4537        0,
4538        adansb1::Ansb16,
4539        adansb1::Ansb16,
4540        Adansb1_SPEC,
4541        crate::common::RW,
4542    > {
4543        crate::common::RegisterField::<
4544            0,
4545            0x1,
4546            1,
4547            0,
4548            adansb1::Ansb16,
4549            adansb1::Ansb16,
4550            Adansb1_SPEC,
4551            crate::common::RW,
4552        >::from_register(self, 0)
4553    }
4554
4555    #[doc = "A/D Conversion Channels Select"]
4556    #[inline(always)]
4557    pub fn ansb17(
4558        self,
4559    ) -> crate::common::RegisterField<
4560        1,
4561        0x1,
4562        1,
4563        0,
4564        adansb1::Ansb17,
4565        adansb1::Ansb17,
4566        Adansb1_SPEC,
4567        crate::common::RW,
4568    > {
4569        crate::common::RegisterField::<
4570            1,
4571            0x1,
4572            1,
4573            0,
4574            adansb1::Ansb17,
4575            adansb1::Ansb17,
4576            Adansb1_SPEC,
4577            crate::common::RW,
4578        >::from_register(self, 0)
4579    }
4580
4581    #[doc = "A/D Conversion Channels Select"]
4582    #[inline(always)]
4583    pub fn ansb18(
4584        self,
4585    ) -> crate::common::RegisterField<
4586        2,
4587        0x1,
4588        1,
4589        0,
4590        adansb1::Ansb18,
4591        adansb1::Ansb18,
4592        Adansb1_SPEC,
4593        crate::common::RW,
4594    > {
4595        crate::common::RegisterField::<
4596            2,
4597            0x1,
4598            1,
4599            0,
4600            adansb1::Ansb18,
4601            adansb1::Ansb18,
4602            Adansb1_SPEC,
4603            crate::common::RW,
4604        >::from_register(self, 0)
4605    }
4606
4607    #[doc = "A/D Conversion Channels Select"]
4608    #[inline(always)]
4609    pub fn ansb19(
4610        self,
4611    ) -> crate::common::RegisterField<
4612        3,
4613        0x1,
4614        1,
4615        0,
4616        adansb1::Ansb19,
4617        adansb1::Ansb19,
4618        Adansb1_SPEC,
4619        crate::common::RW,
4620    > {
4621        crate::common::RegisterField::<
4622            3,
4623            0x1,
4624            1,
4625            0,
4626            adansb1::Ansb19,
4627            adansb1::Ansb19,
4628            Adansb1_SPEC,
4629            crate::common::RW,
4630        >::from_register(self, 0)
4631    }
4632
4633    #[doc = "A/D Conversion Channels Select"]
4634    #[inline(always)]
4635    pub fn ansb20(
4636        self,
4637    ) -> crate::common::RegisterField<
4638        4,
4639        0x1,
4640        1,
4641        0,
4642        adansb1::Ansb20,
4643        adansb1::Ansb20,
4644        Adansb1_SPEC,
4645        crate::common::RW,
4646    > {
4647        crate::common::RegisterField::<
4648            4,
4649            0x1,
4650            1,
4651            0,
4652            adansb1::Ansb20,
4653            adansb1::Ansb20,
4654            Adansb1_SPEC,
4655            crate::common::RW,
4656        >::from_register(self, 0)
4657    }
4658
4659    #[doc = "A/D Conversion Channels Select"]
4660    #[inline(always)]
4661    pub fn ansb21(
4662        self,
4663    ) -> crate::common::RegisterField<
4664        5,
4665        0x1,
4666        1,
4667        0,
4668        adansb1::Ansb21,
4669        adansb1::Ansb21,
4670        Adansb1_SPEC,
4671        crate::common::RW,
4672    > {
4673        crate::common::RegisterField::<
4674            5,
4675            0x1,
4676            1,
4677            0,
4678            adansb1::Ansb21,
4679            adansb1::Ansb21,
4680            Adansb1_SPEC,
4681            crate::common::RW,
4682        >::from_register(self, 0)
4683    }
4684
4685    #[doc = "A/D Conversion Channels Select"]
4686    #[inline(always)]
4687    pub fn ansb22(
4688        self,
4689    ) -> crate::common::RegisterField<
4690        6,
4691        0x1,
4692        1,
4693        0,
4694        adansb1::Ansb22,
4695        adansb1::Ansb22,
4696        Adansb1_SPEC,
4697        crate::common::RW,
4698    > {
4699        crate::common::RegisterField::<
4700            6,
4701            0x1,
4702            1,
4703            0,
4704            adansb1::Ansb22,
4705            adansb1::Ansb22,
4706            Adansb1_SPEC,
4707            crate::common::RW,
4708        >::from_register(self, 0)
4709    }
4710
4711    #[doc = "A/D Conversion Channels Select"]
4712    #[inline(always)]
4713    pub fn ansb23(
4714        self,
4715    ) -> crate::common::RegisterField<
4716        7,
4717        0x1,
4718        1,
4719        0,
4720        adansb1::Ansb23,
4721        adansb1::Ansb23,
4722        Adansb1_SPEC,
4723        crate::common::RW,
4724    > {
4725        crate::common::RegisterField::<
4726            7,
4727            0x1,
4728            1,
4729            0,
4730            adansb1::Ansb23,
4731            adansb1::Ansb23,
4732            Adansb1_SPEC,
4733            crate::common::RW,
4734        >::from_register(self, 0)
4735    }
4736
4737    #[doc = "A/D Conversion Channels Select"]
4738    #[inline(always)]
4739    pub fn ansb24(
4740        self,
4741    ) -> crate::common::RegisterField<
4742        8,
4743        0x1,
4744        1,
4745        0,
4746        adansb1::Ansb24,
4747        adansb1::Ansb24,
4748        Adansb1_SPEC,
4749        crate::common::RW,
4750    > {
4751        crate::common::RegisterField::<
4752            8,
4753            0x1,
4754            1,
4755            0,
4756            adansb1::Ansb24,
4757            adansb1::Ansb24,
4758            Adansb1_SPEC,
4759            crate::common::RW,
4760        >::from_register(self, 0)
4761    }
4762
4763    #[doc = "A/D Conversion Channels Select"]
4764    #[inline(always)]
4765    pub fn ansb25(
4766        self,
4767    ) -> crate::common::RegisterField<
4768        9,
4769        0x1,
4770        1,
4771        0,
4772        adansb1::Ansb25,
4773        adansb1::Ansb25,
4774        Adansb1_SPEC,
4775        crate::common::RW,
4776    > {
4777        crate::common::RegisterField::<
4778            9,
4779            0x1,
4780            1,
4781            0,
4782            adansb1::Ansb25,
4783            adansb1::Ansb25,
4784            Adansb1_SPEC,
4785            crate::common::RW,
4786        >::from_register(self, 0)
4787    }
4788
4789    #[doc = "A/D Conversion Channels Select"]
4790    #[inline(always)]
4791    pub fn ansb26(
4792        self,
4793    ) -> crate::common::RegisterField<
4794        10,
4795        0x1,
4796        1,
4797        0,
4798        adansb1::Ansb26,
4799        adansb1::Ansb26,
4800        Adansb1_SPEC,
4801        crate::common::RW,
4802    > {
4803        crate::common::RegisterField::<
4804            10,
4805            0x1,
4806            1,
4807            0,
4808            adansb1::Ansb26,
4809            adansb1::Ansb26,
4810            Adansb1_SPEC,
4811            crate::common::RW,
4812        >::from_register(self, 0)
4813    }
4814
4815    #[doc = "A/D Conversion Channels Select"]
4816    #[inline(always)]
4817    pub fn ansb27(
4818        self,
4819    ) -> crate::common::RegisterField<
4820        11,
4821        0x1,
4822        1,
4823        0,
4824        adansb1::Ansb27,
4825        adansb1::Ansb27,
4826        Adansb1_SPEC,
4827        crate::common::RW,
4828    > {
4829        crate::common::RegisterField::<
4830            11,
4831            0x1,
4832            1,
4833            0,
4834            adansb1::Ansb27,
4835            adansb1::Ansb27,
4836            Adansb1_SPEC,
4837            crate::common::RW,
4838        >::from_register(self, 0)
4839    }
4840
4841    #[doc = "A/D Conversion Channels Select"]
4842    #[inline(always)]
4843    pub fn ansb28(
4844        self,
4845    ) -> crate::common::RegisterField<
4846        12,
4847        0x1,
4848        1,
4849        0,
4850        adansb1::Ansb28,
4851        adansb1::Ansb28,
4852        Adansb1_SPEC,
4853        crate::common::RW,
4854    > {
4855        crate::common::RegisterField::<
4856            12,
4857            0x1,
4858            1,
4859            0,
4860            adansb1::Ansb28,
4861            adansb1::Ansb28,
4862            Adansb1_SPEC,
4863            crate::common::RW,
4864        >::from_register(self, 0)
4865    }
4866
4867    #[doc = "A/D Conversion Channels Select"]
4868    #[inline(always)]
4869    pub fn ansb29(
4870        self,
4871    ) -> crate::common::RegisterField<
4872        13,
4873        0x1,
4874        1,
4875        0,
4876        adansb1::Ansb29,
4877        adansb1::Ansb29,
4878        Adansb1_SPEC,
4879        crate::common::RW,
4880    > {
4881        crate::common::RegisterField::<
4882            13,
4883            0x1,
4884            1,
4885            0,
4886            adansb1::Ansb29,
4887            adansb1::Ansb29,
4888            Adansb1_SPEC,
4889            crate::common::RW,
4890        >::from_register(self, 0)
4891    }
4892
4893    #[doc = "A/D Conversion Channels Select"]
4894    #[inline(always)]
4895    pub fn ansb30(
4896        self,
4897    ) -> crate::common::RegisterField<
4898        14,
4899        0x1,
4900        1,
4901        0,
4902        adansb1::Ansb30,
4903        adansb1::Ansb30,
4904        Adansb1_SPEC,
4905        crate::common::RW,
4906    > {
4907        crate::common::RegisterField::<
4908            14,
4909            0x1,
4910            1,
4911            0,
4912            adansb1::Ansb30,
4913            adansb1::Ansb30,
4914            Adansb1_SPEC,
4915            crate::common::RW,
4916        >::from_register(self, 0)
4917    }
4918
4919    #[doc = "A/D Conversion Channels Select"]
4920    #[inline(always)]
4921    pub fn ansb31(
4922        self,
4923    ) -> crate::common::RegisterField<
4924        15,
4925        0x1,
4926        1,
4927        0,
4928        adansb1::Ansb31,
4929        adansb1::Ansb31,
4930        Adansb1_SPEC,
4931        crate::common::RW,
4932    > {
4933        crate::common::RegisterField::<
4934            15,
4935            0x1,
4936            1,
4937            0,
4938            adansb1::Ansb31,
4939            adansb1::Ansb31,
4940            Adansb1_SPEC,
4941            crate::common::RW,
4942        >::from_register(self, 0)
4943    }
4944}
4945impl ::core::default::Default for Adansb1 {
4946    #[inline(always)]
4947    fn default() -> Adansb1 {
4948        <crate::RegValueT<Adansb1_SPEC> as RegisterValue<_>>::new(0)
4949    }
4950}
4951pub mod adansb1 {
4952
4953    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4954    pub struct Ansb16_SPEC;
4955    pub type Ansb16 = crate::EnumBitfieldStruct<u8, Ansb16_SPEC>;
4956    impl Ansb16 {
4957        #[doc = "Do not select associated input channel."]
4958        pub const _0: Self = Self::new(0);
4959
4960        #[doc = "Select associated input channel."]
4961        pub const _1: Self = Self::new(1);
4962    }
4963    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4964    pub struct Ansb17_SPEC;
4965    pub type Ansb17 = crate::EnumBitfieldStruct<u8, Ansb17_SPEC>;
4966    impl Ansb17 {
4967        #[doc = "Do not select associated input channel."]
4968        pub const _0: Self = Self::new(0);
4969
4970        #[doc = "Select associated input channel."]
4971        pub const _1: Self = Self::new(1);
4972    }
4973    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4974    pub struct Ansb18_SPEC;
4975    pub type Ansb18 = crate::EnumBitfieldStruct<u8, Ansb18_SPEC>;
4976    impl Ansb18 {
4977        #[doc = "Do not select associated input channel."]
4978        pub const _0: Self = Self::new(0);
4979
4980        #[doc = "Select associated input channel."]
4981        pub const _1: Self = Self::new(1);
4982    }
4983    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4984    pub struct Ansb19_SPEC;
4985    pub type Ansb19 = crate::EnumBitfieldStruct<u8, Ansb19_SPEC>;
4986    impl Ansb19 {
4987        #[doc = "Do not select associated input channel."]
4988        pub const _0: Self = Self::new(0);
4989
4990        #[doc = "Select associated input channel."]
4991        pub const _1: Self = Self::new(1);
4992    }
4993    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4994    pub struct Ansb20_SPEC;
4995    pub type Ansb20 = crate::EnumBitfieldStruct<u8, Ansb20_SPEC>;
4996    impl Ansb20 {
4997        #[doc = "Do not select associated input channel."]
4998        pub const _0: Self = Self::new(0);
4999
5000        #[doc = "Select associated input channel."]
5001        pub const _1: Self = Self::new(1);
5002    }
5003    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5004    pub struct Ansb21_SPEC;
5005    pub type Ansb21 = crate::EnumBitfieldStruct<u8, Ansb21_SPEC>;
5006    impl Ansb21 {
5007        #[doc = "Do not select associated input channel."]
5008        pub const _0: Self = Self::new(0);
5009
5010        #[doc = "Select associated input channel."]
5011        pub const _1: Self = Self::new(1);
5012    }
5013    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5014    pub struct Ansb22_SPEC;
5015    pub type Ansb22 = crate::EnumBitfieldStruct<u8, Ansb22_SPEC>;
5016    impl Ansb22 {
5017        #[doc = "Do not select associated input channel."]
5018        pub const _0: Self = Self::new(0);
5019
5020        #[doc = "Select associated input channel."]
5021        pub const _1: Self = Self::new(1);
5022    }
5023    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5024    pub struct Ansb23_SPEC;
5025    pub type Ansb23 = crate::EnumBitfieldStruct<u8, Ansb23_SPEC>;
5026    impl Ansb23 {
5027        #[doc = "Do not select associated input channel."]
5028        pub const _0: Self = Self::new(0);
5029
5030        #[doc = "Select associated input channel."]
5031        pub const _1: Self = Self::new(1);
5032    }
5033    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5034    pub struct Ansb24_SPEC;
5035    pub type Ansb24 = crate::EnumBitfieldStruct<u8, Ansb24_SPEC>;
5036    impl Ansb24 {
5037        #[doc = "Do not select associated input channel."]
5038        pub const _0: Self = Self::new(0);
5039
5040        #[doc = "Select associated input channel."]
5041        pub const _1: Self = Self::new(1);
5042    }
5043    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5044    pub struct Ansb25_SPEC;
5045    pub type Ansb25 = crate::EnumBitfieldStruct<u8, Ansb25_SPEC>;
5046    impl Ansb25 {
5047        #[doc = "Do not select associated input channel."]
5048        pub const _0: Self = Self::new(0);
5049
5050        #[doc = "Select associated input channel."]
5051        pub const _1: Self = Self::new(1);
5052    }
5053    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5054    pub struct Ansb26_SPEC;
5055    pub type Ansb26 = crate::EnumBitfieldStruct<u8, Ansb26_SPEC>;
5056    impl Ansb26 {
5057        #[doc = "Do not select associated input channel."]
5058        pub const _0: Self = Self::new(0);
5059
5060        #[doc = "Select associated input channel."]
5061        pub const _1: Self = Self::new(1);
5062    }
5063    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5064    pub struct Ansb27_SPEC;
5065    pub type Ansb27 = crate::EnumBitfieldStruct<u8, Ansb27_SPEC>;
5066    impl Ansb27 {
5067        #[doc = "Do not select associated input channel."]
5068        pub const _0: Self = Self::new(0);
5069
5070        #[doc = "Select associated input channel."]
5071        pub const _1: Self = Self::new(1);
5072    }
5073    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5074    pub struct Ansb28_SPEC;
5075    pub type Ansb28 = crate::EnumBitfieldStruct<u8, Ansb28_SPEC>;
5076    impl Ansb28 {
5077        #[doc = "Do not select associated input channel."]
5078        pub const _0: Self = Self::new(0);
5079
5080        #[doc = "Select associated input channel."]
5081        pub const _1: Self = Self::new(1);
5082    }
5083    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5084    pub struct Ansb29_SPEC;
5085    pub type Ansb29 = crate::EnumBitfieldStruct<u8, Ansb29_SPEC>;
5086    impl Ansb29 {
5087        #[doc = "Do not select associated input channel."]
5088        pub const _0: Self = Self::new(0);
5089
5090        #[doc = "Select associated input channel."]
5091        pub const _1: Self = Self::new(1);
5092    }
5093    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5094    pub struct Ansb30_SPEC;
5095    pub type Ansb30 = crate::EnumBitfieldStruct<u8, Ansb30_SPEC>;
5096    impl Ansb30 {
5097        #[doc = "Do not select associated input channel."]
5098        pub const _0: Self = Self::new(0);
5099
5100        #[doc = "Select associated input channel."]
5101        pub const _1: Self = Self::new(1);
5102    }
5103    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5104    pub struct Ansb31_SPEC;
5105    pub type Ansb31 = crate::EnumBitfieldStruct<u8, Ansb31_SPEC>;
5106    impl Ansb31 {
5107        #[doc = "Do not select associated input channel."]
5108        pub const _0: Self = Self::new(0);
5109
5110        #[doc = "Select associated input channel."]
5111        pub const _1: Self = Self::new(1);
5112    }
5113}
5114#[doc(hidden)]
5115#[derive(Copy, Clone, Eq, PartialEq)]
5116pub struct Addbldr_SPEC;
5117impl crate::sealed::RegSpec for Addbldr_SPEC {
5118    type DataType = u16;
5119}
5120
5121#[doc = "A/D Data Duplexing Register"]
5122pub type Addbldr = crate::RegValueT<Addbldr_SPEC>;
5123
5124impl Addbldr {
5125    #[doc = "Converted Value 15 to 0"]
5126    #[inline(always)]
5127    pub fn addbldr(
5128        self,
5129    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addbldr_SPEC, crate::common::R>
5130    {
5131        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addbldr_SPEC,crate::common::R>::from_register(self,0)
5132    }
5133}
5134impl ::core::default::Default for Addbldr {
5135    #[inline(always)]
5136    fn default() -> Addbldr {
5137        <crate::RegValueT<Addbldr_SPEC> as RegisterValue<_>>::new(0)
5138    }
5139}
5140
5141#[doc(hidden)]
5142#[derive(Copy, Clone, Eq, PartialEq)]
5143pub struct Adtsdr_SPEC;
5144impl crate::sealed::RegSpec for Adtsdr_SPEC {
5145    type DataType = u16;
5146}
5147
5148#[doc = "A/D Temperature Sensor Data Register"]
5149pub type Adtsdr = crate::RegValueT<Adtsdr_SPEC>;
5150
5151impl Adtsdr {
5152    #[doc = "Converted Value 15 to 0"]
5153    #[inline(always)]
5154    pub fn adtsdr(
5155        self,
5156    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Adtsdr_SPEC, crate::common::R>
5157    {
5158        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Adtsdr_SPEC,crate::common::R>::from_register(self,0)
5159    }
5160}
5161impl ::core::default::Default for Adtsdr {
5162    #[inline(always)]
5163    fn default() -> Adtsdr {
5164        <crate::RegValueT<Adtsdr_SPEC> as RegisterValue<_>>::new(0)
5165    }
5166}
5167
5168#[doc(hidden)]
5169#[derive(Copy, Clone, Eq, PartialEq)]
5170pub struct Adocdr_SPEC;
5171impl crate::sealed::RegSpec for Adocdr_SPEC {
5172    type DataType = u16;
5173}
5174
5175#[doc = "A/D Internal Reference Voltage Data Register"]
5176pub type Adocdr = crate::RegValueT<Adocdr_SPEC>;
5177
5178impl Adocdr {
5179    #[doc = "Converted Value 15 to 0"]
5180    #[inline(always)]
5181    pub fn adocdr(
5182        self,
5183    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Adocdr_SPEC, crate::common::R>
5184    {
5185        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Adocdr_SPEC,crate::common::R>::from_register(self,0)
5186    }
5187}
5188impl ::core::default::Default for Adocdr {
5189    #[inline(always)]
5190    fn default() -> Adocdr {
5191        <crate::RegValueT<Adocdr_SPEC> as RegisterValue<_>>::new(0)
5192    }
5193}
5194
5195#[doc(hidden)]
5196#[derive(Copy, Clone, Eq, PartialEq)]
5197pub struct Adrd_SPEC;
5198impl crate::sealed::RegSpec for Adrd_SPEC {
5199    type DataType = u16;
5200}
5201
5202#[doc = "A/D Self-Diagnosis Data Register"]
5203pub type Adrd = crate::RegValueT<Adrd_SPEC>;
5204
5205impl Adrd {
5206    #[doc = "Converted Value 11 to 0"]
5207    #[inline(always)]
5208    pub fn ad(
5209        self,
5210    ) -> crate::common::RegisterField<0, 0xfff, 1, 0, u16, u16, Adrd_SPEC, crate::common::R> {
5211        crate::common::RegisterField::<0,0xfff,1,0,u16,u16,Adrd_SPEC,crate::common::R>::from_register(self,0)
5212    }
5213
5214    #[doc = "Self-Diagnosis Status"]
5215    #[inline(always)]
5216    pub fn diagst(
5217        self,
5218    ) -> crate::common::RegisterField<
5219        14,
5220        0x3,
5221        1,
5222        0,
5223        adrd::Diagst,
5224        adrd::Diagst,
5225        Adrd_SPEC,
5226        crate::common::R,
5227    > {
5228        crate::common::RegisterField::<
5229            14,
5230            0x3,
5231            1,
5232            0,
5233            adrd::Diagst,
5234            adrd::Diagst,
5235            Adrd_SPEC,
5236            crate::common::R,
5237        >::from_register(self, 0)
5238    }
5239}
5240impl ::core::default::Default for Adrd {
5241    #[inline(always)]
5242    fn default() -> Adrd {
5243        <crate::RegValueT<Adrd_SPEC> as RegisterValue<_>>::new(0)
5244    }
5245}
5246pub mod adrd {
5247
5248    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5249    pub struct Diagst_SPEC;
5250    pub type Diagst = crate::EnumBitfieldStruct<u8, Diagst_SPEC>;
5251    impl Diagst {
5252        #[doc = "Self-diagnosis not executed after power-on."]
5253        pub const _00: Self = Self::new(0);
5254
5255        #[doc = "Self-diagnosis was executed using the 0 V voltage."]
5256        pub const _01: Self = Self::new(1);
5257
5258        #[doc = "Self-diagnosis was executed using the reference voltage × 1/2."]
5259        pub const _10: Self = Self::new(2);
5260
5261        #[doc = "Self-diagnosis was executed using the reference voltage ."]
5262        pub const _11: Self = Self::new(3);
5263    }
5264}
5265#[doc(hidden)]
5266#[derive(Copy, Clone, Eq, PartialEq)]
5267pub struct Adctdr_SPEC;
5268impl crate::sealed::RegSpec for Adctdr_SPEC {
5269    type DataType = u16;
5270}
5271
5272#[doc = "A/D CTSU TSCAP Voltage Data Register"]
5273pub type Adctdr = crate::RegValueT<Adctdr_SPEC>;
5274
5275impl Adctdr {
5276    #[doc = "Converted Value 15 to 0"]
5277    #[inline(always)]
5278    pub fn adctdr(
5279        self,
5280    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Adctdr_SPEC, crate::common::R>
5281    {
5282        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Adctdr_SPEC,crate::common::R>::from_register(self,0)
5283    }
5284}
5285impl ::core::default::Default for Adctdr {
5286    #[inline(always)]
5287    fn default() -> Adctdr {
5288        <crate::RegValueT<Adctdr_SPEC> as RegisterValue<_>>::new(0)
5289    }
5290}
5291
5292#[doc(hidden)]
5293#[derive(Copy, Clone, Eq, PartialEq)]
5294pub struct Addr_SPEC;
5295impl crate::sealed::RegSpec for Addr_SPEC {
5296    type DataType = u16;
5297}
5298
5299#[doc = "A/D Data Registers %s"]
5300pub type Addr = crate::RegValueT<Addr_SPEC>;
5301
5302impl Addr {
5303    #[doc = "Converted Value 15 to 0"]
5304    #[inline(always)]
5305    pub fn addr(
5306        self,
5307    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addr_SPEC, crate::common::R> {
5308        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addr_SPEC,crate::common::R>::from_register(self,0)
5309    }
5310}
5311impl ::core::default::Default for Addr {
5312    #[inline(always)]
5313    fn default() -> Addr {
5314        <crate::RegValueT<Addr_SPEC> as RegisterValue<_>>::new(0)
5315    }
5316}
5317
5318#[doc(hidden)]
5319#[derive(Copy, Clone, Eq, PartialEq)]
5320pub struct Addiscr_SPEC;
5321impl crate::sealed::RegSpec for Addiscr_SPEC {
5322    type DataType = u8;
5323}
5324
5325#[doc = "A/D Disconnection Detection Control Register"]
5326pub type Addiscr = crate::RegValueT<Addiscr_SPEC>;
5327
5328impl Addiscr {
5329    #[doc = "Disconnection Detection Assist Setting"]
5330    #[inline(always)]
5331    pub fn adndis(
5332        self,
5333    ) -> crate::common::RegisterField<
5334        0,
5335        0xf,
5336        1,
5337        0,
5338        addiscr::Adndis,
5339        addiscr::Adndis,
5340        Addiscr_SPEC,
5341        crate::common::RW,
5342    > {
5343        crate::common::RegisterField::<
5344            0,
5345            0xf,
5346            1,
5347            0,
5348            addiscr::Adndis,
5349            addiscr::Adndis,
5350            Addiscr_SPEC,
5351            crate::common::RW,
5352        >::from_register(self, 0)
5353    }
5354
5355    #[doc = "Precharge/discharge select"]
5356    #[inline(always)]
5357    pub fn pchg(
5358        self,
5359    ) -> crate::common::RegisterField<
5360        4,
5361        0x1,
5362        1,
5363        0,
5364        addiscr::Pchg,
5365        addiscr::Pchg,
5366        Addiscr_SPEC,
5367        crate::common::RW,
5368    > {
5369        crate::common::RegisterField::<
5370            4,
5371            0x1,
5372            1,
5373            0,
5374            addiscr::Pchg,
5375            addiscr::Pchg,
5376            Addiscr_SPEC,
5377            crate::common::RW,
5378        >::from_register(self, 0)
5379    }
5380}
5381impl ::core::default::Default for Addiscr {
5382    #[inline(always)]
5383    fn default() -> Addiscr {
5384        <crate::RegValueT<Addiscr_SPEC> as RegisterValue<_>>::new(0)
5385    }
5386}
5387pub mod addiscr {
5388
5389    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5390    pub struct Adndis_SPEC;
5391    pub type Adndis = crate::EnumBitfieldStruct<u8, Adndis_SPEC>;
5392    impl Adndis {
5393        #[doc = "The disconnection detection assist function is disabled"]
5394        pub const _0_X_0: Self = Self::new(0);
5395
5396        #[doc = "Setting prohibited"]
5397        pub const _0_X_1: Self = Self::new(1);
5398    }
5399    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5400    pub struct Pchg_SPEC;
5401    pub type Pchg = crate::EnumBitfieldStruct<u8, Pchg_SPEC>;
5402    impl Pchg {
5403        #[doc = "Discharge"]
5404        pub const _0: Self = Self::new(0);
5405
5406        #[doc = "Precharge"]
5407        pub const _1: Self = Self::new(1);
5408    }
5409}
5410#[doc(hidden)]
5411#[derive(Copy, Clone, Eq, PartialEq)]
5412pub struct Adacsr_SPEC;
5413impl crate::sealed::RegSpec for Adacsr_SPEC {
5414    type DataType = u8;
5415}
5416
5417#[doc = "A/D Conversion Operation Mode Select Register"]
5418pub type Adacsr = crate::RegValueT<Adacsr_SPEC>;
5419
5420impl Adacsr {
5421    #[doc = "Successive Approximation Control Setting"]
5422    #[inline(always)]
5423    pub fn adsac(
5424        self,
5425    ) -> crate::common::RegisterField<
5426        1,
5427        0x1,
5428        1,
5429        0,
5430        adacsr::Adsac,
5431        adacsr::Adsac,
5432        Adacsr_SPEC,
5433        crate::common::RW,
5434    > {
5435        crate::common::RegisterField::<
5436            1,
5437            0x1,
5438            1,
5439            0,
5440            adacsr::Adsac,
5441            adacsr::Adsac,
5442            Adacsr_SPEC,
5443            crate::common::RW,
5444        >::from_register(self, 0)
5445    }
5446}
5447impl ::core::default::Default for Adacsr {
5448    #[inline(always)]
5449    fn default() -> Adacsr {
5450        <crate::RegValueT<Adacsr_SPEC> as RegisterValue<_>>::new(0)
5451    }
5452}
5453pub mod adacsr {
5454
5455    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5456    pub struct Adsac_SPEC;
5457    pub type Adsac = crate::EnumBitfieldStruct<u8, Adsac_SPEC>;
5458    impl Adsac {
5459        #[doc = "Normal conversion mode (default)"]
5460        pub const _0: Self = Self::new(0);
5461
5462        #[doc = "Fast conversion mode"]
5463        pub const _1: Self = Self::new(1);
5464    }
5465}
5466#[doc(hidden)]
5467#[derive(Copy, Clone, Eq, PartialEq)]
5468pub struct Adgspcr_SPEC;
5469impl crate::sealed::RegSpec for Adgspcr_SPEC {
5470    type DataType = u16;
5471}
5472
5473#[doc = "A/D Group Scan Priority Control Register"]
5474pub type Adgspcr = crate::RegValueT<Adgspcr_SPEC>;
5475
5476impl Adgspcr {
5477    #[doc = "Group Priority Operation Setting"]
5478    #[inline(always)]
5479    pub fn pgs(
5480        self,
5481    ) -> crate::common::RegisterField<
5482        0,
5483        0x1,
5484        1,
5485        0,
5486        adgspcr::Pgs,
5487        adgspcr::Pgs,
5488        Adgspcr_SPEC,
5489        crate::common::RW,
5490    > {
5491        crate::common::RegisterField::<
5492            0,
5493            0x1,
5494            1,
5495            0,
5496            adgspcr::Pgs,
5497            adgspcr::Pgs,
5498            Adgspcr_SPEC,
5499            crate::common::RW,
5500        >::from_register(self, 0)
5501    }
5502
5503    #[doc = "Lower-Priority Group Restart Setting"]
5504    #[inline(always)]
5505    pub fn gbrscn(
5506        self,
5507    ) -> crate::common::RegisterField<
5508        1,
5509        0x1,
5510        1,
5511        0,
5512        adgspcr::Gbrscn,
5513        adgspcr::Gbrscn,
5514        Adgspcr_SPEC,
5515        crate::common::RW,
5516    > {
5517        crate::common::RegisterField::<
5518            1,
5519            0x1,
5520            1,
5521            0,
5522            adgspcr::Gbrscn,
5523            adgspcr::Gbrscn,
5524            Adgspcr_SPEC,
5525            crate::common::RW,
5526        >::from_register(self, 0)
5527    }
5528
5529    #[doc = "Single Scan Continuous Start"]
5530    #[inline(always)]
5531    pub fn gbrp(
5532        self,
5533    ) -> crate::common::RegisterField<
5534        15,
5535        0x1,
5536        1,
5537        0,
5538        adgspcr::Gbrp,
5539        adgspcr::Gbrp,
5540        Adgspcr_SPEC,
5541        crate::common::RW,
5542    > {
5543        crate::common::RegisterField::<
5544            15,
5545            0x1,
5546            1,
5547            0,
5548            adgspcr::Gbrp,
5549            adgspcr::Gbrp,
5550            Adgspcr_SPEC,
5551            crate::common::RW,
5552        >::from_register(self, 0)
5553    }
5554}
5555impl ::core::default::Default for Adgspcr {
5556    #[inline(always)]
5557    fn default() -> Adgspcr {
5558        <crate::RegValueT<Adgspcr_SPEC> as RegisterValue<_>>::new(0)
5559    }
5560}
5561pub mod adgspcr {
5562
5563    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5564    pub struct Pgs_SPEC;
5565    pub type Pgs = crate::EnumBitfieldStruct<u8, Pgs_SPEC>;
5566    impl Pgs {
5567        #[doc = "Operate without group priority control."]
5568        pub const _0: Self = Self::new(0);
5569
5570        #[doc = "Operate with group priority control."]
5571        pub const _1: Self = Self::new(1);
5572    }
5573    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5574    pub struct Gbrscn_SPEC;
5575    pub type Gbrscn = crate::EnumBitfieldStruct<u8, Gbrscn_SPEC>;
5576    impl Gbrscn {
5577        #[doc = "Disable rescanning of the group that was stopped in group priority operation"]
5578        pub const _0: Self = Self::new(0);
5579
5580        #[doc = "Enable rescanning of the group that was stopped in group priority operation."]
5581        pub const _1: Self = Self::new(1);
5582    }
5583    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5584    pub struct Gbrp_SPEC;
5585    pub type Gbrp = crate::EnumBitfieldStruct<u8, Gbrp_SPEC>;
5586    impl Gbrp {
5587        #[doc = "Single scan is not continuously activated."]
5588        pub const _0: Self = Self::new(0);
5589
5590        #[doc = "Single scan for the group with the lower-priority is continuously activated."]
5591        pub const _1: Self = Self::new(1);
5592    }
5593}
5594#[doc(hidden)]
5595#[derive(Copy, Clone, Eq, PartialEq)]
5596pub struct Addbldra_SPEC;
5597impl crate::sealed::RegSpec for Addbldra_SPEC {
5598    type DataType = u16;
5599}
5600
5601#[doc = "A/D Data Duplexing Register A"]
5602pub type Addbldra = crate::RegValueT<Addbldra_SPEC>;
5603
5604impl Addbldra {
5605    #[doc = "Converted Value 15 to 0"]
5606    #[inline(always)]
5607    pub fn addbldr(
5608        self,
5609    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addbldra_SPEC, crate::common::R>
5610    {
5611        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addbldra_SPEC,crate::common::R>::from_register(self,0)
5612    }
5613}
5614impl ::core::default::Default for Addbldra {
5615    #[inline(always)]
5616    fn default() -> Addbldra {
5617        <crate::RegValueT<Addbldra_SPEC> as RegisterValue<_>>::new(0)
5618    }
5619}
5620
5621#[doc(hidden)]
5622#[derive(Copy, Clone, Eq, PartialEq)]
5623pub struct Addbldrb_SPEC;
5624impl crate::sealed::RegSpec for Addbldrb_SPEC {
5625    type DataType = u16;
5626}
5627
5628#[doc = "A/D Data Duplexing Register B"]
5629pub type Addbldrb = crate::RegValueT<Addbldrb_SPEC>;
5630
5631impl Addbldrb {
5632    #[doc = "Converted Value 15 to 0"]
5633    #[inline(always)]
5634    pub fn addbldr(
5635        self,
5636    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addbldrb_SPEC, crate::common::R>
5637    {
5638        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addbldrb_SPEC,crate::common::R>::from_register(self,0)
5639    }
5640}
5641impl ::core::default::Default for Addbldrb {
5642    #[inline(always)]
5643    fn default() -> Addbldrb {
5644        <crate::RegValueT<Addbldrb_SPEC> as RegisterValue<_>>::new(0)
5645    }
5646}
5647
5648#[doc(hidden)]
5649#[derive(Copy, Clone, Eq, PartialEq)]
5650pub struct Adhvrefcnt_SPEC;
5651impl crate::sealed::RegSpec for Adhvrefcnt_SPEC {
5652    type DataType = u8;
5653}
5654
5655#[doc = "A/D High-Potential/Low-Potential Reference Voltage Control Register"]
5656pub type Adhvrefcnt = crate::RegValueT<Adhvrefcnt_SPEC>;
5657
5658impl Adhvrefcnt {
5659    #[doc = "High-Potential Reference Voltage Select"]
5660    #[inline(always)]
5661    pub fn hvsel(
5662        self,
5663    ) -> crate::common::RegisterField<
5664        0,
5665        0x3,
5666        1,
5667        0,
5668        adhvrefcnt::Hvsel,
5669        adhvrefcnt::Hvsel,
5670        Adhvrefcnt_SPEC,
5671        crate::common::RW,
5672    > {
5673        crate::common::RegisterField::<
5674            0,
5675            0x3,
5676            1,
5677            0,
5678            adhvrefcnt::Hvsel,
5679            adhvrefcnt::Hvsel,
5680            Adhvrefcnt_SPEC,
5681            crate::common::RW,
5682        >::from_register(self, 0)
5683    }
5684
5685    #[doc = "Low-Potential Reference Voltage Select"]
5686    #[inline(always)]
5687    pub fn lvsel(
5688        self,
5689    ) -> crate::common::RegisterField<
5690        4,
5691        0x1,
5692        1,
5693        0,
5694        adhvrefcnt::Lvsel,
5695        adhvrefcnt::Lvsel,
5696        Adhvrefcnt_SPEC,
5697        crate::common::RW,
5698    > {
5699        crate::common::RegisterField::<
5700            4,
5701            0x1,
5702            1,
5703            0,
5704            adhvrefcnt::Lvsel,
5705            adhvrefcnt::Lvsel,
5706            Adhvrefcnt_SPEC,
5707            crate::common::RW,
5708        >::from_register(self, 0)
5709    }
5710
5711    #[doc = "Sleep"]
5712    #[inline(always)]
5713    pub fn adslp(
5714        self,
5715    ) -> crate::common::RegisterField<
5716        7,
5717        0x1,
5718        1,
5719        0,
5720        adhvrefcnt::Adslp,
5721        adhvrefcnt::Adslp,
5722        Adhvrefcnt_SPEC,
5723        crate::common::RW,
5724    > {
5725        crate::common::RegisterField::<
5726            7,
5727            0x1,
5728            1,
5729            0,
5730            adhvrefcnt::Adslp,
5731            adhvrefcnt::Adslp,
5732            Adhvrefcnt_SPEC,
5733            crate::common::RW,
5734        >::from_register(self, 0)
5735    }
5736}
5737impl ::core::default::Default for Adhvrefcnt {
5738    #[inline(always)]
5739    fn default() -> Adhvrefcnt {
5740        <crate::RegValueT<Adhvrefcnt_SPEC> as RegisterValue<_>>::new(0)
5741    }
5742}
5743pub mod adhvrefcnt {
5744
5745    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5746    pub struct Hvsel_SPEC;
5747    pub type Hvsel = crate::EnumBitfieldStruct<u8, Hvsel_SPEC>;
5748    impl Hvsel {
5749        #[doc = "AVCC0 is selected as the high-potential reference voltage"]
5750        pub const _00: Self = Self::new(0);
5751
5752        #[doc = "VREFH0 is selected as the high-potential reference voltage"]
5753        pub const _01: Self = Self::new(1);
5754
5755        #[doc = "Internal reference voltage is selected as the high-potential reference voltage"]
5756        pub const _10: Self = Self::new(2);
5757
5758        #[doc = "No reference voltage pin is selected (internal node discharge)"]
5759        pub const _11: Self = Self::new(3);
5760    }
5761    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5762    pub struct Lvsel_SPEC;
5763    pub type Lvsel = crate::EnumBitfieldStruct<u8, Lvsel_SPEC>;
5764    impl Lvsel {
5765        #[doc = "AVSS0 is selected as the low-potential reference voltage."]
5766        pub const _0: Self = Self::new(0);
5767
5768        #[doc = "VREFL0 is selected as the low-potential reference voltage."]
5769        pub const _1: Self = Self::new(1);
5770    }
5771    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5772    pub struct Adslp_SPEC;
5773    pub type Adslp = crate::EnumBitfieldStruct<u8, Adslp_SPEC>;
5774    impl Adslp {
5775        #[doc = "Normal operation"]
5776        pub const _0: Self = Self::new(0);
5777
5778        #[doc = "Standby state"]
5779        pub const _1: Self = Self::new(1);
5780    }
5781}
5782#[doc(hidden)]
5783#[derive(Copy, Clone, Eq, PartialEq)]
5784pub struct Adwinmon_SPEC;
5785impl crate::sealed::RegSpec for Adwinmon_SPEC {
5786    type DataType = u8;
5787}
5788
5789#[doc = "A/D Compare Function Window A/B Status Monitor Register"]
5790pub type Adwinmon = crate::RegValueT<Adwinmon_SPEC>;
5791
5792impl Adwinmon {
5793    #[doc = "Combination Result Monitor"]
5794    #[inline(always)]
5795    pub fn moncomb(
5796        self,
5797    ) -> crate::common::RegisterField<
5798        0,
5799        0x1,
5800        1,
5801        0,
5802        adwinmon::Moncomb,
5803        adwinmon::Moncomb,
5804        Adwinmon_SPEC,
5805        crate::common::R,
5806    > {
5807        crate::common::RegisterField::<
5808            0,
5809            0x1,
5810            1,
5811            0,
5812            adwinmon::Moncomb,
5813            adwinmon::Moncomb,
5814            Adwinmon_SPEC,
5815            crate::common::R,
5816        >::from_register(self, 0)
5817    }
5818
5819    #[doc = "Comparison Result Monitor A"]
5820    #[inline(always)]
5821    pub fn moncmpa(
5822        self,
5823    ) -> crate::common::RegisterField<
5824        4,
5825        0x1,
5826        1,
5827        0,
5828        adwinmon::Moncmpa,
5829        adwinmon::Moncmpa,
5830        Adwinmon_SPEC,
5831        crate::common::R,
5832    > {
5833        crate::common::RegisterField::<
5834            4,
5835            0x1,
5836            1,
5837            0,
5838            adwinmon::Moncmpa,
5839            adwinmon::Moncmpa,
5840            Adwinmon_SPEC,
5841            crate::common::R,
5842        >::from_register(self, 0)
5843    }
5844
5845    #[doc = "Comparison Result Monitor B"]
5846    #[inline(always)]
5847    pub fn moncmpb(
5848        self,
5849    ) -> crate::common::RegisterField<
5850        5,
5851        0x1,
5852        1,
5853        0,
5854        adwinmon::Moncmpb,
5855        adwinmon::Moncmpb,
5856        Adwinmon_SPEC,
5857        crate::common::R,
5858    > {
5859        crate::common::RegisterField::<
5860            5,
5861            0x1,
5862            1,
5863            0,
5864            adwinmon::Moncmpb,
5865            adwinmon::Moncmpb,
5866            Adwinmon_SPEC,
5867            crate::common::R,
5868        >::from_register(self, 0)
5869    }
5870}
5871impl ::core::default::Default for Adwinmon {
5872    #[inline(always)]
5873    fn default() -> Adwinmon {
5874        <crate::RegValueT<Adwinmon_SPEC> as RegisterValue<_>>::new(0)
5875    }
5876}
5877pub mod adwinmon {
5878
5879    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5880    pub struct Moncomb_SPEC;
5881    pub type Moncomb = crate::EnumBitfieldStruct<u8, Moncomb_SPEC>;
5882    impl Moncomb {
5883        #[doc = "Window A/B composite conditions are not met."]
5884        pub const _0: Self = Self::new(0);
5885
5886        #[doc = "Window A/B composite conditions are met."]
5887        pub const _1: Self = Self::new(1);
5888    }
5889    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5890    pub struct Moncmpa_SPEC;
5891    pub type Moncmpa = crate::EnumBitfieldStruct<u8, Moncmpa_SPEC>;
5892    impl Moncmpa {
5893        #[doc = "Window A comparison conditions are not met."]
5894        pub const _0: Self = Self::new(0);
5895
5896        #[doc = "Window A comparison conditions are met."]
5897        pub const _1: Self = Self::new(1);
5898    }
5899    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5900    pub struct Moncmpb_SPEC;
5901    pub type Moncmpb = crate::EnumBitfieldStruct<u8, Moncmpb_SPEC>;
5902    impl Moncmpb {
5903        #[doc = "Window B comparison conditions are not met."]
5904        pub const _0: Self = Self::new(0);
5905
5906        #[doc = "Window B comparison conditions are met."]
5907        pub const _1: Self = Self::new(1);
5908    }
5909}
5910#[doc(hidden)]
5911#[derive(Copy, Clone, Eq, PartialEq)]
5912pub struct Adcmpcr_SPEC;
5913impl crate::sealed::RegSpec for Adcmpcr_SPEC {
5914    type DataType = u16;
5915}
5916
5917#[doc = "A/D Compare Function Control Register"]
5918pub type Adcmpcr = crate::RegValueT<Adcmpcr_SPEC>;
5919
5920impl Adcmpcr {
5921    #[doc = "Window A/B Composite Conditions Setting"]
5922    #[inline(always)]
5923    pub fn cmpab(
5924        self,
5925    ) -> crate::common::RegisterField<
5926        0,
5927        0x3,
5928        1,
5929        0,
5930        adcmpcr::Cmpab,
5931        adcmpcr::Cmpab,
5932        Adcmpcr_SPEC,
5933        crate::common::RW,
5934    > {
5935        crate::common::RegisterField::<
5936            0,
5937            0x3,
5938            1,
5939            0,
5940            adcmpcr::Cmpab,
5941            adcmpcr::Cmpab,
5942            Adcmpcr_SPEC,
5943            crate::common::RW,
5944        >::from_register(self, 0)
5945    }
5946
5947    #[doc = "Compare Window B Operation Enable"]
5948    #[inline(always)]
5949    pub fn cmpbe(
5950        self,
5951    ) -> crate::common::RegisterField<
5952        9,
5953        0x1,
5954        1,
5955        0,
5956        adcmpcr::Cmpbe,
5957        adcmpcr::Cmpbe,
5958        Adcmpcr_SPEC,
5959        crate::common::RW,
5960    > {
5961        crate::common::RegisterField::<
5962            9,
5963            0x1,
5964            1,
5965            0,
5966            adcmpcr::Cmpbe,
5967            adcmpcr::Cmpbe,
5968            Adcmpcr_SPEC,
5969            crate::common::RW,
5970        >::from_register(self, 0)
5971    }
5972
5973    #[doc = "Compare Window A Operation Enable"]
5974    #[inline(always)]
5975    pub fn cmpae(
5976        self,
5977    ) -> crate::common::RegisterField<
5978        11,
5979        0x1,
5980        1,
5981        0,
5982        adcmpcr::Cmpae,
5983        adcmpcr::Cmpae,
5984        Adcmpcr_SPEC,
5985        crate::common::RW,
5986    > {
5987        crate::common::RegisterField::<
5988            11,
5989            0x1,
5990            1,
5991            0,
5992            adcmpcr::Cmpae,
5993            adcmpcr::Cmpae,
5994            Adcmpcr_SPEC,
5995            crate::common::RW,
5996        >::from_register(self, 0)
5997    }
5998
5999    #[doc = "Compare B Interrupt Enable"]
6000    #[inline(always)]
6001    pub fn cmpbie(
6002        self,
6003    ) -> crate::common::RegisterField<
6004        13,
6005        0x1,
6006        1,
6007        0,
6008        adcmpcr::Cmpbie,
6009        adcmpcr::Cmpbie,
6010        Adcmpcr_SPEC,
6011        crate::common::RW,
6012    > {
6013        crate::common::RegisterField::<
6014            13,
6015            0x1,
6016            1,
6017            0,
6018            adcmpcr::Cmpbie,
6019            adcmpcr::Cmpbie,
6020            Adcmpcr_SPEC,
6021            crate::common::RW,
6022        >::from_register(self, 0)
6023    }
6024
6025    #[doc = "Window Function Setting"]
6026    #[inline(always)]
6027    pub fn wcmpe(
6028        self,
6029    ) -> crate::common::RegisterField<
6030        14,
6031        0x1,
6032        1,
6033        0,
6034        adcmpcr::Wcmpe,
6035        adcmpcr::Wcmpe,
6036        Adcmpcr_SPEC,
6037        crate::common::RW,
6038    > {
6039        crate::common::RegisterField::<
6040            14,
6041            0x1,
6042            1,
6043            0,
6044            adcmpcr::Wcmpe,
6045            adcmpcr::Wcmpe,
6046            Adcmpcr_SPEC,
6047            crate::common::RW,
6048        >::from_register(self, 0)
6049    }
6050
6051    #[doc = "Compare A Interrupt Enable"]
6052    #[inline(always)]
6053    pub fn cmpaie(
6054        self,
6055    ) -> crate::common::RegisterField<
6056        15,
6057        0x1,
6058        1,
6059        0,
6060        adcmpcr::Cmpaie,
6061        adcmpcr::Cmpaie,
6062        Adcmpcr_SPEC,
6063        crate::common::RW,
6064    > {
6065        crate::common::RegisterField::<
6066            15,
6067            0x1,
6068            1,
6069            0,
6070            adcmpcr::Cmpaie,
6071            adcmpcr::Cmpaie,
6072            Adcmpcr_SPEC,
6073            crate::common::RW,
6074        >::from_register(self, 0)
6075    }
6076}
6077impl ::core::default::Default for Adcmpcr {
6078    #[inline(always)]
6079    fn default() -> Adcmpcr {
6080        <crate::RegValueT<Adcmpcr_SPEC> as RegisterValue<_>>::new(0)
6081    }
6082}
6083pub mod adcmpcr {
6084
6085    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6086    pub struct Cmpab_SPEC;
6087    pub type Cmpab = crate::EnumBitfieldStruct<u8, Cmpab_SPEC>;
6088    impl Cmpab {
6089        #[doc = "Output ADC120_WCMPM when window A OR window B comparison conditions are met. Otherwise, output ADC120_WCMPUM."]
6090        pub const _00: Self = Self::new(0);
6091
6092        #[doc = "Output ADC120_WCMPM when window A EXOR window B comparison conditions are met. Otherwise, output ADC120_WCMPUM."]
6093        pub const _01: Self = Self::new(1);
6094
6095        #[doc = "Output ADC120_WCMPM when window A AND window B comparison conditions are met. Otherwise, output ADC120_WCMPUM."]
6096        pub const _10: Self = Self::new(2);
6097
6098        #[doc = "Setting prohibited."]
6099        pub const _11: Self = Self::new(3);
6100    }
6101    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6102    pub struct Cmpbe_SPEC;
6103    pub type Cmpbe = crate::EnumBitfieldStruct<u8, Cmpbe_SPEC>;
6104    impl Cmpbe {
6105        #[doc = "Disable compare window B operation. Disable ADC120_WCMPM and ADC120_WCMPUM outputs."]
6106        pub const _0: Self = Self::new(0);
6107
6108        #[doc = "Enable compare window B operation."]
6109        pub const _1: Self = Self::new(1);
6110    }
6111    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6112    pub struct Cmpae_SPEC;
6113    pub type Cmpae = crate::EnumBitfieldStruct<u8, Cmpae_SPEC>;
6114    impl Cmpae {
6115        #[doc = "Disable compare window A operation. Disable ADC120_WCMPM and ADC120_WCMPUM outputs."]
6116        pub const _0: Self = Self::new(0);
6117
6118        #[doc = "Enable compare window A operation."]
6119        pub const _1: Self = Self::new(1);
6120    }
6121    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6122    pub struct Cmpbie_SPEC;
6123    pub type Cmpbie = crate::EnumBitfieldStruct<u8, Cmpbie_SPEC>;
6124    impl Cmpbie {
6125        #[doc = "Disable ADC120_CMPBI interrupt when comparison conditions (window B) are met."]
6126        pub const _0: Self = Self::new(0);
6127
6128        #[doc = "Enable ADC120_CMPBI interrupt when comparison conditions (window B) are met."]
6129        pub const _1: Self = Self::new(1);
6130    }
6131    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6132    pub struct Wcmpe_SPEC;
6133    pub type Wcmpe = crate::EnumBitfieldStruct<u8, Wcmpe_SPEC>;
6134    impl Wcmpe {
6135        #[doc = "Disable window function Window A and window B operate as a comparator to compare the single value on the lower side with the A/D conversion result."]
6136        pub const _0: Self = Self::new(0);
6137
6138        #[doc = "Enable window function Window A and window B operate as a comparator to compare the two values on the upper and lower sides with the A/D conversion result."]
6139        pub const _1: Self = Self::new(1);
6140    }
6141    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6142    pub struct Cmpaie_SPEC;
6143    pub type Cmpaie = crate::EnumBitfieldStruct<u8, Cmpaie_SPEC>;
6144    impl Cmpaie {
6145        #[doc = "Disable ADC120_CMPAI interrupt when comparison conditions (window A) are met."]
6146        pub const _0: Self = Self::new(0);
6147
6148        #[doc = "Enable ADC120_CMPAI interrupt when comparison conditions (window A) are met."]
6149        pub const _1: Self = Self::new(1);
6150    }
6151}
6152#[doc(hidden)]
6153#[derive(Copy, Clone, Eq, PartialEq)]
6154pub struct Adcmpanser_SPEC;
6155impl crate::sealed::RegSpec for Adcmpanser_SPEC {
6156    type DataType = u8;
6157}
6158
6159#[doc = "A/D Compare Function Window A Extended Input Select Register"]
6160pub type Adcmpanser = crate::RegValueT<Adcmpanser_SPEC>;
6161
6162impl Adcmpanser {
6163    #[doc = "Temperature Sensor Output Compare Select"]
6164    #[inline(always)]
6165    pub fn cmptsa(
6166        self,
6167    ) -> crate::common::RegisterField<
6168        0,
6169        0x1,
6170        1,
6171        0,
6172        adcmpanser::Cmptsa,
6173        adcmpanser::Cmptsa,
6174        Adcmpanser_SPEC,
6175        crate::common::RW,
6176    > {
6177        crate::common::RegisterField::<
6178            0,
6179            0x1,
6180            1,
6181            0,
6182            adcmpanser::Cmptsa,
6183            adcmpanser::Cmptsa,
6184            Adcmpanser_SPEC,
6185            crate::common::RW,
6186        >::from_register(self, 0)
6187    }
6188
6189    #[doc = "Internal Reference Voltage Compare Select"]
6190    #[inline(always)]
6191    pub fn cmpoca(
6192        self,
6193    ) -> crate::common::RegisterField<
6194        1,
6195        0x1,
6196        1,
6197        0,
6198        adcmpanser::Cmpoca,
6199        adcmpanser::Cmpoca,
6200        Adcmpanser_SPEC,
6201        crate::common::RW,
6202    > {
6203        crate::common::RegisterField::<
6204            1,
6205            0x1,
6206            1,
6207            0,
6208            adcmpanser::Cmpoca,
6209            adcmpanser::Cmpoca,
6210            Adcmpanser_SPEC,
6211            crate::common::RW,
6212        >::from_register(self, 0)
6213    }
6214}
6215impl ::core::default::Default for Adcmpanser {
6216    #[inline(always)]
6217    fn default() -> Adcmpanser {
6218        <crate::RegValueT<Adcmpanser_SPEC> as RegisterValue<_>>::new(0)
6219    }
6220}
6221pub mod adcmpanser {
6222
6223    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6224    pub struct Cmptsa_SPEC;
6225    pub type Cmptsa = crate::EnumBitfieldStruct<u8, Cmptsa_SPEC>;
6226    impl Cmptsa {
6227        #[doc = "Exclude the temperature sensor output from the compare Window A target range."]
6228        pub const _0: Self = Self::new(0);
6229
6230        #[doc = "Include the temperature sensor output in the compare Window A target range."]
6231        pub const _1: Self = Self::new(1);
6232    }
6233    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6234    pub struct Cmpoca_SPEC;
6235    pub type Cmpoca = crate::EnumBitfieldStruct<u8, Cmpoca_SPEC>;
6236    impl Cmpoca {
6237        #[doc = "Exclude the internal reference voltage from the compare Window A target range."]
6238        pub const _0: Self = Self::new(0);
6239
6240        #[doc = "Include the internal reference voltage in the compare Window A target range."]
6241        pub const _1: Self = Self::new(1);
6242    }
6243}
6244#[doc(hidden)]
6245#[derive(Copy, Clone, Eq, PartialEq)]
6246pub struct Adcmpler_SPEC;
6247impl crate::sealed::RegSpec for Adcmpler_SPEC {
6248    type DataType = u8;
6249}
6250
6251#[doc = "A/D Compare Function Window A Extended Input Comparison Condition Setting Register"]
6252pub type Adcmpler = crate::RegValueT<Adcmpler_SPEC>;
6253
6254impl Adcmpler {
6255    #[doc = "Compare Window A Temperature Sensor Output Comparison Condition Select"]
6256    #[inline(always)]
6257    pub fn cmpltsa(
6258        self,
6259    ) -> crate::common::RegisterField<
6260        0,
6261        0x1,
6262        1,
6263        0,
6264        adcmpler::Cmpltsa,
6265        adcmpler::Cmpltsa,
6266        Adcmpler_SPEC,
6267        crate::common::RW,
6268    > {
6269        crate::common::RegisterField::<
6270            0,
6271            0x1,
6272            1,
6273            0,
6274            adcmpler::Cmpltsa,
6275            adcmpler::Cmpltsa,
6276            Adcmpler_SPEC,
6277            crate::common::RW,
6278        >::from_register(self, 0)
6279    }
6280
6281    #[doc = "Compare Window A Internal Reference Voltage Comparison Condition Select"]
6282    #[inline(always)]
6283    pub fn cmploca(
6284        self,
6285    ) -> crate::common::RegisterField<
6286        1,
6287        0x1,
6288        1,
6289        0,
6290        adcmpler::Cmploca,
6291        adcmpler::Cmploca,
6292        Adcmpler_SPEC,
6293        crate::common::RW,
6294    > {
6295        crate::common::RegisterField::<
6296            1,
6297            0x1,
6298            1,
6299            0,
6300            adcmpler::Cmploca,
6301            adcmpler::Cmploca,
6302            Adcmpler_SPEC,
6303            crate::common::RW,
6304        >::from_register(self, 0)
6305    }
6306}
6307impl ::core::default::Default for Adcmpler {
6308    #[inline(always)]
6309    fn default() -> Adcmpler {
6310        <crate::RegValueT<Adcmpler_SPEC> as RegisterValue<_>>::new(0)
6311    }
6312}
6313pub mod adcmpler {
6314
6315    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6316    pub struct Cmpltsa_SPEC;
6317    pub type Cmpltsa = crate::EnumBitfieldStruct<u8, Cmpltsa_SPEC>;
6318    impl Cmpltsa {
6319        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0) : ADCMPDR0 value > A/D-converted valueCompare Window A Temperature Sensor Output Comparison Condition Select When window function is enabled (ADCMPCR.WCMPE = 1) : Compare Window A Temperature Sensor Output Comparison ConditionA/D-converted value < ADCMPDR0 value, or A/D-converted value > ADCMPDR1 value"]
6320        pub const _0: Self = Self::new(0);
6321
6322        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0) : ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1) : ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
6323        pub const _1: Self = Self::new(1);
6324    }
6325    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6326    pub struct Cmploca_SPEC;
6327    pub type Cmploca = crate::EnumBitfieldStruct<u8, Cmploca_SPEC>;
6328    impl Cmploca {
6329        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0) : ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or A/D-converted value > ADCMPDR1 value"]
6330        pub const _0: Self = Self::new(0);
6331
6332        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
6333        pub const _1: Self = Self::new(1);
6334    }
6335}
6336#[doc(hidden)]
6337#[derive(Copy, Clone, Eq, PartialEq)]
6338pub struct Adcmpansr0_SPEC;
6339impl crate::sealed::RegSpec for Adcmpansr0_SPEC {
6340    type DataType = u16;
6341}
6342
6343#[doc = "A/D Compare Function Window A Channel Select Register 0"]
6344pub type Adcmpansr0 = crate::RegValueT<Adcmpansr0_SPEC>;
6345
6346impl Adcmpansr0 {
6347    #[doc = "Compare Window A Channel Select"]
6348    #[inline(always)]
6349    pub fn cmpcha00(
6350        self,
6351    ) -> crate::common::RegisterField<
6352        0,
6353        0x1,
6354        1,
6355        0,
6356        adcmpansr0::Cmpcha00,
6357        adcmpansr0::Cmpcha00,
6358        Adcmpansr0_SPEC,
6359        crate::common::RW,
6360    > {
6361        crate::common::RegisterField::<
6362            0,
6363            0x1,
6364            1,
6365            0,
6366            adcmpansr0::Cmpcha00,
6367            adcmpansr0::Cmpcha00,
6368            Adcmpansr0_SPEC,
6369            crate::common::RW,
6370        >::from_register(self, 0)
6371    }
6372
6373    #[doc = "Compare Window A Channel Select"]
6374    #[inline(always)]
6375    pub fn cmpcha01(
6376        self,
6377    ) -> crate::common::RegisterField<
6378        1,
6379        0x1,
6380        1,
6381        0,
6382        adcmpansr0::Cmpcha01,
6383        adcmpansr0::Cmpcha01,
6384        Adcmpansr0_SPEC,
6385        crate::common::RW,
6386    > {
6387        crate::common::RegisterField::<
6388            1,
6389            0x1,
6390            1,
6391            0,
6392            adcmpansr0::Cmpcha01,
6393            adcmpansr0::Cmpcha01,
6394            Adcmpansr0_SPEC,
6395            crate::common::RW,
6396        >::from_register(self, 0)
6397    }
6398
6399    #[doc = "Compare Window A Channel Select"]
6400    #[inline(always)]
6401    pub fn cmpcha02(
6402        self,
6403    ) -> crate::common::RegisterField<
6404        2,
6405        0x1,
6406        1,
6407        0,
6408        adcmpansr0::Cmpcha02,
6409        adcmpansr0::Cmpcha02,
6410        Adcmpansr0_SPEC,
6411        crate::common::RW,
6412    > {
6413        crate::common::RegisterField::<
6414            2,
6415            0x1,
6416            1,
6417            0,
6418            adcmpansr0::Cmpcha02,
6419            adcmpansr0::Cmpcha02,
6420            Adcmpansr0_SPEC,
6421            crate::common::RW,
6422        >::from_register(self, 0)
6423    }
6424
6425    #[doc = "Compare Window A Channel Select"]
6426    #[inline(always)]
6427    pub fn cmpcha03(
6428        self,
6429    ) -> crate::common::RegisterField<
6430        3,
6431        0x1,
6432        1,
6433        0,
6434        adcmpansr0::Cmpcha03,
6435        adcmpansr0::Cmpcha03,
6436        Adcmpansr0_SPEC,
6437        crate::common::RW,
6438    > {
6439        crate::common::RegisterField::<
6440            3,
6441            0x1,
6442            1,
6443            0,
6444            adcmpansr0::Cmpcha03,
6445            adcmpansr0::Cmpcha03,
6446            Adcmpansr0_SPEC,
6447            crate::common::RW,
6448        >::from_register(self, 0)
6449    }
6450
6451    #[doc = "Compare Window A Channel Select"]
6452    #[inline(always)]
6453    pub fn cmpcha04(
6454        self,
6455    ) -> crate::common::RegisterField<
6456        4,
6457        0x1,
6458        1,
6459        0,
6460        adcmpansr0::Cmpcha04,
6461        adcmpansr0::Cmpcha04,
6462        Adcmpansr0_SPEC,
6463        crate::common::RW,
6464    > {
6465        crate::common::RegisterField::<
6466            4,
6467            0x1,
6468            1,
6469            0,
6470            adcmpansr0::Cmpcha04,
6471            adcmpansr0::Cmpcha04,
6472            Adcmpansr0_SPEC,
6473            crate::common::RW,
6474        >::from_register(self, 0)
6475    }
6476
6477    #[doc = "Compare Window A Channel Select"]
6478    #[inline(always)]
6479    pub fn cmpcha05(
6480        self,
6481    ) -> crate::common::RegisterField<
6482        5,
6483        0x1,
6484        1,
6485        0,
6486        adcmpansr0::Cmpcha05,
6487        adcmpansr0::Cmpcha05,
6488        Adcmpansr0_SPEC,
6489        crate::common::RW,
6490    > {
6491        crate::common::RegisterField::<
6492            5,
6493            0x1,
6494            1,
6495            0,
6496            adcmpansr0::Cmpcha05,
6497            adcmpansr0::Cmpcha05,
6498            Adcmpansr0_SPEC,
6499            crate::common::RW,
6500        >::from_register(self, 0)
6501    }
6502
6503    #[doc = "Compare Window A Channel Select"]
6504    #[inline(always)]
6505    pub fn cmpcha06(
6506        self,
6507    ) -> crate::common::RegisterField<
6508        6,
6509        0x1,
6510        1,
6511        0,
6512        adcmpansr0::Cmpcha06,
6513        adcmpansr0::Cmpcha06,
6514        Adcmpansr0_SPEC,
6515        crate::common::RW,
6516    > {
6517        crate::common::RegisterField::<
6518            6,
6519            0x1,
6520            1,
6521            0,
6522            adcmpansr0::Cmpcha06,
6523            adcmpansr0::Cmpcha06,
6524            Adcmpansr0_SPEC,
6525            crate::common::RW,
6526        >::from_register(self, 0)
6527    }
6528
6529    #[doc = "Compare Window A Channel Select"]
6530    #[inline(always)]
6531    pub fn cmpcha07(
6532        self,
6533    ) -> crate::common::RegisterField<
6534        7,
6535        0x1,
6536        1,
6537        0,
6538        adcmpansr0::Cmpcha07,
6539        adcmpansr0::Cmpcha07,
6540        Adcmpansr0_SPEC,
6541        crate::common::RW,
6542    > {
6543        crate::common::RegisterField::<
6544            7,
6545            0x1,
6546            1,
6547            0,
6548            adcmpansr0::Cmpcha07,
6549            adcmpansr0::Cmpcha07,
6550            Adcmpansr0_SPEC,
6551            crate::common::RW,
6552        >::from_register(self, 0)
6553    }
6554
6555    #[doc = "Compare Window A Channel Select"]
6556    #[inline(always)]
6557    pub fn cmpcha08(
6558        self,
6559    ) -> crate::common::RegisterField<
6560        8,
6561        0x1,
6562        1,
6563        0,
6564        adcmpansr0::Cmpcha08,
6565        adcmpansr0::Cmpcha08,
6566        Adcmpansr0_SPEC,
6567        crate::common::RW,
6568    > {
6569        crate::common::RegisterField::<
6570            8,
6571            0x1,
6572            1,
6573            0,
6574            adcmpansr0::Cmpcha08,
6575            adcmpansr0::Cmpcha08,
6576            Adcmpansr0_SPEC,
6577            crate::common::RW,
6578        >::from_register(self, 0)
6579    }
6580
6581    #[doc = "Compare Window A Channel Select"]
6582    #[inline(always)]
6583    pub fn cmpcha09(
6584        self,
6585    ) -> crate::common::RegisterField<
6586        9,
6587        0x1,
6588        1,
6589        0,
6590        adcmpansr0::Cmpcha09,
6591        adcmpansr0::Cmpcha09,
6592        Adcmpansr0_SPEC,
6593        crate::common::RW,
6594    > {
6595        crate::common::RegisterField::<
6596            9,
6597            0x1,
6598            1,
6599            0,
6600            adcmpansr0::Cmpcha09,
6601            adcmpansr0::Cmpcha09,
6602            Adcmpansr0_SPEC,
6603            crate::common::RW,
6604        >::from_register(self, 0)
6605    }
6606
6607    #[doc = "Compare Window A Channel Select"]
6608    #[inline(always)]
6609    pub fn cmpcha10(
6610        self,
6611    ) -> crate::common::RegisterField<
6612        10,
6613        0x1,
6614        1,
6615        0,
6616        adcmpansr0::Cmpcha10,
6617        adcmpansr0::Cmpcha10,
6618        Adcmpansr0_SPEC,
6619        crate::common::RW,
6620    > {
6621        crate::common::RegisterField::<
6622            10,
6623            0x1,
6624            1,
6625            0,
6626            adcmpansr0::Cmpcha10,
6627            adcmpansr0::Cmpcha10,
6628            Adcmpansr0_SPEC,
6629            crate::common::RW,
6630        >::from_register(self, 0)
6631    }
6632
6633    #[doc = "Compare Window A Channel Select"]
6634    #[inline(always)]
6635    pub fn cmpcha11(
6636        self,
6637    ) -> crate::common::RegisterField<
6638        11,
6639        0x1,
6640        1,
6641        0,
6642        adcmpansr0::Cmpcha11,
6643        adcmpansr0::Cmpcha11,
6644        Adcmpansr0_SPEC,
6645        crate::common::RW,
6646    > {
6647        crate::common::RegisterField::<
6648            11,
6649            0x1,
6650            1,
6651            0,
6652            adcmpansr0::Cmpcha11,
6653            adcmpansr0::Cmpcha11,
6654            Adcmpansr0_SPEC,
6655            crate::common::RW,
6656        >::from_register(self, 0)
6657    }
6658
6659    #[doc = "Compare Window A Channel Select"]
6660    #[inline(always)]
6661    pub fn cmpcha12(
6662        self,
6663    ) -> crate::common::RegisterField<
6664        12,
6665        0x1,
6666        1,
6667        0,
6668        adcmpansr0::Cmpcha12,
6669        adcmpansr0::Cmpcha12,
6670        Adcmpansr0_SPEC,
6671        crate::common::RW,
6672    > {
6673        crate::common::RegisterField::<
6674            12,
6675            0x1,
6676            1,
6677            0,
6678            adcmpansr0::Cmpcha12,
6679            adcmpansr0::Cmpcha12,
6680            Adcmpansr0_SPEC,
6681            crate::common::RW,
6682        >::from_register(self, 0)
6683    }
6684
6685    #[doc = "Compare Window A Channel Select"]
6686    #[inline(always)]
6687    pub fn cmpcha13(
6688        self,
6689    ) -> crate::common::RegisterField<
6690        13,
6691        0x1,
6692        1,
6693        0,
6694        adcmpansr0::Cmpcha13,
6695        adcmpansr0::Cmpcha13,
6696        Adcmpansr0_SPEC,
6697        crate::common::RW,
6698    > {
6699        crate::common::RegisterField::<
6700            13,
6701            0x1,
6702            1,
6703            0,
6704            adcmpansr0::Cmpcha13,
6705            adcmpansr0::Cmpcha13,
6706            Adcmpansr0_SPEC,
6707            crate::common::RW,
6708        >::from_register(self, 0)
6709    }
6710
6711    #[doc = "Compare Window A Channel Select"]
6712    #[inline(always)]
6713    pub fn cmpcha14(
6714        self,
6715    ) -> crate::common::RegisterField<
6716        14,
6717        0x1,
6718        1,
6719        0,
6720        adcmpansr0::Cmpcha14,
6721        adcmpansr0::Cmpcha14,
6722        Adcmpansr0_SPEC,
6723        crate::common::RW,
6724    > {
6725        crate::common::RegisterField::<
6726            14,
6727            0x1,
6728            1,
6729            0,
6730            adcmpansr0::Cmpcha14,
6731            adcmpansr0::Cmpcha14,
6732            Adcmpansr0_SPEC,
6733            crate::common::RW,
6734        >::from_register(self, 0)
6735    }
6736
6737    #[doc = "Compare Window A Channel Select"]
6738    #[inline(always)]
6739    pub fn cmpcha15(
6740        self,
6741    ) -> crate::common::RegisterField<
6742        15,
6743        0x1,
6744        1,
6745        0,
6746        adcmpansr0::Cmpcha15,
6747        adcmpansr0::Cmpcha15,
6748        Adcmpansr0_SPEC,
6749        crate::common::RW,
6750    > {
6751        crate::common::RegisterField::<
6752            15,
6753            0x1,
6754            1,
6755            0,
6756            adcmpansr0::Cmpcha15,
6757            adcmpansr0::Cmpcha15,
6758            Adcmpansr0_SPEC,
6759            crate::common::RW,
6760        >::from_register(self, 0)
6761    }
6762}
6763impl ::core::default::Default for Adcmpansr0 {
6764    #[inline(always)]
6765    fn default() -> Adcmpansr0 {
6766        <crate::RegValueT<Adcmpansr0_SPEC> as RegisterValue<_>>::new(0)
6767    }
6768}
6769pub mod adcmpansr0 {
6770
6771    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6772    pub struct Cmpcha00_SPEC;
6773    pub type Cmpcha00 = crate::EnumBitfieldStruct<u8, Cmpcha00_SPEC>;
6774    impl Cmpcha00 {
6775        #[doc = "Disable compare function for associated input channel"]
6776        pub const _0: Self = Self::new(0);
6777
6778        #[doc = "Enable compare function for associated input channel"]
6779        pub const _1: Self = Self::new(1);
6780    }
6781    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6782    pub struct Cmpcha01_SPEC;
6783    pub type Cmpcha01 = crate::EnumBitfieldStruct<u8, Cmpcha01_SPEC>;
6784    impl Cmpcha01 {
6785        #[doc = "Disable compare function for associated input channel"]
6786        pub const _0: Self = Self::new(0);
6787
6788        #[doc = "Enable compare function for associated input channel"]
6789        pub const _1: Self = Self::new(1);
6790    }
6791    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6792    pub struct Cmpcha02_SPEC;
6793    pub type Cmpcha02 = crate::EnumBitfieldStruct<u8, Cmpcha02_SPEC>;
6794    impl Cmpcha02 {
6795        #[doc = "Disable compare function for associated input channel"]
6796        pub const _0: Self = Self::new(0);
6797
6798        #[doc = "Enable compare function for associated input channel"]
6799        pub const _1: Self = Self::new(1);
6800    }
6801    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6802    pub struct Cmpcha03_SPEC;
6803    pub type Cmpcha03 = crate::EnumBitfieldStruct<u8, Cmpcha03_SPEC>;
6804    impl Cmpcha03 {
6805        #[doc = "Disable compare function for associated input channel"]
6806        pub const _0: Self = Self::new(0);
6807
6808        #[doc = "Enable compare function for associated input channel"]
6809        pub const _1: Self = Self::new(1);
6810    }
6811    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6812    pub struct Cmpcha04_SPEC;
6813    pub type Cmpcha04 = crate::EnumBitfieldStruct<u8, Cmpcha04_SPEC>;
6814    impl Cmpcha04 {
6815        #[doc = "Disable compare function for associated input channel"]
6816        pub const _0: Self = Self::new(0);
6817
6818        #[doc = "Enable compare function for associated input channel"]
6819        pub const _1: Self = Self::new(1);
6820    }
6821    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6822    pub struct Cmpcha05_SPEC;
6823    pub type Cmpcha05 = crate::EnumBitfieldStruct<u8, Cmpcha05_SPEC>;
6824    impl Cmpcha05 {
6825        #[doc = "Disable compare function for associated input channel"]
6826        pub const _0: Self = Self::new(0);
6827
6828        #[doc = "Enable compare function for associated input channel"]
6829        pub const _1: Self = Self::new(1);
6830    }
6831    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6832    pub struct Cmpcha06_SPEC;
6833    pub type Cmpcha06 = crate::EnumBitfieldStruct<u8, Cmpcha06_SPEC>;
6834    impl Cmpcha06 {
6835        #[doc = "Disable compare function for associated input channel"]
6836        pub const _0: Self = Self::new(0);
6837
6838        #[doc = "Enable compare function for associated input channel"]
6839        pub const _1: Self = Self::new(1);
6840    }
6841    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6842    pub struct Cmpcha07_SPEC;
6843    pub type Cmpcha07 = crate::EnumBitfieldStruct<u8, Cmpcha07_SPEC>;
6844    impl Cmpcha07 {
6845        #[doc = "Disable compare function for associated input channel"]
6846        pub const _0: Self = Self::new(0);
6847
6848        #[doc = "Enable compare function for associated input channel"]
6849        pub const _1: Self = Self::new(1);
6850    }
6851    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6852    pub struct Cmpcha08_SPEC;
6853    pub type Cmpcha08 = crate::EnumBitfieldStruct<u8, Cmpcha08_SPEC>;
6854    impl Cmpcha08 {
6855        #[doc = "Disable compare function for associated input channel"]
6856        pub const _0: Self = Self::new(0);
6857
6858        #[doc = "Enable compare function for associated input channel"]
6859        pub const _1: Self = Self::new(1);
6860    }
6861    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6862    pub struct Cmpcha09_SPEC;
6863    pub type Cmpcha09 = crate::EnumBitfieldStruct<u8, Cmpcha09_SPEC>;
6864    impl Cmpcha09 {
6865        #[doc = "Disable compare function for associated input channel"]
6866        pub const _0: Self = Self::new(0);
6867
6868        #[doc = "Enable compare function for associated input channel"]
6869        pub const _1: Self = Self::new(1);
6870    }
6871    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6872    pub struct Cmpcha10_SPEC;
6873    pub type Cmpcha10 = crate::EnumBitfieldStruct<u8, Cmpcha10_SPEC>;
6874    impl Cmpcha10 {
6875        #[doc = "Disable compare function for associated input channel"]
6876        pub const _0: Self = Self::new(0);
6877
6878        #[doc = "Enable compare function for associated input channel"]
6879        pub const _1: Self = Self::new(1);
6880    }
6881    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6882    pub struct Cmpcha11_SPEC;
6883    pub type Cmpcha11 = crate::EnumBitfieldStruct<u8, Cmpcha11_SPEC>;
6884    impl Cmpcha11 {
6885        #[doc = "Disable compare function for associated input channel"]
6886        pub const _0: Self = Self::new(0);
6887
6888        #[doc = "Enable compare function for associated input channel"]
6889        pub const _1: Self = Self::new(1);
6890    }
6891    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6892    pub struct Cmpcha12_SPEC;
6893    pub type Cmpcha12 = crate::EnumBitfieldStruct<u8, Cmpcha12_SPEC>;
6894    impl Cmpcha12 {
6895        #[doc = "Disable compare function for associated input channel"]
6896        pub const _0: Self = Self::new(0);
6897
6898        #[doc = "Enable compare function for associated input channel"]
6899        pub const _1: Self = Self::new(1);
6900    }
6901    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6902    pub struct Cmpcha13_SPEC;
6903    pub type Cmpcha13 = crate::EnumBitfieldStruct<u8, Cmpcha13_SPEC>;
6904    impl Cmpcha13 {
6905        #[doc = "Disable compare function for associated input channel"]
6906        pub const _0: Self = Self::new(0);
6907
6908        #[doc = "Enable compare function for associated input channel"]
6909        pub const _1: Self = Self::new(1);
6910    }
6911    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6912    pub struct Cmpcha14_SPEC;
6913    pub type Cmpcha14 = crate::EnumBitfieldStruct<u8, Cmpcha14_SPEC>;
6914    impl Cmpcha14 {
6915        #[doc = "Disable compare function for associated input channel"]
6916        pub const _0: Self = Self::new(0);
6917
6918        #[doc = "Enable compare function for associated input channel"]
6919        pub const _1: Self = Self::new(1);
6920    }
6921    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6922    pub struct Cmpcha15_SPEC;
6923    pub type Cmpcha15 = crate::EnumBitfieldStruct<u8, Cmpcha15_SPEC>;
6924    impl Cmpcha15 {
6925        #[doc = "Disable compare function for associated input channel"]
6926        pub const _0: Self = Self::new(0);
6927
6928        #[doc = "Enable compare function for associated input channel"]
6929        pub const _1: Self = Self::new(1);
6930    }
6931}
6932#[doc(hidden)]
6933#[derive(Copy, Clone, Eq, PartialEq)]
6934pub struct Adcmpansr1_SPEC;
6935impl crate::sealed::RegSpec for Adcmpansr1_SPEC {
6936    type DataType = u16;
6937}
6938
6939#[doc = "A/D Compare Function Window A Channel Select Register 1"]
6940pub type Adcmpansr1 = crate::RegValueT<Adcmpansr1_SPEC>;
6941
6942impl Adcmpansr1 {
6943    #[doc = "Compare Window A Channel Select"]
6944    #[inline(always)]
6945    pub fn cmpcha16(
6946        self,
6947    ) -> crate::common::RegisterField<
6948        0,
6949        0x1,
6950        1,
6951        0,
6952        adcmpansr1::Cmpcha16,
6953        adcmpansr1::Cmpcha16,
6954        Adcmpansr1_SPEC,
6955        crate::common::RW,
6956    > {
6957        crate::common::RegisterField::<
6958            0,
6959            0x1,
6960            1,
6961            0,
6962            adcmpansr1::Cmpcha16,
6963            adcmpansr1::Cmpcha16,
6964            Adcmpansr1_SPEC,
6965            crate::common::RW,
6966        >::from_register(self, 0)
6967    }
6968
6969    #[doc = "Compare Window A Channel Select"]
6970    #[inline(always)]
6971    pub fn cmpcha17(
6972        self,
6973    ) -> crate::common::RegisterField<
6974        1,
6975        0x1,
6976        1,
6977        0,
6978        adcmpansr1::Cmpcha17,
6979        adcmpansr1::Cmpcha17,
6980        Adcmpansr1_SPEC,
6981        crate::common::RW,
6982    > {
6983        crate::common::RegisterField::<
6984            1,
6985            0x1,
6986            1,
6987            0,
6988            adcmpansr1::Cmpcha17,
6989            adcmpansr1::Cmpcha17,
6990            Adcmpansr1_SPEC,
6991            crate::common::RW,
6992        >::from_register(self, 0)
6993    }
6994
6995    #[doc = "Compare Window A Channel Select"]
6996    #[inline(always)]
6997    pub fn cmpcha18(
6998        self,
6999    ) -> crate::common::RegisterField<
7000        2,
7001        0x1,
7002        1,
7003        0,
7004        adcmpansr1::Cmpcha18,
7005        adcmpansr1::Cmpcha18,
7006        Adcmpansr1_SPEC,
7007        crate::common::RW,
7008    > {
7009        crate::common::RegisterField::<
7010            2,
7011            0x1,
7012            1,
7013            0,
7014            adcmpansr1::Cmpcha18,
7015            adcmpansr1::Cmpcha18,
7016            Adcmpansr1_SPEC,
7017            crate::common::RW,
7018        >::from_register(self, 0)
7019    }
7020
7021    #[doc = "Compare Window A Channel Select"]
7022    #[inline(always)]
7023    pub fn cmpcha19(
7024        self,
7025    ) -> crate::common::RegisterField<
7026        3,
7027        0x1,
7028        1,
7029        0,
7030        adcmpansr1::Cmpcha19,
7031        adcmpansr1::Cmpcha19,
7032        Adcmpansr1_SPEC,
7033        crate::common::RW,
7034    > {
7035        crate::common::RegisterField::<
7036            3,
7037            0x1,
7038            1,
7039            0,
7040            adcmpansr1::Cmpcha19,
7041            adcmpansr1::Cmpcha19,
7042            Adcmpansr1_SPEC,
7043            crate::common::RW,
7044        >::from_register(self, 0)
7045    }
7046
7047    #[doc = "Compare Window A Channel Select"]
7048    #[inline(always)]
7049    pub fn cmpcha20(
7050        self,
7051    ) -> crate::common::RegisterField<
7052        4,
7053        0x1,
7054        1,
7055        0,
7056        adcmpansr1::Cmpcha20,
7057        adcmpansr1::Cmpcha20,
7058        Adcmpansr1_SPEC,
7059        crate::common::RW,
7060    > {
7061        crate::common::RegisterField::<
7062            4,
7063            0x1,
7064            1,
7065            0,
7066            adcmpansr1::Cmpcha20,
7067            adcmpansr1::Cmpcha20,
7068            Adcmpansr1_SPEC,
7069            crate::common::RW,
7070        >::from_register(self, 0)
7071    }
7072
7073    #[doc = "Compare Window A Channel Select"]
7074    #[inline(always)]
7075    pub fn cmpcha21(
7076        self,
7077    ) -> crate::common::RegisterField<
7078        5,
7079        0x1,
7080        1,
7081        0,
7082        adcmpansr1::Cmpcha21,
7083        adcmpansr1::Cmpcha21,
7084        Adcmpansr1_SPEC,
7085        crate::common::RW,
7086    > {
7087        crate::common::RegisterField::<
7088            5,
7089            0x1,
7090            1,
7091            0,
7092            adcmpansr1::Cmpcha21,
7093            adcmpansr1::Cmpcha21,
7094            Adcmpansr1_SPEC,
7095            crate::common::RW,
7096        >::from_register(self, 0)
7097    }
7098
7099    #[doc = "Compare Window A Channel Select"]
7100    #[inline(always)]
7101    pub fn cmpcha22(
7102        self,
7103    ) -> crate::common::RegisterField<
7104        6,
7105        0x1,
7106        1,
7107        0,
7108        adcmpansr1::Cmpcha22,
7109        adcmpansr1::Cmpcha22,
7110        Adcmpansr1_SPEC,
7111        crate::common::RW,
7112    > {
7113        crate::common::RegisterField::<
7114            6,
7115            0x1,
7116            1,
7117            0,
7118            adcmpansr1::Cmpcha22,
7119            adcmpansr1::Cmpcha22,
7120            Adcmpansr1_SPEC,
7121            crate::common::RW,
7122        >::from_register(self, 0)
7123    }
7124
7125    #[doc = "Compare Window A Channel Select"]
7126    #[inline(always)]
7127    pub fn cmpcha23(
7128        self,
7129    ) -> crate::common::RegisterField<
7130        7,
7131        0x1,
7132        1,
7133        0,
7134        adcmpansr1::Cmpcha23,
7135        adcmpansr1::Cmpcha23,
7136        Adcmpansr1_SPEC,
7137        crate::common::RW,
7138    > {
7139        crate::common::RegisterField::<
7140            7,
7141            0x1,
7142            1,
7143            0,
7144            adcmpansr1::Cmpcha23,
7145            adcmpansr1::Cmpcha23,
7146            Adcmpansr1_SPEC,
7147            crate::common::RW,
7148        >::from_register(self, 0)
7149    }
7150
7151    #[doc = "Compare Window A Channel Select"]
7152    #[inline(always)]
7153    pub fn cmpcha24(
7154        self,
7155    ) -> crate::common::RegisterField<
7156        8,
7157        0x1,
7158        1,
7159        0,
7160        adcmpansr1::Cmpcha24,
7161        adcmpansr1::Cmpcha24,
7162        Adcmpansr1_SPEC,
7163        crate::common::RW,
7164    > {
7165        crate::common::RegisterField::<
7166            8,
7167            0x1,
7168            1,
7169            0,
7170            adcmpansr1::Cmpcha24,
7171            adcmpansr1::Cmpcha24,
7172            Adcmpansr1_SPEC,
7173            crate::common::RW,
7174        >::from_register(self, 0)
7175    }
7176
7177    #[doc = "Compare Window A Channel Select"]
7178    #[inline(always)]
7179    pub fn cmpcha25(
7180        self,
7181    ) -> crate::common::RegisterField<
7182        9,
7183        0x1,
7184        1,
7185        0,
7186        adcmpansr1::Cmpcha25,
7187        adcmpansr1::Cmpcha25,
7188        Adcmpansr1_SPEC,
7189        crate::common::RW,
7190    > {
7191        crate::common::RegisterField::<
7192            9,
7193            0x1,
7194            1,
7195            0,
7196            adcmpansr1::Cmpcha25,
7197            adcmpansr1::Cmpcha25,
7198            Adcmpansr1_SPEC,
7199            crate::common::RW,
7200        >::from_register(self, 0)
7201    }
7202
7203    #[doc = "Compare Window A Channel Select"]
7204    #[inline(always)]
7205    pub fn cmpcha26(
7206        self,
7207    ) -> crate::common::RegisterField<
7208        10,
7209        0x1,
7210        1,
7211        0,
7212        adcmpansr1::Cmpcha26,
7213        adcmpansr1::Cmpcha26,
7214        Adcmpansr1_SPEC,
7215        crate::common::RW,
7216    > {
7217        crate::common::RegisterField::<
7218            10,
7219            0x1,
7220            1,
7221            0,
7222            adcmpansr1::Cmpcha26,
7223            adcmpansr1::Cmpcha26,
7224            Adcmpansr1_SPEC,
7225            crate::common::RW,
7226        >::from_register(self, 0)
7227    }
7228
7229    #[doc = "Compare Window A Channel Select"]
7230    #[inline(always)]
7231    pub fn cmpcha27(
7232        self,
7233    ) -> crate::common::RegisterField<
7234        11,
7235        0x1,
7236        1,
7237        0,
7238        adcmpansr1::Cmpcha27,
7239        adcmpansr1::Cmpcha27,
7240        Adcmpansr1_SPEC,
7241        crate::common::RW,
7242    > {
7243        crate::common::RegisterField::<
7244            11,
7245            0x1,
7246            1,
7247            0,
7248            adcmpansr1::Cmpcha27,
7249            adcmpansr1::Cmpcha27,
7250            Adcmpansr1_SPEC,
7251            crate::common::RW,
7252        >::from_register(self, 0)
7253    }
7254
7255    #[doc = "Compare Window A Channel Select"]
7256    #[inline(always)]
7257    pub fn cmpcha28(
7258        self,
7259    ) -> crate::common::RegisterField<
7260        12,
7261        0x1,
7262        1,
7263        0,
7264        adcmpansr1::Cmpcha28,
7265        adcmpansr1::Cmpcha28,
7266        Adcmpansr1_SPEC,
7267        crate::common::RW,
7268    > {
7269        crate::common::RegisterField::<
7270            12,
7271            0x1,
7272            1,
7273            0,
7274            adcmpansr1::Cmpcha28,
7275            adcmpansr1::Cmpcha28,
7276            Adcmpansr1_SPEC,
7277            crate::common::RW,
7278        >::from_register(self, 0)
7279    }
7280
7281    #[doc = "Compare Window A Channel Select"]
7282    #[inline(always)]
7283    pub fn cmpcha29(
7284        self,
7285    ) -> crate::common::RegisterField<
7286        13,
7287        0x1,
7288        1,
7289        0,
7290        adcmpansr1::Cmpcha29,
7291        adcmpansr1::Cmpcha29,
7292        Adcmpansr1_SPEC,
7293        crate::common::RW,
7294    > {
7295        crate::common::RegisterField::<
7296            13,
7297            0x1,
7298            1,
7299            0,
7300            adcmpansr1::Cmpcha29,
7301            adcmpansr1::Cmpcha29,
7302            Adcmpansr1_SPEC,
7303            crate::common::RW,
7304        >::from_register(self, 0)
7305    }
7306
7307    #[doc = "Compare Window A Channel Select"]
7308    #[inline(always)]
7309    pub fn cmpcha30(
7310        self,
7311    ) -> crate::common::RegisterField<
7312        14,
7313        0x1,
7314        1,
7315        0,
7316        adcmpansr1::Cmpcha30,
7317        adcmpansr1::Cmpcha30,
7318        Adcmpansr1_SPEC,
7319        crate::common::RW,
7320    > {
7321        crate::common::RegisterField::<
7322            14,
7323            0x1,
7324            1,
7325            0,
7326            adcmpansr1::Cmpcha30,
7327            adcmpansr1::Cmpcha30,
7328            Adcmpansr1_SPEC,
7329            crate::common::RW,
7330        >::from_register(self, 0)
7331    }
7332
7333    #[doc = "Compare Window A Channel Select"]
7334    #[inline(always)]
7335    pub fn cmpcha31(
7336        self,
7337    ) -> crate::common::RegisterField<
7338        15,
7339        0x1,
7340        1,
7341        0,
7342        adcmpansr1::Cmpcha31,
7343        adcmpansr1::Cmpcha31,
7344        Adcmpansr1_SPEC,
7345        crate::common::RW,
7346    > {
7347        crate::common::RegisterField::<
7348            15,
7349            0x1,
7350            1,
7351            0,
7352            adcmpansr1::Cmpcha31,
7353            adcmpansr1::Cmpcha31,
7354            Adcmpansr1_SPEC,
7355            crate::common::RW,
7356        >::from_register(self, 0)
7357    }
7358}
7359impl ::core::default::Default for Adcmpansr1 {
7360    #[inline(always)]
7361    fn default() -> Adcmpansr1 {
7362        <crate::RegValueT<Adcmpansr1_SPEC> as RegisterValue<_>>::new(0)
7363    }
7364}
7365pub mod adcmpansr1 {
7366
7367    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7368    pub struct Cmpcha16_SPEC;
7369    pub type Cmpcha16 = crate::EnumBitfieldStruct<u8, Cmpcha16_SPEC>;
7370    impl Cmpcha16 {
7371        #[doc = "Disable compare function for associated input channel"]
7372        pub const _0: Self = Self::new(0);
7373
7374        #[doc = "Enable compare function for associated input channel"]
7375        pub const _1: Self = Self::new(1);
7376    }
7377    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7378    pub struct Cmpcha17_SPEC;
7379    pub type Cmpcha17 = crate::EnumBitfieldStruct<u8, Cmpcha17_SPEC>;
7380    impl Cmpcha17 {
7381        #[doc = "Disable compare function for associated input channel"]
7382        pub const _0: Self = Self::new(0);
7383
7384        #[doc = "Enable compare function for associated input channel"]
7385        pub const _1: Self = Self::new(1);
7386    }
7387    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7388    pub struct Cmpcha18_SPEC;
7389    pub type Cmpcha18 = crate::EnumBitfieldStruct<u8, Cmpcha18_SPEC>;
7390    impl Cmpcha18 {
7391        #[doc = "Disable compare function for associated input channel"]
7392        pub const _0: Self = Self::new(0);
7393
7394        #[doc = "Enable compare function for associated input channel"]
7395        pub const _1: Self = Self::new(1);
7396    }
7397    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7398    pub struct Cmpcha19_SPEC;
7399    pub type Cmpcha19 = crate::EnumBitfieldStruct<u8, Cmpcha19_SPEC>;
7400    impl Cmpcha19 {
7401        #[doc = "Disable compare function for associated input channel"]
7402        pub const _0: Self = Self::new(0);
7403
7404        #[doc = "Enable compare function for associated input channel"]
7405        pub const _1: Self = Self::new(1);
7406    }
7407    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7408    pub struct Cmpcha20_SPEC;
7409    pub type Cmpcha20 = crate::EnumBitfieldStruct<u8, Cmpcha20_SPEC>;
7410    impl Cmpcha20 {
7411        #[doc = "Disable compare function for associated input channel"]
7412        pub const _0: Self = Self::new(0);
7413
7414        #[doc = "Enable compare function for associated input channel"]
7415        pub const _1: Self = Self::new(1);
7416    }
7417    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7418    pub struct Cmpcha21_SPEC;
7419    pub type Cmpcha21 = crate::EnumBitfieldStruct<u8, Cmpcha21_SPEC>;
7420    impl Cmpcha21 {
7421        #[doc = "Disable compare function for associated input channel"]
7422        pub const _0: Self = Self::new(0);
7423
7424        #[doc = "Enable compare function for associated input channel"]
7425        pub const _1: Self = Self::new(1);
7426    }
7427    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7428    pub struct Cmpcha22_SPEC;
7429    pub type Cmpcha22 = crate::EnumBitfieldStruct<u8, Cmpcha22_SPEC>;
7430    impl Cmpcha22 {
7431        #[doc = "Disable compare function for associated input channel"]
7432        pub const _0: Self = Self::new(0);
7433
7434        #[doc = "Enable compare function for associated input channel"]
7435        pub const _1: Self = Self::new(1);
7436    }
7437    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7438    pub struct Cmpcha23_SPEC;
7439    pub type Cmpcha23 = crate::EnumBitfieldStruct<u8, Cmpcha23_SPEC>;
7440    impl Cmpcha23 {
7441        #[doc = "Disable compare function for associated input channel"]
7442        pub const _0: Self = Self::new(0);
7443
7444        #[doc = "Enable compare function for associated input channel"]
7445        pub const _1: Self = Self::new(1);
7446    }
7447    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7448    pub struct Cmpcha24_SPEC;
7449    pub type Cmpcha24 = crate::EnumBitfieldStruct<u8, Cmpcha24_SPEC>;
7450    impl Cmpcha24 {
7451        #[doc = "Disable compare function for associated input channel"]
7452        pub const _0: Self = Self::new(0);
7453
7454        #[doc = "Enable compare function for associated input channel"]
7455        pub const _1: Self = Self::new(1);
7456    }
7457    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7458    pub struct Cmpcha25_SPEC;
7459    pub type Cmpcha25 = crate::EnumBitfieldStruct<u8, Cmpcha25_SPEC>;
7460    impl Cmpcha25 {
7461        #[doc = "Disable compare function for associated input channel"]
7462        pub const _0: Self = Self::new(0);
7463
7464        #[doc = "Enable compare function for associated input channel"]
7465        pub const _1: Self = Self::new(1);
7466    }
7467    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7468    pub struct Cmpcha26_SPEC;
7469    pub type Cmpcha26 = crate::EnumBitfieldStruct<u8, Cmpcha26_SPEC>;
7470    impl Cmpcha26 {
7471        #[doc = "Disable compare function for associated input channel"]
7472        pub const _0: Self = Self::new(0);
7473
7474        #[doc = "Enable compare function for associated input channel"]
7475        pub const _1: Self = Self::new(1);
7476    }
7477    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7478    pub struct Cmpcha27_SPEC;
7479    pub type Cmpcha27 = crate::EnumBitfieldStruct<u8, Cmpcha27_SPEC>;
7480    impl Cmpcha27 {
7481        #[doc = "Disable compare function for associated input channel"]
7482        pub const _0: Self = Self::new(0);
7483
7484        #[doc = "Enable compare function for associated input channel"]
7485        pub const _1: Self = Self::new(1);
7486    }
7487    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7488    pub struct Cmpcha28_SPEC;
7489    pub type Cmpcha28 = crate::EnumBitfieldStruct<u8, Cmpcha28_SPEC>;
7490    impl Cmpcha28 {
7491        #[doc = "Disable compare function for associated input channel"]
7492        pub const _0: Self = Self::new(0);
7493
7494        #[doc = "Enable compare function for associated input channel"]
7495        pub const _1: Self = Self::new(1);
7496    }
7497    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7498    pub struct Cmpcha29_SPEC;
7499    pub type Cmpcha29 = crate::EnumBitfieldStruct<u8, Cmpcha29_SPEC>;
7500    impl Cmpcha29 {
7501        #[doc = "Disable compare function for associated input channel"]
7502        pub const _0: Self = Self::new(0);
7503
7504        #[doc = "Enable compare function for associated input channel"]
7505        pub const _1: Self = Self::new(1);
7506    }
7507    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7508    pub struct Cmpcha30_SPEC;
7509    pub type Cmpcha30 = crate::EnumBitfieldStruct<u8, Cmpcha30_SPEC>;
7510    impl Cmpcha30 {
7511        #[doc = "Disable compare function for associated input channel"]
7512        pub const _0: Self = Self::new(0);
7513
7514        #[doc = "Enable compare function for associated input channel"]
7515        pub const _1: Self = Self::new(1);
7516    }
7517    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7518    pub struct Cmpcha31_SPEC;
7519    pub type Cmpcha31 = crate::EnumBitfieldStruct<u8, Cmpcha31_SPEC>;
7520    impl Cmpcha31 {
7521        #[doc = "Disable compare function for associated input channel"]
7522        pub const _0: Self = Self::new(0);
7523
7524        #[doc = "Enable compare function for associated input channel"]
7525        pub const _1: Self = Self::new(1);
7526    }
7527}
7528#[doc(hidden)]
7529#[derive(Copy, Clone, Eq, PartialEq)]
7530pub struct Adcmplr0_SPEC;
7531impl crate::sealed::RegSpec for Adcmplr0_SPEC {
7532    type DataType = u16;
7533}
7534
7535#[doc = "A/D Compare Function Window A Comparison Condition Setting Register 0"]
7536pub type Adcmplr0 = crate::RegValueT<Adcmplr0_SPEC>;
7537
7538impl Adcmplr0 {
7539    #[doc = "Compare Window A Comparison Condition Select"]
7540    #[inline(always)]
7541    pub fn cmplcha00(
7542        self,
7543    ) -> crate::common::RegisterField<
7544        0,
7545        0x1,
7546        1,
7547        0,
7548        adcmplr0::Cmplcha00,
7549        adcmplr0::Cmplcha00,
7550        Adcmplr0_SPEC,
7551        crate::common::RW,
7552    > {
7553        crate::common::RegisterField::<
7554            0,
7555            0x1,
7556            1,
7557            0,
7558            adcmplr0::Cmplcha00,
7559            adcmplr0::Cmplcha00,
7560            Adcmplr0_SPEC,
7561            crate::common::RW,
7562        >::from_register(self, 0)
7563    }
7564
7565    #[doc = "Compare Window A Comparison Condition Select"]
7566    #[inline(always)]
7567    pub fn cmplcha01(
7568        self,
7569    ) -> crate::common::RegisterField<
7570        1,
7571        0x1,
7572        1,
7573        0,
7574        adcmplr0::Cmplcha01,
7575        adcmplr0::Cmplcha01,
7576        Adcmplr0_SPEC,
7577        crate::common::RW,
7578    > {
7579        crate::common::RegisterField::<
7580            1,
7581            0x1,
7582            1,
7583            0,
7584            adcmplr0::Cmplcha01,
7585            adcmplr0::Cmplcha01,
7586            Adcmplr0_SPEC,
7587            crate::common::RW,
7588        >::from_register(self, 0)
7589    }
7590
7591    #[doc = "Compare Window A Comparison Condition Select"]
7592    #[inline(always)]
7593    pub fn cmplcha02(
7594        self,
7595    ) -> crate::common::RegisterField<
7596        2,
7597        0x1,
7598        1,
7599        0,
7600        adcmplr0::Cmplcha02,
7601        adcmplr0::Cmplcha02,
7602        Adcmplr0_SPEC,
7603        crate::common::RW,
7604    > {
7605        crate::common::RegisterField::<
7606            2,
7607            0x1,
7608            1,
7609            0,
7610            adcmplr0::Cmplcha02,
7611            adcmplr0::Cmplcha02,
7612            Adcmplr0_SPEC,
7613            crate::common::RW,
7614        >::from_register(self, 0)
7615    }
7616
7617    #[doc = "Compare Window A Comparison Condition Select"]
7618    #[inline(always)]
7619    pub fn cmplcha03(
7620        self,
7621    ) -> crate::common::RegisterField<
7622        3,
7623        0x1,
7624        1,
7625        0,
7626        adcmplr0::Cmplcha03,
7627        adcmplr0::Cmplcha03,
7628        Adcmplr0_SPEC,
7629        crate::common::RW,
7630    > {
7631        crate::common::RegisterField::<
7632            3,
7633            0x1,
7634            1,
7635            0,
7636            adcmplr0::Cmplcha03,
7637            adcmplr0::Cmplcha03,
7638            Adcmplr0_SPEC,
7639            crate::common::RW,
7640        >::from_register(self, 0)
7641    }
7642
7643    #[doc = "Compare Window A Comparison Condition Select"]
7644    #[inline(always)]
7645    pub fn cmplcha04(
7646        self,
7647    ) -> crate::common::RegisterField<
7648        4,
7649        0x1,
7650        1,
7651        0,
7652        adcmplr0::Cmplcha04,
7653        adcmplr0::Cmplcha04,
7654        Adcmplr0_SPEC,
7655        crate::common::RW,
7656    > {
7657        crate::common::RegisterField::<
7658            4,
7659            0x1,
7660            1,
7661            0,
7662            adcmplr0::Cmplcha04,
7663            adcmplr0::Cmplcha04,
7664            Adcmplr0_SPEC,
7665            crate::common::RW,
7666        >::from_register(self, 0)
7667    }
7668
7669    #[doc = "Compare Window A Comparison Condition Select"]
7670    #[inline(always)]
7671    pub fn cmplcha05(
7672        self,
7673    ) -> crate::common::RegisterField<
7674        5,
7675        0x1,
7676        1,
7677        0,
7678        adcmplr0::Cmplcha05,
7679        adcmplr0::Cmplcha05,
7680        Adcmplr0_SPEC,
7681        crate::common::RW,
7682    > {
7683        crate::common::RegisterField::<
7684            5,
7685            0x1,
7686            1,
7687            0,
7688            adcmplr0::Cmplcha05,
7689            adcmplr0::Cmplcha05,
7690            Adcmplr0_SPEC,
7691            crate::common::RW,
7692        >::from_register(self, 0)
7693    }
7694
7695    #[doc = "Compare Window A Comparison Condition Select"]
7696    #[inline(always)]
7697    pub fn cmplcha06(
7698        self,
7699    ) -> crate::common::RegisterField<
7700        6,
7701        0x1,
7702        1,
7703        0,
7704        adcmplr0::Cmplcha06,
7705        adcmplr0::Cmplcha06,
7706        Adcmplr0_SPEC,
7707        crate::common::RW,
7708    > {
7709        crate::common::RegisterField::<
7710            6,
7711            0x1,
7712            1,
7713            0,
7714            adcmplr0::Cmplcha06,
7715            adcmplr0::Cmplcha06,
7716            Adcmplr0_SPEC,
7717            crate::common::RW,
7718        >::from_register(self, 0)
7719    }
7720
7721    #[doc = "Compare Window A Comparison Condition Select"]
7722    #[inline(always)]
7723    pub fn cmplcha07(
7724        self,
7725    ) -> crate::common::RegisterField<
7726        7,
7727        0x1,
7728        1,
7729        0,
7730        adcmplr0::Cmplcha07,
7731        adcmplr0::Cmplcha07,
7732        Adcmplr0_SPEC,
7733        crate::common::RW,
7734    > {
7735        crate::common::RegisterField::<
7736            7,
7737            0x1,
7738            1,
7739            0,
7740            adcmplr0::Cmplcha07,
7741            adcmplr0::Cmplcha07,
7742            Adcmplr0_SPEC,
7743            crate::common::RW,
7744        >::from_register(self, 0)
7745    }
7746
7747    #[doc = "Compare Window A Comparison Condition Select"]
7748    #[inline(always)]
7749    pub fn cmplcha08(
7750        self,
7751    ) -> crate::common::RegisterField<
7752        8,
7753        0x1,
7754        1,
7755        0,
7756        adcmplr0::Cmplcha08,
7757        adcmplr0::Cmplcha08,
7758        Adcmplr0_SPEC,
7759        crate::common::RW,
7760    > {
7761        crate::common::RegisterField::<
7762            8,
7763            0x1,
7764            1,
7765            0,
7766            adcmplr0::Cmplcha08,
7767            adcmplr0::Cmplcha08,
7768            Adcmplr0_SPEC,
7769            crate::common::RW,
7770        >::from_register(self, 0)
7771    }
7772
7773    #[doc = "Compare Window A Comparison Condition Select"]
7774    #[inline(always)]
7775    pub fn cmplcha09(
7776        self,
7777    ) -> crate::common::RegisterField<
7778        9,
7779        0x1,
7780        1,
7781        0,
7782        adcmplr0::Cmplcha09,
7783        adcmplr0::Cmplcha09,
7784        Adcmplr0_SPEC,
7785        crate::common::RW,
7786    > {
7787        crate::common::RegisterField::<
7788            9,
7789            0x1,
7790            1,
7791            0,
7792            adcmplr0::Cmplcha09,
7793            adcmplr0::Cmplcha09,
7794            Adcmplr0_SPEC,
7795            crate::common::RW,
7796        >::from_register(self, 0)
7797    }
7798
7799    #[doc = "Compare Window A Comparison Condition Select"]
7800    #[inline(always)]
7801    pub fn cmplcha10(
7802        self,
7803    ) -> crate::common::RegisterField<
7804        10,
7805        0x1,
7806        1,
7807        0,
7808        adcmplr0::Cmplcha10,
7809        adcmplr0::Cmplcha10,
7810        Adcmplr0_SPEC,
7811        crate::common::RW,
7812    > {
7813        crate::common::RegisterField::<
7814            10,
7815            0x1,
7816            1,
7817            0,
7818            adcmplr0::Cmplcha10,
7819            adcmplr0::Cmplcha10,
7820            Adcmplr0_SPEC,
7821            crate::common::RW,
7822        >::from_register(self, 0)
7823    }
7824
7825    #[doc = "Compare Window A Comparison Condition Select"]
7826    #[inline(always)]
7827    pub fn cmplcha11(
7828        self,
7829    ) -> crate::common::RegisterField<
7830        11,
7831        0x1,
7832        1,
7833        0,
7834        adcmplr0::Cmplcha11,
7835        adcmplr0::Cmplcha11,
7836        Adcmplr0_SPEC,
7837        crate::common::RW,
7838    > {
7839        crate::common::RegisterField::<
7840            11,
7841            0x1,
7842            1,
7843            0,
7844            adcmplr0::Cmplcha11,
7845            adcmplr0::Cmplcha11,
7846            Adcmplr0_SPEC,
7847            crate::common::RW,
7848        >::from_register(self, 0)
7849    }
7850
7851    #[doc = "Compare Window A Comparison Condition Select"]
7852    #[inline(always)]
7853    pub fn cmplcha12(
7854        self,
7855    ) -> crate::common::RegisterField<
7856        12,
7857        0x1,
7858        1,
7859        0,
7860        adcmplr0::Cmplcha12,
7861        adcmplr0::Cmplcha12,
7862        Adcmplr0_SPEC,
7863        crate::common::RW,
7864    > {
7865        crate::common::RegisterField::<
7866            12,
7867            0x1,
7868            1,
7869            0,
7870            adcmplr0::Cmplcha12,
7871            adcmplr0::Cmplcha12,
7872            Adcmplr0_SPEC,
7873            crate::common::RW,
7874        >::from_register(self, 0)
7875    }
7876
7877    #[doc = "Compare Window A Comparison Condition Select"]
7878    #[inline(always)]
7879    pub fn cmplcha13(
7880        self,
7881    ) -> crate::common::RegisterField<
7882        13,
7883        0x1,
7884        1,
7885        0,
7886        adcmplr0::Cmplcha13,
7887        adcmplr0::Cmplcha13,
7888        Adcmplr0_SPEC,
7889        crate::common::RW,
7890    > {
7891        crate::common::RegisterField::<
7892            13,
7893            0x1,
7894            1,
7895            0,
7896            adcmplr0::Cmplcha13,
7897            adcmplr0::Cmplcha13,
7898            Adcmplr0_SPEC,
7899            crate::common::RW,
7900        >::from_register(self, 0)
7901    }
7902
7903    #[doc = "Compare Window A Comparison Condition Select"]
7904    #[inline(always)]
7905    pub fn cmplcha14(
7906        self,
7907    ) -> crate::common::RegisterField<
7908        14,
7909        0x1,
7910        1,
7911        0,
7912        adcmplr0::Cmplcha14,
7913        adcmplr0::Cmplcha14,
7914        Adcmplr0_SPEC,
7915        crate::common::RW,
7916    > {
7917        crate::common::RegisterField::<
7918            14,
7919            0x1,
7920            1,
7921            0,
7922            adcmplr0::Cmplcha14,
7923            adcmplr0::Cmplcha14,
7924            Adcmplr0_SPEC,
7925            crate::common::RW,
7926        >::from_register(self, 0)
7927    }
7928
7929    #[doc = "Compare Window A Comparison Condition Select"]
7930    #[inline(always)]
7931    pub fn cmplcha15(
7932        self,
7933    ) -> crate::common::RegisterField<
7934        15,
7935        0x1,
7936        1,
7937        0,
7938        adcmplr0::Cmplcha15,
7939        adcmplr0::Cmplcha15,
7940        Adcmplr0_SPEC,
7941        crate::common::RW,
7942    > {
7943        crate::common::RegisterField::<
7944            15,
7945            0x1,
7946            1,
7947            0,
7948            adcmplr0::Cmplcha15,
7949            adcmplr0::Cmplcha15,
7950            Adcmplr0_SPEC,
7951            crate::common::RW,
7952        >::from_register(self, 0)
7953    }
7954}
7955impl ::core::default::Default for Adcmplr0 {
7956    #[inline(always)]
7957    fn default() -> Adcmplr0 {
7958        <crate::RegValueT<Adcmplr0_SPEC> as RegisterValue<_>>::new(0)
7959    }
7960}
7961pub mod adcmplr0 {
7962
7963    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7964    pub struct Cmplcha00_SPEC;
7965    pub type Cmplcha00 = crate::EnumBitfieldStruct<u8, Cmplcha00_SPEC>;
7966    impl Cmplcha00 {
7967        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
7968        pub const _0: Self = Self::new(0);
7969
7970        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
7971        pub const _1: Self = Self::new(1);
7972    }
7973    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7974    pub struct Cmplcha01_SPEC;
7975    pub type Cmplcha01 = crate::EnumBitfieldStruct<u8, Cmplcha01_SPEC>;
7976    impl Cmplcha01 {
7977        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
7978        pub const _0: Self = Self::new(0);
7979
7980        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
7981        pub const _1: Self = Self::new(1);
7982    }
7983    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7984    pub struct Cmplcha02_SPEC;
7985    pub type Cmplcha02 = crate::EnumBitfieldStruct<u8, Cmplcha02_SPEC>;
7986    impl Cmplcha02 {
7987        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
7988        pub const _0: Self = Self::new(0);
7989
7990        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
7991        pub const _1: Self = Self::new(1);
7992    }
7993    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
7994    pub struct Cmplcha03_SPEC;
7995    pub type Cmplcha03 = crate::EnumBitfieldStruct<u8, Cmplcha03_SPEC>;
7996    impl Cmplcha03 {
7997        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
7998        pub const _0: Self = Self::new(0);
7999
8000        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8001        pub const _1: Self = Self::new(1);
8002    }
8003    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8004    pub struct Cmplcha04_SPEC;
8005    pub type Cmplcha04 = crate::EnumBitfieldStruct<u8, Cmplcha04_SPEC>;
8006    impl Cmplcha04 {
8007        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8008        pub const _0: Self = Self::new(0);
8009
8010        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8011        pub const _1: Self = Self::new(1);
8012    }
8013    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8014    pub struct Cmplcha05_SPEC;
8015    pub type Cmplcha05 = crate::EnumBitfieldStruct<u8, Cmplcha05_SPEC>;
8016    impl Cmplcha05 {
8017        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8018        pub const _0: Self = Self::new(0);
8019
8020        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8021        pub const _1: Self = Self::new(1);
8022    }
8023    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8024    pub struct Cmplcha06_SPEC;
8025    pub type Cmplcha06 = crate::EnumBitfieldStruct<u8, Cmplcha06_SPEC>;
8026    impl Cmplcha06 {
8027        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8028        pub const _0: Self = Self::new(0);
8029
8030        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8031        pub const _1: Self = Self::new(1);
8032    }
8033    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8034    pub struct Cmplcha07_SPEC;
8035    pub type Cmplcha07 = crate::EnumBitfieldStruct<u8, Cmplcha07_SPEC>;
8036    impl Cmplcha07 {
8037        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8038        pub const _0: Self = Self::new(0);
8039
8040        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8041        pub const _1: Self = Self::new(1);
8042    }
8043    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8044    pub struct Cmplcha08_SPEC;
8045    pub type Cmplcha08 = crate::EnumBitfieldStruct<u8, Cmplcha08_SPEC>;
8046    impl Cmplcha08 {
8047        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8048        pub const _0: Self = Self::new(0);
8049
8050        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8051        pub const _1: Self = Self::new(1);
8052    }
8053    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8054    pub struct Cmplcha09_SPEC;
8055    pub type Cmplcha09 = crate::EnumBitfieldStruct<u8, Cmplcha09_SPEC>;
8056    impl Cmplcha09 {
8057        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8058        pub const _0: Self = Self::new(0);
8059
8060        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8061        pub const _1: Self = Self::new(1);
8062    }
8063    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8064    pub struct Cmplcha10_SPEC;
8065    pub type Cmplcha10 = crate::EnumBitfieldStruct<u8, Cmplcha10_SPEC>;
8066    impl Cmplcha10 {
8067        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8068        pub const _0: Self = Self::new(0);
8069
8070        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8071        pub const _1: Self = Self::new(1);
8072    }
8073    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8074    pub struct Cmplcha11_SPEC;
8075    pub type Cmplcha11 = crate::EnumBitfieldStruct<u8, Cmplcha11_SPEC>;
8076    impl Cmplcha11 {
8077        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8078        pub const _0: Self = Self::new(0);
8079
8080        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8081        pub const _1: Self = Self::new(1);
8082    }
8083    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8084    pub struct Cmplcha12_SPEC;
8085    pub type Cmplcha12 = crate::EnumBitfieldStruct<u8, Cmplcha12_SPEC>;
8086    impl Cmplcha12 {
8087        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8088        pub const _0: Self = Self::new(0);
8089
8090        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8091        pub const _1: Self = Self::new(1);
8092    }
8093    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8094    pub struct Cmplcha13_SPEC;
8095    pub type Cmplcha13 = crate::EnumBitfieldStruct<u8, Cmplcha13_SPEC>;
8096    impl Cmplcha13 {
8097        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8098        pub const _0: Self = Self::new(0);
8099
8100        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8101        pub const _1: Self = Self::new(1);
8102    }
8103    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8104    pub struct Cmplcha14_SPEC;
8105    pub type Cmplcha14 = crate::EnumBitfieldStruct<u8, Cmplcha14_SPEC>;
8106    impl Cmplcha14 {
8107        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8108        pub const _0: Self = Self::new(0);
8109
8110        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8111        pub const _1: Self = Self::new(1);
8112    }
8113    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8114    pub struct Cmplcha15_SPEC;
8115    pub type Cmplcha15 = crate::EnumBitfieldStruct<u8, Cmplcha15_SPEC>;
8116    impl Cmplcha15 {
8117        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8118        pub const _0: Self = Self::new(0);
8119
8120        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8121        pub const _1: Self = Self::new(1);
8122    }
8123}
8124#[doc(hidden)]
8125#[derive(Copy, Clone, Eq, PartialEq)]
8126pub struct Adcmplr1_SPEC;
8127impl crate::sealed::RegSpec for Adcmplr1_SPEC {
8128    type DataType = u16;
8129}
8130
8131#[doc = "A/D Compare Function Window A Comparison Condition Setting Register 1"]
8132pub type Adcmplr1 = crate::RegValueT<Adcmplr1_SPEC>;
8133
8134impl Adcmplr1 {
8135    #[doc = "Compare Window A Comparison Condition Select"]
8136    #[inline(always)]
8137    pub fn cmplcha16(
8138        self,
8139    ) -> crate::common::RegisterField<
8140        0,
8141        0x1,
8142        1,
8143        0,
8144        adcmplr1::Cmplcha16,
8145        adcmplr1::Cmplcha16,
8146        Adcmplr1_SPEC,
8147        crate::common::RW,
8148    > {
8149        crate::common::RegisterField::<
8150            0,
8151            0x1,
8152            1,
8153            0,
8154            adcmplr1::Cmplcha16,
8155            adcmplr1::Cmplcha16,
8156            Adcmplr1_SPEC,
8157            crate::common::RW,
8158        >::from_register(self, 0)
8159    }
8160
8161    #[doc = "Compare Window A Comparison Condition Select"]
8162    #[inline(always)]
8163    pub fn cmplcha17(
8164        self,
8165    ) -> crate::common::RegisterField<
8166        1,
8167        0x1,
8168        1,
8169        0,
8170        adcmplr1::Cmplcha17,
8171        adcmplr1::Cmplcha17,
8172        Adcmplr1_SPEC,
8173        crate::common::RW,
8174    > {
8175        crate::common::RegisterField::<
8176            1,
8177            0x1,
8178            1,
8179            0,
8180            adcmplr1::Cmplcha17,
8181            adcmplr1::Cmplcha17,
8182            Adcmplr1_SPEC,
8183            crate::common::RW,
8184        >::from_register(self, 0)
8185    }
8186
8187    #[doc = "Compare Window A Comparison Condition Select"]
8188    #[inline(always)]
8189    pub fn cmplcha18(
8190        self,
8191    ) -> crate::common::RegisterField<
8192        2,
8193        0x1,
8194        1,
8195        0,
8196        adcmplr1::Cmplcha18,
8197        adcmplr1::Cmplcha18,
8198        Adcmplr1_SPEC,
8199        crate::common::RW,
8200    > {
8201        crate::common::RegisterField::<
8202            2,
8203            0x1,
8204            1,
8205            0,
8206            adcmplr1::Cmplcha18,
8207            adcmplr1::Cmplcha18,
8208            Adcmplr1_SPEC,
8209            crate::common::RW,
8210        >::from_register(self, 0)
8211    }
8212
8213    #[doc = "Compare Window A Comparison Condition Select"]
8214    #[inline(always)]
8215    pub fn cmplcha19(
8216        self,
8217    ) -> crate::common::RegisterField<
8218        3,
8219        0x1,
8220        1,
8221        0,
8222        adcmplr1::Cmplcha19,
8223        adcmplr1::Cmplcha19,
8224        Adcmplr1_SPEC,
8225        crate::common::RW,
8226    > {
8227        crate::common::RegisterField::<
8228            3,
8229            0x1,
8230            1,
8231            0,
8232            adcmplr1::Cmplcha19,
8233            adcmplr1::Cmplcha19,
8234            Adcmplr1_SPEC,
8235            crate::common::RW,
8236        >::from_register(self, 0)
8237    }
8238
8239    #[doc = "Compare Window A Comparison Condition Select"]
8240    #[inline(always)]
8241    pub fn cmplcha20(
8242        self,
8243    ) -> crate::common::RegisterField<
8244        4,
8245        0x1,
8246        1,
8247        0,
8248        adcmplr1::Cmplcha20,
8249        adcmplr1::Cmplcha20,
8250        Adcmplr1_SPEC,
8251        crate::common::RW,
8252    > {
8253        crate::common::RegisterField::<
8254            4,
8255            0x1,
8256            1,
8257            0,
8258            adcmplr1::Cmplcha20,
8259            adcmplr1::Cmplcha20,
8260            Adcmplr1_SPEC,
8261            crate::common::RW,
8262        >::from_register(self, 0)
8263    }
8264
8265    #[doc = "Compare Window A Comparison Condition Select"]
8266    #[inline(always)]
8267    pub fn cmplcha21(
8268        self,
8269    ) -> crate::common::RegisterField<
8270        5,
8271        0x1,
8272        1,
8273        0,
8274        adcmplr1::Cmplcha21,
8275        adcmplr1::Cmplcha21,
8276        Adcmplr1_SPEC,
8277        crate::common::RW,
8278    > {
8279        crate::common::RegisterField::<
8280            5,
8281            0x1,
8282            1,
8283            0,
8284            adcmplr1::Cmplcha21,
8285            adcmplr1::Cmplcha21,
8286            Adcmplr1_SPEC,
8287            crate::common::RW,
8288        >::from_register(self, 0)
8289    }
8290
8291    #[doc = "Compare Window A Comparison Condition Select"]
8292    #[inline(always)]
8293    pub fn cmplcha22(
8294        self,
8295    ) -> crate::common::RegisterField<
8296        6,
8297        0x1,
8298        1,
8299        0,
8300        adcmplr1::Cmplcha22,
8301        adcmplr1::Cmplcha22,
8302        Adcmplr1_SPEC,
8303        crate::common::RW,
8304    > {
8305        crate::common::RegisterField::<
8306            6,
8307            0x1,
8308            1,
8309            0,
8310            adcmplr1::Cmplcha22,
8311            adcmplr1::Cmplcha22,
8312            Adcmplr1_SPEC,
8313            crate::common::RW,
8314        >::from_register(self, 0)
8315    }
8316
8317    #[doc = "Compare Window A Comparison Condition Select"]
8318    #[inline(always)]
8319    pub fn cmplcha23(
8320        self,
8321    ) -> crate::common::RegisterField<
8322        7,
8323        0x1,
8324        1,
8325        0,
8326        adcmplr1::Cmplcha23,
8327        adcmplr1::Cmplcha23,
8328        Adcmplr1_SPEC,
8329        crate::common::RW,
8330    > {
8331        crate::common::RegisterField::<
8332            7,
8333            0x1,
8334            1,
8335            0,
8336            adcmplr1::Cmplcha23,
8337            adcmplr1::Cmplcha23,
8338            Adcmplr1_SPEC,
8339            crate::common::RW,
8340        >::from_register(self, 0)
8341    }
8342
8343    #[doc = "Compare Window A Comparison Condition Select"]
8344    #[inline(always)]
8345    pub fn cmplcha24(
8346        self,
8347    ) -> crate::common::RegisterField<
8348        8,
8349        0x1,
8350        1,
8351        0,
8352        adcmplr1::Cmplcha24,
8353        adcmplr1::Cmplcha24,
8354        Adcmplr1_SPEC,
8355        crate::common::RW,
8356    > {
8357        crate::common::RegisterField::<
8358            8,
8359            0x1,
8360            1,
8361            0,
8362            adcmplr1::Cmplcha24,
8363            adcmplr1::Cmplcha24,
8364            Adcmplr1_SPEC,
8365            crate::common::RW,
8366        >::from_register(self, 0)
8367    }
8368
8369    #[doc = "Compare Window A Comparison Condition Select"]
8370    #[inline(always)]
8371    pub fn cmplcha25(
8372        self,
8373    ) -> crate::common::RegisterField<
8374        9,
8375        0x1,
8376        1,
8377        0,
8378        adcmplr1::Cmplcha25,
8379        adcmplr1::Cmplcha25,
8380        Adcmplr1_SPEC,
8381        crate::common::RW,
8382    > {
8383        crate::common::RegisterField::<
8384            9,
8385            0x1,
8386            1,
8387            0,
8388            adcmplr1::Cmplcha25,
8389            adcmplr1::Cmplcha25,
8390            Adcmplr1_SPEC,
8391            crate::common::RW,
8392        >::from_register(self, 0)
8393    }
8394
8395    #[doc = "Compare Window A Comparison Condition Select"]
8396    #[inline(always)]
8397    pub fn cmplcha26(
8398        self,
8399    ) -> crate::common::RegisterField<
8400        10,
8401        0x1,
8402        1,
8403        0,
8404        adcmplr1::Cmplcha26,
8405        adcmplr1::Cmplcha26,
8406        Adcmplr1_SPEC,
8407        crate::common::RW,
8408    > {
8409        crate::common::RegisterField::<
8410            10,
8411            0x1,
8412            1,
8413            0,
8414            adcmplr1::Cmplcha26,
8415            adcmplr1::Cmplcha26,
8416            Adcmplr1_SPEC,
8417            crate::common::RW,
8418        >::from_register(self, 0)
8419    }
8420
8421    #[doc = "Compare Window A Comparison Condition Select"]
8422    #[inline(always)]
8423    pub fn cmplcha27(
8424        self,
8425    ) -> crate::common::RegisterField<
8426        11,
8427        0x1,
8428        1,
8429        0,
8430        adcmplr1::Cmplcha27,
8431        adcmplr1::Cmplcha27,
8432        Adcmplr1_SPEC,
8433        crate::common::RW,
8434    > {
8435        crate::common::RegisterField::<
8436            11,
8437            0x1,
8438            1,
8439            0,
8440            adcmplr1::Cmplcha27,
8441            adcmplr1::Cmplcha27,
8442            Adcmplr1_SPEC,
8443            crate::common::RW,
8444        >::from_register(self, 0)
8445    }
8446
8447    #[doc = "Compare Window A Comparison Condition Select"]
8448    #[inline(always)]
8449    pub fn cmplcha28(
8450        self,
8451    ) -> crate::common::RegisterField<
8452        12,
8453        0x1,
8454        1,
8455        0,
8456        adcmplr1::Cmplcha28,
8457        adcmplr1::Cmplcha28,
8458        Adcmplr1_SPEC,
8459        crate::common::RW,
8460    > {
8461        crate::common::RegisterField::<
8462            12,
8463            0x1,
8464            1,
8465            0,
8466            adcmplr1::Cmplcha28,
8467            adcmplr1::Cmplcha28,
8468            Adcmplr1_SPEC,
8469            crate::common::RW,
8470        >::from_register(self, 0)
8471    }
8472
8473    #[doc = "Compare Window A Comparison Condition Select"]
8474    #[inline(always)]
8475    pub fn cmplcha29(
8476        self,
8477    ) -> crate::common::RegisterField<
8478        13,
8479        0x1,
8480        1,
8481        0,
8482        adcmplr1::Cmplcha29,
8483        adcmplr1::Cmplcha29,
8484        Adcmplr1_SPEC,
8485        crate::common::RW,
8486    > {
8487        crate::common::RegisterField::<
8488            13,
8489            0x1,
8490            1,
8491            0,
8492            adcmplr1::Cmplcha29,
8493            adcmplr1::Cmplcha29,
8494            Adcmplr1_SPEC,
8495            crate::common::RW,
8496        >::from_register(self, 0)
8497    }
8498
8499    #[doc = "Compare Window A Comparison Condition Select"]
8500    #[inline(always)]
8501    pub fn cmplcha30(
8502        self,
8503    ) -> crate::common::RegisterField<
8504        14,
8505        0x1,
8506        1,
8507        0,
8508        adcmplr1::Cmplcha30,
8509        adcmplr1::Cmplcha30,
8510        Adcmplr1_SPEC,
8511        crate::common::RW,
8512    > {
8513        crate::common::RegisterField::<
8514            14,
8515            0x1,
8516            1,
8517            0,
8518            adcmplr1::Cmplcha30,
8519            adcmplr1::Cmplcha30,
8520            Adcmplr1_SPEC,
8521            crate::common::RW,
8522        >::from_register(self, 0)
8523    }
8524
8525    #[doc = "Compare Window A Comparison Condition Select"]
8526    #[inline(always)]
8527    pub fn cmplcha31(
8528        self,
8529    ) -> crate::common::RegisterField<
8530        15,
8531        0x1,
8532        1,
8533        0,
8534        adcmplr1::Cmplcha31,
8535        adcmplr1::Cmplcha31,
8536        Adcmplr1_SPEC,
8537        crate::common::RW,
8538    > {
8539        crate::common::RegisterField::<
8540            15,
8541            0x1,
8542            1,
8543            0,
8544            adcmplr1::Cmplcha31,
8545            adcmplr1::Cmplcha31,
8546            Adcmplr1_SPEC,
8547            crate::common::RW,
8548        >::from_register(self, 0)
8549    }
8550}
8551impl ::core::default::Default for Adcmplr1 {
8552    #[inline(always)]
8553    fn default() -> Adcmplr1 {
8554        <crate::RegValueT<Adcmplr1_SPEC> as RegisterValue<_>>::new(0)
8555    }
8556}
8557pub mod adcmplr1 {
8558
8559    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8560    pub struct Cmplcha16_SPEC;
8561    pub type Cmplcha16 = crate::EnumBitfieldStruct<u8, Cmplcha16_SPEC>;
8562    impl Cmplcha16 {
8563        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8564        pub const _0: Self = Self::new(0);
8565
8566        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8567        pub const _1: Self = Self::new(1);
8568    }
8569    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8570    pub struct Cmplcha17_SPEC;
8571    pub type Cmplcha17 = crate::EnumBitfieldStruct<u8, Cmplcha17_SPEC>;
8572    impl Cmplcha17 {
8573        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8574        pub const _0: Self = Self::new(0);
8575
8576        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8577        pub const _1: Self = Self::new(1);
8578    }
8579    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8580    pub struct Cmplcha18_SPEC;
8581    pub type Cmplcha18 = crate::EnumBitfieldStruct<u8, Cmplcha18_SPEC>;
8582    impl Cmplcha18 {
8583        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8584        pub const _0: Self = Self::new(0);
8585
8586        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8587        pub const _1: Self = Self::new(1);
8588    }
8589    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8590    pub struct Cmplcha19_SPEC;
8591    pub type Cmplcha19 = crate::EnumBitfieldStruct<u8, Cmplcha19_SPEC>;
8592    impl Cmplcha19 {
8593        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8594        pub const _0: Self = Self::new(0);
8595
8596        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8597        pub const _1: Self = Self::new(1);
8598    }
8599    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8600    pub struct Cmplcha20_SPEC;
8601    pub type Cmplcha20 = crate::EnumBitfieldStruct<u8, Cmplcha20_SPEC>;
8602    impl Cmplcha20 {
8603        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8604        pub const _0: Self = Self::new(0);
8605
8606        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8607        pub const _1: Self = Self::new(1);
8608    }
8609    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8610    pub struct Cmplcha21_SPEC;
8611    pub type Cmplcha21 = crate::EnumBitfieldStruct<u8, Cmplcha21_SPEC>;
8612    impl Cmplcha21 {
8613        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8614        pub const _0: Self = Self::new(0);
8615
8616        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8617        pub const _1: Self = Self::new(1);
8618    }
8619    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8620    pub struct Cmplcha22_SPEC;
8621    pub type Cmplcha22 = crate::EnumBitfieldStruct<u8, Cmplcha22_SPEC>;
8622    impl Cmplcha22 {
8623        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8624        pub const _0: Self = Self::new(0);
8625
8626        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8627        pub const _1: Self = Self::new(1);
8628    }
8629    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8630    pub struct Cmplcha23_SPEC;
8631    pub type Cmplcha23 = crate::EnumBitfieldStruct<u8, Cmplcha23_SPEC>;
8632    impl Cmplcha23 {
8633        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8634        pub const _0: Self = Self::new(0);
8635
8636        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8637        pub const _1: Self = Self::new(1);
8638    }
8639    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8640    pub struct Cmplcha24_SPEC;
8641    pub type Cmplcha24 = crate::EnumBitfieldStruct<u8, Cmplcha24_SPEC>;
8642    impl Cmplcha24 {
8643        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8644        pub const _0: Self = Self::new(0);
8645
8646        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8647        pub const _1: Self = Self::new(1);
8648    }
8649    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8650    pub struct Cmplcha25_SPEC;
8651    pub type Cmplcha25 = crate::EnumBitfieldStruct<u8, Cmplcha25_SPEC>;
8652    impl Cmplcha25 {
8653        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8654        pub const _0: Self = Self::new(0);
8655
8656        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8657        pub const _1: Self = Self::new(1);
8658    }
8659    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8660    pub struct Cmplcha26_SPEC;
8661    pub type Cmplcha26 = crate::EnumBitfieldStruct<u8, Cmplcha26_SPEC>;
8662    impl Cmplcha26 {
8663        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8664        pub const _0: Self = Self::new(0);
8665
8666        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8667        pub const _1: Self = Self::new(1);
8668    }
8669    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8670    pub struct Cmplcha27_SPEC;
8671    pub type Cmplcha27 = crate::EnumBitfieldStruct<u8, Cmplcha27_SPEC>;
8672    impl Cmplcha27 {
8673        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8674        pub const _0: Self = Self::new(0);
8675
8676        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8677        pub const _1: Self = Self::new(1);
8678    }
8679    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8680    pub struct Cmplcha28_SPEC;
8681    pub type Cmplcha28 = crate::EnumBitfieldStruct<u8, Cmplcha28_SPEC>;
8682    impl Cmplcha28 {
8683        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8684        pub const _0: Self = Self::new(0);
8685
8686        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8687        pub const _1: Self = Self::new(1);
8688    }
8689    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8690    pub struct Cmplcha29_SPEC;
8691    pub type Cmplcha29 = crate::EnumBitfieldStruct<u8, Cmplcha29_SPEC>;
8692    impl Cmplcha29 {
8693        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8694        pub const _0: Self = Self::new(0);
8695
8696        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8697        pub const _1: Self = Self::new(1);
8698    }
8699    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8700    pub struct Cmplcha30_SPEC;
8701    pub type Cmplcha30 = crate::EnumBitfieldStruct<u8, Cmplcha30_SPEC>;
8702    impl Cmplcha30 {
8703        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8704        pub const _0: Self = Self::new(0);
8705
8706        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8707        pub const _1: Self = Self::new(1);
8708    }
8709    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
8710    pub struct Cmplcha31_SPEC;
8711    pub type Cmplcha31 = crate::EnumBitfieldStruct<u8, Cmplcha31_SPEC>;
8712    impl Cmplcha31 {
8713        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADCMPDR0 value, or ADCMPDR1 value < A/D-converted value"]
8714        pub const _0: Self = Self::new(0);
8715
8716        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADCMPDR0 value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADCMPDR0 value < A/D-converted value < ADCMPDR1 value"]
8717        pub const _1: Self = Self::new(1);
8718    }
8719}
8720#[doc(hidden)]
8721#[derive(Copy, Clone, Eq, PartialEq)]
8722pub struct Adcmpdr_SPEC;
8723impl crate::sealed::RegSpec for Adcmpdr_SPEC {
8724    type DataType = u16;
8725}
8726
8727#[doc = "A/D Compare Function Window A Lower-Side/Upper-Side Level Setting Register"]
8728pub type Adcmpdr = crate::RegValueT<Adcmpdr_SPEC>;
8729
8730impl NoBitfieldReg<Adcmpdr_SPEC> for Adcmpdr {}
8731impl ::core::default::Default for Adcmpdr {
8732    #[inline(always)]
8733    fn default() -> Adcmpdr {
8734        <crate::RegValueT<Adcmpdr_SPEC> as RegisterValue<_>>::new(0)
8735    }
8736}
8737
8738#[doc(hidden)]
8739#[derive(Copy, Clone, Eq, PartialEq)]
8740pub struct Adcmpsr0_SPEC;
8741impl crate::sealed::RegSpec for Adcmpsr0_SPEC {
8742    type DataType = u16;
8743}
8744
8745#[doc = "A/D Compare Function Window A Channel Status Register 0"]
8746pub type Adcmpsr0 = crate::RegValueT<Adcmpsr0_SPEC>;
8747
8748impl Adcmpsr0 {
8749    #[doc = "Compare Window A Flag"]
8750    #[inline(always)]
8751    pub fn cmpstcha00(
8752        self,
8753    ) -> crate::common::RegisterField<
8754        0,
8755        0x1,
8756        1,
8757        0,
8758        adcmpsr0::Cmpstcha00,
8759        adcmpsr0::Cmpstcha00,
8760        Adcmpsr0_SPEC,
8761        crate::common::RW,
8762    > {
8763        crate::common::RegisterField::<
8764            0,
8765            0x1,
8766            1,
8767            0,
8768            adcmpsr0::Cmpstcha00,
8769            adcmpsr0::Cmpstcha00,
8770            Adcmpsr0_SPEC,
8771            crate::common::RW,
8772        >::from_register(self, 0)
8773    }
8774
8775    #[doc = "Compare Window A Flag"]
8776    #[inline(always)]
8777    pub fn cmpstcha01(
8778        self,
8779    ) -> crate::common::RegisterField<
8780        1,
8781        0x1,
8782        1,
8783        0,
8784        adcmpsr0::Cmpstcha01,
8785        adcmpsr0::Cmpstcha01,
8786        Adcmpsr0_SPEC,
8787        crate::common::RW,
8788    > {
8789        crate::common::RegisterField::<
8790            1,
8791            0x1,
8792            1,
8793            0,
8794            adcmpsr0::Cmpstcha01,
8795            adcmpsr0::Cmpstcha01,
8796            Adcmpsr0_SPEC,
8797            crate::common::RW,
8798        >::from_register(self, 0)
8799    }
8800
8801    #[doc = "Compare Window A Flag"]
8802    #[inline(always)]
8803    pub fn cmpstcha02(
8804        self,
8805    ) -> crate::common::RegisterField<
8806        2,
8807        0x1,
8808        1,
8809        0,
8810        adcmpsr0::Cmpstcha02,
8811        adcmpsr0::Cmpstcha02,
8812        Adcmpsr0_SPEC,
8813        crate::common::RW,
8814    > {
8815        crate::common::RegisterField::<
8816            2,
8817            0x1,
8818            1,
8819            0,
8820            adcmpsr0::Cmpstcha02,
8821            adcmpsr0::Cmpstcha02,
8822            Adcmpsr0_SPEC,
8823            crate::common::RW,
8824        >::from_register(self, 0)
8825    }
8826
8827    #[doc = "Compare Window A Flag"]
8828    #[inline(always)]
8829    pub fn cmpstcha03(
8830        self,
8831    ) -> crate::common::RegisterField<
8832        3,
8833        0x1,
8834        1,
8835        0,
8836        adcmpsr0::Cmpstcha03,
8837        adcmpsr0::Cmpstcha03,
8838        Adcmpsr0_SPEC,
8839        crate::common::RW,
8840    > {
8841        crate::common::RegisterField::<
8842            3,
8843            0x1,
8844            1,
8845            0,
8846            adcmpsr0::Cmpstcha03,
8847            adcmpsr0::Cmpstcha03,
8848            Adcmpsr0_SPEC,
8849            crate::common::RW,
8850        >::from_register(self, 0)
8851    }
8852
8853    #[doc = "Compare Window A Flag"]
8854    #[inline(always)]
8855    pub fn cmpstcha04(
8856        self,
8857    ) -> crate::common::RegisterField<
8858        4,
8859        0x1,
8860        1,
8861        0,
8862        adcmpsr0::Cmpstcha04,
8863        adcmpsr0::Cmpstcha04,
8864        Adcmpsr0_SPEC,
8865        crate::common::RW,
8866    > {
8867        crate::common::RegisterField::<
8868            4,
8869            0x1,
8870            1,
8871            0,
8872            adcmpsr0::Cmpstcha04,
8873            adcmpsr0::Cmpstcha04,
8874            Adcmpsr0_SPEC,
8875            crate::common::RW,
8876        >::from_register(self, 0)
8877    }
8878
8879    #[doc = "Compare Window A Flag"]
8880    #[inline(always)]
8881    pub fn cmpstcha05(
8882        self,
8883    ) -> crate::common::RegisterField<
8884        5,
8885        0x1,
8886        1,
8887        0,
8888        adcmpsr0::Cmpstcha05,
8889        adcmpsr0::Cmpstcha05,
8890        Adcmpsr0_SPEC,
8891        crate::common::RW,
8892    > {
8893        crate::common::RegisterField::<
8894            5,
8895            0x1,
8896            1,
8897            0,
8898            adcmpsr0::Cmpstcha05,
8899            adcmpsr0::Cmpstcha05,
8900            Adcmpsr0_SPEC,
8901            crate::common::RW,
8902        >::from_register(self, 0)
8903    }
8904
8905    #[doc = "Compare Window A Flag"]
8906    #[inline(always)]
8907    pub fn cmpstcha06(
8908        self,
8909    ) -> crate::common::RegisterField<
8910        6,
8911        0x1,
8912        1,
8913        0,
8914        adcmpsr0::Cmpstcha06,
8915        adcmpsr0::Cmpstcha06,
8916        Adcmpsr0_SPEC,
8917        crate::common::RW,
8918    > {
8919        crate::common::RegisterField::<
8920            6,
8921            0x1,
8922            1,
8923            0,
8924            adcmpsr0::Cmpstcha06,
8925            adcmpsr0::Cmpstcha06,
8926            Adcmpsr0_SPEC,
8927            crate::common::RW,
8928        >::from_register(self, 0)
8929    }
8930
8931    #[doc = "Compare Window A Flag"]
8932    #[inline(always)]
8933    pub fn cmpstcha07(
8934        self,
8935    ) -> crate::common::RegisterField<
8936        7,
8937        0x1,
8938        1,
8939        0,
8940        adcmpsr0::Cmpstcha07,
8941        adcmpsr0::Cmpstcha07,
8942        Adcmpsr0_SPEC,
8943        crate::common::RW,
8944    > {
8945        crate::common::RegisterField::<
8946            7,
8947            0x1,
8948            1,
8949            0,
8950            adcmpsr0::Cmpstcha07,
8951            adcmpsr0::Cmpstcha07,
8952            Adcmpsr0_SPEC,
8953            crate::common::RW,
8954        >::from_register(self, 0)
8955    }
8956
8957    #[doc = "Compare Window A Flag"]
8958    #[inline(always)]
8959    pub fn cmpstcha08(
8960        self,
8961    ) -> crate::common::RegisterField<
8962        8,
8963        0x1,
8964        1,
8965        0,
8966        adcmpsr0::Cmpstcha08,
8967        adcmpsr0::Cmpstcha08,
8968        Adcmpsr0_SPEC,
8969        crate::common::RW,
8970    > {
8971        crate::common::RegisterField::<
8972            8,
8973            0x1,
8974            1,
8975            0,
8976            adcmpsr0::Cmpstcha08,
8977            adcmpsr0::Cmpstcha08,
8978            Adcmpsr0_SPEC,
8979            crate::common::RW,
8980        >::from_register(self, 0)
8981    }
8982
8983    #[doc = "Compare Window A Flag"]
8984    #[inline(always)]
8985    pub fn cmpstcha09(
8986        self,
8987    ) -> crate::common::RegisterField<
8988        9,
8989        0x1,
8990        1,
8991        0,
8992        adcmpsr0::Cmpstcha09,
8993        adcmpsr0::Cmpstcha09,
8994        Adcmpsr0_SPEC,
8995        crate::common::RW,
8996    > {
8997        crate::common::RegisterField::<
8998            9,
8999            0x1,
9000            1,
9001            0,
9002            adcmpsr0::Cmpstcha09,
9003            adcmpsr0::Cmpstcha09,
9004            Adcmpsr0_SPEC,
9005            crate::common::RW,
9006        >::from_register(self, 0)
9007    }
9008
9009    #[doc = "Compare Window A Flag"]
9010    #[inline(always)]
9011    pub fn cmpstcha10(
9012        self,
9013    ) -> crate::common::RegisterField<
9014        10,
9015        0x1,
9016        1,
9017        0,
9018        adcmpsr0::Cmpstcha10,
9019        adcmpsr0::Cmpstcha10,
9020        Adcmpsr0_SPEC,
9021        crate::common::RW,
9022    > {
9023        crate::common::RegisterField::<
9024            10,
9025            0x1,
9026            1,
9027            0,
9028            adcmpsr0::Cmpstcha10,
9029            adcmpsr0::Cmpstcha10,
9030            Adcmpsr0_SPEC,
9031            crate::common::RW,
9032        >::from_register(self, 0)
9033    }
9034
9035    #[doc = "Compare Window A Flag"]
9036    #[inline(always)]
9037    pub fn cmpstcha11(
9038        self,
9039    ) -> crate::common::RegisterField<
9040        11,
9041        0x1,
9042        1,
9043        0,
9044        adcmpsr0::Cmpstcha11,
9045        adcmpsr0::Cmpstcha11,
9046        Adcmpsr0_SPEC,
9047        crate::common::RW,
9048    > {
9049        crate::common::RegisterField::<
9050            11,
9051            0x1,
9052            1,
9053            0,
9054            adcmpsr0::Cmpstcha11,
9055            adcmpsr0::Cmpstcha11,
9056            Adcmpsr0_SPEC,
9057            crate::common::RW,
9058        >::from_register(self, 0)
9059    }
9060
9061    #[doc = "Compare Window A Flag"]
9062    #[inline(always)]
9063    pub fn cmpstcha12(
9064        self,
9065    ) -> crate::common::RegisterField<
9066        12,
9067        0x1,
9068        1,
9069        0,
9070        adcmpsr0::Cmpstcha12,
9071        adcmpsr0::Cmpstcha12,
9072        Adcmpsr0_SPEC,
9073        crate::common::RW,
9074    > {
9075        crate::common::RegisterField::<
9076            12,
9077            0x1,
9078            1,
9079            0,
9080            adcmpsr0::Cmpstcha12,
9081            adcmpsr0::Cmpstcha12,
9082            Adcmpsr0_SPEC,
9083            crate::common::RW,
9084        >::from_register(self, 0)
9085    }
9086
9087    #[doc = "Compare Window A Flag"]
9088    #[inline(always)]
9089    pub fn cmpstcha13(
9090        self,
9091    ) -> crate::common::RegisterField<
9092        13,
9093        0x1,
9094        1,
9095        0,
9096        adcmpsr0::Cmpstcha13,
9097        adcmpsr0::Cmpstcha13,
9098        Adcmpsr0_SPEC,
9099        crate::common::RW,
9100    > {
9101        crate::common::RegisterField::<
9102            13,
9103            0x1,
9104            1,
9105            0,
9106            adcmpsr0::Cmpstcha13,
9107            adcmpsr0::Cmpstcha13,
9108            Adcmpsr0_SPEC,
9109            crate::common::RW,
9110        >::from_register(self, 0)
9111    }
9112
9113    #[doc = "Compare Window A Flag"]
9114    #[inline(always)]
9115    pub fn cmpstcha14(
9116        self,
9117    ) -> crate::common::RegisterField<
9118        14,
9119        0x1,
9120        1,
9121        0,
9122        adcmpsr0::Cmpstcha14,
9123        adcmpsr0::Cmpstcha14,
9124        Adcmpsr0_SPEC,
9125        crate::common::RW,
9126    > {
9127        crate::common::RegisterField::<
9128            14,
9129            0x1,
9130            1,
9131            0,
9132            adcmpsr0::Cmpstcha14,
9133            adcmpsr0::Cmpstcha14,
9134            Adcmpsr0_SPEC,
9135            crate::common::RW,
9136        >::from_register(self, 0)
9137    }
9138
9139    #[doc = "Compare Window A Flag"]
9140    #[inline(always)]
9141    pub fn cmpstcha15(
9142        self,
9143    ) -> crate::common::RegisterField<
9144        15,
9145        0x1,
9146        1,
9147        0,
9148        adcmpsr0::Cmpstcha15,
9149        adcmpsr0::Cmpstcha15,
9150        Adcmpsr0_SPEC,
9151        crate::common::RW,
9152    > {
9153        crate::common::RegisterField::<
9154            15,
9155            0x1,
9156            1,
9157            0,
9158            adcmpsr0::Cmpstcha15,
9159            adcmpsr0::Cmpstcha15,
9160            Adcmpsr0_SPEC,
9161            crate::common::RW,
9162        >::from_register(self, 0)
9163    }
9164}
9165impl ::core::default::Default for Adcmpsr0 {
9166    #[inline(always)]
9167    fn default() -> Adcmpsr0 {
9168        <crate::RegValueT<Adcmpsr0_SPEC> as RegisterValue<_>>::new(0)
9169    }
9170}
9171pub mod adcmpsr0 {
9172
9173    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9174    pub struct Cmpstcha00_SPEC;
9175    pub type Cmpstcha00 = crate::EnumBitfieldStruct<u8, Cmpstcha00_SPEC>;
9176    impl Cmpstcha00 {
9177        #[doc = "Comparison conditions are not met."]
9178        pub const _0: Self = Self::new(0);
9179
9180        #[doc = "Comparison conditions are met."]
9181        pub const _1: Self = Self::new(1);
9182    }
9183    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9184    pub struct Cmpstcha01_SPEC;
9185    pub type Cmpstcha01 = crate::EnumBitfieldStruct<u8, Cmpstcha01_SPEC>;
9186    impl Cmpstcha01 {
9187        #[doc = "Comparison conditions are not met."]
9188        pub const _0: Self = Self::new(0);
9189
9190        #[doc = "Comparison conditions are met."]
9191        pub const _1: Self = Self::new(1);
9192    }
9193    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9194    pub struct Cmpstcha02_SPEC;
9195    pub type Cmpstcha02 = crate::EnumBitfieldStruct<u8, Cmpstcha02_SPEC>;
9196    impl Cmpstcha02 {
9197        #[doc = "Comparison conditions are not met."]
9198        pub const _0: Self = Self::new(0);
9199
9200        #[doc = "Comparison conditions are met."]
9201        pub const _1: Self = Self::new(1);
9202    }
9203    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9204    pub struct Cmpstcha03_SPEC;
9205    pub type Cmpstcha03 = crate::EnumBitfieldStruct<u8, Cmpstcha03_SPEC>;
9206    impl Cmpstcha03 {
9207        #[doc = "Comparison conditions are not met."]
9208        pub const _0: Self = Self::new(0);
9209
9210        #[doc = "Comparison conditions are met."]
9211        pub const _1: Self = Self::new(1);
9212    }
9213    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9214    pub struct Cmpstcha04_SPEC;
9215    pub type Cmpstcha04 = crate::EnumBitfieldStruct<u8, Cmpstcha04_SPEC>;
9216    impl Cmpstcha04 {
9217        #[doc = "Comparison conditions are not met."]
9218        pub const _0: Self = Self::new(0);
9219
9220        #[doc = "Comparison conditions are met."]
9221        pub const _1: Self = Self::new(1);
9222    }
9223    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9224    pub struct Cmpstcha05_SPEC;
9225    pub type Cmpstcha05 = crate::EnumBitfieldStruct<u8, Cmpstcha05_SPEC>;
9226    impl Cmpstcha05 {
9227        #[doc = "Comparison conditions are not met."]
9228        pub const _0: Self = Self::new(0);
9229
9230        #[doc = "Comparison conditions are met."]
9231        pub const _1: Self = Self::new(1);
9232    }
9233    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9234    pub struct Cmpstcha06_SPEC;
9235    pub type Cmpstcha06 = crate::EnumBitfieldStruct<u8, Cmpstcha06_SPEC>;
9236    impl Cmpstcha06 {
9237        #[doc = "Comparison conditions are not met."]
9238        pub const _0: Self = Self::new(0);
9239
9240        #[doc = "Comparison conditions are met."]
9241        pub const _1: Self = Self::new(1);
9242    }
9243    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9244    pub struct Cmpstcha07_SPEC;
9245    pub type Cmpstcha07 = crate::EnumBitfieldStruct<u8, Cmpstcha07_SPEC>;
9246    impl Cmpstcha07 {
9247        #[doc = "Comparison conditions are not met."]
9248        pub const _0: Self = Self::new(0);
9249
9250        #[doc = "Comparison conditions are met."]
9251        pub const _1: Self = Self::new(1);
9252    }
9253    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9254    pub struct Cmpstcha08_SPEC;
9255    pub type Cmpstcha08 = crate::EnumBitfieldStruct<u8, Cmpstcha08_SPEC>;
9256    impl Cmpstcha08 {
9257        #[doc = "Comparison conditions are not met."]
9258        pub const _0: Self = Self::new(0);
9259
9260        #[doc = "Comparison conditions are met."]
9261        pub const _1: Self = Self::new(1);
9262    }
9263    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9264    pub struct Cmpstcha09_SPEC;
9265    pub type Cmpstcha09 = crate::EnumBitfieldStruct<u8, Cmpstcha09_SPEC>;
9266    impl Cmpstcha09 {
9267        #[doc = "Comparison conditions are not met."]
9268        pub const _0: Self = Self::new(0);
9269
9270        #[doc = "Comparison conditions are met."]
9271        pub const _1: Self = Self::new(1);
9272    }
9273    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9274    pub struct Cmpstcha10_SPEC;
9275    pub type Cmpstcha10 = crate::EnumBitfieldStruct<u8, Cmpstcha10_SPEC>;
9276    impl Cmpstcha10 {
9277        #[doc = "Comparison conditions are not met."]
9278        pub const _0: Self = Self::new(0);
9279
9280        #[doc = "Comparison conditions are met."]
9281        pub const _1: Self = Self::new(1);
9282    }
9283    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9284    pub struct Cmpstcha11_SPEC;
9285    pub type Cmpstcha11 = crate::EnumBitfieldStruct<u8, Cmpstcha11_SPEC>;
9286    impl Cmpstcha11 {
9287        #[doc = "Comparison conditions are not met."]
9288        pub const _0: Self = Self::new(0);
9289
9290        #[doc = "Comparison conditions are met."]
9291        pub const _1: Self = Self::new(1);
9292    }
9293    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9294    pub struct Cmpstcha12_SPEC;
9295    pub type Cmpstcha12 = crate::EnumBitfieldStruct<u8, Cmpstcha12_SPEC>;
9296    impl Cmpstcha12 {
9297        #[doc = "Comparison conditions are not met."]
9298        pub const _0: Self = Self::new(0);
9299
9300        #[doc = "Comparison conditions are met."]
9301        pub const _1: Self = Self::new(1);
9302    }
9303    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9304    pub struct Cmpstcha13_SPEC;
9305    pub type Cmpstcha13 = crate::EnumBitfieldStruct<u8, Cmpstcha13_SPEC>;
9306    impl Cmpstcha13 {
9307        #[doc = "Comparison conditions are not met."]
9308        pub const _0: Self = Self::new(0);
9309
9310        #[doc = "Comparison conditions are met."]
9311        pub const _1: Self = Self::new(1);
9312    }
9313    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9314    pub struct Cmpstcha14_SPEC;
9315    pub type Cmpstcha14 = crate::EnumBitfieldStruct<u8, Cmpstcha14_SPEC>;
9316    impl Cmpstcha14 {
9317        #[doc = "Comparison conditions are not met."]
9318        pub const _0: Self = Self::new(0);
9319
9320        #[doc = "Comparison conditions are met."]
9321        pub const _1: Self = Self::new(1);
9322    }
9323    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9324    pub struct Cmpstcha15_SPEC;
9325    pub type Cmpstcha15 = crate::EnumBitfieldStruct<u8, Cmpstcha15_SPEC>;
9326    impl Cmpstcha15 {
9327        #[doc = "Comparison conditions are not met."]
9328        pub const _0: Self = Self::new(0);
9329
9330        #[doc = "Comparison conditions are met."]
9331        pub const _1: Self = Self::new(1);
9332    }
9333}
9334#[doc(hidden)]
9335#[derive(Copy, Clone, Eq, PartialEq)]
9336pub struct Adcmpsr1_SPEC;
9337impl crate::sealed::RegSpec for Adcmpsr1_SPEC {
9338    type DataType = u16;
9339}
9340
9341#[doc = "A/D Compare Function Window A Channel Status Register1"]
9342pub type Adcmpsr1 = crate::RegValueT<Adcmpsr1_SPEC>;
9343
9344impl Adcmpsr1 {
9345    #[doc = "Compare Window A Flag"]
9346    #[inline(always)]
9347    pub fn cmpstcha16(
9348        self,
9349    ) -> crate::common::RegisterField<
9350        0,
9351        0x1,
9352        1,
9353        0,
9354        adcmpsr1::Cmpstcha16,
9355        adcmpsr1::Cmpstcha16,
9356        Adcmpsr1_SPEC,
9357        crate::common::RW,
9358    > {
9359        crate::common::RegisterField::<
9360            0,
9361            0x1,
9362            1,
9363            0,
9364            adcmpsr1::Cmpstcha16,
9365            adcmpsr1::Cmpstcha16,
9366            Adcmpsr1_SPEC,
9367            crate::common::RW,
9368        >::from_register(self, 0)
9369    }
9370
9371    #[doc = "Compare Window A Flag"]
9372    #[inline(always)]
9373    pub fn cmpstcha17(
9374        self,
9375    ) -> crate::common::RegisterField<
9376        1,
9377        0x1,
9378        1,
9379        0,
9380        adcmpsr1::Cmpstcha17,
9381        adcmpsr1::Cmpstcha17,
9382        Adcmpsr1_SPEC,
9383        crate::common::RW,
9384    > {
9385        crate::common::RegisterField::<
9386            1,
9387            0x1,
9388            1,
9389            0,
9390            adcmpsr1::Cmpstcha17,
9391            adcmpsr1::Cmpstcha17,
9392            Adcmpsr1_SPEC,
9393            crate::common::RW,
9394        >::from_register(self, 0)
9395    }
9396
9397    #[doc = "Compare Window A Flag"]
9398    #[inline(always)]
9399    pub fn cmpstcha18(
9400        self,
9401    ) -> crate::common::RegisterField<
9402        2,
9403        0x1,
9404        1,
9405        0,
9406        adcmpsr1::Cmpstcha18,
9407        adcmpsr1::Cmpstcha18,
9408        Adcmpsr1_SPEC,
9409        crate::common::RW,
9410    > {
9411        crate::common::RegisterField::<
9412            2,
9413            0x1,
9414            1,
9415            0,
9416            adcmpsr1::Cmpstcha18,
9417            adcmpsr1::Cmpstcha18,
9418            Adcmpsr1_SPEC,
9419            crate::common::RW,
9420        >::from_register(self, 0)
9421    }
9422
9423    #[doc = "Compare Window A Flag"]
9424    #[inline(always)]
9425    pub fn cmpstcha19(
9426        self,
9427    ) -> crate::common::RegisterField<
9428        3,
9429        0x1,
9430        1,
9431        0,
9432        adcmpsr1::Cmpstcha19,
9433        adcmpsr1::Cmpstcha19,
9434        Adcmpsr1_SPEC,
9435        crate::common::RW,
9436    > {
9437        crate::common::RegisterField::<
9438            3,
9439            0x1,
9440            1,
9441            0,
9442            adcmpsr1::Cmpstcha19,
9443            adcmpsr1::Cmpstcha19,
9444            Adcmpsr1_SPEC,
9445            crate::common::RW,
9446        >::from_register(self, 0)
9447    }
9448
9449    #[doc = "Compare Window A Flag"]
9450    #[inline(always)]
9451    pub fn cmpstcha20(
9452        self,
9453    ) -> crate::common::RegisterField<
9454        4,
9455        0x1,
9456        1,
9457        0,
9458        adcmpsr1::Cmpstcha20,
9459        adcmpsr1::Cmpstcha20,
9460        Adcmpsr1_SPEC,
9461        crate::common::RW,
9462    > {
9463        crate::common::RegisterField::<
9464            4,
9465            0x1,
9466            1,
9467            0,
9468            adcmpsr1::Cmpstcha20,
9469            adcmpsr1::Cmpstcha20,
9470            Adcmpsr1_SPEC,
9471            crate::common::RW,
9472        >::from_register(self, 0)
9473    }
9474
9475    #[doc = "Compare Window A Flag"]
9476    #[inline(always)]
9477    pub fn cmpstcha21(
9478        self,
9479    ) -> crate::common::RegisterField<
9480        5,
9481        0x1,
9482        1,
9483        0,
9484        adcmpsr1::Cmpstcha21,
9485        adcmpsr1::Cmpstcha21,
9486        Adcmpsr1_SPEC,
9487        crate::common::RW,
9488    > {
9489        crate::common::RegisterField::<
9490            5,
9491            0x1,
9492            1,
9493            0,
9494            adcmpsr1::Cmpstcha21,
9495            adcmpsr1::Cmpstcha21,
9496            Adcmpsr1_SPEC,
9497            crate::common::RW,
9498        >::from_register(self, 0)
9499    }
9500
9501    #[doc = "Compare Window A Flag"]
9502    #[inline(always)]
9503    pub fn cmpstcha22(
9504        self,
9505    ) -> crate::common::RegisterField<
9506        6,
9507        0x1,
9508        1,
9509        0,
9510        adcmpsr1::Cmpstcha22,
9511        adcmpsr1::Cmpstcha22,
9512        Adcmpsr1_SPEC,
9513        crate::common::RW,
9514    > {
9515        crate::common::RegisterField::<
9516            6,
9517            0x1,
9518            1,
9519            0,
9520            adcmpsr1::Cmpstcha22,
9521            adcmpsr1::Cmpstcha22,
9522            Adcmpsr1_SPEC,
9523            crate::common::RW,
9524        >::from_register(self, 0)
9525    }
9526
9527    #[doc = "Compare Window A Flag"]
9528    #[inline(always)]
9529    pub fn cmpstcha23(
9530        self,
9531    ) -> crate::common::RegisterField<
9532        7,
9533        0x1,
9534        1,
9535        0,
9536        adcmpsr1::Cmpstcha23,
9537        adcmpsr1::Cmpstcha23,
9538        Adcmpsr1_SPEC,
9539        crate::common::RW,
9540    > {
9541        crate::common::RegisterField::<
9542            7,
9543            0x1,
9544            1,
9545            0,
9546            adcmpsr1::Cmpstcha23,
9547            adcmpsr1::Cmpstcha23,
9548            Adcmpsr1_SPEC,
9549            crate::common::RW,
9550        >::from_register(self, 0)
9551    }
9552
9553    #[doc = "Compare Window A Flag"]
9554    #[inline(always)]
9555    pub fn cmpstcha24(
9556        self,
9557    ) -> crate::common::RegisterField<
9558        8,
9559        0x1,
9560        1,
9561        0,
9562        adcmpsr1::Cmpstcha24,
9563        adcmpsr1::Cmpstcha24,
9564        Adcmpsr1_SPEC,
9565        crate::common::RW,
9566    > {
9567        crate::common::RegisterField::<
9568            8,
9569            0x1,
9570            1,
9571            0,
9572            adcmpsr1::Cmpstcha24,
9573            adcmpsr1::Cmpstcha24,
9574            Adcmpsr1_SPEC,
9575            crate::common::RW,
9576        >::from_register(self, 0)
9577    }
9578
9579    #[doc = "Compare Window A Flag"]
9580    #[inline(always)]
9581    pub fn cmpstcha25(
9582        self,
9583    ) -> crate::common::RegisterField<
9584        9,
9585        0x1,
9586        1,
9587        0,
9588        adcmpsr1::Cmpstcha25,
9589        adcmpsr1::Cmpstcha25,
9590        Adcmpsr1_SPEC,
9591        crate::common::RW,
9592    > {
9593        crate::common::RegisterField::<
9594            9,
9595            0x1,
9596            1,
9597            0,
9598            adcmpsr1::Cmpstcha25,
9599            adcmpsr1::Cmpstcha25,
9600            Adcmpsr1_SPEC,
9601            crate::common::RW,
9602        >::from_register(self, 0)
9603    }
9604
9605    #[doc = "Compare Window A Flag"]
9606    #[inline(always)]
9607    pub fn cmpstcha26(
9608        self,
9609    ) -> crate::common::RegisterField<
9610        10,
9611        0x1,
9612        1,
9613        0,
9614        adcmpsr1::Cmpstcha26,
9615        adcmpsr1::Cmpstcha26,
9616        Adcmpsr1_SPEC,
9617        crate::common::RW,
9618    > {
9619        crate::common::RegisterField::<
9620            10,
9621            0x1,
9622            1,
9623            0,
9624            adcmpsr1::Cmpstcha26,
9625            adcmpsr1::Cmpstcha26,
9626            Adcmpsr1_SPEC,
9627            crate::common::RW,
9628        >::from_register(self, 0)
9629    }
9630
9631    #[doc = "Compare Window A Flag"]
9632    #[inline(always)]
9633    pub fn cmpstcha27(
9634        self,
9635    ) -> crate::common::RegisterField<
9636        11,
9637        0x1,
9638        1,
9639        0,
9640        adcmpsr1::Cmpstcha27,
9641        adcmpsr1::Cmpstcha27,
9642        Adcmpsr1_SPEC,
9643        crate::common::RW,
9644    > {
9645        crate::common::RegisterField::<
9646            11,
9647            0x1,
9648            1,
9649            0,
9650            adcmpsr1::Cmpstcha27,
9651            adcmpsr1::Cmpstcha27,
9652            Adcmpsr1_SPEC,
9653            crate::common::RW,
9654        >::from_register(self, 0)
9655    }
9656
9657    #[doc = "Compare Window A Flag"]
9658    #[inline(always)]
9659    pub fn cmpstcha28(
9660        self,
9661    ) -> crate::common::RegisterField<
9662        12,
9663        0x1,
9664        1,
9665        0,
9666        adcmpsr1::Cmpstcha28,
9667        adcmpsr1::Cmpstcha28,
9668        Adcmpsr1_SPEC,
9669        crate::common::RW,
9670    > {
9671        crate::common::RegisterField::<
9672            12,
9673            0x1,
9674            1,
9675            0,
9676            adcmpsr1::Cmpstcha28,
9677            adcmpsr1::Cmpstcha28,
9678            Adcmpsr1_SPEC,
9679            crate::common::RW,
9680        >::from_register(self, 0)
9681    }
9682
9683    #[doc = "Compare Window A Flag"]
9684    #[inline(always)]
9685    pub fn cmpstcha29(
9686        self,
9687    ) -> crate::common::RegisterField<
9688        13,
9689        0x1,
9690        1,
9691        0,
9692        adcmpsr1::Cmpstcha29,
9693        adcmpsr1::Cmpstcha29,
9694        Adcmpsr1_SPEC,
9695        crate::common::RW,
9696    > {
9697        crate::common::RegisterField::<
9698            13,
9699            0x1,
9700            1,
9701            0,
9702            adcmpsr1::Cmpstcha29,
9703            adcmpsr1::Cmpstcha29,
9704            Adcmpsr1_SPEC,
9705            crate::common::RW,
9706        >::from_register(self, 0)
9707    }
9708
9709    #[doc = "Compare Window A Flag"]
9710    #[inline(always)]
9711    pub fn cmpstcha30(
9712        self,
9713    ) -> crate::common::RegisterField<
9714        14,
9715        0x1,
9716        1,
9717        0,
9718        adcmpsr1::Cmpstcha30,
9719        adcmpsr1::Cmpstcha30,
9720        Adcmpsr1_SPEC,
9721        crate::common::RW,
9722    > {
9723        crate::common::RegisterField::<
9724            14,
9725            0x1,
9726            1,
9727            0,
9728            adcmpsr1::Cmpstcha30,
9729            adcmpsr1::Cmpstcha30,
9730            Adcmpsr1_SPEC,
9731            crate::common::RW,
9732        >::from_register(self, 0)
9733    }
9734
9735    #[doc = "Compare Window A Flag"]
9736    #[inline(always)]
9737    pub fn cmpstcha31(
9738        self,
9739    ) -> crate::common::RegisterField<
9740        15,
9741        0x1,
9742        1,
9743        0,
9744        adcmpsr1::Cmpstcha31,
9745        adcmpsr1::Cmpstcha31,
9746        Adcmpsr1_SPEC,
9747        crate::common::RW,
9748    > {
9749        crate::common::RegisterField::<
9750            15,
9751            0x1,
9752            1,
9753            0,
9754            adcmpsr1::Cmpstcha31,
9755            adcmpsr1::Cmpstcha31,
9756            Adcmpsr1_SPEC,
9757            crate::common::RW,
9758        >::from_register(self, 0)
9759    }
9760}
9761impl ::core::default::Default for Adcmpsr1 {
9762    #[inline(always)]
9763    fn default() -> Adcmpsr1 {
9764        <crate::RegValueT<Adcmpsr1_SPEC> as RegisterValue<_>>::new(0)
9765    }
9766}
9767pub mod adcmpsr1 {
9768
9769    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9770    pub struct Cmpstcha16_SPEC;
9771    pub type Cmpstcha16 = crate::EnumBitfieldStruct<u8, Cmpstcha16_SPEC>;
9772    impl Cmpstcha16 {
9773        #[doc = "Comparison conditions are not met."]
9774        pub const _0: Self = Self::new(0);
9775
9776        #[doc = "Comparison conditions are met."]
9777        pub const _1: Self = Self::new(1);
9778    }
9779    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9780    pub struct Cmpstcha17_SPEC;
9781    pub type Cmpstcha17 = crate::EnumBitfieldStruct<u8, Cmpstcha17_SPEC>;
9782    impl Cmpstcha17 {
9783        #[doc = "Comparison conditions are not met."]
9784        pub const _0: Self = Self::new(0);
9785
9786        #[doc = "Comparison conditions are met."]
9787        pub const _1: Self = Self::new(1);
9788    }
9789    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9790    pub struct Cmpstcha18_SPEC;
9791    pub type Cmpstcha18 = crate::EnumBitfieldStruct<u8, Cmpstcha18_SPEC>;
9792    impl Cmpstcha18 {
9793        #[doc = "Comparison conditions are not met."]
9794        pub const _0: Self = Self::new(0);
9795
9796        #[doc = "Comparison conditions are met."]
9797        pub const _1: Self = Self::new(1);
9798    }
9799    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9800    pub struct Cmpstcha19_SPEC;
9801    pub type Cmpstcha19 = crate::EnumBitfieldStruct<u8, Cmpstcha19_SPEC>;
9802    impl Cmpstcha19 {
9803        #[doc = "Comparison conditions are not met."]
9804        pub const _0: Self = Self::new(0);
9805
9806        #[doc = "Comparison conditions are met."]
9807        pub const _1: Self = Self::new(1);
9808    }
9809    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9810    pub struct Cmpstcha20_SPEC;
9811    pub type Cmpstcha20 = crate::EnumBitfieldStruct<u8, Cmpstcha20_SPEC>;
9812    impl Cmpstcha20 {
9813        #[doc = "Comparison conditions are not met."]
9814        pub const _0: Self = Self::new(0);
9815
9816        #[doc = "Comparison conditions are met."]
9817        pub const _1: Self = Self::new(1);
9818    }
9819    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9820    pub struct Cmpstcha21_SPEC;
9821    pub type Cmpstcha21 = crate::EnumBitfieldStruct<u8, Cmpstcha21_SPEC>;
9822    impl Cmpstcha21 {
9823        #[doc = "Comparison conditions are not met."]
9824        pub const _0: Self = Self::new(0);
9825
9826        #[doc = "Comparison conditions are met."]
9827        pub const _1: Self = Self::new(1);
9828    }
9829    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9830    pub struct Cmpstcha22_SPEC;
9831    pub type Cmpstcha22 = crate::EnumBitfieldStruct<u8, Cmpstcha22_SPEC>;
9832    impl Cmpstcha22 {
9833        #[doc = "Comparison conditions are not met."]
9834        pub const _0: Self = Self::new(0);
9835
9836        #[doc = "Comparison conditions are met."]
9837        pub const _1: Self = Self::new(1);
9838    }
9839    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9840    pub struct Cmpstcha23_SPEC;
9841    pub type Cmpstcha23 = crate::EnumBitfieldStruct<u8, Cmpstcha23_SPEC>;
9842    impl Cmpstcha23 {
9843        #[doc = "Comparison conditions are not met."]
9844        pub const _0: Self = Self::new(0);
9845
9846        #[doc = "Comparison conditions are met."]
9847        pub const _1: Self = Self::new(1);
9848    }
9849    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9850    pub struct Cmpstcha24_SPEC;
9851    pub type Cmpstcha24 = crate::EnumBitfieldStruct<u8, Cmpstcha24_SPEC>;
9852    impl Cmpstcha24 {
9853        #[doc = "Comparison conditions are not met."]
9854        pub const _0: Self = Self::new(0);
9855
9856        #[doc = "Comparison conditions are met."]
9857        pub const _1: Self = Self::new(1);
9858    }
9859    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9860    pub struct Cmpstcha25_SPEC;
9861    pub type Cmpstcha25 = crate::EnumBitfieldStruct<u8, Cmpstcha25_SPEC>;
9862    impl Cmpstcha25 {
9863        #[doc = "Comparison conditions are not met."]
9864        pub const _0: Self = Self::new(0);
9865
9866        #[doc = "Comparison conditions are met."]
9867        pub const _1: Self = Self::new(1);
9868    }
9869    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9870    pub struct Cmpstcha26_SPEC;
9871    pub type Cmpstcha26 = crate::EnumBitfieldStruct<u8, Cmpstcha26_SPEC>;
9872    impl Cmpstcha26 {
9873        #[doc = "Comparison conditions are not met."]
9874        pub const _0: Self = Self::new(0);
9875
9876        #[doc = "Comparison conditions are met."]
9877        pub const _1: Self = Self::new(1);
9878    }
9879    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9880    pub struct Cmpstcha27_SPEC;
9881    pub type Cmpstcha27 = crate::EnumBitfieldStruct<u8, Cmpstcha27_SPEC>;
9882    impl Cmpstcha27 {
9883        #[doc = "Comparison conditions are not met."]
9884        pub const _0: Self = Self::new(0);
9885
9886        #[doc = "Comparison conditions are met."]
9887        pub const _1: Self = Self::new(1);
9888    }
9889    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9890    pub struct Cmpstcha28_SPEC;
9891    pub type Cmpstcha28 = crate::EnumBitfieldStruct<u8, Cmpstcha28_SPEC>;
9892    impl Cmpstcha28 {
9893        #[doc = "Comparison conditions are not met."]
9894        pub const _0: Self = Self::new(0);
9895
9896        #[doc = "Comparison conditions are met."]
9897        pub const _1: Self = Self::new(1);
9898    }
9899    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9900    pub struct Cmpstcha29_SPEC;
9901    pub type Cmpstcha29 = crate::EnumBitfieldStruct<u8, Cmpstcha29_SPEC>;
9902    impl Cmpstcha29 {
9903        #[doc = "Comparison conditions are not met."]
9904        pub const _0: Self = Self::new(0);
9905
9906        #[doc = "Comparison conditions are met."]
9907        pub const _1: Self = Self::new(1);
9908    }
9909    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9910    pub struct Cmpstcha30_SPEC;
9911    pub type Cmpstcha30 = crate::EnumBitfieldStruct<u8, Cmpstcha30_SPEC>;
9912    impl Cmpstcha30 {
9913        #[doc = "Comparison conditions are not met."]
9914        pub const _0: Self = Self::new(0);
9915
9916        #[doc = "Comparison conditions are met."]
9917        pub const _1: Self = Self::new(1);
9918    }
9919    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
9920    pub struct Cmpstcha31_SPEC;
9921    pub type Cmpstcha31 = crate::EnumBitfieldStruct<u8, Cmpstcha31_SPEC>;
9922    impl Cmpstcha31 {
9923        #[doc = "Comparison conditions are not met."]
9924        pub const _0: Self = Self::new(0);
9925
9926        #[doc = "Comparison conditions are met."]
9927        pub const _1: Self = Self::new(1);
9928    }
9929}
9930#[doc(hidden)]
9931#[derive(Copy, Clone, Eq, PartialEq)]
9932pub struct Adcmpser_SPEC;
9933impl crate::sealed::RegSpec for Adcmpser_SPEC {
9934    type DataType = u8;
9935}
9936
9937#[doc = "A/D Compare Function Window A Extended Input Channel Status Register"]
9938pub type Adcmpser = crate::RegValueT<Adcmpser_SPEC>;
9939
9940impl Adcmpser {
9941    #[doc = "Compare Window A Temperature Sensor Output Compare Flag"]
9942    #[inline(always)]
9943    pub fn cmpsttsa(
9944        self,
9945    ) -> crate::common::RegisterField<
9946        0,
9947        0x1,
9948        1,
9949        0,
9950        adcmpser::Cmpsttsa,
9951        adcmpser::Cmpsttsa,
9952        Adcmpser_SPEC,
9953        crate::common::RW,
9954    > {
9955        crate::common::RegisterField::<
9956            0,
9957            0x1,
9958            1,
9959            0,
9960            adcmpser::Cmpsttsa,
9961            adcmpser::Cmpsttsa,
9962            Adcmpser_SPEC,
9963            crate::common::RW,
9964        >::from_register(self, 0)
9965    }
9966
9967    #[doc = "Compare Window A Internal Reference Voltage Compare Flag"]
9968    #[inline(always)]
9969    pub fn cmpstoca(
9970        self,
9971    ) -> crate::common::RegisterField<
9972        1,
9973        0x1,
9974        1,
9975        0,
9976        adcmpser::Cmpstoca,
9977        adcmpser::Cmpstoca,
9978        Adcmpser_SPEC,
9979        crate::common::RW,
9980    > {
9981        crate::common::RegisterField::<
9982            1,
9983            0x1,
9984            1,
9985            0,
9986            adcmpser::Cmpstoca,
9987            adcmpser::Cmpstoca,
9988            Adcmpser_SPEC,
9989            crate::common::RW,
9990        >::from_register(self, 0)
9991    }
9992}
9993impl ::core::default::Default for Adcmpser {
9994    #[inline(always)]
9995    fn default() -> Adcmpser {
9996        <crate::RegValueT<Adcmpser_SPEC> as RegisterValue<_>>::new(0)
9997    }
9998}
9999pub mod adcmpser {
10000
10001    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
10002    pub struct Cmpsttsa_SPEC;
10003    pub type Cmpsttsa = crate::EnumBitfieldStruct<u8, Cmpsttsa_SPEC>;
10004    impl Cmpsttsa {
10005        #[doc = "Comparison conditions are not met."]
10006        pub const _0: Self = Self::new(0);
10007
10008        #[doc = "Comparison conditions are met."]
10009        pub const _1: Self = Self::new(1);
10010    }
10011    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
10012    pub struct Cmpstoca_SPEC;
10013    pub type Cmpstoca = crate::EnumBitfieldStruct<u8, Cmpstoca_SPEC>;
10014    impl Cmpstoca {
10015        #[doc = "Comparison conditions are not met."]
10016        pub const _0: Self = Self::new(0);
10017
10018        #[doc = "Comparison conditions are met."]
10019        pub const _1: Self = Self::new(1);
10020    }
10021}
10022#[doc(hidden)]
10023#[derive(Copy, Clone, Eq, PartialEq)]
10024pub struct Adcmpbnsr_SPEC;
10025impl crate::sealed::RegSpec for Adcmpbnsr_SPEC {
10026    type DataType = u8;
10027}
10028
10029#[doc = "A/D Compare Function Window B Channel Select Register"]
10030pub type Adcmpbnsr = crate::RegValueT<Adcmpbnsr_SPEC>;
10031
10032impl Adcmpbnsr {
10033    #[doc = "Compare Window B Channel Select"]
10034    #[inline(always)]
10035    pub fn cmpchb(
10036        self,
10037    ) -> crate::common::RegisterField<0, 0x3f, 1, 0, u8, u8, Adcmpbnsr_SPEC, crate::common::RW>
10038    {
10039        crate::common::RegisterField::<0,0x3f,1,0,u8,u8,Adcmpbnsr_SPEC,crate::common::RW>::from_register(self,0)
10040    }
10041
10042    #[doc = "Compare Window B Comparison Condition Setting"]
10043    #[inline(always)]
10044    pub fn cmplb(
10045        self,
10046    ) -> crate::common::RegisterField<
10047        7,
10048        0x1,
10049        1,
10050        0,
10051        adcmpbnsr::Cmplb,
10052        adcmpbnsr::Cmplb,
10053        Adcmpbnsr_SPEC,
10054        crate::common::RW,
10055    > {
10056        crate::common::RegisterField::<
10057            7,
10058            0x1,
10059            1,
10060            0,
10061            adcmpbnsr::Cmplb,
10062            adcmpbnsr::Cmplb,
10063            Adcmpbnsr_SPEC,
10064            crate::common::RW,
10065        >::from_register(self, 0)
10066    }
10067}
10068impl ::core::default::Default for Adcmpbnsr {
10069    #[inline(always)]
10070    fn default() -> Adcmpbnsr {
10071        <crate::RegValueT<Adcmpbnsr_SPEC> as RegisterValue<_>>::new(0)
10072    }
10073}
10074pub mod adcmpbnsr {
10075
10076    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
10077    pub struct Cmplb_SPEC;
10078    pub type Cmplb = crate::EnumBitfieldStruct<u8, Cmplb_SPEC>;
10079    impl Cmplb {
10080        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADWINLLB value > A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): A/D-converted value < ADWINLLB value, or ADWINULB value < A/D-converted value"]
10081        pub const _0: Self = Self::new(0);
10082
10083        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0): ADWINLLB value < A/D-converted value When window function is enabled (ADCMPCR.WCMPE = 1): ADWINLLB value < A/D-converted value < ADWINULB value"]
10084        pub const _1: Self = Self::new(1);
10085    }
10086}
10087#[doc(hidden)]
10088#[derive(Copy, Clone, Eq, PartialEq)]
10089pub struct Adwinllb_SPEC;
10090impl crate::sealed::RegSpec for Adwinllb_SPEC {
10091    type DataType = u16;
10092}
10093
10094#[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
10095pub type Adwinllb = crate::RegValueT<Adwinllb_SPEC>;
10096
10097impl NoBitfieldReg<Adwinllb_SPEC> for Adwinllb {}
10098impl ::core::default::Default for Adwinllb {
10099    #[inline(always)]
10100    fn default() -> Adwinllb {
10101        <crate::RegValueT<Adwinllb_SPEC> as RegisterValue<_>>::new(0)
10102    }
10103}
10104
10105#[doc(hidden)]
10106#[derive(Copy, Clone, Eq, PartialEq)]
10107pub struct Adwinulb_SPEC;
10108impl crate::sealed::RegSpec for Adwinulb_SPEC {
10109    type DataType = u16;
10110}
10111
10112#[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
10113pub type Adwinulb = crate::RegValueT<Adwinulb_SPEC>;
10114
10115impl NoBitfieldReg<Adwinulb_SPEC> for Adwinulb {}
10116impl ::core::default::Default for Adwinulb {
10117    #[inline(always)]
10118    fn default() -> Adwinulb {
10119        <crate::RegValueT<Adwinulb_SPEC> as RegisterValue<_>>::new(0)
10120    }
10121}
10122
10123#[doc(hidden)]
10124#[derive(Copy, Clone, Eq, PartialEq)]
10125pub struct Adcmpbsr_SPEC;
10126impl crate::sealed::RegSpec for Adcmpbsr_SPEC {
10127    type DataType = u8;
10128}
10129
10130#[doc = "A/D Compare Function Window B Status Register"]
10131pub type Adcmpbsr = crate::RegValueT<Adcmpbsr_SPEC>;
10132
10133impl Adcmpbsr {
10134    #[doc = "Compare Window B Flag"]
10135    #[inline(always)]
10136    pub fn cmpstb(
10137        self,
10138    ) -> crate::common::RegisterField<
10139        0,
10140        0x1,
10141        1,
10142        0,
10143        adcmpbsr::Cmpstb,
10144        adcmpbsr::Cmpstb,
10145        Adcmpbsr_SPEC,
10146        crate::common::RW,
10147    > {
10148        crate::common::RegisterField::<
10149            0,
10150            0x1,
10151            1,
10152            0,
10153            adcmpbsr::Cmpstb,
10154            adcmpbsr::Cmpstb,
10155            Adcmpbsr_SPEC,
10156            crate::common::RW,
10157        >::from_register(self, 0)
10158    }
10159}
10160impl ::core::default::Default for Adcmpbsr {
10161    #[inline(always)]
10162    fn default() -> Adcmpbsr {
10163        <crate::RegValueT<Adcmpbsr_SPEC> as RegisterValue<_>>::new(0)
10164    }
10165}
10166pub mod adcmpbsr {
10167
10168    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
10169    pub struct Cmpstb_SPEC;
10170    pub type Cmpstb = crate::EnumBitfieldStruct<u8, Cmpstb_SPEC>;
10171    impl Cmpstb {
10172        #[doc = "Comparison conditions are not met."]
10173        pub const _0: Self = Self::new(0);
10174
10175        #[doc = "Comparison conditions are met."]
10176        pub const _1: Self = Self::new(1);
10177    }
10178}
10179#[doc(hidden)]
10180#[derive(Copy, Clone, Eq, PartialEq)]
10181pub struct Adsstrl_SPEC;
10182impl crate::sealed::RegSpec for Adsstrl_SPEC {
10183    type DataType = u8;
10184}
10185
10186#[doc = "A/D Sampling State Register"]
10187pub type Adsstrl = crate::RegValueT<Adsstrl_SPEC>;
10188
10189impl Adsstrl {
10190    #[doc = "Sampling Time Setting"]
10191    #[inline(always)]
10192    pub fn sst(
10193        self,
10194    ) -> crate::common::RegisterField<0, 0xff, 1, 0, u8, u8, Adsstrl_SPEC, crate::common::RW> {
10195        crate::common::RegisterField::<0,0xff,1,0,u8,u8,Adsstrl_SPEC,crate::common::RW>::from_register(self,0)
10196    }
10197}
10198impl ::core::default::Default for Adsstrl {
10199    #[inline(always)]
10200    fn default() -> Adsstrl {
10201        <crate::RegValueT<Adsstrl_SPEC> as RegisterValue<_>>::new(13)
10202    }
10203}
10204
10205#[doc(hidden)]
10206#[derive(Copy, Clone, Eq, PartialEq)]
10207pub struct Adsstrt_SPEC;
10208impl crate::sealed::RegSpec for Adsstrt_SPEC {
10209    type DataType = u8;
10210}
10211
10212#[doc = "A/D Sampling State Register"]
10213pub type Adsstrt = crate::RegValueT<Adsstrt_SPEC>;
10214
10215impl Adsstrt {
10216    #[doc = "Sampling Time Setting"]
10217    #[inline(always)]
10218    pub fn sst(
10219        self,
10220    ) -> crate::common::RegisterField<0, 0xff, 1, 0, u8, u8, Adsstrt_SPEC, crate::common::RW> {
10221        crate::common::RegisterField::<0,0xff,1,0,u8,u8,Adsstrt_SPEC,crate::common::RW>::from_register(self,0)
10222    }
10223}
10224impl ::core::default::Default for Adsstrt {
10225    #[inline(always)]
10226    fn default() -> Adsstrt {
10227        <crate::RegValueT<Adsstrt_SPEC> as RegisterValue<_>>::new(13)
10228    }
10229}
10230
10231#[doc(hidden)]
10232#[derive(Copy, Clone, Eq, PartialEq)]
10233pub struct Adsstro_SPEC;
10234impl crate::sealed::RegSpec for Adsstro_SPEC {
10235    type DataType = u8;
10236}
10237
10238#[doc = "A/D Sampling State Register"]
10239pub type Adsstro = crate::RegValueT<Adsstro_SPEC>;
10240
10241impl Adsstro {
10242    #[doc = "Sampling Time Setting"]
10243    #[inline(always)]
10244    pub fn sst(
10245        self,
10246    ) -> crate::common::RegisterField<0, 0xff, 1, 0, u8, u8, Adsstro_SPEC, crate::common::RW> {
10247        crate::common::RegisterField::<0,0xff,1,0,u8,u8,Adsstro_SPEC,crate::common::RW>::from_register(self,0)
10248    }
10249}
10250impl ::core::default::Default for Adsstro {
10251    #[inline(always)]
10252    fn default() -> Adsstro {
10253        <crate::RegValueT<Adsstro_SPEC> as RegisterValue<_>>::new(13)
10254    }
10255}
10256
10257#[doc(hidden)]
10258#[derive(Copy, Clone, Eq, PartialEq)]
10259pub struct Adsstr_SPEC;
10260impl crate::sealed::RegSpec for Adsstr_SPEC {
10261    type DataType = u8;
10262}
10263
10264#[doc = "A/D Sampling State Register"]
10265pub type Adsstr = crate::RegValueT<Adsstr_SPEC>;
10266
10267impl Adsstr {
10268    #[doc = "Sampling Time Setting"]
10269    #[inline(always)]
10270    pub fn sst(
10271        self,
10272    ) -> crate::common::RegisterField<0, 0xff, 1, 0, u8, u8, Adsstr_SPEC, crate::common::RW> {
10273        crate::common::RegisterField::<0,0xff,1,0,u8,u8,Adsstr_SPEC,crate::common::RW>::from_register(self,0)
10274    }
10275}
10276impl ::core::default::Default for Adsstr {
10277    #[inline(always)]
10278    fn default() -> Adsstr {
10279        <crate::RegValueT<Adsstr_SPEC> as RegisterValue<_>>::new(13)
10280    }
10281}
ra2l1_pac/adc120.rs

ra2l1_pac/
adc120.rs
