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

///Register `IER` reader
pub type R = crate::R<IERrs>;
///Register `IER` writer
pub type W = crate::W<IERrs>;
///Field `EOPIE` reader - End-of-program interrupt control bit
pub type EOPIE_R = crate::BitReader;
///Field `EOPIE` writer - End-of-program interrupt control bit
pub type EOPIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `WRPERRIE` reader - Write protection error interrupt enable bit
pub type WRPERRIE_R = crate::BitReader;
///Field `WRPERRIE` writer - Write protection error interrupt enable bit
pub type WRPERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `PGSERRIE` reader - Programming sequence error interrupt enable bit
pub type PGSERRIE_R = crate::BitReader;
///Field `PGSERRIE` writer - Programming sequence error interrupt enable bit
pub type PGSERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `STRBERRIE` reader - Strobe error interrupt enable bit
pub type STRBERRIE_R = crate::BitReader;
///Field `STRBERRIE` writer - Strobe error interrupt enable bit
pub type STRBERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `OBLERRIE` reader - Option byte loading error interrupt enable bit
pub type OBLERRIE_R = crate::BitReader;
///Field `OBLERRIE` writer - Option byte loading error interrupt enable bit
pub type OBLERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `INCERRIE` reader - Inconsistency error interrupt enable bit
pub type INCERRIE_R = crate::BitReader;
///Field `INCERRIE` writer - Inconsistency error interrupt enable bit
pub type INCERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `RDSERRIE` reader - Read security error interrupt enable bit
pub type RDSERRIE_R = crate::BitReader;
///Field `RDSERRIE` writer - Read security error interrupt enable bit
pub type RDSERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `SNECCERRIE` reader - ECC single correction error interrupt enable bit
pub type SNECCERRIE_R = crate::BitReader;
///Field `SNECCERRIE` writer - ECC single correction error interrupt enable bit
pub type SNECCERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `DBECCERRIE` reader - ECC double detection error interrupt enable bit
pub type DBECCERRIE_R = crate::BitReader;
///Field `DBECCERRIE` writer - ECC double detection error interrupt enable bit
pub type DBECCERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `CRCENDIE` reader - CRC end of calculation interrupt enable bit
pub type CRCENDIE_R = crate::BitReader;
///Field `CRCENDIE` writer - CRC end of calculation interrupt enable bit
pub type CRCENDIE_W<'a, REG> = crate::BitWriter<'a, REG>;
///Field `CRCRDERRIE` reader - CRC read error interrupt enable bit
pub type CRCRDERRIE_R = crate::BitReader;
///Field `CRCRDERRIE` writer - CRC read error interrupt enable bit
pub type CRCRDERRIE_W<'a, REG> = crate::BitWriter<'a, REG>;
impl R {
    ///Bit 16 - End-of-program interrupt control bit
    #[inline(always)]
    pub fn eopie(&self) -> EOPIE_R {
        EOPIE_R::new(((self.bits >> 16) & 1) != 0)
    }
    ///Bit 17 - Write protection error interrupt enable bit
    #[inline(always)]
    pub fn wrperrie(&self) -> WRPERRIE_R {
        WRPERRIE_R::new(((self.bits >> 17) & 1) != 0)
    }
    ///Bit 18 - Programming sequence error interrupt enable bit
    #[inline(always)]
    pub fn pgserrie(&self) -> PGSERRIE_R {
        PGSERRIE_R::new(((self.bits >> 18) & 1) != 0)
    }
    ///Bit 19 - Strobe error interrupt enable bit
    #[inline(always)]
    pub fn strberrie(&self) -> STRBERRIE_R {
        STRBERRIE_R::new(((self.bits >> 19) & 1) != 0)
    }
    ///Bit 20 - Option byte loading error interrupt enable bit
    #[inline(always)]
    pub fn oblerrie(&self) -> OBLERRIE_R {
        OBLERRIE_R::new(((self.bits >> 20) & 1) != 0)
    }
    ///Bit 21 - Inconsistency error interrupt enable bit
    #[inline(always)]
    pub fn incerrie(&self) -> INCERRIE_R {
        INCERRIE_R::new(((self.bits >> 21) & 1) != 0)
    }
    ///Bit 24 - Read security error interrupt enable bit
    #[inline(always)]
    pub fn rdserrie(&self) -> RDSERRIE_R {
        RDSERRIE_R::new(((self.bits >> 24) & 1) != 0)
    }
    ///Bit 25 - ECC single correction error interrupt enable bit
    #[inline(always)]
    pub fn sneccerrie(&self) -> SNECCERRIE_R {
        SNECCERRIE_R::new(((self.bits >> 25) & 1) != 0)
    }
    ///Bit 26 - ECC double detection error interrupt enable bit
    #[inline(always)]
    pub fn dbeccerrie(&self) -> DBECCERRIE_R {
        DBECCERRIE_R::new(((self.bits >> 26) & 1) != 0)
    }
    ///Bit 27 - CRC end of calculation interrupt enable bit
    #[inline(always)]
    pub fn crcendie(&self) -> CRCENDIE_R {
        CRCENDIE_R::new(((self.bits >> 27) & 1) != 0)
    }
    ///Bit 28 - CRC read error interrupt enable bit
    #[inline(always)]
    pub fn crcrderrie(&self) -> CRCRDERRIE_R {
        CRCRDERRIE_R::new(((self.bits >> 28) & 1) != 0)
    }
}
impl core::fmt::Debug for R {
    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
        f.debug_struct("IER")
            .field("eopie", &self.eopie())
            .field("wrperrie", &self.wrperrie())
            .field("pgserrie", &self.pgserrie())
            .field("strberrie", &self.strberrie())
            .field("oblerrie", &self.oblerrie())
            .field("incerrie", &self.incerrie())
            .field("rdserrie", &self.rdserrie())
            .field("sneccerrie", &self.sneccerrie())
            .field("dbeccerrie", &self.dbeccerrie())
            .field("crcendie", &self.crcendie())
            .field("crcrderrie", &self.crcrderrie())
            .finish()
    }
}
impl W {
    ///Bit 16 - End-of-program interrupt control bit
    #[inline(always)]
    pub fn eopie(&mut self) -> EOPIE_W<IERrs> {
        EOPIE_W::new(self, 16)
    }
    ///Bit 17 - Write protection error interrupt enable bit
    #[inline(always)]
    pub fn wrperrie(&mut self) -> WRPERRIE_W<IERrs> {
        WRPERRIE_W::new(self, 17)
    }
    ///Bit 18 - Programming sequence error interrupt enable bit
    #[inline(always)]
    pub fn pgserrie(&mut self) -> PGSERRIE_W<IERrs> {
        PGSERRIE_W::new(self, 18)
    }
    ///Bit 19 - Strobe error interrupt enable bit
    #[inline(always)]
    pub fn strberrie(&mut self) -> STRBERRIE_W<IERrs> {
        STRBERRIE_W::new(self, 19)
    }
    ///Bit 20 - Option byte loading error interrupt enable bit
    #[inline(always)]
    pub fn oblerrie(&mut self) -> OBLERRIE_W<IERrs> {
        OBLERRIE_W::new(self, 20)
    }
    ///Bit 21 - Inconsistency error interrupt enable bit
    #[inline(always)]
    pub fn incerrie(&mut self) -> INCERRIE_W<IERrs> {
        INCERRIE_W::new(self, 21)
    }
    ///Bit 24 - Read security error interrupt enable bit
    #[inline(always)]
    pub fn rdserrie(&mut self) -> RDSERRIE_W<IERrs> {
        RDSERRIE_W::new(self, 24)
    }
    ///Bit 25 - ECC single correction error interrupt enable bit
    #[inline(always)]
    pub fn sneccerrie(&mut self) -> SNECCERRIE_W<IERrs> {
        SNECCERRIE_W::new(self, 25)
    }
    ///Bit 26 - ECC double detection error interrupt enable bit
    #[inline(always)]
    pub fn dbeccerrie(&mut self) -> DBECCERRIE_W<IERrs> {
        DBECCERRIE_W::new(self, 26)
    }
    ///Bit 27 - CRC end of calculation interrupt enable bit
    #[inline(always)]
    pub fn crcendie(&mut self) -> CRCENDIE_W<IERrs> {
        CRCENDIE_W::new(self, 27)
    }
    ///Bit 28 - CRC read error interrupt enable bit
    #[inline(always)]
    pub fn crcrderrie(&mut self) -> CRCRDERRIE_W<IERrs> {
        CRCRDERRIE_W::new(self, 28)
    }
}
/**FLASH 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 {}