1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
///Register `APB1HENR` reader
pub type R = crate::R<APB1HENRrs>;
///Register `APB1HENR` writer
pub type W = crate::W<APB1HENRrs>;
/**Clock Recovery System peripheral clock enable
Value on reset: 0*/
#[cfg_attr(feature = "defmt", derive(defmt::Format))]
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum CRSEN {
///0: The selected clock is disabled
Disabled = 0,
///1: The selected clock is enabled
Enabled = 1,
}
impl From<CRSEN> for bool {
#[inline(always)]
fn from(variant: CRSEN) -> Self {
variant as u8 != 0
}
}
///Field `CRSEN` reader - Clock Recovery System peripheral clock enable
pub type CRSEN_R = crate::BitReader<CRSEN>;
impl CRSEN_R {
///Get enumerated values variant
#[inline(always)]
pub const fn variant(&self) -> CRSEN {
match self.bits {
false => CRSEN::Disabled,
true => CRSEN::Enabled,
}
}
///The selected clock is disabled
#[inline(always)]
pub fn is_disabled(&self) -> bool {
*self == CRSEN::Disabled
}
///The selected clock is enabled
#[inline(always)]
pub fn is_enabled(&self) -> bool {
*self == CRSEN::Enabled
}
}
///Field `CRSEN` writer - Clock Recovery System peripheral clock enable
pub type CRSEN_W<'a, REG> = crate::BitWriter<'a, REG, CRSEN>;
impl<'a, REG> CRSEN_W<'a, REG>
where
REG: crate::Writable + crate::RegisterSpec,
{
///The selected clock is disabled
#[inline(always)]
pub fn disabled(self) -> &'a mut crate::W<REG> {
self.variant(CRSEN::Disabled)
}
///The selected clock is enabled
#[inline(always)]
pub fn enabled(self) -> &'a mut crate::W<REG> {
self.variant(CRSEN::Enabled)
}
}
///Field `SWPMIEN` reader - SWPMI Peripheral Clocks Enable
pub use CRSEN_R as SWPMIEN_R;
///Field `OPAMPEN` reader - OPAMP peripheral clock enable
pub use CRSEN_R as OPAMPEN_R;
///Field `MDIOSEN` reader - MDIOS peripheral clock enable
pub use CRSEN_R as MDIOSEN_R;
///Field `FDCANEN` reader - FDCAN Peripheral Clocks Enable
pub use CRSEN_R as FDCANEN_R;
///Field `TIM23EN` reader - TIM23 Peripheral Clocks Enable
pub use CRSEN_R as TIM23EN_R;
///Field `TIM24EN` reader - TIM24 Peripheral Clocks Enable
pub use CRSEN_R as TIM24EN_R;
///Field `SWPMIEN` writer - SWPMI Peripheral Clocks Enable
pub use CRSEN_W as SWPMIEN_W;
///Field `OPAMPEN` writer - OPAMP peripheral clock enable
pub use CRSEN_W as OPAMPEN_W;
///Field `MDIOSEN` writer - MDIOS peripheral clock enable
pub use CRSEN_W as MDIOSEN_W;
///Field `FDCANEN` writer - FDCAN Peripheral Clocks Enable
pub use CRSEN_W as FDCANEN_W;
///Field `TIM23EN` writer - TIM23 Peripheral Clocks Enable
pub use CRSEN_W as TIM23EN_W;
///Field `TIM24EN` writer - TIM24 Peripheral Clocks Enable
pub use CRSEN_W as TIM24EN_W;
impl R {
///Bit 1 - Clock Recovery System peripheral clock enable
#[inline(always)]
pub fn crsen(&self) -> CRSEN_R {
CRSEN_R::new(((self.bits >> 1) & 1) != 0)
}
///Bit 2 - SWPMI Peripheral Clocks Enable
#[inline(always)]
pub fn swpmien(&self) -> SWPMIEN_R {
SWPMIEN_R::new(((self.bits >> 2) & 1) != 0)
}
///Bit 4 - OPAMP peripheral clock enable
#[inline(always)]
pub fn opampen(&self) -> OPAMPEN_R {
OPAMPEN_R::new(((self.bits >> 4) & 1) != 0)
}
///Bit 5 - MDIOS peripheral clock enable
#[inline(always)]
pub fn mdiosen(&self) -> MDIOSEN_R {
MDIOSEN_R::new(((self.bits >> 5) & 1) != 0)
}
///Bit 8 - FDCAN Peripheral Clocks Enable
#[inline(always)]
pub fn fdcanen(&self) -> FDCANEN_R {
FDCANEN_R::new(((self.bits >> 8) & 1) != 0)
}
///Bit 24 - TIM23 Peripheral Clocks Enable
#[inline(always)]
pub fn tim23en(&self) -> TIM23EN_R {
TIM23EN_R::new(((self.bits >> 24) & 1) != 0)
}
///Bit 25 - TIM24 Peripheral Clocks Enable
#[inline(always)]
pub fn tim24en(&self) -> TIM24EN_R {
TIM24EN_R::new(((self.bits >> 25) & 1) != 0)
}
}
impl core::fmt::Debug for R {
fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
f.debug_struct("APB1HENR")
.field("crsen", &self.crsen())
.field("swpmien", &self.swpmien())
.field("opampen", &self.opampen())
.field("mdiosen", &self.mdiosen())
.field("fdcanen", &self.fdcanen())
.field("tim23en", &self.tim23en())
.field("tim24en", &self.tim24en())
.finish()
}
}
impl W {
///Bit 1 - Clock Recovery System peripheral clock enable
#[inline(always)]
pub fn crsen(&mut self) -> CRSEN_W<APB1HENRrs> {
CRSEN_W::new(self, 1)
}
///Bit 2 - SWPMI Peripheral Clocks Enable
#[inline(always)]
pub fn swpmien(&mut self) -> SWPMIEN_W<APB1HENRrs> {
SWPMIEN_W::new(self, 2)
}
///Bit 4 - OPAMP peripheral clock enable
#[inline(always)]
pub fn opampen(&mut self) -> OPAMPEN_W<APB1HENRrs> {
OPAMPEN_W::new(self, 4)
}
///Bit 5 - MDIOS peripheral clock enable
#[inline(always)]
pub fn mdiosen(&mut self) -> MDIOSEN_W<APB1HENRrs> {
MDIOSEN_W::new(self, 5)
}
///Bit 8 - FDCAN Peripheral Clocks Enable
#[inline(always)]
pub fn fdcanen(&mut self) -> FDCANEN_W<APB1HENRrs> {
FDCANEN_W::new(self, 8)
}
///Bit 24 - TIM23 Peripheral Clocks Enable
#[inline(always)]
pub fn tim23en(&mut self) -> TIM23EN_W<APB1HENRrs> {
TIM23EN_W::new(self, 24)
}
///Bit 25 - TIM24 Peripheral Clocks Enable
#[inline(always)]
pub fn tim24en(&mut self) -> TIM24EN_W<APB1HENRrs> {
TIM24EN_W::new(self, 25)
}
}
/**RCC APB1 Clock Register
You can [`read`](crate::Reg::read) this register and get [`apb1henr::R`](R). You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`apb1henr::W`](W). You can also [`modify`](crate::Reg::modify) this register. See [API](https://docs.rs/svd2rust/#read--modify--write-api).*/
pub struct APB1HENRrs;
impl crate::RegisterSpec for APB1HENRrs {
type Ux = u32;
}
///`read()` method returns [`apb1henr::R`](R) reader structure
impl crate::Readable for APB1HENRrs {}
///`write(|w| ..)` method takes [`apb1henr::W`](W) writer structure
impl crate::Writable for APB1HENRrs {
type Safety = crate::Unsafe;
}
///`reset()` method sets APB1HENR to value 0
impl crate::Resettable for APB1HENRrs {}