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

///Register `IER` reader
pub type R = crate::R<IERrs>;
///Register `IER` writer
pub type W = crate::W<IERrs>;
///Field `RXBRIE` reader - Rx-Byte Received Interrupt Enable The RXBRIE bit is set and cleared by software.
pub type RXBRIE_R = crate::BitReader;
///Field `RXBRIE` writer - Rx-Byte Received Interrupt Enable The RXBRIE bit is set and cleared by software.
pub type RXBRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `RXENDIE` reader - End Of Reception Interrupt Enable The RXENDIE bit is set and cleared by software.
pub type RXENDIE_R = crate::BitReader;
///Field `RXENDIE` writer - End Of Reception Interrupt Enable The RXENDIE bit is set and cleared by software.
pub type RXENDIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `RXOVRIE` reader - Rx-Buffer Overrun Interrupt Enable The RXOVRIE bit is set and cleared by software.
pub type RXOVRIE_R = crate::BitReader;
///Field `RXOVRIE` writer - Rx-Buffer Overrun Interrupt Enable The RXOVRIE bit is set and cleared by software.
pub type RXOVRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `BREIE` reader - Bit Rising Error Interrupt Enable The BREIE bit is set and cleared by software.
pub type BREIE_R = crate::BitReader;
///Field `BREIE` writer - Bit Rising Error Interrupt Enable The BREIE bit is set and cleared by software.
pub type BREIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `SBPEIE` reader - Short Bit Period Error Interrupt Enable The SBPEIE bit is set and cleared by software.
pub type SBPEIE_R = crate::BitReader;
///Field `SBPEIE` writer - Short Bit Period Error Interrupt Enable The SBPEIE bit is set and cleared by software.
pub type SBPEIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `LBPEIE` reader - Long Bit Period Error Interrupt Enable The LBPEIE bit is set and cleared by software.
pub type LBPEIE_R = crate::BitReader;
///Field `LBPEIE` writer - Long Bit Period Error Interrupt Enable The LBPEIE bit is set and cleared by software.
pub type LBPEIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `RXACKIE` reader - Rx-Missing Acknowledge Error Interrupt Enable The RXACKIE bit is set and cleared by software.
pub type RXACKIE_R = crate::BitReader;
///Field `RXACKIE` writer - Rx-Missing Acknowledge Error Interrupt Enable The RXACKIE bit is set and cleared by software.
pub type RXACKIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `ARBLSTIE` reader - Arbitration Lost Interrupt Enable The ARBLSTIE bit is set and cleared by software.
pub type ARBLSTIE_R = crate::BitReader;
///Field `ARBLSTIE` writer - Arbitration Lost Interrupt Enable The ARBLSTIE bit is set and cleared by software.
pub type ARBLSTIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `TXBRIE` reader - Tx-Byte Request Interrupt Enable The TXBRIE bit is set and cleared by software.
pub type TXBRIE_R = crate::BitReader;
///Field `TXBRIE` writer - Tx-Byte Request Interrupt Enable The TXBRIE bit is set and cleared by software.
pub type TXBRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `TXENDIE` reader - Tx-End Of Message Interrupt Enable The TXENDIE bit is set and cleared by software.
pub type TXENDIE_R = crate::BitReader;
///Field `TXENDIE` writer - Tx-End Of Message Interrupt Enable The TXENDIE bit is set and cleared by software.
pub type TXENDIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `TXUDRIE` reader - Tx-Underrun Interrupt Enable The TXUDRIE bit is set and cleared by software.
pub type TXUDRIE_R = crate::BitReader;
///Field `TXUDRIE` writer - Tx-Underrun Interrupt Enable The TXUDRIE bit is set and cleared by software.
pub type TXUDRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `TXERRIE` reader - Tx-Error Interrupt Enable The TXERRIE bit is set and cleared by software.
pub type TXERRIE_R = crate::BitReader;
///Field `TXERRIE` writer - Tx-Error Interrupt Enable The TXERRIE bit is set and cleared by software.
pub type TXERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `TXACKIE` reader - Tx-Missing Acknowledge Error Interrupt Enable The TXACKEIE bit is set and cleared by software.
pub type TXACKIE_R = crate::BitReader;
///Field `TXACKIE` writer - Tx-Missing Acknowledge Error Interrupt Enable The TXACKEIE bit is set and cleared by software.
pub type TXACKIE_W<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
    ///Bit 0 - Rx-Byte Received Interrupt Enable The RXBRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxbrie(&self) -> RXBRIE_R {
        RXBRIE_R::new((self.bits & 1) != 0)
    }
    ///Bit 1 - End Of Reception Interrupt Enable The RXENDIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxendie(&self) -> RXENDIE_R {
        RXENDIE_R::new(((self.bits >> 1) & 1) != 0)
    }
    ///Bit 2 - Rx-Buffer Overrun Interrupt Enable The RXOVRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxovrie(&self) -> RXOVRIE_R {
        RXOVRIE_R::new(((self.bits >> 2) & 1) != 0)
    }
    ///Bit 3 - Bit Rising Error Interrupt Enable The BREIE bit is set and cleared by software.
    #[inline(always)]
    pub fn breie(&self) -> BREIE_R {
        BREIE_R::new(((self.bits >> 3) & 1) != 0)
    }
    ///Bit 4 - Short Bit Period Error Interrupt Enable The SBPEIE bit is set and cleared by software.
    #[inline(always)]
    pub fn sbpeie(&self) -> SBPEIE_R {
        SBPEIE_R::new(((self.bits >> 4) & 1) != 0)
    }
    ///Bit 5 - Long Bit Period Error Interrupt Enable The LBPEIE bit is set and cleared by software.
    #[inline(always)]
    pub fn lbpeie(&self) -> LBPEIE_R {
        LBPEIE_R::new(((self.bits >> 5) & 1) != 0)
    }
    ///Bit 6 - Rx-Missing Acknowledge Error Interrupt Enable The RXACKIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxackie(&self) -> RXACKIE_R {
        RXACKIE_R::new(((self.bits >> 6) & 1) != 0)
    }
    ///Bit 7 - Arbitration Lost Interrupt Enable The ARBLSTIE bit is set and cleared by software.
    #[inline(always)]
    pub fn arblstie(&self) -> ARBLSTIE_R {
        ARBLSTIE_R::new(((self.bits >> 7) & 1) != 0)
    }
    ///Bit 8 - Tx-Byte Request Interrupt Enable The TXBRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txbrie(&self) -> TXBRIE_R {
        TXBRIE_R::new(((self.bits >> 8) & 1) != 0)
    }
    ///Bit 9 - Tx-End Of Message Interrupt Enable The TXENDIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txendie(&self) -> TXENDIE_R {
        TXENDIE_R::new(((self.bits >> 9) & 1) != 0)
    }
    ///Bit 10 - Tx-Underrun Interrupt Enable The TXUDRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txudrie(&self) -> TXUDRIE_R {
        TXUDRIE_R::new(((self.bits >> 10) & 1) != 0)
    }
    ///Bit 11 - Tx-Error Interrupt Enable The TXERRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txerrie(&self) -> TXERRIE_R {
        TXERRIE_R::new(((self.bits >> 11) & 1) != 0)
    }
    ///Bit 12 - Tx-Missing Acknowledge Error Interrupt Enable The TXACKEIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txackie(&self) -> TXACKIE_R {
        TXACKIE_R::new(((self.bits >> 12) & 1) != 0)
    }
}
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("IER")
            .field("rxbrie", &self.rxbrie())
            .field("rxendie", &self.rxendie())
            .field("rxovrie", &self.rxovrie())
            .field("breie", &self.breie())
            .field("sbpeie", &self.sbpeie())
            .field("lbpeie", &self.lbpeie())
            .field("rxackie", &self.rxackie())
            .field("arblstie", &self.arblstie())
            .field("txbrie", &self.txbrie())
            .field("txendie", &self.txendie())
            .field("txudrie", &self.txudrie())
            .field("txerrie", &self.txerrie())
            .field("txackie", &self.txackie())
            .finish()
    }
}
impl W {
    ///Bit 0 - Rx-Byte Received Interrupt Enable The RXBRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxbrie(&mut self) -> RXBRIE_W<IERrs> {
        RXBRIE_W::new(self, 0)
    }
    ///Bit 1 - End Of Reception Interrupt Enable The RXENDIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxendie(&mut self) -> RXENDIE_W<IERrs> {
        RXENDIE_W::new(self, 1)
    }
    ///Bit 2 - Rx-Buffer Overrun Interrupt Enable The RXOVRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxovrie(&mut self) -> RXOVRIE_W<IERrs> {
        RXOVRIE_W::new(self, 2)
    }
    ///Bit 3 - Bit Rising Error Interrupt Enable The BREIE bit is set and cleared by software.
    #[inline(always)]
    pub fn breie(&mut self) -> BREIE_W<IERrs> {
        BREIE_W::new(self, 3)
    }
    ///Bit 4 - Short Bit Period Error Interrupt Enable The SBPEIE bit is set and cleared by software.
    #[inline(always)]
    pub fn sbpeie(&mut self) -> SBPEIE_W<IERrs> {
        SBPEIE_W::new(self, 4)
    }
    ///Bit 5 - Long Bit Period Error Interrupt Enable The LBPEIE bit is set and cleared by software.
    #[inline(always)]
    pub fn lbpeie(&mut self) -> LBPEIE_W<IERrs> {
        LBPEIE_W::new(self, 5)
    }
    ///Bit 6 - Rx-Missing Acknowledge Error Interrupt Enable The RXACKIE bit is set and cleared by software.
    #[inline(always)]
    pub fn rxackie(&mut self) -> RXACKIE_W<IERrs> {
        RXACKIE_W::new(self, 6)
    }
    ///Bit 7 - Arbitration Lost Interrupt Enable The ARBLSTIE bit is set and cleared by software.
    #[inline(always)]
    pub fn arblstie(&mut self) -> ARBLSTIE_W<IERrs> {
        ARBLSTIE_W::new(self, 7)
    }
    ///Bit 8 - Tx-Byte Request Interrupt Enable The TXBRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txbrie(&mut self) -> TXBRIE_W<IERrs> {
        TXBRIE_W::new(self, 8)
    }
    ///Bit 9 - Tx-End Of Message Interrupt Enable The TXENDIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txendie(&mut self) -> TXENDIE_W<IERrs> {
        TXENDIE_W::new(self, 9)
    }
    ///Bit 10 - Tx-Underrun Interrupt Enable The TXUDRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txudrie(&mut self) -> TXUDRIE_W<IERrs> {
        TXUDRIE_W::new(self, 10)
    }
    ///Bit 11 - Tx-Error Interrupt Enable The TXERRIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txerrie(&mut self) -> TXERRIE_W<IERrs> {
        TXERRIE_W::new(self, 11)
    }
    ///Bit 12 - Tx-Missing Acknowledge Error Interrupt Enable The TXACKEIE bit is set and cleared by software.
    #[inline(always)]
    pub fn txackie(&mut self) -> TXACKIE_W<IERrs> {
        TXACKIE_W::new(self, 12)
    }
}
/**CEC interrupt enable register

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