stm32h7 0.16.0

Device support crates for STM32H7 devices
Documentation 
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
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246

///Register `K0LR` writer
pub type W = crate::W<K0LRrs>;
///Field `b224` writer - b224
pub type B224_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b225` writer - b225
pub type B225_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b226` writer - b226
pub type B226_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b227` writer - b227
pub type B227_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b228` writer - b228
pub type B228_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b229` writer - b229
pub type B229_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b230` writer - b230
pub type B230_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b231` writer - b231
pub type B231_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b232` writer - b232
pub type B232_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b233` writer - b233
pub type B233_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b234` writer - b234
pub type B234_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b235` writer - b235
pub type B235_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b236` writer - b236
pub type B236_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b237` writer - b237
pub type B237_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b238` writer - b238
pub type B238_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b239` writer - b239
pub type B239_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b240` writer - b240
pub type B240_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b241` writer - b241
pub type B241_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b242` writer - b242
pub type B242_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b243` writer - b243
pub type B243_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b244` writer - b244
pub type B244_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b245` writer - b245
pub type B245_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b246` writer - b246
pub type B246_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b247` writer - b247
pub type B247_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b248` writer - b248
pub type B248_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b249` writer - b249
pub type B249_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b250` writer - b250
pub type B250_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b251` writer - b251
pub type B251_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b252` writer - b252
pub type B252_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b253` writer - b253
pub type B253_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b254` writer - b254
pub type B254_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b255` writer - b255
pub type B255_W<'a, REG> = crate::BitWriter<'a, REG>;
impl core::fmt::Debug for crate::generic::Reg<K0LRrs> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "(not readable)")
    }
}
impl W {
    ///Bit 0 - b224
    #[inline(always)]
    pub fn b224(&mut self) -> B224_W<K0LRrs> {
        B224_W::new(self, 0)
    }
    ///Bit 1 - b225
    #[inline(always)]
    pub fn b225(&mut self) -> B225_W<K0LRrs> {
        B225_W::new(self, 1)
    }
    ///Bit 2 - b226
    #[inline(always)]
    pub fn b226(&mut self) -> B226_W<K0LRrs> {
        B226_W::new(self, 2)
    }
    ///Bit 3 - b227
    #[inline(always)]
    pub fn b227(&mut self) -> B227_W<K0LRrs> {
        B227_W::new(self, 3)
    }
    ///Bit 4 - b228
    #[inline(always)]
    pub fn b228(&mut self) -> B228_W<K0LRrs> {
        B228_W::new(self, 4)
    }
    ///Bit 5 - b229
    #[inline(always)]
    pub fn b229(&mut self) -> B229_W<K0LRrs> {
        B229_W::new(self, 5)
    }
    ///Bit 6 - b230
    #[inline(always)]
    pub fn b230(&mut self) -> B230_W<K0LRrs> {
        B230_W::new(self, 6)
    }
    ///Bit 7 - b231
    #[inline(always)]
    pub fn b231(&mut self) -> B231_W<K0LRrs> {
        B231_W::new(self, 7)
    }
    ///Bit 8 - b232
    #[inline(always)]
    pub fn b232(&mut self) -> B232_W<K0LRrs> {
        B232_W::new(self, 8)
    }
    ///Bit 9 - b233
    #[inline(always)]
    pub fn b233(&mut self) -> B233_W<K0LRrs> {
        B233_W::new(self, 9)
    }
    ///Bit 10 - b234
    #[inline(always)]
    pub fn b234(&mut self) -> B234_W<K0LRrs> {
        B234_W::new(self, 10)
    }
    ///Bit 11 - b235
    #[inline(always)]
    pub fn b235(&mut self) -> B235_W<K0LRrs> {
        B235_W::new(self, 11)
    }
    ///Bit 12 - b236
    #[inline(always)]
    pub fn b236(&mut self) -> B236_W<K0LRrs> {
        B236_W::new(self, 12)
    }
    ///Bit 13 - b237
    #[inline(always)]
    pub fn b237(&mut self) -> B237_W<K0LRrs> {
        B237_W::new(self, 13)
    }
    ///Bit 14 - b238
    #[inline(always)]
    pub fn b238(&mut self) -> B238_W<K0LRrs> {
        B238_W::new(self, 14)
    }
    ///Bit 15 - b239
    #[inline(always)]
    pub fn b239(&mut self) -> B239_W<K0LRrs> {
        B239_W::new(self, 15)
    }
    ///Bit 16 - b240
    #[inline(always)]
    pub fn b240(&mut self) -> B240_W<K0LRrs> {
        B240_W::new(self, 16)
    }
    ///Bit 17 - b241
    #[inline(always)]
    pub fn b241(&mut self) -> B241_W<K0LRrs> {
        B241_W::new(self, 17)
    }
    ///Bit 18 - b242
    #[inline(always)]
    pub fn b242(&mut self) -> B242_W<K0LRrs> {
        B242_W::new(self, 18)
    }
    ///Bit 19 - b243
    #[inline(always)]
    pub fn b243(&mut self) -> B243_W<K0LRrs> {
        B243_W::new(self, 19)
    }
    ///Bit 20 - b244
    #[inline(always)]
    pub fn b244(&mut self) -> B244_W<K0LRrs> {
        B244_W::new(self, 20)
    }
    ///Bit 21 - b245
    #[inline(always)]
    pub fn b245(&mut self) -> B245_W<K0LRrs> {
        B245_W::new(self, 21)
    }
    ///Bit 22 - b246
    #[inline(always)]
    pub fn b246(&mut self) -> B246_W<K0LRrs> {
        B246_W::new(self, 22)
    }
    ///Bit 23 - b247
    #[inline(always)]
    pub fn b247(&mut self) -> B247_W<K0LRrs> {
        B247_W::new(self, 23)
    }
    ///Bit 24 - b248
    #[inline(always)]
    pub fn b248(&mut self) -> B248_W<K0LRrs> {
        B248_W::new(self, 24)
    }
    ///Bit 25 - b249
    #[inline(always)]
    pub fn b249(&mut self) -> B249_W<K0LRrs> {
        B249_W::new(self, 25)
    }
    ///Bit 26 - b250
    #[inline(always)]
    pub fn b250(&mut self) -> B250_W<K0LRrs> {
        B250_W::new(self, 26)
    }
    ///Bit 27 - b251
    #[inline(always)]
    pub fn b251(&mut self) -> B251_W<K0LRrs> {
        B251_W::new(self, 27)
    }
    ///Bit 28 - b252
    #[inline(always)]
    pub fn b252(&mut self) -> B252_W<K0LRrs> {
        B252_W::new(self, 28)
    }
    ///Bit 29 - b253
    #[inline(always)]
    pub fn b253(&mut self) -> B253_W<K0LRrs> {
        B253_W::new(self, 29)
    }
    ///Bit 30 - b254
    #[inline(always)]
    pub fn b254(&mut self) -> B254_W<K0LRrs> {
        B254_W::new(self, 30)
    }
    ///Bit 31 - b255
    #[inline(always)]
    pub fn b255(&mut self) -> B255_W<K0LRrs> {
        B255_W::new(self, 31)
    }
}
/**key registers

You can [`reset`](crate::Reg::reset), [`write`](crate::Reg::write), [`write_with_zero`](crate::Reg::write_with_zero) this register using [`k0lr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api).*/
pub struct K0LRrs;
impl crate::RegisterSpec for K0LRrs {
    type Ux = u32;
}
///`write(|w| ..)` method takes [`k0lr::W`](W) writer structure
impl crate::Writable for K0LRrs {
    type Safety = crate::Unsafe;
}
///`reset()` method sets K0LR to value 0
impl crate::Resettable for K0LRrs {}