stm32l4x2_pac/tim2/
ccer.rs

1#[doc = r" Value read from the register"]
2pub struct R {
3    bits: u32,
4}
5#[doc = r" Value to write to the register"]
6pub struct W {
7    bits: u32,
8}
9impl super::CCER {
10    #[doc = r" Modifies the contents of the register"]
11    #[inline]
12    pub fn modify<F>(&self, f: F)
13    where
14        for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W,
15    {
16        let bits = self.register.get();
17        let r = R { bits: bits };
18        let mut w = W { bits: bits };
19        f(&r, &mut w);
20        self.register.set(w.bits);
21    }
22    #[doc = r" Reads the contents of the register"]
23    #[inline]
24    pub fn read(&self) -> R {
25        R {
26            bits: self.register.get(),
27        }
28    }
29    #[doc = r" Writes to the register"]
30    #[inline]
31    pub fn write<F>(&self, f: F)
32    where
33        F: FnOnce(&mut W) -> &mut W,
34    {
35        let mut w = W::reset_value();
36        f(&mut w);
37        self.register.set(w.bits);
38    }
39    #[doc = r" Writes the reset value to the register"]
40    #[inline]
41    pub fn reset(&self) {
42        self.write(|w| w)
43    }
44}
45#[doc = r" Value of the field"]
46pub struct CC4NPR {
47    bits: bool,
48}
49impl CC4NPR {
50    #[doc = r" Value of the field as raw bits"]
51    #[inline]
52    pub fn bit(&self) -> bool {
53        self.bits
54    }
55    #[doc = r" Returns `true` if the bit is clear (0)"]
56    #[inline]
57    pub fn bit_is_clear(&self) -> bool {
58        !self.bit()
59    }
60    #[doc = r" Returns `true` if the bit is set (1)"]
61    #[inline]
62    pub fn bit_is_set(&self) -> bool {
63        self.bit()
64    }
65}
66#[doc = r" Value of the field"]
67pub struct CC4PR {
68    bits: bool,
69}
70impl CC4PR {
71    #[doc = r" Value of the field as raw bits"]
72    #[inline]
73    pub fn bit(&self) -> bool {
74        self.bits
75    }
76    #[doc = r" Returns `true` if the bit is clear (0)"]
77    #[inline]
78    pub fn bit_is_clear(&self) -> bool {
79        !self.bit()
80    }
81    #[doc = r" Returns `true` if the bit is set (1)"]
82    #[inline]
83    pub fn bit_is_set(&self) -> bool {
84        self.bit()
85    }
86}
87#[doc = r" Value of the field"]
88pub struct CC4ER {
89    bits: bool,
90}
91impl CC4ER {
92    #[doc = r" Value of the field as raw bits"]
93    #[inline]
94    pub fn bit(&self) -> bool {
95        self.bits
96    }
97    #[doc = r" Returns `true` if the bit is clear (0)"]
98    #[inline]
99    pub fn bit_is_clear(&self) -> bool {
100        !self.bit()
101    }
102    #[doc = r" Returns `true` if the bit is set (1)"]
103    #[inline]
104    pub fn bit_is_set(&self) -> bool {
105        self.bit()
106    }
107}
108#[doc = r" Value of the field"]
109pub struct CC3NPR {
110    bits: bool,
111}
112impl CC3NPR {
113    #[doc = r" Value of the field as raw bits"]
114    #[inline]
115    pub fn bit(&self) -> bool {
116        self.bits
117    }
118    #[doc = r" Returns `true` if the bit is clear (0)"]
119    #[inline]
120    pub fn bit_is_clear(&self) -> bool {
121        !self.bit()
122    }
123    #[doc = r" Returns `true` if the bit is set (1)"]
124    #[inline]
125    pub fn bit_is_set(&self) -> bool {
126        self.bit()
127    }
128}
129#[doc = r" Value of the field"]
130pub struct CC3PR {
131    bits: bool,
132}
133impl CC3PR {
134    #[doc = r" Value of the field as raw bits"]
135    #[inline]
136    pub fn bit(&self) -> bool {
137        self.bits
138    }
139    #[doc = r" Returns `true` if the bit is clear (0)"]
140    #[inline]
141    pub fn bit_is_clear(&self) -> bool {
142        !self.bit()
143    }
144    #[doc = r" Returns `true` if the bit is set (1)"]
145    #[inline]
146    pub fn bit_is_set(&self) -> bool {
147        self.bit()
148    }
149}
150#[doc = r" Value of the field"]
151pub struct CC3ER {
152    bits: bool,
153}
154impl CC3ER {
155    #[doc = r" Value of the field as raw bits"]
156    #[inline]
157    pub fn bit(&self) -> bool {
158        self.bits
159    }
160    #[doc = r" Returns `true` if the bit is clear (0)"]
161    #[inline]
162    pub fn bit_is_clear(&self) -> bool {
163        !self.bit()
164    }
165    #[doc = r" Returns `true` if the bit is set (1)"]
166    #[inline]
167    pub fn bit_is_set(&self) -> bool {
168        self.bit()
169    }
170}
171#[doc = r" Value of the field"]
172pub struct CC2NPR {
173    bits: bool,
174}
175impl CC2NPR {
176    #[doc = r" Value of the field as raw bits"]
177    #[inline]
178    pub fn bit(&self) -> bool {
179        self.bits
180    }
181    #[doc = r" Returns `true` if the bit is clear (0)"]
182    #[inline]
183    pub fn bit_is_clear(&self) -> bool {
184        !self.bit()
185    }
186    #[doc = r" Returns `true` if the bit is set (1)"]
187    #[inline]
188    pub fn bit_is_set(&self) -> bool {
189        self.bit()
190    }
191}
192#[doc = r" Value of the field"]
193pub struct CC2PR {
194    bits: bool,
195}
196impl CC2PR {
197    #[doc = r" Value of the field as raw bits"]
198    #[inline]
199    pub fn bit(&self) -> bool {
200        self.bits
201    }
202    #[doc = r" Returns `true` if the bit is clear (0)"]
203    #[inline]
204    pub fn bit_is_clear(&self) -> bool {
205        !self.bit()
206    }
207    #[doc = r" Returns `true` if the bit is set (1)"]
208    #[inline]
209    pub fn bit_is_set(&self) -> bool {
210        self.bit()
211    }
212}
213#[doc = r" Value of the field"]
214pub struct CC2ER {
215    bits: bool,
216}
217impl CC2ER {
218    #[doc = r" Value of the field as raw bits"]
219    #[inline]
220    pub fn bit(&self) -> bool {
221        self.bits
222    }
223    #[doc = r" Returns `true` if the bit is clear (0)"]
224    #[inline]
225    pub fn bit_is_clear(&self) -> bool {
226        !self.bit()
227    }
228    #[doc = r" Returns `true` if the bit is set (1)"]
229    #[inline]
230    pub fn bit_is_set(&self) -> bool {
231        self.bit()
232    }
233}
234#[doc = r" Value of the field"]
235pub struct CC1NPR {
236    bits: bool,
237}
238impl CC1NPR {
239    #[doc = r" Value of the field as raw bits"]
240    #[inline]
241    pub fn bit(&self) -> bool {
242        self.bits
243    }
244    #[doc = r" Returns `true` if the bit is clear (0)"]
245    #[inline]
246    pub fn bit_is_clear(&self) -> bool {
247        !self.bit()
248    }
249    #[doc = r" Returns `true` if the bit is set (1)"]
250    #[inline]
251    pub fn bit_is_set(&self) -> bool {
252        self.bit()
253    }
254}
255#[doc = r" Value of the field"]
256pub struct CC1PR {
257    bits: bool,
258}
259impl CC1PR {
260    #[doc = r" Value of the field as raw bits"]
261    #[inline]
262    pub fn bit(&self) -> bool {
263        self.bits
264    }
265    #[doc = r" Returns `true` if the bit is clear (0)"]
266    #[inline]
267    pub fn bit_is_clear(&self) -> bool {
268        !self.bit()
269    }
270    #[doc = r" Returns `true` if the bit is set (1)"]
271    #[inline]
272    pub fn bit_is_set(&self) -> bool {
273        self.bit()
274    }
275}
276#[doc = r" Value of the field"]
277pub struct CC1ER {
278    bits: bool,
279}
280impl CC1ER {
281    #[doc = r" Value of the field as raw bits"]
282    #[inline]
283    pub fn bit(&self) -> bool {
284        self.bits
285    }
286    #[doc = r" Returns `true` if the bit is clear (0)"]
287    #[inline]
288    pub fn bit_is_clear(&self) -> bool {
289        !self.bit()
290    }
291    #[doc = r" Returns `true` if the bit is set (1)"]
292    #[inline]
293    pub fn bit_is_set(&self) -> bool {
294        self.bit()
295    }
296}
297#[doc = r" Proxy"]
298pub struct _CC4NPW<'a> {
299    w: &'a mut W,
300}
301impl<'a> _CC4NPW<'a> {
302    #[doc = r" Sets the field bit"]
303    pub fn set_bit(self) -> &'a mut W {
304        self.bit(true)
305    }
306    #[doc = r" Clears the field bit"]
307    pub fn clear_bit(self) -> &'a mut W {
308        self.bit(false)
309    }
310    #[doc = r" Writes raw bits to the field"]
311    #[inline]
312    pub fn bit(self, value: bool) -> &'a mut W {
313        const MASK: bool = true;
314        const OFFSET: u8 = 15;
315        self.w.bits &= !((MASK as u32) << OFFSET);
316        self.w.bits |= ((value & MASK) as u32) << OFFSET;
317        self.w
318    }
319}
320#[doc = r" Proxy"]
321pub struct _CC4PW<'a> {
322    w: &'a mut W,
323}
324impl<'a> _CC4PW<'a> {
325    #[doc = r" Sets the field bit"]
326    pub fn set_bit(self) -> &'a mut W {
327        self.bit(true)
328    }
329    #[doc = r" Clears the field bit"]
330    pub fn clear_bit(self) -> &'a mut W {
331        self.bit(false)
332    }
333    #[doc = r" Writes raw bits to the field"]
334    #[inline]
335    pub fn bit(self, value: bool) -> &'a mut W {
336        const MASK: bool = true;
337        const OFFSET: u8 = 13;
338        self.w.bits &= !((MASK as u32) << OFFSET);
339        self.w.bits |= ((value & MASK) as u32) << OFFSET;
340        self.w
341    }
342}
343#[doc = r" Proxy"]
344pub struct _CC4EW<'a> {
345    w: &'a mut W,
346}
347impl<'a> _CC4EW<'a> {
348    #[doc = r" Sets the field bit"]
349    pub fn set_bit(self) -> &'a mut W {
350        self.bit(true)
351    }
352    #[doc = r" Clears the field bit"]
353    pub fn clear_bit(self) -> &'a mut W {
354        self.bit(false)
355    }
356    #[doc = r" Writes raw bits to the field"]
357    #[inline]
358    pub fn bit(self, value: bool) -> &'a mut W {
359        const MASK: bool = true;
360        const OFFSET: u8 = 12;
361        self.w.bits &= !((MASK as u32) << OFFSET);
362        self.w.bits |= ((value & MASK) as u32) << OFFSET;
363        self.w
364    }
365}
366#[doc = r" Proxy"]
367pub struct _CC3NPW<'a> {
368    w: &'a mut W,
369}
370impl<'a> _CC3NPW<'a> {
371    #[doc = r" Sets the field bit"]
372    pub fn set_bit(self) -> &'a mut W {
373        self.bit(true)
374    }
375    #[doc = r" Clears the field bit"]
376    pub fn clear_bit(self) -> &'a mut W {
377        self.bit(false)
378    }
379    #[doc = r" Writes raw bits to the field"]
380    #[inline]
381    pub fn bit(self, value: bool) -> &'a mut W {
382        const MASK: bool = true;
383        const OFFSET: u8 = 11;
384        self.w.bits &= !((MASK as u32) << OFFSET);
385        self.w.bits |= ((value & MASK) as u32) << OFFSET;
386        self.w
387    }
388}
389#[doc = r" Proxy"]
390pub struct _CC3PW<'a> {
391    w: &'a mut W,
392}
393impl<'a> _CC3PW<'a> {
394    #[doc = r" Sets the field bit"]
395    pub fn set_bit(self) -> &'a mut W {
396        self.bit(true)
397    }
398    #[doc = r" Clears the field bit"]
399    pub fn clear_bit(self) -> &'a mut W {
400        self.bit(false)
401    }
402    #[doc = r" Writes raw bits to the field"]
403    #[inline]
404    pub fn bit(self, value: bool) -> &'a mut W {
405        const MASK: bool = true;
406        const OFFSET: u8 = 9;
407        self.w.bits &= !((MASK as u32) << OFFSET);
408        self.w.bits |= ((value & MASK) as u32) << OFFSET;
409        self.w
410    }
411}
412#[doc = r" Proxy"]
413pub struct _CC3EW<'a> {
414    w: &'a mut W,
415}
416impl<'a> _CC3EW<'a> {
417    #[doc = r" Sets the field bit"]
418    pub fn set_bit(self) -> &'a mut W {
419        self.bit(true)
420    }
421    #[doc = r" Clears the field bit"]
422    pub fn clear_bit(self) -> &'a mut W {
423        self.bit(false)
424    }
425    #[doc = r" Writes raw bits to the field"]
426    #[inline]
427    pub fn bit(self, value: bool) -> &'a mut W {
428        const MASK: bool = true;
429        const OFFSET: u8 = 8;
430        self.w.bits &= !((MASK as u32) << OFFSET);
431        self.w.bits |= ((value & MASK) as u32) << OFFSET;
432        self.w
433    }
434}
435#[doc = r" Proxy"]
436pub struct _CC2NPW<'a> {
437    w: &'a mut W,
438}
439impl<'a> _CC2NPW<'a> {
440    #[doc = r" Sets the field bit"]
441    pub fn set_bit(self) -> &'a mut W {
442        self.bit(true)
443    }
444    #[doc = r" Clears the field bit"]
445    pub fn clear_bit(self) -> &'a mut W {
446        self.bit(false)
447    }
448    #[doc = r" Writes raw bits to the field"]
449    #[inline]
450    pub fn bit(self, value: bool) -> &'a mut W {
451        const MASK: bool = true;
452        const OFFSET: u8 = 7;
453        self.w.bits &= !((MASK as u32) << OFFSET);
454        self.w.bits |= ((value & MASK) as u32) << OFFSET;
455        self.w
456    }
457}
458#[doc = r" Proxy"]
459pub struct _CC2PW<'a> {
460    w: &'a mut W,
461}
462impl<'a> _CC2PW<'a> {
463    #[doc = r" Sets the field bit"]
464    pub fn set_bit(self) -> &'a mut W {
465        self.bit(true)
466    }
467    #[doc = r" Clears the field bit"]
468    pub fn clear_bit(self) -> &'a mut W {
469        self.bit(false)
470    }
471    #[doc = r" Writes raw bits to the field"]
472    #[inline]
473    pub fn bit(self, value: bool) -> &'a mut W {
474        const MASK: bool = true;
475        const OFFSET: u8 = 5;
476        self.w.bits &= !((MASK as u32) << OFFSET);
477        self.w.bits |= ((value & MASK) as u32) << OFFSET;
478        self.w
479    }
480}
481#[doc = r" Proxy"]
482pub struct _CC2EW<'a> {
483    w: &'a mut W,
484}
485impl<'a> _CC2EW<'a> {
486    #[doc = r" Sets the field bit"]
487    pub fn set_bit(self) -> &'a mut W {
488        self.bit(true)
489    }
490    #[doc = r" Clears the field bit"]
491    pub fn clear_bit(self) -> &'a mut W {
492        self.bit(false)
493    }
494    #[doc = r" Writes raw bits to the field"]
495    #[inline]
496    pub fn bit(self, value: bool) -> &'a mut W {
497        const MASK: bool = true;
498        const OFFSET: u8 = 4;
499        self.w.bits &= !((MASK as u32) << OFFSET);
500        self.w.bits |= ((value & MASK) as u32) << OFFSET;
501        self.w
502    }
503}
504#[doc = r" Proxy"]
505pub struct _CC1NPW<'a> {
506    w: &'a mut W,
507}
508impl<'a> _CC1NPW<'a> {
509    #[doc = r" Sets the field bit"]
510    pub fn set_bit(self) -> &'a mut W {
511        self.bit(true)
512    }
513    #[doc = r" Clears the field bit"]
514    pub fn clear_bit(self) -> &'a mut W {
515        self.bit(false)
516    }
517    #[doc = r" Writes raw bits to the field"]
518    #[inline]
519    pub fn bit(self, value: bool) -> &'a mut W {
520        const MASK: bool = true;
521        const OFFSET: u8 = 3;
522        self.w.bits &= !((MASK as u32) << OFFSET);
523        self.w.bits |= ((value & MASK) as u32) << OFFSET;
524        self.w
525    }
526}
527#[doc = r" Proxy"]
528pub struct _CC1PW<'a> {
529    w: &'a mut W,
530}
531impl<'a> _CC1PW<'a> {
532    #[doc = r" Sets the field bit"]
533    pub fn set_bit(self) -> &'a mut W {
534        self.bit(true)
535    }
536    #[doc = r" Clears the field bit"]
537    pub fn clear_bit(self) -> &'a mut W {
538        self.bit(false)
539    }
540    #[doc = r" Writes raw bits to the field"]
541    #[inline]
542    pub fn bit(self, value: bool) -> &'a mut W {
543        const MASK: bool = true;
544        const OFFSET: u8 = 1;
545        self.w.bits &= !((MASK as u32) << OFFSET);
546        self.w.bits |= ((value & MASK) as u32) << OFFSET;
547        self.w
548    }
549}
550#[doc = r" Proxy"]
551pub struct _CC1EW<'a> {
552    w: &'a mut W,
553}
554impl<'a> _CC1EW<'a> {
555    #[doc = r" Sets the field bit"]
556    pub fn set_bit(self) -> &'a mut W {
557        self.bit(true)
558    }
559    #[doc = r" Clears the field bit"]
560    pub fn clear_bit(self) -> &'a mut W {
561        self.bit(false)
562    }
563    #[doc = r" Writes raw bits to the field"]
564    #[inline]
565    pub fn bit(self, value: bool) -> &'a mut W {
566        const MASK: bool = true;
567        const OFFSET: u8 = 0;
568        self.w.bits &= !((MASK as u32) << OFFSET);
569        self.w.bits |= ((value & MASK) as u32) << OFFSET;
570        self.w
571    }
572}
573impl R {
574    #[doc = r" Value of the register as raw bits"]
575    #[inline]
576    pub fn bits(&self) -> u32 {
577        self.bits
578    }
579    #[doc = "Bit 15 - Capture/Compare 4 output Polarity"]
580    #[inline]
581    pub fn cc4np(&self) -> CC4NPR {
582        let bits = {
583            const MASK: bool = true;
584            const OFFSET: u8 = 15;
585            ((self.bits >> OFFSET) & MASK as u32) != 0
586        };
587        CC4NPR { bits }
588    }
589    #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
590    #[inline]
591    pub fn cc4p(&self) -> CC4PR {
592        let bits = {
593            const MASK: bool = true;
594            const OFFSET: u8 = 13;
595            ((self.bits >> OFFSET) & MASK as u32) != 0
596        };
597        CC4PR { bits }
598    }
599    #[doc = "Bit 12 - Capture/Compare 4 output enable"]
600    #[inline]
601    pub fn cc4e(&self) -> CC4ER {
602        let bits = {
603            const MASK: bool = true;
604            const OFFSET: u8 = 12;
605            ((self.bits >> OFFSET) & MASK as u32) != 0
606        };
607        CC4ER { bits }
608    }
609    #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
610    #[inline]
611    pub fn cc3np(&self) -> CC3NPR {
612        let bits = {
613            const MASK: bool = true;
614            const OFFSET: u8 = 11;
615            ((self.bits >> OFFSET) & MASK as u32) != 0
616        };
617        CC3NPR { bits }
618    }
619    #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
620    #[inline]
621    pub fn cc3p(&self) -> CC3PR {
622        let bits = {
623            const MASK: bool = true;
624            const OFFSET: u8 = 9;
625            ((self.bits >> OFFSET) & MASK as u32) != 0
626        };
627        CC3PR { bits }
628    }
629    #[doc = "Bit 8 - Capture/Compare 3 output enable"]
630    #[inline]
631    pub fn cc3e(&self) -> CC3ER {
632        let bits = {
633            const MASK: bool = true;
634            const OFFSET: u8 = 8;
635            ((self.bits >> OFFSET) & MASK as u32) != 0
636        };
637        CC3ER { bits }
638    }
639    #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
640    #[inline]
641    pub fn cc2np(&self) -> CC2NPR {
642        let bits = {
643            const MASK: bool = true;
644            const OFFSET: u8 = 7;
645            ((self.bits >> OFFSET) & MASK as u32) != 0
646        };
647        CC2NPR { bits }
648    }
649    #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
650    #[inline]
651    pub fn cc2p(&self) -> CC2PR {
652        let bits = {
653            const MASK: bool = true;
654            const OFFSET: u8 = 5;
655            ((self.bits >> OFFSET) & MASK as u32) != 0
656        };
657        CC2PR { bits }
658    }
659    #[doc = "Bit 4 - Capture/Compare 2 output enable"]
660    #[inline]
661    pub fn cc2e(&self) -> CC2ER {
662        let bits = {
663            const MASK: bool = true;
664            const OFFSET: u8 = 4;
665            ((self.bits >> OFFSET) & MASK as u32) != 0
666        };
667        CC2ER { bits }
668    }
669    #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
670    #[inline]
671    pub fn cc1np(&self) -> CC1NPR {
672        let bits = {
673            const MASK: bool = true;
674            const OFFSET: u8 = 3;
675            ((self.bits >> OFFSET) & MASK as u32) != 0
676        };
677        CC1NPR { bits }
678    }
679    #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
680    #[inline]
681    pub fn cc1p(&self) -> CC1PR {
682        let bits = {
683            const MASK: bool = true;
684            const OFFSET: u8 = 1;
685            ((self.bits >> OFFSET) & MASK as u32) != 0
686        };
687        CC1PR { bits }
688    }
689    #[doc = "Bit 0 - Capture/Compare 1 output enable"]
690    #[inline]
691    pub fn cc1e(&self) -> CC1ER {
692        let bits = {
693            const MASK: bool = true;
694            const OFFSET: u8 = 0;
695            ((self.bits >> OFFSET) & MASK as u32) != 0
696        };
697        CC1ER { bits }
698    }
699}
700impl W {
701    #[doc = r" Reset value of the register"]
702    #[inline]
703    pub fn reset_value() -> W {
704        W { bits: 0 }
705    }
706    #[doc = r" Writes raw bits to the register"]
707    #[inline]
708    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
709        self.bits = bits;
710        self
711    }
712    #[doc = "Bit 15 - Capture/Compare 4 output Polarity"]
713    #[inline]
714    pub fn cc4np(&mut self) -> _CC4NPW {
715        _CC4NPW { w: self }
716    }
717    #[doc = "Bit 13 - Capture/Compare 3 output Polarity"]
718    #[inline]
719    pub fn cc4p(&mut self) -> _CC4PW {
720        _CC4PW { w: self }
721    }
722    #[doc = "Bit 12 - Capture/Compare 4 output enable"]
723    #[inline]
724    pub fn cc4e(&mut self) -> _CC4EW {
725        _CC4EW { w: self }
726    }
727    #[doc = "Bit 11 - Capture/Compare 3 output Polarity"]
728    #[inline]
729    pub fn cc3np(&mut self) -> _CC3NPW {
730        _CC3NPW { w: self }
731    }
732    #[doc = "Bit 9 - Capture/Compare 3 output Polarity"]
733    #[inline]
734    pub fn cc3p(&mut self) -> _CC3PW {
735        _CC3PW { w: self }
736    }
737    #[doc = "Bit 8 - Capture/Compare 3 output enable"]
738    #[inline]
739    pub fn cc3e(&mut self) -> _CC3EW {
740        _CC3EW { w: self }
741    }
742    #[doc = "Bit 7 - Capture/Compare 2 output Polarity"]
743    #[inline]
744    pub fn cc2np(&mut self) -> _CC2NPW {
745        _CC2NPW { w: self }
746    }
747    #[doc = "Bit 5 - Capture/Compare 2 output Polarity"]
748    #[inline]
749    pub fn cc2p(&mut self) -> _CC2PW {
750        _CC2PW { w: self }
751    }
752    #[doc = "Bit 4 - Capture/Compare 2 output enable"]
753    #[inline]
754    pub fn cc2e(&mut self) -> _CC2EW {
755        _CC2EW { w: self }
756    }
757    #[doc = "Bit 3 - Capture/Compare 1 output Polarity"]
758    #[inline]
759    pub fn cc1np(&mut self) -> _CC1NPW {
760        _CC1NPW { w: self }
761    }
762    #[doc = "Bit 1 - Capture/Compare 1 output Polarity"]
763    #[inline]
764    pub fn cc1p(&mut self) -> _CC1PW {
765        _CC1PW { w: self }
766    }
767    #[doc = "Bit 0 - Capture/Compare 1 output enable"]
768    #[inline]
769    pub fn cc1e(&mut self) -> _CC1EW {
770        _CC1EW { w: self }
771    }
772}
stm32l4x2_pac/tim2/ccer.rs

stm32l4x2_pac/tim2/
ccer.rs
