1#![allow(clippy::missing_safety_doc)]
2#![allow(clippy::identity_op)]
3#![allow(clippy::unnecessary_cast)]
4#![allow(clippy::erasing_op)]
5
6#[doc = "Touch sensing controller."]
7#[derive(Copy, Clone, Eq, PartialEq)]
8pub struct Tsc {
9 ptr: *mut u8,
10}
11unsafe impl Send for Tsc {}
12unsafe impl Sync for Tsc {}
13impl Tsc {
14 #[inline(always)]
15 pub const unsafe fn from_ptr(ptr: *mut ()) -> Self {
16 Self { ptr: ptr as _ }
17 }
18 #[inline(always)]
19 pub const fn as_ptr(&self) -> *mut () {
20 self.ptr as _
21 }
22 #[doc = "control register."]
23 #[inline(always)]
24 pub const fn cr(self) -> crate::common::Reg<regs::Cr, crate::common::RW> {
25 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0usize) as _) }
26 }
27 #[doc = "interrupt enable register."]
28 #[inline(always)]
29 pub const fn ier(self) -> crate::common::Reg<regs::Ier, crate::common::RW> {
30 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x04usize) as _) }
31 }
32 #[doc = "interrupt clear register."]
33 #[inline(always)]
34 pub const fn icr(self) -> crate::common::Reg<regs::Icr, crate::common::RW> {
35 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x08usize) as _) }
36 }
37 #[doc = "interrupt status register."]
38 #[inline(always)]
39 pub const fn isr(self) -> crate::common::Reg<regs::Isr, crate::common::RW> {
40 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x0cusize) as _) }
41 }
42 #[doc = "I/O hysteresis control register."]
43 #[inline(always)]
44 pub const fn iohcr(self) -> crate::common::Reg<regs::Iohcr, crate::common::RW> {
45 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x10usize) as _) }
46 }
47 #[doc = "I/O analog switch control register."]
48 #[inline(always)]
49 pub const fn ioascr(self) -> crate::common::Reg<regs::Ioascr, crate::common::RW> {
50 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x18usize) as _) }
51 }
52 #[doc = "I/O sampling control register."]
53 #[inline(always)]
54 pub const fn ioscr(self) -> crate::common::Reg<regs::Ioscr, crate::common::RW> {
55 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x20usize) as _) }
56 }
57 #[doc = "I/O channel control register."]
58 #[inline(always)]
59 pub const fn ioccr(self) -> crate::common::Reg<regs::Ioccr, crate::common::RW> {
60 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x28usize) as _) }
61 }
62 #[doc = "I/O group control status register."]
63 #[inline(always)]
64 pub const fn iogcsr(self) -> crate::common::Reg<regs::Iogcsr, crate::common::RW> {
65 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x30usize) as _) }
66 }
67 #[doc = "I/O group x counter register."]
68 #[inline(always)]
69 pub const fn iogcr(self, n: usize) -> crate::common::Reg<regs::Iogcr, crate::common::R> {
70 assert!(n < 8usize);
71 unsafe { crate::common::Reg::from_ptr(self.ptr.add(0x34usize + n * 4usize) as _) }
72 }
73}
74pub mod regs {
75 #[doc = "control register."]
76 #[repr(transparent)]
77 #[derive(Copy, Clone, Eq, PartialEq)]
78 pub struct Cr(pub u32);
79 impl Cr {
80 #[doc = "Touch sensing controller enable."]
81 #[inline(always)]
82 pub const fn tsce(&self) -> bool {
83 let val = (self.0 >> 0usize) & 0x01;
84 val != 0
85 }
86 #[doc = "Touch sensing controller enable."]
87 #[inline(always)]
88 pub fn set_tsce(&mut self, val: bool) {
89 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
90 }
91 #[doc = "Start a new acquisition."]
92 #[inline(always)]
93 pub const fn start(&self) -> bool {
94 let val = (self.0 >> 1usize) & 0x01;
95 val != 0
96 }
97 #[doc = "Start a new acquisition."]
98 #[inline(always)]
99 pub fn set_start(&mut self, val: bool) {
100 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
101 }
102 #[doc = "Acquisition mode."]
103 #[inline(always)]
104 pub const fn am(&self) -> bool {
105 let val = (self.0 >> 2usize) & 0x01;
106 val != 0
107 }
108 #[doc = "Acquisition mode."]
109 #[inline(always)]
110 pub fn set_am(&mut self, val: bool) {
111 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
112 }
113 #[doc = "Synchronization pin polarity."]
114 #[inline(always)]
115 pub const fn syncpol(&self) -> bool {
116 let val = (self.0 >> 3usize) & 0x01;
117 val != 0
118 }
119 #[doc = "Synchronization pin polarity."]
120 #[inline(always)]
121 pub fn set_syncpol(&mut self, val: bool) {
122 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
123 }
124 #[doc = "I/O Default mode."]
125 #[inline(always)]
126 pub const fn iodef(&self) -> bool {
127 let val = (self.0 >> 4usize) & 0x01;
128 val != 0
129 }
130 #[doc = "I/O Default mode."]
131 #[inline(always)]
132 pub fn set_iodef(&mut self, val: bool) {
133 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
134 }
135 #[doc = "Max count value."]
136 #[inline(always)]
137 pub const fn mcv(&self) -> u8 {
138 let val = (self.0 >> 5usize) & 0x07;
139 val as u8
140 }
141 #[doc = "Max count value."]
142 #[inline(always)]
143 pub fn set_mcv(&mut self, val: u8) {
144 self.0 = (self.0 & !(0x07 << 5usize)) | (((val as u32) & 0x07) << 5usize);
145 }
146 #[doc = "pulse generator prescaler."]
147 #[inline(always)]
148 pub const fn pgpsc(&self) -> u8 {
149 let val = (self.0 >> 12usize) & 0x07;
150 val as u8
151 }
152 #[doc = "pulse generator prescaler."]
153 #[inline(always)]
154 pub fn set_pgpsc(&mut self, val: u8) {
155 self.0 = (self.0 & !(0x07 << 12usize)) | (((val as u32) & 0x07) << 12usize);
156 }
157 #[doc = "Spread spectrum prescaler."]
158 #[inline(always)]
159 pub const fn sspsc(&self) -> bool {
160 let val = (self.0 >> 15usize) & 0x01;
161 val != 0
162 }
163 #[doc = "Spread spectrum prescaler."]
164 #[inline(always)]
165 pub fn set_sspsc(&mut self, val: bool) {
166 self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
167 }
168 #[doc = "Spread spectrum enable."]
169 #[inline(always)]
170 pub const fn sse(&self) -> bool {
171 let val = (self.0 >> 16usize) & 0x01;
172 val != 0
173 }
174 #[doc = "Spread spectrum enable."]
175 #[inline(always)]
176 pub fn set_sse(&mut self, val: bool) {
177 self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
178 }
179 #[doc = "Spread spectrum deviation."]
180 #[inline(always)]
181 pub const fn ssd(&self) -> u8 {
182 let val = (self.0 >> 17usize) & 0x7f;
183 val as u8
184 }
185 #[doc = "Spread spectrum deviation."]
186 #[inline(always)]
187 pub fn set_ssd(&mut self, val: u8) {
188 self.0 = (self.0 & !(0x7f << 17usize)) | (((val as u32) & 0x7f) << 17usize);
189 }
190 #[doc = "Charge transfer pulse low."]
191 #[inline(always)]
192 pub const fn ctpl(&self) -> u8 {
193 let val = (self.0 >> 24usize) & 0x0f;
194 val as u8
195 }
196 #[doc = "Charge transfer pulse low."]
197 #[inline(always)]
198 pub fn set_ctpl(&mut self, val: u8) {
199 self.0 = (self.0 & !(0x0f << 24usize)) | (((val as u32) & 0x0f) << 24usize);
200 }
201 #[doc = "Charge transfer pulse high."]
202 #[inline(always)]
203 pub const fn ctph(&self) -> u8 {
204 let val = (self.0 >> 28usize) & 0x0f;
205 val as u8
206 }
207 #[doc = "Charge transfer pulse high."]
208 #[inline(always)]
209 pub fn set_ctph(&mut self, val: u8) {
210 self.0 = (self.0 & !(0x0f << 28usize)) | (((val as u32) & 0x0f) << 28usize);
211 }
212 }
213 impl Default for Cr {
214 #[inline(always)]
215 fn default() -> Cr {
216 Cr(0)
217 }
218 }
219 impl core::fmt::Debug for Cr {
220 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
221 f.debug_struct("Cr")
222 .field("tsce", &self.tsce())
223 .field("start", &self.start())
224 .field("am", &self.am())
225 .field("syncpol", &self.syncpol())
226 .field("iodef", &self.iodef())
227 .field("mcv", &self.mcv())
228 .field("pgpsc", &self.pgpsc())
229 .field("sspsc", &self.sspsc())
230 .field("sse", &self.sse())
231 .field("ssd", &self.ssd())
232 .field("ctpl", &self.ctpl())
233 .field("ctph", &self.ctph())
234 .finish()
235 }
236 }
237 #[cfg(feature = "defmt")]
238 impl defmt::Format for Cr {
239 fn format(&self, f: defmt::Formatter) {
240 #[derive(defmt :: Format)]
241 struct Cr {
242 tsce: bool,
243 start: bool,
244 am: bool,
245 syncpol: bool,
246 iodef: bool,
247 mcv: u8,
248 pgpsc: u8,
249 sspsc: bool,
250 sse: bool,
251 ssd: u8,
252 ctpl: u8,
253 ctph: u8,
254 }
255 let proxy = Cr {
256 tsce: self.tsce(),
257 start: self.start(),
258 am: self.am(),
259 syncpol: self.syncpol(),
260 iodef: self.iodef(),
261 mcv: self.mcv(),
262 pgpsc: self.pgpsc(),
263 sspsc: self.sspsc(),
264 sse: self.sse(),
265 ssd: self.ssd(),
266 ctpl: self.ctpl(),
267 ctph: self.ctph(),
268 };
269 defmt::write!(f, "{}", proxy)
270 }
271 }
272 #[doc = "interrupt clear register."]
273 #[repr(transparent)]
274 #[derive(Copy, Clone, Eq, PartialEq)]
275 pub struct Icr(pub u32);
276 impl Icr {
277 #[doc = "End of acquisition interrupt clear."]
278 #[inline(always)]
279 pub const fn eoaic(&self) -> bool {
280 let val = (self.0 >> 0usize) & 0x01;
281 val != 0
282 }
283 #[doc = "End of acquisition interrupt clear."]
284 #[inline(always)]
285 pub fn set_eoaic(&mut self, val: bool) {
286 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
287 }
288 #[doc = "Max count error interrupt clear."]
289 #[inline(always)]
290 pub const fn mceic(&self) -> bool {
291 let val = (self.0 >> 1usize) & 0x01;
292 val != 0
293 }
294 #[doc = "Max count error interrupt clear."]
295 #[inline(always)]
296 pub fn set_mceic(&mut self, val: bool) {
297 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
298 }
299 }
300 impl Default for Icr {
301 #[inline(always)]
302 fn default() -> Icr {
303 Icr(0)
304 }
305 }
306 impl core::fmt::Debug for Icr {
307 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
308 f.debug_struct("Icr")
309 .field("eoaic", &self.eoaic())
310 .field("mceic", &self.mceic())
311 .finish()
312 }
313 }
314 #[cfg(feature = "defmt")]
315 impl defmt::Format for Icr {
316 fn format(&self, f: defmt::Formatter) {
317 #[derive(defmt :: Format)]
318 struct Icr {
319 eoaic: bool,
320 mceic: bool,
321 }
322 let proxy = Icr {
323 eoaic: self.eoaic(),
324 mceic: self.mceic(),
325 };
326 defmt::write!(f, "{}", proxy)
327 }
328 }
329 #[doc = "interrupt enable register."]
330 #[repr(transparent)]
331 #[derive(Copy, Clone, Eq, PartialEq)]
332 pub struct Ier(pub u32);
333 impl Ier {
334 #[doc = "End of acquisition interrupt enable."]
335 #[inline(always)]
336 pub const fn eoaie(&self) -> bool {
337 let val = (self.0 >> 0usize) & 0x01;
338 val != 0
339 }
340 #[doc = "End of acquisition interrupt enable."]
341 #[inline(always)]
342 pub fn set_eoaie(&mut self, val: bool) {
343 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
344 }
345 #[doc = "Max count error interrupt enable."]
346 #[inline(always)]
347 pub const fn mceie(&self) -> bool {
348 let val = (self.0 >> 1usize) & 0x01;
349 val != 0
350 }
351 #[doc = "Max count error interrupt enable."]
352 #[inline(always)]
353 pub fn set_mceie(&mut self, val: bool) {
354 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
355 }
356 }
357 impl Default for Ier {
358 #[inline(always)]
359 fn default() -> Ier {
360 Ier(0)
361 }
362 }
363 impl core::fmt::Debug for Ier {
364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
365 f.debug_struct("Ier")
366 .field("eoaie", &self.eoaie())
367 .field("mceie", &self.mceie())
368 .finish()
369 }
370 }
371 #[cfg(feature = "defmt")]
372 impl defmt::Format for Ier {
373 fn format(&self, f: defmt::Formatter) {
374 #[derive(defmt :: Format)]
375 struct Ier {
376 eoaie: bool,
377 mceie: bool,
378 }
379 let proxy = Ier {
380 eoaie: self.eoaie(),
381 mceie: self.mceie(),
382 };
383 defmt::write!(f, "{}", proxy)
384 }
385 }
386 #[doc = "I/O analog switch control register."]
387 #[repr(transparent)]
388 #[derive(Copy, Clone, Eq, PartialEq)]
389 pub struct Ioascr(pub u32);
390 impl Ioascr {
391 #[doc = "G1_IO1 analog switch enable."]
392 #[inline(always)]
393 pub const fn g1_io1(&self) -> bool {
394 let val = (self.0 >> 0usize) & 0x01;
395 val != 0
396 }
397 #[doc = "G1_IO1 analog switch enable."]
398 #[inline(always)]
399 pub fn set_g1_io1(&mut self, val: bool) {
400 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
401 }
402 #[doc = "G1_IO2 analog switch enable."]
403 #[inline(always)]
404 pub const fn g1_io2(&self) -> bool {
405 let val = (self.0 >> 1usize) & 0x01;
406 val != 0
407 }
408 #[doc = "G1_IO2 analog switch enable."]
409 #[inline(always)]
410 pub fn set_g1_io2(&mut self, val: bool) {
411 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
412 }
413 #[doc = "G1_IO3 analog switch enable."]
414 #[inline(always)]
415 pub const fn g1_io3(&self) -> bool {
416 let val = (self.0 >> 2usize) & 0x01;
417 val != 0
418 }
419 #[doc = "G1_IO3 analog switch enable."]
420 #[inline(always)]
421 pub fn set_g1_io3(&mut self, val: bool) {
422 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
423 }
424 #[doc = "G1_IO4 analog switch enable."]
425 #[inline(always)]
426 pub const fn g1_io4(&self) -> bool {
427 let val = (self.0 >> 3usize) & 0x01;
428 val != 0
429 }
430 #[doc = "G1_IO4 analog switch enable."]
431 #[inline(always)]
432 pub fn set_g1_io4(&mut self, val: bool) {
433 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
434 }
435 #[doc = "G2_IO1 analog switch enable."]
436 #[inline(always)]
437 pub const fn g2_io1(&self) -> bool {
438 let val = (self.0 >> 4usize) & 0x01;
439 val != 0
440 }
441 #[doc = "G2_IO1 analog switch enable."]
442 #[inline(always)]
443 pub fn set_g2_io1(&mut self, val: bool) {
444 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
445 }
446 #[doc = "G2_IO2 analog switch enable."]
447 #[inline(always)]
448 pub const fn g2_io2(&self) -> bool {
449 let val = (self.0 >> 5usize) & 0x01;
450 val != 0
451 }
452 #[doc = "G2_IO2 analog switch enable."]
453 #[inline(always)]
454 pub fn set_g2_io2(&mut self, val: bool) {
455 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
456 }
457 #[doc = "G2_IO3 analog switch enable."]
458 #[inline(always)]
459 pub const fn g2_io3(&self) -> bool {
460 let val = (self.0 >> 6usize) & 0x01;
461 val != 0
462 }
463 #[doc = "G2_IO3 analog switch enable."]
464 #[inline(always)]
465 pub fn set_g2_io3(&mut self, val: bool) {
466 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
467 }
468 #[doc = "G2_IO4 analog switch enable."]
469 #[inline(always)]
470 pub const fn g2_io4(&self) -> bool {
471 let val = (self.0 >> 7usize) & 0x01;
472 val != 0
473 }
474 #[doc = "G2_IO4 analog switch enable."]
475 #[inline(always)]
476 pub fn set_g2_io4(&mut self, val: bool) {
477 self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
478 }
479 #[doc = "G3_IO1 analog switch enable."]
480 #[inline(always)]
481 pub const fn g3_io1(&self) -> bool {
482 let val = (self.0 >> 8usize) & 0x01;
483 val != 0
484 }
485 #[doc = "G3_IO1 analog switch enable."]
486 #[inline(always)]
487 pub fn set_g3_io1(&mut self, val: bool) {
488 self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
489 }
490 #[doc = "G3_IO2 analog switch enable."]
491 #[inline(always)]
492 pub const fn g3_io2(&self) -> bool {
493 let val = (self.0 >> 9usize) & 0x01;
494 val != 0
495 }
496 #[doc = "G3_IO2 analog switch enable."]
497 #[inline(always)]
498 pub fn set_g3_io2(&mut self, val: bool) {
499 self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
500 }
501 #[doc = "G3_IO3 analog switch enable."]
502 #[inline(always)]
503 pub const fn g3_io3(&self) -> bool {
504 let val = (self.0 >> 10usize) & 0x01;
505 val != 0
506 }
507 #[doc = "G3_IO3 analog switch enable."]
508 #[inline(always)]
509 pub fn set_g3_io3(&mut self, val: bool) {
510 self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
511 }
512 #[doc = "G3_IO4 analog switch enable."]
513 #[inline(always)]
514 pub const fn g3_io4(&self) -> bool {
515 let val = (self.0 >> 11usize) & 0x01;
516 val != 0
517 }
518 #[doc = "G3_IO4 analog switch enable."]
519 #[inline(always)]
520 pub fn set_g3_io4(&mut self, val: bool) {
521 self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
522 }
523 #[doc = "G4_IO1 analog switch enable."]
524 #[inline(always)]
525 pub const fn g4_io1(&self) -> bool {
526 let val = (self.0 >> 12usize) & 0x01;
527 val != 0
528 }
529 #[doc = "G4_IO1 analog switch enable."]
530 #[inline(always)]
531 pub fn set_g4_io1(&mut self, val: bool) {
532 self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
533 }
534 #[doc = "G4_IO2 analog switch enable."]
535 #[inline(always)]
536 pub const fn g4_io2(&self) -> bool {
537 let val = (self.0 >> 13usize) & 0x01;
538 val != 0
539 }
540 #[doc = "G4_IO2 analog switch enable."]
541 #[inline(always)]
542 pub fn set_g4_io2(&mut self, val: bool) {
543 self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
544 }
545 #[doc = "G4_IO3 analog switch enable."]
546 #[inline(always)]
547 pub const fn g4_io3(&self) -> bool {
548 let val = (self.0 >> 14usize) & 0x01;
549 val != 0
550 }
551 #[doc = "G4_IO3 analog switch enable."]
552 #[inline(always)]
553 pub fn set_g4_io3(&mut self, val: bool) {
554 self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
555 }
556 #[doc = "G4_IO4 analog switch enable."]
557 #[inline(always)]
558 pub const fn g4_io4(&self) -> bool {
559 let val = (self.0 >> 15usize) & 0x01;
560 val != 0
561 }
562 #[doc = "G4_IO4 analog switch enable."]
563 #[inline(always)]
564 pub fn set_g4_io4(&mut self, val: bool) {
565 self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
566 }
567 #[doc = "G5_IO1 analog switch enable."]
568 #[inline(always)]
569 pub const fn g5_io1(&self) -> bool {
570 let val = (self.0 >> 16usize) & 0x01;
571 val != 0
572 }
573 #[doc = "G5_IO1 analog switch enable."]
574 #[inline(always)]
575 pub fn set_g5_io1(&mut self, val: bool) {
576 self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
577 }
578 #[doc = "G5_IO2 analog switch enable."]
579 #[inline(always)]
580 pub const fn g5_io2(&self) -> bool {
581 let val = (self.0 >> 17usize) & 0x01;
582 val != 0
583 }
584 #[doc = "G5_IO2 analog switch enable."]
585 #[inline(always)]
586 pub fn set_g5_io2(&mut self, val: bool) {
587 self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
588 }
589 #[doc = "G5_IO3 analog switch enable."]
590 #[inline(always)]
591 pub const fn g5_io3(&self) -> bool {
592 let val = (self.0 >> 18usize) & 0x01;
593 val != 0
594 }
595 #[doc = "G5_IO3 analog switch enable."]
596 #[inline(always)]
597 pub fn set_g5_io3(&mut self, val: bool) {
598 self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
599 }
600 #[doc = "G5_IO4 analog switch enable."]
601 #[inline(always)]
602 pub const fn g5_io4(&self) -> bool {
603 let val = (self.0 >> 19usize) & 0x01;
604 val != 0
605 }
606 #[doc = "G5_IO4 analog switch enable."]
607 #[inline(always)]
608 pub fn set_g5_io4(&mut self, val: bool) {
609 self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
610 }
611 #[doc = "G6_IO1 analog switch enable."]
612 #[inline(always)]
613 pub const fn g6_io1(&self) -> bool {
614 let val = (self.0 >> 20usize) & 0x01;
615 val != 0
616 }
617 #[doc = "G6_IO1 analog switch enable."]
618 #[inline(always)]
619 pub fn set_g6_io1(&mut self, val: bool) {
620 self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
621 }
622 #[doc = "G6_IO2 analog switch enable."]
623 #[inline(always)]
624 pub const fn g6_io2(&self) -> bool {
625 let val = (self.0 >> 21usize) & 0x01;
626 val != 0
627 }
628 #[doc = "G6_IO2 analog switch enable."]
629 #[inline(always)]
630 pub fn set_g6_io2(&mut self, val: bool) {
631 self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
632 }
633 #[doc = "G6_IO3 analog switch enable."]
634 #[inline(always)]
635 pub const fn g6_io3(&self) -> bool {
636 let val = (self.0 >> 22usize) & 0x01;
637 val != 0
638 }
639 #[doc = "G6_IO3 analog switch enable."]
640 #[inline(always)]
641 pub fn set_g6_io3(&mut self, val: bool) {
642 self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
643 }
644 #[doc = "G6_IO4 analog switch enable."]
645 #[inline(always)]
646 pub const fn g6_io4(&self) -> bool {
647 let val = (self.0 >> 23usize) & 0x01;
648 val != 0
649 }
650 #[doc = "G6_IO4 analog switch enable."]
651 #[inline(always)]
652 pub fn set_g6_io4(&mut self, val: bool) {
653 self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
654 }
655 #[doc = "G7_IO1 analog switch enable."]
656 #[inline(always)]
657 pub const fn g7_io1(&self) -> bool {
658 let val = (self.0 >> 24usize) & 0x01;
659 val != 0
660 }
661 #[doc = "G7_IO1 analog switch enable."]
662 #[inline(always)]
663 pub fn set_g7_io1(&mut self, val: bool) {
664 self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
665 }
666 #[doc = "G7_IO2 analog switch enable."]
667 #[inline(always)]
668 pub const fn g7_io2(&self) -> bool {
669 let val = (self.0 >> 25usize) & 0x01;
670 val != 0
671 }
672 #[doc = "G7_IO2 analog switch enable."]
673 #[inline(always)]
674 pub fn set_g7_io2(&mut self, val: bool) {
675 self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
676 }
677 #[doc = "G7_IO3 analog switch enable."]
678 #[inline(always)]
679 pub const fn g7_io3(&self) -> bool {
680 let val = (self.0 >> 26usize) & 0x01;
681 val != 0
682 }
683 #[doc = "G7_IO3 analog switch enable."]
684 #[inline(always)]
685 pub fn set_g7_io3(&mut self, val: bool) {
686 self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
687 }
688 #[doc = "G7_IO4 analog switch enable."]
689 #[inline(always)]
690 pub const fn g7_io4(&self) -> bool {
691 let val = (self.0 >> 27usize) & 0x01;
692 val != 0
693 }
694 #[doc = "G7_IO4 analog switch enable."]
695 #[inline(always)]
696 pub fn set_g7_io4(&mut self, val: bool) {
697 self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
698 }
699 #[doc = "G8_IO1 analog switch enable."]
700 #[inline(always)]
701 pub const fn g8_io1(&self) -> bool {
702 let val = (self.0 >> 28usize) & 0x01;
703 val != 0
704 }
705 #[doc = "G8_IO1 analog switch enable."]
706 #[inline(always)]
707 pub fn set_g8_io1(&mut self, val: bool) {
708 self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
709 }
710 #[doc = "G8_IO2 analog switch enable."]
711 #[inline(always)]
712 pub const fn g8_io2(&self) -> bool {
713 let val = (self.0 >> 29usize) & 0x01;
714 val != 0
715 }
716 #[doc = "G8_IO2 analog switch enable."]
717 #[inline(always)]
718 pub fn set_g8_io2(&mut self, val: bool) {
719 self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
720 }
721 #[doc = "G8_IO3 analog switch enable."]
722 #[inline(always)]
723 pub const fn g8_io3(&self) -> bool {
724 let val = (self.0 >> 30usize) & 0x01;
725 val != 0
726 }
727 #[doc = "G8_IO3 analog switch enable."]
728 #[inline(always)]
729 pub fn set_g8_io3(&mut self, val: bool) {
730 self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
731 }
732 #[doc = "G8_IO4 analog switch enable."]
733 #[inline(always)]
734 pub const fn g8_io4(&self) -> bool {
735 let val = (self.0 >> 31usize) & 0x01;
736 val != 0
737 }
738 #[doc = "G8_IO4 analog switch enable."]
739 #[inline(always)]
740 pub fn set_g8_io4(&mut self, val: bool) {
741 self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
742 }
743 }
744 impl Default for Ioascr {
745 #[inline(always)]
746 fn default() -> Ioascr {
747 Ioascr(0)
748 }
749 }
750 impl core::fmt::Debug for Ioascr {
751 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
752 f.debug_struct("Ioascr")
753 .field("g1_io1", &self.g1_io1())
754 .field("g1_io2", &self.g1_io2())
755 .field("g1_io3", &self.g1_io3())
756 .field("g1_io4", &self.g1_io4())
757 .field("g2_io1", &self.g2_io1())
758 .field("g2_io2", &self.g2_io2())
759 .field("g2_io3", &self.g2_io3())
760 .field("g2_io4", &self.g2_io4())
761 .field("g3_io1", &self.g3_io1())
762 .field("g3_io2", &self.g3_io2())
763 .field("g3_io3", &self.g3_io3())
764 .field("g3_io4", &self.g3_io4())
765 .field("g4_io1", &self.g4_io1())
766 .field("g4_io2", &self.g4_io2())
767 .field("g4_io3", &self.g4_io3())
768 .field("g4_io4", &self.g4_io4())
769 .field("g5_io1", &self.g5_io1())
770 .field("g5_io2", &self.g5_io2())
771 .field("g5_io3", &self.g5_io3())
772 .field("g5_io4", &self.g5_io4())
773 .field("g6_io1", &self.g6_io1())
774 .field("g6_io2", &self.g6_io2())
775 .field("g6_io3", &self.g6_io3())
776 .field("g6_io4", &self.g6_io4())
777 .field("g7_io1", &self.g7_io1())
778 .field("g7_io2", &self.g7_io2())
779 .field("g7_io3", &self.g7_io3())
780 .field("g7_io4", &self.g7_io4())
781 .field("g8_io1", &self.g8_io1())
782 .field("g8_io2", &self.g8_io2())
783 .field("g8_io3", &self.g8_io3())
784 .field("g8_io4", &self.g8_io4())
785 .finish()
786 }
787 }
788 #[cfg(feature = "defmt")]
789 impl defmt::Format for Ioascr {
790 fn format(&self, f: defmt::Formatter) {
791 #[derive(defmt :: Format)]
792 struct Ioascr {
793 g1_io1: bool,
794 g1_io2: bool,
795 g1_io3: bool,
796 g1_io4: bool,
797 g2_io1: bool,
798 g2_io2: bool,
799 g2_io3: bool,
800 g2_io4: bool,
801 g3_io1: bool,
802 g3_io2: bool,
803 g3_io3: bool,
804 g3_io4: bool,
805 g4_io1: bool,
806 g4_io2: bool,
807 g4_io3: bool,
808 g4_io4: bool,
809 g5_io1: bool,
810 g5_io2: bool,
811 g5_io3: bool,
812 g5_io4: bool,
813 g6_io1: bool,
814 g6_io2: bool,
815 g6_io3: bool,
816 g6_io4: bool,
817 g7_io1: bool,
818 g7_io2: bool,
819 g7_io3: bool,
820 g7_io4: bool,
821 g8_io1: bool,
822 g8_io2: bool,
823 g8_io3: bool,
824 g8_io4: bool,
825 }
826 let proxy = Ioascr {
827 g1_io1: self.g1_io1(),
828 g1_io2: self.g1_io2(),
829 g1_io3: self.g1_io3(),
830 g1_io4: self.g1_io4(),
831 g2_io1: self.g2_io1(),
832 g2_io2: self.g2_io2(),
833 g2_io3: self.g2_io3(),
834 g2_io4: self.g2_io4(),
835 g3_io1: self.g3_io1(),
836 g3_io2: self.g3_io2(),
837 g3_io3: self.g3_io3(),
838 g3_io4: self.g3_io4(),
839 g4_io1: self.g4_io1(),
840 g4_io2: self.g4_io2(),
841 g4_io3: self.g4_io3(),
842 g4_io4: self.g4_io4(),
843 g5_io1: self.g5_io1(),
844 g5_io2: self.g5_io2(),
845 g5_io3: self.g5_io3(),
846 g5_io4: self.g5_io4(),
847 g6_io1: self.g6_io1(),
848 g6_io2: self.g6_io2(),
849 g6_io3: self.g6_io3(),
850 g6_io4: self.g6_io4(),
851 g7_io1: self.g7_io1(),
852 g7_io2: self.g7_io2(),
853 g7_io3: self.g7_io3(),
854 g7_io4: self.g7_io4(),
855 g8_io1: self.g8_io1(),
856 g8_io2: self.g8_io2(),
857 g8_io3: self.g8_io3(),
858 g8_io4: self.g8_io4(),
859 };
860 defmt::write!(f, "{}", proxy)
861 }
862 }
863 #[doc = "I/O channel control register."]
864 #[repr(transparent)]
865 #[derive(Copy, Clone, Eq, PartialEq)]
866 pub struct Ioccr(pub u32);
867 impl Ioccr {
868 #[doc = "G1_IO1 channel mode."]
869 #[inline(always)]
870 pub const fn g1_io1(&self) -> bool {
871 let val = (self.0 >> 0usize) & 0x01;
872 val != 0
873 }
874 #[doc = "G1_IO1 channel mode."]
875 #[inline(always)]
876 pub fn set_g1_io1(&mut self, val: bool) {
877 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
878 }
879 #[doc = "G1_IO2 channel mode."]
880 #[inline(always)]
881 pub const fn g1_io2(&self) -> bool {
882 let val = (self.0 >> 1usize) & 0x01;
883 val != 0
884 }
885 #[doc = "G1_IO2 channel mode."]
886 #[inline(always)]
887 pub fn set_g1_io2(&mut self, val: bool) {
888 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
889 }
890 #[doc = "G1_IO3 channel mode."]
891 #[inline(always)]
892 pub const fn g1_io3(&self) -> bool {
893 let val = (self.0 >> 2usize) & 0x01;
894 val != 0
895 }
896 #[doc = "G1_IO3 channel mode."]
897 #[inline(always)]
898 pub fn set_g1_io3(&mut self, val: bool) {
899 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
900 }
901 #[doc = "G1_IO4 channel mode."]
902 #[inline(always)]
903 pub const fn g1_io4(&self) -> bool {
904 let val = (self.0 >> 3usize) & 0x01;
905 val != 0
906 }
907 #[doc = "G1_IO4 channel mode."]
908 #[inline(always)]
909 pub fn set_g1_io4(&mut self, val: bool) {
910 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
911 }
912 #[doc = "G2_IO1 channel mode."]
913 #[inline(always)]
914 pub const fn g2_io1(&self) -> bool {
915 let val = (self.0 >> 4usize) & 0x01;
916 val != 0
917 }
918 #[doc = "G2_IO1 channel mode."]
919 #[inline(always)]
920 pub fn set_g2_io1(&mut self, val: bool) {
921 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
922 }
923 #[doc = "G2_IO2 channel mode."]
924 #[inline(always)]
925 pub const fn g2_io2(&self) -> bool {
926 let val = (self.0 >> 5usize) & 0x01;
927 val != 0
928 }
929 #[doc = "G2_IO2 channel mode."]
930 #[inline(always)]
931 pub fn set_g2_io2(&mut self, val: bool) {
932 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
933 }
934 #[doc = "G2_IO3 channel mode."]
935 #[inline(always)]
936 pub const fn g2_io3(&self) -> bool {
937 let val = (self.0 >> 6usize) & 0x01;
938 val != 0
939 }
940 #[doc = "G2_IO3 channel mode."]
941 #[inline(always)]
942 pub fn set_g2_io3(&mut self, val: bool) {
943 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
944 }
945 #[doc = "G2_IO4 channel mode."]
946 #[inline(always)]
947 pub const fn g2_io4(&self) -> bool {
948 let val = (self.0 >> 7usize) & 0x01;
949 val != 0
950 }
951 #[doc = "G2_IO4 channel mode."]
952 #[inline(always)]
953 pub fn set_g2_io4(&mut self, val: bool) {
954 self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
955 }
956 #[doc = "G3_IO1 channel mode."]
957 #[inline(always)]
958 pub const fn g3_io1(&self) -> bool {
959 let val = (self.0 >> 8usize) & 0x01;
960 val != 0
961 }
962 #[doc = "G3_IO1 channel mode."]
963 #[inline(always)]
964 pub fn set_g3_io1(&mut self, val: bool) {
965 self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
966 }
967 #[doc = "G3_IO2 channel mode."]
968 #[inline(always)]
969 pub const fn g3_io2(&self) -> bool {
970 let val = (self.0 >> 9usize) & 0x01;
971 val != 0
972 }
973 #[doc = "G3_IO2 channel mode."]
974 #[inline(always)]
975 pub fn set_g3_io2(&mut self, val: bool) {
976 self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
977 }
978 #[doc = "G3_IO3 channel mode."]
979 #[inline(always)]
980 pub const fn g3_io3(&self) -> bool {
981 let val = (self.0 >> 10usize) & 0x01;
982 val != 0
983 }
984 #[doc = "G3_IO3 channel mode."]
985 #[inline(always)]
986 pub fn set_g3_io3(&mut self, val: bool) {
987 self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
988 }
989 #[doc = "G3_IO4 channel mode."]
990 #[inline(always)]
991 pub const fn g3_io4(&self) -> bool {
992 let val = (self.0 >> 11usize) & 0x01;
993 val != 0
994 }
995 #[doc = "G3_IO4 channel mode."]
996 #[inline(always)]
997 pub fn set_g3_io4(&mut self, val: bool) {
998 self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
999 }
1000 #[doc = "G4_IO1 channel mode."]
1001 #[inline(always)]
1002 pub const fn g4_io1(&self) -> bool {
1003 let val = (self.0 >> 12usize) & 0x01;
1004 val != 0
1005 }
1006 #[doc = "G4_IO1 channel mode."]
1007 #[inline(always)]
1008 pub fn set_g4_io1(&mut self, val: bool) {
1009 self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
1010 }
1011 #[doc = "G4_IO2 channel mode."]
1012 #[inline(always)]
1013 pub const fn g4_io2(&self) -> bool {
1014 let val = (self.0 >> 13usize) & 0x01;
1015 val != 0
1016 }
1017 #[doc = "G4_IO2 channel mode."]
1018 #[inline(always)]
1019 pub fn set_g4_io2(&mut self, val: bool) {
1020 self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
1021 }
1022 #[doc = "G4_IO3 channel mode."]
1023 #[inline(always)]
1024 pub const fn g4_io3(&self) -> bool {
1025 let val = (self.0 >> 14usize) & 0x01;
1026 val != 0
1027 }
1028 #[doc = "G4_IO3 channel mode."]
1029 #[inline(always)]
1030 pub fn set_g4_io3(&mut self, val: bool) {
1031 self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
1032 }
1033 #[doc = "G4_IO4 channel mode."]
1034 #[inline(always)]
1035 pub const fn g4_io4(&self) -> bool {
1036 let val = (self.0 >> 15usize) & 0x01;
1037 val != 0
1038 }
1039 #[doc = "G4_IO4 channel mode."]
1040 #[inline(always)]
1041 pub fn set_g4_io4(&mut self, val: bool) {
1042 self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
1043 }
1044 #[doc = "G5_IO1 channel mode."]
1045 #[inline(always)]
1046 pub const fn g5_io1(&self) -> bool {
1047 let val = (self.0 >> 16usize) & 0x01;
1048 val != 0
1049 }
1050 #[doc = "G5_IO1 channel mode."]
1051 #[inline(always)]
1052 pub fn set_g5_io1(&mut self, val: bool) {
1053 self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
1054 }
1055 #[doc = "G5_IO2 channel mode."]
1056 #[inline(always)]
1057 pub const fn g5_io2(&self) -> bool {
1058 let val = (self.0 >> 17usize) & 0x01;
1059 val != 0
1060 }
1061 #[doc = "G5_IO2 channel mode."]
1062 #[inline(always)]
1063 pub fn set_g5_io2(&mut self, val: bool) {
1064 self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
1065 }
1066 #[doc = "G5_IO3 channel mode."]
1067 #[inline(always)]
1068 pub const fn g5_io3(&self) -> bool {
1069 let val = (self.0 >> 18usize) & 0x01;
1070 val != 0
1071 }
1072 #[doc = "G5_IO3 channel mode."]
1073 #[inline(always)]
1074 pub fn set_g5_io3(&mut self, val: bool) {
1075 self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
1076 }
1077 #[doc = "G5_IO4 channel mode."]
1078 #[inline(always)]
1079 pub const fn g5_io4(&self) -> bool {
1080 let val = (self.0 >> 19usize) & 0x01;
1081 val != 0
1082 }
1083 #[doc = "G5_IO4 channel mode."]
1084 #[inline(always)]
1085 pub fn set_g5_io4(&mut self, val: bool) {
1086 self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
1087 }
1088 #[doc = "G6_IO1 channel mode."]
1089 #[inline(always)]
1090 pub const fn g6_io1(&self) -> bool {
1091 let val = (self.0 >> 20usize) & 0x01;
1092 val != 0
1093 }
1094 #[doc = "G6_IO1 channel mode."]
1095 #[inline(always)]
1096 pub fn set_g6_io1(&mut self, val: bool) {
1097 self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
1098 }
1099 #[doc = "G6_IO2 channel mode."]
1100 #[inline(always)]
1101 pub const fn g6_io2(&self) -> bool {
1102 let val = (self.0 >> 21usize) & 0x01;
1103 val != 0
1104 }
1105 #[doc = "G6_IO2 channel mode."]
1106 #[inline(always)]
1107 pub fn set_g6_io2(&mut self, val: bool) {
1108 self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
1109 }
1110 #[doc = "G6_IO3 channel mode."]
1111 #[inline(always)]
1112 pub const fn g6_io3(&self) -> bool {
1113 let val = (self.0 >> 22usize) & 0x01;
1114 val != 0
1115 }
1116 #[doc = "G6_IO3 channel mode."]
1117 #[inline(always)]
1118 pub fn set_g6_io3(&mut self, val: bool) {
1119 self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
1120 }
1121 #[doc = "G6_IO4 channel mode."]
1122 #[inline(always)]
1123 pub const fn g6_io4(&self) -> bool {
1124 let val = (self.0 >> 23usize) & 0x01;
1125 val != 0
1126 }
1127 #[doc = "G6_IO4 channel mode."]
1128 #[inline(always)]
1129 pub fn set_g6_io4(&mut self, val: bool) {
1130 self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
1131 }
1132 #[doc = "G7_IO1 channel mode."]
1133 #[inline(always)]
1134 pub const fn g7_io1(&self) -> bool {
1135 let val = (self.0 >> 24usize) & 0x01;
1136 val != 0
1137 }
1138 #[doc = "G7_IO1 channel mode."]
1139 #[inline(always)]
1140 pub fn set_g7_io1(&mut self, val: bool) {
1141 self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
1142 }
1143 #[doc = "G7_IO2 channel mode."]
1144 #[inline(always)]
1145 pub const fn g7_io2(&self) -> bool {
1146 let val = (self.0 >> 25usize) & 0x01;
1147 val != 0
1148 }
1149 #[doc = "G7_IO2 channel mode."]
1150 #[inline(always)]
1151 pub fn set_g7_io2(&mut self, val: bool) {
1152 self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
1153 }
1154 #[doc = "G7_IO3 channel mode."]
1155 #[inline(always)]
1156 pub const fn g7_io3(&self) -> bool {
1157 let val = (self.0 >> 26usize) & 0x01;
1158 val != 0
1159 }
1160 #[doc = "G7_IO3 channel mode."]
1161 #[inline(always)]
1162 pub fn set_g7_io3(&mut self, val: bool) {
1163 self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
1164 }
1165 #[doc = "G7_IO4 channel mode."]
1166 #[inline(always)]
1167 pub const fn g7_io4(&self) -> bool {
1168 let val = (self.0 >> 27usize) & 0x01;
1169 val != 0
1170 }
1171 #[doc = "G7_IO4 channel mode."]
1172 #[inline(always)]
1173 pub fn set_g7_io4(&mut self, val: bool) {
1174 self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
1175 }
1176 #[doc = "G8_IO1 channel mode."]
1177 #[inline(always)]
1178 pub const fn g8_io1(&self) -> bool {
1179 let val = (self.0 >> 28usize) & 0x01;
1180 val != 0
1181 }
1182 #[doc = "G8_IO1 channel mode."]
1183 #[inline(always)]
1184 pub fn set_g8_io1(&mut self, val: bool) {
1185 self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
1186 }
1187 #[doc = "G8_IO2 channel mode."]
1188 #[inline(always)]
1189 pub const fn g8_io2(&self) -> bool {
1190 let val = (self.0 >> 29usize) & 0x01;
1191 val != 0
1192 }
1193 #[doc = "G8_IO2 channel mode."]
1194 #[inline(always)]
1195 pub fn set_g8_io2(&mut self, val: bool) {
1196 self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
1197 }
1198 #[doc = "G8_IO3 channel mode."]
1199 #[inline(always)]
1200 pub const fn g8_io3(&self) -> bool {
1201 let val = (self.0 >> 30usize) & 0x01;
1202 val != 0
1203 }
1204 #[doc = "G8_IO3 channel mode."]
1205 #[inline(always)]
1206 pub fn set_g8_io3(&mut self, val: bool) {
1207 self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
1208 }
1209 #[doc = "G8_IO4 channel mode."]
1210 #[inline(always)]
1211 pub const fn g8_io4(&self) -> bool {
1212 let val = (self.0 >> 31usize) & 0x01;
1213 val != 0
1214 }
1215 #[doc = "G8_IO4 channel mode."]
1216 #[inline(always)]
1217 pub fn set_g8_io4(&mut self, val: bool) {
1218 self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
1219 }
1220 }
1221 impl Default for Ioccr {
1222 #[inline(always)]
1223 fn default() -> Ioccr {
1224 Ioccr(0)
1225 }
1226 }
1227 impl core::fmt::Debug for Ioccr {
1228 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1229 f.debug_struct("Ioccr")
1230 .field("g1_io1", &self.g1_io1())
1231 .field("g1_io2", &self.g1_io2())
1232 .field("g1_io3", &self.g1_io3())
1233 .field("g1_io4", &self.g1_io4())
1234 .field("g2_io1", &self.g2_io1())
1235 .field("g2_io2", &self.g2_io2())
1236 .field("g2_io3", &self.g2_io3())
1237 .field("g2_io4", &self.g2_io4())
1238 .field("g3_io1", &self.g3_io1())
1239 .field("g3_io2", &self.g3_io2())
1240 .field("g3_io3", &self.g3_io3())
1241 .field("g3_io4", &self.g3_io4())
1242 .field("g4_io1", &self.g4_io1())
1243 .field("g4_io2", &self.g4_io2())
1244 .field("g4_io3", &self.g4_io3())
1245 .field("g4_io4", &self.g4_io4())
1246 .field("g5_io1", &self.g5_io1())
1247 .field("g5_io2", &self.g5_io2())
1248 .field("g5_io3", &self.g5_io3())
1249 .field("g5_io4", &self.g5_io4())
1250 .field("g6_io1", &self.g6_io1())
1251 .field("g6_io2", &self.g6_io2())
1252 .field("g6_io3", &self.g6_io3())
1253 .field("g6_io4", &self.g6_io4())
1254 .field("g7_io1", &self.g7_io1())
1255 .field("g7_io2", &self.g7_io2())
1256 .field("g7_io3", &self.g7_io3())
1257 .field("g7_io4", &self.g7_io4())
1258 .field("g8_io1", &self.g8_io1())
1259 .field("g8_io2", &self.g8_io2())
1260 .field("g8_io3", &self.g8_io3())
1261 .field("g8_io4", &self.g8_io4())
1262 .finish()
1263 }
1264 }
1265 #[cfg(feature = "defmt")]
1266 impl defmt::Format for Ioccr {
1267 fn format(&self, f: defmt::Formatter) {
1268 #[derive(defmt :: Format)]
1269 struct Ioccr {
1270 g1_io1: bool,
1271 g1_io2: bool,
1272 g1_io3: bool,
1273 g1_io4: bool,
1274 g2_io1: bool,
1275 g2_io2: bool,
1276 g2_io3: bool,
1277 g2_io4: bool,
1278 g3_io1: bool,
1279 g3_io2: bool,
1280 g3_io3: bool,
1281 g3_io4: bool,
1282 g4_io1: bool,
1283 g4_io2: bool,
1284 g4_io3: bool,
1285 g4_io4: bool,
1286 g5_io1: bool,
1287 g5_io2: bool,
1288 g5_io3: bool,
1289 g5_io4: bool,
1290 g6_io1: bool,
1291 g6_io2: bool,
1292 g6_io3: bool,
1293 g6_io4: bool,
1294 g7_io1: bool,
1295 g7_io2: bool,
1296 g7_io3: bool,
1297 g7_io4: bool,
1298 g8_io1: bool,
1299 g8_io2: bool,
1300 g8_io3: bool,
1301 g8_io4: bool,
1302 }
1303 let proxy = Ioccr {
1304 g1_io1: self.g1_io1(),
1305 g1_io2: self.g1_io2(),
1306 g1_io3: self.g1_io3(),
1307 g1_io4: self.g1_io4(),
1308 g2_io1: self.g2_io1(),
1309 g2_io2: self.g2_io2(),
1310 g2_io3: self.g2_io3(),
1311 g2_io4: self.g2_io4(),
1312 g3_io1: self.g3_io1(),
1313 g3_io2: self.g3_io2(),
1314 g3_io3: self.g3_io3(),
1315 g3_io4: self.g3_io4(),
1316 g4_io1: self.g4_io1(),
1317 g4_io2: self.g4_io2(),
1318 g4_io3: self.g4_io3(),
1319 g4_io4: self.g4_io4(),
1320 g5_io1: self.g5_io1(),
1321 g5_io2: self.g5_io2(),
1322 g5_io3: self.g5_io3(),
1323 g5_io4: self.g5_io4(),
1324 g6_io1: self.g6_io1(),
1325 g6_io2: self.g6_io2(),
1326 g6_io3: self.g6_io3(),
1327 g6_io4: self.g6_io4(),
1328 g7_io1: self.g7_io1(),
1329 g7_io2: self.g7_io2(),
1330 g7_io3: self.g7_io3(),
1331 g7_io4: self.g7_io4(),
1332 g8_io1: self.g8_io1(),
1333 g8_io2: self.g8_io2(),
1334 g8_io3: self.g8_io3(),
1335 g8_io4: self.g8_io4(),
1336 };
1337 defmt::write!(f, "{}", proxy)
1338 }
1339 }
1340 #[doc = "I/O group x counter register."]
1341 #[repr(transparent)]
1342 #[derive(Copy, Clone, Eq, PartialEq)]
1343 pub struct Iogcr(pub u32);
1344 impl Iogcr {
1345 #[doc = "Counter value."]
1346 #[inline(always)]
1347 pub const fn cnt(&self) -> u16 {
1348 let val = (self.0 >> 0usize) & 0x3fff;
1349 val as u16
1350 }
1351 #[doc = "Counter value."]
1352 #[inline(always)]
1353 pub fn set_cnt(&mut self, val: u16) {
1354 self.0 = (self.0 & !(0x3fff << 0usize)) | (((val as u32) & 0x3fff) << 0usize);
1355 }
1356 }
1357 impl Default for Iogcr {
1358 #[inline(always)]
1359 fn default() -> Iogcr {
1360 Iogcr(0)
1361 }
1362 }
1363 impl core::fmt::Debug for Iogcr {
1364 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1365 f.debug_struct("Iogcr").field("cnt", &self.cnt()).finish()
1366 }
1367 }
1368 #[cfg(feature = "defmt")]
1369 impl defmt::Format for Iogcr {
1370 fn format(&self, f: defmt::Formatter) {
1371 #[derive(defmt :: Format)]
1372 struct Iogcr {
1373 cnt: u16,
1374 }
1375 let proxy = Iogcr { cnt: self.cnt() };
1376 defmt::write!(f, "{}", proxy)
1377 }
1378 }
1379 #[doc = "I/O group control status register."]
1380 #[repr(transparent)]
1381 #[derive(Copy, Clone, Eq, PartialEq)]
1382 pub struct Iogcsr(pub u32);
1383 impl Iogcsr {
1384 #[doc = "Analog I/O group x enable."]
1385 #[inline(always)]
1386 pub const fn g1e(&self) -> bool {
1387 let val = (self.0 >> 0usize) & 0x01;
1388 val != 0
1389 }
1390 #[doc = "Analog I/O group x enable."]
1391 #[inline(always)]
1392 pub fn set_g1e(&mut self, val: bool) {
1393 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
1394 }
1395 #[doc = "Analog I/O group x enable."]
1396 #[inline(always)]
1397 pub const fn g2e(&self) -> bool {
1398 let val = (self.0 >> 1usize) & 0x01;
1399 val != 0
1400 }
1401 #[doc = "Analog I/O group x enable."]
1402 #[inline(always)]
1403 pub fn set_g2e(&mut self, val: bool) {
1404 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
1405 }
1406 #[doc = "Analog I/O group x enable."]
1407 #[inline(always)]
1408 pub const fn g3e(&self) -> bool {
1409 let val = (self.0 >> 2usize) & 0x01;
1410 val != 0
1411 }
1412 #[doc = "Analog I/O group x enable."]
1413 #[inline(always)]
1414 pub fn set_g3e(&mut self, val: bool) {
1415 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
1416 }
1417 #[doc = "Analog I/O group x enable."]
1418 #[inline(always)]
1419 pub const fn g4e(&self) -> bool {
1420 let val = (self.0 >> 3usize) & 0x01;
1421 val != 0
1422 }
1423 #[doc = "Analog I/O group x enable."]
1424 #[inline(always)]
1425 pub fn set_g4e(&mut self, val: bool) {
1426 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
1427 }
1428 #[doc = "Analog I/O group x enable."]
1429 #[inline(always)]
1430 pub const fn g5e(&self) -> bool {
1431 let val = (self.0 >> 4usize) & 0x01;
1432 val != 0
1433 }
1434 #[doc = "Analog I/O group x enable."]
1435 #[inline(always)]
1436 pub fn set_g5e(&mut self, val: bool) {
1437 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
1438 }
1439 #[doc = "Analog I/O group x enable."]
1440 #[inline(always)]
1441 pub const fn g6e(&self) -> bool {
1442 let val = (self.0 >> 5usize) & 0x01;
1443 val != 0
1444 }
1445 #[doc = "Analog I/O group x enable."]
1446 #[inline(always)]
1447 pub fn set_g6e(&mut self, val: bool) {
1448 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
1449 }
1450 #[doc = "Analog I/O group x enable."]
1451 #[inline(always)]
1452 pub const fn g7e(&self) -> bool {
1453 let val = (self.0 >> 6usize) & 0x01;
1454 val != 0
1455 }
1456 #[doc = "Analog I/O group x enable."]
1457 #[inline(always)]
1458 pub fn set_g7e(&mut self, val: bool) {
1459 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
1460 }
1461 #[doc = "Analog I/O group x enable."]
1462 #[inline(always)]
1463 pub const fn g8e(&self) -> bool {
1464 let val = (self.0 >> 7usize) & 0x01;
1465 val != 0
1466 }
1467 #[doc = "Analog I/O group x enable."]
1468 #[inline(always)]
1469 pub fn set_g8e(&mut self, val: bool) {
1470 self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
1471 }
1472 #[doc = "Analog I/O group x status."]
1473 #[inline(always)]
1474 pub const fn g1s(&self) -> bool {
1475 let val = (self.0 >> 16usize) & 0x01;
1476 val != 0
1477 }
1478 #[doc = "Analog I/O group x status."]
1479 #[inline(always)]
1480 pub fn set_g1s(&mut self, val: bool) {
1481 self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
1482 }
1483 #[doc = "Analog I/O group x status."]
1484 #[inline(always)]
1485 pub const fn g2s(&self) -> bool {
1486 let val = (self.0 >> 17usize) & 0x01;
1487 val != 0
1488 }
1489 #[doc = "Analog I/O group x status."]
1490 #[inline(always)]
1491 pub fn set_g2s(&mut self, val: bool) {
1492 self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
1493 }
1494 #[doc = "Analog I/O group x status."]
1495 #[inline(always)]
1496 pub const fn g3s(&self) -> bool {
1497 let val = (self.0 >> 18usize) & 0x01;
1498 val != 0
1499 }
1500 #[doc = "Analog I/O group x status."]
1501 #[inline(always)]
1502 pub fn set_g3s(&mut self, val: bool) {
1503 self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
1504 }
1505 #[doc = "Analog I/O group x status."]
1506 #[inline(always)]
1507 pub const fn g4s(&self) -> bool {
1508 let val = (self.0 >> 19usize) & 0x01;
1509 val != 0
1510 }
1511 #[doc = "Analog I/O group x status."]
1512 #[inline(always)]
1513 pub fn set_g4s(&mut self, val: bool) {
1514 self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
1515 }
1516 #[doc = "Analog I/O group x status."]
1517 #[inline(always)]
1518 pub const fn g5s(&self) -> bool {
1519 let val = (self.0 >> 20usize) & 0x01;
1520 val != 0
1521 }
1522 #[doc = "Analog I/O group x status."]
1523 #[inline(always)]
1524 pub fn set_g5s(&mut self, val: bool) {
1525 self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
1526 }
1527 #[doc = "Analog I/O group x status."]
1528 #[inline(always)]
1529 pub const fn g6s(&self) -> bool {
1530 let val = (self.0 >> 21usize) & 0x01;
1531 val != 0
1532 }
1533 #[doc = "Analog I/O group x status."]
1534 #[inline(always)]
1535 pub fn set_g6s(&mut self, val: bool) {
1536 self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
1537 }
1538 #[doc = "Analog I/O group x status."]
1539 #[inline(always)]
1540 pub const fn g7s(&self) -> bool {
1541 let val = (self.0 >> 22usize) & 0x01;
1542 val != 0
1543 }
1544 #[doc = "Analog I/O group x status."]
1545 #[inline(always)]
1546 pub fn set_g7s(&mut self, val: bool) {
1547 self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
1548 }
1549 #[doc = "Analog I/O group x status."]
1550 #[inline(always)]
1551 pub const fn g8s(&self) -> bool {
1552 let val = (self.0 >> 23usize) & 0x01;
1553 val != 0
1554 }
1555 #[doc = "Analog I/O group x status."]
1556 #[inline(always)]
1557 pub fn set_g8s(&mut self, val: bool) {
1558 self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
1559 }
1560 }
1561 impl Default for Iogcsr {
1562 #[inline(always)]
1563 fn default() -> Iogcsr {
1564 Iogcsr(0)
1565 }
1566 }
1567 impl core::fmt::Debug for Iogcsr {
1568 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1569 f.debug_struct("Iogcsr")
1570 .field("g1e", &self.g1e())
1571 .field("g2e", &self.g2e())
1572 .field("g3e", &self.g3e())
1573 .field("g4e", &self.g4e())
1574 .field("g5e", &self.g5e())
1575 .field("g6e", &self.g6e())
1576 .field("g7e", &self.g7e())
1577 .field("g8e", &self.g8e())
1578 .field("g1s", &self.g1s())
1579 .field("g2s", &self.g2s())
1580 .field("g3s", &self.g3s())
1581 .field("g4s", &self.g4s())
1582 .field("g5s", &self.g5s())
1583 .field("g6s", &self.g6s())
1584 .field("g7s", &self.g7s())
1585 .field("g8s", &self.g8s())
1586 .finish()
1587 }
1588 }
1589 #[cfg(feature = "defmt")]
1590 impl defmt::Format for Iogcsr {
1591 fn format(&self, f: defmt::Formatter) {
1592 #[derive(defmt :: Format)]
1593 struct Iogcsr {
1594 g1e: bool,
1595 g2e: bool,
1596 g3e: bool,
1597 g4e: bool,
1598 g5e: bool,
1599 g6e: bool,
1600 g7e: bool,
1601 g8e: bool,
1602 g1s: bool,
1603 g2s: bool,
1604 g3s: bool,
1605 g4s: bool,
1606 g5s: bool,
1607 g6s: bool,
1608 g7s: bool,
1609 g8s: bool,
1610 }
1611 let proxy = Iogcsr {
1612 g1e: self.g1e(),
1613 g2e: self.g2e(),
1614 g3e: self.g3e(),
1615 g4e: self.g4e(),
1616 g5e: self.g5e(),
1617 g6e: self.g6e(),
1618 g7e: self.g7e(),
1619 g8e: self.g8e(),
1620 g1s: self.g1s(),
1621 g2s: self.g2s(),
1622 g3s: self.g3s(),
1623 g4s: self.g4s(),
1624 g5s: self.g5s(),
1625 g6s: self.g6s(),
1626 g7s: self.g7s(),
1627 g8s: self.g8s(),
1628 };
1629 defmt::write!(f, "{}", proxy)
1630 }
1631 }
1632 #[doc = "I/O hysteresis control register."]
1633 #[repr(transparent)]
1634 #[derive(Copy, Clone, Eq, PartialEq)]
1635 pub struct Iohcr(pub u32);
1636 impl Iohcr {
1637 #[doc = "G1_IO1 Schmitt trigger hysteresis mode."]
1638 #[inline(always)]
1639 pub const fn g1_io1(&self) -> bool {
1640 let val = (self.0 >> 0usize) & 0x01;
1641 val != 0
1642 }
1643 #[doc = "G1_IO1 Schmitt trigger hysteresis mode."]
1644 #[inline(always)]
1645 pub fn set_g1_io1(&mut self, val: bool) {
1646 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
1647 }
1648 #[doc = "G1_IO2 Schmitt trigger hysteresis mode."]
1649 #[inline(always)]
1650 pub const fn g1_io2(&self) -> bool {
1651 let val = (self.0 >> 1usize) & 0x01;
1652 val != 0
1653 }
1654 #[doc = "G1_IO2 Schmitt trigger hysteresis mode."]
1655 #[inline(always)]
1656 pub fn set_g1_io2(&mut self, val: bool) {
1657 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
1658 }
1659 #[doc = "G1_IO3 Schmitt trigger hysteresis mode."]
1660 #[inline(always)]
1661 pub const fn g1_io3(&self) -> bool {
1662 let val = (self.0 >> 2usize) & 0x01;
1663 val != 0
1664 }
1665 #[doc = "G1_IO3 Schmitt trigger hysteresis mode."]
1666 #[inline(always)]
1667 pub fn set_g1_io3(&mut self, val: bool) {
1668 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
1669 }
1670 #[doc = "G1_IO4 Schmitt trigger hysteresis mode."]
1671 #[inline(always)]
1672 pub const fn g1_io4(&self) -> bool {
1673 let val = (self.0 >> 3usize) & 0x01;
1674 val != 0
1675 }
1676 #[doc = "G1_IO4 Schmitt trigger hysteresis mode."]
1677 #[inline(always)]
1678 pub fn set_g1_io4(&mut self, val: bool) {
1679 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
1680 }
1681 #[doc = "G2_IO1 Schmitt trigger hysteresis mode."]
1682 #[inline(always)]
1683 pub const fn g2_io1(&self) -> bool {
1684 let val = (self.0 >> 4usize) & 0x01;
1685 val != 0
1686 }
1687 #[doc = "G2_IO1 Schmitt trigger hysteresis mode."]
1688 #[inline(always)]
1689 pub fn set_g2_io1(&mut self, val: bool) {
1690 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
1691 }
1692 #[doc = "G2_IO2 Schmitt trigger hysteresis mode."]
1693 #[inline(always)]
1694 pub const fn g2_io2(&self) -> bool {
1695 let val = (self.0 >> 5usize) & 0x01;
1696 val != 0
1697 }
1698 #[doc = "G2_IO2 Schmitt trigger hysteresis mode."]
1699 #[inline(always)]
1700 pub fn set_g2_io2(&mut self, val: bool) {
1701 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
1702 }
1703 #[doc = "G2_IO3 Schmitt trigger hysteresis mode."]
1704 #[inline(always)]
1705 pub const fn g2_io3(&self) -> bool {
1706 let val = (self.0 >> 6usize) & 0x01;
1707 val != 0
1708 }
1709 #[doc = "G2_IO3 Schmitt trigger hysteresis mode."]
1710 #[inline(always)]
1711 pub fn set_g2_io3(&mut self, val: bool) {
1712 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
1713 }
1714 #[doc = "G2_IO4 Schmitt trigger hysteresis mode."]
1715 #[inline(always)]
1716 pub const fn g2_io4(&self) -> bool {
1717 let val = (self.0 >> 7usize) & 0x01;
1718 val != 0
1719 }
1720 #[doc = "G2_IO4 Schmitt trigger hysteresis mode."]
1721 #[inline(always)]
1722 pub fn set_g2_io4(&mut self, val: bool) {
1723 self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
1724 }
1725 #[doc = "G3_IO1 Schmitt trigger hysteresis mode."]
1726 #[inline(always)]
1727 pub const fn g3_io1(&self) -> bool {
1728 let val = (self.0 >> 8usize) & 0x01;
1729 val != 0
1730 }
1731 #[doc = "G3_IO1 Schmitt trigger hysteresis mode."]
1732 #[inline(always)]
1733 pub fn set_g3_io1(&mut self, val: bool) {
1734 self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
1735 }
1736 #[doc = "G3_IO2 Schmitt trigger hysteresis mode."]
1737 #[inline(always)]
1738 pub const fn g3_io2(&self) -> bool {
1739 let val = (self.0 >> 9usize) & 0x01;
1740 val != 0
1741 }
1742 #[doc = "G3_IO2 Schmitt trigger hysteresis mode."]
1743 #[inline(always)]
1744 pub fn set_g3_io2(&mut self, val: bool) {
1745 self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
1746 }
1747 #[doc = "G3_IO3 Schmitt trigger hysteresis mode."]
1748 #[inline(always)]
1749 pub const fn g3_io3(&self) -> bool {
1750 let val = (self.0 >> 10usize) & 0x01;
1751 val != 0
1752 }
1753 #[doc = "G3_IO3 Schmitt trigger hysteresis mode."]
1754 #[inline(always)]
1755 pub fn set_g3_io3(&mut self, val: bool) {
1756 self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
1757 }
1758 #[doc = "G3_IO4 Schmitt trigger hysteresis mode."]
1759 #[inline(always)]
1760 pub const fn g3_io4(&self) -> bool {
1761 let val = (self.0 >> 11usize) & 0x01;
1762 val != 0
1763 }
1764 #[doc = "G3_IO4 Schmitt trigger hysteresis mode."]
1765 #[inline(always)]
1766 pub fn set_g3_io4(&mut self, val: bool) {
1767 self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
1768 }
1769 #[doc = "G4_IO1 Schmitt trigger hysteresis mode."]
1770 #[inline(always)]
1771 pub const fn g4_io1(&self) -> bool {
1772 let val = (self.0 >> 12usize) & 0x01;
1773 val != 0
1774 }
1775 #[doc = "G4_IO1 Schmitt trigger hysteresis mode."]
1776 #[inline(always)]
1777 pub fn set_g4_io1(&mut self, val: bool) {
1778 self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
1779 }
1780 #[doc = "G4_IO2 Schmitt trigger hysteresis mode."]
1781 #[inline(always)]
1782 pub const fn g4_io2(&self) -> bool {
1783 let val = (self.0 >> 13usize) & 0x01;
1784 val != 0
1785 }
1786 #[doc = "G4_IO2 Schmitt trigger hysteresis mode."]
1787 #[inline(always)]
1788 pub fn set_g4_io2(&mut self, val: bool) {
1789 self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
1790 }
1791 #[doc = "G4_IO3 Schmitt trigger hysteresis mode."]
1792 #[inline(always)]
1793 pub const fn g4_io3(&self) -> bool {
1794 let val = (self.0 >> 14usize) & 0x01;
1795 val != 0
1796 }
1797 #[doc = "G4_IO3 Schmitt trigger hysteresis mode."]
1798 #[inline(always)]
1799 pub fn set_g4_io3(&mut self, val: bool) {
1800 self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
1801 }
1802 #[doc = "G4_IO4 Schmitt trigger hysteresis mode."]
1803 #[inline(always)]
1804 pub const fn g4_io4(&self) -> bool {
1805 let val = (self.0 >> 15usize) & 0x01;
1806 val != 0
1807 }
1808 #[doc = "G4_IO4 Schmitt trigger hysteresis mode."]
1809 #[inline(always)]
1810 pub fn set_g4_io4(&mut self, val: bool) {
1811 self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
1812 }
1813 #[doc = "G5_IO1 Schmitt trigger hysteresis mode."]
1814 #[inline(always)]
1815 pub const fn g5_io1(&self) -> bool {
1816 let val = (self.0 >> 16usize) & 0x01;
1817 val != 0
1818 }
1819 #[doc = "G5_IO1 Schmitt trigger hysteresis mode."]
1820 #[inline(always)]
1821 pub fn set_g5_io1(&mut self, val: bool) {
1822 self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
1823 }
1824 #[doc = "G5_IO2 Schmitt trigger hysteresis mode."]
1825 #[inline(always)]
1826 pub const fn g5_io2(&self) -> bool {
1827 let val = (self.0 >> 17usize) & 0x01;
1828 val != 0
1829 }
1830 #[doc = "G5_IO2 Schmitt trigger hysteresis mode."]
1831 #[inline(always)]
1832 pub fn set_g5_io2(&mut self, val: bool) {
1833 self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
1834 }
1835 #[doc = "G5_IO3 Schmitt trigger hysteresis mode."]
1836 #[inline(always)]
1837 pub const fn g5_io3(&self) -> bool {
1838 let val = (self.0 >> 18usize) & 0x01;
1839 val != 0
1840 }
1841 #[doc = "G5_IO3 Schmitt trigger hysteresis mode."]
1842 #[inline(always)]
1843 pub fn set_g5_io3(&mut self, val: bool) {
1844 self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
1845 }
1846 #[doc = "G5_IO4 Schmitt trigger hysteresis mode."]
1847 #[inline(always)]
1848 pub const fn g5_io4(&self) -> bool {
1849 let val = (self.0 >> 19usize) & 0x01;
1850 val != 0
1851 }
1852 #[doc = "G5_IO4 Schmitt trigger hysteresis mode."]
1853 #[inline(always)]
1854 pub fn set_g5_io4(&mut self, val: bool) {
1855 self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
1856 }
1857 #[doc = "G6_IO1 Schmitt trigger hysteresis mode."]
1858 #[inline(always)]
1859 pub const fn g6_io1(&self) -> bool {
1860 let val = (self.0 >> 20usize) & 0x01;
1861 val != 0
1862 }
1863 #[doc = "G6_IO1 Schmitt trigger hysteresis mode."]
1864 #[inline(always)]
1865 pub fn set_g6_io1(&mut self, val: bool) {
1866 self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
1867 }
1868 #[doc = "G6_IO2 Schmitt trigger hysteresis mode."]
1869 #[inline(always)]
1870 pub const fn g6_io2(&self) -> bool {
1871 let val = (self.0 >> 21usize) & 0x01;
1872 val != 0
1873 }
1874 #[doc = "G6_IO2 Schmitt trigger hysteresis mode."]
1875 #[inline(always)]
1876 pub fn set_g6_io2(&mut self, val: bool) {
1877 self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
1878 }
1879 #[doc = "G6_IO3 Schmitt trigger hysteresis mode."]
1880 #[inline(always)]
1881 pub const fn g6_io3(&self) -> bool {
1882 let val = (self.0 >> 22usize) & 0x01;
1883 val != 0
1884 }
1885 #[doc = "G6_IO3 Schmitt trigger hysteresis mode."]
1886 #[inline(always)]
1887 pub fn set_g6_io3(&mut self, val: bool) {
1888 self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
1889 }
1890 #[doc = "G6_IO4 Schmitt trigger hysteresis mode."]
1891 #[inline(always)]
1892 pub const fn g6_io4(&self) -> bool {
1893 let val = (self.0 >> 23usize) & 0x01;
1894 val != 0
1895 }
1896 #[doc = "G6_IO4 Schmitt trigger hysteresis mode."]
1897 #[inline(always)]
1898 pub fn set_g6_io4(&mut self, val: bool) {
1899 self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
1900 }
1901 #[doc = "G7_IO1 Schmitt trigger hysteresis mode."]
1902 #[inline(always)]
1903 pub const fn g7_io1(&self) -> bool {
1904 let val = (self.0 >> 24usize) & 0x01;
1905 val != 0
1906 }
1907 #[doc = "G7_IO1 Schmitt trigger hysteresis mode."]
1908 #[inline(always)]
1909 pub fn set_g7_io1(&mut self, val: bool) {
1910 self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
1911 }
1912 #[doc = "G7_IO2 Schmitt trigger hysteresis mode."]
1913 #[inline(always)]
1914 pub const fn g7_io2(&self) -> bool {
1915 let val = (self.0 >> 25usize) & 0x01;
1916 val != 0
1917 }
1918 #[doc = "G7_IO2 Schmitt trigger hysteresis mode."]
1919 #[inline(always)]
1920 pub fn set_g7_io2(&mut self, val: bool) {
1921 self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
1922 }
1923 #[doc = "G7_IO3 Schmitt trigger hysteresis mode."]
1924 #[inline(always)]
1925 pub const fn g7_io3(&self) -> bool {
1926 let val = (self.0 >> 26usize) & 0x01;
1927 val != 0
1928 }
1929 #[doc = "G7_IO3 Schmitt trigger hysteresis mode."]
1930 #[inline(always)]
1931 pub fn set_g7_io3(&mut self, val: bool) {
1932 self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
1933 }
1934 #[doc = "G7_IO4 Schmitt trigger hysteresis mode."]
1935 #[inline(always)]
1936 pub const fn g7_io4(&self) -> bool {
1937 let val = (self.0 >> 27usize) & 0x01;
1938 val != 0
1939 }
1940 #[doc = "G7_IO4 Schmitt trigger hysteresis mode."]
1941 #[inline(always)]
1942 pub fn set_g7_io4(&mut self, val: bool) {
1943 self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
1944 }
1945 #[doc = "G8_IO1 Schmitt trigger hysteresis mode."]
1946 #[inline(always)]
1947 pub const fn g8_io1(&self) -> bool {
1948 let val = (self.0 >> 28usize) & 0x01;
1949 val != 0
1950 }
1951 #[doc = "G8_IO1 Schmitt trigger hysteresis mode."]
1952 #[inline(always)]
1953 pub fn set_g8_io1(&mut self, val: bool) {
1954 self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
1955 }
1956 #[doc = "G8_IO2 Schmitt trigger hysteresis mode."]
1957 #[inline(always)]
1958 pub const fn g8_io2(&self) -> bool {
1959 let val = (self.0 >> 29usize) & 0x01;
1960 val != 0
1961 }
1962 #[doc = "G8_IO2 Schmitt trigger hysteresis mode."]
1963 #[inline(always)]
1964 pub fn set_g8_io2(&mut self, val: bool) {
1965 self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
1966 }
1967 #[doc = "G8_IO3 Schmitt trigger hysteresis mode."]
1968 #[inline(always)]
1969 pub const fn g8_io3(&self) -> bool {
1970 let val = (self.0 >> 30usize) & 0x01;
1971 val != 0
1972 }
1973 #[doc = "G8_IO3 Schmitt trigger hysteresis mode."]
1974 #[inline(always)]
1975 pub fn set_g8_io3(&mut self, val: bool) {
1976 self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
1977 }
1978 #[doc = "G8_IO4 Schmitt trigger hysteresis mode."]
1979 #[inline(always)]
1980 pub const fn g8_io4(&self) -> bool {
1981 let val = (self.0 >> 31usize) & 0x01;
1982 val != 0
1983 }
1984 #[doc = "G8_IO4 Schmitt trigger hysteresis mode."]
1985 #[inline(always)]
1986 pub fn set_g8_io4(&mut self, val: bool) {
1987 self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
1988 }
1989 }
1990 impl Default for Iohcr {
1991 #[inline(always)]
1992 fn default() -> Iohcr {
1993 Iohcr(0)
1994 }
1995 }
1996 impl core::fmt::Debug for Iohcr {
1997 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1998 f.debug_struct("Iohcr")
1999 .field("g1_io1", &self.g1_io1())
2000 .field("g1_io2", &self.g1_io2())
2001 .field("g1_io3", &self.g1_io3())
2002 .field("g1_io4", &self.g1_io4())
2003 .field("g2_io1", &self.g2_io1())
2004 .field("g2_io2", &self.g2_io2())
2005 .field("g2_io3", &self.g2_io3())
2006 .field("g2_io4", &self.g2_io4())
2007 .field("g3_io1", &self.g3_io1())
2008 .field("g3_io2", &self.g3_io2())
2009 .field("g3_io3", &self.g3_io3())
2010 .field("g3_io4", &self.g3_io4())
2011 .field("g4_io1", &self.g4_io1())
2012 .field("g4_io2", &self.g4_io2())
2013 .field("g4_io3", &self.g4_io3())
2014 .field("g4_io4", &self.g4_io4())
2015 .field("g5_io1", &self.g5_io1())
2016 .field("g5_io2", &self.g5_io2())
2017 .field("g5_io3", &self.g5_io3())
2018 .field("g5_io4", &self.g5_io4())
2019 .field("g6_io1", &self.g6_io1())
2020 .field("g6_io2", &self.g6_io2())
2021 .field("g6_io3", &self.g6_io3())
2022 .field("g6_io4", &self.g6_io4())
2023 .field("g7_io1", &self.g7_io1())
2024 .field("g7_io2", &self.g7_io2())
2025 .field("g7_io3", &self.g7_io3())
2026 .field("g7_io4", &self.g7_io4())
2027 .field("g8_io1", &self.g8_io1())
2028 .field("g8_io2", &self.g8_io2())
2029 .field("g8_io3", &self.g8_io3())
2030 .field("g8_io4", &self.g8_io4())
2031 .finish()
2032 }
2033 }
2034 #[cfg(feature = "defmt")]
2035 impl defmt::Format for Iohcr {
2036 fn format(&self, f: defmt::Formatter) {
2037 #[derive(defmt :: Format)]
2038 struct Iohcr {
2039 g1_io1: bool,
2040 g1_io2: bool,
2041 g1_io3: bool,
2042 g1_io4: bool,
2043 g2_io1: bool,
2044 g2_io2: bool,
2045 g2_io3: bool,
2046 g2_io4: bool,
2047 g3_io1: bool,
2048 g3_io2: bool,
2049 g3_io3: bool,
2050 g3_io4: bool,
2051 g4_io1: bool,
2052 g4_io2: bool,
2053 g4_io3: bool,
2054 g4_io4: bool,
2055 g5_io1: bool,
2056 g5_io2: bool,
2057 g5_io3: bool,
2058 g5_io4: bool,
2059 g6_io1: bool,
2060 g6_io2: bool,
2061 g6_io3: bool,
2062 g6_io4: bool,
2063 g7_io1: bool,
2064 g7_io2: bool,
2065 g7_io3: bool,
2066 g7_io4: bool,
2067 g8_io1: bool,
2068 g8_io2: bool,
2069 g8_io3: bool,
2070 g8_io4: bool,
2071 }
2072 let proxy = Iohcr {
2073 g1_io1: self.g1_io1(),
2074 g1_io2: self.g1_io2(),
2075 g1_io3: self.g1_io3(),
2076 g1_io4: self.g1_io4(),
2077 g2_io1: self.g2_io1(),
2078 g2_io2: self.g2_io2(),
2079 g2_io3: self.g2_io3(),
2080 g2_io4: self.g2_io4(),
2081 g3_io1: self.g3_io1(),
2082 g3_io2: self.g3_io2(),
2083 g3_io3: self.g3_io3(),
2084 g3_io4: self.g3_io4(),
2085 g4_io1: self.g4_io1(),
2086 g4_io2: self.g4_io2(),
2087 g4_io3: self.g4_io3(),
2088 g4_io4: self.g4_io4(),
2089 g5_io1: self.g5_io1(),
2090 g5_io2: self.g5_io2(),
2091 g5_io3: self.g5_io3(),
2092 g5_io4: self.g5_io4(),
2093 g6_io1: self.g6_io1(),
2094 g6_io2: self.g6_io2(),
2095 g6_io3: self.g6_io3(),
2096 g6_io4: self.g6_io4(),
2097 g7_io1: self.g7_io1(),
2098 g7_io2: self.g7_io2(),
2099 g7_io3: self.g7_io3(),
2100 g7_io4: self.g7_io4(),
2101 g8_io1: self.g8_io1(),
2102 g8_io2: self.g8_io2(),
2103 g8_io3: self.g8_io3(),
2104 g8_io4: self.g8_io4(),
2105 };
2106 defmt::write!(f, "{}", proxy)
2107 }
2108 }
2109 #[doc = "I/O sampling control register."]
2110 #[repr(transparent)]
2111 #[derive(Copy, Clone, Eq, PartialEq)]
2112 pub struct Ioscr(pub u32);
2113 impl Ioscr {
2114 #[doc = "G1_IO1 sampling mode."]
2115 #[inline(always)]
2116 pub const fn g1_io1(&self) -> bool {
2117 let val = (self.0 >> 0usize) & 0x01;
2118 val != 0
2119 }
2120 #[doc = "G1_IO1 sampling mode."]
2121 #[inline(always)]
2122 pub fn set_g1_io1(&mut self, val: bool) {
2123 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
2124 }
2125 #[doc = "G1_IO2 sampling mode."]
2126 #[inline(always)]
2127 pub const fn g1_io2(&self) -> bool {
2128 let val = (self.0 >> 1usize) & 0x01;
2129 val != 0
2130 }
2131 #[doc = "G1_IO2 sampling mode."]
2132 #[inline(always)]
2133 pub fn set_g1_io2(&mut self, val: bool) {
2134 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
2135 }
2136 #[doc = "G1_IO3 sampling mode."]
2137 #[inline(always)]
2138 pub const fn g1_io3(&self) -> bool {
2139 let val = (self.0 >> 2usize) & 0x01;
2140 val != 0
2141 }
2142 #[doc = "G1_IO3 sampling mode."]
2143 #[inline(always)]
2144 pub fn set_g1_io3(&mut self, val: bool) {
2145 self.0 = (self.0 & !(0x01 << 2usize)) | (((val as u32) & 0x01) << 2usize);
2146 }
2147 #[doc = "G1_IO4 sampling mode."]
2148 #[inline(always)]
2149 pub const fn g1_io4(&self) -> bool {
2150 let val = (self.0 >> 3usize) & 0x01;
2151 val != 0
2152 }
2153 #[doc = "G1_IO4 sampling mode."]
2154 #[inline(always)]
2155 pub fn set_g1_io4(&mut self, val: bool) {
2156 self.0 = (self.0 & !(0x01 << 3usize)) | (((val as u32) & 0x01) << 3usize);
2157 }
2158 #[doc = "G2_IO1 sampling mode."]
2159 #[inline(always)]
2160 pub const fn g2_io1(&self) -> bool {
2161 let val = (self.0 >> 4usize) & 0x01;
2162 val != 0
2163 }
2164 #[doc = "G2_IO1 sampling mode."]
2165 #[inline(always)]
2166 pub fn set_g2_io1(&mut self, val: bool) {
2167 self.0 = (self.0 & !(0x01 << 4usize)) | (((val as u32) & 0x01) << 4usize);
2168 }
2169 #[doc = "G2_IO2 sampling mode."]
2170 #[inline(always)]
2171 pub const fn g2_io2(&self) -> bool {
2172 let val = (self.0 >> 5usize) & 0x01;
2173 val != 0
2174 }
2175 #[doc = "G2_IO2 sampling mode."]
2176 #[inline(always)]
2177 pub fn set_g2_io2(&mut self, val: bool) {
2178 self.0 = (self.0 & !(0x01 << 5usize)) | (((val as u32) & 0x01) << 5usize);
2179 }
2180 #[doc = "G2_IO3 sampling mode."]
2181 #[inline(always)]
2182 pub const fn g2_io3(&self) -> bool {
2183 let val = (self.0 >> 6usize) & 0x01;
2184 val != 0
2185 }
2186 #[doc = "G2_IO3 sampling mode."]
2187 #[inline(always)]
2188 pub fn set_g2_io3(&mut self, val: bool) {
2189 self.0 = (self.0 & !(0x01 << 6usize)) | (((val as u32) & 0x01) << 6usize);
2190 }
2191 #[doc = "G2_IO4 sampling mode."]
2192 #[inline(always)]
2193 pub const fn g2_io4(&self) -> bool {
2194 let val = (self.0 >> 7usize) & 0x01;
2195 val != 0
2196 }
2197 #[doc = "G2_IO4 sampling mode."]
2198 #[inline(always)]
2199 pub fn set_g2_io4(&mut self, val: bool) {
2200 self.0 = (self.0 & !(0x01 << 7usize)) | (((val as u32) & 0x01) << 7usize);
2201 }
2202 #[doc = "G3_IO1 sampling mode."]
2203 #[inline(always)]
2204 pub const fn g3_io1(&self) -> bool {
2205 let val = (self.0 >> 8usize) & 0x01;
2206 val != 0
2207 }
2208 #[doc = "G3_IO1 sampling mode."]
2209 #[inline(always)]
2210 pub fn set_g3_io1(&mut self, val: bool) {
2211 self.0 = (self.0 & !(0x01 << 8usize)) | (((val as u32) & 0x01) << 8usize);
2212 }
2213 #[doc = "G3_IO2 sampling mode."]
2214 #[inline(always)]
2215 pub const fn g3_io2(&self) -> bool {
2216 let val = (self.0 >> 9usize) & 0x01;
2217 val != 0
2218 }
2219 #[doc = "G3_IO2 sampling mode."]
2220 #[inline(always)]
2221 pub fn set_g3_io2(&mut self, val: bool) {
2222 self.0 = (self.0 & !(0x01 << 9usize)) | (((val as u32) & 0x01) << 9usize);
2223 }
2224 #[doc = "G3_IO3 sampling mode."]
2225 #[inline(always)]
2226 pub const fn g3_io3(&self) -> bool {
2227 let val = (self.0 >> 10usize) & 0x01;
2228 val != 0
2229 }
2230 #[doc = "G3_IO3 sampling mode."]
2231 #[inline(always)]
2232 pub fn set_g3_io3(&mut self, val: bool) {
2233 self.0 = (self.0 & !(0x01 << 10usize)) | (((val as u32) & 0x01) << 10usize);
2234 }
2235 #[doc = "G3_IO4 sampling mode."]
2236 #[inline(always)]
2237 pub const fn g3_io4(&self) -> bool {
2238 let val = (self.0 >> 11usize) & 0x01;
2239 val != 0
2240 }
2241 #[doc = "G3_IO4 sampling mode."]
2242 #[inline(always)]
2243 pub fn set_g3_io4(&mut self, val: bool) {
2244 self.0 = (self.0 & !(0x01 << 11usize)) | (((val as u32) & 0x01) << 11usize);
2245 }
2246 #[doc = "G4_IO1 sampling mode."]
2247 #[inline(always)]
2248 pub const fn g4_io1(&self) -> bool {
2249 let val = (self.0 >> 12usize) & 0x01;
2250 val != 0
2251 }
2252 #[doc = "G4_IO1 sampling mode."]
2253 #[inline(always)]
2254 pub fn set_g4_io1(&mut self, val: bool) {
2255 self.0 = (self.0 & !(0x01 << 12usize)) | (((val as u32) & 0x01) << 12usize);
2256 }
2257 #[doc = "G4_IO2 sampling mode."]
2258 #[inline(always)]
2259 pub const fn g4_io2(&self) -> bool {
2260 let val = (self.0 >> 13usize) & 0x01;
2261 val != 0
2262 }
2263 #[doc = "G4_IO2 sampling mode."]
2264 #[inline(always)]
2265 pub fn set_g4_io2(&mut self, val: bool) {
2266 self.0 = (self.0 & !(0x01 << 13usize)) | (((val as u32) & 0x01) << 13usize);
2267 }
2268 #[doc = "G4_IO3 sampling mode."]
2269 #[inline(always)]
2270 pub const fn g4_io3(&self) -> bool {
2271 let val = (self.0 >> 14usize) & 0x01;
2272 val != 0
2273 }
2274 #[doc = "G4_IO3 sampling mode."]
2275 #[inline(always)]
2276 pub fn set_g4_io3(&mut self, val: bool) {
2277 self.0 = (self.0 & !(0x01 << 14usize)) | (((val as u32) & 0x01) << 14usize);
2278 }
2279 #[doc = "G4_IO4 sampling mode."]
2280 #[inline(always)]
2281 pub const fn g4_io4(&self) -> bool {
2282 let val = (self.0 >> 15usize) & 0x01;
2283 val != 0
2284 }
2285 #[doc = "G4_IO4 sampling mode."]
2286 #[inline(always)]
2287 pub fn set_g4_io4(&mut self, val: bool) {
2288 self.0 = (self.0 & !(0x01 << 15usize)) | (((val as u32) & 0x01) << 15usize);
2289 }
2290 #[doc = "G5_IO1 sampling mode."]
2291 #[inline(always)]
2292 pub const fn g5_io1(&self) -> bool {
2293 let val = (self.0 >> 16usize) & 0x01;
2294 val != 0
2295 }
2296 #[doc = "G5_IO1 sampling mode."]
2297 #[inline(always)]
2298 pub fn set_g5_io1(&mut self, val: bool) {
2299 self.0 = (self.0 & !(0x01 << 16usize)) | (((val as u32) & 0x01) << 16usize);
2300 }
2301 #[doc = "G5_IO2 sampling mode."]
2302 #[inline(always)]
2303 pub const fn g5_io2(&self) -> bool {
2304 let val = (self.0 >> 17usize) & 0x01;
2305 val != 0
2306 }
2307 #[doc = "G5_IO2 sampling mode."]
2308 #[inline(always)]
2309 pub fn set_g5_io2(&mut self, val: bool) {
2310 self.0 = (self.0 & !(0x01 << 17usize)) | (((val as u32) & 0x01) << 17usize);
2311 }
2312 #[doc = "G5_IO3 sampling mode."]
2313 #[inline(always)]
2314 pub const fn g5_io3(&self) -> bool {
2315 let val = (self.0 >> 18usize) & 0x01;
2316 val != 0
2317 }
2318 #[doc = "G5_IO3 sampling mode."]
2319 #[inline(always)]
2320 pub fn set_g5_io3(&mut self, val: bool) {
2321 self.0 = (self.0 & !(0x01 << 18usize)) | (((val as u32) & 0x01) << 18usize);
2322 }
2323 #[doc = "G5_IO4 sampling mode."]
2324 #[inline(always)]
2325 pub const fn g5_io4(&self) -> bool {
2326 let val = (self.0 >> 19usize) & 0x01;
2327 val != 0
2328 }
2329 #[doc = "G5_IO4 sampling mode."]
2330 #[inline(always)]
2331 pub fn set_g5_io4(&mut self, val: bool) {
2332 self.0 = (self.0 & !(0x01 << 19usize)) | (((val as u32) & 0x01) << 19usize);
2333 }
2334 #[doc = "G6_IO1 sampling mode."]
2335 #[inline(always)]
2336 pub const fn g6_io1(&self) -> bool {
2337 let val = (self.0 >> 20usize) & 0x01;
2338 val != 0
2339 }
2340 #[doc = "G6_IO1 sampling mode."]
2341 #[inline(always)]
2342 pub fn set_g6_io1(&mut self, val: bool) {
2343 self.0 = (self.0 & !(0x01 << 20usize)) | (((val as u32) & 0x01) << 20usize);
2344 }
2345 #[doc = "G6_IO2 sampling mode."]
2346 #[inline(always)]
2347 pub const fn g6_io2(&self) -> bool {
2348 let val = (self.0 >> 21usize) & 0x01;
2349 val != 0
2350 }
2351 #[doc = "G6_IO2 sampling mode."]
2352 #[inline(always)]
2353 pub fn set_g6_io2(&mut self, val: bool) {
2354 self.0 = (self.0 & !(0x01 << 21usize)) | (((val as u32) & 0x01) << 21usize);
2355 }
2356 #[doc = "G6_IO3 sampling mode."]
2357 #[inline(always)]
2358 pub const fn g6_io3(&self) -> bool {
2359 let val = (self.0 >> 22usize) & 0x01;
2360 val != 0
2361 }
2362 #[doc = "G6_IO3 sampling mode."]
2363 #[inline(always)]
2364 pub fn set_g6_io3(&mut self, val: bool) {
2365 self.0 = (self.0 & !(0x01 << 22usize)) | (((val as u32) & 0x01) << 22usize);
2366 }
2367 #[doc = "G6_IO4 sampling mode."]
2368 #[inline(always)]
2369 pub const fn g6_io4(&self) -> bool {
2370 let val = (self.0 >> 23usize) & 0x01;
2371 val != 0
2372 }
2373 #[doc = "G6_IO4 sampling mode."]
2374 #[inline(always)]
2375 pub fn set_g6_io4(&mut self, val: bool) {
2376 self.0 = (self.0 & !(0x01 << 23usize)) | (((val as u32) & 0x01) << 23usize);
2377 }
2378 #[doc = "G7_IO1 sampling mode."]
2379 #[inline(always)]
2380 pub const fn g7_io1(&self) -> bool {
2381 let val = (self.0 >> 24usize) & 0x01;
2382 val != 0
2383 }
2384 #[doc = "G7_IO1 sampling mode."]
2385 #[inline(always)]
2386 pub fn set_g7_io1(&mut self, val: bool) {
2387 self.0 = (self.0 & !(0x01 << 24usize)) | (((val as u32) & 0x01) << 24usize);
2388 }
2389 #[doc = "G7_IO2 sampling mode."]
2390 #[inline(always)]
2391 pub const fn g7_io2(&self) -> bool {
2392 let val = (self.0 >> 25usize) & 0x01;
2393 val != 0
2394 }
2395 #[doc = "G7_IO2 sampling mode."]
2396 #[inline(always)]
2397 pub fn set_g7_io2(&mut self, val: bool) {
2398 self.0 = (self.0 & !(0x01 << 25usize)) | (((val as u32) & 0x01) << 25usize);
2399 }
2400 #[doc = "G7_IO3 sampling mode."]
2401 #[inline(always)]
2402 pub const fn g7_io3(&self) -> bool {
2403 let val = (self.0 >> 26usize) & 0x01;
2404 val != 0
2405 }
2406 #[doc = "G7_IO3 sampling mode."]
2407 #[inline(always)]
2408 pub fn set_g7_io3(&mut self, val: bool) {
2409 self.0 = (self.0 & !(0x01 << 26usize)) | (((val as u32) & 0x01) << 26usize);
2410 }
2411 #[doc = "G7_IO4 sampling mode."]
2412 #[inline(always)]
2413 pub const fn g7_io4(&self) -> bool {
2414 let val = (self.0 >> 27usize) & 0x01;
2415 val != 0
2416 }
2417 #[doc = "G7_IO4 sampling mode."]
2418 #[inline(always)]
2419 pub fn set_g7_io4(&mut self, val: bool) {
2420 self.0 = (self.0 & !(0x01 << 27usize)) | (((val as u32) & 0x01) << 27usize);
2421 }
2422 #[doc = "G8_IO1 sampling mode."]
2423 #[inline(always)]
2424 pub const fn g8_io1(&self) -> bool {
2425 let val = (self.0 >> 28usize) & 0x01;
2426 val != 0
2427 }
2428 #[doc = "G8_IO1 sampling mode."]
2429 #[inline(always)]
2430 pub fn set_g8_io1(&mut self, val: bool) {
2431 self.0 = (self.0 & !(0x01 << 28usize)) | (((val as u32) & 0x01) << 28usize);
2432 }
2433 #[doc = "G8_IO2 sampling mode."]
2434 #[inline(always)]
2435 pub const fn g8_io2(&self) -> bool {
2436 let val = (self.0 >> 29usize) & 0x01;
2437 val != 0
2438 }
2439 #[doc = "G8_IO2 sampling mode."]
2440 #[inline(always)]
2441 pub fn set_g8_io2(&mut self, val: bool) {
2442 self.0 = (self.0 & !(0x01 << 29usize)) | (((val as u32) & 0x01) << 29usize);
2443 }
2444 #[doc = "G8_IO3 sampling mode."]
2445 #[inline(always)]
2446 pub const fn g8_io3(&self) -> bool {
2447 let val = (self.0 >> 30usize) & 0x01;
2448 val != 0
2449 }
2450 #[doc = "G8_IO3 sampling mode."]
2451 #[inline(always)]
2452 pub fn set_g8_io3(&mut self, val: bool) {
2453 self.0 = (self.0 & !(0x01 << 30usize)) | (((val as u32) & 0x01) << 30usize);
2454 }
2455 #[doc = "G8_IO4 sampling mode."]
2456 #[inline(always)]
2457 pub const fn g8_io4(&self) -> bool {
2458 let val = (self.0 >> 31usize) & 0x01;
2459 val != 0
2460 }
2461 #[doc = "G8_IO4 sampling mode."]
2462 #[inline(always)]
2463 pub fn set_g8_io4(&mut self, val: bool) {
2464 self.0 = (self.0 & !(0x01 << 31usize)) | (((val as u32) & 0x01) << 31usize);
2465 }
2466 }
2467 impl Default for Ioscr {
2468 #[inline(always)]
2469 fn default() -> Ioscr {
2470 Ioscr(0)
2471 }
2472 }
2473 impl core::fmt::Debug for Ioscr {
2474 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2475 f.debug_struct("Ioscr")
2476 .field("g1_io1", &self.g1_io1())
2477 .field("g1_io2", &self.g1_io2())
2478 .field("g1_io3", &self.g1_io3())
2479 .field("g1_io4", &self.g1_io4())
2480 .field("g2_io1", &self.g2_io1())
2481 .field("g2_io2", &self.g2_io2())
2482 .field("g2_io3", &self.g2_io3())
2483 .field("g2_io4", &self.g2_io4())
2484 .field("g3_io1", &self.g3_io1())
2485 .field("g3_io2", &self.g3_io2())
2486 .field("g3_io3", &self.g3_io3())
2487 .field("g3_io4", &self.g3_io4())
2488 .field("g4_io1", &self.g4_io1())
2489 .field("g4_io2", &self.g4_io2())
2490 .field("g4_io3", &self.g4_io3())
2491 .field("g4_io4", &self.g4_io4())
2492 .field("g5_io1", &self.g5_io1())
2493 .field("g5_io2", &self.g5_io2())
2494 .field("g5_io3", &self.g5_io3())
2495 .field("g5_io4", &self.g5_io4())
2496 .field("g6_io1", &self.g6_io1())
2497 .field("g6_io2", &self.g6_io2())
2498 .field("g6_io3", &self.g6_io3())
2499 .field("g6_io4", &self.g6_io4())
2500 .field("g7_io1", &self.g7_io1())
2501 .field("g7_io2", &self.g7_io2())
2502 .field("g7_io3", &self.g7_io3())
2503 .field("g7_io4", &self.g7_io4())
2504 .field("g8_io1", &self.g8_io1())
2505 .field("g8_io2", &self.g8_io2())
2506 .field("g8_io3", &self.g8_io3())
2507 .field("g8_io4", &self.g8_io4())
2508 .finish()
2509 }
2510 }
2511 #[cfg(feature = "defmt")]
2512 impl defmt::Format for Ioscr {
2513 fn format(&self, f: defmt::Formatter) {
2514 #[derive(defmt :: Format)]
2515 struct Ioscr {
2516 g1_io1: bool,
2517 g1_io2: bool,
2518 g1_io3: bool,
2519 g1_io4: bool,
2520 g2_io1: bool,
2521 g2_io2: bool,
2522 g2_io3: bool,
2523 g2_io4: bool,
2524 g3_io1: bool,
2525 g3_io2: bool,
2526 g3_io3: bool,
2527 g3_io4: bool,
2528 g4_io1: bool,
2529 g4_io2: bool,
2530 g4_io3: bool,
2531 g4_io4: bool,
2532 g5_io1: bool,
2533 g5_io2: bool,
2534 g5_io3: bool,
2535 g5_io4: bool,
2536 g6_io1: bool,
2537 g6_io2: bool,
2538 g6_io3: bool,
2539 g6_io4: bool,
2540 g7_io1: bool,
2541 g7_io2: bool,
2542 g7_io3: bool,
2543 g7_io4: bool,
2544 g8_io1: bool,
2545 g8_io2: bool,
2546 g8_io3: bool,
2547 g8_io4: bool,
2548 }
2549 let proxy = Ioscr {
2550 g1_io1: self.g1_io1(),
2551 g1_io2: self.g1_io2(),
2552 g1_io3: self.g1_io3(),
2553 g1_io4: self.g1_io4(),
2554 g2_io1: self.g2_io1(),
2555 g2_io2: self.g2_io2(),
2556 g2_io3: self.g2_io3(),
2557 g2_io4: self.g2_io4(),
2558 g3_io1: self.g3_io1(),
2559 g3_io2: self.g3_io2(),
2560 g3_io3: self.g3_io3(),
2561 g3_io4: self.g3_io4(),
2562 g4_io1: self.g4_io1(),
2563 g4_io2: self.g4_io2(),
2564 g4_io3: self.g4_io3(),
2565 g4_io4: self.g4_io4(),
2566 g5_io1: self.g5_io1(),
2567 g5_io2: self.g5_io2(),
2568 g5_io3: self.g5_io3(),
2569 g5_io4: self.g5_io4(),
2570 g6_io1: self.g6_io1(),
2571 g6_io2: self.g6_io2(),
2572 g6_io3: self.g6_io3(),
2573 g6_io4: self.g6_io4(),
2574 g7_io1: self.g7_io1(),
2575 g7_io2: self.g7_io2(),
2576 g7_io3: self.g7_io3(),
2577 g7_io4: self.g7_io4(),
2578 g8_io1: self.g8_io1(),
2579 g8_io2: self.g8_io2(),
2580 g8_io3: self.g8_io3(),
2581 g8_io4: self.g8_io4(),
2582 };
2583 defmt::write!(f, "{}", proxy)
2584 }
2585 }
2586 #[doc = "interrupt status register."]
2587 #[repr(transparent)]
2588 #[derive(Copy, Clone, Eq, PartialEq)]
2589 pub struct Isr(pub u32);
2590 impl Isr {
2591 #[doc = "End of acquisition flag."]
2592 #[inline(always)]
2593 pub const fn eoaf(&self) -> bool {
2594 let val = (self.0 >> 0usize) & 0x01;
2595 val != 0
2596 }
2597 #[doc = "End of acquisition flag."]
2598 #[inline(always)]
2599 pub fn set_eoaf(&mut self, val: bool) {
2600 self.0 = (self.0 & !(0x01 << 0usize)) | (((val as u32) & 0x01) << 0usize);
2601 }
2602 #[doc = "Max count error flag."]
2603 #[inline(always)]
2604 pub const fn mcef(&self) -> bool {
2605 let val = (self.0 >> 1usize) & 0x01;
2606 val != 0
2607 }
2608 #[doc = "Max count error flag."]
2609 #[inline(always)]
2610 pub fn set_mcef(&mut self, val: bool) {
2611 self.0 = (self.0 & !(0x01 << 1usize)) | (((val as u32) & 0x01) << 1usize);
2612 }
2613 }
2614 impl Default for Isr {
2615 #[inline(always)]
2616 fn default() -> Isr {
2617 Isr(0)
2618 }
2619 }
2620 impl core::fmt::Debug for Isr {
2621 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
2622 f.debug_struct("Isr")
2623 .field("eoaf", &self.eoaf())
2624 .field("mcef", &self.mcef())
2625 .finish()
2626 }
2627 }
2628 #[cfg(feature = "defmt")]
2629 impl defmt::Format for Isr {
2630 fn format(&self, f: defmt::Formatter) {
2631 #[derive(defmt :: Format)]
2632 struct Isr {
2633 eoaf: bool,
2634 mcef: bool,
2635 }
2636 let proxy = Isr {
2637 eoaf: self.eoaf(),
2638 mcef: self.mcef(),
2639 };
2640 defmt::write!(f, "{}", proxy)
2641 }
2642 }
2643}
2644