1#[doc = "Register `OUTINIT` reader"]
2pub struct R(crate::R<OUTINIT_SPEC>);
3impl core::ops::Deref for R {
4 type Target = crate::R<OUTINIT_SPEC>;
5 #[inline(always)]
6 fn deref(&self) -> &Self::Target {
7 &self.0
8 }
9}
10impl From<crate::R<OUTINIT_SPEC>> for R {
11 #[inline(always)]
12 fn from(reader: crate::R<OUTINIT_SPEC>) -> Self {
13 R(reader)
14 }
15}
16#[doc = "Register `OUTINIT` writer"]
17pub struct W(crate::W<OUTINIT_SPEC>);
18impl core::ops::Deref for W {
19 type Target = crate::W<OUTINIT_SPEC>;
20 #[inline(always)]
21 fn deref(&self) -> &Self::Target {
22 &self.0
23 }
24}
25impl core::ops::DerefMut for W {
26 #[inline(always)]
27 fn deref_mut(&mut self) -> &mut Self::Target {
28 &mut self.0
29 }
30}
31impl From<crate::W<OUTINIT_SPEC>> for W {
32 #[inline(always)]
33 fn from(writer: crate::W<OUTINIT_SPEC>) -> Self {
34 W(writer)
35 }
36}
37#[doc = "Channel 0 Output Initialization Value\n\nValue on reset: 0"]
38#[derive(Clone, Copy, Debug, PartialEq)]
39pub enum CH0OI_A {
40 #[doc = "0: The initialization value is 0."]
41 CH0OI_0 = 0,
42 #[doc = "1: The initialization value is 1."]
43 CH0OI_1 = 1,
44}
45impl From<CH0OI_A> for bool {
46 #[inline(always)]
47 fn from(variant: CH0OI_A) -> Self {
48 variant as u8 != 0
49 }
50}
51#[doc = "Field `CH0OI` reader - Channel 0 Output Initialization Value"]
52pub struct CH0OI_R(crate::FieldReader<bool, CH0OI_A>);
53impl CH0OI_R {
54 #[inline(always)]
55 pub(crate) fn new(bits: bool) -> Self {
56 CH0OI_R(crate::FieldReader::new(bits))
57 }
58 #[doc = r"Get enumerated values variant"]
59 #[inline(always)]
60 pub fn variant(&self) -> CH0OI_A {
61 match self.bits {
62 false => CH0OI_A::CH0OI_0,
63 true => CH0OI_A::CH0OI_1,
64 }
65 }
66 #[doc = "Checks if the value of the field is `CH0OI_0`"]
67 #[inline(always)]
68 pub fn is_ch0oi_0(&self) -> bool {
69 **self == CH0OI_A::CH0OI_0
70 }
71 #[doc = "Checks if the value of the field is `CH0OI_1`"]
72 #[inline(always)]
73 pub fn is_ch0oi_1(&self) -> bool {
74 **self == CH0OI_A::CH0OI_1
75 }
76}
77impl core::ops::Deref for CH0OI_R {
78 type Target = crate::FieldReader<bool, CH0OI_A>;
79 #[inline(always)]
80 fn deref(&self) -> &Self::Target {
81 &self.0
82 }
83}
84#[doc = "Field `CH0OI` writer - Channel 0 Output Initialization Value"]
85pub struct CH0OI_W<'a> {
86 w: &'a mut W,
87}
88impl<'a> CH0OI_W<'a> {
89 #[doc = r"Writes `variant` to the field"]
90 #[inline(always)]
91 pub fn variant(self, variant: CH0OI_A) -> &'a mut W {
92 self.bit(variant.into())
93 }
94 #[doc = "The initialization value is 0."]
95 #[inline(always)]
96 pub fn ch0oi_0(self) -> &'a mut W {
97 self.variant(CH0OI_A::CH0OI_0)
98 }
99 #[doc = "The initialization value is 1."]
100 #[inline(always)]
101 pub fn ch0oi_1(self) -> &'a mut W {
102 self.variant(CH0OI_A::CH0OI_1)
103 }
104 #[doc = r"Sets the field bit"]
105 #[inline(always)]
106 pub fn set_bit(self) -> &'a mut W {
107 self.bit(true)
108 }
109 #[doc = r"Clears the field bit"]
110 #[inline(always)]
111 pub fn clear_bit(self) -> &'a mut W {
112 self.bit(false)
113 }
114 #[doc = r"Writes raw bits to the field"]
115 #[inline(always)]
116 pub fn bit(self, value: bool) -> &'a mut W {
117 self.w.bits = (self.w.bits & !0x01) | (value as u32 & 0x01);
118 self.w
119 }
120}
121#[doc = "Channel 1 Output Initialization Value\n\nValue on reset: 0"]
122#[derive(Clone, Copy, Debug, PartialEq)]
123pub enum CH1OI_A {
124 #[doc = "0: The initialization value is 0."]
125 CH1OI_0 = 0,
126 #[doc = "1: The initialization value is 1."]
127 CH1OI_1 = 1,
128}
129impl From<CH1OI_A> for bool {
130 #[inline(always)]
131 fn from(variant: CH1OI_A) -> Self {
132 variant as u8 != 0
133 }
134}
135#[doc = "Field `CH1OI` reader - Channel 1 Output Initialization Value"]
136pub struct CH1OI_R(crate::FieldReader<bool, CH1OI_A>);
137impl CH1OI_R {
138 #[inline(always)]
139 pub(crate) fn new(bits: bool) -> Self {
140 CH1OI_R(crate::FieldReader::new(bits))
141 }
142 #[doc = r"Get enumerated values variant"]
143 #[inline(always)]
144 pub fn variant(&self) -> CH1OI_A {
145 match self.bits {
146 false => CH1OI_A::CH1OI_0,
147 true => CH1OI_A::CH1OI_1,
148 }
149 }
150 #[doc = "Checks if the value of the field is `CH1OI_0`"]
151 #[inline(always)]
152 pub fn is_ch1oi_0(&self) -> bool {
153 **self == CH1OI_A::CH1OI_0
154 }
155 #[doc = "Checks if the value of the field is `CH1OI_1`"]
156 #[inline(always)]
157 pub fn is_ch1oi_1(&self) -> bool {
158 **self == CH1OI_A::CH1OI_1
159 }
160}
161impl core::ops::Deref for CH1OI_R {
162 type Target = crate::FieldReader<bool, CH1OI_A>;
163 #[inline(always)]
164 fn deref(&self) -> &Self::Target {
165 &self.0
166 }
167}
168#[doc = "Field `CH1OI` writer - Channel 1 Output Initialization Value"]
169pub struct CH1OI_W<'a> {
170 w: &'a mut W,
171}
172impl<'a> CH1OI_W<'a> {
173 #[doc = r"Writes `variant` to the field"]
174 #[inline(always)]
175 pub fn variant(self, variant: CH1OI_A) -> &'a mut W {
176 self.bit(variant.into())
177 }
178 #[doc = "The initialization value is 0."]
179 #[inline(always)]
180 pub fn ch1oi_0(self) -> &'a mut W {
181 self.variant(CH1OI_A::CH1OI_0)
182 }
183 #[doc = "The initialization value is 1."]
184 #[inline(always)]
185 pub fn ch1oi_1(self) -> &'a mut W {
186 self.variant(CH1OI_A::CH1OI_1)
187 }
188 #[doc = r"Sets the field bit"]
189 #[inline(always)]
190 pub fn set_bit(self) -> &'a mut W {
191 self.bit(true)
192 }
193 #[doc = r"Clears the field bit"]
194 #[inline(always)]
195 pub fn clear_bit(self) -> &'a mut W {
196 self.bit(false)
197 }
198 #[doc = r"Writes raw bits to the field"]
199 #[inline(always)]
200 pub fn bit(self, value: bool) -> &'a mut W {
201 self.w.bits = (self.w.bits & !(0x01 << 1)) | ((value as u32 & 0x01) << 1);
202 self.w
203 }
204}
205#[doc = "Channel 2 Output Initialization Value\n\nValue on reset: 0"]
206#[derive(Clone, Copy, Debug, PartialEq)]
207pub enum CH2OI_A {
208 #[doc = "0: The initialization value is 0."]
209 CH2OI_0 = 0,
210 #[doc = "1: The initialization value is 1."]
211 CH2OI_1 = 1,
212}
213impl From<CH2OI_A> for bool {
214 #[inline(always)]
215 fn from(variant: CH2OI_A) -> Self {
216 variant as u8 != 0
217 }
218}
219#[doc = "Field `CH2OI` reader - Channel 2 Output Initialization Value"]
220pub struct CH2OI_R(crate::FieldReader<bool, CH2OI_A>);
221impl CH2OI_R {
222 #[inline(always)]
223 pub(crate) fn new(bits: bool) -> Self {
224 CH2OI_R(crate::FieldReader::new(bits))
225 }
226 #[doc = r"Get enumerated values variant"]
227 #[inline(always)]
228 pub fn variant(&self) -> CH2OI_A {
229 match self.bits {
230 false => CH2OI_A::CH2OI_0,
231 true => CH2OI_A::CH2OI_1,
232 }
233 }
234 #[doc = "Checks if the value of the field is `CH2OI_0`"]
235 #[inline(always)]
236 pub fn is_ch2oi_0(&self) -> bool {
237 **self == CH2OI_A::CH2OI_0
238 }
239 #[doc = "Checks if the value of the field is `CH2OI_1`"]
240 #[inline(always)]
241 pub fn is_ch2oi_1(&self) -> bool {
242 **self == CH2OI_A::CH2OI_1
243 }
244}
245impl core::ops::Deref for CH2OI_R {
246 type Target = crate::FieldReader<bool, CH2OI_A>;
247 #[inline(always)]
248 fn deref(&self) -> &Self::Target {
249 &self.0
250 }
251}
252#[doc = "Field `CH2OI` writer - Channel 2 Output Initialization Value"]
253pub struct CH2OI_W<'a> {
254 w: &'a mut W,
255}
256impl<'a> CH2OI_W<'a> {
257 #[doc = r"Writes `variant` to the field"]
258 #[inline(always)]
259 pub fn variant(self, variant: CH2OI_A) -> &'a mut W {
260 self.bit(variant.into())
261 }
262 #[doc = "The initialization value is 0."]
263 #[inline(always)]
264 pub fn ch2oi_0(self) -> &'a mut W {
265 self.variant(CH2OI_A::CH2OI_0)
266 }
267 #[doc = "The initialization value is 1."]
268 #[inline(always)]
269 pub fn ch2oi_1(self) -> &'a mut W {
270 self.variant(CH2OI_A::CH2OI_1)
271 }
272 #[doc = r"Sets the field bit"]
273 #[inline(always)]
274 pub fn set_bit(self) -> &'a mut W {
275 self.bit(true)
276 }
277 #[doc = r"Clears the field bit"]
278 #[inline(always)]
279 pub fn clear_bit(self) -> &'a mut W {
280 self.bit(false)
281 }
282 #[doc = r"Writes raw bits to the field"]
283 #[inline(always)]
284 pub fn bit(self, value: bool) -> &'a mut W {
285 self.w.bits = (self.w.bits & !(0x01 << 2)) | ((value as u32 & 0x01) << 2);
286 self.w
287 }
288}
289#[doc = "Channel 3 Output Initialization Value\n\nValue on reset: 0"]
290#[derive(Clone, Copy, Debug, PartialEq)]
291pub enum CH3OI_A {
292 #[doc = "0: The initialization value is 0."]
293 CH3OI_0 = 0,
294 #[doc = "1: The initialization value is 1."]
295 CH3OI_1 = 1,
296}
297impl From<CH3OI_A> for bool {
298 #[inline(always)]
299 fn from(variant: CH3OI_A) -> Self {
300 variant as u8 != 0
301 }
302}
303#[doc = "Field `CH3OI` reader - Channel 3 Output Initialization Value"]
304pub struct CH3OI_R(crate::FieldReader<bool, CH3OI_A>);
305impl CH3OI_R {
306 #[inline(always)]
307 pub(crate) fn new(bits: bool) -> Self {
308 CH3OI_R(crate::FieldReader::new(bits))
309 }
310 #[doc = r"Get enumerated values variant"]
311 #[inline(always)]
312 pub fn variant(&self) -> CH3OI_A {
313 match self.bits {
314 false => CH3OI_A::CH3OI_0,
315 true => CH3OI_A::CH3OI_1,
316 }
317 }
318 #[doc = "Checks if the value of the field is `CH3OI_0`"]
319 #[inline(always)]
320 pub fn is_ch3oi_0(&self) -> bool {
321 **self == CH3OI_A::CH3OI_0
322 }
323 #[doc = "Checks if the value of the field is `CH3OI_1`"]
324 #[inline(always)]
325 pub fn is_ch3oi_1(&self) -> bool {
326 **self == CH3OI_A::CH3OI_1
327 }
328}
329impl core::ops::Deref for CH3OI_R {
330 type Target = crate::FieldReader<bool, CH3OI_A>;
331 #[inline(always)]
332 fn deref(&self) -> &Self::Target {
333 &self.0
334 }
335}
336#[doc = "Field `CH3OI` writer - Channel 3 Output Initialization Value"]
337pub struct CH3OI_W<'a> {
338 w: &'a mut W,
339}
340impl<'a> CH3OI_W<'a> {
341 #[doc = r"Writes `variant` to the field"]
342 #[inline(always)]
343 pub fn variant(self, variant: CH3OI_A) -> &'a mut W {
344 self.bit(variant.into())
345 }
346 #[doc = "The initialization value is 0."]
347 #[inline(always)]
348 pub fn ch3oi_0(self) -> &'a mut W {
349 self.variant(CH3OI_A::CH3OI_0)
350 }
351 #[doc = "The initialization value is 1."]
352 #[inline(always)]
353 pub fn ch3oi_1(self) -> &'a mut W {
354 self.variant(CH3OI_A::CH3OI_1)
355 }
356 #[doc = r"Sets the field bit"]
357 #[inline(always)]
358 pub fn set_bit(self) -> &'a mut W {
359 self.bit(true)
360 }
361 #[doc = r"Clears the field bit"]
362 #[inline(always)]
363 pub fn clear_bit(self) -> &'a mut W {
364 self.bit(false)
365 }
366 #[doc = r"Writes raw bits to the field"]
367 #[inline(always)]
368 pub fn bit(self, value: bool) -> &'a mut W {
369 self.w.bits = (self.w.bits & !(0x01 << 3)) | ((value as u32 & 0x01) << 3);
370 self.w
371 }
372}
373#[doc = "Channel 4 Output Initialization Value\n\nValue on reset: 0"]
374#[derive(Clone, Copy, Debug, PartialEq)]
375pub enum CH4OI_A {
376 #[doc = "0: The initialization value is 0."]
377 CH4OI_0 = 0,
378 #[doc = "1: The initialization value is 1."]
379 CH4OI_1 = 1,
380}
381impl From<CH4OI_A> for bool {
382 #[inline(always)]
383 fn from(variant: CH4OI_A) -> Self {
384 variant as u8 != 0
385 }
386}
387#[doc = "Field `CH4OI` reader - Channel 4 Output Initialization Value"]
388pub struct CH4OI_R(crate::FieldReader<bool, CH4OI_A>);
389impl CH4OI_R {
390 #[inline(always)]
391 pub(crate) fn new(bits: bool) -> Self {
392 CH4OI_R(crate::FieldReader::new(bits))
393 }
394 #[doc = r"Get enumerated values variant"]
395 #[inline(always)]
396 pub fn variant(&self) -> CH4OI_A {
397 match self.bits {
398 false => CH4OI_A::CH4OI_0,
399 true => CH4OI_A::CH4OI_1,
400 }
401 }
402 #[doc = "Checks if the value of the field is `CH4OI_0`"]
403 #[inline(always)]
404 pub fn is_ch4oi_0(&self) -> bool {
405 **self == CH4OI_A::CH4OI_0
406 }
407 #[doc = "Checks if the value of the field is `CH4OI_1`"]
408 #[inline(always)]
409 pub fn is_ch4oi_1(&self) -> bool {
410 **self == CH4OI_A::CH4OI_1
411 }
412}
413impl core::ops::Deref for CH4OI_R {
414 type Target = crate::FieldReader<bool, CH4OI_A>;
415 #[inline(always)]
416 fn deref(&self) -> &Self::Target {
417 &self.0
418 }
419}
420#[doc = "Field `CH4OI` writer - Channel 4 Output Initialization Value"]
421pub struct CH4OI_W<'a> {
422 w: &'a mut W,
423}
424impl<'a> CH4OI_W<'a> {
425 #[doc = r"Writes `variant` to the field"]
426 #[inline(always)]
427 pub fn variant(self, variant: CH4OI_A) -> &'a mut W {
428 self.bit(variant.into())
429 }
430 #[doc = "The initialization value is 0."]
431 #[inline(always)]
432 pub fn ch4oi_0(self) -> &'a mut W {
433 self.variant(CH4OI_A::CH4OI_0)
434 }
435 #[doc = "The initialization value is 1."]
436 #[inline(always)]
437 pub fn ch4oi_1(self) -> &'a mut W {
438 self.variant(CH4OI_A::CH4OI_1)
439 }
440 #[doc = r"Sets the field bit"]
441 #[inline(always)]
442 pub fn set_bit(self) -> &'a mut W {
443 self.bit(true)
444 }
445 #[doc = r"Clears the field bit"]
446 #[inline(always)]
447 pub fn clear_bit(self) -> &'a mut W {
448 self.bit(false)
449 }
450 #[doc = r"Writes raw bits to the field"]
451 #[inline(always)]
452 pub fn bit(self, value: bool) -> &'a mut W {
453 self.w.bits = (self.w.bits & !(0x01 << 4)) | ((value as u32 & 0x01) << 4);
454 self.w
455 }
456}
457#[doc = "Channel 5 Output Initialization Value\n\nValue on reset: 0"]
458#[derive(Clone, Copy, Debug, PartialEq)]
459pub enum CH5OI_A {
460 #[doc = "0: The initialization value is 0."]
461 CH5OI_0 = 0,
462 #[doc = "1: The initialization value is 1."]
463 CH5OI_1 = 1,
464}
465impl From<CH5OI_A> for bool {
466 #[inline(always)]
467 fn from(variant: CH5OI_A) -> Self {
468 variant as u8 != 0
469 }
470}
471#[doc = "Field `CH5OI` reader - Channel 5 Output Initialization Value"]
472pub struct CH5OI_R(crate::FieldReader<bool, CH5OI_A>);
473impl CH5OI_R {
474 #[inline(always)]
475 pub(crate) fn new(bits: bool) -> Self {
476 CH5OI_R(crate::FieldReader::new(bits))
477 }
478 #[doc = r"Get enumerated values variant"]
479 #[inline(always)]
480 pub fn variant(&self) -> CH5OI_A {
481 match self.bits {
482 false => CH5OI_A::CH5OI_0,
483 true => CH5OI_A::CH5OI_1,
484 }
485 }
486 #[doc = "Checks if the value of the field is `CH5OI_0`"]
487 #[inline(always)]
488 pub fn is_ch5oi_0(&self) -> bool {
489 **self == CH5OI_A::CH5OI_0
490 }
491 #[doc = "Checks if the value of the field is `CH5OI_1`"]
492 #[inline(always)]
493 pub fn is_ch5oi_1(&self) -> bool {
494 **self == CH5OI_A::CH5OI_1
495 }
496}
497impl core::ops::Deref for CH5OI_R {
498 type Target = crate::FieldReader<bool, CH5OI_A>;
499 #[inline(always)]
500 fn deref(&self) -> &Self::Target {
501 &self.0
502 }
503}
504#[doc = "Field `CH5OI` writer - Channel 5 Output Initialization Value"]
505pub struct CH5OI_W<'a> {
506 w: &'a mut W,
507}
508impl<'a> CH5OI_W<'a> {
509 #[doc = r"Writes `variant` to the field"]
510 #[inline(always)]
511 pub fn variant(self, variant: CH5OI_A) -> &'a mut W {
512 self.bit(variant.into())
513 }
514 #[doc = "The initialization value is 0."]
515 #[inline(always)]
516 pub fn ch5oi_0(self) -> &'a mut W {
517 self.variant(CH5OI_A::CH5OI_0)
518 }
519 #[doc = "The initialization value is 1."]
520 #[inline(always)]
521 pub fn ch5oi_1(self) -> &'a mut W {
522 self.variant(CH5OI_A::CH5OI_1)
523 }
524 #[doc = r"Sets the field bit"]
525 #[inline(always)]
526 pub fn set_bit(self) -> &'a mut W {
527 self.bit(true)
528 }
529 #[doc = r"Clears the field bit"]
530 #[inline(always)]
531 pub fn clear_bit(self) -> &'a mut W {
532 self.bit(false)
533 }
534 #[doc = r"Writes raw bits to the field"]
535 #[inline(always)]
536 pub fn bit(self, value: bool) -> &'a mut W {
537 self.w.bits = (self.w.bits & !(0x01 << 5)) | ((value as u32 & 0x01) << 5);
538 self.w
539 }
540}
541#[doc = "Channel 6 Output Initialization Value\n\nValue on reset: 0"]
542#[derive(Clone, Copy, Debug, PartialEq)]
543pub enum CH6OI_A {
544 #[doc = "0: The initialization value is 0."]
545 CH6OI_0 = 0,
546 #[doc = "1: The initialization value is 1."]
547 CH6OI_1 = 1,
548}
549impl From<CH6OI_A> for bool {
550 #[inline(always)]
551 fn from(variant: CH6OI_A) -> Self {
552 variant as u8 != 0
553 }
554}
555#[doc = "Field `CH6OI` reader - Channel 6 Output Initialization Value"]
556pub struct CH6OI_R(crate::FieldReader<bool, CH6OI_A>);
557impl CH6OI_R {
558 #[inline(always)]
559 pub(crate) fn new(bits: bool) -> Self {
560 CH6OI_R(crate::FieldReader::new(bits))
561 }
562 #[doc = r"Get enumerated values variant"]
563 #[inline(always)]
564 pub fn variant(&self) -> CH6OI_A {
565 match self.bits {
566 false => CH6OI_A::CH6OI_0,
567 true => CH6OI_A::CH6OI_1,
568 }
569 }
570 #[doc = "Checks if the value of the field is `CH6OI_0`"]
571 #[inline(always)]
572 pub fn is_ch6oi_0(&self) -> bool {
573 **self == CH6OI_A::CH6OI_0
574 }
575 #[doc = "Checks if the value of the field is `CH6OI_1`"]
576 #[inline(always)]
577 pub fn is_ch6oi_1(&self) -> bool {
578 **self == CH6OI_A::CH6OI_1
579 }
580}
581impl core::ops::Deref for CH6OI_R {
582 type Target = crate::FieldReader<bool, CH6OI_A>;
583 #[inline(always)]
584 fn deref(&self) -> &Self::Target {
585 &self.0
586 }
587}
588#[doc = "Field `CH6OI` writer - Channel 6 Output Initialization Value"]
589pub struct CH6OI_W<'a> {
590 w: &'a mut W,
591}
592impl<'a> CH6OI_W<'a> {
593 #[doc = r"Writes `variant` to the field"]
594 #[inline(always)]
595 pub fn variant(self, variant: CH6OI_A) -> &'a mut W {
596 self.bit(variant.into())
597 }
598 #[doc = "The initialization value is 0."]
599 #[inline(always)]
600 pub fn ch6oi_0(self) -> &'a mut W {
601 self.variant(CH6OI_A::CH6OI_0)
602 }
603 #[doc = "The initialization value is 1."]
604 #[inline(always)]
605 pub fn ch6oi_1(self) -> &'a mut W {
606 self.variant(CH6OI_A::CH6OI_1)
607 }
608 #[doc = r"Sets the field bit"]
609 #[inline(always)]
610 pub fn set_bit(self) -> &'a mut W {
611 self.bit(true)
612 }
613 #[doc = r"Clears the field bit"]
614 #[inline(always)]
615 pub fn clear_bit(self) -> &'a mut W {
616 self.bit(false)
617 }
618 #[doc = r"Writes raw bits to the field"]
619 #[inline(always)]
620 pub fn bit(self, value: bool) -> &'a mut W {
621 self.w.bits = (self.w.bits & !(0x01 << 6)) | ((value as u32 & 0x01) << 6);
622 self.w
623 }
624}
625#[doc = "Channel 7 Output Initialization Value\n\nValue on reset: 0"]
626#[derive(Clone, Copy, Debug, PartialEq)]
627pub enum CH7OI_A {
628 #[doc = "0: The initialization value is 0."]
629 CH7OI_0 = 0,
630 #[doc = "1: The initialization value is 1."]
631 CH7OI_1 = 1,
632}
633impl From<CH7OI_A> for bool {
634 #[inline(always)]
635 fn from(variant: CH7OI_A) -> Self {
636 variant as u8 != 0
637 }
638}
639#[doc = "Field `CH7OI` reader - Channel 7 Output Initialization Value"]
640pub struct CH7OI_R(crate::FieldReader<bool, CH7OI_A>);
641impl CH7OI_R {
642 #[inline(always)]
643 pub(crate) fn new(bits: bool) -> Self {
644 CH7OI_R(crate::FieldReader::new(bits))
645 }
646 #[doc = r"Get enumerated values variant"]
647 #[inline(always)]
648 pub fn variant(&self) -> CH7OI_A {
649 match self.bits {
650 false => CH7OI_A::CH7OI_0,
651 true => CH7OI_A::CH7OI_1,
652 }
653 }
654 #[doc = "Checks if the value of the field is `CH7OI_0`"]
655 #[inline(always)]
656 pub fn is_ch7oi_0(&self) -> bool {
657 **self == CH7OI_A::CH7OI_0
658 }
659 #[doc = "Checks if the value of the field is `CH7OI_1`"]
660 #[inline(always)]
661 pub fn is_ch7oi_1(&self) -> bool {
662 **self == CH7OI_A::CH7OI_1
663 }
664}
665impl core::ops::Deref for CH7OI_R {
666 type Target = crate::FieldReader<bool, CH7OI_A>;
667 #[inline(always)]
668 fn deref(&self) -> &Self::Target {
669 &self.0
670 }
671}
672#[doc = "Field `CH7OI` writer - Channel 7 Output Initialization Value"]
673pub struct CH7OI_W<'a> {
674 w: &'a mut W,
675}
676impl<'a> CH7OI_W<'a> {
677 #[doc = r"Writes `variant` to the field"]
678 #[inline(always)]
679 pub fn variant(self, variant: CH7OI_A) -> &'a mut W {
680 self.bit(variant.into())
681 }
682 #[doc = "The initialization value is 0."]
683 #[inline(always)]
684 pub fn ch7oi_0(self) -> &'a mut W {
685 self.variant(CH7OI_A::CH7OI_0)
686 }
687 #[doc = "The initialization value is 1."]
688 #[inline(always)]
689 pub fn ch7oi_1(self) -> &'a mut W {
690 self.variant(CH7OI_A::CH7OI_1)
691 }
692 #[doc = r"Sets the field bit"]
693 #[inline(always)]
694 pub fn set_bit(self) -> &'a mut W {
695 self.bit(true)
696 }
697 #[doc = r"Clears the field bit"]
698 #[inline(always)]
699 pub fn clear_bit(self) -> &'a mut W {
700 self.bit(false)
701 }
702 #[doc = r"Writes raw bits to the field"]
703 #[inline(always)]
704 pub fn bit(self, value: bool) -> &'a mut W {
705 self.w.bits = (self.w.bits & !(0x01 << 7)) | ((value as u32 & 0x01) << 7);
706 self.w
707 }
708}
709impl R {
710 #[doc = "Bit 0 - Channel 0 Output Initialization Value"]
711 #[inline(always)]
712 pub fn ch0oi(&self) -> CH0OI_R {
713 CH0OI_R::new((self.bits & 0x01) != 0)
714 }
715 #[doc = "Bit 1 - Channel 1 Output Initialization Value"]
716 #[inline(always)]
717 pub fn ch1oi(&self) -> CH1OI_R {
718 CH1OI_R::new(((self.bits >> 1) & 0x01) != 0)
719 }
720 #[doc = "Bit 2 - Channel 2 Output Initialization Value"]
721 #[inline(always)]
722 pub fn ch2oi(&self) -> CH2OI_R {
723 CH2OI_R::new(((self.bits >> 2) & 0x01) != 0)
724 }
725 #[doc = "Bit 3 - Channel 3 Output Initialization Value"]
726 #[inline(always)]
727 pub fn ch3oi(&self) -> CH3OI_R {
728 CH3OI_R::new(((self.bits >> 3) & 0x01) != 0)
729 }
730 #[doc = "Bit 4 - Channel 4 Output Initialization Value"]
731 #[inline(always)]
732 pub fn ch4oi(&self) -> CH4OI_R {
733 CH4OI_R::new(((self.bits >> 4) & 0x01) != 0)
734 }
735 #[doc = "Bit 5 - Channel 5 Output Initialization Value"]
736 #[inline(always)]
737 pub fn ch5oi(&self) -> CH5OI_R {
738 CH5OI_R::new(((self.bits >> 5) & 0x01) != 0)
739 }
740 #[doc = "Bit 6 - Channel 6 Output Initialization Value"]
741 #[inline(always)]
742 pub fn ch6oi(&self) -> CH6OI_R {
743 CH6OI_R::new(((self.bits >> 6) & 0x01) != 0)
744 }
745 #[doc = "Bit 7 - Channel 7 Output Initialization Value"]
746 #[inline(always)]
747 pub fn ch7oi(&self) -> CH7OI_R {
748 CH7OI_R::new(((self.bits >> 7) & 0x01) != 0)
749 }
750}
751impl W {
752 #[doc = "Bit 0 - Channel 0 Output Initialization Value"]
753 #[inline(always)]
754 pub fn ch0oi(&mut self) -> CH0OI_W {
755 CH0OI_W { w: self }
756 }
757 #[doc = "Bit 1 - Channel 1 Output Initialization Value"]
758 #[inline(always)]
759 pub fn ch1oi(&mut self) -> CH1OI_W {
760 CH1OI_W { w: self }
761 }
762 #[doc = "Bit 2 - Channel 2 Output Initialization Value"]
763 #[inline(always)]
764 pub fn ch2oi(&mut self) -> CH2OI_W {
765 CH2OI_W { w: self }
766 }
767 #[doc = "Bit 3 - Channel 3 Output Initialization Value"]
768 #[inline(always)]
769 pub fn ch3oi(&mut self) -> CH3OI_W {
770 CH3OI_W { w: self }
771 }
772 #[doc = "Bit 4 - Channel 4 Output Initialization Value"]
773 #[inline(always)]
774 pub fn ch4oi(&mut self) -> CH4OI_W {
775 CH4OI_W { w: self }
776 }
777 #[doc = "Bit 5 - Channel 5 Output Initialization Value"]
778 #[inline(always)]
779 pub fn ch5oi(&mut self) -> CH5OI_W {
780 CH5OI_W { w: self }
781 }
782 #[doc = "Bit 6 - Channel 6 Output Initialization Value"]
783 #[inline(always)]
784 pub fn ch6oi(&mut self) -> CH6OI_W {
785 CH6OI_W { w: self }
786 }
787 #[doc = "Bit 7 - Channel 7 Output Initialization Value"]
788 #[inline(always)]
789 pub fn ch7oi(&mut self) -> CH7OI_W {
790 CH7OI_W { w: self }
791 }
792 #[doc = "Writes raw bits to the register."]
793 #[inline(always)]
794 pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
795 self.0.bits(bits);
796 self
797 }
798}
799#[doc = "Initial State For Channels Output\n\nThis register you can [`read`](crate::generic::Reg::read), [`write_with_zero`](crate::generic::Reg::write_with_zero), [`reset`](crate::generic::Reg::reset), [`write`](crate::generic::Reg::write), [`modify`](crate::generic::Reg::modify). See [API](https://docs.rs/svd2rust/#read--modify--write-api).\n\nFor information about available fields see [outinit](index.html) module"]
800pub struct OUTINIT_SPEC;
801impl crate::RegisterSpec for OUTINIT_SPEC {
802 type Ux = u32;
803}
804#[doc = "`read()` method returns [outinit::R](R) reader structure"]
805impl crate::Readable for OUTINIT_SPEC {
806 type Reader = R;
807}
808#[doc = "`write(|w| ..)` method takes [outinit::W](W) writer structure"]
809impl crate::Writable for OUTINIT_SPEC {
810 type Writer = W;
811}
812#[doc = "`reset()` method sets OUTINIT to value 0"]
813impl crate::Resettable for OUTINIT_SPEC {
814 #[inline(always)]
815 fn reset_value() -> Self::Ux {
816 0
817 }
818}