py32f0/py32f002a/usart1/
cr3.rs

1///Register `CR3` reader
2pub struct R(crate::R<CR3_SPEC>);
3impl core::ops::Deref for R {
4    type Target = crate::R<CR3_SPEC>;
5    #[inline(always)]
6    fn deref(&self) -> &Self::Target {
7        &self.0
8    }
9}
10impl From<crate::R<CR3_SPEC>> for R {
11    #[inline(always)]
12    fn from(reader: crate::R<CR3_SPEC>) -> Self {
13        R(reader)
14    }
15}
16///Register `CR3` writer
17pub struct W(crate::W<CR3_SPEC>);
18impl core::ops::Deref for W {
19    type Target = crate::W<CR3_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<CR3_SPEC>> for W {
32    #[inline(always)]
33    fn from(writer: crate::W<CR3_SPEC>) -> Self {
34        W(writer)
35    }
36}
37///Field `EIE` reader - Error interrupt enable
38pub type EIE_R = crate::BitReader<EIE_A>;
39/**Error interrupt enable
40
41Value on reset: 0*/
42#[derive(Clone, Copy, Debug, PartialEq, Eq)]
43pub enum EIE_A {
44    ///0: Error interrupt disabled
45    Disabled = 0,
46    ///1: Error interrupt enabled
47    Enabled = 1,
48}
49impl From<EIE_A> for bool {
50    #[inline(always)]
51    fn from(variant: EIE_A) -> Self {
52        variant as u8 != 0
53    }
54}
55impl EIE_R {
56    ///Get enumerated values variant
57    #[inline(always)]
58    pub fn variant(&self) -> EIE_A {
59        match self.bits {
60            false => EIE_A::Disabled,
61            true => EIE_A::Enabled,
62        }
63    }
64    ///Checks if the value of the field is `Disabled`
65    #[inline(always)]
66    pub fn is_disabled(&self) -> bool {
67        *self == EIE_A::Disabled
68    }
69    ///Checks if the value of the field is `Enabled`
70    #[inline(always)]
71    pub fn is_enabled(&self) -> bool {
72        *self == EIE_A::Enabled
73    }
74}
75///Field `EIE` writer - Error interrupt enable
76pub type EIE_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, EIE_A, O>;
77impl<'a, const O: u8> EIE_W<'a, O> {
78    ///Error interrupt disabled
79    #[inline(always)]
80    pub fn disabled(self) -> &'a mut W {
81        self.variant(EIE_A::Disabled)
82    }
83    ///Error interrupt enabled
84    #[inline(always)]
85    pub fn enabled(self) -> &'a mut W {
86        self.variant(EIE_A::Enabled)
87    }
88}
89///Field `IREN` reader - IrDA mode enable
90pub type IREN_R = crate::BitReader<IREN_A>;
91/**IrDA mode enable
92
93Value on reset: 0*/
94#[derive(Clone, Copy, Debug, PartialEq, Eq)]
95pub enum IREN_A {
96    ///0: IrDA disabled
97    Disabled = 0,
98    ///1: IrDA enabled
99    Enabled = 1,
100}
101impl From<IREN_A> for bool {
102    #[inline(always)]
103    fn from(variant: IREN_A) -> Self {
104        variant as u8 != 0
105    }
106}
107impl IREN_R {
108    ///Get enumerated values variant
109    #[inline(always)]
110    pub fn variant(&self) -> IREN_A {
111        match self.bits {
112            false => IREN_A::Disabled,
113            true => IREN_A::Enabled,
114        }
115    }
116    ///Checks if the value of the field is `Disabled`
117    #[inline(always)]
118    pub fn is_disabled(&self) -> bool {
119        *self == IREN_A::Disabled
120    }
121    ///Checks if the value of the field is `Enabled`
122    #[inline(always)]
123    pub fn is_enabled(&self) -> bool {
124        *self == IREN_A::Enabled
125    }
126}
127///Field `IREN` writer - IrDA mode enable
128pub type IREN_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, IREN_A, O>;
129impl<'a, const O: u8> IREN_W<'a, O> {
130    ///IrDA disabled
131    #[inline(always)]
132    pub fn disabled(self) -> &'a mut W {
133        self.variant(IREN_A::Disabled)
134    }
135    ///IrDA enabled
136    #[inline(always)]
137    pub fn enabled(self) -> &'a mut W {
138        self.variant(IREN_A::Enabled)
139    }
140}
141///Field `IRLP` reader - IrDA low-power
142pub type IRLP_R = crate::BitReader<IRLP_A>;
143/**IrDA low-power
144
145Value on reset: 0*/
146#[derive(Clone, Copy, Debug, PartialEq, Eq)]
147pub enum IRLP_A {
148    ///0: Normal mode
149    Normal = 0,
150    ///1: Low-power mode
151    LowPower = 1,
152}
153impl From<IRLP_A> for bool {
154    #[inline(always)]
155    fn from(variant: IRLP_A) -> Self {
156        variant as u8 != 0
157    }
158}
159impl IRLP_R {
160    ///Get enumerated values variant
161    #[inline(always)]
162    pub fn variant(&self) -> IRLP_A {
163        match self.bits {
164            false => IRLP_A::Normal,
165            true => IRLP_A::LowPower,
166        }
167    }
168    ///Checks if the value of the field is `Normal`
169    #[inline(always)]
170    pub fn is_normal(&self) -> bool {
171        *self == IRLP_A::Normal
172    }
173    ///Checks if the value of the field is `LowPower`
174    #[inline(always)]
175    pub fn is_low_power(&self) -> bool {
176        *self == IRLP_A::LowPower
177    }
178}
179///Field `IRLP` writer - IrDA low-power
180pub type IRLP_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, IRLP_A, O>;
181impl<'a, const O: u8> IRLP_W<'a, O> {
182    ///Normal mode
183    #[inline(always)]
184    pub fn normal(self) -> &'a mut W {
185        self.variant(IRLP_A::Normal)
186    }
187    ///Low-power mode
188    #[inline(always)]
189    pub fn low_power(self) -> &'a mut W {
190        self.variant(IRLP_A::LowPower)
191    }
192}
193///Field `HDSEL` reader - Half-duplex selection
194pub type HDSEL_R = crate::BitReader<HDSEL_A>;
195/**Half-duplex selection
196
197Value on reset: 0*/
198#[derive(Clone, Copy, Debug, PartialEq, Eq)]
199pub enum HDSEL_A {
200    ///0: Half duplex mode is not selected
201    FullDuplex = 0,
202    ///1: Half duplex mode is selected
203    HalfDuplex = 1,
204}
205impl From<HDSEL_A> for bool {
206    #[inline(always)]
207    fn from(variant: HDSEL_A) -> Self {
208        variant as u8 != 0
209    }
210}
211impl HDSEL_R {
212    ///Get enumerated values variant
213    #[inline(always)]
214    pub fn variant(&self) -> HDSEL_A {
215        match self.bits {
216            false => HDSEL_A::FullDuplex,
217            true => HDSEL_A::HalfDuplex,
218        }
219    }
220    ///Checks if the value of the field is `FullDuplex`
221    #[inline(always)]
222    pub fn is_full_duplex(&self) -> bool {
223        *self == HDSEL_A::FullDuplex
224    }
225    ///Checks if the value of the field is `HalfDuplex`
226    #[inline(always)]
227    pub fn is_half_duplex(&self) -> bool {
228        *self == HDSEL_A::HalfDuplex
229    }
230}
231///Field `HDSEL` writer - Half-duplex selection
232pub type HDSEL_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, HDSEL_A, O>;
233impl<'a, const O: u8> HDSEL_W<'a, O> {
234    ///Half duplex mode is not selected
235    #[inline(always)]
236    pub fn full_duplex(self) -> &'a mut W {
237        self.variant(HDSEL_A::FullDuplex)
238    }
239    ///Half duplex mode is selected
240    #[inline(always)]
241    pub fn half_duplex(self) -> &'a mut W {
242        self.variant(HDSEL_A::HalfDuplex)
243    }
244}
245///Field `RTSE` reader - RTS enable
246pub type RTSE_R = crate::BitReader<RTSE_A>;
247/**RTS enable
248
249Value on reset: 0*/
250#[derive(Clone, Copy, Debug, PartialEq, Eq)]
251pub enum RTSE_A {
252    ///0: RTS hardware flow control disabled
253    Disabled = 0,
254    ///1: RTS hardware flow control enabled
255    Enabled = 1,
256}
257impl From<RTSE_A> for bool {
258    #[inline(always)]
259    fn from(variant: RTSE_A) -> Self {
260        variant as u8 != 0
261    }
262}
263impl RTSE_R {
264    ///Get enumerated values variant
265    #[inline(always)]
266    pub fn variant(&self) -> RTSE_A {
267        match self.bits {
268            false => RTSE_A::Disabled,
269            true => RTSE_A::Enabled,
270        }
271    }
272    ///Checks if the value of the field is `Disabled`
273    #[inline(always)]
274    pub fn is_disabled(&self) -> bool {
275        *self == RTSE_A::Disabled
276    }
277    ///Checks if the value of the field is `Enabled`
278    #[inline(always)]
279    pub fn is_enabled(&self) -> bool {
280        *self == RTSE_A::Enabled
281    }
282}
283///Field `RTSE` writer - RTS enable
284pub type RTSE_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, RTSE_A, O>;
285impl<'a, const O: u8> RTSE_W<'a, O> {
286    ///RTS hardware flow control disabled
287    #[inline(always)]
288    pub fn disabled(self) -> &'a mut W {
289        self.variant(RTSE_A::Disabled)
290    }
291    ///RTS hardware flow control enabled
292    #[inline(always)]
293    pub fn enabled(self) -> &'a mut W {
294        self.variant(RTSE_A::Enabled)
295    }
296}
297///Field `CTSE` reader - CTS enable
298pub type CTSE_R = crate::BitReader<CTSE_A>;
299/**CTS enable
300
301Value on reset: 0*/
302#[derive(Clone, Copy, Debug, PartialEq, Eq)]
303pub enum CTSE_A {
304    ///0: CTS hardware flow control disabled
305    Disabled = 0,
306    ///1: CTS hardware flow control enabled
307    Enabled = 1,
308}
309impl From<CTSE_A> for bool {
310    #[inline(always)]
311    fn from(variant: CTSE_A) -> Self {
312        variant as u8 != 0
313    }
314}
315impl CTSE_R {
316    ///Get enumerated values variant
317    #[inline(always)]
318    pub fn variant(&self) -> CTSE_A {
319        match self.bits {
320            false => CTSE_A::Disabled,
321            true => CTSE_A::Enabled,
322        }
323    }
324    ///Checks if the value of the field is `Disabled`
325    #[inline(always)]
326    pub fn is_disabled(&self) -> bool {
327        *self == CTSE_A::Disabled
328    }
329    ///Checks if the value of the field is `Enabled`
330    #[inline(always)]
331    pub fn is_enabled(&self) -> bool {
332        *self == CTSE_A::Enabled
333    }
334}
335///Field `CTSE` writer - CTS enable
336pub type CTSE_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, CTSE_A, O>;
337impl<'a, const O: u8> CTSE_W<'a, O> {
338    ///CTS hardware flow control disabled
339    #[inline(always)]
340    pub fn disabled(self) -> &'a mut W {
341        self.variant(CTSE_A::Disabled)
342    }
343    ///CTS hardware flow control enabled
344    #[inline(always)]
345    pub fn enabled(self) -> &'a mut W {
346        self.variant(CTSE_A::Enabled)
347    }
348}
349///Field `CTSIE` reader - CTS interrupt enable
350pub type CTSIE_R = crate::BitReader<CTSIE_A>;
351/**CTS interrupt enable
352
353Value on reset: 0*/
354#[derive(Clone, Copy, Debug, PartialEq, Eq)]
355pub enum CTSIE_A {
356    ///0: CTS interrupt disabled
357    Disabled = 0,
358    ///1: CTS interrupt enabled
359    Enabled = 1,
360}
361impl From<CTSIE_A> for bool {
362    #[inline(always)]
363    fn from(variant: CTSIE_A) -> Self {
364        variant as u8 != 0
365    }
366}
367impl CTSIE_R {
368    ///Get enumerated values variant
369    #[inline(always)]
370    pub fn variant(&self) -> CTSIE_A {
371        match self.bits {
372            false => CTSIE_A::Disabled,
373            true => CTSIE_A::Enabled,
374        }
375    }
376    ///Checks if the value of the field is `Disabled`
377    #[inline(always)]
378    pub fn is_disabled(&self) -> bool {
379        *self == CTSIE_A::Disabled
380    }
381    ///Checks if the value of the field is `Enabled`
382    #[inline(always)]
383    pub fn is_enabled(&self) -> bool {
384        *self == CTSIE_A::Enabled
385    }
386}
387///Field `CTSIE` writer - CTS interrupt enable
388pub type CTSIE_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, CTSIE_A, O>;
389impl<'a, const O: u8> CTSIE_W<'a, O> {
390    ///CTS interrupt disabled
391    #[inline(always)]
392    pub fn disabled(self) -> &'a mut W {
393        self.variant(CTSIE_A::Disabled)
394    }
395    ///CTS interrupt enabled
396    #[inline(always)]
397    pub fn enabled(self) -> &'a mut W {
398        self.variant(CTSIE_A::Enabled)
399    }
400}
401///Field `OVER8` reader - Oversampling mode
402pub type OVER8_R = crate::BitReader<OVER8_A>;
403/**Oversampling mode
404
405Value on reset: 0*/
406#[derive(Clone, Copy, Debug, PartialEq, Eq)]
407pub enum OVER8_A {
408    ///0: Oversampling by 16
409    Oversampling16 = 0,
410    ///1: Oversampling by 8
411    Oversampling8 = 1,
412}
413impl From<OVER8_A> for bool {
414    #[inline(always)]
415    fn from(variant: OVER8_A) -> Self {
416        variant as u8 != 0
417    }
418}
419impl OVER8_R {
420    ///Get enumerated values variant
421    #[inline(always)]
422    pub fn variant(&self) -> OVER8_A {
423        match self.bits {
424            false => OVER8_A::Oversampling16,
425            true => OVER8_A::Oversampling8,
426        }
427    }
428    ///Checks if the value of the field is `Oversampling16`
429    #[inline(always)]
430    pub fn is_oversampling16(&self) -> bool {
431        *self == OVER8_A::Oversampling16
432    }
433    ///Checks if the value of the field is `Oversampling8`
434    #[inline(always)]
435    pub fn is_oversampling8(&self) -> bool {
436        *self == OVER8_A::Oversampling8
437    }
438}
439///Field `OVER8` writer - Oversampling mode
440pub type OVER8_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, OVER8_A, O>;
441impl<'a, const O: u8> OVER8_W<'a, O> {
442    ///Oversampling by 16
443    #[inline(always)]
444    pub fn oversampling16(self) -> &'a mut W {
445        self.variant(OVER8_A::Oversampling16)
446    }
447    ///Oversampling by 8
448    #[inline(always)]
449    pub fn oversampling8(self) -> &'a mut W {
450        self.variant(OVER8_A::Oversampling8)
451    }
452}
453///Field `ABREN` reader - Auto baudrate enable
454pub type ABREN_R = crate::BitReader<ABREN_A>;
455/**Auto baudrate enable
456
457Value on reset: 0*/
458#[derive(Clone, Copy, Debug, PartialEq, Eq)]
459pub enum ABREN_A {
460    ///0: Auto baud rate detection is disabled
461    Disabled = 0,
462    ///1: Auto baud rate detection is enabled
463    Enabled = 1,
464}
465impl From<ABREN_A> for bool {
466    #[inline(always)]
467    fn from(variant: ABREN_A) -> Self {
468        variant as u8 != 0
469    }
470}
471impl ABREN_R {
472    ///Get enumerated values variant
473    #[inline(always)]
474    pub fn variant(&self) -> ABREN_A {
475        match self.bits {
476            false => ABREN_A::Disabled,
477            true => ABREN_A::Enabled,
478        }
479    }
480    ///Checks if the value of the field is `Disabled`
481    #[inline(always)]
482    pub fn is_disabled(&self) -> bool {
483        *self == ABREN_A::Disabled
484    }
485    ///Checks if the value of the field is `Enabled`
486    #[inline(always)]
487    pub fn is_enabled(&self) -> bool {
488        *self == ABREN_A::Enabled
489    }
490}
491///Field `ABREN` writer - Auto baudrate enable
492pub type ABREN_W<'a, const O: u8> = crate::BitWriter<'a, u32, CR3_SPEC, ABREN_A, O>;
493impl<'a, const O: u8> ABREN_W<'a, O> {
494    ///Auto baud rate detection is disabled
495    #[inline(always)]
496    pub fn disabled(self) -> &'a mut W {
497        self.variant(ABREN_A::Disabled)
498    }
499    ///Auto baud rate detection is enabled
500    #[inline(always)]
501    pub fn enabled(self) -> &'a mut W {
502        self.variant(ABREN_A::Enabled)
503    }
504}
505///Field `ABRMOD` reader - Auto baudrate mode
506pub type ABRMOD_R = crate::FieldReader<u8, ABRMOD_A>;
507/**Auto baudrate mode
508
509Value on reset: 0*/
510#[derive(Clone, Copy, Debug, PartialEq, Eq)]
511#[repr(u8)]
512pub enum ABRMOD_A {
513    ///0: Measurement of the start bit is used to detect the baud rate
514    Start = 0,
515    ///1: Falling edge to falling edge measurement
516    Edge = 1,
517    ///2: Reserved
518    Reserved1 = 2,
519    ///3: Reserved
520    Reserved2 = 3,
521}
522impl From<ABRMOD_A> for u8 {
523    #[inline(always)]
524    fn from(variant: ABRMOD_A) -> Self {
525        variant as _
526    }
527}
528impl ABRMOD_R {
529    ///Get enumerated values variant
530    #[inline(always)]
531    pub fn variant(&self) -> ABRMOD_A {
532        match self.bits {
533            0 => ABRMOD_A::Start,
534            1 => ABRMOD_A::Edge,
535            2 => ABRMOD_A::Reserved1,
536            3 => ABRMOD_A::Reserved2,
537            _ => unreachable!(),
538        }
539    }
540    ///Checks if the value of the field is `Start`
541    #[inline(always)]
542    pub fn is_start(&self) -> bool {
543        *self == ABRMOD_A::Start
544    }
545    ///Checks if the value of the field is `Edge`
546    #[inline(always)]
547    pub fn is_edge(&self) -> bool {
548        *self == ABRMOD_A::Edge
549    }
550    ///Checks if the value of the field is `Reserved1`
551    #[inline(always)]
552    pub fn is_reserved1(&self) -> bool {
553        *self == ABRMOD_A::Reserved1
554    }
555    ///Checks if the value of the field is `Reserved2`
556    #[inline(always)]
557    pub fn is_reserved2(&self) -> bool {
558        *self == ABRMOD_A::Reserved2
559    }
560}
561///Field `ABRMOD` writer - Auto baudrate mode
562pub type ABRMOD_W<'a, const O: u8> = crate::FieldWriterSafe<'a, u32, CR3_SPEC, u8, ABRMOD_A, 2, O>;
563impl<'a, const O: u8> ABRMOD_W<'a, O> {
564    ///Measurement of the start bit is used to detect the baud rate
565    #[inline(always)]
566    pub fn start(self) -> &'a mut W {
567        self.variant(ABRMOD_A::Start)
568    }
569    ///Falling edge to falling edge measurement
570    #[inline(always)]
571    pub fn edge(self) -> &'a mut W {
572        self.variant(ABRMOD_A::Edge)
573    }
574    ///Reserved
575    #[inline(always)]
576    pub fn reserved1(self) -> &'a mut W {
577        self.variant(ABRMOD_A::Reserved1)
578    }
579    ///Reserved
580    #[inline(always)]
581    pub fn reserved2(self) -> &'a mut W {
582        self.variant(ABRMOD_A::Reserved2)
583    }
584}
585impl R {
586    ///Bit 0 - Error interrupt enable
587    #[inline(always)]
588    pub fn eie(&self) -> EIE_R {
589        EIE_R::new((self.bits & 1) != 0)
590    }
591    ///Bit 1 - IrDA mode enable
592    #[inline(always)]
593    pub fn iren(&self) -> IREN_R {
594        IREN_R::new(((self.bits >> 1) & 1) != 0)
595    }
596    ///Bit 2 - IrDA low-power
597    #[inline(always)]
598    pub fn irlp(&self) -> IRLP_R {
599        IRLP_R::new(((self.bits >> 2) & 1) != 0)
600    }
601    ///Bit 3 - Half-duplex selection
602    #[inline(always)]
603    pub fn hdsel(&self) -> HDSEL_R {
604        HDSEL_R::new(((self.bits >> 3) & 1) != 0)
605    }
606    ///Bit 8 - RTS enable
607    #[inline(always)]
608    pub fn rtse(&self) -> RTSE_R {
609        RTSE_R::new(((self.bits >> 8) & 1) != 0)
610    }
611    ///Bit 9 - CTS enable
612    #[inline(always)]
613    pub fn ctse(&self) -> CTSE_R {
614        CTSE_R::new(((self.bits >> 9) & 1) != 0)
615    }
616    ///Bit 10 - CTS interrupt enable
617    #[inline(always)]
618    pub fn ctsie(&self) -> CTSIE_R {
619        CTSIE_R::new(((self.bits >> 10) & 1) != 0)
620    }
621    ///Bit 11 - Oversampling mode
622    #[inline(always)]
623    pub fn over8(&self) -> OVER8_R {
624        OVER8_R::new(((self.bits >> 11) & 1) != 0)
625    }
626    ///Bit 12 - Auto baudrate enable
627    #[inline(always)]
628    pub fn abren(&self) -> ABREN_R {
629        ABREN_R::new(((self.bits >> 12) & 1) != 0)
630    }
631    ///Bits 13:14 - Auto baudrate mode
632    #[inline(always)]
633    pub fn abrmod(&self) -> ABRMOD_R {
634        ABRMOD_R::new(((self.bits >> 13) & 3) as u8)
635    }
636}
637impl W {
638    ///Bit 0 - Error interrupt enable
639    #[inline(always)]
640    #[must_use]
641    pub fn eie(&mut self) -> EIE_W<0> {
642        EIE_W::new(self)
643    }
644    ///Bit 1 - IrDA mode enable
645    #[inline(always)]
646    #[must_use]
647    pub fn iren(&mut self) -> IREN_W<1> {
648        IREN_W::new(self)
649    }
650    ///Bit 2 - IrDA low-power
651    #[inline(always)]
652    #[must_use]
653    pub fn irlp(&mut self) -> IRLP_W<2> {
654        IRLP_W::new(self)
655    }
656    ///Bit 3 - Half-duplex selection
657    #[inline(always)]
658    #[must_use]
659    pub fn hdsel(&mut self) -> HDSEL_W<3> {
660        HDSEL_W::new(self)
661    }
662    ///Bit 8 - RTS enable
663    #[inline(always)]
664    #[must_use]
665    pub fn rtse(&mut self) -> RTSE_W<8> {
666        RTSE_W::new(self)
667    }
668    ///Bit 9 - CTS enable
669    #[inline(always)]
670    #[must_use]
671    pub fn ctse(&mut self) -> CTSE_W<9> {
672        CTSE_W::new(self)
673    }
674    ///Bit 10 - CTS interrupt enable
675    #[inline(always)]
676    #[must_use]
677    pub fn ctsie(&mut self) -> CTSIE_W<10> {
678        CTSIE_W::new(self)
679    }
680    ///Bit 11 - Oversampling mode
681    #[inline(always)]
682    #[must_use]
683    pub fn over8(&mut self) -> OVER8_W<11> {
684        OVER8_W::new(self)
685    }
686    ///Bit 12 - Auto baudrate enable
687    #[inline(always)]
688    #[must_use]
689    pub fn abren(&mut self) -> ABREN_W<12> {
690        ABREN_W::new(self)
691    }
692    ///Bits 13:14 - Auto baudrate mode
693    #[inline(always)]
694    #[must_use]
695    pub fn abrmod(&mut self) -> ABRMOD_W<13> {
696        ABRMOD_W::new(self)
697    }
698    ///Writes raw bits to the register.
699    #[inline(always)]
700    pub unsafe fn bits(&mut self, bits: u32) -> &mut Self {
701        self.0.bits(bits);
702        self
703    }
704}
705/**Control register 3
706
707This 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).
708
709For information about available fields see [cr3](index.html) module*/
710pub struct CR3_SPEC;
711impl crate::RegisterSpec for CR3_SPEC {
712    type Ux = u32;
713}
714///`read()` method returns [cr3::R](R) reader structure
715impl crate::Readable for CR3_SPEC {
716    type Reader = R;
717}
718///`write(|w| ..)` method takes [cr3::W](W) writer structure
719impl crate::Writable for CR3_SPEC {
720    type Writer = W;
721    const ZERO_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
722    const ONE_TO_MODIFY_FIELDS_BITMAP: Self::Ux = 0;
723}
724///`reset()` method sets CR3 to value 0
725impl crate::Resettable for CR3_SPEC {
726    const RESET_VALUE: Self::Ux = 0;
727}
py32f0/py32f002a/usart1/cr3.rs

py32f0/py32f002a/usart1/
cr3.rs
