1pub type R = crate::R<CCERrs>;
3pub type W = crate::W<CCERrs>;
5#[cfg_attr(feature = "defmt", derive(defmt::Format))]
9#[derive(Clone, Copy, Debug, PartialEq, Eq)]
10pub enum CC1E {
11 Disabled = 0,
13 Enabled = 1,
15}
16impl From<CC1E> for bool {
17 #[inline(always)]
18 fn from(variant: CC1E) -> Self {
19 variant as u8 != 0
20 }
21}
22pub type CCE_R = crate::BitReader<CC1E>;
24impl CCE_R {
25 #[inline(always)]
27 pub const fn variant(&self) -> CC1E {
28 match self.bits {
29 false => CC1E::Disabled,
30 true => CC1E::Enabled,
31 }
32 }
33 #[inline(always)]
35 pub fn is_disabled(&self) -> bool {
36 *self == CC1E::Disabled
37 }
38 #[inline(always)]
40 pub fn is_enabled(&self) -> bool {
41 *self == CC1E::Enabled
42 }
43}
44pub type CCE_W<'a, REG> = crate::BitWriter<'a, REG, CC1E>;
46impl<'a, REG> CCE_W<'a, REG>
47where
48 REG: crate::Writable + crate::RegisterSpec,
49{
50 #[inline(always)]
52 pub fn disabled(self) -> &'a mut crate::W<REG> {
53 self.variant(CC1E::Disabled)
54 }
55 #[inline(always)]
57 pub fn enabled(self) -> &'a mut crate::W<REG> {
58 self.variant(CC1E::Enabled)
59 }
60}
61#[cfg_attr(feature = "defmt", derive(defmt::Format))]
65#[derive(Clone, Copy, Debug, PartialEq, Eq)]
66pub enum CC1P {
67 RisingEdge = 0,
69 FallingEdge = 1,
71}
72impl From<CC1P> for bool {
73 #[inline(always)]
74 fn from(variant: CC1P) -> Self {
75 variant as u8 != 0
76 }
77}
78pub type CCP_R = crate::BitReader<CC1P>;
80impl CCP_R {
81 #[inline(always)]
83 pub const fn variant(&self) -> CC1P {
84 match self.bits {
85 false => CC1P::RisingEdge,
86 true => CC1P::FallingEdge,
87 }
88 }
89 #[inline(always)]
91 pub fn is_rising_edge(&self) -> bool {
92 *self == CC1P::RisingEdge
93 }
94 #[inline(always)]
96 pub fn is_falling_edge(&self) -> bool {
97 *self == CC1P::FallingEdge
98 }
99}
100pub type CCP_W<'a, REG> = crate::BitWriter<'a, REG, CC1P>;
102impl<'a, REG> CCP_W<'a, REG>
103where
104 REG: crate::Writable + crate::RegisterSpec,
105{
106 #[inline(always)]
108 pub fn rising_edge(self) -> &'a mut crate::W<REG> {
109 self.variant(CC1P::RisingEdge)
110 }
111 #[inline(always)]
113 pub fn falling_edge(self) -> &'a mut crate::W<REG> {
114 self.variant(CC1P::FallingEdge)
115 }
116}
117#[cfg_attr(feature = "defmt", derive(defmt::Format))]
121#[derive(Clone, Copy, Debug, PartialEq, Eq)]
122pub enum CC1NE {
123 Disabled = 0,
125 Enabled = 1,
127}
128impl From<CC1NE> for bool {
129 #[inline(always)]
130 fn from(variant: CC1NE) -> Self {
131 variant as u8 != 0
132 }
133}
134pub type CCNE_R = crate::BitReader<CC1NE>;
136impl CCNE_R {
137 #[inline(always)]
139 pub const fn variant(&self) -> CC1NE {
140 match self.bits {
141 false => CC1NE::Disabled,
142 true => CC1NE::Enabled,
143 }
144 }
145 #[inline(always)]
147 pub fn is_disabled(&self) -> bool {
148 *self == CC1NE::Disabled
149 }
150 #[inline(always)]
152 pub fn is_enabled(&self) -> bool {
153 *self == CC1NE::Enabled
154 }
155}
156pub type CCNE_W<'a, REG> = crate::BitWriter<'a, REG, CC1NE>;
158impl<'a, REG> CCNE_W<'a, REG>
159where
160 REG: crate::Writable + crate::RegisterSpec,
161{
162 #[inline(always)]
164 pub fn disabled(self) -> &'a mut crate::W<REG> {
165 self.variant(CC1NE::Disabled)
166 }
167 #[inline(always)]
169 pub fn enabled(self) -> &'a mut crate::W<REG> {
170 self.variant(CC1NE::Enabled)
171 }
172}
173#[cfg_attr(feature = "defmt", derive(defmt::Format))]
177#[derive(Clone, Copy, Debug, PartialEq, Eq)]
178pub enum CC1NP {
179 ActiveHigh = 0,
181 ActiveLow = 1,
183}
184impl From<CC1NP> for bool {
185 #[inline(always)]
186 fn from(variant: CC1NP) -> Self {
187 variant as u8 != 0
188 }
189}
190pub type CCNP_R = crate::BitReader<CC1NP>;
192impl CCNP_R {
193 #[inline(always)]
195 pub const fn variant(&self) -> CC1NP {
196 match self.bits {
197 false => CC1NP::ActiveHigh,
198 true => CC1NP::ActiveLow,
199 }
200 }
201 #[inline(always)]
203 pub fn is_active_high(&self) -> bool {
204 *self == CC1NP::ActiveHigh
205 }
206 #[inline(always)]
208 pub fn is_active_low(&self) -> bool {
209 *self == CC1NP::ActiveLow
210 }
211}
212pub type CCNP_W<'a, REG> = crate::BitWriter<'a, REG, CC1NP>;
214impl<'a, REG> CCNP_W<'a, REG>
215where
216 REG: crate::Writable + crate::RegisterSpec,
217{
218 #[inline(always)]
220 pub fn active_high(self) -> &'a mut crate::W<REG> {
221 self.variant(CC1NP::ActiveHigh)
222 }
223 #[inline(always)]
225 pub fn active_low(self) -> &'a mut crate::W<REG> {
226 self.variant(CC1NP::ActiveLow)
227 }
228}
229impl R {
230 #[inline(always)]
234 pub fn cce(&self, n: u8) -> CCE_R {
235 #[allow(clippy::no_effect)]
236 [(); 2][n as usize];
237 CCE_R::new(((self.bits >> (n * 4)) & 1) != 0)
238 }
239 #[inline(always)]
242 pub fn cce_iter(&self) -> impl Iterator<Item = CCE_R> + '_ {
243 (0..2).map(move |n| CCE_R::new(((self.bits >> (n * 4)) & 1) != 0))
244 }
245 #[inline(always)]
247 pub fn cc1e(&self) -> CCE_R {
248 CCE_R::new((self.bits & 1) != 0)
249 }
250 #[inline(always)]
252 pub fn cc2e(&self) -> CCE_R {
253 CCE_R::new(((self.bits >> 4) & 1) != 0)
254 }
255 #[inline(always)]
259 pub fn ccp(&self, n: u8) -> CCP_R {
260 #[allow(clippy::no_effect)]
261 [(); 2][n as usize];
262 CCP_R::new(((self.bits >> (n * 4 + 1)) & 1) != 0)
263 }
264 #[inline(always)]
267 pub fn ccp_iter(&self) -> impl Iterator<Item = CCP_R> + '_ {
268 (0..2).map(move |n| CCP_R::new(((self.bits >> (n * 4 + 1)) & 1) != 0))
269 }
270 #[inline(always)]
272 pub fn cc1p(&self) -> CCP_R {
273 CCP_R::new(((self.bits >> 1) & 1) != 0)
274 }
275 #[inline(always)]
277 pub fn cc2p(&self) -> CCP_R {
278 CCP_R::new(((self.bits >> 5) & 1) != 0)
279 }
280 #[inline(always)]
284 pub fn ccne(&self, n: u8) -> CCNE_R {
285 #[allow(clippy::no_effect)]
286 [(); 1][n as usize];
287 CCNE_R::new(((self.bits >> (n * 0 + 2)) & 1) != 0)
288 }
289 #[inline(always)]
292 pub fn ccne_iter(&self) -> impl Iterator<Item = CCNE_R> + '_ {
293 (0..1).map(move |n| CCNE_R::new(((self.bits >> (n * 0 + 2)) & 1) != 0))
294 }
295 #[inline(always)]
297 pub fn cc1ne(&self) -> CCNE_R {
298 CCNE_R::new(((self.bits >> 2) & 1) != 0)
299 }
300 #[inline(always)]
304 pub fn ccnp(&self, n: u8) -> CCNP_R {
305 #[allow(clippy::no_effect)]
306 [(); 2][n as usize];
307 CCNP_R::new(((self.bits >> (n * 4 + 3)) & 1) != 0)
308 }
309 #[inline(always)]
312 pub fn ccnp_iter(&self) -> impl Iterator<Item = CCNP_R> + '_ {
313 (0..2).map(move |n| CCNP_R::new(((self.bits >> (n * 4 + 3)) & 1) != 0))
314 }
315 #[inline(always)]
317 pub fn cc1np(&self) -> CCNP_R {
318 CCNP_R::new(((self.bits >> 3) & 1) != 0)
319 }
320 #[inline(always)]
322 pub fn cc2np(&self) -> CCNP_R {
323 CCNP_R::new(((self.bits >> 7) & 1) != 0)
324 }
325}
326impl core::fmt::Debug for R {
327 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
328 f.debug_struct("CCER")
329 .field("cc1np", &self.cc1np())
330 .field("cc2np", &self.cc2np())
331 .field("cc1p", &self.cc1p())
332 .field("cc2p", &self.cc2p())
333 .field("cc1e", &self.cc1e())
334 .field("cc2e", &self.cc2e())
335 .field("cc1ne", &self.cc1ne())
336 .finish()
337 }
338}
339impl W {
340 #[inline(always)]
344 pub fn cce(&mut self, n: u8) -> CCE_W<CCERrs> {
345 #[allow(clippy::no_effect)]
346 [(); 2][n as usize];
347 CCE_W::new(self, n * 4)
348 }
349 #[inline(always)]
351 pub fn cc1e(&mut self) -> CCE_W<CCERrs> {
352 CCE_W::new(self, 0)
353 }
354 #[inline(always)]
356 pub fn cc2e(&mut self) -> CCE_W<CCERrs> {
357 CCE_W::new(self, 4)
358 }
359 #[inline(always)]
363 pub fn ccp(&mut self, n: u8) -> CCP_W<CCERrs> {
364 #[allow(clippy::no_effect)]
365 [(); 2][n as usize];
366 CCP_W::new(self, n * 4 + 1)
367 }
368 #[inline(always)]
370 pub fn cc1p(&mut self) -> CCP_W<CCERrs> {
371 CCP_W::new(self, 1)
372 }
373 #[inline(always)]
375 pub fn cc2p(&mut self) -> CCP_W<CCERrs> {
376 CCP_W::new(self, 5)
377 }
378 #[inline(always)]
382 pub fn ccne(&mut self, n: u8) -> CCNE_W<CCERrs> {
383 #[allow(clippy::no_effect)]
384 [(); 1][n as usize];
385 CCNE_W::new(self, n * 0 + 2)
386 }
387 #[inline(always)]
389 pub fn cc1ne(&mut self) -> CCNE_W<CCERrs> {
390 CCNE_W::new(self, 2)
391 }
392 #[inline(always)]
396 pub fn ccnp(&mut self, n: u8) -> CCNP_W<CCERrs> {
397 #[allow(clippy::no_effect)]
398 [(); 2][n as usize];
399 CCNP_W::new(self, n * 4 + 3)
400 }
401 #[inline(always)]
403 pub fn cc1np(&mut self) -> CCNP_W<CCERrs> {
404 CCNP_W::new(self, 3)
405 }
406 #[inline(always)]
408 pub fn cc2np(&mut self) -> CCNP_W<CCERrs> {
409 CCNP_W::new(self, 7)
410 }
411}
412pub struct CCERrs;
418impl crate::RegisterSpec for CCERrs {
419 type Ux = u32;
420}
421impl crate::Readable for CCERrs {}
423impl crate::Writable for CCERrs {
425 type Safety = crate::Unsafe;
426}
427impl crate::Resettable for CCERrs {}