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 `K1RR` writer
pub type W = crate::W<K1RRrs>;
///Field `b128` writer - b128
pub type B128_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b129` writer - b129
pub type B129_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b130` writer - b130
pub type B130_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b131` writer - b131
pub type B131_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b132` writer - b132
pub type B132_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b133` writer - b133
pub type B133_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b134` writer - b134
pub type B134_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b135` writer - b135
pub type B135_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b136` writer - b136
pub type B136_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b137` writer - b137
pub type B137_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b138` writer - b138
pub type B138_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b139` writer - b139
pub type B139_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b140` writer - b140
pub type B140_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b141` writer - b141
pub type B141_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b142` writer - b142
pub type B142_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b143` writer - b143
pub type B143_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b144` writer - b144
pub type B144_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b145` writer - b145
pub type B145_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b146` writer - b146
pub type B146_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b147` writer - b147
pub type B147_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b148` writer - b148
pub type B148_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b149` writer - b149
pub type B149_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b150` writer - b150
pub type B150_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b151` writer - b151
pub type B151_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b152` writer - b152
pub type B152_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b153` writer - b153
pub type B153_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b154` writer - b154
pub type B154_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b155` writer - b155
pub type B155_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b156` writer - b156
pub type B156_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b157` writer - b157
pub type B157_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b158` writer - b158
pub type B158_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `b159` writer - b159
pub type B159_W<'a, REG> = crate::BitWriter<'a, REG>;
impl core::fmt::Debug for crate::generic::Reg<K1RRrs> {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        write!(f, "(not readable)")
    }
}
impl W {
    ///Bit 0 - b128
    #[inline(always)]
    pub fn b128(&mut self) -> B128_W<K1RRrs> {
        B128_W::new(self, 0)
    }
    ///Bit 1 - b129
    #[inline(always)]
    pub fn b129(&mut self) -> B129_W<K1RRrs> {
        B129_W::new(self, 1)
    }
    ///Bit 2 - b130
    #[inline(always)]
    pub fn b130(&mut self) -> B130_W<K1RRrs> {
        B130_W::new(self, 2)
    }
    ///Bit 3 - b131
    #[inline(always)]
    pub fn b131(&mut self) -> B131_W<K1RRrs> {
        B131_W::new(self, 3)
    }
    ///Bit 4 - b132
    #[inline(always)]
    pub fn b132(&mut self) -> B132_W<K1RRrs> {
        B132_W::new(self, 4)
    }
    ///Bit 5 - b133
    #[inline(always)]
    pub fn b133(&mut self) -> B133_W<K1RRrs> {
        B133_W::new(self, 5)
    }
    ///Bit 6 - b134
    #[inline(always)]
    pub fn b134(&mut self) -> B134_W<K1RRrs> {
        B134_W::new(self, 6)
    }
    ///Bit 7 - b135
    #[inline(always)]
    pub fn b135(&mut self) -> B135_W<K1RRrs> {
        B135_W::new(self, 7)
    }
    ///Bit 8 - b136
    #[inline(always)]
    pub fn b136(&mut self) -> B136_W<K1RRrs> {
        B136_W::new(self, 8)
    }
    ///Bit 9 - b137
    #[inline(always)]
    pub fn b137(&mut self) -> B137_W<K1RRrs> {
        B137_W::new(self, 9)
    }
    ///Bit 10 - b138
    #[inline(always)]
    pub fn b138(&mut self) -> B138_W<K1RRrs> {
        B138_W::new(self, 10)
    }
    ///Bit 11 - b139
    #[inline(always)]
    pub fn b139(&mut self) -> B139_W<K1RRrs> {
        B139_W::new(self, 11)
    }
    ///Bit 12 - b140
    #[inline(always)]
    pub fn b140(&mut self) -> B140_W<K1RRrs> {
        B140_W::new(self, 12)
    }
    ///Bit 13 - b141
    #[inline(always)]
    pub fn b141(&mut self) -> B141_W<K1RRrs> {
        B141_W::new(self, 13)
    }
    ///Bit 14 - b142
    #[inline(always)]
    pub fn b142(&mut self) -> B142_W<K1RRrs> {
        B142_W::new(self, 14)
    }
    ///Bit 15 - b143
    #[inline(always)]
    pub fn b143(&mut self) -> B143_W<K1RRrs> {
        B143_W::new(self, 15)
    }
    ///Bit 16 - b144
    #[inline(always)]
    pub fn b144(&mut self) -> B144_W<K1RRrs> {
        B144_W::new(self, 16)
    }
    ///Bit 17 - b145
    #[inline(always)]
    pub fn b145(&mut self) -> B145_W<K1RRrs> {
        B145_W::new(self, 17)
    }
    ///Bit 18 - b146
    #[inline(always)]
    pub fn b146(&mut self) -> B146_W<K1RRrs> {
        B146_W::new(self, 18)
    }
    ///Bit 19 - b147
    #[inline(always)]
    pub fn b147(&mut self) -> B147_W<K1RRrs> {
        B147_W::new(self, 19)
    }
    ///Bit 20 - b148
    #[inline(always)]
    pub fn b148(&mut self) -> B148_W<K1RRrs> {
        B148_W::new(self, 20)
    }
    ///Bit 21 - b149
    #[inline(always)]
    pub fn b149(&mut self) -> B149_W<K1RRrs> {
        B149_W::new(self, 21)
    }
    ///Bit 22 - b150
    #[inline(always)]
    pub fn b150(&mut self) -> B150_W<K1RRrs> {
        B150_W::new(self, 22)
    }
    ///Bit 23 - b151
    #[inline(always)]
    pub fn b151(&mut self) -> B151_W<K1RRrs> {
        B151_W::new(self, 23)
    }
    ///Bit 24 - b152
    #[inline(always)]
    pub fn b152(&mut self) -> B152_W<K1RRrs> {
        B152_W::new(self, 24)
    }
    ///Bit 25 - b153
    #[inline(always)]
    pub fn b153(&mut self) -> B153_W<K1RRrs> {
        B153_W::new(self, 25)
    }
    ///Bit 26 - b154
    #[inline(always)]
    pub fn b154(&mut self) -> B154_W<K1RRrs> {
        B154_W::new(self, 26)
    }
    ///Bit 27 - b155
    #[inline(always)]
    pub fn b155(&mut self) -> B155_W<K1RRrs> {
        B155_W::new(self, 27)
    }
    ///Bit 28 - b156
    #[inline(always)]
    pub fn b156(&mut self) -> B156_W<K1RRrs> {
        B156_W::new(self, 28)
    }
    ///Bit 29 - b157
    #[inline(always)]
    pub fn b157(&mut self) -> B157_W<K1RRrs> {
        B157_W::new(self, 29)
    }
    ///Bit 30 - b158
    #[inline(always)]
    pub fn b158(&mut self) -> B158_W<K1RRrs> {
        B158_W::new(self, 30)
    }
    ///Bit 31 - b159
    #[inline(always)]
    pub fn b159(&mut self) -> B159_W<K1RRrs> {
        B159_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 [`k1rr::W`](W). See [API](https://docs.rs/svd2rust/#read--modify--write-api).*/
pub struct K1RRrs;
impl crate::RegisterSpec for K1RRrs {
    type Ux = u32;
}
///`write(|w| ..)` method takes [`k1rr::W`](W) writer structure
impl crate::Writable for K1RRrs {
    type Safety = crate::Unsafe;
}
///`reset()` method sets K1RR to value 0
impl crate::Resettable for K1RRrs {}