ra4m3_pac/
adc121.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.40.00, with svd2pac 0.6.1 on Sun, 15 Mar 2026 07:07:45 +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::Adc121 {}
29unsafe impl ::core::marker::Sync for super::Adc121 {}
30impl super::Adc121 {
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 A1"]
48    #[inline(always)]
49    pub const fn adansa1(
50        &self,
51    ) -> &'static crate::common::Reg<self::Adansa1_SPEC, crate::common::RW> {
52        unsafe {
53            crate::common::Reg::<self::Adansa1_SPEC, crate::common::RW>::from_ptr(
54                self._svd2pac_as_ptr().add(6usize),
55            )
56        }
57    }
58
59    #[doc = "A/D-Converted Value Addition/Average Channel Select Register 0"]
60    #[inline(always)]
61    pub const fn adads0(
62        &self,
63    ) -> &'static crate::common::Reg<self::Adads0_SPEC, crate::common::RW> {
64        unsafe {
65            crate::common::Reg::<self::Adads0_SPEC, crate::common::RW>::from_ptr(
66                self._svd2pac_as_ptr().add(8usize),
67            )
68        }
69    }
70
71    #[doc = "A/D-Converted Value Addition/Average Channel Select Register 1"]
72    #[inline(always)]
73    pub const fn adads1(
74        &self,
75    ) -> &'static crate::common::Reg<self::Adads1_SPEC, crate::common::RW> {
76        unsafe {
77            crate::common::Reg::<self::Adads1_SPEC, crate::common::RW>::from_ptr(
78                self._svd2pac_as_ptr().add(10usize),
79            )
80        }
81    }
82
83    #[doc = "A/D-Converted Value Addition/Average Count Select Register"]
84    #[inline(always)]
85    pub const fn adadc(&self) -> &'static crate::common::Reg<self::Adadc_SPEC, crate::common::RW> {
86        unsafe {
87            crate::common::Reg::<self::Adadc_SPEC, crate::common::RW>::from_ptr(
88                self._svd2pac_as_ptr().add(12usize),
89            )
90        }
91    }
92
93    #[doc = "A/D Control Extended Register"]
94    #[inline(always)]
95    pub const fn adcer(&self) -> &'static crate::common::Reg<self::Adcer_SPEC, crate::common::RW> {
96        unsafe {
97            crate::common::Reg::<self::Adcer_SPEC, crate::common::RW>::from_ptr(
98                self._svd2pac_as_ptr().add(14usize),
99            )
100        }
101    }
102
103    #[doc = "A/D Conversion Start Trigger Select Register"]
104    #[inline(always)]
105    pub const fn adstrgr(
106        &self,
107    ) -> &'static crate::common::Reg<self::Adstrgr_SPEC, crate::common::RW> {
108        unsafe {
109            crate::common::Reg::<self::Adstrgr_SPEC, crate::common::RW>::from_ptr(
110                self._svd2pac_as_ptr().add(16usize),
111            )
112        }
113    }
114
115    #[doc = "A/D Conversion Extended Input Control Registers"]
116    #[inline(always)]
117    pub const fn adexicr(
118        &self,
119    ) -> &'static crate::common::Reg<self::Adexicr_SPEC, crate::common::RW> {
120        unsafe {
121            crate::common::Reg::<self::Adexicr_SPEC, crate::common::RW>::from_ptr(
122                self._svd2pac_as_ptr().add(18usize),
123            )
124        }
125    }
126
127    #[doc = "A/D Channel Select Register B0"]
128    #[inline(always)]
129    pub const fn adansb0(
130        &self,
131    ) -> &'static crate::common::Reg<self::Adansb0_SPEC, crate::common::RW> {
132        unsafe {
133            crate::common::Reg::<self::Adansb0_SPEC, crate::common::RW>::from_ptr(
134                self._svd2pac_as_ptr().add(20usize),
135            )
136        }
137    }
138
139    #[doc = "A/D Channel Select Register B1"]
140    #[inline(always)]
141    pub const fn adansb1(
142        &self,
143    ) -> &'static crate::common::Reg<self::Adansb1_SPEC, crate::common::RW> {
144        unsafe {
145            crate::common::Reg::<self::Adansb1_SPEC, crate::common::RW>::from_ptr(
146                self._svd2pac_as_ptr().add(22usize),
147            )
148        }
149    }
150
151    #[doc = "A/D Data Duplexing Register"]
152    #[inline(always)]
153    pub const fn addbldr(
154        &self,
155    ) -> &'static crate::common::Reg<self::Addbldr_SPEC, crate::common::R> {
156        unsafe {
157            crate::common::Reg::<self::Addbldr_SPEC, crate::common::R>::from_ptr(
158                self._svd2pac_as_ptr().add(24usize),
159            )
160        }
161    }
162
163    #[doc = "A/D Temperature Sensor Data Register"]
164    #[inline(always)]
165    pub const fn adtsdr(&self) -> &'static crate::common::Reg<self::Adtsdr_SPEC, crate::common::R> {
166        unsafe {
167            crate::common::Reg::<self::Adtsdr_SPEC, crate::common::R>::from_ptr(
168                self._svd2pac_as_ptr().add(26usize),
169            )
170        }
171    }
172
173    #[doc = "A/D Internal Reference Voltage Data Register"]
174    #[inline(always)]
175    pub const fn adocdr(&self) -> &'static crate::common::Reg<self::Adocdr_SPEC, crate::common::R> {
176        unsafe {
177            crate::common::Reg::<self::Adocdr_SPEC, crate::common::R>::from_ptr(
178                self._svd2pac_as_ptr().add(28usize),
179            )
180        }
181    }
182
183    #[doc = "A/D Self-Diagnosis Data Register"]
184    #[inline(always)]
185    pub const fn adrd(&self) -> &'static crate::common::Reg<self::Adrd_SPEC, crate::common::R> {
186        unsafe {
187            crate::common::Reg::<self::Adrd_SPEC, crate::common::R>::from_ptr(
188                self._svd2pac_as_ptr().add(30usize),
189            )
190        }
191    }
192
193    #[doc = "A/D Data Registers %s"]
194    #[inline(always)]
195    pub const fn addr(
196        &self,
197    ) -> &'static crate::common::ClusterRegisterArray<
198        crate::common::Reg<self::Addr_SPEC, crate::common::R>,
199        7,
200        0x2,
201    > {
202        unsafe {
203            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0x40usize))
204        }
205    }
206    #[inline(always)]
207    pub const fn addr16(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
208        unsafe {
209            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
210                self._svd2pac_as_ptr().add(0x40usize),
211            )
212        }
213    }
214    #[inline(always)]
215    pub const fn addr17(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
216        unsafe {
217            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
218                self._svd2pac_as_ptr().add(0x42usize),
219            )
220        }
221    }
222    #[inline(always)]
223    pub const fn addr18(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
224        unsafe {
225            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
226                self._svd2pac_as_ptr().add(0x44usize),
227            )
228        }
229    }
230    #[inline(always)]
231    pub const fn addr19(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
232        unsafe {
233            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
234                self._svd2pac_as_ptr().add(0x46usize),
235            )
236        }
237    }
238    #[inline(always)]
239    pub const fn addr20(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
240        unsafe {
241            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
242                self._svd2pac_as_ptr().add(0x48usize),
243            )
244        }
245    }
246    #[inline(always)]
247    pub const fn addr21(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
248        unsafe {
249            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
250                self._svd2pac_as_ptr().add(0x4ausize),
251            )
252        }
253    }
254    #[inline(always)]
255    pub const fn addr22(&self) -> &'static crate::common::Reg<self::Addr_SPEC, crate::common::R> {
256        unsafe {
257            crate::common::Reg::<self::Addr_SPEC, crate::common::R>::from_ptr(
258                self._svd2pac_as_ptr().add(0x4cusize),
259            )
260        }
261    }
262
263    #[doc = "A/D Disconnection Detection Control Register"]
264    #[inline(always)]
265    pub const fn addiscr(
266        &self,
267    ) -> &'static crate::common::Reg<self::Addiscr_SPEC, crate::common::RW> {
268        unsafe {
269            crate::common::Reg::<self::Addiscr_SPEC, crate::common::RW>::from_ptr(
270                self._svd2pac_as_ptr().add(122usize),
271            )
272        }
273    }
274
275    #[doc = "A/D Group Scan Priority Control Register"]
276    #[inline(always)]
277    pub const fn adgspcr(
278        &self,
279    ) -> &'static crate::common::Reg<self::Adgspcr_SPEC, crate::common::RW> {
280        unsafe {
281            crate::common::Reg::<self::Adgspcr_SPEC, crate::common::RW>::from_ptr(
282                self._svd2pac_as_ptr().add(128usize),
283            )
284        }
285    }
286
287    #[doc = "A/D Data Duplexing Register A"]
288    #[inline(always)]
289    pub const fn addbldra(
290        &self,
291    ) -> &'static crate::common::Reg<self::Addbldra_SPEC, crate::common::R> {
292        unsafe {
293            crate::common::Reg::<self::Addbldra_SPEC, crate::common::R>::from_ptr(
294                self._svd2pac_as_ptr().add(132usize),
295            )
296        }
297    }
298
299    #[doc = "A/D Data Duplexing Register B"]
300    #[inline(always)]
301    pub const fn addbldrb(
302        &self,
303    ) -> &'static crate::common::Reg<self::Addbldrb_SPEC, crate::common::R> {
304        unsafe {
305            crate::common::Reg::<self::Addbldrb_SPEC, crate::common::R>::from_ptr(
306                self._svd2pac_as_ptr().add(134usize),
307            )
308        }
309    }
310
311    #[doc = "A/D Compare Function Window A/B Status Monitor Register"]
312    #[inline(always)]
313    pub const fn adwinmon(
314        &self,
315    ) -> &'static crate::common::Reg<self::Adwinmon_SPEC, crate::common::R> {
316        unsafe {
317            crate::common::Reg::<self::Adwinmon_SPEC, crate::common::R>::from_ptr(
318                self._svd2pac_as_ptr().add(140usize),
319            )
320        }
321    }
322
323    #[doc = "A/D Compare Function Control Register"]
324    #[inline(always)]
325    pub const fn adcmpcr(
326        &self,
327    ) -> &'static crate::common::Reg<self::Adcmpcr_SPEC, crate::common::RW> {
328        unsafe {
329            crate::common::Reg::<self::Adcmpcr_SPEC, crate::common::RW>::from_ptr(
330                self._svd2pac_as_ptr().add(144usize),
331            )
332        }
333    }
334
335    #[doc = "A/D Compare Function Window A Extended Input Select Register"]
336    #[inline(always)]
337    pub const fn adcmpanser(
338        &self,
339    ) -> &'static crate::common::Reg<self::Adcmpanser_SPEC, crate::common::RW> {
340        unsafe {
341            crate::common::Reg::<self::Adcmpanser_SPEC, crate::common::RW>::from_ptr(
342                self._svd2pac_as_ptr().add(146usize),
343            )
344        }
345    }
346
347    #[doc = "A/D Compare Function Window A Extended Input Comparison Condition Setting Register"]
348    #[inline(always)]
349    pub const fn adcmpler(
350        &self,
351    ) -> &'static crate::common::Reg<self::Adcmpler_SPEC, crate::common::RW> {
352        unsafe {
353            crate::common::Reg::<self::Adcmpler_SPEC, crate::common::RW>::from_ptr(
354                self._svd2pac_as_ptr().add(147usize),
355            )
356        }
357    }
358
359    #[doc = "A/D Compare Function Window A Channel Select Register 0"]
360    #[inline(always)]
361    pub const fn adcmpansr0(
362        &self,
363    ) -> &'static crate::common::Reg<self::Adcmpansr0_SPEC, crate::common::RW> {
364        unsafe {
365            crate::common::Reg::<self::Adcmpansr0_SPEC, crate::common::RW>::from_ptr(
366                self._svd2pac_as_ptr().add(148usize),
367            )
368        }
369    }
370
371    #[doc = "A/D Compare Function Window A Channel Select Register 1"]
372    #[inline(always)]
373    pub const fn adcmpansr1(
374        &self,
375    ) -> &'static crate::common::Reg<self::Adcmpansr1_SPEC, crate::common::RW> {
376        unsafe {
377            crate::common::Reg::<self::Adcmpansr1_SPEC, crate::common::RW>::from_ptr(
378                self._svd2pac_as_ptr().add(150usize),
379            )
380        }
381    }
382
383    #[doc = "A/D Compare Function Window A Comparison Condition Setting Register 0"]
384    #[inline(always)]
385    pub const fn adcmplr0(
386        &self,
387    ) -> &'static crate::common::Reg<self::Adcmplr0_SPEC, crate::common::RW> {
388        unsafe {
389            crate::common::Reg::<self::Adcmplr0_SPEC, crate::common::RW>::from_ptr(
390                self._svd2pac_as_ptr().add(152usize),
391            )
392        }
393    }
394
395    #[doc = "A/D Compare Function Window A Comparison Condition Setting Register 1"]
396    #[inline(always)]
397    pub const fn adcmplr1(
398        &self,
399    ) -> &'static crate::common::Reg<self::Adcmplr1_SPEC, crate::common::RW> {
400        unsafe {
401            crate::common::Reg::<self::Adcmplr1_SPEC, crate::common::RW>::from_ptr(
402                self._svd2pac_as_ptr().add(154usize),
403            )
404        }
405    }
406
407    #[doc = "A/D Compare Function Window A Lower-Side/Upper-Side Level Setting Register"]
408    #[inline(always)]
409    pub const fn adcmpdr(
410        &self,
411    ) -> &'static crate::common::ClusterRegisterArray<
412        crate::common::Reg<self::Adcmpdr_SPEC, crate::common::RW>,
413        2,
414        0x2,
415    > {
416        unsafe {
417            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0x9cusize))
418        }
419    }
420    #[inline(always)]
421    pub const fn adcmpdr0(
422        &self,
423    ) -> &'static crate::common::Reg<self::Adcmpdr_SPEC, crate::common::RW> {
424        unsafe {
425            crate::common::Reg::<self::Adcmpdr_SPEC, crate::common::RW>::from_ptr(
426                self._svd2pac_as_ptr().add(0x9cusize),
427            )
428        }
429    }
430    #[inline(always)]
431    pub const fn adcmpdr1(
432        &self,
433    ) -> &'static crate::common::Reg<self::Adcmpdr_SPEC, crate::common::RW> {
434        unsafe {
435            crate::common::Reg::<self::Adcmpdr_SPEC, crate::common::RW>::from_ptr(
436                self._svd2pac_as_ptr().add(0x9eusize),
437            )
438        }
439    }
440
441    #[doc = "A/D Compare Function Window A Channel Status Register 0"]
442    #[inline(always)]
443    pub const fn adcmpsr0(
444        &self,
445    ) -> &'static crate::common::Reg<self::Adcmpsr0_SPEC, crate::common::RW> {
446        unsafe {
447            crate::common::Reg::<self::Adcmpsr0_SPEC, crate::common::RW>::from_ptr(
448                self._svd2pac_as_ptr().add(160usize),
449            )
450        }
451    }
452
453    #[doc = "A/D Compare Function Window A Channel Status Register1"]
454    #[inline(always)]
455    pub const fn adcmpsr1(
456        &self,
457    ) -> &'static crate::common::Reg<self::Adcmpsr1_SPEC, crate::common::RW> {
458        unsafe {
459            crate::common::Reg::<self::Adcmpsr1_SPEC, crate::common::RW>::from_ptr(
460                self._svd2pac_as_ptr().add(162usize),
461            )
462        }
463    }
464
465    #[doc = "A/D Compare Function Window A Extended Input Channel Status Register"]
466    #[inline(always)]
467    pub const fn adcmpser(
468        &self,
469    ) -> &'static crate::common::Reg<self::Adcmpser_SPEC, crate::common::RW> {
470        unsafe {
471            crate::common::Reg::<self::Adcmpser_SPEC, crate::common::RW>::from_ptr(
472                self._svd2pac_as_ptr().add(164usize),
473            )
474        }
475    }
476
477    #[doc = "A/D Compare Function Window B Channel Select Register"]
478    #[inline(always)]
479    pub const fn adcmpbnsr(
480        &self,
481    ) -> &'static crate::common::Reg<self::Adcmpbnsr_SPEC, crate::common::RW> {
482        unsafe {
483            crate::common::Reg::<self::Adcmpbnsr_SPEC, crate::common::RW>::from_ptr(
484                self._svd2pac_as_ptr().add(166usize),
485            )
486        }
487    }
488
489    #[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
490    #[inline(always)]
491    pub const fn adwinllb(
492        &self,
493    ) -> &'static crate::common::Reg<self::Adwinllb_SPEC, crate::common::RW> {
494        unsafe {
495            crate::common::Reg::<self::Adwinllb_SPEC, crate::common::RW>::from_ptr(
496                self._svd2pac_as_ptr().add(168usize),
497            )
498        }
499    }
500
501    #[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
502    #[inline(always)]
503    pub const fn adwinulb(
504        &self,
505    ) -> &'static crate::common::Reg<self::Adwinulb_SPEC, crate::common::RW> {
506        unsafe {
507            crate::common::Reg::<self::Adwinulb_SPEC, crate::common::RW>::from_ptr(
508                self._svd2pac_as_ptr().add(170usize),
509            )
510        }
511    }
512
513    #[doc = "A/D Compare Function Window B Status Register"]
514    #[inline(always)]
515    pub const fn adcmpbsr(
516        &self,
517    ) -> &'static crate::common::Reg<self::Adcmpbsr_SPEC, crate::common::RW> {
518        unsafe {
519            crate::common::Reg::<self::Adcmpbsr_SPEC, crate::common::RW>::from_ptr(
520                self._svd2pac_as_ptr().add(172usize),
521            )
522        }
523    }
524
525    #[doc = "A/D Data Buffer Registers %s"]
526    #[inline(always)]
527    pub const fn adbuf(
528        &self,
529    ) -> &'static crate::common::ClusterRegisterArray<
530        crate::common::Reg<self::Adbuf_SPEC, crate::common::R>,
531        16,
532        0x2,
533    > {
534        unsafe {
535            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0xb0usize))
536        }
537    }
538    #[inline(always)]
539    pub const fn adbuf0(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
540        unsafe {
541            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
542                self._svd2pac_as_ptr().add(0xb0usize),
543            )
544        }
545    }
546    #[inline(always)]
547    pub const fn adbuf1(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
548        unsafe {
549            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
550                self._svd2pac_as_ptr().add(0xb2usize),
551            )
552        }
553    }
554    #[inline(always)]
555    pub const fn adbuf2(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
556        unsafe {
557            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
558                self._svd2pac_as_ptr().add(0xb4usize),
559            )
560        }
561    }
562    #[inline(always)]
563    pub const fn adbuf3(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
564        unsafe {
565            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
566                self._svd2pac_as_ptr().add(0xb6usize),
567            )
568        }
569    }
570    #[inline(always)]
571    pub const fn adbuf4(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
572        unsafe {
573            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
574                self._svd2pac_as_ptr().add(0xb8usize),
575            )
576        }
577    }
578    #[inline(always)]
579    pub const fn adbuf5(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
580        unsafe {
581            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
582                self._svd2pac_as_ptr().add(0xbausize),
583            )
584        }
585    }
586    #[inline(always)]
587    pub const fn adbuf6(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
588        unsafe {
589            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
590                self._svd2pac_as_ptr().add(0xbcusize),
591            )
592        }
593    }
594    #[inline(always)]
595    pub const fn adbuf7(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
596        unsafe {
597            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
598                self._svd2pac_as_ptr().add(0xbeusize),
599            )
600        }
601    }
602    #[inline(always)]
603    pub const fn adbuf8(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
604        unsafe {
605            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
606                self._svd2pac_as_ptr().add(0xc0usize),
607            )
608        }
609    }
610    #[inline(always)]
611    pub const fn adbuf9(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
612        unsafe {
613            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
614                self._svd2pac_as_ptr().add(0xc2usize),
615            )
616        }
617    }
618    #[inline(always)]
619    pub const fn adbuf10(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
620        unsafe {
621            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
622                self._svd2pac_as_ptr().add(0xc4usize),
623            )
624        }
625    }
626    #[inline(always)]
627    pub const fn adbuf11(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
628        unsafe {
629            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
630                self._svd2pac_as_ptr().add(0xc6usize),
631            )
632        }
633    }
634    #[inline(always)]
635    pub const fn adbuf12(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
636        unsafe {
637            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
638                self._svd2pac_as_ptr().add(0xc8usize),
639            )
640        }
641    }
642    #[inline(always)]
643    pub const fn adbuf13(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
644        unsafe {
645            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
646                self._svd2pac_as_ptr().add(0xcausize),
647            )
648        }
649    }
650    #[inline(always)]
651    pub const fn adbuf14(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
652        unsafe {
653            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
654                self._svd2pac_as_ptr().add(0xccusize),
655            )
656        }
657    }
658    #[inline(always)]
659    pub const fn adbuf15(&self) -> &'static crate::common::Reg<self::Adbuf_SPEC, crate::common::R> {
660        unsafe {
661            crate::common::Reg::<self::Adbuf_SPEC, crate::common::R>::from_ptr(
662                self._svd2pac_as_ptr().add(0xceusize),
663            )
664        }
665    }
666
667    #[doc = "A/D Data Buffer Enable Register"]
668    #[inline(always)]
669    pub const fn adbufen(
670        &self,
671    ) -> &'static crate::common::Reg<self::Adbufen_SPEC, crate::common::RW> {
672        unsafe {
673            crate::common::Reg::<self::Adbufen_SPEC, crate::common::RW>::from_ptr(
674                self._svd2pac_as_ptr().add(208usize),
675            )
676        }
677    }
678
679    #[doc = "A/D Data Buffer Pointer Register"]
680    #[inline(always)]
681    pub const fn adbufptr(
682        &self,
683    ) -> &'static crate::common::Reg<self::Adbufptr_SPEC, crate::common::RW> {
684        unsafe {
685            crate::common::Reg::<self::Adbufptr_SPEC, crate::common::RW>::from_ptr(
686                self._svd2pac_as_ptr().add(210usize),
687            )
688        }
689    }
690
691    #[doc = "A/D Sampling State Register"]
692    #[inline(always)]
693    pub const fn adsstr(
694        &self,
695    ) -> &'static crate::common::ClusterRegisterArray<
696        crate::common::Reg<self::Adsstr_SPEC, crate::common::RW>,
697        3,
698        0x1,
699    > {
700        unsafe {
701            crate::common::ClusterRegisterArray::from_ptr(self._svd2pac_as_ptr().add(0xe0usize))
702        }
703    }
704    #[inline(always)]
705    pub const fn adsstr0(
706        &self,
707    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
708        unsafe {
709            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
710                self._svd2pac_as_ptr().add(0xe0usize),
711            )
712        }
713    }
714    #[inline(always)]
715    pub const fn adsstr1(
716        &self,
717    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
718        unsafe {
719            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
720                self._svd2pac_as_ptr().add(0xe1usize),
721            )
722        }
723    }
724    #[inline(always)]
725    pub const fn adsstr2(
726        &self,
727    ) -> &'static crate::common::Reg<self::Adsstr_SPEC, crate::common::RW> {
728        unsafe {
729            crate::common::Reg::<self::Adsstr_SPEC, crate::common::RW>::from_ptr(
730                self._svd2pac_as_ptr().add(0xe2usize),
731            )
732        }
733    }
734}
735#[doc(hidden)]
736#[derive(Copy, Clone, Eq, PartialEq)]
737pub struct Adcsr_SPEC;
738impl crate::sealed::RegSpec for Adcsr_SPEC {
739    type DataType = u16;
740}
741
742#[doc = "A/D Control Register"]
743pub type Adcsr = crate::RegValueT<Adcsr_SPEC>;
744
745impl Adcsr {
746    #[doc = "Double Trigger Channel Select"]
747    #[inline(always)]
748    pub fn dblans(
749        self,
750    ) -> crate::common::RegisterField<0, 0x1f, 1, 0, u8, u8, Adcsr_SPEC, crate::common::RW> {
751        crate::common::RegisterField::<0,0x1f,1,0,u8,u8,Adcsr_SPEC,crate::common::RW>::from_register(self,0)
752    }
753
754    #[doc = "Group B Scan End Interrupt and ELC Event Enable"]
755    #[inline(always)]
756    pub fn gbadie(
757        self,
758    ) -> crate::common::RegisterField<
759        6,
760        0x1,
761        1,
762        0,
763        adcsr::Gbadie,
764        adcsr::Gbadie,
765        Adcsr_SPEC,
766        crate::common::RW,
767    > {
768        crate::common::RegisterField::<
769            6,
770            0x1,
771            1,
772            0,
773            adcsr::Gbadie,
774            adcsr::Gbadie,
775            Adcsr_SPEC,
776            crate::common::RW,
777        >::from_register(self, 0)
778    }
779
780    #[doc = "Double Trigger Mode Select"]
781    #[inline(always)]
782    pub fn dble(
783        self,
784    ) -> crate::common::RegisterField<
785        7,
786        0x1,
787        1,
788        0,
789        adcsr::Dble,
790        adcsr::Dble,
791        Adcsr_SPEC,
792        crate::common::RW,
793    > {
794        crate::common::RegisterField::<
795            7,
796            0x1,
797            1,
798            0,
799            adcsr::Dble,
800            adcsr::Dble,
801            Adcsr_SPEC,
802            crate::common::RW,
803        >::from_register(self, 0)
804    }
805
806    #[doc = "Trigger Select"]
807    #[inline(always)]
808    pub fn extrg(
809        self,
810    ) -> crate::common::RegisterField<
811        8,
812        0x1,
813        1,
814        0,
815        adcsr::Extrg,
816        adcsr::Extrg,
817        Adcsr_SPEC,
818        crate::common::RW,
819    > {
820        crate::common::RegisterField::<
821            8,
822            0x1,
823            1,
824            0,
825            adcsr::Extrg,
826            adcsr::Extrg,
827            Adcsr_SPEC,
828            crate::common::RW,
829        >::from_register(self, 0)
830    }
831
832    #[doc = "Trigger Start Enable"]
833    #[inline(always)]
834    pub fn trge(
835        self,
836    ) -> crate::common::RegisterField<
837        9,
838        0x1,
839        1,
840        0,
841        adcsr::Trge,
842        adcsr::Trge,
843        Adcsr_SPEC,
844        crate::common::RW,
845    > {
846        crate::common::RegisterField::<
847            9,
848            0x1,
849            1,
850            0,
851            adcsr::Trge,
852            adcsr::Trge,
853            Adcsr_SPEC,
854            crate::common::RW,
855        >::from_register(self, 0)
856    }
857
858    #[doc = "Scan Mode Select"]
859    #[inline(always)]
860    pub fn adcs(
861        self,
862    ) -> crate::common::RegisterField<
863        13,
864        0x3,
865        1,
866        0,
867        adcsr::Adcs,
868        adcsr::Adcs,
869        Adcsr_SPEC,
870        crate::common::RW,
871    > {
872        crate::common::RegisterField::<
873            13,
874            0x3,
875            1,
876            0,
877            adcsr::Adcs,
878            adcsr::Adcs,
879            Adcsr_SPEC,
880            crate::common::RW,
881        >::from_register(self, 0)
882    }
883
884    #[doc = "A/D Conversion Start"]
885    #[inline(always)]
886    pub fn adst(
887        self,
888    ) -> crate::common::RegisterField<
889        15,
890        0x1,
891        1,
892        0,
893        adcsr::Adst,
894        adcsr::Adst,
895        Adcsr_SPEC,
896        crate::common::RW,
897    > {
898        crate::common::RegisterField::<
899            15,
900            0x1,
901            1,
902            0,
903            adcsr::Adst,
904            adcsr::Adst,
905            Adcsr_SPEC,
906            crate::common::RW,
907        >::from_register(self, 0)
908    }
909}
910impl ::core::default::Default for Adcsr {
911    #[inline(always)]
912    fn default() -> Adcsr {
913        <crate::RegValueT<Adcsr_SPEC> as RegisterValue<_>>::new(0)
914    }
915}
916pub mod adcsr {
917
918    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
919    pub struct Gbadie_SPEC;
920    pub type Gbadie = crate::EnumBitfieldStruct<u8, Gbadie_SPEC>;
921    impl Gbadie {
922        #[doc = "Disable ADC12i_GBADI (i = 0, 1) interrupt generation on group B scan completion."]
923        pub const _0: Self = Self::new(0);
924
925        #[doc = "Enable ADC12i_GBADI (i = 0, 1) interrupt generation on group B scan completion."]
926        pub const _1: Self = Self::new(1);
927    }
928    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
929    pub struct Dble_SPEC;
930    pub type Dble = crate::EnumBitfieldStruct<u8, Dble_SPEC>;
931    impl Dble {
932        #[doc = "Deselect double-trigger mode."]
933        pub const _0: Self = Self::new(0);
934
935        #[doc = "Select double-trigger mode."]
936        pub const _1: Self = Self::new(1);
937    }
938    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
939    pub struct Extrg_SPEC;
940    pub type Extrg = crate::EnumBitfieldStruct<u8, Extrg_SPEC>;
941    impl Extrg {
942        #[doc = "Start A/D conversion by the synchronous trigger (ELC)."]
943        pub const _0: Self = Self::new(0);
944
945        #[doc = "Start A/D conversion by the asynchronous trigger (ADTRG0)."]
946        pub const _1: Self = Self::new(1);
947    }
948    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
949    pub struct Trge_SPEC;
950    pub type Trge = crate::EnumBitfieldStruct<u8, Trge_SPEC>;
951    impl Trge {
952        #[doc = "Disable A/D conversion to be started by the synchronous or asynchronous trigger"]
953        pub const _0: Self = Self::new(0);
954
955        #[doc = "Enable A/D conversion to be started by the synchronous or asynchronous trigger"]
956        pub const _1: Self = Self::new(1);
957    }
958    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
959    pub struct Adcs_SPEC;
960    pub type Adcs = crate::EnumBitfieldStruct<u8, Adcs_SPEC>;
961    impl Adcs {
962        #[doc = "Single scan mode"]
963        pub const _00: Self = Self::new(0);
964
965        #[doc = "Group scan mode"]
966        pub const _01: Self = Self::new(1);
967
968        #[doc = "Continuous scan mode"]
969        pub const _10: Self = Self::new(2);
970
971        #[doc = "Setting prohibited"]
972        pub const _11: Self = Self::new(3);
973    }
974    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
975    pub struct Adst_SPEC;
976    pub type Adst = crate::EnumBitfieldStruct<u8, Adst_SPEC>;
977    impl Adst {
978        #[doc = "Stop A/D conversion process."]
979        pub const _0: Self = Self::new(0);
980
981        #[doc = "Start A/D conversion process."]
982        pub const _1: Self = Self::new(1);
983    }
984}
985#[doc(hidden)]
986#[derive(Copy, Clone, Eq, PartialEq)]
987pub struct Adansa1_SPEC;
988impl crate::sealed::RegSpec for Adansa1_SPEC {
989    type DataType = u16;
990}
991
992#[doc = "A/D Channel Select Register A1"]
993pub type Adansa1 = crate::RegValueT<Adansa1_SPEC>;
994
995impl Adansa1 {
996    #[doc = "A/D Conversion Channels Select"]
997    #[inline(always)]
998    pub fn ansa16(
999        self,
1000    ) -> crate::common::RegisterField<
1001        0,
1002        0x1,
1003        1,
1004        0,
1005        adansa1::Ansa16,
1006        adansa1::Ansa16,
1007        Adansa1_SPEC,
1008        crate::common::RW,
1009    > {
1010        crate::common::RegisterField::<
1011            0,
1012            0x1,
1013            1,
1014            0,
1015            adansa1::Ansa16,
1016            adansa1::Ansa16,
1017            Adansa1_SPEC,
1018            crate::common::RW,
1019        >::from_register(self, 0)
1020    }
1021
1022    #[doc = "A/D Conversion Channels Select"]
1023    #[inline(always)]
1024    pub fn ansa17(
1025        self,
1026    ) -> crate::common::RegisterField<
1027        1,
1028        0x1,
1029        1,
1030        0,
1031        adansa1::Ansa17,
1032        adansa1::Ansa17,
1033        Adansa1_SPEC,
1034        crate::common::RW,
1035    > {
1036        crate::common::RegisterField::<
1037            1,
1038            0x1,
1039            1,
1040            0,
1041            adansa1::Ansa17,
1042            adansa1::Ansa17,
1043            Adansa1_SPEC,
1044            crate::common::RW,
1045        >::from_register(self, 0)
1046    }
1047
1048    #[doc = "A/D Conversion Channels Select"]
1049    #[inline(always)]
1050    pub fn ansa18(
1051        self,
1052    ) -> crate::common::RegisterField<
1053        2,
1054        0x1,
1055        1,
1056        0,
1057        adansa1::Ansa18,
1058        adansa1::Ansa18,
1059        Adansa1_SPEC,
1060        crate::common::RW,
1061    > {
1062        crate::common::RegisterField::<
1063            2,
1064            0x1,
1065            1,
1066            0,
1067            adansa1::Ansa18,
1068            adansa1::Ansa18,
1069            Adansa1_SPEC,
1070            crate::common::RW,
1071        >::from_register(self, 0)
1072    }
1073
1074    #[doc = "A/D Conversion Channels Select"]
1075    #[inline(always)]
1076    pub fn ansa19(
1077        self,
1078    ) -> crate::common::RegisterField<
1079        3,
1080        0x1,
1081        1,
1082        0,
1083        adansa1::Ansa19,
1084        adansa1::Ansa19,
1085        Adansa1_SPEC,
1086        crate::common::RW,
1087    > {
1088        crate::common::RegisterField::<
1089            3,
1090            0x1,
1091            1,
1092            0,
1093            adansa1::Ansa19,
1094            adansa1::Ansa19,
1095            Adansa1_SPEC,
1096            crate::common::RW,
1097        >::from_register(self, 0)
1098    }
1099
1100    #[doc = "A/D Conversion Channels Select"]
1101    #[inline(always)]
1102    pub fn ansa20(
1103        self,
1104    ) -> crate::common::RegisterField<
1105        4,
1106        0x1,
1107        1,
1108        0,
1109        adansa1::Ansa20,
1110        adansa1::Ansa20,
1111        Adansa1_SPEC,
1112        crate::common::RW,
1113    > {
1114        crate::common::RegisterField::<
1115            4,
1116            0x1,
1117            1,
1118            0,
1119            adansa1::Ansa20,
1120            adansa1::Ansa20,
1121            Adansa1_SPEC,
1122            crate::common::RW,
1123        >::from_register(self, 0)
1124    }
1125
1126    #[doc = "A/D Conversion Channels Select"]
1127    #[inline(always)]
1128    pub fn ansa21(
1129        self,
1130    ) -> crate::common::RegisterField<
1131        5,
1132        0x1,
1133        1,
1134        0,
1135        adansa1::Ansa21,
1136        adansa1::Ansa21,
1137        Adansa1_SPEC,
1138        crate::common::RW,
1139    > {
1140        crate::common::RegisterField::<
1141            5,
1142            0x1,
1143            1,
1144            0,
1145            adansa1::Ansa21,
1146            adansa1::Ansa21,
1147            Adansa1_SPEC,
1148            crate::common::RW,
1149        >::from_register(self, 0)
1150    }
1151
1152    #[doc = "A/D Conversion Channels Select"]
1153    #[inline(always)]
1154    pub fn ansa22(
1155        self,
1156    ) -> crate::common::RegisterField<
1157        6,
1158        0x1,
1159        1,
1160        0,
1161        adansa1::Ansa22,
1162        adansa1::Ansa22,
1163        Adansa1_SPEC,
1164        crate::common::RW,
1165    > {
1166        crate::common::RegisterField::<
1167            6,
1168            0x1,
1169            1,
1170            0,
1171            adansa1::Ansa22,
1172            adansa1::Ansa22,
1173            Adansa1_SPEC,
1174            crate::common::RW,
1175        >::from_register(self, 0)
1176    }
1177}
1178impl ::core::default::Default for Adansa1 {
1179    #[inline(always)]
1180    fn default() -> Adansa1 {
1181        <crate::RegValueT<Adansa1_SPEC> as RegisterValue<_>>::new(0)
1182    }
1183}
1184pub mod adansa1 {
1185
1186    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1187    pub struct Ansa16_SPEC;
1188    pub type Ansa16 = crate::EnumBitfieldStruct<u8, Ansa16_SPEC>;
1189    impl Ansa16 {
1190        #[doc = "Do not select associated input channel."]
1191        pub const _0: Self = Self::new(0);
1192
1193        #[doc = "Select associated input channel."]
1194        pub const _1: Self = Self::new(1);
1195    }
1196    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1197    pub struct Ansa17_SPEC;
1198    pub type Ansa17 = crate::EnumBitfieldStruct<u8, Ansa17_SPEC>;
1199    impl Ansa17 {
1200        #[doc = "Do not select associated input channel."]
1201        pub const _0: Self = Self::new(0);
1202
1203        #[doc = "Select associated input channel."]
1204        pub const _1: Self = Self::new(1);
1205    }
1206    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1207    pub struct Ansa18_SPEC;
1208    pub type Ansa18 = crate::EnumBitfieldStruct<u8, Ansa18_SPEC>;
1209    impl Ansa18 {
1210        #[doc = "Do not select associated input channel."]
1211        pub const _0: Self = Self::new(0);
1212
1213        #[doc = "Select associated input channel."]
1214        pub const _1: Self = Self::new(1);
1215    }
1216    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1217    pub struct Ansa19_SPEC;
1218    pub type Ansa19 = crate::EnumBitfieldStruct<u8, Ansa19_SPEC>;
1219    impl Ansa19 {
1220        #[doc = "Do not select associated input channel."]
1221        pub const _0: Self = Self::new(0);
1222
1223        #[doc = "Select associated input channel."]
1224        pub const _1: Self = Self::new(1);
1225    }
1226    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1227    pub struct Ansa20_SPEC;
1228    pub type Ansa20 = crate::EnumBitfieldStruct<u8, Ansa20_SPEC>;
1229    impl Ansa20 {
1230        #[doc = "Do not select associated input channel."]
1231        pub const _0: Self = Self::new(0);
1232
1233        #[doc = "Select associated input channel."]
1234        pub const _1: Self = Self::new(1);
1235    }
1236    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1237    pub struct Ansa21_SPEC;
1238    pub type Ansa21 = crate::EnumBitfieldStruct<u8, Ansa21_SPEC>;
1239    impl Ansa21 {
1240        #[doc = "Do not select associated input channel."]
1241        pub const _0: Self = Self::new(0);
1242
1243        #[doc = "Select associated input channel."]
1244        pub const _1: Self = Self::new(1);
1245    }
1246    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1247    pub struct Ansa22_SPEC;
1248    pub type Ansa22 = crate::EnumBitfieldStruct<u8, Ansa22_SPEC>;
1249    impl Ansa22 {
1250        #[doc = "Do not select associated input channel."]
1251        pub const _0: Self = Self::new(0);
1252
1253        #[doc = "Select associated input channel."]
1254        pub const _1: Self = Self::new(1);
1255    }
1256}
1257#[doc(hidden)]
1258#[derive(Copy, Clone, Eq, PartialEq)]
1259pub struct Adads0_SPEC;
1260impl crate::sealed::RegSpec for Adads0_SPEC {
1261    type DataType = u16;
1262}
1263
1264#[doc = "A/D-Converted Value Addition/Average Channel Select Register 0"]
1265pub type Adads0 = crate::RegValueT<Adads0_SPEC>;
1266
1267impl Adads0 {
1268    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1269    #[inline(always)]
1270    pub fn ads0(
1271        self,
1272    ) -> crate::common::RegisterField<
1273        0,
1274        0x1,
1275        1,
1276        0,
1277        adads0::Ads0,
1278        adads0::Ads0,
1279        Adads0_SPEC,
1280        crate::common::RW,
1281    > {
1282        crate::common::RegisterField::<
1283            0,
1284            0x1,
1285            1,
1286            0,
1287            adads0::Ads0,
1288            adads0::Ads0,
1289            Adads0_SPEC,
1290            crate::common::RW,
1291        >::from_register(self, 0)
1292    }
1293
1294    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1295    #[inline(always)]
1296    pub fn ads1(
1297        self,
1298    ) -> crate::common::RegisterField<
1299        1,
1300        0x1,
1301        1,
1302        0,
1303        adads0::Ads1,
1304        adads0::Ads1,
1305        Adads0_SPEC,
1306        crate::common::RW,
1307    > {
1308        crate::common::RegisterField::<
1309            1,
1310            0x1,
1311            1,
1312            0,
1313            adads0::Ads1,
1314            adads0::Ads1,
1315            Adads0_SPEC,
1316            crate::common::RW,
1317        >::from_register(self, 0)
1318    }
1319
1320    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1321    #[inline(always)]
1322    pub fn ads2(
1323        self,
1324    ) -> crate::common::RegisterField<
1325        2,
1326        0x1,
1327        1,
1328        0,
1329        adads0::Ads2,
1330        adads0::Ads2,
1331        Adads0_SPEC,
1332        crate::common::RW,
1333    > {
1334        crate::common::RegisterField::<
1335            2,
1336            0x1,
1337            1,
1338            0,
1339            adads0::Ads2,
1340            adads0::Ads2,
1341            Adads0_SPEC,
1342            crate::common::RW,
1343        >::from_register(self, 0)
1344    }
1345
1346    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1347    #[inline(always)]
1348    pub fn ads3(
1349        self,
1350    ) -> crate::common::RegisterField<
1351        3,
1352        0x1,
1353        1,
1354        0,
1355        adads0::Ads3,
1356        adads0::Ads3,
1357        Adads0_SPEC,
1358        crate::common::RW,
1359    > {
1360        crate::common::RegisterField::<
1361            3,
1362            0x1,
1363            1,
1364            0,
1365            adads0::Ads3,
1366            adads0::Ads3,
1367            Adads0_SPEC,
1368            crate::common::RW,
1369        >::from_register(self, 0)
1370    }
1371
1372    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1373    #[inline(always)]
1374    pub fn ads4(
1375        self,
1376    ) -> crate::common::RegisterField<
1377        4,
1378        0x1,
1379        1,
1380        0,
1381        adads0::Ads4,
1382        adads0::Ads4,
1383        Adads0_SPEC,
1384        crate::common::RW,
1385    > {
1386        crate::common::RegisterField::<
1387            4,
1388            0x1,
1389            1,
1390            0,
1391            adads0::Ads4,
1392            adads0::Ads4,
1393            Adads0_SPEC,
1394            crate::common::RW,
1395        >::from_register(self, 0)
1396    }
1397
1398    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1399    #[inline(always)]
1400    pub fn ads5(
1401        self,
1402    ) -> crate::common::RegisterField<
1403        5,
1404        0x1,
1405        1,
1406        0,
1407        adads0::Ads5,
1408        adads0::Ads5,
1409        Adads0_SPEC,
1410        crate::common::RW,
1411    > {
1412        crate::common::RegisterField::<
1413            5,
1414            0x1,
1415            1,
1416            0,
1417            adads0::Ads5,
1418            adads0::Ads5,
1419            Adads0_SPEC,
1420            crate::common::RW,
1421        >::from_register(self, 0)
1422    }
1423
1424    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1425    #[inline(always)]
1426    pub fn ads6(
1427        self,
1428    ) -> crate::common::RegisterField<
1429        6,
1430        0x1,
1431        1,
1432        0,
1433        adads0::Ads6,
1434        adads0::Ads6,
1435        Adads0_SPEC,
1436        crate::common::RW,
1437    > {
1438        crate::common::RegisterField::<
1439            6,
1440            0x1,
1441            1,
1442            0,
1443            adads0::Ads6,
1444            adads0::Ads6,
1445            Adads0_SPEC,
1446            crate::common::RW,
1447        >::from_register(self, 0)
1448    }
1449
1450    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1451    #[inline(always)]
1452    pub fn ads7(
1453        self,
1454    ) -> crate::common::RegisterField<
1455        7,
1456        0x1,
1457        1,
1458        0,
1459        adads0::Ads7,
1460        adads0::Ads7,
1461        Adads0_SPEC,
1462        crate::common::RW,
1463    > {
1464        crate::common::RegisterField::<
1465            7,
1466            0x1,
1467            1,
1468            0,
1469            adads0::Ads7,
1470            adads0::Ads7,
1471            Adads0_SPEC,
1472            crate::common::RW,
1473        >::from_register(self, 0)
1474    }
1475
1476    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1477    #[inline(always)]
1478    pub fn ads8(
1479        self,
1480    ) -> crate::common::RegisterField<
1481        8,
1482        0x1,
1483        1,
1484        0,
1485        adads0::Ads8,
1486        adads0::Ads8,
1487        Adads0_SPEC,
1488        crate::common::RW,
1489    > {
1490        crate::common::RegisterField::<
1491            8,
1492            0x1,
1493            1,
1494            0,
1495            adads0::Ads8,
1496            adads0::Ads8,
1497            Adads0_SPEC,
1498            crate::common::RW,
1499        >::from_register(self, 0)
1500    }
1501
1502    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1503    #[inline(always)]
1504    pub fn ads9(
1505        self,
1506    ) -> crate::common::RegisterField<
1507        9,
1508        0x1,
1509        1,
1510        0,
1511        adads0::Ads9,
1512        adads0::Ads9,
1513        Adads0_SPEC,
1514        crate::common::RW,
1515    > {
1516        crate::common::RegisterField::<
1517            9,
1518            0x1,
1519            1,
1520            0,
1521            adads0::Ads9,
1522            adads0::Ads9,
1523            Adads0_SPEC,
1524            crate::common::RW,
1525        >::from_register(self, 0)
1526    }
1527
1528    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1529    #[inline(always)]
1530    pub fn ads12(
1531        self,
1532    ) -> crate::common::RegisterField<
1533        12,
1534        0x1,
1535        1,
1536        0,
1537        adads0::Ads12,
1538        adads0::Ads12,
1539        Adads0_SPEC,
1540        crate::common::RW,
1541    > {
1542        crate::common::RegisterField::<
1543            12,
1544            0x1,
1545            1,
1546            0,
1547            adads0::Ads12,
1548            adads0::Ads12,
1549            Adads0_SPEC,
1550            crate::common::RW,
1551        >::from_register(self, 0)
1552    }
1553
1554    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1555    #[inline(always)]
1556    pub fn ads13(
1557        self,
1558    ) -> crate::common::RegisterField<
1559        13,
1560        0x1,
1561        1,
1562        0,
1563        adads0::Ads13,
1564        adads0::Ads13,
1565        Adads0_SPEC,
1566        crate::common::RW,
1567    > {
1568        crate::common::RegisterField::<
1569            13,
1570            0x1,
1571            1,
1572            0,
1573            adads0::Ads13,
1574            adads0::Ads13,
1575            Adads0_SPEC,
1576            crate::common::RW,
1577        >::from_register(self, 0)
1578    }
1579}
1580impl ::core::default::Default for Adads0 {
1581    #[inline(always)]
1582    fn default() -> Adads0 {
1583        <crate::RegValueT<Adads0_SPEC> as RegisterValue<_>>::new(0)
1584    }
1585}
1586pub mod adads0 {
1587
1588    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1589    pub struct Ads0_SPEC;
1590    pub type Ads0 = crate::EnumBitfieldStruct<u8, Ads0_SPEC>;
1591    impl Ads0 {
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 Ads1_SPEC;
1600    pub type Ads1 = crate::EnumBitfieldStruct<u8, Ads1_SPEC>;
1601    impl Ads1 {
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 Ads2_SPEC;
1610    pub type Ads2 = crate::EnumBitfieldStruct<u8, Ads2_SPEC>;
1611    impl Ads2 {
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 Ads3_SPEC;
1620    pub type Ads3 = crate::EnumBitfieldStruct<u8, Ads3_SPEC>;
1621    impl Ads3 {
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    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1629    pub struct Ads4_SPEC;
1630    pub type Ads4 = crate::EnumBitfieldStruct<u8, Ads4_SPEC>;
1631    impl Ads4 {
1632        #[doc = "Do not select associated input channel."]
1633        pub const _0: Self = Self::new(0);
1634
1635        #[doc = "Select associated input channel."]
1636        pub const _1: Self = Self::new(1);
1637    }
1638    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1639    pub struct Ads5_SPEC;
1640    pub type Ads5 = crate::EnumBitfieldStruct<u8, Ads5_SPEC>;
1641    impl Ads5 {
1642        #[doc = "Do not select associated input channel."]
1643        pub const _0: Self = Self::new(0);
1644
1645        #[doc = "Select associated input channel."]
1646        pub const _1: Self = Self::new(1);
1647    }
1648    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1649    pub struct Ads6_SPEC;
1650    pub type Ads6 = crate::EnumBitfieldStruct<u8, Ads6_SPEC>;
1651    impl Ads6 {
1652        #[doc = "Do not select associated input channel."]
1653        pub const _0: Self = Self::new(0);
1654
1655        #[doc = "Select associated input channel."]
1656        pub const _1: Self = Self::new(1);
1657    }
1658    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1659    pub struct Ads7_SPEC;
1660    pub type Ads7 = crate::EnumBitfieldStruct<u8, Ads7_SPEC>;
1661    impl Ads7 {
1662        #[doc = "Do not select associated input channel."]
1663        pub const _0: Self = Self::new(0);
1664
1665        #[doc = "Select associated input channel."]
1666        pub const _1: Self = Self::new(1);
1667    }
1668    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1669    pub struct Ads8_SPEC;
1670    pub type Ads8 = crate::EnumBitfieldStruct<u8, Ads8_SPEC>;
1671    impl Ads8 {
1672        #[doc = "Do not select associated input channel."]
1673        pub const _0: Self = Self::new(0);
1674
1675        #[doc = "Select associated input channel."]
1676        pub const _1: Self = Self::new(1);
1677    }
1678    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1679    pub struct Ads9_SPEC;
1680    pub type Ads9 = crate::EnumBitfieldStruct<u8, Ads9_SPEC>;
1681    impl Ads9 {
1682        #[doc = "Do not select associated input channel."]
1683        pub const _0: Self = Self::new(0);
1684
1685        #[doc = "Select associated input channel."]
1686        pub const _1: Self = Self::new(1);
1687    }
1688    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1689    pub struct Ads12_SPEC;
1690    pub type Ads12 = crate::EnumBitfieldStruct<u8, Ads12_SPEC>;
1691    impl Ads12 {
1692        #[doc = "Do not select associated input channel."]
1693        pub const _0: Self = Self::new(0);
1694
1695        #[doc = "Select associated input channel."]
1696        pub const _1: Self = Self::new(1);
1697    }
1698    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1699    pub struct Ads13_SPEC;
1700    pub type Ads13 = crate::EnumBitfieldStruct<u8, Ads13_SPEC>;
1701    impl Ads13 {
1702        #[doc = "Do not select associated input channel."]
1703        pub const _0: Self = Self::new(0);
1704
1705        #[doc = "Select associated input channel."]
1706        pub const _1: Self = Self::new(1);
1707    }
1708}
1709#[doc(hidden)]
1710#[derive(Copy, Clone, Eq, PartialEq)]
1711pub struct Adads1_SPEC;
1712impl crate::sealed::RegSpec for Adads1_SPEC {
1713    type DataType = u16;
1714}
1715
1716#[doc = "A/D-Converted Value Addition/Average Channel Select Register 1"]
1717pub type Adads1 = crate::RegValueT<Adads1_SPEC>;
1718
1719impl Adads1 {
1720    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1721    #[inline(always)]
1722    pub fn ads16(
1723        self,
1724    ) -> crate::common::RegisterField<
1725        0,
1726        0x1,
1727        1,
1728        0,
1729        adads1::Ads16,
1730        adads1::Ads16,
1731        Adads1_SPEC,
1732        crate::common::RW,
1733    > {
1734        crate::common::RegisterField::<
1735            0,
1736            0x1,
1737            1,
1738            0,
1739            adads1::Ads16,
1740            adads1::Ads16,
1741            Adads1_SPEC,
1742            crate::common::RW,
1743        >::from_register(self, 0)
1744    }
1745
1746    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1747    #[inline(always)]
1748    pub fn ads17(
1749        self,
1750    ) -> crate::common::RegisterField<
1751        1,
1752        0x1,
1753        1,
1754        0,
1755        adads1::Ads17,
1756        adads1::Ads17,
1757        Adads1_SPEC,
1758        crate::common::RW,
1759    > {
1760        crate::common::RegisterField::<
1761            1,
1762            0x1,
1763            1,
1764            0,
1765            adads1::Ads17,
1766            adads1::Ads17,
1767            Adads1_SPEC,
1768            crate::common::RW,
1769        >::from_register(self, 0)
1770    }
1771
1772    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1773    #[inline(always)]
1774    pub fn ads18(
1775        self,
1776    ) -> crate::common::RegisterField<
1777        2,
1778        0x1,
1779        1,
1780        0,
1781        adads1::Ads18,
1782        adads1::Ads18,
1783        Adads1_SPEC,
1784        crate::common::RW,
1785    > {
1786        crate::common::RegisterField::<
1787            2,
1788            0x1,
1789            1,
1790            0,
1791            adads1::Ads18,
1792            adads1::Ads18,
1793            Adads1_SPEC,
1794            crate::common::RW,
1795        >::from_register(self, 0)
1796    }
1797
1798    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1799    #[inline(always)]
1800    pub fn ads19(
1801        self,
1802    ) -> crate::common::RegisterField<
1803        3,
1804        0x1,
1805        1,
1806        0,
1807        adads1::Ads19,
1808        adads1::Ads19,
1809        Adads1_SPEC,
1810        crate::common::RW,
1811    > {
1812        crate::common::RegisterField::<
1813            3,
1814            0x1,
1815            1,
1816            0,
1817            adads1::Ads19,
1818            adads1::Ads19,
1819            Adads1_SPEC,
1820            crate::common::RW,
1821        >::from_register(self, 0)
1822    }
1823
1824    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1825    #[inline(always)]
1826    pub fn ads20(
1827        self,
1828    ) -> crate::common::RegisterField<
1829        4,
1830        0x1,
1831        1,
1832        0,
1833        adads1::Ads20,
1834        adads1::Ads20,
1835        Adads1_SPEC,
1836        crate::common::RW,
1837    > {
1838        crate::common::RegisterField::<
1839            4,
1840            0x1,
1841            1,
1842            0,
1843            adads1::Ads20,
1844            adads1::Ads20,
1845            Adads1_SPEC,
1846            crate::common::RW,
1847        >::from_register(self, 0)
1848    }
1849
1850    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1851    #[inline(always)]
1852    pub fn ads21(
1853        self,
1854    ) -> crate::common::RegisterField<
1855        5,
1856        0x1,
1857        1,
1858        0,
1859        adads1::Ads21,
1860        adads1::Ads21,
1861        Adads1_SPEC,
1862        crate::common::RW,
1863    > {
1864        crate::common::RegisterField::<
1865            5,
1866            0x1,
1867            1,
1868            0,
1869            adads1::Ads21,
1870            adads1::Ads21,
1871            Adads1_SPEC,
1872            crate::common::RW,
1873        >::from_register(self, 0)
1874    }
1875
1876    #[doc = "A/D-Converted Value Addition/Average Channel Select"]
1877    #[inline(always)]
1878    pub fn ads22(
1879        self,
1880    ) -> crate::common::RegisterField<
1881        6,
1882        0x1,
1883        1,
1884        0,
1885        adads1::Ads22,
1886        adads1::Ads22,
1887        Adads1_SPEC,
1888        crate::common::RW,
1889    > {
1890        crate::common::RegisterField::<
1891            6,
1892            0x1,
1893            1,
1894            0,
1895            adads1::Ads22,
1896            adads1::Ads22,
1897            Adads1_SPEC,
1898            crate::common::RW,
1899        >::from_register(self, 0)
1900    }
1901}
1902impl ::core::default::Default for Adads1 {
1903    #[inline(always)]
1904    fn default() -> Adads1 {
1905        <crate::RegValueT<Adads1_SPEC> as RegisterValue<_>>::new(0)
1906    }
1907}
1908pub mod adads1 {
1909
1910    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1911    pub struct Ads16_SPEC;
1912    pub type Ads16 = crate::EnumBitfieldStruct<u8, Ads16_SPEC>;
1913    impl Ads16 {
1914        #[doc = "Do not select associated input channel."]
1915        pub const _0: Self = Self::new(0);
1916
1917        #[doc = "Select associated input channel."]
1918        pub const _1: Self = Self::new(1);
1919    }
1920    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1921    pub struct Ads17_SPEC;
1922    pub type Ads17 = crate::EnumBitfieldStruct<u8, Ads17_SPEC>;
1923    impl Ads17 {
1924        #[doc = "Do not select associated input channel."]
1925        pub const _0: Self = Self::new(0);
1926
1927        #[doc = "Select associated input channel."]
1928        pub const _1: Self = Self::new(1);
1929    }
1930    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1931    pub struct Ads18_SPEC;
1932    pub type Ads18 = crate::EnumBitfieldStruct<u8, Ads18_SPEC>;
1933    impl Ads18 {
1934        #[doc = "Do not select associated input channel."]
1935        pub const _0: Self = Self::new(0);
1936
1937        #[doc = "Select associated input channel."]
1938        pub const _1: Self = Self::new(1);
1939    }
1940    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1941    pub struct Ads19_SPEC;
1942    pub type Ads19 = crate::EnumBitfieldStruct<u8, Ads19_SPEC>;
1943    impl Ads19 {
1944        #[doc = "Do not select associated input channel."]
1945        pub const _0: Self = Self::new(0);
1946
1947        #[doc = "Select associated input channel."]
1948        pub const _1: Self = Self::new(1);
1949    }
1950    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1951    pub struct Ads20_SPEC;
1952    pub type Ads20 = crate::EnumBitfieldStruct<u8, Ads20_SPEC>;
1953    impl Ads20 {
1954        #[doc = "Do not select associated input channel."]
1955        pub const _0: Self = Self::new(0);
1956
1957        #[doc = "Select associated input channel."]
1958        pub const _1: Self = Self::new(1);
1959    }
1960    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1961    pub struct Ads21_SPEC;
1962    pub type Ads21 = crate::EnumBitfieldStruct<u8, Ads21_SPEC>;
1963    impl Ads21 {
1964        #[doc = "Do not select associated input channel."]
1965        pub const _0: Self = Self::new(0);
1966
1967        #[doc = "Select associated input channel."]
1968        pub const _1: Self = Self::new(1);
1969    }
1970    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
1971    pub struct Ads22_SPEC;
1972    pub type Ads22 = crate::EnumBitfieldStruct<u8, Ads22_SPEC>;
1973    impl Ads22 {
1974        #[doc = "Do not select associated input channel."]
1975        pub const _0: Self = Self::new(0);
1976
1977        #[doc = "Select associated input channel."]
1978        pub const _1: Self = Self::new(1);
1979    }
1980}
1981#[doc(hidden)]
1982#[derive(Copy, Clone, Eq, PartialEq)]
1983pub struct Adadc_SPEC;
1984impl crate::sealed::RegSpec for Adadc_SPEC {
1985    type DataType = u8;
1986}
1987
1988#[doc = "A/D-Converted Value Addition/Average Count Select Register"]
1989pub type Adadc = crate::RegValueT<Adadc_SPEC>;
1990
1991impl Adadc {
1992    #[doc = "Addition/Average Count Select"]
1993    #[inline(always)]
1994    pub fn adc(
1995        self,
1996    ) -> crate::common::RegisterField<
1997        0,
1998        0x7,
1999        1,
2000        0,
2001        adadc::Adc,
2002        adadc::Adc,
2003        Adadc_SPEC,
2004        crate::common::RW,
2005    > {
2006        crate::common::RegisterField::<
2007            0,
2008            0x7,
2009            1,
2010            0,
2011            adadc::Adc,
2012            adadc::Adc,
2013            Adadc_SPEC,
2014            crate::common::RW,
2015        >::from_register(self, 0)
2016    }
2017
2018    #[doc = "Average Mode Select"]
2019    #[inline(always)]
2020    pub fn avee(
2021        self,
2022    ) -> crate::common::RegisterField<
2023        7,
2024        0x1,
2025        1,
2026        0,
2027        adadc::Avee,
2028        adadc::Avee,
2029        Adadc_SPEC,
2030        crate::common::RW,
2031    > {
2032        crate::common::RegisterField::<
2033            7,
2034            0x1,
2035            1,
2036            0,
2037            adadc::Avee,
2038            adadc::Avee,
2039            Adadc_SPEC,
2040            crate::common::RW,
2041        >::from_register(self, 0)
2042    }
2043}
2044impl ::core::default::Default for Adadc {
2045    #[inline(always)]
2046    fn default() -> Adadc {
2047        <crate::RegValueT<Adadc_SPEC> as RegisterValue<_>>::new(0)
2048    }
2049}
2050pub mod adadc {
2051
2052    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2053    pub struct Adc_SPEC;
2054    pub type Adc = crate::EnumBitfieldStruct<u8, Adc_SPEC>;
2055    impl Adc {
2056        #[doc = "1-time conversion (no addition, same as normal conversion)"]
2057        pub const _000: Self = Self::new(0);
2058
2059        #[doc = "2-time conversion (1 addition)"]
2060        pub const _001: Self = Self::new(1);
2061
2062        #[doc = "3-time conversion (2 additions)"]
2063        pub const _010: Self = Self::new(2);
2064
2065        #[doc = "4-time conversion (3 additions)"]
2066        pub const _011: Self = Self::new(3);
2067
2068        #[doc = "16-time conversion (15 additions)"]
2069        pub const _101: Self = Self::new(5);
2070    }
2071    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2072    pub struct Avee_SPEC;
2073    pub type Avee = crate::EnumBitfieldStruct<u8, Avee_SPEC>;
2074    impl Avee {
2075        #[doc = "Enable addition mode"]
2076        pub const _0: Self = Self::new(0);
2077
2078        #[doc = "Enable average mode"]
2079        pub const _1: Self = Self::new(1);
2080    }
2081}
2082#[doc(hidden)]
2083#[derive(Copy, Clone, Eq, PartialEq)]
2084pub struct Adcer_SPEC;
2085impl crate::sealed::RegSpec for Adcer_SPEC {
2086    type DataType = u16;
2087}
2088
2089#[doc = "A/D Control Extended Register"]
2090pub type Adcer = crate::RegValueT<Adcer_SPEC>;
2091
2092impl Adcer {
2093    #[inline(always)]
2094    pub fn adprc(
2095        self,
2096    ) -> crate::common::RegisterField<
2097        1,
2098        0x3,
2099        1,
2100        0,
2101        adcer::Adprc,
2102        adcer::Adprc,
2103        Adcer_SPEC,
2104        crate::common::RW,
2105    > {
2106        crate::common::RegisterField::<
2107            1,
2108            0x3,
2109            1,
2110            0,
2111            adcer::Adprc,
2112            adcer::Adprc,
2113            Adcer_SPEC,
2114            crate::common::RW,
2115        >::from_register(self, 0)
2116    }
2117
2118    #[doc = "A/D Data Register Automatic Clearing Enable"]
2119    #[inline(always)]
2120    pub fn ace(
2121        self,
2122    ) -> crate::common::RegisterField<
2123        5,
2124        0x1,
2125        1,
2126        0,
2127        adcer::Ace,
2128        adcer::Ace,
2129        Adcer_SPEC,
2130        crate::common::RW,
2131    > {
2132        crate::common::RegisterField::<
2133            5,
2134            0x1,
2135            1,
2136            0,
2137            adcer::Ace,
2138            adcer::Ace,
2139            Adcer_SPEC,
2140            crate::common::RW,
2141        >::from_register(self, 0)
2142    }
2143
2144    #[doc = "Self-Diagnosis Conversion Voltage Select"]
2145    #[inline(always)]
2146    pub fn diagval(
2147        self,
2148    ) -> crate::common::RegisterField<
2149        8,
2150        0x3,
2151        1,
2152        0,
2153        adcer::Diagval,
2154        adcer::Diagval,
2155        Adcer_SPEC,
2156        crate::common::RW,
2157    > {
2158        crate::common::RegisterField::<
2159            8,
2160            0x3,
2161            1,
2162            0,
2163            adcer::Diagval,
2164            adcer::Diagval,
2165            Adcer_SPEC,
2166            crate::common::RW,
2167        >::from_register(self, 0)
2168    }
2169
2170    #[doc = "Self-Diagnosis Mode Select"]
2171    #[inline(always)]
2172    pub fn diagld(
2173        self,
2174    ) -> crate::common::RegisterField<
2175        10,
2176        0x1,
2177        1,
2178        0,
2179        adcer::Diagld,
2180        adcer::Diagld,
2181        Adcer_SPEC,
2182        crate::common::RW,
2183    > {
2184        crate::common::RegisterField::<
2185            10,
2186            0x1,
2187            1,
2188            0,
2189            adcer::Diagld,
2190            adcer::Diagld,
2191            Adcer_SPEC,
2192            crate::common::RW,
2193        >::from_register(self, 0)
2194    }
2195
2196    #[doc = "Self-Diagnosis Enable"]
2197    #[inline(always)]
2198    pub fn diagm(
2199        self,
2200    ) -> crate::common::RegisterField<
2201        11,
2202        0x1,
2203        1,
2204        0,
2205        adcer::Diagm,
2206        adcer::Diagm,
2207        Adcer_SPEC,
2208        crate::common::RW,
2209    > {
2210        crate::common::RegisterField::<
2211            11,
2212            0x1,
2213            1,
2214            0,
2215            adcer::Diagm,
2216            adcer::Diagm,
2217            Adcer_SPEC,
2218            crate::common::RW,
2219        >::from_register(self, 0)
2220    }
2221
2222    #[doc = "A/D Data Register Format Select"]
2223    #[inline(always)]
2224    pub fn adrfmt(
2225        self,
2226    ) -> crate::common::RegisterField<
2227        15,
2228        0x1,
2229        1,
2230        0,
2231        adcer::Adrfmt,
2232        adcer::Adrfmt,
2233        Adcer_SPEC,
2234        crate::common::RW,
2235    > {
2236        crate::common::RegisterField::<
2237            15,
2238            0x1,
2239            1,
2240            0,
2241            adcer::Adrfmt,
2242            adcer::Adrfmt,
2243            Adcer_SPEC,
2244            crate::common::RW,
2245        >::from_register(self, 0)
2246    }
2247}
2248impl ::core::default::Default for Adcer {
2249    #[inline(always)]
2250    fn default() -> Adcer {
2251        <crate::RegValueT<Adcer_SPEC> as RegisterValue<_>>::new(0)
2252    }
2253}
2254pub mod adcer {
2255
2256    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2257    pub struct Adprc_SPEC;
2258    pub type Adprc = crate::EnumBitfieldStruct<u8, Adprc_SPEC>;
2259    impl Adprc {
2260        #[doc = "12-bit accuracy"]
2261        pub const _00: Self = Self::new(0);
2262
2263        #[doc = "10-bit accuracy"]
2264        pub const _01: Self = Self::new(1);
2265
2266        #[doc = "8-bit accuracy"]
2267        pub const _10: Self = Self::new(2);
2268
2269        #[doc = "Setting prohibited"]
2270        pub const _11: Self = Self::new(3);
2271    }
2272    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2273    pub struct Ace_SPEC;
2274    pub type Ace = crate::EnumBitfieldStruct<u8, Ace_SPEC>;
2275    impl Ace {
2276        #[doc = "Disable automatic clearing"]
2277        pub const _0: Self = Self::new(0);
2278
2279        #[doc = "Enable automatic clearing"]
2280        pub const _1: Self = Self::new(1);
2281    }
2282    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2283    pub struct Diagval_SPEC;
2284    pub type Diagval = crate::EnumBitfieldStruct<u8, Diagval_SPEC>;
2285    impl Diagval {
2286        #[doc = "Setting prohibited when self-diagnosis is enabled"]
2287        pub const _00: Self = Self::new(0);
2288
2289        #[doc = "0 volts"]
2290        pub const _01: Self = Self::new(1);
2291
2292        #[doc = "Reference voltage × 1/2"]
2293        pub const _10: Self = Self::new(2);
2294
2295        #[doc = "Reference voltage"]
2296        pub const _11: Self = Self::new(3);
2297    }
2298    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2299    pub struct Diagld_SPEC;
2300    pub type Diagld = crate::EnumBitfieldStruct<u8, Diagld_SPEC>;
2301    impl Diagld {
2302        #[doc = "Select rotation mode for self-diagnosis voltage"]
2303        pub const _0: Self = Self::new(0);
2304
2305        #[doc = "Select mixed mode for self-diagnosis voltage"]
2306        pub const _1: Self = Self::new(1);
2307    }
2308    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2309    pub struct Diagm_SPEC;
2310    pub type Diagm = crate::EnumBitfieldStruct<u8, Diagm_SPEC>;
2311    impl Diagm {
2312        #[doc = "Disable ADC12 self-diagnosis"]
2313        pub const _0: Self = Self::new(0);
2314
2315        #[doc = "Enable ADC12 self-diagnosis"]
2316        pub const _1: Self = Self::new(1);
2317    }
2318    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2319    pub struct Adrfmt_SPEC;
2320    pub type Adrfmt = crate::EnumBitfieldStruct<u8, Adrfmt_SPEC>;
2321    impl Adrfmt {
2322        #[doc = "Select right-justified for the A/D data register format"]
2323        pub const _0: Self = Self::new(0);
2324
2325        #[doc = "Select left-justified for the A/D data register format"]
2326        pub const _1: Self = Self::new(1);
2327    }
2328}
2329#[doc(hidden)]
2330#[derive(Copy, Clone, Eq, PartialEq)]
2331pub struct Adstrgr_SPEC;
2332impl crate::sealed::RegSpec for Adstrgr_SPEC {
2333    type DataType = u16;
2334}
2335
2336#[doc = "A/D Conversion Start Trigger Select Register"]
2337pub type Adstrgr = crate::RegValueT<Adstrgr_SPEC>;
2338
2339impl Adstrgr {
2340    #[doc = "A/D Conversion Start Trigger Select for Group B"]
2341    #[inline(always)]
2342    pub fn trsb(
2343        self,
2344    ) -> crate::common::RegisterField<0, 0x3f, 1, 0, u8, u8, Adstrgr_SPEC, crate::common::RW> {
2345        crate::common::RegisterField::<0,0x3f,1,0,u8,u8,Adstrgr_SPEC,crate::common::RW>::from_register(self,0)
2346    }
2347
2348    #[doc = "A/D Conversion Start Trigger Select"]
2349    #[inline(always)]
2350    pub fn trsa(
2351        self,
2352    ) -> crate::common::RegisterField<8, 0x3f, 1, 0, u8, u8, Adstrgr_SPEC, crate::common::RW> {
2353        crate::common::RegisterField::<8,0x3f,1,0,u8,u8,Adstrgr_SPEC,crate::common::RW>::from_register(self,0)
2354    }
2355}
2356impl ::core::default::Default for Adstrgr {
2357    #[inline(always)]
2358    fn default() -> Adstrgr {
2359        <crate::RegValueT<Adstrgr_SPEC> as RegisterValue<_>>::new(0)
2360    }
2361}
2362
2363#[doc(hidden)]
2364#[derive(Copy, Clone, Eq, PartialEq)]
2365pub struct Adexicr_SPEC;
2366impl crate::sealed::RegSpec for Adexicr_SPEC {
2367    type DataType = u16;
2368}
2369
2370#[doc = "A/D Conversion Extended Input Control Registers"]
2371pub type Adexicr = crate::RegValueT<Adexicr_SPEC>;
2372
2373impl Adexicr {
2374    #[doc = "Temperature Sensor Output A/D-Converted Value Addition/Average Mode Select"]
2375    #[inline(always)]
2376    pub fn tssad(
2377        self,
2378    ) -> crate::common::RegisterField<
2379        0,
2380        0x1,
2381        1,
2382        0,
2383        adexicr::Tssad,
2384        adexicr::Tssad,
2385        Adexicr_SPEC,
2386        crate::common::RW,
2387    > {
2388        crate::common::RegisterField::<
2389            0,
2390            0x1,
2391            1,
2392            0,
2393            adexicr::Tssad,
2394            adexicr::Tssad,
2395            Adexicr_SPEC,
2396            crate::common::RW,
2397        >::from_register(self, 0)
2398    }
2399
2400    #[doc = "Internal Reference Voltage A/D-Converted Value Addition/Average Mode Select"]
2401    #[inline(always)]
2402    pub fn ocsad(
2403        self,
2404    ) -> crate::common::RegisterField<
2405        1,
2406        0x1,
2407        1,
2408        0,
2409        adexicr::Ocsad,
2410        adexicr::Ocsad,
2411        Adexicr_SPEC,
2412        crate::common::RW,
2413    > {
2414        crate::common::RegisterField::<
2415            1,
2416            0x1,
2417            1,
2418            0,
2419            adexicr::Ocsad,
2420            adexicr::Ocsad,
2421            Adexicr_SPEC,
2422            crate::common::RW,
2423        >::from_register(self, 0)
2424    }
2425
2426    #[doc = "Temperature Sensor Output A/D Conversion Select"]
2427    #[inline(always)]
2428    pub fn tssa(
2429        self,
2430    ) -> crate::common::RegisterField<
2431        8,
2432        0x1,
2433        1,
2434        0,
2435        adexicr::Tssa,
2436        adexicr::Tssa,
2437        Adexicr_SPEC,
2438        crate::common::RW,
2439    > {
2440        crate::common::RegisterField::<
2441            8,
2442            0x1,
2443            1,
2444            0,
2445            adexicr::Tssa,
2446            adexicr::Tssa,
2447            Adexicr_SPEC,
2448            crate::common::RW,
2449        >::from_register(self, 0)
2450    }
2451
2452    #[doc = "Internal Reference Voltage A/D Conversion Select"]
2453    #[inline(always)]
2454    pub fn ocsa(
2455        self,
2456    ) -> crate::common::RegisterField<
2457        9,
2458        0x1,
2459        1,
2460        0,
2461        adexicr::Ocsa,
2462        adexicr::Ocsa,
2463        Adexicr_SPEC,
2464        crate::common::RW,
2465    > {
2466        crate::common::RegisterField::<
2467            9,
2468            0x1,
2469            1,
2470            0,
2471            adexicr::Ocsa,
2472            adexicr::Ocsa,
2473            Adexicr_SPEC,
2474            crate::common::RW,
2475        >::from_register(self, 0)
2476    }
2477
2478    #[doc = "Temperature Sensor Output A/D Conversion Select for Group B"]
2479    #[inline(always)]
2480    pub fn tssb(
2481        self,
2482    ) -> crate::common::RegisterField<
2483        10,
2484        0x1,
2485        1,
2486        0,
2487        adexicr::Tssb,
2488        adexicr::Tssb,
2489        Adexicr_SPEC,
2490        crate::common::RW,
2491    > {
2492        crate::common::RegisterField::<
2493            10,
2494            0x1,
2495            1,
2496            0,
2497            adexicr::Tssb,
2498            adexicr::Tssb,
2499            Adexicr_SPEC,
2500            crate::common::RW,
2501        >::from_register(self, 0)
2502    }
2503
2504    #[doc = "Internal Reference Voltage A/D Conversion Select for Group B"]
2505    #[inline(always)]
2506    pub fn ocsb(
2507        self,
2508    ) -> crate::common::RegisterField<
2509        11,
2510        0x1,
2511        1,
2512        0,
2513        adexicr::Ocsb,
2514        adexicr::Ocsb,
2515        Adexicr_SPEC,
2516        crate::common::RW,
2517    > {
2518        crate::common::RegisterField::<
2519            11,
2520            0x1,
2521            1,
2522            0,
2523            adexicr::Ocsb,
2524            adexicr::Ocsb,
2525            Adexicr_SPEC,
2526            crate::common::RW,
2527        >::from_register(self, 0)
2528    }
2529}
2530impl ::core::default::Default for Adexicr {
2531    #[inline(always)]
2532    fn default() -> Adexicr {
2533        <crate::RegValueT<Adexicr_SPEC> as RegisterValue<_>>::new(0)
2534    }
2535}
2536pub mod adexicr {
2537
2538    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2539    pub struct Tssad_SPEC;
2540    pub type Tssad = crate::EnumBitfieldStruct<u8, Tssad_SPEC>;
2541    impl Tssad {
2542        #[doc = "Do not select addition/average mode for temperature sensor output."]
2543        pub const _0: Self = Self::new(0);
2544
2545        #[doc = "Select addition/average mode for temperature sensor output."]
2546        pub const _1: Self = Self::new(1);
2547    }
2548    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2549    pub struct Ocsad_SPEC;
2550    pub type Ocsad = crate::EnumBitfieldStruct<u8, Ocsad_SPEC>;
2551    impl Ocsad {
2552        #[doc = "Do not select addition/average mode for internal reference voltage."]
2553        pub const _0: Self = Self::new(0);
2554
2555        #[doc = "Select addition/average mode for internal reference voltage."]
2556        pub const _1: Self = Self::new(1);
2557    }
2558    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2559    pub struct Tssa_SPEC;
2560    pub type Tssa = crate::EnumBitfieldStruct<u8, Tssa_SPEC>;
2561    impl Tssa {
2562        #[doc = "Disable A/D conversion of temperature sensor output"]
2563        pub const _0: Self = Self::new(0);
2564
2565        #[doc = "Enable A/D conversion of temperature sensor output"]
2566        pub const _1: Self = Self::new(1);
2567    }
2568    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2569    pub struct Ocsa_SPEC;
2570    pub type Ocsa = crate::EnumBitfieldStruct<u8, Ocsa_SPEC>;
2571    impl Ocsa {
2572        #[doc = "Disable A/D conversion of internal reference voltage"]
2573        pub const _0: Self = Self::new(0);
2574
2575        #[doc = "Enable A/D conversion of internal reference voltage"]
2576        pub const _1: Self = Self::new(1);
2577    }
2578    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2579    pub struct Tssb_SPEC;
2580    pub type Tssb = crate::EnumBitfieldStruct<u8, Tssb_SPEC>;
2581    impl Tssb {
2582        #[doc = "Disable A/D conversion of temperature sensor output"]
2583        pub const _0: Self = Self::new(0);
2584
2585        #[doc = "Enable A/D conversion of temperature sensor output"]
2586        pub const _1: Self = Self::new(1);
2587    }
2588    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2589    pub struct Ocsb_SPEC;
2590    pub type Ocsb = crate::EnumBitfieldStruct<u8, Ocsb_SPEC>;
2591    impl Ocsb {
2592        #[doc = "Disable A/D conversion of internal reference voltage"]
2593        pub const _0: Self = Self::new(0);
2594
2595        #[doc = "Enable A/D conversion of internal reference voltage"]
2596        pub const _1: Self = Self::new(1);
2597    }
2598}
2599#[doc(hidden)]
2600#[derive(Copy, Clone, Eq, PartialEq)]
2601pub struct Adansb0_SPEC;
2602impl crate::sealed::RegSpec for Adansb0_SPEC {
2603    type DataType = u16;
2604}
2605
2606#[doc = "A/D Channel Select Register B0"]
2607pub type Adansb0 = crate::RegValueT<Adansb0_SPEC>;
2608
2609impl Adansb0 {
2610    #[doc = "A/D Conversion Channels Select"]
2611    #[inline(always)]
2612    pub fn ansb0(
2613        self,
2614    ) -> crate::common::RegisterField<
2615        0,
2616        0x1,
2617        1,
2618        0,
2619        adansb0::Ansb0,
2620        adansb0::Ansb0,
2621        Adansb0_SPEC,
2622        crate::common::RW,
2623    > {
2624        crate::common::RegisterField::<
2625            0,
2626            0x1,
2627            1,
2628            0,
2629            adansb0::Ansb0,
2630            adansb0::Ansb0,
2631            Adansb0_SPEC,
2632            crate::common::RW,
2633        >::from_register(self, 0)
2634    }
2635
2636    #[doc = "A/D Conversion Channels Select"]
2637    #[inline(always)]
2638    pub fn ansb1(
2639        self,
2640    ) -> crate::common::RegisterField<
2641        1,
2642        0x1,
2643        1,
2644        0,
2645        adansb0::Ansb1,
2646        adansb0::Ansb1,
2647        Adansb0_SPEC,
2648        crate::common::RW,
2649    > {
2650        crate::common::RegisterField::<
2651            1,
2652            0x1,
2653            1,
2654            0,
2655            adansb0::Ansb1,
2656            adansb0::Ansb1,
2657            Adansb0_SPEC,
2658            crate::common::RW,
2659        >::from_register(self, 0)
2660    }
2661
2662    #[doc = "A/D Conversion Channels Select"]
2663    #[inline(always)]
2664    pub fn ansb2(
2665        self,
2666    ) -> crate::common::RegisterField<
2667        2,
2668        0x1,
2669        1,
2670        0,
2671        adansb0::Ansb2,
2672        adansb0::Ansb2,
2673        Adansb0_SPEC,
2674        crate::common::RW,
2675    > {
2676        crate::common::RegisterField::<
2677            2,
2678            0x1,
2679            1,
2680            0,
2681            adansb0::Ansb2,
2682            adansb0::Ansb2,
2683            Adansb0_SPEC,
2684            crate::common::RW,
2685        >::from_register(self, 0)
2686    }
2687
2688    #[doc = "A/D Conversion Channels Select"]
2689    #[inline(always)]
2690    pub fn ansb3(
2691        self,
2692    ) -> crate::common::RegisterField<
2693        3,
2694        0x1,
2695        1,
2696        0,
2697        adansb0::Ansb3,
2698        adansb0::Ansb3,
2699        Adansb0_SPEC,
2700        crate::common::RW,
2701    > {
2702        crate::common::RegisterField::<
2703            3,
2704            0x1,
2705            1,
2706            0,
2707            adansb0::Ansb3,
2708            adansb0::Ansb3,
2709            Adansb0_SPEC,
2710            crate::common::RW,
2711        >::from_register(self, 0)
2712    }
2713
2714    #[doc = "A/D Conversion Channels Select"]
2715    #[inline(always)]
2716    pub fn ansb4(
2717        self,
2718    ) -> crate::common::RegisterField<
2719        4,
2720        0x1,
2721        1,
2722        0,
2723        adansb0::Ansb4,
2724        adansb0::Ansb4,
2725        Adansb0_SPEC,
2726        crate::common::RW,
2727    > {
2728        crate::common::RegisterField::<
2729            4,
2730            0x1,
2731            1,
2732            0,
2733            adansb0::Ansb4,
2734            adansb0::Ansb4,
2735            Adansb0_SPEC,
2736            crate::common::RW,
2737        >::from_register(self, 0)
2738    }
2739
2740    #[doc = "A/D Conversion Channels Select"]
2741    #[inline(always)]
2742    pub fn ansb5(
2743        self,
2744    ) -> crate::common::RegisterField<
2745        5,
2746        0x1,
2747        1,
2748        0,
2749        adansb0::Ansb5,
2750        adansb0::Ansb5,
2751        Adansb0_SPEC,
2752        crate::common::RW,
2753    > {
2754        crate::common::RegisterField::<
2755            5,
2756            0x1,
2757            1,
2758            0,
2759            adansb0::Ansb5,
2760            adansb0::Ansb5,
2761            Adansb0_SPEC,
2762            crate::common::RW,
2763        >::from_register(self, 0)
2764    }
2765
2766    #[doc = "A/D Conversion Channels Select"]
2767    #[inline(always)]
2768    pub fn ansb6(
2769        self,
2770    ) -> crate::common::RegisterField<
2771        6,
2772        0x1,
2773        1,
2774        0,
2775        adansb0::Ansb6,
2776        adansb0::Ansb6,
2777        Adansb0_SPEC,
2778        crate::common::RW,
2779    > {
2780        crate::common::RegisterField::<
2781            6,
2782            0x1,
2783            1,
2784            0,
2785            adansb0::Ansb6,
2786            adansb0::Ansb6,
2787            Adansb0_SPEC,
2788            crate::common::RW,
2789        >::from_register(self, 0)
2790    }
2791
2792    #[doc = "A/D Conversion Channels Select"]
2793    #[inline(always)]
2794    pub fn ansb7(
2795        self,
2796    ) -> crate::common::RegisterField<
2797        7,
2798        0x1,
2799        1,
2800        0,
2801        adansb0::Ansb7,
2802        adansb0::Ansb7,
2803        Adansb0_SPEC,
2804        crate::common::RW,
2805    > {
2806        crate::common::RegisterField::<
2807            7,
2808            0x1,
2809            1,
2810            0,
2811            adansb0::Ansb7,
2812            adansb0::Ansb7,
2813            Adansb0_SPEC,
2814            crate::common::RW,
2815        >::from_register(self, 0)
2816    }
2817
2818    #[doc = "A/D Conversion Channels Select"]
2819    #[inline(always)]
2820    pub fn ansb8(
2821        self,
2822    ) -> crate::common::RegisterField<
2823        8,
2824        0x1,
2825        1,
2826        0,
2827        adansb0::Ansb8,
2828        adansb0::Ansb8,
2829        Adansb0_SPEC,
2830        crate::common::RW,
2831    > {
2832        crate::common::RegisterField::<
2833            8,
2834            0x1,
2835            1,
2836            0,
2837            adansb0::Ansb8,
2838            adansb0::Ansb8,
2839            Adansb0_SPEC,
2840            crate::common::RW,
2841        >::from_register(self, 0)
2842    }
2843
2844    #[doc = "A/D Conversion Channels Select"]
2845    #[inline(always)]
2846    pub fn ansb9(
2847        self,
2848    ) -> crate::common::RegisterField<
2849        9,
2850        0x1,
2851        1,
2852        0,
2853        adansb0::Ansb9,
2854        adansb0::Ansb9,
2855        Adansb0_SPEC,
2856        crate::common::RW,
2857    > {
2858        crate::common::RegisterField::<
2859            9,
2860            0x1,
2861            1,
2862            0,
2863            adansb0::Ansb9,
2864            adansb0::Ansb9,
2865            Adansb0_SPEC,
2866            crate::common::RW,
2867        >::from_register(self, 0)
2868    }
2869
2870    #[doc = "A/D Conversion Channels Select"]
2871    #[inline(always)]
2872    pub fn ansb12(
2873        self,
2874    ) -> crate::common::RegisterField<
2875        12,
2876        0x1,
2877        1,
2878        0,
2879        adansb0::Ansb12,
2880        adansb0::Ansb12,
2881        Adansb0_SPEC,
2882        crate::common::RW,
2883    > {
2884        crate::common::RegisterField::<
2885            12,
2886            0x1,
2887            1,
2888            0,
2889            adansb0::Ansb12,
2890            adansb0::Ansb12,
2891            Adansb0_SPEC,
2892            crate::common::RW,
2893        >::from_register(self, 0)
2894    }
2895
2896    #[doc = "A/D Conversion Channels Select"]
2897    #[inline(always)]
2898    pub fn ansb13(
2899        self,
2900    ) -> crate::common::RegisterField<
2901        13,
2902        0x1,
2903        1,
2904        0,
2905        adansb0::Ansb13,
2906        adansb0::Ansb13,
2907        Adansb0_SPEC,
2908        crate::common::RW,
2909    > {
2910        crate::common::RegisterField::<
2911            13,
2912            0x1,
2913            1,
2914            0,
2915            adansb0::Ansb13,
2916            adansb0::Ansb13,
2917            Adansb0_SPEC,
2918            crate::common::RW,
2919        >::from_register(self, 0)
2920    }
2921}
2922impl ::core::default::Default for Adansb0 {
2923    #[inline(always)]
2924    fn default() -> Adansb0 {
2925        <crate::RegValueT<Adansb0_SPEC> as RegisterValue<_>>::new(0)
2926    }
2927}
2928pub mod adansb0 {
2929
2930    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2931    pub struct Ansb0_SPEC;
2932    pub type Ansb0 = crate::EnumBitfieldStruct<u8, Ansb0_SPEC>;
2933    impl Ansb0 {
2934        #[doc = "Do not select associated input channel."]
2935        pub const _0: Self = Self::new(0);
2936
2937        #[doc = "Select associated input channel."]
2938        pub const _1: Self = Self::new(1);
2939    }
2940    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2941    pub struct Ansb1_SPEC;
2942    pub type Ansb1 = crate::EnumBitfieldStruct<u8, Ansb1_SPEC>;
2943    impl Ansb1 {
2944        #[doc = "Do not select associated input channel."]
2945        pub const _0: Self = Self::new(0);
2946
2947        #[doc = "Select associated input channel."]
2948        pub const _1: Self = Self::new(1);
2949    }
2950    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2951    pub struct Ansb2_SPEC;
2952    pub type Ansb2 = crate::EnumBitfieldStruct<u8, Ansb2_SPEC>;
2953    impl Ansb2 {
2954        #[doc = "Do not select associated input channel."]
2955        pub const _0: Self = Self::new(0);
2956
2957        #[doc = "Select associated input channel."]
2958        pub const _1: Self = Self::new(1);
2959    }
2960    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2961    pub struct Ansb3_SPEC;
2962    pub type Ansb3 = crate::EnumBitfieldStruct<u8, Ansb3_SPEC>;
2963    impl Ansb3 {
2964        #[doc = "Do not select associated input channel."]
2965        pub const _0: Self = Self::new(0);
2966
2967        #[doc = "Select associated input channel."]
2968        pub const _1: Self = Self::new(1);
2969    }
2970    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2971    pub struct Ansb4_SPEC;
2972    pub type Ansb4 = crate::EnumBitfieldStruct<u8, Ansb4_SPEC>;
2973    impl Ansb4 {
2974        #[doc = "Do not select associated input channel."]
2975        pub const _0: Self = Self::new(0);
2976
2977        #[doc = "Select associated input channel."]
2978        pub const _1: Self = Self::new(1);
2979    }
2980    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2981    pub struct Ansb5_SPEC;
2982    pub type Ansb5 = crate::EnumBitfieldStruct<u8, Ansb5_SPEC>;
2983    impl Ansb5 {
2984        #[doc = "Do not select associated input channel."]
2985        pub const _0: Self = Self::new(0);
2986
2987        #[doc = "Select associated input channel."]
2988        pub const _1: Self = Self::new(1);
2989    }
2990    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
2991    pub struct Ansb6_SPEC;
2992    pub type Ansb6 = crate::EnumBitfieldStruct<u8, Ansb6_SPEC>;
2993    impl Ansb6 {
2994        #[doc = "Do not select associated input channel."]
2995        pub const _0: Self = Self::new(0);
2996
2997        #[doc = "Select associated input channel."]
2998        pub const _1: Self = Self::new(1);
2999    }
3000    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3001    pub struct Ansb7_SPEC;
3002    pub type Ansb7 = crate::EnumBitfieldStruct<u8, Ansb7_SPEC>;
3003    impl Ansb7 {
3004        #[doc = "Do not select associated input channel."]
3005        pub const _0: Self = Self::new(0);
3006
3007        #[doc = "Select associated input channel."]
3008        pub const _1: Self = Self::new(1);
3009    }
3010    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3011    pub struct Ansb8_SPEC;
3012    pub type Ansb8 = crate::EnumBitfieldStruct<u8, Ansb8_SPEC>;
3013    impl Ansb8 {
3014        #[doc = "Do not select associated input channel."]
3015        pub const _0: Self = Self::new(0);
3016
3017        #[doc = "Select associated input channel."]
3018        pub const _1: Self = Self::new(1);
3019    }
3020    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3021    pub struct Ansb9_SPEC;
3022    pub type Ansb9 = crate::EnumBitfieldStruct<u8, Ansb9_SPEC>;
3023    impl Ansb9 {
3024        #[doc = "Do not select associated input channel."]
3025        pub const _0: Self = Self::new(0);
3026
3027        #[doc = "Select associated input channel."]
3028        pub const _1: Self = Self::new(1);
3029    }
3030    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3031    pub struct Ansb12_SPEC;
3032    pub type Ansb12 = crate::EnumBitfieldStruct<u8, Ansb12_SPEC>;
3033    impl Ansb12 {
3034        #[doc = "Do not select associated input channel."]
3035        pub const _0: Self = Self::new(0);
3036
3037        #[doc = "Select associated input channel."]
3038        pub const _1: Self = Self::new(1);
3039    }
3040    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3041    pub struct Ansb13_SPEC;
3042    pub type Ansb13 = crate::EnumBitfieldStruct<u8, Ansb13_SPEC>;
3043    impl Ansb13 {
3044        #[doc = "Do not select associated input channel."]
3045        pub const _0: Self = Self::new(0);
3046
3047        #[doc = "Select associated input channel."]
3048        pub const _1: Self = Self::new(1);
3049    }
3050}
3051#[doc(hidden)]
3052#[derive(Copy, Clone, Eq, PartialEq)]
3053pub struct Adansb1_SPEC;
3054impl crate::sealed::RegSpec for Adansb1_SPEC {
3055    type DataType = u16;
3056}
3057
3058#[doc = "A/D Channel Select Register B1"]
3059pub type Adansb1 = crate::RegValueT<Adansb1_SPEC>;
3060
3061impl Adansb1 {
3062    #[doc = "A/D Conversion Channels Select"]
3063    #[inline(always)]
3064    pub fn ansb16(
3065        self,
3066    ) -> crate::common::RegisterField<
3067        0,
3068        0x1,
3069        1,
3070        0,
3071        adansb1::Ansb16,
3072        adansb1::Ansb16,
3073        Adansb1_SPEC,
3074        crate::common::RW,
3075    > {
3076        crate::common::RegisterField::<
3077            0,
3078            0x1,
3079            1,
3080            0,
3081            adansb1::Ansb16,
3082            adansb1::Ansb16,
3083            Adansb1_SPEC,
3084            crate::common::RW,
3085        >::from_register(self, 0)
3086    }
3087
3088    #[doc = "A/D Conversion Channels Select"]
3089    #[inline(always)]
3090    pub fn ansb17(
3091        self,
3092    ) -> crate::common::RegisterField<
3093        1,
3094        0x1,
3095        1,
3096        0,
3097        adansb1::Ansb17,
3098        adansb1::Ansb17,
3099        Adansb1_SPEC,
3100        crate::common::RW,
3101    > {
3102        crate::common::RegisterField::<
3103            1,
3104            0x1,
3105            1,
3106            0,
3107            adansb1::Ansb17,
3108            adansb1::Ansb17,
3109            Adansb1_SPEC,
3110            crate::common::RW,
3111        >::from_register(self, 0)
3112    }
3113
3114    #[doc = "A/D Conversion Channels Select"]
3115    #[inline(always)]
3116    pub fn ansb18(
3117        self,
3118    ) -> crate::common::RegisterField<
3119        2,
3120        0x1,
3121        1,
3122        0,
3123        adansb1::Ansb18,
3124        adansb1::Ansb18,
3125        Adansb1_SPEC,
3126        crate::common::RW,
3127    > {
3128        crate::common::RegisterField::<
3129            2,
3130            0x1,
3131            1,
3132            0,
3133            adansb1::Ansb18,
3134            adansb1::Ansb18,
3135            Adansb1_SPEC,
3136            crate::common::RW,
3137        >::from_register(self, 0)
3138    }
3139
3140    #[doc = "A/D Conversion Channels Select"]
3141    #[inline(always)]
3142    pub fn ansb19(
3143        self,
3144    ) -> crate::common::RegisterField<
3145        3,
3146        0x1,
3147        1,
3148        0,
3149        adansb1::Ansb19,
3150        adansb1::Ansb19,
3151        Adansb1_SPEC,
3152        crate::common::RW,
3153    > {
3154        crate::common::RegisterField::<
3155            3,
3156            0x1,
3157            1,
3158            0,
3159            adansb1::Ansb19,
3160            adansb1::Ansb19,
3161            Adansb1_SPEC,
3162            crate::common::RW,
3163        >::from_register(self, 0)
3164    }
3165
3166    #[doc = "A/D Conversion Channels Select"]
3167    #[inline(always)]
3168    pub fn ansb20(
3169        self,
3170    ) -> crate::common::RegisterField<
3171        4,
3172        0x1,
3173        1,
3174        0,
3175        adansb1::Ansb20,
3176        adansb1::Ansb20,
3177        Adansb1_SPEC,
3178        crate::common::RW,
3179    > {
3180        crate::common::RegisterField::<
3181            4,
3182            0x1,
3183            1,
3184            0,
3185            adansb1::Ansb20,
3186            adansb1::Ansb20,
3187            Adansb1_SPEC,
3188            crate::common::RW,
3189        >::from_register(self, 0)
3190    }
3191
3192    #[doc = "A/D Conversion Channels Select"]
3193    #[inline(always)]
3194    pub fn ansb21(
3195        self,
3196    ) -> crate::common::RegisterField<
3197        5,
3198        0x1,
3199        1,
3200        0,
3201        adansb1::Ansb21,
3202        adansb1::Ansb21,
3203        Adansb1_SPEC,
3204        crate::common::RW,
3205    > {
3206        crate::common::RegisterField::<
3207            5,
3208            0x1,
3209            1,
3210            0,
3211            adansb1::Ansb21,
3212            adansb1::Ansb21,
3213            Adansb1_SPEC,
3214            crate::common::RW,
3215        >::from_register(self, 0)
3216    }
3217
3218    #[doc = "A/D Conversion Channels Select"]
3219    #[inline(always)]
3220    pub fn ansb22(
3221        self,
3222    ) -> crate::common::RegisterField<
3223        6,
3224        0x1,
3225        1,
3226        0,
3227        adansb1::Ansb22,
3228        adansb1::Ansb22,
3229        Adansb1_SPEC,
3230        crate::common::RW,
3231    > {
3232        crate::common::RegisterField::<
3233            6,
3234            0x1,
3235            1,
3236            0,
3237            adansb1::Ansb22,
3238            adansb1::Ansb22,
3239            Adansb1_SPEC,
3240            crate::common::RW,
3241        >::from_register(self, 0)
3242    }
3243}
3244impl ::core::default::Default for Adansb1 {
3245    #[inline(always)]
3246    fn default() -> Adansb1 {
3247        <crate::RegValueT<Adansb1_SPEC> as RegisterValue<_>>::new(0)
3248    }
3249}
3250pub mod adansb1 {
3251
3252    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3253    pub struct Ansb16_SPEC;
3254    pub type Ansb16 = crate::EnumBitfieldStruct<u8, Ansb16_SPEC>;
3255    impl Ansb16 {
3256        #[doc = "Do not select associated input channel."]
3257        pub const _0: Self = Self::new(0);
3258
3259        #[doc = "Select associated input channel."]
3260        pub const _1: Self = Self::new(1);
3261    }
3262    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3263    pub struct Ansb17_SPEC;
3264    pub type Ansb17 = crate::EnumBitfieldStruct<u8, Ansb17_SPEC>;
3265    impl Ansb17 {
3266        #[doc = "Do not select associated input channel."]
3267        pub const _0: Self = Self::new(0);
3268
3269        #[doc = "Select associated input channel."]
3270        pub const _1: Self = Self::new(1);
3271    }
3272    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3273    pub struct Ansb18_SPEC;
3274    pub type Ansb18 = crate::EnumBitfieldStruct<u8, Ansb18_SPEC>;
3275    impl Ansb18 {
3276        #[doc = "Do not select associated input channel."]
3277        pub const _0: Self = Self::new(0);
3278
3279        #[doc = "Select associated input channel."]
3280        pub const _1: Self = Self::new(1);
3281    }
3282    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3283    pub struct Ansb19_SPEC;
3284    pub type Ansb19 = crate::EnumBitfieldStruct<u8, Ansb19_SPEC>;
3285    impl Ansb19 {
3286        #[doc = "Do not select associated input channel."]
3287        pub const _0: Self = Self::new(0);
3288
3289        #[doc = "Select associated input channel."]
3290        pub const _1: Self = Self::new(1);
3291    }
3292    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3293    pub struct Ansb20_SPEC;
3294    pub type Ansb20 = crate::EnumBitfieldStruct<u8, Ansb20_SPEC>;
3295    impl Ansb20 {
3296        #[doc = "Do not select associated input channel."]
3297        pub const _0: Self = Self::new(0);
3298
3299        #[doc = "Select associated input channel."]
3300        pub const _1: Self = Self::new(1);
3301    }
3302    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3303    pub struct Ansb21_SPEC;
3304    pub type Ansb21 = crate::EnumBitfieldStruct<u8, Ansb21_SPEC>;
3305    impl Ansb21 {
3306        #[doc = "Do not select associated input channel."]
3307        pub const _0: Self = Self::new(0);
3308
3309        #[doc = "Select associated input channel."]
3310        pub const _1: Self = Self::new(1);
3311    }
3312    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3313    pub struct Ansb22_SPEC;
3314    pub type Ansb22 = crate::EnumBitfieldStruct<u8, Ansb22_SPEC>;
3315    impl Ansb22 {
3316        #[doc = "Do not select associated input channel."]
3317        pub const _0: Self = Self::new(0);
3318
3319        #[doc = "Select associated input channel."]
3320        pub const _1: Self = Self::new(1);
3321    }
3322}
3323#[doc(hidden)]
3324#[derive(Copy, Clone, Eq, PartialEq)]
3325pub struct Addbldr_SPEC;
3326impl crate::sealed::RegSpec for Addbldr_SPEC {
3327    type DataType = u16;
3328}
3329
3330#[doc = "A/D Data Duplexing Register"]
3331pub type Addbldr = crate::RegValueT<Addbldr_SPEC>;
3332
3333impl Addbldr {
3334    #[doc = "Converted Value 15 to 0"]
3335    #[inline(always)]
3336    pub fn addbldr(
3337        self,
3338    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addbldr_SPEC, crate::common::R>
3339    {
3340        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addbldr_SPEC,crate::common::R>::from_register(self,0)
3341    }
3342}
3343impl ::core::default::Default for Addbldr {
3344    #[inline(always)]
3345    fn default() -> Addbldr {
3346        <crate::RegValueT<Addbldr_SPEC> as RegisterValue<_>>::new(0)
3347    }
3348}
3349
3350#[doc(hidden)]
3351#[derive(Copy, Clone, Eq, PartialEq)]
3352pub struct Adtsdr_SPEC;
3353impl crate::sealed::RegSpec for Adtsdr_SPEC {
3354    type DataType = u16;
3355}
3356
3357#[doc = "A/D Temperature Sensor Data Register"]
3358pub type Adtsdr = crate::RegValueT<Adtsdr_SPEC>;
3359
3360impl Adtsdr {
3361    #[doc = "Converted Value 15 to 0"]
3362    #[inline(always)]
3363    pub fn adtsdr(
3364        self,
3365    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Adtsdr_SPEC, crate::common::R>
3366    {
3367        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Adtsdr_SPEC,crate::common::R>::from_register(self,0)
3368    }
3369}
3370impl ::core::default::Default for Adtsdr {
3371    #[inline(always)]
3372    fn default() -> Adtsdr {
3373        <crate::RegValueT<Adtsdr_SPEC> as RegisterValue<_>>::new(0)
3374    }
3375}
3376
3377#[doc(hidden)]
3378#[derive(Copy, Clone, Eq, PartialEq)]
3379pub struct Adocdr_SPEC;
3380impl crate::sealed::RegSpec for Adocdr_SPEC {
3381    type DataType = u16;
3382}
3383
3384#[doc = "A/D Internal Reference Voltage Data Register"]
3385pub type Adocdr = crate::RegValueT<Adocdr_SPEC>;
3386
3387impl Adocdr {
3388    #[doc = "Converted Value 15 to 0"]
3389    #[inline(always)]
3390    pub fn adocdr(
3391        self,
3392    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Adocdr_SPEC, crate::common::R>
3393    {
3394        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Adocdr_SPEC,crate::common::R>::from_register(self,0)
3395    }
3396}
3397impl ::core::default::Default for Adocdr {
3398    #[inline(always)]
3399    fn default() -> Adocdr {
3400        <crate::RegValueT<Adocdr_SPEC> as RegisterValue<_>>::new(0)
3401    }
3402}
3403
3404#[doc(hidden)]
3405#[derive(Copy, Clone, Eq, PartialEq)]
3406pub struct Adrd_SPEC;
3407impl crate::sealed::RegSpec for Adrd_SPEC {
3408    type DataType = u16;
3409}
3410
3411#[doc = "A/D Self-Diagnosis Data Register"]
3412pub type Adrd = crate::RegValueT<Adrd_SPEC>;
3413
3414impl Adrd {
3415    #[doc = "Converted Value 11 to 0"]
3416    #[inline(always)]
3417    pub fn ad(
3418        self,
3419    ) -> crate::common::RegisterField<0, 0xfff, 1, 0, u16, u16, Adrd_SPEC, crate::common::R> {
3420        crate::common::RegisterField::<0,0xfff,1,0,u16,u16,Adrd_SPEC,crate::common::R>::from_register(self,0)
3421    }
3422
3423    #[doc = "Self-Diagnosis Status"]
3424    #[inline(always)]
3425    pub fn diagst(
3426        self,
3427    ) -> crate::common::RegisterField<
3428        14,
3429        0x3,
3430        1,
3431        0,
3432        adrd::Diagst,
3433        adrd::Diagst,
3434        Adrd_SPEC,
3435        crate::common::R,
3436    > {
3437        crate::common::RegisterField::<
3438            14,
3439            0x3,
3440            1,
3441            0,
3442            adrd::Diagst,
3443            adrd::Diagst,
3444            Adrd_SPEC,
3445            crate::common::R,
3446        >::from_register(self, 0)
3447    }
3448}
3449impl ::core::default::Default for Adrd {
3450    #[inline(always)]
3451    fn default() -> Adrd {
3452        <crate::RegValueT<Adrd_SPEC> as RegisterValue<_>>::new(0)
3453    }
3454}
3455pub mod adrd {
3456
3457    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3458    pub struct Diagst_SPEC;
3459    pub type Diagst = crate::EnumBitfieldStruct<u8, Diagst_SPEC>;
3460    impl Diagst {
3461        #[doc = "Self-diagnosis not executed after power-on."]
3462        pub const _00: Self = Self::new(0);
3463
3464        #[doc = "Self-diagnosis was executed using the 0 V voltage."]
3465        pub const _01: Self = Self::new(1);
3466
3467        #[doc = "Self-diagnosis was executed using the reference voltage × 1/2."]
3468        pub const _10: Self = Self::new(2);
3469
3470        #[doc = "Self-diagnosis was executed using the reference voltage ."]
3471        pub const _11: Self = Self::new(3);
3472    }
3473}
3474#[doc(hidden)]
3475#[derive(Copy, Clone, Eq, PartialEq)]
3476pub struct Addr_SPEC;
3477impl crate::sealed::RegSpec for Addr_SPEC {
3478    type DataType = u16;
3479}
3480
3481#[doc = "A/D Data Registers %s"]
3482pub type Addr = crate::RegValueT<Addr_SPEC>;
3483
3484impl Addr {
3485    #[doc = "Converted Value 15 to 0"]
3486    #[inline(always)]
3487    pub fn addr(
3488        self,
3489    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addr_SPEC, crate::common::R> {
3490        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addr_SPEC,crate::common::R>::from_register(self,0)
3491    }
3492}
3493impl ::core::default::Default for Addr {
3494    #[inline(always)]
3495    fn default() -> Addr {
3496        <crate::RegValueT<Addr_SPEC> as RegisterValue<_>>::new(0)
3497    }
3498}
3499
3500#[doc(hidden)]
3501#[derive(Copy, Clone, Eq, PartialEq)]
3502pub struct Addiscr_SPEC;
3503impl crate::sealed::RegSpec for Addiscr_SPEC {
3504    type DataType = u8;
3505}
3506
3507#[doc = "A/D Disconnection Detection Control Register"]
3508pub type Addiscr = crate::RegValueT<Addiscr_SPEC>;
3509
3510impl Addiscr {
3511    #[doc = "Disconnection Detection Assist Setting"]
3512    #[inline(always)]
3513    pub fn adndis(
3514        self,
3515    ) -> crate::common::RegisterField<
3516        0,
3517        0xf,
3518        1,
3519        0,
3520        addiscr::Adndis,
3521        addiscr::Adndis,
3522        Addiscr_SPEC,
3523        crate::common::RW,
3524    > {
3525        crate::common::RegisterField::<
3526            0,
3527            0xf,
3528            1,
3529            0,
3530            addiscr::Adndis,
3531            addiscr::Adndis,
3532            Addiscr_SPEC,
3533            crate::common::RW,
3534        >::from_register(self, 0)
3535    }
3536
3537    #[doc = "Precharge/discharge select"]
3538    #[inline(always)]
3539    pub fn pchg(
3540        self,
3541    ) -> crate::common::RegisterField<
3542        4,
3543        0x1,
3544        1,
3545        0,
3546        addiscr::Pchg,
3547        addiscr::Pchg,
3548        Addiscr_SPEC,
3549        crate::common::RW,
3550    > {
3551        crate::common::RegisterField::<
3552            4,
3553            0x1,
3554            1,
3555            0,
3556            addiscr::Pchg,
3557            addiscr::Pchg,
3558            Addiscr_SPEC,
3559            crate::common::RW,
3560        >::from_register(self, 0)
3561    }
3562}
3563impl ::core::default::Default for Addiscr {
3564    #[inline(always)]
3565    fn default() -> Addiscr {
3566        <crate::RegValueT<Addiscr_SPEC> as RegisterValue<_>>::new(0)
3567    }
3568}
3569pub mod addiscr {
3570
3571    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3572    pub struct Adndis_SPEC;
3573    pub type Adndis = crate::EnumBitfieldStruct<u8, Adndis_SPEC>;
3574    impl Adndis {
3575        #[doc = "The disconnection detection assist function is disabled"]
3576        pub const _0_X_0: Self = Self::new(0);
3577
3578        #[doc = "Setting prohibited"]
3579        pub const _0_X_1: Self = Self::new(1);
3580    }
3581    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3582    pub struct Pchg_SPEC;
3583    pub type Pchg = crate::EnumBitfieldStruct<u8, Pchg_SPEC>;
3584    impl Pchg {
3585        #[doc = "Discharge"]
3586        pub const _0: Self = Self::new(0);
3587
3588        #[doc = "Precharge"]
3589        pub const _1: Self = Self::new(1);
3590    }
3591}
3592#[doc(hidden)]
3593#[derive(Copy, Clone, Eq, PartialEq)]
3594pub struct Adgspcr_SPEC;
3595impl crate::sealed::RegSpec for Adgspcr_SPEC {
3596    type DataType = u16;
3597}
3598
3599#[doc = "A/D Group Scan Priority Control Register"]
3600pub type Adgspcr = crate::RegValueT<Adgspcr_SPEC>;
3601
3602impl Adgspcr {
3603    #[doc = "Group Priority Operation Setting"]
3604    #[inline(always)]
3605    pub fn pgs(
3606        self,
3607    ) -> crate::common::RegisterField<
3608        0,
3609        0x1,
3610        1,
3611        0,
3612        adgspcr::Pgs,
3613        adgspcr::Pgs,
3614        Adgspcr_SPEC,
3615        crate::common::RW,
3616    > {
3617        crate::common::RegisterField::<
3618            0,
3619            0x1,
3620            1,
3621            0,
3622            adgspcr::Pgs,
3623            adgspcr::Pgs,
3624            Adgspcr_SPEC,
3625            crate::common::RW,
3626        >::from_register(self, 0)
3627    }
3628
3629    #[doc = "Lower-Priority Group Restart Setting"]
3630    #[inline(always)]
3631    pub fn gbrscn(
3632        self,
3633    ) -> crate::common::RegisterField<
3634        1,
3635        0x1,
3636        1,
3637        0,
3638        adgspcr::Gbrscn,
3639        adgspcr::Gbrscn,
3640        Adgspcr_SPEC,
3641        crate::common::RW,
3642    > {
3643        crate::common::RegisterField::<
3644            1,
3645            0x1,
3646            1,
3647            0,
3648            adgspcr::Gbrscn,
3649            adgspcr::Gbrscn,
3650            Adgspcr_SPEC,
3651            crate::common::RW,
3652        >::from_register(self, 0)
3653    }
3654
3655    #[doc = "Enabled only when PGS = 1 and GBRSCN = 1."]
3656    #[inline(always)]
3657    pub fn lgrrs(
3658        self,
3659    ) -> crate::common::RegisterField<
3660        14,
3661        0x1,
3662        1,
3663        0,
3664        adgspcr::Lgrrs,
3665        adgspcr::Lgrrs,
3666        Adgspcr_SPEC,
3667        crate::common::RW,
3668    > {
3669        crate::common::RegisterField::<
3670            14,
3671            0x1,
3672            1,
3673            0,
3674            adgspcr::Lgrrs,
3675            adgspcr::Lgrrs,
3676            Adgspcr_SPEC,
3677            crate::common::RW,
3678        >::from_register(self, 0)
3679    }
3680
3681    #[doc = "Single Scan Continuous Start"]
3682    #[inline(always)]
3683    pub fn gbrp(
3684        self,
3685    ) -> crate::common::RegisterField<
3686        15,
3687        0x1,
3688        1,
3689        0,
3690        adgspcr::Gbrp,
3691        adgspcr::Gbrp,
3692        Adgspcr_SPEC,
3693        crate::common::RW,
3694    > {
3695        crate::common::RegisterField::<
3696            15,
3697            0x1,
3698            1,
3699            0,
3700            adgspcr::Gbrp,
3701            adgspcr::Gbrp,
3702            Adgspcr_SPEC,
3703            crate::common::RW,
3704        >::from_register(self, 0)
3705    }
3706}
3707impl ::core::default::Default for Adgspcr {
3708    #[inline(always)]
3709    fn default() -> Adgspcr {
3710        <crate::RegValueT<Adgspcr_SPEC> as RegisterValue<_>>::new(0)
3711    }
3712}
3713pub mod adgspcr {
3714
3715    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3716    pub struct Pgs_SPEC;
3717    pub type Pgs = crate::EnumBitfieldStruct<u8, Pgs_SPEC>;
3718    impl Pgs {
3719        #[doc = "Operate without group priority control."]
3720        pub const _0: Self = Self::new(0);
3721
3722        #[doc = "Operate with group priority control."]
3723        pub const _1: Self = Self::new(1);
3724    }
3725    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3726    pub struct Gbrscn_SPEC;
3727    pub type Gbrscn = crate::EnumBitfieldStruct<u8, Gbrscn_SPEC>;
3728    impl Gbrscn {
3729        #[doc = "Disable rescanning of the group that was stopped in group priority operation"]
3730        pub const _0: Self = Self::new(0);
3731
3732        #[doc = "Enable rescanning of the group that was stopped in group priority operation."]
3733        pub const _1: Self = Self::new(1);
3734    }
3735    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3736    pub struct Lgrrs_SPEC;
3737    pub type Lgrrs = crate::EnumBitfieldStruct<u8, Lgrrs_SPEC>;
3738    impl Lgrrs {
3739        #[doc = "Start rescanning from the first channel for scanning"]
3740        pub const _0: Self = Self::new(0);
3741
3742        #[doc = "Start rescanning from the channel for which A/D conversion is not completed."]
3743        pub const _1: Self = Self::new(1);
3744    }
3745    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3746    pub struct Gbrp_SPEC;
3747    pub type Gbrp = crate::EnumBitfieldStruct<u8, Gbrp_SPEC>;
3748    impl Gbrp {
3749        #[doc = "Single scan is not continuously activated."]
3750        pub const _0: Self = Self::new(0);
3751
3752        #[doc = "Single scan for the group with the lower-priority is continuously activated."]
3753        pub const _1: Self = Self::new(1);
3754    }
3755}
3756#[doc(hidden)]
3757#[derive(Copy, Clone, Eq, PartialEq)]
3758pub struct Addbldra_SPEC;
3759impl crate::sealed::RegSpec for Addbldra_SPEC {
3760    type DataType = u16;
3761}
3762
3763#[doc = "A/D Data Duplexing Register A"]
3764pub type Addbldra = crate::RegValueT<Addbldra_SPEC>;
3765
3766impl Addbldra {
3767    #[doc = "Converted Value 15 to 0"]
3768    #[inline(always)]
3769    pub fn addbldr(
3770        self,
3771    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addbldra_SPEC, crate::common::R>
3772    {
3773        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addbldra_SPEC,crate::common::R>::from_register(self,0)
3774    }
3775}
3776impl ::core::default::Default for Addbldra {
3777    #[inline(always)]
3778    fn default() -> Addbldra {
3779        <crate::RegValueT<Addbldra_SPEC> as RegisterValue<_>>::new(0)
3780    }
3781}
3782
3783#[doc(hidden)]
3784#[derive(Copy, Clone, Eq, PartialEq)]
3785pub struct Addbldrb_SPEC;
3786impl crate::sealed::RegSpec for Addbldrb_SPEC {
3787    type DataType = u16;
3788}
3789
3790#[doc = "A/D Data Duplexing Register B"]
3791pub type Addbldrb = crate::RegValueT<Addbldrb_SPEC>;
3792
3793impl Addbldrb {
3794    #[doc = "Converted Value 15 to 0"]
3795    #[inline(always)]
3796    pub fn addbldr(
3797        self,
3798    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Addbldrb_SPEC, crate::common::R>
3799    {
3800        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Addbldrb_SPEC,crate::common::R>::from_register(self,0)
3801    }
3802}
3803impl ::core::default::Default for Addbldrb {
3804    #[inline(always)]
3805    fn default() -> Addbldrb {
3806        <crate::RegValueT<Addbldrb_SPEC> as RegisterValue<_>>::new(0)
3807    }
3808}
3809
3810#[doc(hidden)]
3811#[derive(Copy, Clone, Eq, PartialEq)]
3812pub struct Adwinmon_SPEC;
3813impl crate::sealed::RegSpec for Adwinmon_SPEC {
3814    type DataType = u8;
3815}
3816
3817#[doc = "A/D Compare Function Window A/B Status Monitor Register"]
3818pub type Adwinmon = crate::RegValueT<Adwinmon_SPEC>;
3819
3820impl Adwinmon {
3821    #[doc = "Combination Result Monitor"]
3822    #[inline(always)]
3823    pub fn moncomb(
3824        self,
3825    ) -> crate::common::RegisterField<
3826        0,
3827        0x1,
3828        1,
3829        0,
3830        adwinmon::Moncomb,
3831        adwinmon::Moncomb,
3832        Adwinmon_SPEC,
3833        crate::common::R,
3834    > {
3835        crate::common::RegisterField::<
3836            0,
3837            0x1,
3838            1,
3839            0,
3840            adwinmon::Moncomb,
3841            adwinmon::Moncomb,
3842            Adwinmon_SPEC,
3843            crate::common::R,
3844        >::from_register(self, 0)
3845    }
3846
3847    #[doc = "Comparison Result Monitor A"]
3848    #[inline(always)]
3849    pub fn moncmpa(
3850        self,
3851    ) -> crate::common::RegisterField<
3852        4,
3853        0x1,
3854        1,
3855        0,
3856        adwinmon::Moncmpa,
3857        adwinmon::Moncmpa,
3858        Adwinmon_SPEC,
3859        crate::common::R,
3860    > {
3861        crate::common::RegisterField::<
3862            4,
3863            0x1,
3864            1,
3865            0,
3866            adwinmon::Moncmpa,
3867            adwinmon::Moncmpa,
3868            Adwinmon_SPEC,
3869            crate::common::R,
3870        >::from_register(self, 0)
3871    }
3872
3873    #[doc = "Comparison Result Monitor B"]
3874    #[inline(always)]
3875    pub fn moncmpb(
3876        self,
3877    ) -> crate::common::RegisterField<
3878        5,
3879        0x1,
3880        1,
3881        0,
3882        adwinmon::Moncmpb,
3883        adwinmon::Moncmpb,
3884        Adwinmon_SPEC,
3885        crate::common::R,
3886    > {
3887        crate::common::RegisterField::<
3888            5,
3889            0x1,
3890            1,
3891            0,
3892            adwinmon::Moncmpb,
3893            adwinmon::Moncmpb,
3894            Adwinmon_SPEC,
3895            crate::common::R,
3896        >::from_register(self, 0)
3897    }
3898}
3899impl ::core::default::Default for Adwinmon {
3900    #[inline(always)]
3901    fn default() -> Adwinmon {
3902        <crate::RegValueT<Adwinmon_SPEC> as RegisterValue<_>>::new(0)
3903    }
3904}
3905pub mod adwinmon {
3906
3907    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3908    pub struct Moncomb_SPEC;
3909    pub type Moncomb = crate::EnumBitfieldStruct<u8, Moncomb_SPEC>;
3910    impl Moncomb {
3911        #[doc = "Window A/B composite conditions are not met."]
3912        pub const _0: Self = Self::new(0);
3913
3914        #[doc = "Window A/B composite conditions are met."]
3915        pub const _1: Self = Self::new(1);
3916    }
3917    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3918    pub struct Moncmpa_SPEC;
3919    pub type Moncmpa = crate::EnumBitfieldStruct<u8, Moncmpa_SPEC>;
3920    impl Moncmpa {
3921        #[doc = "Window A comparison conditions are not met."]
3922        pub const _0: Self = Self::new(0);
3923
3924        #[doc = "Window A comparison conditions are met."]
3925        pub const _1: Self = Self::new(1);
3926    }
3927    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
3928    pub struct Moncmpb_SPEC;
3929    pub type Moncmpb = crate::EnumBitfieldStruct<u8, Moncmpb_SPEC>;
3930    impl Moncmpb {
3931        #[doc = "Window B comparison conditions are not met."]
3932        pub const _0: Self = Self::new(0);
3933
3934        #[doc = "Window B comparison conditions are met."]
3935        pub const _1: Self = Self::new(1);
3936    }
3937}
3938#[doc(hidden)]
3939#[derive(Copy, Clone, Eq, PartialEq)]
3940pub struct Adcmpcr_SPEC;
3941impl crate::sealed::RegSpec for Adcmpcr_SPEC {
3942    type DataType = u16;
3943}
3944
3945#[doc = "A/D Compare Function Control Register"]
3946pub type Adcmpcr = crate::RegValueT<Adcmpcr_SPEC>;
3947
3948impl Adcmpcr {
3949    #[doc = "Window A/B Composite Conditions Setting"]
3950    #[inline(always)]
3951    pub fn cmpab(
3952        self,
3953    ) -> crate::common::RegisterField<
3954        0,
3955        0x3,
3956        1,
3957        0,
3958        adcmpcr::Cmpab,
3959        adcmpcr::Cmpab,
3960        Adcmpcr_SPEC,
3961        crate::common::RW,
3962    > {
3963        crate::common::RegisterField::<
3964            0,
3965            0x3,
3966            1,
3967            0,
3968            adcmpcr::Cmpab,
3969            adcmpcr::Cmpab,
3970            Adcmpcr_SPEC,
3971            crate::common::RW,
3972        >::from_register(self, 0)
3973    }
3974
3975    #[doc = "Compare Window B Operation Enable"]
3976    #[inline(always)]
3977    pub fn cmpbe(
3978        self,
3979    ) -> crate::common::RegisterField<
3980        9,
3981        0x1,
3982        1,
3983        0,
3984        adcmpcr::Cmpbe,
3985        adcmpcr::Cmpbe,
3986        Adcmpcr_SPEC,
3987        crate::common::RW,
3988    > {
3989        crate::common::RegisterField::<
3990            9,
3991            0x1,
3992            1,
3993            0,
3994            adcmpcr::Cmpbe,
3995            adcmpcr::Cmpbe,
3996            Adcmpcr_SPEC,
3997            crate::common::RW,
3998        >::from_register(self, 0)
3999    }
4000
4001    #[doc = "Compare Window A Operation Enable"]
4002    #[inline(always)]
4003    pub fn cmpae(
4004        self,
4005    ) -> crate::common::RegisterField<
4006        11,
4007        0x1,
4008        1,
4009        0,
4010        adcmpcr::Cmpae,
4011        adcmpcr::Cmpae,
4012        Adcmpcr_SPEC,
4013        crate::common::RW,
4014    > {
4015        crate::common::RegisterField::<
4016            11,
4017            0x1,
4018            1,
4019            0,
4020            adcmpcr::Cmpae,
4021            adcmpcr::Cmpae,
4022            Adcmpcr_SPEC,
4023            crate::common::RW,
4024        >::from_register(self, 0)
4025    }
4026
4027    #[doc = "Compare B Interrupt Enable"]
4028    #[inline(always)]
4029    pub fn cmpbie(
4030        self,
4031    ) -> crate::common::RegisterField<
4032        13,
4033        0x1,
4034        1,
4035        0,
4036        adcmpcr::Cmpbie,
4037        adcmpcr::Cmpbie,
4038        Adcmpcr_SPEC,
4039        crate::common::RW,
4040    > {
4041        crate::common::RegisterField::<
4042            13,
4043            0x1,
4044            1,
4045            0,
4046            adcmpcr::Cmpbie,
4047            adcmpcr::Cmpbie,
4048            Adcmpcr_SPEC,
4049            crate::common::RW,
4050        >::from_register(self, 0)
4051    }
4052
4053    #[doc = "Window Function Setting"]
4054    #[inline(always)]
4055    pub fn wcmpe(
4056        self,
4057    ) -> crate::common::RegisterField<
4058        14,
4059        0x1,
4060        1,
4061        0,
4062        adcmpcr::Wcmpe,
4063        adcmpcr::Wcmpe,
4064        Adcmpcr_SPEC,
4065        crate::common::RW,
4066    > {
4067        crate::common::RegisterField::<
4068            14,
4069            0x1,
4070            1,
4071            0,
4072            adcmpcr::Wcmpe,
4073            adcmpcr::Wcmpe,
4074            Adcmpcr_SPEC,
4075            crate::common::RW,
4076        >::from_register(self, 0)
4077    }
4078
4079    #[doc = "Compare A Interrupt Enable"]
4080    #[inline(always)]
4081    pub fn cmpaie(
4082        self,
4083    ) -> crate::common::RegisterField<
4084        15,
4085        0x1,
4086        1,
4087        0,
4088        adcmpcr::Cmpaie,
4089        adcmpcr::Cmpaie,
4090        Adcmpcr_SPEC,
4091        crate::common::RW,
4092    > {
4093        crate::common::RegisterField::<
4094            15,
4095            0x1,
4096            1,
4097            0,
4098            adcmpcr::Cmpaie,
4099            adcmpcr::Cmpaie,
4100            Adcmpcr_SPEC,
4101            crate::common::RW,
4102        >::from_register(self, 0)
4103    }
4104}
4105impl ::core::default::Default for Adcmpcr {
4106    #[inline(always)]
4107    fn default() -> Adcmpcr {
4108        <crate::RegValueT<Adcmpcr_SPEC> as RegisterValue<_>>::new(0)
4109    }
4110}
4111pub mod adcmpcr {
4112
4113    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4114    pub struct Cmpab_SPEC;
4115    pub type Cmpab = crate::EnumBitfieldStruct<u8, Cmpab_SPEC>;
4116    impl Cmpab {
4117        #[doc = "Output ADC12i_WCMPM (i = 0, 1) when window A OR window B comparison conditions are met. Otherwise, output ADC12i_WCMPUM (i = 0, 1)."]
4118        pub const _00: Self = Self::new(0);
4119
4120        #[doc = "Output ADC12i_WCMPM (i = 0, 1) when window A EXOR window B comparison conditions are met. Otherwise, output ADC12i_WCMPUM (i = 0, 1)."]
4121        pub const _01: Self = Self::new(1);
4122
4123        #[doc = "Output ADC12i_WCMPM (i = 0, 1) when window A AND window B comparison conditions are met. Otherwise, output ADC12i_WCMPUM (i = 0, 1)."]
4124        pub const _10: Self = Self::new(2);
4125
4126        #[doc = "Setting prohibited."]
4127        pub const _11: Self = Self::new(3);
4128    }
4129    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4130    pub struct Cmpbe_SPEC;
4131    pub type Cmpbe = crate::EnumBitfieldStruct<u8, Cmpbe_SPEC>;
4132    impl Cmpbe {
4133        #[doc = "Disable compare window B operation. Disable ADC12i_WCMPM (i = 0, 1) and ADC12i_WCMPUM (i = 0, 1) outputs."]
4134        pub const _0: Self = Self::new(0);
4135
4136        #[doc = "Enable compare window B operation."]
4137        pub const _1: Self = Self::new(1);
4138    }
4139    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4140    pub struct Cmpae_SPEC;
4141    pub type Cmpae = crate::EnumBitfieldStruct<u8, Cmpae_SPEC>;
4142    impl Cmpae {
4143        #[doc = "Disable compare window A operation. Disable ADC12i_WCMPM (i = 0, 1) and ADC12i_WCMPUM (i = 0, 1) outputs."]
4144        pub const _0: Self = Self::new(0);
4145
4146        #[doc = "Enable compare window A operation."]
4147        pub const _1: Self = Self::new(1);
4148    }
4149    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4150    pub struct Cmpbie_SPEC;
4151    pub type Cmpbie = crate::EnumBitfieldStruct<u8, Cmpbie_SPEC>;
4152    impl Cmpbie {
4153        #[doc = "Disable ADC12i_CMPBI (i = 0, 1) interrupt when comparison conditions (window B) are met."]
4154        pub const _0: Self = Self::new(0);
4155
4156        #[doc = "Enable ADC12i_CMPBI (i = 0, 1) interrupt when comparison conditions (window B) are met."]
4157        pub const _1: Self = Self::new(1);
4158    }
4159    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4160    pub struct Wcmpe_SPEC;
4161    pub type Wcmpe = crate::EnumBitfieldStruct<u8, Wcmpe_SPEC>;
4162    impl Wcmpe {
4163        #[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."]
4164        pub const _0: Self = Self::new(0);
4165
4166        #[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."]
4167        pub const _1: Self = Self::new(1);
4168    }
4169    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4170    pub struct Cmpaie_SPEC;
4171    pub type Cmpaie = crate::EnumBitfieldStruct<u8, Cmpaie_SPEC>;
4172    impl Cmpaie {
4173        #[doc = "Disable ADC12i_CMPAI (i = 0, 1) interrupt when comparison conditions (window A) are met."]
4174        pub const _0: Self = Self::new(0);
4175
4176        #[doc = "Enable ADC12i_CMPAI (i = 0, 1) interrupt when comparison conditions (window A) are met."]
4177        pub const _1: Self = Self::new(1);
4178    }
4179}
4180#[doc(hidden)]
4181#[derive(Copy, Clone, Eq, PartialEq)]
4182pub struct Adcmpanser_SPEC;
4183impl crate::sealed::RegSpec for Adcmpanser_SPEC {
4184    type DataType = u8;
4185}
4186
4187#[doc = "A/D Compare Function Window A Extended Input Select Register"]
4188pub type Adcmpanser = crate::RegValueT<Adcmpanser_SPEC>;
4189
4190impl Adcmpanser {
4191    #[doc = "Temperature Sensor Output Compare Select"]
4192    #[inline(always)]
4193    pub fn cmptsa(
4194        self,
4195    ) -> crate::common::RegisterField<
4196        0,
4197        0x1,
4198        1,
4199        0,
4200        adcmpanser::Cmptsa,
4201        adcmpanser::Cmptsa,
4202        Adcmpanser_SPEC,
4203        crate::common::RW,
4204    > {
4205        crate::common::RegisterField::<
4206            0,
4207            0x1,
4208            1,
4209            0,
4210            adcmpanser::Cmptsa,
4211            adcmpanser::Cmptsa,
4212            Adcmpanser_SPEC,
4213            crate::common::RW,
4214        >::from_register(self, 0)
4215    }
4216
4217    #[doc = "Internal Reference Voltage Compare Select"]
4218    #[inline(always)]
4219    pub fn cmpoca(
4220        self,
4221    ) -> crate::common::RegisterField<
4222        1,
4223        0x1,
4224        1,
4225        0,
4226        adcmpanser::Cmpoca,
4227        adcmpanser::Cmpoca,
4228        Adcmpanser_SPEC,
4229        crate::common::RW,
4230    > {
4231        crate::common::RegisterField::<
4232            1,
4233            0x1,
4234            1,
4235            0,
4236            adcmpanser::Cmpoca,
4237            adcmpanser::Cmpoca,
4238            Adcmpanser_SPEC,
4239            crate::common::RW,
4240        >::from_register(self, 0)
4241    }
4242}
4243impl ::core::default::Default for Adcmpanser {
4244    #[inline(always)]
4245    fn default() -> Adcmpanser {
4246        <crate::RegValueT<Adcmpanser_SPEC> as RegisterValue<_>>::new(0)
4247    }
4248}
4249pub mod adcmpanser {
4250
4251    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4252    pub struct Cmptsa_SPEC;
4253    pub type Cmptsa = crate::EnumBitfieldStruct<u8, Cmptsa_SPEC>;
4254    impl Cmptsa {
4255        #[doc = "Exclude the temperature sensor output from the compare Window A target range."]
4256        pub const _0: Self = Self::new(0);
4257
4258        #[doc = "Include the temperature sensor output in the compare Window A target range."]
4259        pub const _1: Self = Self::new(1);
4260    }
4261    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4262    pub struct Cmpoca_SPEC;
4263    pub type Cmpoca = crate::EnumBitfieldStruct<u8, Cmpoca_SPEC>;
4264    impl Cmpoca {
4265        #[doc = "Exclude the internal reference voltage from the compare Window A target range."]
4266        pub const _0: Self = Self::new(0);
4267
4268        #[doc = "Include the internal reference voltage in the compare Window A target range."]
4269        pub const _1: Self = Self::new(1);
4270    }
4271}
4272#[doc(hidden)]
4273#[derive(Copy, Clone, Eq, PartialEq)]
4274pub struct Adcmpler_SPEC;
4275impl crate::sealed::RegSpec for Adcmpler_SPEC {
4276    type DataType = u8;
4277}
4278
4279#[doc = "A/D Compare Function Window A Extended Input Comparison Condition Setting Register"]
4280pub type Adcmpler = crate::RegValueT<Adcmpler_SPEC>;
4281
4282impl Adcmpler {
4283    #[doc = "Compare Window A Temperature Sensor Output Comparison Condition Select"]
4284    #[inline(always)]
4285    pub fn cmpltsa(
4286        self,
4287    ) -> crate::common::RegisterField<
4288        0,
4289        0x1,
4290        1,
4291        0,
4292        adcmpler::Cmpltsa,
4293        adcmpler::Cmpltsa,
4294        Adcmpler_SPEC,
4295        crate::common::RW,
4296    > {
4297        crate::common::RegisterField::<
4298            0,
4299            0x1,
4300            1,
4301            0,
4302            adcmpler::Cmpltsa,
4303            adcmpler::Cmpltsa,
4304            Adcmpler_SPEC,
4305            crate::common::RW,
4306        >::from_register(self, 0)
4307    }
4308
4309    #[doc = "Compare Window A Internal Reference Voltage Comparison Condition Select"]
4310    #[inline(always)]
4311    pub fn cmploca(
4312        self,
4313    ) -> crate::common::RegisterField<
4314        1,
4315        0x1,
4316        1,
4317        0,
4318        adcmpler::Cmploca,
4319        adcmpler::Cmploca,
4320        Adcmpler_SPEC,
4321        crate::common::RW,
4322    > {
4323        crate::common::RegisterField::<
4324            1,
4325            0x1,
4326            1,
4327            0,
4328            adcmpler::Cmploca,
4329            adcmpler::Cmploca,
4330            Adcmpler_SPEC,
4331            crate::common::RW,
4332        >::from_register(self, 0)
4333    }
4334}
4335impl ::core::default::Default for Adcmpler {
4336    #[inline(always)]
4337    fn default() -> Adcmpler {
4338        <crate::RegValueT<Adcmpler_SPEC> as RegisterValue<_>>::new(0)
4339    }
4340}
4341pub mod adcmpler {
4342
4343    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4344    pub struct Cmpltsa_SPEC;
4345    pub type Cmpltsa = crate::EnumBitfieldStruct<u8, Cmpltsa_SPEC>;
4346    impl Cmpltsa {
4347        #[doc = "When window function is disabled (ADCMPCR.WCMPE = 0) : ADCMPDR0 value > A/D-converted value Compare Window A Temperature Sensor Output Comparison Condition Select When window function is enabled (ADCMPCR.WCMPE = 1) : Compare Window A Temperature Sensor Output Comparison Condition A/D-converted value < ADCMPDR0 value, or A/D-converted value > ADCMPDR1 value"]
4348        pub const _0: Self = Self::new(0);
4349
4350        #[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"]
4351        pub const _1: Self = Self::new(1);
4352    }
4353    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4354    pub struct Cmploca_SPEC;
4355    pub type Cmploca = crate::EnumBitfieldStruct<u8, Cmploca_SPEC>;
4356    impl Cmploca {
4357        #[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"]
4358        pub const _0: Self = Self::new(0);
4359
4360        #[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"]
4361        pub const _1: Self = Self::new(1);
4362    }
4363}
4364#[doc(hidden)]
4365#[derive(Copy, Clone, Eq, PartialEq)]
4366pub struct Adcmpansr0_SPEC;
4367impl crate::sealed::RegSpec for Adcmpansr0_SPEC {
4368    type DataType = u16;
4369}
4370
4371#[doc = "A/D Compare Function Window A Channel Select Register 0"]
4372pub type Adcmpansr0 = crate::RegValueT<Adcmpansr0_SPEC>;
4373
4374impl Adcmpansr0 {
4375    #[doc = "Compare Window A Channel Select"]
4376    #[inline(always)]
4377    pub fn cmpcha0(
4378        self,
4379    ) -> crate::common::RegisterField<
4380        0,
4381        0x1,
4382        1,
4383        0,
4384        adcmpansr0::Cmpcha0,
4385        adcmpansr0::Cmpcha0,
4386        Adcmpansr0_SPEC,
4387        crate::common::RW,
4388    > {
4389        crate::common::RegisterField::<
4390            0,
4391            0x1,
4392            1,
4393            0,
4394            adcmpansr0::Cmpcha0,
4395            adcmpansr0::Cmpcha0,
4396            Adcmpansr0_SPEC,
4397            crate::common::RW,
4398        >::from_register(self, 0)
4399    }
4400
4401    #[doc = "Compare Window A Channel Select"]
4402    #[inline(always)]
4403    pub fn cmpcha1(
4404        self,
4405    ) -> crate::common::RegisterField<
4406        1,
4407        0x1,
4408        1,
4409        0,
4410        adcmpansr0::Cmpcha1,
4411        adcmpansr0::Cmpcha1,
4412        Adcmpansr0_SPEC,
4413        crate::common::RW,
4414    > {
4415        crate::common::RegisterField::<
4416            1,
4417            0x1,
4418            1,
4419            0,
4420            adcmpansr0::Cmpcha1,
4421            adcmpansr0::Cmpcha1,
4422            Adcmpansr0_SPEC,
4423            crate::common::RW,
4424        >::from_register(self, 0)
4425    }
4426
4427    #[doc = "Compare Window A Channel Select"]
4428    #[inline(always)]
4429    pub fn cmpcha2(
4430        self,
4431    ) -> crate::common::RegisterField<
4432        2,
4433        0x1,
4434        1,
4435        0,
4436        adcmpansr0::Cmpcha2,
4437        adcmpansr0::Cmpcha2,
4438        Adcmpansr0_SPEC,
4439        crate::common::RW,
4440    > {
4441        crate::common::RegisterField::<
4442            2,
4443            0x1,
4444            1,
4445            0,
4446            adcmpansr0::Cmpcha2,
4447            adcmpansr0::Cmpcha2,
4448            Adcmpansr0_SPEC,
4449            crate::common::RW,
4450        >::from_register(self, 0)
4451    }
4452
4453    #[doc = "Compare Window A Channel Select"]
4454    #[inline(always)]
4455    pub fn cmpcha3(
4456        self,
4457    ) -> crate::common::RegisterField<
4458        3,
4459        0x1,
4460        1,
4461        0,
4462        adcmpansr0::Cmpcha3,
4463        adcmpansr0::Cmpcha3,
4464        Adcmpansr0_SPEC,
4465        crate::common::RW,
4466    > {
4467        crate::common::RegisterField::<
4468            3,
4469            0x1,
4470            1,
4471            0,
4472            adcmpansr0::Cmpcha3,
4473            adcmpansr0::Cmpcha3,
4474            Adcmpansr0_SPEC,
4475            crate::common::RW,
4476        >::from_register(self, 0)
4477    }
4478
4479    #[doc = "Compare Window A Channel Select"]
4480    #[inline(always)]
4481    pub fn cmpcha4(
4482        self,
4483    ) -> crate::common::RegisterField<
4484        4,
4485        0x1,
4486        1,
4487        0,
4488        adcmpansr0::Cmpcha4,
4489        adcmpansr0::Cmpcha4,
4490        Adcmpansr0_SPEC,
4491        crate::common::RW,
4492    > {
4493        crate::common::RegisterField::<
4494            4,
4495            0x1,
4496            1,
4497            0,
4498            adcmpansr0::Cmpcha4,
4499            adcmpansr0::Cmpcha4,
4500            Adcmpansr0_SPEC,
4501            crate::common::RW,
4502        >::from_register(self, 0)
4503    }
4504
4505    #[doc = "Compare Window A Channel Select"]
4506    #[inline(always)]
4507    pub fn cmpcha5(
4508        self,
4509    ) -> crate::common::RegisterField<
4510        5,
4511        0x1,
4512        1,
4513        0,
4514        adcmpansr0::Cmpcha5,
4515        adcmpansr0::Cmpcha5,
4516        Adcmpansr0_SPEC,
4517        crate::common::RW,
4518    > {
4519        crate::common::RegisterField::<
4520            5,
4521            0x1,
4522            1,
4523            0,
4524            adcmpansr0::Cmpcha5,
4525            adcmpansr0::Cmpcha5,
4526            Adcmpansr0_SPEC,
4527            crate::common::RW,
4528        >::from_register(self, 0)
4529    }
4530
4531    #[doc = "Compare Window A Channel Select"]
4532    #[inline(always)]
4533    pub fn cmpcha6(
4534        self,
4535    ) -> crate::common::RegisterField<
4536        6,
4537        0x1,
4538        1,
4539        0,
4540        adcmpansr0::Cmpcha6,
4541        adcmpansr0::Cmpcha6,
4542        Adcmpansr0_SPEC,
4543        crate::common::RW,
4544    > {
4545        crate::common::RegisterField::<
4546            6,
4547            0x1,
4548            1,
4549            0,
4550            adcmpansr0::Cmpcha6,
4551            adcmpansr0::Cmpcha6,
4552            Adcmpansr0_SPEC,
4553            crate::common::RW,
4554        >::from_register(self, 0)
4555    }
4556
4557    #[doc = "Compare Window A Channel Select"]
4558    #[inline(always)]
4559    pub fn cmpcha7(
4560        self,
4561    ) -> crate::common::RegisterField<
4562        7,
4563        0x1,
4564        1,
4565        0,
4566        adcmpansr0::Cmpcha7,
4567        adcmpansr0::Cmpcha7,
4568        Adcmpansr0_SPEC,
4569        crate::common::RW,
4570    > {
4571        crate::common::RegisterField::<
4572            7,
4573            0x1,
4574            1,
4575            0,
4576            adcmpansr0::Cmpcha7,
4577            adcmpansr0::Cmpcha7,
4578            Adcmpansr0_SPEC,
4579            crate::common::RW,
4580        >::from_register(self, 0)
4581    }
4582
4583    #[doc = "Compare Window A Channel Select"]
4584    #[inline(always)]
4585    pub fn cmpcha8(
4586        self,
4587    ) -> crate::common::RegisterField<
4588        8,
4589        0x1,
4590        1,
4591        0,
4592        adcmpansr0::Cmpcha8,
4593        adcmpansr0::Cmpcha8,
4594        Adcmpansr0_SPEC,
4595        crate::common::RW,
4596    > {
4597        crate::common::RegisterField::<
4598            8,
4599            0x1,
4600            1,
4601            0,
4602            adcmpansr0::Cmpcha8,
4603            adcmpansr0::Cmpcha8,
4604            Adcmpansr0_SPEC,
4605            crate::common::RW,
4606        >::from_register(self, 0)
4607    }
4608
4609    #[doc = "Compare Window A Channel Select"]
4610    #[inline(always)]
4611    pub fn cmpcha9(
4612        self,
4613    ) -> crate::common::RegisterField<
4614        9,
4615        0x1,
4616        1,
4617        0,
4618        adcmpansr0::Cmpcha9,
4619        adcmpansr0::Cmpcha9,
4620        Adcmpansr0_SPEC,
4621        crate::common::RW,
4622    > {
4623        crate::common::RegisterField::<
4624            9,
4625            0x1,
4626            1,
4627            0,
4628            adcmpansr0::Cmpcha9,
4629            adcmpansr0::Cmpcha9,
4630            Adcmpansr0_SPEC,
4631            crate::common::RW,
4632        >::from_register(self, 0)
4633    }
4634
4635    #[doc = "Compare Window A Channel Select"]
4636    #[inline(always)]
4637    pub fn cmpcha12(
4638        self,
4639    ) -> crate::common::RegisterField<
4640        12,
4641        0x1,
4642        1,
4643        0,
4644        adcmpansr0::Cmpcha12,
4645        adcmpansr0::Cmpcha12,
4646        Adcmpansr0_SPEC,
4647        crate::common::RW,
4648    > {
4649        crate::common::RegisterField::<
4650            12,
4651            0x1,
4652            1,
4653            0,
4654            adcmpansr0::Cmpcha12,
4655            adcmpansr0::Cmpcha12,
4656            Adcmpansr0_SPEC,
4657            crate::common::RW,
4658        >::from_register(self, 0)
4659    }
4660
4661    #[doc = "Compare Window A Channel Select"]
4662    #[inline(always)]
4663    pub fn cmpcha13(
4664        self,
4665    ) -> crate::common::RegisterField<
4666        13,
4667        0x1,
4668        1,
4669        0,
4670        adcmpansr0::Cmpcha13,
4671        adcmpansr0::Cmpcha13,
4672        Adcmpansr0_SPEC,
4673        crate::common::RW,
4674    > {
4675        crate::common::RegisterField::<
4676            13,
4677            0x1,
4678            1,
4679            0,
4680            adcmpansr0::Cmpcha13,
4681            adcmpansr0::Cmpcha13,
4682            Adcmpansr0_SPEC,
4683            crate::common::RW,
4684        >::from_register(self, 0)
4685    }
4686}
4687impl ::core::default::Default for Adcmpansr0 {
4688    #[inline(always)]
4689    fn default() -> Adcmpansr0 {
4690        <crate::RegValueT<Adcmpansr0_SPEC> as RegisterValue<_>>::new(0)
4691    }
4692}
4693pub mod adcmpansr0 {
4694
4695    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4696    pub struct Cmpcha0_SPEC;
4697    pub type Cmpcha0 = crate::EnumBitfieldStruct<u8, Cmpcha0_SPEC>;
4698    impl Cmpcha0 {
4699        #[doc = "Disable compare function for associated input channel"]
4700        pub const _0: Self = Self::new(0);
4701
4702        #[doc = "Enable compare function for associated input channel"]
4703        pub const _1: Self = Self::new(1);
4704    }
4705    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4706    pub struct Cmpcha1_SPEC;
4707    pub type Cmpcha1 = crate::EnumBitfieldStruct<u8, Cmpcha1_SPEC>;
4708    impl Cmpcha1 {
4709        #[doc = "Disable compare function for associated input channel"]
4710        pub const _0: Self = Self::new(0);
4711
4712        #[doc = "Enable compare function for associated input channel"]
4713        pub const _1: Self = Self::new(1);
4714    }
4715    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4716    pub struct Cmpcha2_SPEC;
4717    pub type Cmpcha2 = crate::EnumBitfieldStruct<u8, Cmpcha2_SPEC>;
4718    impl Cmpcha2 {
4719        #[doc = "Disable compare function for associated input channel"]
4720        pub const _0: Self = Self::new(0);
4721
4722        #[doc = "Enable compare function for associated input channel"]
4723        pub const _1: Self = Self::new(1);
4724    }
4725    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4726    pub struct Cmpcha3_SPEC;
4727    pub type Cmpcha3 = crate::EnumBitfieldStruct<u8, Cmpcha3_SPEC>;
4728    impl Cmpcha3 {
4729        #[doc = "Disable compare function for associated input channel"]
4730        pub const _0: Self = Self::new(0);
4731
4732        #[doc = "Enable compare function for associated input channel"]
4733        pub const _1: Self = Self::new(1);
4734    }
4735    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4736    pub struct Cmpcha4_SPEC;
4737    pub type Cmpcha4 = crate::EnumBitfieldStruct<u8, Cmpcha4_SPEC>;
4738    impl Cmpcha4 {
4739        #[doc = "Disable compare function for associated input channel"]
4740        pub const _0: Self = Self::new(0);
4741
4742        #[doc = "Enable compare function for associated input channel"]
4743        pub const _1: Self = Self::new(1);
4744    }
4745    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4746    pub struct Cmpcha5_SPEC;
4747    pub type Cmpcha5 = crate::EnumBitfieldStruct<u8, Cmpcha5_SPEC>;
4748    impl Cmpcha5 {
4749        #[doc = "Disable compare function for associated input channel"]
4750        pub const _0: Self = Self::new(0);
4751
4752        #[doc = "Enable compare function for associated input channel"]
4753        pub const _1: Self = Self::new(1);
4754    }
4755    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4756    pub struct Cmpcha6_SPEC;
4757    pub type Cmpcha6 = crate::EnumBitfieldStruct<u8, Cmpcha6_SPEC>;
4758    impl Cmpcha6 {
4759        #[doc = "Disable compare function for associated input channel"]
4760        pub const _0: Self = Self::new(0);
4761
4762        #[doc = "Enable compare function for associated input channel"]
4763        pub const _1: Self = Self::new(1);
4764    }
4765    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4766    pub struct Cmpcha7_SPEC;
4767    pub type Cmpcha7 = crate::EnumBitfieldStruct<u8, Cmpcha7_SPEC>;
4768    impl Cmpcha7 {
4769        #[doc = "Disable compare function for associated input channel"]
4770        pub const _0: Self = Self::new(0);
4771
4772        #[doc = "Enable compare function for associated input channel"]
4773        pub const _1: Self = Self::new(1);
4774    }
4775    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4776    pub struct Cmpcha8_SPEC;
4777    pub type Cmpcha8 = crate::EnumBitfieldStruct<u8, Cmpcha8_SPEC>;
4778    impl Cmpcha8 {
4779        #[doc = "Disable compare function for associated input channel"]
4780        pub const _0: Self = Self::new(0);
4781
4782        #[doc = "Enable compare function for associated input channel"]
4783        pub const _1: Self = Self::new(1);
4784    }
4785    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4786    pub struct Cmpcha9_SPEC;
4787    pub type Cmpcha9 = crate::EnumBitfieldStruct<u8, Cmpcha9_SPEC>;
4788    impl Cmpcha9 {
4789        #[doc = "Disable compare function for associated input channel"]
4790        pub const _0: Self = Self::new(0);
4791
4792        #[doc = "Enable compare function for associated input channel"]
4793        pub const _1: Self = Self::new(1);
4794    }
4795    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4796    pub struct Cmpcha12_SPEC;
4797    pub type Cmpcha12 = crate::EnumBitfieldStruct<u8, Cmpcha12_SPEC>;
4798    impl Cmpcha12 {
4799        #[doc = "Disable compare function for associated input channel"]
4800        pub const _0: Self = Self::new(0);
4801
4802        #[doc = "Enable compare function for associated input channel"]
4803        pub const _1: Self = Self::new(1);
4804    }
4805    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
4806    pub struct Cmpcha13_SPEC;
4807    pub type Cmpcha13 = crate::EnumBitfieldStruct<u8, Cmpcha13_SPEC>;
4808    impl Cmpcha13 {
4809        #[doc = "Disable compare function for associated input channel"]
4810        pub const _0: Self = Self::new(0);
4811
4812        #[doc = "Enable compare function for associated input channel"]
4813        pub const _1: Self = Self::new(1);
4814    }
4815}
4816#[doc(hidden)]
4817#[derive(Copy, Clone, Eq, PartialEq)]
4818pub struct Adcmpansr1_SPEC;
4819impl crate::sealed::RegSpec for Adcmpansr1_SPEC {
4820    type DataType = u16;
4821}
4822
4823#[doc = "A/D Compare Function Window A Channel Select Register 1"]
4824pub type Adcmpansr1 = crate::RegValueT<Adcmpansr1_SPEC>;
4825
4826impl Adcmpansr1 {
4827    #[doc = "Compare Window A Channel Select"]
4828    #[inline(always)]
4829    pub fn cmpcha16(
4830        self,
4831    ) -> crate::common::RegisterField<
4832        0,
4833        0x1,
4834        1,
4835        0,
4836        adcmpansr1::Cmpcha16,
4837        adcmpansr1::Cmpcha16,
4838        Adcmpansr1_SPEC,
4839        crate::common::RW,
4840    > {
4841        crate::common::RegisterField::<
4842            0,
4843            0x1,
4844            1,
4845            0,
4846            adcmpansr1::Cmpcha16,
4847            adcmpansr1::Cmpcha16,
4848            Adcmpansr1_SPEC,
4849            crate::common::RW,
4850        >::from_register(self, 0)
4851    }
4852
4853    #[doc = "Compare Window A Channel Select"]
4854    #[inline(always)]
4855    pub fn cmpcha17(
4856        self,
4857    ) -> crate::common::RegisterField<
4858        1,
4859        0x1,
4860        1,
4861        0,
4862        adcmpansr1::Cmpcha17,
4863        adcmpansr1::Cmpcha17,
4864        Adcmpansr1_SPEC,
4865        crate::common::RW,
4866    > {
4867        crate::common::RegisterField::<
4868            1,
4869            0x1,
4870            1,
4871            0,
4872            adcmpansr1::Cmpcha17,
4873            adcmpansr1::Cmpcha17,
4874            Adcmpansr1_SPEC,
4875            crate::common::RW,
4876        >::from_register(self, 0)
4877    }
4878
4879    #[doc = "Compare Window A Channel Select"]
4880    #[inline(always)]
4881    pub fn cmpcha18(
4882        self,
4883    ) -> crate::common::RegisterField<
4884        2,
4885        0x1,
4886        1,
4887        0,
4888        adcmpansr1::Cmpcha18,
4889        adcmpansr1::Cmpcha18,
4890        Adcmpansr1_SPEC,
4891        crate::common::RW,
4892    > {
4893        crate::common::RegisterField::<
4894            2,
4895            0x1,
4896            1,
4897            0,
4898            adcmpansr1::Cmpcha18,
4899            adcmpansr1::Cmpcha18,
4900            Adcmpansr1_SPEC,
4901            crate::common::RW,
4902        >::from_register(self, 0)
4903    }
4904
4905    #[doc = "Compare Window A Channel Select"]
4906    #[inline(always)]
4907    pub fn cmpcha19(
4908        self,
4909    ) -> crate::common::RegisterField<
4910        3,
4911        0x1,
4912        1,
4913        0,
4914        adcmpansr1::Cmpcha19,
4915        adcmpansr1::Cmpcha19,
4916        Adcmpansr1_SPEC,
4917        crate::common::RW,
4918    > {
4919        crate::common::RegisterField::<
4920            3,
4921            0x1,
4922            1,
4923            0,
4924            adcmpansr1::Cmpcha19,
4925            adcmpansr1::Cmpcha19,
4926            Adcmpansr1_SPEC,
4927            crate::common::RW,
4928        >::from_register(self, 0)
4929    }
4930
4931    #[doc = "Compare Window A Channel Select"]
4932    #[inline(always)]
4933    pub fn cmpcha20(
4934        self,
4935    ) -> crate::common::RegisterField<
4936        4,
4937        0x1,
4938        1,
4939        0,
4940        adcmpansr1::Cmpcha20,
4941        adcmpansr1::Cmpcha20,
4942        Adcmpansr1_SPEC,
4943        crate::common::RW,
4944    > {
4945        crate::common::RegisterField::<
4946            4,
4947            0x1,
4948            1,
4949            0,
4950            adcmpansr1::Cmpcha20,
4951            adcmpansr1::Cmpcha20,
4952            Adcmpansr1_SPEC,
4953            crate::common::RW,
4954        >::from_register(self, 0)
4955    }
4956
4957    #[doc = "Compare Window A Channel Select"]
4958    #[inline(always)]
4959    pub fn cmpcha21(
4960        self,
4961    ) -> crate::common::RegisterField<
4962        5,
4963        0x1,
4964        1,
4965        0,
4966        adcmpansr1::Cmpcha21,
4967        adcmpansr1::Cmpcha21,
4968        Adcmpansr1_SPEC,
4969        crate::common::RW,
4970    > {
4971        crate::common::RegisterField::<
4972            5,
4973            0x1,
4974            1,
4975            0,
4976            adcmpansr1::Cmpcha21,
4977            adcmpansr1::Cmpcha21,
4978            Adcmpansr1_SPEC,
4979            crate::common::RW,
4980        >::from_register(self, 0)
4981    }
4982
4983    #[doc = "Compare Window A Channel Select"]
4984    #[inline(always)]
4985    pub fn cmpcha22(
4986        self,
4987    ) -> crate::common::RegisterField<
4988        6,
4989        0x1,
4990        1,
4991        0,
4992        adcmpansr1::Cmpcha22,
4993        adcmpansr1::Cmpcha22,
4994        Adcmpansr1_SPEC,
4995        crate::common::RW,
4996    > {
4997        crate::common::RegisterField::<
4998            6,
4999            0x1,
5000            1,
5001            0,
5002            adcmpansr1::Cmpcha22,
5003            adcmpansr1::Cmpcha22,
5004            Adcmpansr1_SPEC,
5005            crate::common::RW,
5006        >::from_register(self, 0)
5007    }
5008}
5009impl ::core::default::Default for Adcmpansr1 {
5010    #[inline(always)]
5011    fn default() -> Adcmpansr1 {
5012        <crate::RegValueT<Adcmpansr1_SPEC> as RegisterValue<_>>::new(0)
5013    }
5014}
5015pub mod adcmpansr1 {
5016
5017    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5018    pub struct Cmpcha16_SPEC;
5019    pub type Cmpcha16 = crate::EnumBitfieldStruct<u8, Cmpcha16_SPEC>;
5020    impl Cmpcha16 {
5021        #[doc = "Disable compare function for associated input channel"]
5022        pub const _0: Self = Self::new(0);
5023
5024        #[doc = "Enable compare function for associated input channel"]
5025        pub const _1: Self = Self::new(1);
5026    }
5027    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5028    pub struct Cmpcha17_SPEC;
5029    pub type Cmpcha17 = crate::EnumBitfieldStruct<u8, Cmpcha17_SPEC>;
5030    impl Cmpcha17 {
5031        #[doc = "Disable compare function for associated input channel"]
5032        pub const _0: Self = Self::new(0);
5033
5034        #[doc = "Enable compare function for associated input channel"]
5035        pub const _1: Self = Self::new(1);
5036    }
5037    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5038    pub struct Cmpcha18_SPEC;
5039    pub type Cmpcha18 = crate::EnumBitfieldStruct<u8, Cmpcha18_SPEC>;
5040    impl Cmpcha18 {
5041        #[doc = "Disable compare function for associated input channel"]
5042        pub const _0: Self = Self::new(0);
5043
5044        #[doc = "Enable compare function for associated input channel"]
5045        pub const _1: Self = Self::new(1);
5046    }
5047    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5048    pub struct Cmpcha19_SPEC;
5049    pub type Cmpcha19 = crate::EnumBitfieldStruct<u8, Cmpcha19_SPEC>;
5050    impl Cmpcha19 {
5051        #[doc = "Disable compare function for associated input channel"]
5052        pub const _0: Self = Self::new(0);
5053
5054        #[doc = "Enable compare function for associated input channel"]
5055        pub const _1: Self = Self::new(1);
5056    }
5057    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5058    pub struct Cmpcha20_SPEC;
5059    pub type Cmpcha20 = crate::EnumBitfieldStruct<u8, Cmpcha20_SPEC>;
5060    impl Cmpcha20 {
5061        #[doc = "Disable compare function for associated input channel"]
5062        pub const _0: Self = Self::new(0);
5063
5064        #[doc = "Enable compare function for associated input channel"]
5065        pub const _1: Self = Self::new(1);
5066    }
5067    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5068    pub struct Cmpcha21_SPEC;
5069    pub type Cmpcha21 = crate::EnumBitfieldStruct<u8, Cmpcha21_SPEC>;
5070    impl Cmpcha21 {
5071        #[doc = "Disable compare function for associated input channel"]
5072        pub const _0: Self = Self::new(0);
5073
5074        #[doc = "Enable compare function for associated input channel"]
5075        pub const _1: Self = Self::new(1);
5076    }
5077    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5078    pub struct Cmpcha22_SPEC;
5079    pub type Cmpcha22 = crate::EnumBitfieldStruct<u8, Cmpcha22_SPEC>;
5080    impl Cmpcha22 {
5081        #[doc = "Disable compare function for associated input channel"]
5082        pub const _0: Self = Self::new(0);
5083
5084        #[doc = "Enable compare function for associated input channel"]
5085        pub const _1: Self = Self::new(1);
5086    }
5087}
5088#[doc(hidden)]
5089#[derive(Copy, Clone, Eq, PartialEq)]
5090pub struct Adcmplr0_SPEC;
5091impl crate::sealed::RegSpec for Adcmplr0_SPEC {
5092    type DataType = u16;
5093}
5094
5095#[doc = "A/D Compare Function Window A Comparison Condition Setting Register 0"]
5096pub type Adcmplr0 = crate::RegValueT<Adcmplr0_SPEC>;
5097
5098impl Adcmplr0 {
5099    #[doc = "Compare Window A Comparison Condition Select"]
5100    #[inline(always)]
5101    pub fn cmplcha0(
5102        self,
5103    ) -> crate::common::RegisterField<
5104        0,
5105        0x1,
5106        1,
5107        0,
5108        adcmplr0::Cmplcha0,
5109        adcmplr0::Cmplcha0,
5110        Adcmplr0_SPEC,
5111        crate::common::RW,
5112    > {
5113        crate::common::RegisterField::<
5114            0,
5115            0x1,
5116            1,
5117            0,
5118            adcmplr0::Cmplcha0,
5119            adcmplr0::Cmplcha0,
5120            Adcmplr0_SPEC,
5121            crate::common::RW,
5122        >::from_register(self, 0)
5123    }
5124
5125    #[doc = "Compare Window A Comparison Condition Select"]
5126    #[inline(always)]
5127    pub fn cmplcha1(
5128        self,
5129    ) -> crate::common::RegisterField<
5130        1,
5131        0x1,
5132        1,
5133        0,
5134        adcmplr0::Cmplcha1,
5135        adcmplr0::Cmplcha1,
5136        Adcmplr0_SPEC,
5137        crate::common::RW,
5138    > {
5139        crate::common::RegisterField::<
5140            1,
5141            0x1,
5142            1,
5143            0,
5144            adcmplr0::Cmplcha1,
5145            adcmplr0::Cmplcha1,
5146            Adcmplr0_SPEC,
5147            crate::common::RW,
5148        >::from_register(self, 0)
5149    }
5150
5151    #[doc = "Compare Window A Comparison Condition Select"]
5152    #[inline(always)]
5153    pub fn cmplcha2(
5154        self,
5155    ) -> crate::common::RegisterField<
5156        2,
5157        0x1,
5158        1,
5159        0,
5160        adcmplr0::Cmplcha2,
5161        adcmplr0::Cmplcha2,
5162        Adcmplr0_SPEC,
5163        crate::common::RW,
5164    > {
5165        crate::common::RegisterField::<
5166            2,
5167            0x1,
5168            1,
5169            0,
5170            adcmplr0::Cmplcha2,
5171            adcmplr0::Cmplcha2,
5172            Adcmplr0_SPEC,
5173            crate::common::RW,
5174        >::from_register(self, 0)
5175    }
5176
5177    #[doc = "Compare Window A Comparison Condition Select"]
5178    #[inline(always)]
5179    pub fn cmplcha3(
5180        self,
5181    ) -> crate::common::RegisterField<
5182        3,
5183        0x1,
5184        1,
5185        0,
5186        adcmplr0::Cmplcha3,
5187        adcmplr0::Cmplcha3,
5188        Adcmplr0_SPEC,
5189        crate::common::RW,
5190    > {
5191        crate::common::RegisterField::<
5192            3,
5193            0x1,
5194            1,
5195            0,
5196            adcmplr0::Cmplcha3,
5197            adcmplr0::Cmplcha3,
5198            Adcmplr0_SPEC,
5199            crate::common::RW,
5200        >::from_register(self, 0)
5201    }
5202
5203    #[doc = "Compare Window A Comparison Condition Select"]
5204    #[inline(always)]
5205    pub fn cmplcha4(
5206        self,
5207    ) -> crate::common::RegisterField<
5208        4,
5209        0x1,
5210        1,
5211        0,
5212        adcmplr0::Cmplcha4,
5213        adcmplr0::Cmplcha4,
5214        Adcmplr0_SPEC,
5215        crate::common::RW,
5216    > {
5217        crate::common::RegisterField::<
5218            4,
5219            0x1,
5220            1,
5221            0,
5222            adcmplr0::Cmplcha4,
5223            adcmplr0::Cmplcha4,
5224            Adcmplr0_SPEC,
5225            crate::common::RW,
5226        >::from_register(self, 0)
5227    }
5228
5229    #[doc = "Compare Window A Comparison Condition Select"]
5230    #[inline(always)]
5231    pub fn cmplcha5(
5232        self,
5233    ) -> crate::common::RegisterField<
5234        5,
5235        0x1,
5236        1,
5237        0,
5238        adcmplr0::Cmplcha5,
5239        adcmplr0::Cmplcha5,
5240        Adcmplr0_SPEC,
5241        crate::common::RW,
5242    > {
5243        crate::common::RegisterField::<
5244            5,
5245            0x1,
5246            1,
5247            0,
5248            adcmplr0::Cmplcha5,
5249            adcmplr0::Cmplcha5,
5250            Adcmplr0_SPEC,
5251            crate::common::RW,
5252        >::from_register(self, 0)
5253    }
5254
5255    #[doc = "Compare Window A Comparison Condition Select"]
5256    #[inline(always)]
5257    pub fn cmplcha6(
5258        self,
5259    ) -> crate::common::RegisterField<
5260        6,
5261        0x1,
5262        1,
5263        0,
5264        adcmplr0::Cmplcha6,
5265        adcmplr0::Cmplcha6,
5266        Adcmplr0_SPEC,
5267        crate::common::RW,
5268    > {
5269        crate::common::RegisterField::<
5270            6,
5271            0x1,
5272            1,
5273            0,
5274            adcmplr0::Cmplcha6,
5275            adcmplr0::Cmplcha6,
5276            Adcmplr0_SPEC,
5277            crate::common::RW,
5278        >::from_register(self, 0)
5279    }
5280
5281    #[doc = "Compare Window A Comparison Condition Select"]
5282    #[inline(always)]
5283    pub fn cmplcha7(
5284        self,
5285    ) -> crate::common::RegisterField<
5286        7,
5287        0x1,
5288        1,
5289        0,
5290        adcmplr0::Cmplcha7,
5291        adcmplr0::Cmplcha7,
5292        Adcmplr0_SPEC,
5293        crate::common::RW,
5294    > {
5295        crate::common::RegisterField::<
5296            7,
5297            0x1,
5298            1,
5299            0,
5300            adcmplr0::Cmplcha7,
5301            adcmplr0::Cmplcha7,
5302            Adcmplr0_SPEC,
5303            crate::common::RW,
5304        >::from_register(self, 0)
5305    }
5306
5307    #[doc = "Compare Window A Comparison Condition Select"]
5308    #[inline(always)]
5309    pub fn cmplcha8(
5310        self,
5311    ) -> crate::common::RegisterField<
5312        8,
5313        0x1,
5314        1,
5315        0,
5316        adcmplr0::Cmplcha8,
5317        adcmplr0::Cmplcha8,
5318        Adcmplr0_SPEC,
5319        crate::common::RW,
5320    > {
5321        crate::common::RegisterField::<
5322            8,
5323            0x1,
5324            1,
5325            0,
5326            adcmplr0::Cmplcha8,
5327            adcmplr0::Cmplcha8,
5328            Adcmplr0_SPEC,
5329            crate::common::RW,
5330        >::from_register(self, 0)
5331    }
5332
5333    #[doc = "Compare Window A Comparison Condition Select"]
5334    #[inline(always)]
5335    pub fn cmplcha9(
5336        self,
5337    ) -> crate::common::RegisterField<
5338        9,
5339        0x1,
5340        1,
5341        0,
5342        adcmplr0::Cmplcha9,
5343        adcmplr0::Cmplcha9,
5344        Adcmplr0_SPEC,
5345        crate::common::RW,
5346    > {
5347        crate::common::RegisterField::<
5348            9,
5349            0x1,
5350            1,
5351            0,
5352            adcmplr0::Cmplcha9,
5353            adcmplr0::Cmplcha9,
5354            Adcmplr0_SPEC,
5355            crate::common::RW,
5356        >::from_register(self, 0)
5357    }
5358
5359    #[doc = "Compare Window A Comparison Condition Select"]
5360    #[inline(always)]
5361    pub fn cmplcha12(
5362        self,
5363    ) -> crate::common::RegisterField<
5364        12,
5365        0x1,
5366        1,
5367        0,
5368        adcmplr0::Cmplcha12,
5369        adcmplr0::Cmplcha12,
5370        Adcmplr0_SPEC,
5371        crate::common::RW,
5372    > {
5373        crate::common::RegisterField::<
5374            12,
5375            0x1,
5376            1,
5377            0,
5378            adcmplr0::Cmplcha12,
5379            adcmplr0::Cmplcha12,
5380            Adcmplr0_SPEC,
5381            crate::common::RW,
5382        >::from_register(self, 0)
5383    }
5384
5385    #[doc = "Compare Window A Comparison Condition Select"]
5386    #[inline(always)]
5387    pub fn cmplcha13(
5388        self,
5389    ) -> crate::common::RegisterField<
5390        13,
5391        0x1,
5392        1,
5393        0,
5394        adcmplr0::Cmplcha13,
5395        adcmplr0::Cmplcha13,
5396        Adcmplr0_SPEC,
5397        crate::common::RW,
5398    > {
5399        crate::common::RegisterField::<
5400            13,
5401            0x1,
5402            1,
5403            0,
5404            adcmplr0::Cmplcha13,
5405            adcmplr0::Cmplcha13,
5406            Adcmplr0_SPEC,
5407            crate::common::RW,
5408        >::from_register(self, 0)
5409    }
5410}
5411impl ::core::default::Default for Adcmplr0 {
5412    #[inline(always)]
5413    fn default() -> Adcmplr0 {
5414        <crate::RegValueT<Adcmplr0_SPEC> as RegisterValue<_>>::new(0)
5415    }
5416}
5417pub mod adcmplr0 {
5418
5419    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5420    pub struct Cmplcha0_SPEC;
5421    pub type Cmplcha0 = crate::EnumBitfieldStruct<u8, Cmplcha0_SPEC>;
5422    impl Cmplcha0 {
5423        #[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"]
5424        pub const _0: Self = Self::new(0);
5425
5426        #[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"]
5427        pub const _1: Self = Self::new(1);
5428    }
5429    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5430    pub struct Cmplcha1_SPEC;
5431    pub type Cmplcha1 = crate::EnumBitfieldStruct<u8, Cmplcha1_SPEC>;
5432    impl Cmplcha1 {
5433        #[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"]
5434        pub const _0: Self = Self::new(0);
5435
5436        #[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"]
5437        pub const _1: Self = Self::new(1);
5438    }
5439    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5440    pub struct Cmplcha2_SPEC;
5441    pub type Cmplcha2 = crate::EnumBitfieldStruct<u8, Cmplcha2_SPEC>;
5442    impl Cmplcha2 {
5443        #[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"]
5444        pub const _0: Self = Self::new(0);
5445
5446        #[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"]
5447        pub const _1: Self = Self::new(1);
5448    }
5449    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5450    pub struct Cmplcha3_SPEC;
5451    pub type Cmplcha3 = crate::EnumBitfieldStruct<u8, Cmplcha3_SPEC>;
5452    impl Cmplcha3 {
5453        #[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"]
5454        pub const _0: Self = Self::new(0);
5455
5456        #[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"]
5457        pub const _1: Self = Self::new(1);
5458    }
5459    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5460    pub struct Cmplcha4_SPEC;
5461    pub type Cmplcha4 = crate::EnumBitfieldStruct<u8, Cmplcha4_SPEC>;
5462    impl Cmplcha4 {
5463        #[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"]
5464        pub const _0: Self = Self::new(0);
5465
5466        #[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"]
5467        pub const _1: Self = Self::new(1);
5468    }
5469    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5470    pub struct Cmplcha5_SPEC;
5471    pub type Cmplcha5 = crate::EnumBitfieldStruct<u8, Cmplcha5_SPEC>;
5472    impl Cmplcha5 {
5473        #[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"]
5474        pub const _0: Self = Self::new(0);
5475
5476        #[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"]
5477        pub const _1: Self = Self::new(1);
5478    }
5479    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5480    pub struct Cmplcha6_SPEC;
5481    pub type Cmplcha6 = crate::EnumBitfieldStruct<u8, Cmplcha6_SPEC>;
5482    impl Cmplcha6 {
5483        #[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"]
5484        pub const _0: Self = Self::new(0);
5485
5486        #[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"]
5487        pub const _1: Self = Self::new(1);
5488    }
5489    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5490    pub struct Cmplcha7_SPEC;
5491    pub type Cmplcha7 = crate::EnumBitfieldStruct<u8, Cmplcha7_SPEC>;
5492    impl Cmplcha7 {
5493        #[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"]
5494        pub const _0: Self = Self::new(0);
5495
5496        #[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"]
5497        pub const _1: Self = Self::new(1);
5498    }
5499    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5500    pub struct Cmplcha8_SPEC;
5501    pub type Cmplcha8 = crate::EnumBitfieldStruct<u8, Cmplcha8_SPEC>;
5502    impl Cmplcha8 {
5503        #[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"]
5504        pub const _0: Self = Self::new(0);
5505
5506        #[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"]
5507        pub const _1: Self = Self::new(1);
5508    }
5509    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5510    pub struct Cmplcha9_SPEC;
5511    pub type Cmplcha9 = crate::EnumBitfieldStruct<u8, Cmplcha9_SPEC>;
5512    impl Cmplcha9 {
5513        #[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"]
5514        pub const _0: Self = Self::new(0);
5515
5516        #[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"]
5517        pub const _1: Self = Self::new(1);
5518    }
5519    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5520    pub struct Cmplcha12_SPEC;
5521    pub type Cmplcha12 = crate::EnumBitfieldStruct<u8, Cmplcha12_SPEC>;
5522    impl Cmplcha12 {
5523        #[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"]
5524        pub const _0: Self = Self::new(0);
5525
5526        #[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"]
5527        pub const _1: Self = Self::new(1);
5528    }
5529    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5530    pub struct Cmplcha13_SPEC;
5531    pub type Cmplcha13 = crate::EnumBitfieldStruct<u8, Cmplcha13_SPEC>;
5532    impl Cmplcha13 {
5533        #[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"]
5534        pub const _0: Self = Self::new(0);
5535
5536        #[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"]
5537        pub const _1: Self = Self::new(1);
5538    }
5539}
5540#[doc(hidden)]
5541#[derive(Copy, Clone, Eq, PartialEq)]
5542pub struct Adcmplr1_SPEC;
5543impl crate::sealed::RegSpec for Adcmplr1_SPEC {
5544    type DataType = u16;
5545}
5546
5547#[doc = "A/D Compare Function Window A Comparison Condition Setting Register 1"]
5548pub type Adcmplr1 = crate::RegValueT<Adcmplr1_SPEC>;
5549
5550impl Adcmplr1 {
5551    #[doc = "Compare Window A Comparison Condition Select"]
5552    #[inline(always)]
5553    pub fn cmplcha16(
5554        self,
5555    ) -> crate::common::RegisterField<
5556        0,
5557        0x1,
5558        1,
5559        0,
5560        adcmplr1::Cmplcha16,
5561        adcmplr1::Cmplcha16,
5562        Adcmplr1_SPEC,
5563        crate::common::RW,
5564    > {
5565        crate::common::RegisterField::<
5566            0,
5567            0x1,
5568            1,
5569            0,
5570            adcmplr1::Cmplcha16,
5571            adcmplr1::Cmplcha16,
5572            Adcmplr1_SPEC,
5573            crate::common::RW,
5574        >::from_register(self, 0)
5575    }
5576
5577    #[doc = "Compare Window A Comparison Condition Select"]
5578    #[inline(always)]
5579    pub fn cmplcha17(
5580        self,
5581    ) -> crate::common::RegisterField<
5582        1,
5583        0x1,
5584        1,
5585        0,
5586        adcmplr1::Cmplcha17,
5587        adcmplr1::Cmplcha17,
5588        Adcmplr1_SPEC,
5589        crate::common::RW,
5590    > {
5591        crate::common::RegisterField::<
5592            1,
5593            0x1,
5594            1,
5595            0,
5596            adcmplr1::Cmplcha17,
5597            adcmplr1::Cmplcha17,
5598            Adcmplr1_SPEC,
5599            crate::common::RW,
5600        >::from_register(self, 0)
5601    }
5602
5603    #[doc = "Compare Window A Comparison Condition Select"]
5604    #[inline(always)]
5605    pub fn cmplcha18(
5606        self,
5607    ) -> crate::common::RegisterField<
5608        2,
5609        0x1,
5610        1,
5611        0,
5612        adcmplr1::Cmplcha18,
5613        adcmplr1::Cmplcha18,
5614        Adcmplr1_SPEC,
5615        crate::common::RW,
5616    > {
5617        crate::common::RegisterField::<
5618            2,
5619            0x1,
5620            1,
5621            0,
5622            adcmplr1::Cmplcha18,
5623            adcmplr1::Cmplcha18,
5624            Adcmplr1_SPEC,
5625            crate::common::RW,
5626        >::from_register(self, 0)
5627    }
5628
5629    #[doc = "Compare Window A Comparison Condition Select"]
5630    #[inline(always)]
5631    pub fn cmplcha19(
5632        self,
5633    ) -> crate::common::RegisterField<
5634        3,
5635        0x1,
5636        1,
5637        0,
5638        adcmplr1::Cmplcha19,
5639        adcmplr1::Cmplcha19,
5640        Adcmplr1_SPEC,
5641        crate::common::RW,
5642    > {
5643        crate::common::RegisterField::<
5644            3,
5645            0x1,
5646            1,
5647            0,
5648            adcmplr1::Cmplcha19,
5649            adcmplr1::Cmplcha19,
5650            Adcmplr1_SPEC,
5651            crate::common::RW,
5652        >::from_register(self, 0)
5653    }
5654
5655    #[doc = "Compare Window A Comparison Condition Select"]
5656    #[inline(always)]
5657    pub fn cmplcha20(
5658        self,
5659    ) -> crate::common::RegisterField<
5660        4,
5661        0x1,
5662        1,
5663        0,
5664        adcmplr1::Cmplcha20,
5665        adcmplr1::Cmplcha20,
5666        Adcmplr1_SPEC,
5667        crate::common::RW,
5668    > {
5669        crate::common::RegisterField::<
5670            4,
5671            0x1,
5672            1,
5673            0,
5674            adcmplr1::Cmplcha20,
5675            adcmplr1::Cmplcha20,
5676            Adcmplr1_SPEC,
5677            crate::common::RW,
5678        >::from_register(self, 0)
5679    }
5680
5681    #[doc = "Compare Window A Comparison Condition Select"]
5682    #[inline(always)]
5683    pub fn cmplcha21(
5684        self,
5685    ) -> crate::common::RegisterField<
5686        5,
5687        0x1,
5688        1,
5689        0,
5690        adcmplr1::Cmplcha21,
5691        adcmplr1::Cmplcha21,
5692        Adcmplr1_SPEC,
5693        crate::common::RW,
5694    > {
5695        crate::common::RegisterField::<
5696            5,
5697            0x1,
5698            1,
5699            0,
5700            adcmplr1::Cmplcha21,
5701            adcmplr1::Cmplcha21,
5702            Adcmplr1_SPEC,
5703            crate::common::RW,
5704        >::from_register(self, 0)
5705    }
5706
5707    #[doc = "Compare Window A Comparison Condition Select"]
5708    #[inline(always)]
5709    pub fn cmplcha22(
5710        self,
5711    ) -> crate::common::RegisterField<
5712        6,
5713        0x1,
5714        1,
5715        0,
5716        adcmplr1::Cmplcha22,
5717        adcmplr1::Cmplcha22,
5718        Adcmplr1_SPEC,
5719        crate::common::RW,
5720    > {
5721        crate::common::RegisterField::<
5722            6,
5723            0x1,
5724            1,
5725            0,
5726            adcmplr1::Cmplcha22,
5727            adcmplr1::Cmplcha22,
5728            Adcmplr1_SPEC,
5729            crate::common::RW,
5730        >::from_register(self, 0)
5731    }
5732}
5733impl ::core::default::Default for Adcmplr1 {
5734    #[inline(always)]
5735    fn default() -> Adcmplr1 {
5736        <crate::RegValueT<Adcmplr1_SPEC> as RegisterValue<_>>::new(0)
5737    }
5738}
5739pub mod adcmplr1 {
5740
5741    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5742    pub struct Cmplcha16_SPEC;
5743    pub type Cmplcha16 = crate::EnumBitfieldStruct<u8, Cmplcha16_SPEC>;
5744    impl Cmplcha16 {
5745        #[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"]
5746        pub const _0: Self = Self::new(0);
5747
5748        #[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"]
5749        pub const _1: Self = Self::new(1);
5750    }
5751    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5752    pub struct Cmplcha17_SPEC;
5753    pub type Cmplcha17 = crate::EnumBitfieldStruct<u8, Cmplcha17_SPEC>;
5754    impl Cmplcha17 {
5755        #[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"]
5756        pub const _0: Self = Self::new(0);
5757
5758        #[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"]
5759        pub const _1: Self = Self::new(1);
5760    }
5761    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5762    pub struct Cmplcha18_SPEC;
5763    pub type Cmplcha18 = crate::EnumBitfieldStruct<u8, Cmplcha18_SPEC>;
5764    impl Cmplcha18 {
5765        #[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"]
5766        pub const _0: Self = Self::new(0);
5767
5768        #[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"]
5769        pub const _1: Self = Self::new(1);
5770    }
5771    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5772    pub struct Cmplcha19_SPEC;
5773    pub type Cmplcha19 = crate::EnumBitfieldStruct<u8, Cmplcha19_SPEC>;
5774    impl Cmplcha19 {
5775        #[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"]
5776        pub const _0: Self = Self::new(0);
5777
5778        #[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"]
5779        pub const _1: Self = Self::new(1);
5780    }
5781    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5782    pub struct Cmplcha20_SPEC;
5783    pub type Cmplcha20 = crate::EnumBitfieldStruct<u8, Cmplcha20_SPEC>;
5784    impl Cmplcha20 {
5785        #[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"]
5786        pub const _0: Self = Self::new(0);
5787
5788        #[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"]
5789        pub const _1: Self = Self::new(1);
5790    }
5791    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5792    pub struct Cmplcha21_SPEC;
5793    pub type Cmplcha21 = crate::EnumBitfieldStruct<u8, Cmplcha21_SPEC>;
5794    impl Cmplcha21 {
5795        #[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"]
5796        pub const _0: Self = Self::new(0);
5797
5798        #[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"]
5799        pub const _1: Self = Self::new(1);
5800    }
5801    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
5802    pub struct Cmplcha22_SPEC;
5803    pub type Cmplcha22 = crate::EnumBitfieldStruct<u8, Cmplcha22_SPEC>;
5804    impl Cmplcha22 {
5805        #[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"]
5806        pub const _0: Self = Self::new(0);
5807
5808        #[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"]
5809        pub const _1: Self = Self::new(1);
5810    }
5811}
5812#[doc(hidden)]
5813#[derive(Copy, Clone, Eq, PartialEq)]
5814pub struct Adcmpdr_SPEC;
5815impl crate::sealed::RegSpec for Adcmpdr_SPEC {
5816    type DataType = u16;
5817}
5818
5819#[doc = "A/D Compare Function Window A Lower-Side/Upper-Side Level Setting Register"]
5820pub type Adcmpdr = crate::RegValueT<Adcmpdr_SPEC>;
5821
5822impl NoBitfieldReg<Adcmpdr_SPEC> for Adcmpdr {}
5823impl ::core::default::Default for Adcmpdr {
5824    #[inline(always)]
5825    fn default() -> Adcmpdr {
5826        <crate::RegValueT<Adcmpdr_SPEC> as RegisterValue<_>>::new(0)
5827    }
5828}
5829
5830#[doc(hidden)]
5831#[derive(Copy, Clone, Eq, PartialEq)]
5832pub struct Adcmpsr0_SPEC;
5833impl crate::sealed::RegSpec for Adcmpsr0_SPEC {
5834    type DataType = u16;
5835}
5836
5837#[doc = "A/D Compare Function Window A Channel Status Register 0"]
5838pub type Adcmpsr0 = crate::RegValueT<Adcmpsr0_SPEC>;
5839
5840impl Adcmpsr0 {
5841    #[doc = "Compare Window A Flag"]
5842    #[inline(always)]
5843    pub fn cmpstcha0(
5844        self,
5845    ) -> crate::common::RegisterField<
5846        0,
5847        0x1,
5848        1,
5849        0,
5850        adcmpsr0::Cmpstcha0,
5851        adcmpsr0::Cmpstcha0,
5852        Adcmpsr0_SPEC,
5853        crate::common::RW,
5854    > {
5855        crate::common::RegisterField::<
5856            0,
5857            0x1,
5858            1,
5859            0,
5860            adcmpsr0::Cmpstcha0,
5861            adcmpsr0::Cmpstcha0,
5862            Adcmpsr0_SPEC,
5863            crate::common::RW,
5864        >::from_register(self, 0)
5865    }
5866
5867    #[doc = "Compare Window A Flag"]
5868    #[inline(always)]
5869    pub fn cmpstcha1(
5870        self,
5871    ) -> crate::common::RegisterField<
5872        1,
5873        0x1,
5874        1,
5875        0,
5876        adcmpsr0::Cmpstcha1,
5877        adcmpsr0::Cmpstcha1,
5878        Adcmpsr0_SPEC,
5879        crate::common::RW,
5880    > {
5881        crate::common::RegisterField::<
5882            1,
5883            0x1,
5884            1,
5885            0,
5886            adcmpsr0::Cmpstcha1,
5887            adcmpsr0::Cmpstcha1,
5888            Adcmpsr0_SPEC,
5889            crate::common::RW,
5890        >::from_register(self, 0)
5891    }
5892
5893    #[doc = "Compare Window A Flag"]
5894    #[inline(always)]
5895    pub fn cmpstcha2(
5896        self,
5897    ) -> crate::common::RegisterField<
5898        2,
5899        0x1,
5900        1,
5901        0,
5902        adcmpsr0::Cmpstcha2,
5903        adcmpsr0::Cmpstcha2,
5904        Adcmpsr0_SPEC,
5905        crate::common::RW,
5906    > {
5907        crate::common::RegisterField::<
5908            2,
5909            0x1,
5910            1,
5911            0,
5912            adcmpsr0::Cmpstcha2,
5913            adcmpsr0::Cmpstcha2,
5914            Adcmpsr0_SPEC,
5915            crate::common::RW,
5916        >::from_register(self, 0)
5917    }
5918
5919    #[doc = "Compare Window A Flag"]
5920    #[inline(always)]
5921    pub fn cmpstcha3(
5922        self,
5923    ) -> crate::common::RegisterField<
5924        3,
5925        0x1,
5926        1,
5927        0,
5928        adcmpsr0::Cmpstcha3,
5929        adcmpsr0::Cmpstcha3,
5930        Adcmpsr0_SPEC,
5931        crate::common::RW,
5932    > {
5933        crate::common::RegisterField::<
5934            3,
5935            0x1,
5936            1,
5937            0,
5938            adcmpsr0::Cmpstcha3,
5939            adcmpsr0::Cmpstcha3,
5940            Adcmpsr0_SPEC,
5941            crate::common::RW,
5942        >::from_register(self, 0)
5943    }
5944
5945    #[doc = "Compare Window A Flag"]
5946    #[inline(always)]
5947    pub fn cmpstcha4(
5948        self,
5949    ) -> crate::common::RegisterField<
5950        4,
5951        0x1,
5952        1,
5953        0,
5954        adcmpsr0::Cmpstcha4,
5955        adcmpsr0::Cmpstcha4,
5956        Adcmpsr0_SPEC,
5957        crate::common::RW,
5958    > {
5959        crate::common::RegisterField::<
5960            4,
5961            0x1,
5962            1,
5963            0,
5964            adcmpsr0::Cmpstcha4,
5965            adcmpsr0::Cmpstcha4,
5966            Adcmpsr0_SPEC,
5967            crate::common::RW,
5968        >::from_register(self, 0)
5969    }
5970
5971    #[doc = "Compare Window A Flag"]
5972    #[inline(always)]
5973    pub fn cmpstcha5(
5974        self,
5975    ) -> crate::common::RegisterField<
5976        5,
5977        0x1,
5978        1,
5979        0,
5980        adcmpsr0::Cmpstcha5,
5981        adcmpsr0::Cmpstcha5,
5982        Adcmpsr0_SPEC,
5983        crate::common::RW,
5984    > {
5985        crate::common::RegisterField::<
5986            5,
5987            0x1,
5988            1,
5989            0,
5990            adcmpsr0::Cmpstcha5,
5991            adcmpsr0::Cmpstcha5,
5992            Adcmpsr0_SPEC,
5993            crate::common::RW,
5994        >::from_register(self, 0)
5995    }
5996
5997    #[doc = "Compare Window A Flag"]
5998    #[inline(always)]
5999    pub fn cmpstcha6(
6000        self,
6001    ) -> crate::common::RegisterField<
6002        6,
6003        0x1,
6004        1,
6005        0,
6006        adcmpsr0::Cmpstcha6,
6007        adcmpsr0::Cmpstcha6,
6008        Adcmpsr0_SPEC,
6009        crate::common::RW,
6010    > {
6011        crate::common::RegisterField::<
6012            6,
6013            0x1,
6014            1,
6015            0,
6016            adcmpsr0::Cmpstcha6,
6017            adcmpsr0::Cmpstcha6,
6018            Adcmpsr0_SPEC,
6019            crate::common::RW,
6020        >::from_register(self, 0)
6021    }
6022
6023    #[doc = "Compare Window A Flag"]
6024    #[inline(always)]
6025    pub fn cmpstcha7(
6026        self,
6027    ) -> crate::common::RegisterField<
6028        7,
6029        0x1,
6030        1,
6031        0,
6032        adcmpsr0::Cmpstcha7,
6033        adcmpsr0::Cmpstcha7,
6034        Adcmpsr0_SPEC,
6035        crate::common::RW,
6036    > {
6037        crate::common::RegisterField::<
6038            7,
6039            0x1,
6040            1,
6041            0,
6042            adcmpsr0::Cmpstcha7,
6043            adcmpsr0::Cmpstcha7,
6044            Adcmpsr0_SPEC,
6045            crate::common::RW,
6046        >::from_register(self, 0)
6047    }
6048
6049    #[doc = "Compare Window A Flag"]
6050    #[inline(always)]
6051    pub fn cmpstcha8(
6052        self,
6053    ) -> crate::common::RegisterField<
6054        8,
6055        0x1,
6056        1,
6057        0,
6058        adcmpsr0::Cmpstcha8,
6059        adcmpsr0::Cmpstcha8,
6060        Adcmpsr0_SPEC,
6061        crate::common::RW,
6062    > {
6063        crate::common::RegisterField::<
6064            8,
6065            0x1,
6066            1,
6067            0,
6068            adcmpsr0::Cmpstcha8,
6069            adcmpsr0::Cmpstcha8,
6070            Adcmpsr0_SPEC,
6071            crate::common::RW,
6072        >::from_register(self, 0)
6073    }
6074
6075    #[doc = "Compare Window A Flag"]
6076    #[inline(always)]
6077    pub fn cmpstcha9(
6078        self,
6079    ) -> crate::common::RegisterField<
6080        9,
6081        0x1,
6082        1,
6083        0,
6084        adcmpsr0::Cmpstcha9,
6085        adcmpsr0::Cmpstcha9,
6086        Adcmpsr0_SPEC,
6087        crate::common::RW,
6088    > {
6089        crate::common::RegisterField::<
6090            9,
6091            0x1,
6092            1,
6093            0,
6094            adcmpsr0::Cmpstcha9,
6095            adcmpsr0::Cmpstcha9,
6096            Adcmpsr0_SPEC,
6097            crate::common::RW,
6098        >::from_register(self, 0)
6099    }
6100
6101    #[doc = "Compare Window A Flag"]
6102    #[inline(always)]
6103    pub fn cmpstcha12(
6104        self,
6105    ) -> crate::common::RegisterField<
6106        12,
6107        0x1,
6108        1,
6109        0,
6110        adcmpsr0::Cmpstcha12,
6111        adcmpsr0::Cmpstcha12,
6112        Adcmpsr0_SPEC,
6113        crate::common::RW,
6114    > {
6115        crate::common::RegisterField::<
6116            12,
6117            0x1,
6118            1,
6119            0,
6120            adcmpsr0::Cmpstcha12,
6121            adcmpsr0::Cmpstcha12,
6122            Adcmpsr0_SPEC,
6123            crate::common::RW,
6124        >::from_register(self, 0)
6125    }
6126
6127    #[doc = "Compare Window A Flag"]
6128    #[inline(always)]
6129    pub fn cmpstcha13(
6130        self,
6131    ) -> crate::common::RegisterField<
6132        13,
6133        0x1,
6134        1,
6135        0,
6136        adcmpsr0::Cmpstcha13,
6137        adcmpsr0::Cmpstcha13,
6138        Adcmpsr0_SPEC,
6139        crate::common::RW,
6140    > {
6141        crate::common::RegisterField::<
6142            13,
6143            0x1,
6144            1,
6145            0,
6146            adcmpsr0::Cmpstcha13,
6147            adcmpsr0::Cmpstcha13,
6148            Adcmpsr0_SPEC,
6149            crate::common::RW,
6150        >::from_register(self, 0)
6151    }
6152}
6153impl ::core::default::Default for Adcmpsr0 {
6154    #[inline(always)]
6155    fn default() -> Adcmpsr0 {
6156        <crate::RegValueT<Adcmpsr0_SPEC> as RegisterValue<_>>::new(0)
6157    }
6158}
6159pub mod adcmpsr0 {
6160
6161    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6162    pub struct Cmpstcha0_SPEC;
6163    pub type Cmpstcha0 = crate::EnumBitfieldStruct<u8, Cmpstcha0_SPEC>;
6164    impl Cmpstcha0 {
6165        #[doc = "Comparison conditions are not met."]
6166        pub const _0: Self = Self::new(0);
6167
6168        #[doc = "Comparison conditions are met."]
6169        pub const _1: Self = Self::new(1);
6170    }
6171    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6172    pub struct Cmpstcha1_SPEC;
6173    pub type Cmpstcha1 = crate::EnumBitfieldStruct<u8, Cmpstcha1_SPEC>;
6174    impl Cmpstcha1 {
6175        #[doc = "Comparison conditions are not met."]
6176        pub const _0: Self = Self::new(0);
6177
6178        #[doc = "Comparison conditions are met."]
6179        pub const _1: Self = Self::new(1);
6180    }
6181    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6182    pub struct Cmpstcha2_SPEC;
6183    pub type Cmpstcha2 = crate::EnumBitfieldStruct<u8, Cmpstcha2_SPEC>;
6184    impl Cmpstcha2 {
6185        #[doc = "Comparison conditions are not met."]
6186        pub const _0: Self = Self::new(0);
6187
6188        #[doc = "Comparison conditions are met."]
6189        pub const _1: Self = Self::new(1);
6190    }
6191    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6192    pub struct Cmpstcha3_SPEC;
6193    pub type Cmpstcha3 = crate::EnumBitfieldStruct<u8, Cmpstcha3_SPEC>;
6194    impl Cmpstcha3 {
6195        #[doc = "Comparison conditions are not met."]
6196        pub const _0: Self = Self::new(0);
6197
6198        #[doc = "Comparison conditions are met."]
6199        pub const _1: Self = Self::new(1);
6200    }
6201    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6202    pub struct Cmpstcha4_SPEC;
6203    pub type Cmpstcha4 = crate::EnumBitfieldStruct<u8, Cmpstcha4_SPEC>;
6204    impl Cmpstcha4 {
6205        #[doc = "Comparison conditions are not met."]
6206        pub const _0: Self = Self::new(0);
6207
6208        #[doc = "Comparison conditions are met."]
6209        pub const _1: Self = Self::new(1);
6210    }
6211    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6212    pub struct Cmpstcha5_SPEC;
6213    pub type Cmpstcha5 = crate::EnumBitfieldStruct<u8, Cmpstcha5_SPEC>;
6214    impl Cmpstcha5 {
6215        #[doc = "Comparison conditions are not met."]
6216        pub const _0: Self = Self::new(0);
6217
6218        #[doc = "Comparison conditions are met."]
6219        pub const _1: Self = Self::new(1);
6220    }
6221    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6222    pub struct Cmpstcha6_SPEC;
6223    pub type Cmpstcha6 = crate::EnumBitfieldStruct<u8, Cmpstcha6_SPEC>;
6224    impl Cmpstcha6 {
6225        #[doc = "Comparison conditions are not met."]
6226        pub const _0: Self = Self::new(0);
6227
6228        #[doc = "Comparison conditions are met."]
6229        pub const _1: Self = Self::new(1);
6230    }
6231    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6232    pub struct Cmpstcha7_SPEC;
6233    pub type Cmpstcha7 = crate::EnumBitfieldStruct<u8, Cmpstcha7_SPEC>;
6234    impl Cmpstcha7 {
6235        #[doc = "Comparison conditions are not met."]
6236        pub const _0: Self = Self::new(0);
6237
6238        #[doc = "Comparison conditions are met."]
6239        pub const _1: Self = Self::new(1);
6240    }
6241    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6242    pub struct Cmpstcha8_SPEC;
6243    pub type Cmpstcha8 = crate::EnumBitfieldStruct<u8, Cmpstcha8_SPEC>;
6244    impl Cmpstcha8 {
6245        #[doc = "Comparison conditions are not met."]
6246        pub const _0: Self = Self::new(0);
6247
6248        #[doc = "Comparison conditions are met."]
6249        pub const _1: Self = Self::new(1);
6250    }
6251    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6252    pub struct Cmpstcha9_SPEC;
6253    pub type Cmpstcha9 = crate::EnumBitfieldStruct<u8, Cmpstcha9_SPEC>;
6254    impl Cmpstcha9 {
6255        #[doc = "Comparison conditions are not met."]
6256        pub const _0: Self = Self::new(0);
6257
6258        #[doc = "Comparison conditions are met."]
6259        pub const _1: Self = Self::new(1);
6260    }
6261    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6262    pub struct Cmpstcha12_SPEC;
6263    pub type Cmpstcha12 = crate::EnumBitfieldStruct<u8, Cmpstcha12_SPEC>;
6264    impl Cmpstcha12 {
6265        #[doc = "Comparison conditions are not met."]
6266        pub const _0: Self = Self::new(0);
6267
6268        #[doc = "Comparison conditions are met."]
6269        pub const _1: Self = Self::new(1);
6270    }
6271    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6272    pub struct Cmpstcha13_SPEC;
6273    pub type Cmpstcha13 = crate::EnumBitfieldStruct<u8, Cmpstcha13_SPEC>;
6274    impl Cmpstcha13 {
6275        #[doc = "Comparison conditions are not met."]
6276        pub const _0: Self = Self::new(0);
6277
6278        #[doc = "Comparison conditions are met."]
6279        pub const _1: Self = Self::new(1);
6280    }
6281}
6282#[doc(hidden)]
6283#[derive(Copy, Clone, Eq, PartialEq)]
6284pub struct Adcmpsr1_SPEC;
6285impl crate::sealed::RegSpec for Adcmpsr1_SPEC {
6286    type DataType = u16;
6287}
6288
6289#[doc = "A/D Compare Function Window A Channel Status Register1"]
6290pub type Adcmpsr1 = crate::RegValueT<Adcmpsr1_SPEC>;
6291
6292impl Adcmpsr1 {
6293    #[doc = "Compare Window A Flag"]
6294    #[inline(always)]
6295    pub fn cmpstcha16(
6296        self,
6297    ) -> crate::common::RegisterField<
6298        0,
6299        0x1,
6300        1,
6301        0,
6302        adcmpsr1::Cmpstcha16,
6303        adcmpsr1::Cmpstcha16,
6304        Adcmpsr1_SPEC,
6305        crate::common::RW,
6306    > {
6307        crate::common::RegisterField::<
6308            0,
6309            0x1,
6310            1,
6311            0,
6312            adcmpsr1::Cmpstcha16,
6313            adcmpsr1::Cmpstcha16,
6314            Adcmpsr1_SPEC,
6315            crate::common::RW,
6316        >::from_register(self, 0)
6317    }
6318
6319    #[doc = "Compare Window A Flag"]
6320    #[inline(always)]
6321    pub fn cmpstcha17(
6322        self,
6323    ) -> crate::common::RegisterField<
6324        1,
6325        0x1,
6326        1,
6327        0,
6328        adcmpsr1::Cmpstcha17,
6329        adcmpsr1::Cmpstcha17,
6330        Adcmpsr1_SPEC,
6331        crate::common::RW,
6332    > {
6333        crate::common::RegisterField::<
6334            1,
6335            0x1,
6336            1,
6337            0,
6338            adcmpsr1::Cmpstcha17,
6339            adcmpsr1::Cmpstcha17,
6340            Adcmpsr1_SPEC,
6341            crate::common::RW,
6342        >::from_register(self, 0)
6343    }
6344
6345    #[doc = "Compare Window A Flag"]
6346    #[inline(always)]
6347    pub fn cmpstcha18(
6348        self,
6349    ) -> crate::common::RegisterField<
6350        2,
6351        0x1,
6352        1,
6353        0,
6354        adcmpsr1::Cmpstcha18,
6355        adcmpsr1::Cmpstcha18,
6356        Adcmpsr1_SPEC,
6357        crate::common::RW,
6358    > {
6359        crate::common::RegisterField::<
6360            2,
6361            0x1,
6362            1,
6363            0,
6364            adcmpsr1::Cmpstcha18,
6365            adcmpsr1::Cmpstcha18,
6366            Adcmpsr1_SPEC,
6367            crate::common::RW,
6368        >::from_register(self, 0)
6369    }
6370
6371    #[doc = "Compare Window A Flag"]
6372    #[inline(always)]
6373    pub fn cmpstcha19(
6374        self,
6375    ) -> crate::common::RegisterField<
6376        3,
6377        0x1,
6378        1,
6379        0,
6380        adcmpsr1::Cmpstcha19,
6381        adcmpsr1::Cmpstcha19,
6382        Adcmpsr1_SPEC,
6383        crate::common::RW,
6384    > {
6385        crate::common::RegisterField::<
6386            3,
6387            0x1,
6388            1,
6389            0,
6390            adcmpsr1::Cmpstcha19,
6391            adcmpsr1::Cmpstcha19,
6392            Adcmpsr1_SPEC,
6393            crate::common::RW,
6394        >::from_register(self, 0)
6395    }
6396
6397    #[doc = "Compare Window A Flag"]
6398    #[inline(always)]
6399    pub fn cmpstcha20(
6400        self,
6401    ) -> crate::common::RegisterField<
6402        4,
6403        0x1,
6404        1,
6405        0,
6406        adcmpsr1::Cmpstcha20,
6407        adcmpsr1::Cmpstcha20,
6408        Adcmpsr1_SPEC,
6409        crate::common::RW,
6410    > {
6411        crate::common::RegisterField::<
6412            4,
6413            0x1,
6414            1,
6415            0,
6416            adcmpsr1::Cmpstcha20,
6417            adcmpsr1::Cmpstcha20,
6418            Adcmpsr1_SPEC,
6419            crate::common::RW,
6420        >::from_register(self, 0)
6421    }
6422
6423    #[doc = "Compare Window A Flag"]
6424    #[inline(always)]
6425    pub fn cmpstcha21(
6426        self,
6427    ) -> crate::common::RegisterField<
6428        5,
6429        0x1,
6430        1,
6431        0,
6432        adcmpsr1::Cmpstcha21,
6433        adcmpsr1::Cmpstcha21,
6434        Adcmpsr1_SPEC,
6435        crate::common::RW,
6436    > {
6437        crate::common::RegisterField::<
6438            5,
6439            0x1,
6440            1,
6441            0,
6442            adcmpsr1::Cmpstcha21,
6443            adcmpsr1::Cmpstcha21,
6444            Adcmpsr1_SPEC,
6445            crate::common::RW,
6446        >::from_register(self, 0)
6447    }
6448
6449    #[doc = "Compare Window A Flag"]
6450    #[inline(always)]
6451    pub fn cmpstcha22(
6452        self,
6453    ) -> crate::common::RegisterField<
6454        6,
6455        0x1,
6456        1,
6457        0,
6458        adcmpsr1::Cmpstcha22,
6459        adcmpsr1::Cmpstcha22,
6460        Adcmpsr1_SPEC,
6461        crate::common::RW,
6462    > {
6463        crate::common::RegisterField::<
6464            6,
6465            0x1,
6466            1,
6467            0,
6468            adcmpsr1::Cmpstcha22,
6469            adcmpsr1::Cmpstcha22,
6470            Adcmpsr1_SPEC,
6471            crate::common::RW,
6472        >::from_register(self, 0)
6473    }
6474}
6475impl ::core::default::Default for Adcmpsr1 {
6476    #[inline(always)]
6477    fn default() -> Adcmpsr1 {
6478        <crate::RegValueT<Adcmpsr1_SPEC> as RegisterValue<_>>::new(0)
6479    }
6480}
6481pub mod adcmpsr1 {
6482
6483    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6484    pub struct Cmpstcha16_SPEC;
6485    pub type Cmpstcha16 = crate::EnumBitfieldStruct<u8, Cmpstcha16_SPEC>;
6486    impl Cmpstcha16 {
6487        #[doc = "Comparison conditions are not met."]
6488        pub const _0: Self = Self::new(0);
6489
6490        #[doc = "Comparison conditions are met."]
6491        pub const _1: Self = Self::new(1);
6492    }
6493    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6494    pub struct Cmpstcha17_SPEC;
6495    pub type Cmpstcha17 = crate::EnumBitfieldStruct<u8, Cmpstcha17_SPEC>;
6496    impl Cmpstcha17 {
6497        #[doc = "Comparison conditions are not met."]
6498        pub const _0: Self = Self::new(0);
6499
6500        #[doc = "Comparison conditions are met."]
6501        pub const _1: Self = Self::new(1);
6502    }
6503    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6504    pub struct Cmpstcha18_SPEC;
6505    pub type Cmpstcha18 = crate::EnumBitfieldStruct<u8, Cmpstcha18_SPEC>;
6506    impl Cmpstcha18 {
6507        #[doc = "Comparison conditions are not met."]
6508        pub const _0: Self = Self::new(0);
6509
6510        #[doc = "Comparison conditions are met."]
6511        pub const _1: Self = Self::new(1);
6512    }
6513    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6514    pub struct Cmpstcha19_SPEC;
6515    pub type Cmpstcha19 = crate::EnumBitfieldStruct<u8, Cmpstcha19_SPEC>;
6516    impl Cmpstcha19 {
6517        #[doc = "Comparison conditions are not met."]
6518        pub const _0: Self = Self::new(0);
6519
6520        #[doc = "Comparison conditions are met."]
6521        pub const _1: Self = Self::new(1);
6522    }
6523    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6524    pub struct Cmpstcha20_SPEC;
6525    pub type Cmpstcha20 = crate::EnumBitfieldStruct<u8, Cmpstcha20_SPEC>;
6526    impl Cmpstcha20 {
6527        #[doc = "Comparison conditions are not met."]
6528        pub const _0: Self = Self::new(0);
6529
6530        #[doc = "Comparison conditions are met."]
6531        pub const _1: Self = Self::new(1);
6532    }
6533    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6534    pub struct Cmpstcha21_SPEC;
6535    pub type Cmpstcha21 = crate::EnumBitfieldStruct<u8, Cmpstcha21_SPEC>;
6536    impl Cmpstcha21 {
6537        #[doc = "Comparison conditions are not met."]
6538        pub const _0: Self = Self::new(0);
6539
6540        #[doc = "Comparison conditions are met."]
6541        pub const _1: Self = Self::new(1);
6542    }
6543    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6544    pub struct Cmpstcha22_SPEC;
6545    pub type Cmpstcha22 = crate::EnumBitfieldStruct<u8, Cmpstcha22_SPEC>;
6546    impl Cmpstcha22 {
6547        #[doc = "Comparison conditions are not met."]
6548        pub const _0: Self = Self::new(0);
6549
6550        #[doc = "Comparison conditions are met."]
6551        pub const _1: Self = Self::new(1);
6552    }
6553}
6554#[doc(hidden)]
6555#[derive(Copy, Clone, Eq, PartialEq)]
6556pub struct Adcmpser_SPEC;
6557impl crate::sealed::RegSpec for Adcmpser_SPEC {
6558    type DataType = u8;
6559}
6560
6561#[doc = "A/D Compare Function Window A Extended Input Channel Status Register"]
6562pub type Adcmpser = crate::RegValueT<Adcmpser_SPEC>;
6563
6564impl Adcmpser {
6565    #[doc = "Compare Window A Temperature Sensor Output Compare Flag"]
6566    #[inline(always)]
6567    pub fn cmpsttsa(
6568        self,
6569    ) -> crate::common::RegisterField<
6570        0,
6571        0x1,
6572        1,
6573        0,
6574        adcmpser::Cmpsttsa,
6575        adcmpser::Cmpsttsa,
6576        Adcmpser_SPEC,
6577        crate::common::RW,
6578    > {
6579        crate::common::RegisterField::<
6580            0,
6581            0x1,
6582            1,
6583            0,
6584            adcmpser::Cmpsttsa,
6585            adcmpser::Cmpsttsa,
6586            Adcmpser_SPEC,
6587            crate::common::RW,
6588        >::from_register(self, 0)
6589    }
6590
6591    #[doc = "Compare Window A Internal Reference Voltage Compare Flag"]
6592    #[inline(always)]
6593    pub fn cmpstoca(
6594        self,
6595    ) -> crate::common::RegisterField<
6596        1,
6597        0x1,
6598        1,
6599        0,
6600        adcmpser::Cmpstoca,
6601        adcmpser::Cmpstoca,
6602        Adcmpser_SPEC,
6603        crate::common::RW,
6604    > {
6605        crate::common::RegisterField::<
6606            1,
6607            0x1,
6608            1,
6609            0,
6610            adcmpser::Cmpstoca,
6611            adcmpser::Cmpstoca,
6612            Adcmpser_SPEC,
6613            crate::common::RW,
6614        >::from_register(self, 0)
6615    }
6616}
6617impl ::core::default::Default for Adcmpser {
6618    #[inline(always)]
6619    fn default() -> Adcmpser {
6620        <crate::RegValueT<Adcmpser_SPEC> as RegisterValue<_>>::new(0)
6621    }
6622}
6623pub mod adcmpser {
6624
6625    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6626    pub struct Cmpsttsa_SPEC;
6627    pub type Cmpsttsa = crate::EnumBitfieldStruct<u8, Cmpsttsa_SPEC>;
6628    impl Cmpsttsa {
6629        #[doc = "Comparison conditions are not met."]
6630        pub const _0: Self = Self::new(0);
6631
6632        #[doc = "Comparison conditions are met."]
6633        pub const _1: Self = Self::new(1);
6634    }
6635    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6636    pub struct Cmpstoca_SPEC;
6637    pub type Cmpstoca = crate::EnumBitfieldStruct<u8, Cmpstoca_SPEC>;
6638    impl Cmpstoca {
6639        #[doc = "Comparison conditions are not met."]
6640        pub const _0: Self = Self::new(0);
6641
6642        #[doc = "Comparison conditions are met."]
6643        pub const _1: Self = Self::new(1);
6644    }
6645}
6646#[doc(hidden)]
6647#[derive(Copy, Clone, Eq, PartialEq)]
6648pub struct Adcmpbnsr_SPEC;
6649impl crate::sealed::RegSpec for Adcmpbnsr_SPEC {
6650    type DataType = u8;
6651}
6652
6653#[doc = "A/D Compare Function Window B Channel Select Register"]
6654pub type Adcmpbnsr = crate::RegValueT<Adcmpbnsr_SPEC>;
6655
6656impl Adcmpbnsr {
6657    #[doc = "Compare Window B Channel Select"]
6658    #[inline(always)]
6659    pub fn cmpchb(
6660        self,
6661    ) -> crate::common::RegisterField<0, 0x3f, 1, 0, u8, u8, Adcmpbnsr_SPEC, crate::common::RW>
6662    {
6663        crate::common::RegisterField::<0,0x3f,1,0,u8,u8,Adcmpbnsr_SPEC,crate::common::RW>::from_register(self,0)
6664    }
6665
6666    #[doc = "Compare Window B Comparison Condition Setting"]
6667    #[inline(always)]
6668    pub fn cmplb(
6669        self,
6670    ) -> crate::common::RegisterField<
6671        7,
6672        0x1,
6673        1,
6674        0,
6675        adcmpbnsr::Cmplb,
6676        adcmpbnsr::Cmplb,
6677        Adcmpbnsr_SPEC,
6678        crate::common::RW,
6679    > {
6680        crate::common::RegisterField::<
6681            7,
6682            0x1,
6683            1,
6684            0,
6685            adcmpbnsr::Cmplb,
6686            adcmpbnsr::Cmplb,
6687            Adcmpbnsr_SPEC,
6688            crate::common::RW,
6689        >::from_register(self, 0)
6690    }
6691}
6692impl ::core::default::Default for Adcmpbnsr {
6693    #[inline(always)]
6694    fn default() -> Adcmpbnsr {
6695        <crate::RegValueT<Adcmpbnsr_SPEC> as RegisterValue<_>>::new(0)
6696    }
6697}
6698pub mod adcmpbnsr {
6699
6700    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6701    pub struct Cmplb_SPEC;
6702    pub type Cmplb = crate::EnumBitfieldStruct<u8, Cmplb_SPEC>;
6703    impl Cmplb {
6704        #[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"]
6705        pub const _0: Self = Self::new(0);
6706
6707        #[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"]
6708        pub const _1: Self = Self::new(1);
6709    }
6710}
6711#[doc(hidden)]
6712#[derive(Copy, Clone, Eq, PartialEq)]
6713pub struct Adwinllb_SPEC;
6714impl crate::sealed::RegSpec for Adwinllb_SPEC {
6715    type DataType = u16;
6716}
6717
6718#[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
6719pub type Adwinllb = crate::RegValueT<Adwinllb_SPEC>;
6720
6721impl NoBitfieldReg<Adwinllb_SPEC> for Adwinllb {}
6722impl ::core::default::Default for Adwinllb {
6723    #[inline(always)]
6724    fn default() -> Adwinllb {
6725        <crate::RegValueT<Adwinllb_SPEC> as RegisterValue<_>>::new(0)
6726    }
6727}
6728
6729#[doc(hidden)]
6730#[derive(Copy, Clone, Eq, PartialEq)]
6731pub struct Adwinulb_SPEC;
6732impl crate::sealed::RegSpec for Adwinulb_SPEC {
6733    type DataType = u16;
6734}
6735
6736#[doc = "A/D Compare Function Window B Lower-Side/Upper-Side Level Setting Register"]
6737pub type Adwinulb = crate::RegValueT<Adwinulb_SPEC>;
6738
6739impl NoBitfieldReg<Adwinulb_SPEC> for Adwinulb {}
6740impl ::core::default::Default for Adwinulb {
6741    #[inline(always)]
6742    fn default() -> Adwinulb {
6743        <crate::RegValueT<Adwinulb_SPEC> as RegisterValue<_>>::new(0)
6744    }
6745}
6746
6747#[doc(hidden)]
6748#[derive(Copy, Clone, Eq, PartialEq)]
6749pub struct Adcmpbsr_SPEC;
6750impl crate::sealed::RegSpec for Adcmpbsr_SPEC {
6751    type DataType = u8;
6752}
6753
6754#[doc = "A/D Compare Function Window B Status Register"]
6755pub type Adcmpbsr = crate::RegValueT<Adcmpbsr_SPEC>;
6756
6757impl Adcmpbsr {
6758    #[doc = "Compare Window B Flag"]
6759    #[inline(always)]
6760    pub fn cmpstb(
6761        self,
6762    ) -> crate::common::RegisterField<
6763        0,
6764        0x1,
6765        1,
6766        0,
6767        adcmpbsr::Cmpstb,
6768        adcmpbsr::Cmpstb,
6769        Adcmpbsr_SPEC,
6770        crate::common::RW,
6771    > {
6772        crate::common::RegisterField::<
6773            0,
6774            0x1,
6775            1,
6776            0,
6777            adcmpbsr::Cmpstb,
6778            adcmpbsr::Cmpstb,
6779            Adcmpbsr_SPEC,
6780            crate::common::RW,
6781        >::from_register(self, 0)
6782    }
6783}
6784impl ::core::default::Default for Adcmpbsr {
6785    #[inline(always)]
6786    fn default() -> Adcmpbsr {
6787        <crate::RegValueT<Adcmpbsr_SPEC> as RegisterValue<_>>::new(0)
6788    }
6789}
6790pub mod adcmpbsr {
6791
6792    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6793    pub struct Cmpstb_SPEC;
6794    pub type Cmpstb = crate::EnumBitfieldStruct<u8, Cmpstb_SPEC>;
6795    impl Cmpstb {
6796        #[doc = "Comparison conditions are not met."]
6797        pub const _0: Self = Self::new(0);
6798
6799        #[doc = "Comparison conditions are met."]
6800        pub const _1: Self = Self::new(1);
6801    }
6802}
6803#[doc(hidden)]
6804#[derive(Copy, Clone, Eq, PartialEq)]
6805pub struct Adbuf_SPEC;
6806impl crate::sealed::RegSpec for Adbuf_SPEC {
6807    type DataType = u16;
6808}
6809
6810#[doc = "A/D Data Buffer Registers %s"]
6811pub type Adbuf = crate::RegValueT<Adbuf_SPEC>;
6812
6813impl Adbuf {
6814    #[doc = "Converted Value 15 to 0"]
6815    #[inline(always)]
6816    pub fn adbuf(
6817        self,
6818    ) -> crate::common::RegisterField<0, 0xffff, 1, 0, u16, u16, Adbuf_SPEC, crate::common::R> {
6819        crate::common::RegisterField::<0,0xffff,1,0,u16,u16,Adbuf_SPEC,crate::common::R>::from_register(self,0)
6820    }
6821}
6822impl ::core::default::Default for Adbuf {
6823    #[inline(always)]
6824    fn default() -> Adbuf {
6825        <crate::RegValueT<Adbuf_SPEC> as RegisterValue<_>>::new(0)
6826    }
6827}
6828
6829#[doc(hidden)]
6830#[derive(Copy, Clone, Eq, PartialEq)]
6831pub struct Adbufen_SPEC;
6832impl crate::sealed::RegSpec for Adbufen_SPEC {
6833    type DataType = u8;
6834}
6835
6836#[doc = "A/D Data Buffer Enable Register"]
6837pub type Adbufen = crate::RegValueT<Adbufen_SPEC>;
6838
6839impl Adbufen {
6840    #[doc = "Data Buffer Enable"]
6841    #[inline(always)]
6842    pub fn bufen(
6843        self,
6844    ) -> crate::common::RegisterField<
6845        0,
6846        0x1,
6847        1,
6848        0,
6849        adbufen::Bufen,
6850        adbufen::Bufen,
6851        Adbufen_SPEC,
6852        crate::common::RW,
6853    > {
6854        crate::common::RegisterField::<
6855            0,
6856            0x1,
6857            1,
6858            0,
6859            adbufen::Bufen,
6860            adbufen::Bufen,
6861            Adbufen_SPEC,
6862            crate::common::RW,
6863        >::from_register(self, 0)
6864    }
6865}
6866impl ::core::default::Default for Adbufen {
6867    #[inline(always)]
6868    fn default() -> Adbufen {
6869        <crate::RegValueT<Adbufen_SPEC> as RegisterValue<_>>::new(0)
6870    }
6871}
6872pub mod adbufen {
6873
6874    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6875    pub struct Bufen_SPEC;
6876    pub type Bufen = crate::EnumBitfieldStruct<u8, Bufen_SPEC>;
6877    impl Bufen {
6878        #[doc = "The data buffer is not used."]
6879        pub const _0: Self = Self::new(0);
6880
6881        #[doc = "The data buffer is used."]
6882        pub const _1: Self = Self::new(1);
6883    }
6884}
6885#[doc(hidden)]
6886#[derive(Copy, Clone, Eq, PartialEq)]
6887pub struct Adbufptr_SPEC;
6888impl crate::sealed::RegSpec for Adbufptr_SPEC {
6889    type DataType = u8;
6890}
6891
6892#[doc = "A/D Data Buffer Pointer Register"]
6893pub type Adbufptr = crate::RegValueT<Adbufptr_SPEC>;
6894
6895impl Adbufptr {
6896    #[doc = "Data Buffer Pointer"]
6897    #[inline(always)]
6898    pub fn bufptr(
6899        self,
6900    ) -> crate::common::RegisterField<0, 0xf, 1, 0, u8, u8, Adbufptr_SPEC, crate::common::RW> {
6901        crate::common::RegisterField::<0,0xf,1,0,u8,u8,Adbufptr_SPEC,crate::common::RW>::from_register(self,0)
6902    }
6903
6904    #[doc = "Pointer Overflow Flag"]
6905    #[inline(always)]
6906    pub fn ptrovf(
6907        self,
6908    ) -> crate::common::RegisterField<
6909        4,
6910        0x1,
6911        1,
6912        0,
6913        adbufptr::Ptrovf,
6914        adbufptr::Ptrovf,
6915        Adbufptr_SPEC,
6916        crate::common::RW,
6917    > {
6918        crate::common::RegisterField::<
6919            4,
6920            0x1,
6921            1,
6922            0,
6923            adbufptr::Ptrovf,
6924            adbufptr::Ptrovf,
6925            Adbufptr_SPEC,
6926            crate::common::RW,
6927        >::from_register(self, 0)
6928    }
6929}
6930impl ::core::default::Default for Adbufptr {
6931    #[inline(always)]
6932    fn default() -> Adbufptr {
6933        <crate::RegValueT<Adbufptr_SPEC> as RegisterValue<_>>::new(0)
6934    }
6935}
6936pub mod adbufptr {
6937
6938    #[derive(Clone, Copy, Eq, PartialEq, Ord, PartialOrd)]
6939    pub struct Ptrovf_SPEC;
6940    pub type Ptrovf = crate::EnumBitfieldStruct<u8, Ptrovf_SPEC>;
6941    impl Ptrovf {
6942        #[doc = "The data buffer pointer has not overflowed."]
6943        pub const _0: Self = Self::new(0);
6944
6945        #[doc = "The data buffer pointer has overflowed."]
6946        pub const _1: Self = Self::new(1);
6947    }
6948}
6949#[doc(hidden)]
6950#[derive(Copy, Clone, Eq, PartialEq)]
6951pub struct Adsstr_SPEC;
6952impl crate::sealed::RegSpec for Adsstr_SPEC {
6953    type DataType = u8;
6954}
6955
6956#[doc = "A/D Sampling State Register"]
6957pub type Adsstr = crate::RegValueT<Adsstr_SPEC>;
6958
6959impl Adsstr {
6960    #[doc = "Sampling Time Setting"]
6961    #[inline(always)]
6962    pub fn sst(
6963        self,
6964    ) -> crate::common::RegisterField<0, 0xff, 1, 0, u8, u8, Adsstr_SPEC, crate::common::RW> {
6965        crate::common::RegisterField::<0,0xff,1,0,u8,u8,Adsstr_SPEC,crate::common::RW>::from_register(self,0)
6966    }
6967}
6968impl ::core::default::Default for Adsstr {
6969    #[inline(always)]
6970    fn default() -> Adsstr {
6971        <crate::RegValueT<Adsstr_SPEC> as RegisterValue<_>>::new(11)
6972    }
6973}
ra4m3_pac/adc121.rs

ra4m3_pac/
adc121.rs
