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 `K1LR` writer
pub type W = crate::W<K1LRrs>;
///Field `b160` writer - b160
pub type B160_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b161` writer - b161
pub type B161_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b162` writer - b162
pub type B162_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b163` writer - b163
pub type B163_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b164` writer - b164
pub type B164_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b165` writer - b165
pub type B165_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b166` writer - b166
pub type B166_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b167` writer - b167
pub type B167_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b168` writer - b168
pub type B168_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b169` writer - b169
pub type B169_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b170` writer - b170
pub type B170_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b171` writer - b171
pub type B171_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b172` writer - b172
pub type B172_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b173` writer - b173
pub type B173_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b174` writer - b174
pub type B174_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b175` writer - b175
pub type B175_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b176` writer - b176
pub type B176_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b177` writer - b177
pub type B177_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b178` writer - b178
pub type B178_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b179` writer - b179
pub type B179_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b180` writer - b180
pub type B180_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b181` writer - b181
pub type B181_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b182` writer - b182
pub type B182_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b183` writer - b183
pub type B183_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b184` writer - b184
pub type B184_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b185` writer - b185
pub type B185_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b186` writer - b186
pub type B186_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b187` writer - b187
pub type B187_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b188` writer - b188
pub type B188_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b189` writer - b189
pub type B189_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b190` writer - b190
pub type B190_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b191` writer - b191
pub type B191_W<'a, REG> = crate::BitWriter<'a, REG>;
impl core::fmt::Debug for crate::generic::Reg<K1LRrs> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "(not readable)")
    }
}
impl W {
    ///Bit 0 - b160
    #[inline(always)]
    pub fn b160(&mut self) -> B160_W<K1LRrs> {
        B160_W::new(self, 0)
    }
    ///Bit 1 - b161
    #[inline(always)]
    pub fn b161(&mut self) -> B161_W<K1LRrs> {
        B161_W::new(self, 1)
    }
    ///Bit 2 - b162
    #[inline(always)]
    pub fn b162(&mut self) -> B162_W<K1LRrs> {
        B162_W::new(self, 2)
    }
    ///Bit 3 - b163
    #[inline(always)]
    pub fn b163(&mut self) -> B163_W<K1LRrs> {
        B163_W::new(self, 3)
    }
    ///Bit 4 - b164
    #[inline(always)]
    pub fn b164(&mut self) -> B164_W<K1LRrs> {
        B164_W::new(self, 4)
    }
    ///Bit 5 - b165
    #[inline(always)]
    pub fn b165(&mut self) -> B165_W<K1LRrs> {
        B165_W::new(self, 5)
    }
    ///Bit 6 - b166
    #[inline(always)]
    pub fn b166(&mut self) -> B166_W<K1LRrs> {
        B166_W::new(self, 6)
    }
    ///Bit 7 - b167
    #[inline(always)]
    pub fn b167(&mut self) -> B167_W<K1LRrs> {
        B167_W::new(self, 7)
    }
    ///Bit 8 - b168
    #[inline(always)]
    pub fn b168(&mut self) -> B168_W<K1LRrs> {
        B168_W::new(self, 8)
    }
    ///Bit 9 - b169
    #[inline(always)]
    pub fn b169(&mut self) -> B169_W<K1LRrs> {
        B169_W::new(self, 9)
    }
    ///Bit 10 - b170
    #[inline(always)]
    pub fn b170(&mut self) -> B170_W<K1LRrs> {
        B170_W::new(self, 10)
    }
    ///Bit 11 - b171
    #[inline(always)]
    pub fn b171(&mut self) -> B171_W<K1LRrs> {
        B171_W::new(self, 11)
    }
    ///Bit 12 - b172
    #[inline(always)]
    pub fn b172(&mut self) -> B172_W<K1LRrs> {
        B172_W::new(self, 12)
    }
    ///Bit 13 - b173
    #[inline(always)]
    pub fn b173(&mut self) -> B173_W<K1LRrs> {
        B173_W::new(self, 13)
    }
    ///Bit 14 - b174
    #[inline(always)]
    pub fn b174(&mut self) -> B174_W<K1LRrs> {
        B174_W::new(self, 14)
    }
    ///Bit 15 - b175
    #[inline(always)]
    pub fn b175(&mut self) -> B175_W<K1LRrs> {
        B175_W::new(self, 15)
    }
    ///Bit 16 - b176
    #[inline(always)]
    pub fn b176(&mut self) -> B176_W<K1LRrs> {
        B176_W::new(self, 16)
    }
    ///Bit 17 - b177
    #[inline(always)]
    pub fn b177(&mut self) -> B177_W<K1LRrs> {
        B177_W::new(self, 17)
    }
    ///Bit 18 - b178
    #[inline(always)]
    pub fn b178(&mut self) -> B178_W<K1LRrs> {
        B178_W::new(self, 18)
    }
    ///Bit 19 - b179
    #[inline(always)]
    pub fn b179(&mut self) -> B179_W<K1LRrs> {
        B179_W::new(self, 19)
    }
    ///Bit 20 - b180
    #[inline(always)]
    pub fn b180(&mut self) -> B180_W<K1LRrs> {
        B180_W::new(self, 20)
    }
    ///Bit 21 - b181
    #[inline(always)]
    pub fn b181(&mut self) -> B181_W<K1LRrs> {
        B181_W::new(self, 21)
    }
    ///Bit 22 - b182
    #[inline(always)]
    pub fn b182(&mut self) -> B182_W<K1LRrs> {
        B182_W::new(self, 22)
    }
    ///Bit 23 - b183
    #[inline(always)]
    pub fn b183(&mut self) -> B183_W<K1LRrs> {
        B183_W::new(self, 23)
    }
    ///Bit 24 - b184
    #[inline(always)]
    pub fn b184(&mut self) -> B184_W<K1LRrs> {
        B184_W::new(self, 24)
    }
    ///Bit 25 - b185
    #[inline(always)]
    pub fn b185(&mut self) -> B185_W<K1LRrs> {
        B185_W::new(self, 25)
    }
    ///Bit 26 - b186
    #[inline(always)]
    pub fn b186(&mut self) -> B186_W<K1LRrs> {
        B186_W::new(self, 26)
    }
    ///Bit 27 - b187
    #[inline(always)]
    pub fn b187(&mut self) -> B187_W<K1LRrs> {
        B187_W::new(self, 27)
    }
    ///Bit 28 - b188
    #[inline(always)]
    pub fn b188(&mut self) -> B188_W<K1LRrs> {
        B188_W::new(self, 28)
    }
    ///Bit 29 - b189
    #[inline(always)]
    pub fn b189(&mut self) -> B189_W<K1LRrs> {
        B189_W::new(self, 29)
    }
    ///Bit 30 - b190
    #[inline(always)]
    pub fn b190(&mut self) -> B190_W<K1LRrs> {
        B190_W::new(self, 30)
    }
    ///Bit 31 - b191
    #[inline(always)]
    pub fn b191(&mut self) -> B191_W<K1LRrs> {
        B191_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 [`k1lr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api).*/
pub struct K1LRrs;
impl crate::RegisterSpec for K1LRrs {
    type Ux = u32;
}
///`write(|w| ..)` method takes [`k1lr::W`](W) writer structure
impl crate::Writable for K1LRrs {
    type Safety = crate::Unsafe;
}
///`reset()` method sets K1LR to value 0
impl crate::Resettable for K1LRrs {}