1#![doc = "Peripheral access API for PY32F403 microcontrollers (generated using svd2rust v0.25.1 ( ))\n\nYou can find an overview of the generated API [here].\n\nAPI features to be included in the [next]
2svd2rust release can be generated by cloning the svd2rust [repository], checking out the above commit, and running `cargo doc --open`.\n\n[here]: https://docs.rs/svd2rust/0.25.1/svd2rust/#peripheral-api\n[next]: https://github.com/rust-embedded/svd2rust/blob/master/CHANGELOG.md#unreleased\n[repository]: https://github.com/rust-embedded/svd2rust"]
3#![deny(const_err)]
4#![deny(dead_code)]
5#![deny(improper_ctypes)]
6#![deny(missing_docs)]
7#![deny(no_mangle_generic_items)]
8#![deny(non_shorthand_field_patterns)]
9#![deny(overflowing_literals)]
10#![deny(path_statements)]
11#![deny(patterns_in_fns_without_body)]
12#![deny(private_in_public)]
13#![deny(unconditional_recursion)]
14#![deny(unused_allocation)]
15#![deny(unused_comparisons)]
16#![deny(unused_parens)]
17#![deny(while_true)]
18#![allow(non_camel_case_types)]
19#![allow(non_snake_case)]
20#![no_std]
21use core::marker::PhantomData;
22use core::ops::Deref;
23#[doc = r"Number available in the NVIC for configuring priority"]
24pub const NVIC_PRIO_BITS: u8 = 4;
25#[cfg(feature = "rt")]
26pub use self::Interrupt as interrupt;
27pub use cortex_m::peripheral::Peripherals as CorePeripherals;
28pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
29#[cfg(feature = "rt")]
30pub use cortex_m_rt::interrupt;
31#[allow(unused_imports)]
32use generic::*;
33#[doc = r"Common register and bit access and modify traits"]
34pub mod generic;
35#[cfg(feature = "rt")]
36extern "C" {
37 fn WWDG();
38 fn PVD();
39 fn TAMPER();
40 fn RTC();
41 fn FLASH();
42 fn RCC_CTC();
43 fn EXTI0();
44 fn EXTI1();
45 fn EXTI2();
46 fn EXTI3();
47 fn EXTI4();
48 fn DMA1_CHANNEL1();
49 fn DMA1_CHANNEL2();
50 fn DMA1_CHANNEL3();
51 fn DMA1_CHANNEL4();
52 fn DMA1_CHANNEL5();
53 fn DMA1_CHANNEL6();
54 fn DMA1_CHANNEL7();
55 fn ADC1_2();
56 fn USB();
57 fn CANFD_RX1();
58 fn CANFD_SCE();
59 fn EXTI9_5();
60 fn TIM1_BRK_TIM9();
61 fn TIM1_UP_TIM10();
62 fn TIM1_TRG_COM_TIM11();
63 fn TIM1_CC();
64 fn TIM2();
65 fn TIM3();
66 fn TIM4();
67 fn I2C1_EV();
68 fn I2C1_ER();
69 fn I2C2_EV();
70 fn I2C2_ER();
71 fn SPI1();
72 fn SPI2();
73 fn USART1();
74 fn USART2();
75 fn USART3();
76 fn EXTI15_10();
77 fn RTC_ALARM();
78 fn TIM8_BRK_TIM12();
79 fn TIM8_UP_TIM13();
80 fn TIM8_TRG_COM_TIM14();
81 fn TIM8_CC();
82 fn ADC3();
83 fn ESMC();
84 fn SDIO();
85 fn TIM5();
86 fn SPI3();
87 fn USART4();
88 fn USART5();
89 fn TIM6();
90 fn TIM7();
91 fn DMA2_CHANNEL1();
92 fn DMA2_CHANNEL2();
93 fn DMA2_CHANNEL3();
94 fn DMA2_CHANNEL4_5();
95}
96#[doc(hidden)]
97pub union Vector {
98 _handler: unsafe extern "C" fn(),
99 _reserved: u32,
100}
101#[cfg(feature = "rt")]
102#[doc(hidden)]
103#[link_section = ".vector_table.interrupts"]
104#[no_mangle]
105pub static __INTERRUPTS: [Vector; 60] = [
106 Vector { _handler: WWDG },
107 Vector { _handler: PVD },
108 Vector { _handler: TAMPER },
109 Vector { _handler: RTC },
110 Vector { _handler: FLASH },
111 Vector { _handler: RCC_CTC },
112 Vector { _handler: EXTI0 },
113 Vector { _handler: EXTI1 },
114 Vector { _handler: EXTI2 },
115 Vector { _handler: EXTI3 },
116 Vector { _handler: EXTI4 },
117 Vector {
118 _handler: DMA1_CHANNEL1,
119 },
120 Vector {
121 _handler: DMA1_CHANNEL2,
122 },
123 Vector {
124 _handler: DMA1_CHANNEL3,
125 },
126 Vector {
127 _handler: DMA1_CHANNEL4,
128 },
129 Vector {
130 _handler: DMA1_CHANNEL5,
131 },
132 Vector {
133 _handler: DMA1_CHANNEL6,
134 },
135 Vector {
136 _handler: DMA1_CHANNEL7,
137 },
138 Vector { _handler: ADC1_2 },
139 Vector { _handler: USB },
140 Vector { _reserved: 0 },
141 Vector {
142 _handler: CANFD_RX1,
143 },
144 Vector {
145 _handler: CANFD_SCE,
146 },
147 Vector { _handler: EXTI9_5 },
148 Vector {
149 _handler: TIM1_BRK_TIM9,
150 },
151 Vector {
152 _handler: TIM1_UP_TIM10,
153 },
154 Vector {
155 _handler: TIM1_TRG_COM_TIM11,
156 },
157 Vector { _handler: TIM1_CC },
158 Vector { _handler: TIM2 },
159 Vector { _handler: TIM3 },
160 Vector { _handler: TIM4 },
161 Vector { _handler: I2C1_EV },
162 Vector { _handler: I2C1_ER },
163 Vector { _handler: I2C2_EV },
164 Vector { _handler: I2C2_ER },
165 Vector { _handler: SPI1 },
166 Vector { _handler: SPI2 },
167 Vector { _handler: USART1 },
168 Vector { _handler: USART2 },
169 Vector { _handler: USART3 },
170 Vector {
171 _handler: EXTI15_10,
172 },
173 Vector {
174 _handler: RTC_ALARM,
175 },
176 Vector { _reserved: 0 },
177 Vector {
178 _handler: TIM8_BRK_TIM12,
179 },
180 Vector {
181 _handler: TIM8_UP_TIM13,
182 },
183 Vector {
184 _handler: TIM8_TRG_COM_TIM14,
185 },
186 Vector { _handler: TIM8_CC },
187 Vector { _handler: ADC3 },
188 Vector { _handler: ESMC },
189 Vector { _handler: SDIO },
190 Vector { _handler: TIM5 },
191 Vector { _handler: SPI3 },
192 Vector { _handler: USART4 },
193 Vector { _handler: USART5 },
194 Vector { _handler: TIM6 },
195 Vector { _handler: TIM7 },
196 Vector {
197 _handler: DMA2_CHANNEL1,
198 },
199 Vector {
200 _handler: DMA2_CHANNEL2,
201 },
202 Vector {
203 _handler: DMA2_CHANNEL3,
204 },
205 Vector {
206 _handler: DMA2_CHANNEL4_5,
207 },
208];
209#[doc = r"Enumeration of all the interrupts."]
210#[derive(Copy, Clone, Debug, PartialEq, Eq)]
211#[repr(u16)]
212pub enum Interrupt {
213 #[doc = "0 - desc WWDG"]
214 WWDG = 0,
215 #[doc = "1 - PVD through EXTI Line detection Interrupt"]
216 PVD = 1,
217 #[doc = "2 - Tamper Interrupt"]
218 TAMPER = 2,
219 #[doc = "3 - desc RTC"]
220 RTC = 3,
221 #[doc = "4 - FLASH global Interrupt"]
222 FLASH = 4,
223 #[doc = "5 - RCC global Interrupt"]
224 RCC_CTC = 5,
225 #[doc = "6 - EXTI Line0 Interrupt"]
226 EXTI0 = 6,
227 #[doc = "7 - EXTI Line1 Interrupt"]
228 EXTI1 = 7,
229 #[doc = "8 - EXTI Line2 Interrupt"]
230 EXTI2 = 8,
231 #[doc = "9 - EXTI Line3 Interrupt"]
232 EXTI3 = 9,
233 #[doc = "10 - EXTI Line4 Interrupt"]
234 EXTI4 = 10,
235 #[doc = "11 - DMA1 Channel 1 global Interrupt"]
236 DMA1_CHANNEL1 = 11,
237 #[doc = "12 - DMA1 Channel 2 global Interrupt"]
238 DMA1_CHANNEL2 = 12,
239 #[doc = "13 - DMA1 Channel 3 global Interrupt"]
240 DMA1_CHANNEL3 = 13,
241 #[doc = "14 - DMA1 Channel 4 global Interrupt"]
242 DMA1_CHANNEL4 = 14,
243 #[doc = "15 - DMA1 Channel 5 global Interrupt"]
244 DMA1_CHANNEL5 = 15,
245 #[doc = "16 - DMA1 Channel 6 global Interrupt"]
246 DMA1_CHANNEL6 = 16,
247 #[doc = "17 - DMA1 Channel 7 global Interrupt"]
248 DMA1_CHANNEL7 = 17,
249 #[doc = "18 - ADC1 and ADC2 global Interrupt"]
250 ADC1_2 = 18,
251 #[doc = "19 - USB global Interrupts"]
252 USB = 19,
253 #[doc = "21 - desc CANFD_RX1"]
254 CANFD_RX1 = 21,
255 #[doc = "22 - desc CANFD_SCE"]
256 CANFD_SCE = 22,
257 #[doc = "23 - External Line\\[9:5\\]
258Interrupts"]
259 EXTI9_5 = 23,
260 #[doc = "24 - TIM1 Break Interrupt and TIM9 global Interrupt"]
261 TIM1_BRK_TIM9 = 24,
262 #[doc = "25 - TIM1 Update Interrupt and TIM10 global Interrupt"]
263 TIM1_UP_TIM10 = 25,
264 #[doc = "26 - TIM1 Trigger and Commutation Interrupt and TIM11 global interrupt"]
265 TIM1_TRG_COM_TIM11 = 26,
266 #[doc = "27 - TIM1 Capture Compare Interrupt"]
267 TIM1_CC = 27,
268 #[doc = "28 - TIM2 global Interrupt"]
269 TIM2 = 28,
270 #[doc = "29 - TIM3 global Interrupt"]
271 TIM3 = 29,
272 #[doc = "30 - TIM4 global Interrupt"]
273 TIM4 = 30,
274 #[doc = "31 - I2C1 Event Interrupt"]
275 I2C1_EV = 31,
276 #[doc = "32 - I2C1 Error Interrupt"]
277 I2C1_ER = 32,
278 #[doc = "33 - I2C2 Event Interrupt"]
279 I2C2_EV = 33,
280 #[doc = "34 - I2C2 Error Interrupt"]
281 I2C2_ER = 34,
282 #[doc = "35 - SPI1 global Interrupt"]
283 SPI1 = 35,
284 #[doc = "36 - SPI2 global Interrupt"]
285 SPI2 = 36,
286 #[doc = "37 - USART1 global Interrupt"]
287 USART1 = 37,
288 #[doc = "38 - USART2 global Interrupt"]
289 USART2 = 38,
290 #[doc = "39 - USART3 global Interrupt"]
291 USART3 = 39,
292 #[doc = "40 - External Line\\[15:10\\]
293Interrupts"]
294 EXTI15_10 = 40,
295 #[doc = "41 - desc RTC_Alarm"]
296 RTC_ALARM = 41,
297 #[doc = "43 - TIM8 Break Interrupt and TIM12 global Interrupt"]
298 TIM8_BRK_TIM12 = 43,
299 #[doc = "44 - TIM8 Update Interrupt and TIM13 global Interrupt"]
300 TIM8_UP_TIM13 = 44,
301 #[doc = "45 - TIM8 Trigger and Commutation Interrupt and TIM14 global interrupt"]
302 TIM8_TRG_COM_TIM14 = 45,
303 #[doc = "46 - TIM8 Capture Compare Interrupt"]
304 TIM8_CC = 46,
305 #[doc = "47 - ADC3 global Interrupt"]
306 ADC3 = 47,
307 #[doc = "48 - ESMC global Interrupt"]
308 ESMC = 48,
309 #[doc = "49 - SDIO global Interrupt"]
310 SDIO = 49,
311 #[doc = "50 - TIM5 global Interrupt"]
312 TIM5 = 50,
313 #[doc = "51 - SPI3 global Interrupt"]
314 SPI3 = 51,
315 #[doc = "52 - USART4 global Interrupt"]
316 USART4 = 52,
317 #[doc = "53 - USART5 global Interrupt"]
318 USART5 = 53,
319 #[doc = "54 - TIM6 global Interrupt"]
320 TIM6 = 54,
321 #[doc = "55 - TIM7 global Interrupt"]
322 TIM7 = 55,
323 #[doc = "56 - DMA2 Channel 1 global Interrupt"]
324 DMA2_CHANNEL1 = 56,
325 #[doc = "57 - DMA2 Channel 2 global Interrupt"]
326 DMA2_CHANNEL2 = 57,
327 #[doc = "58 - DMA2 Channel 3 global Interrupt"]
328 DMA2_CHANNEL3 = 58,
329 #[doc = "59 - DMA2 Channel 4 and Channel 5 global Interrupt"]
330 DMA2_CHANNEL4_5 = 59,
331}
332unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
333 #[inline(always)]
334 fn number(self) -> u16 {
335 self as u16
336 }
337}
338#[doc = "desc ADC"]
339pub struct ADC1 {
340 _marker: PhantomData<*const ()>,
341}
342unsafe impl Send for ADC1 {}
343impl ADC1 {
344 #[doc = r"Pointer to the register block"]
345 pub const PTR: *const adc1::RegisterBlock = 0x4001_2400 as *const _;
346 #[doc = r"Return the pointer to the register block"]
347 #[inline(always)]
348 pub const fn ptr() -> *const adc1::RegisterBlock {
349 Self::PTR
350 }
351}
352impl Deref for ADC1 {
353 type Target = adc1::RegisterBlock;
354 #[inline(always)]
355 fn deref(&self) -> &Self::Target {
356 unsafe { &*Self::PTR }
357 }
358}
359impl core::fmt::Debug for ADC1 {
360 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
361 f.debug_struct("ADC1").finish()
362 }
363}
364#[doc = "desc ADC"]
365pub mod adc1;
366#[doc = "desc ADC"]
367pub struct ADC2 {
368 _marker: PhantomData<*const ()>,
369}
370unsafe impl Send for ADC2 {}
371impl ADC2 {
372 #[doc = r"Pointer to the register block"]
373 pub const PTR: *const adc1::RegisterBlock = 0x4001_2800 as *const _;
374 #[doc = r"Return the pointer to the register block"]
375 #[inline(always)]
376 pub const fn ptr() -> *const adc1::RegisterBlock {
377 Self::PTR
378 }
379}
380impl Deref for ADC2 {
381 type Target = adc1::RegisterBlock;
382 #[inline(always)]
383 fn deref(&self) -> &Self::Target {
384 unsafe { &*Self::PTR }
385 }
386}
387impl core::fmt::Debug for ADC2 {
388 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
389 f.debug_struct("ADC2").finish()
390 }
391}
392#[doc = "desc ADC"]
393pub use adc1 as adc2;
394#[doc = "desc ADC"]
395pub struct ADC3 {
396 _marker: PhantomData<*const ()>,
397}
398unsafe impl Send for ADC3 {}
399impl ADC3 {
400 #[doc = r"Pointer to the register block"]
401 pub const PTR: *const adc1::RegisterBlock = 0x4001_3c00 as *const _;
402 #[doc = r"Return the pointer to the register block"]
403 #[inline(always)]
404 pub const fn ptr() -> *const adc1::RegisterBlock {
405 Self::PTR
406 }
407}
408impl Deref for ADC3 {
409 type Target = adc1::RegisterBlock;
410 #[inline(always)]
411 fn deref(&self) -> &Self::Target {
412 unsafe { &*Self::PTR }
413 }
414}
415impl core::fmt::Debug for ADC3 {
416 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
417 f.debug_struct("ADC3").finish()
418 }
419}
420#[doc = "desc ADC"]
421pub use adc1 as adc3;
422#[doc = "desc BKP"]
423pub struct BKP {
424 _marker: PhantomData<*const ()>,
425}
426unsafe impl Send for BKP {}
427impl BKP {
428 #[doc = r"Pointer to the register block"]
429 pub const PTR: *const bkp::RegisterBlock = 0x4000_6c00 as *const _;
430 #[doc = r"Return the pointer to the register block"]
431 #[inline(always)]
432 pub const fn ptr() -> *const bkp::RegisterBlock {
433 Self::PTR
434 }
435}
436impl Deref for BKP {
437 type Target = bkp::RegisterBlock;
438 #[inline(always)]
439 fn deref(&self) -> &Self::Target {
440 unsafe { &*Self::PTR }
441 }
442}
443impl core::fmt::Debug for BKP {
444 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
445 f.debug_struct("BKP").finish()
446 }
447}
448#[doc = "desc BKP"]
449pub mod bkp;
450#[doc = "desc CANFD"]
451pub struct CANFD {
452 _marker: PhantomData<*const ()>,
453}
454unsafe impl Send for CANFD {}
455impl CANFD {
456 #[doc = r"Pointer to the register block"]
457 pub const PTR: *const canfd::RegisterBlock = 0x4000_8000 as *const _;
458 #[doc = r"Return the pointer to the register block"]
459 #[inline(always)]
460 pub const fn ptr() -> *const canfd::RegisterBlock {
461 Self::PTR
462 }
463}
464impl Deref for CANFD {
465 type Target = canfd::RegisterBlock;
466 #[inline(always)]
467 fn deref(&self) -> &Self::Target {
468 unsafe { &*Self::PTR }
469 }
470}
471impl core::fmt::Debug for CANFD {
472 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
473 f.debug_struct("CANFD").finish()
474 }
475}
476#[doc = "desc CANFD"]
477pub mod canfd;
478#[doc = "desc CRC"]
479pub struct CRC {
480 _marker: PhantomData<*const ()>,
481}
482unsafe impl Send for CRC {}
483impl CRC {
484 #[doc = r"Pointer to the register block"]
485 pub const PTR: *const crc::RegisterBlock = 0x4002_3000 as *const _;
486 #[doc = r"Return the pointer to the register block"]
487 #[inline(always)]
488 pub const fn ptr() -> *const crc::RegisterBlock {
489 Self::PTR
490 }
491}
492impl Deref for CRC {
493 type Target = crc::RegisterBlock;
494 #[inline(always)]
495 fn deref(&self) -> &Self::Target {
496 unsafe { &*Self::PTR }
497 }
498}
499impl core::fmt::Debug for CRC {
500 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
501 f.debug_struct("CRC").finish()
502 }
503}
504#[doc = "desc CRC"]
505pub mod crc;
506#[doc = "desc CTC"]
507pub struct CTC {
508 _marker: PhantomData<*const ()>,
509}
510unsafe impl Send for CTC {}
511impl CTC {
512 #[doc = r"Pointer to the register block"]
513 pub const PTR: *const ctc::RegisterBlock = 0x4000_c800 as *const _;
514 #[doc = r"Return the pointer to the register block"]
515 #[inline(always)]
516 pub const fn ptr() -> *const ctc::RegisterBlock {
517 Self::PTR
518 }
519}
520impl Deref for CTC {
521 type Target = ctc::RegisterBlock;
522 #[inline(always)]
523 fn deref(&self) -> &Self::Target {
524 unsafe { &*Self::PTR }
525 }
526}
527impl core::fmt::Debug for CTC {
528 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
529 f.debug_struct("CTC").finish()
530 }
531}
532#[doc = "desc CTC"]
533pub mod ctc;
534#[doc = "desc DBGMCU"]
535pub struct DBGMCU {
536 _marker: PhantomData<*const ()>,
537}
538unsafe impl Send for DBGMCU {}
539impl DBGMCU {
540 #[doc = r"Pointer to the register block"]
541 pub const PTR: *const dbgmcu::RegisterBlock = 0xe004_2000 as *const _;
542 #[doc = r"Return the pointer to the register block"]
543 #[inline(always)]
544 pub const fn ptr() -> *const dbgmcu::RegisterBlock {
545 Self::PTR
546 }
547}
548impl Deref for DBGMCU {
549 type Target = dbgmcu::RegisterBlock;
550 #[inline(always)]
551 fn deref(&self) -> &Self::Target {
552 unsafe { &*Self::PTR }
553 }
554}
555impl core::fmt::Debug for DBGMCU {
556 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
557 f.debug_struct("DBGMCU").finish()
558 }
559}
560#[doc = "desc DBGMCU"]
561pub mod dbgmcu;
562#[doc = "desc DMA"]
563pub struct DMA1 {
564 _marker: PhantomData<*const ()>,
565}
566unsafe impl Send for DMA1 {}
567impl DMA1 {
568 #[doc = r"Pointer to the register block"]
569 pub const PTR: *const dma1::RegisterBlock = 0x4002_0000 as *const _;
570 #[doc = r"Return the pointer to the register block"]
571 #[inline(always)]
572 pub const fn ptr() -> *const dma1::RegisterBlock {
573 Self::PTR
574 }
575}
576impl Deref for DMA1 {
577 type Target = dma1::RegisterBlock;
578 #[inline(always)]
579 fn deref(&self) -> &Self::Target {
580 unsafe { &*Self::PTR }
581 }
582}
583impl core::fmt::Debug for DMA1 {
584 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
585 f.debug_struct("DMA1").finish()
586 }
587}
588#[doc = "desc DMA"]
589pub mod dma1;
590#[doc = "desc DMA"]
591pub struct DMA2 {
592 _marker: PhantomData<*const ()>,
593}
594unsafe impl Send for DMA2 {}
595impl DMA2 {
596 #[doc = r"Pointer to the register block"]
597 pub const PTR: *const dma1::RegisterBlock = 0x4002_0400 as *const _;
598 #[doc = r"Return the pointer to the register block"]
599 #[inline(always)]
600 pub const fn ptr() -> *const dma1::RegisterBlock {
601 Self::PTR
602 }
603}
604impl Deref for DMA2 {
605 type Target = dma1::RegisterBlock;
606 #[inline(always)]
607 fn deref(&self) -> &Self::Target {
608 unsafe { &*Self::PTR }
609 }
610}
611impl core::fmt::Debug for DMA2 {
612 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
613 f.debug_struct("DMA2").finish()
614 }
615}
616#[doc = "desc DMA"]
617pub use dma1 as dma2;
618#[doc = "desc ESMC"]
619pub struct ESMC {
620 _marker: PhantomData<*const ()>,
621}
622unsafe impl Send for ESMC {}
623impl ESMC {
624 #[doc = r"Pointer to the register block"]
625 pub const PTR: *const esmc::RegisterBlock = 0xa000_1000 as *const _;
626 #[doc = r"Return the pointer to the register block"]
627 #[inline(always)]
628 pub const fn ptr() -> *const esmc::RegisterBlock {
629 Self::PTR
630 }
631}
632impl Deref for ESMC {
633 type Target = esmc::RegisterBlock;
634 #[inline(always)]
635 fn deref(&self) -> &Self::Target {
636 unsafe { &*Self::PTR }
637 }
638}
639impl core::fmt::Debug for ESMC {
640 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
641 f.debug_struct("ESMC").finish()
642 }
643}
644#[doc = "desc ESMC"]
645pub mod esmc;
646#[doc = "desc EXTI"]
647pub struct EXTI {
648 _marker: PhantomData<*const ()>,
649}
650unsafe impl Send for EXTI {}
651impl EXTI {
652 #[doc = r"Pointer to the register block"]
653 pub const PTR: *const exti::RegisterBlock = 0x4001_0400 as *const _;
654 #[doc = r"Return the pointer to the register block"]
655 #[inline(always)]
656 pub const fn ptr() -> *const exti::RegisterBlock {
657 Self::PTR
658 }
659}
660impl Deref for EXTI {
661 type Target = exti::RegisterBlock;
662 #[inline(always)]
663 fn deref(&self) -> &Self::Target {
664 unsafe { &*Self::PTR }
665 }
666}
667impl core::fmt::Debug for EXTI {
668 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
669 f.debug_struct("EXTI").finish()
670 }
671}
672#[doc = "desc EXTI"]
673pub mod exti;
674#[doc = "desc FLASH"]
675pub struct FLASH {
676 _marker: PhantomData<*const ()>,
677}
678unsafe impl Send for FLASH {}
679impl FLASH {
680 #[doc = r"Pointer to the register block"]
681 pub const PTR: *const flash::RegisterBlock = 0x4002_2000 as *const _;
682 #[doc = r"Return the pointer to the register block"]
683 #[inline(always)]
684 pub const fn ptr() -> *const flash::RegisterBlock {
685 Self::PTR
686 }
687}
688impl Deref for FLASH {
689 type Target = flash::RegisterBlock;
690 #[inline(always)]
691 fn deref(&self) -> &Self::Target {
692 unsafe { &*Self::PTR }
693 }
694}
695impl core::fmt::Debug for FLASH {
696 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
697 f.debug_struct("FLASH").finish()
698 }
699}
700#[doc = "desc FLASH"]
701pub mod flash;
702#[doc = "desc GPIO"]
703pub struct GPIOA {
704 _marker: PhantomData<*const ()>,
705}
706unsafe impl Send for GPIOA {}
707impl GPIOA {
708 #[doc = r"Pointer to the register block"]
709 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0000 as *const _;
710 #[doc = r"Return the pointer to the register block"]
711 #[inline(always)]
712 pub const fn ptr() -> *const gpioa::RegisterBlock {
713 Self::PTR
714 }
715}
716impl Deref for GPIOA {
717 type Target = gpioa::RegisterBlock;
718 #[inline(always)]
719 fn deref(&self) -> &Self::Target {
720 unsafe { &*Self::PTR }
721 }
722}
723impl core::fmt::Debug for GPIOA {
724 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
725 f.debug_struct("GPIOA").finish()
726 }
727}
728#[doc = "desc GPIO"]
729pub mod gpioa;
730#[doc = "desc GPIO"]
731pub struct GPIOB {
732 _marker: PhantomData<*const ()>,
733}
734unsafe impl Send for GPIOB {}
735impl GPIOB {
736 #[doc = r"Pointer to the register block"]
737 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0400 as *const _;
738 #[doc = r"Return the pointer to the register block"]
739 #[inline(always)]
740 pub const fn ptr() -> *const gpioa::RegisterBlock {
741 Self::PTR
742 }
743}
744impl Deref for GPIOB {
745 type Target = gpioa::RegisterBlock;
746 #[inline(always)]
747 fn deref(&self) -> &Self::Target {
748 unsafe { &*Self::PTR }
749 }
750}
751impl core::fmt::Debug for GPIOB {
752 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
753 f.debug_struct("GPIOB").finish()
754 }
755}
756#[doc = "desc GPIO"]
757pub use gpioa as gpiob;
758#[doc = "desc GPIO"]
759pub struct GPIOC {
760 _marker: PhantomData<*const ()>,
761}
762unsafe impl Send for GPIOC {}
763impl GPIOC {
764 #[doc = r"Pointer to the register block"]
765 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0800 as *const _;
766 #[doc = r"Return the pointer to the register block"]
767 #[inline(always)]
768 pub const fn ptr() -> *const gpioa::RegisterBlock {
769 Self::PTR
770 }
771}
772impl Deref for GPIOC {
773 type Target = gpioa::RegisterBlock;
774 #[inline(always)]
775 fn deref(&self) -> &Self::Target {
776 unsafe { &*Self::PTR }
777 }
778}
779impl core::fmt::Debug for GPIOC {
780 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
781 f.debug_struct("GPIOC").finish()
782 }
783}
784#[doc = "desc GPIO"]
785pub use gpioa as gpioc;
786#[doc = "desc GPIO"]
787pub struct GPIOD {
788 _marker: PhantomData<*const ()>,
789}
790unsafe impl Send for GPIOD {}
791impl GPIOD {
792 #[doc = r"Pointer to the register block"]
793 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0c00 as *const _;
794 #[doc = r"Return the pointer to the register block"]
795 #[inline(always)]
796 pub const fn ptr() -> *const gpioa::RegisterBlock {
797 Self::PTR
798 }
799}
800impl Deref for GPIOD {
801 type Target = gpioa::RegisterBlock;
802 #[inline(always)]
803 fn deref(&self) -> &Self::Target {
804 unsafe { &*Self::PTR }
805 }
806}
807impl core::fmt::Debug for GPIOD {
808 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
809 f.debug_struct("GPIOD").finish()
810 }
811}
812#[doc = "desc GPIO"]
813pub use gpioa as gpiod;
814#[doc = "desc GPIO"]
815pub struct GPIOE {
816 _marker: PhantomData<*const ()>,
817}
818unsafe impl Send for GPIOE {}
819impl GPIOE {
820 #[doc = r"Pointer to the register block"]
821 pub const PTR: *const gpioa::RegisterBlock = 0x4800_1000 as *const _;
822 #[doc = r"Return the pointer to the register block"]
823 #[inline(always)]
824 pub const fn ptr() -> *const gpioa::RegisterBlock {
825 Self::PTR
826 }
827}
828impl Deref for GPIOE {
829 type Target = gpioa::RegisterBlock;
830 #[inline(always)]
831 fn deref(&self) -> &Self::Target {
832 unsafe { &*Self::PTR }
833 }
834}
835impl core::fmt::Debug for GPIOE {
836 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
837 f.debug_struct("GPIOE").finish()
838 }
839}
840#[doc = "desc GPIO"]
841pub use gpioa as gpioe;
842#[doc = "desc I2C"]
843pub struct I2C1 {
844 _marker: PhantomData<*const ()>,
845}
846unsafe impl Send for I2C1 {}
847impl I2C1 {
848 #[doc = r"Pointer to the register block"]
849 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5400 as *const _;
850 #[doc = r"Return the pointer to the register block"]
851 #[inline(always)]
852 pub const fn ptr() -> *const i2c1::RegisterBlock {
853 Self::PTR
854 }
855}
856impl Deref for I2C1 {
857 type Target = i2c1::RegisterBlock;
858 #[inline(always)]
859 fn deref(&self) -> &Self::Target {
860 unsafe { &*Self::PTR }
861 }
862}
863impl core::fmt::Debug for I2C1 {
864 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
865 f.debug_struct("I2C1").finish()
866 }
867}
868#[doc = "desc I2C"]
869pub mod i2c1;
870#[doc = "desc I2C"]
871pub struct I2C2 {
872 _marker: PhantomData<*const ()>,
873}
874unsafe impl Send for I2C2 {}
875impl I2C2 {
876 #[doc = r"Pointer to the register block"]
877 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5800 as *const _;
878 #[doc = r"Return the pointer to the register block"]
879 #[inline(always)]
880 pub const fn ptr() -> *const i2c1::RegisterBlock {
881 Self::PTR
882 }
883}
884impl Deref for I2C2 {
885 type Target = i2c1::RegisterBlock;
886 #[inline(always)]
887 fn deref(&self) -> &Self::Target {
888 unsafe { &*Self::PTR }
889 }
890}
891impl core::fmt::Debug for I2C2 {
892 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
893 f.debug_struct("I2C2").finish()
894 }
895}
896#[doc = "desc I2C"]
897pub use i2c1 as i2c2;
898#[doc = "desc IWDG"]
899pub struct IWDG {
900 _marker: PhantomData<*const ()>,
901}
902unsafe impl Send for IWDG {}
903impl IWDG {
904 #[doc = r"Pointer to the register block"]
905 pub const PTR: *const iwdg::RegisterBlock = 0x4000_3000 as *const _;
906 #[doc = r"Return the pointer to the register block"]
907 #[inline(always)]
908 pub const fn ptr() -> *const iwdg::RegisterBlock {
909 Self::PTR
910 }
911}
912impl Deref for IWDG {
913 type Target = iwdg::RegisterBlock;
914 #[inline(always)]
915 fn deref(&self) -> &Self::Target {
916 unsafe { &*Self::PTR }
917 }
918}
919impl core::fmt::Debug for IWDG {
920 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
921 f.debug_struct("IWDG").finish()
922 }
923}
924#[doc = "desc IWDG"]
925pub mod iwdg;
926#[doc = "desc PWR"]
927pub struct PWR {
928 _marker: PhantomData<*const ()>,
929}
930unsafe impl Send for PWR {}
931impl PWR {
932 #[doc = r"Pointer to the register block"]
933 pub const PTR: *const pwr::RegisterBlock = 0x4000_7000 as *const _;
934 #[doc = r"Return the pointer to the register block"]
935 #[inline(always)]
936 pub const fn ptr() -> *const pwr::RegisterBlock {
937 Self::PTR
938 }
939}
940impl Deref for PWR {
941 type Target = pwr::RegisterBlock;
942 #[inline(always)]
943 fn deref(&self) -> &Self::Target {
944 unsafe { &*Self::PTR }
945 }
946}
947impl core::fmt::Debug for PWR {
948 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
949 f.debug_struct("PWR").finish()
950 }
951}
952#[doc = "desc PWR"]
953pub mod pwr;
954#[doc = "desc RCC"]
955pub struct RCC {
956 _marker: PhantomData<*const ()>,
957}
958unsafe impl Send for RCC {}
959impl RCC {
960 #[doc = r"Pointer to the register block"]
961 pub const PTR: *const rcc::RegisterBlock = 0x4002_1000 as *const _;
962 #[doc = r"Return the pointer to the register block"]
963 #[inline(always)]
964 pub const fn ptr() -> *const rcc::RegisterBlock {
965 Self::PTR
966 }
967}
968impl Deref for RCC {
969 type Target = rcc::RegisterBlock;
970 #[inline(always)]
971 fn deref(&self) -> &Self::Target {
972 unsafe { &*Self::PTR }
973 }
974}
975impl core::fmt::Debug for RCC {
976 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
977 f.debug_struct("RCC").finish()
978 }
979}
980#[doc = "desc RCC"]
981pub mod rcc;
982#[doc = "desc RTC"]
983pub struct RTC {
984 _marker: PhantomData<*const ()>,
985}
986unsafe impl Send for RTC {}
987impl RTC {
988 #[doc = r"Pointer to the register block"]
989 pub const PTR: *const rtc::RegisterBlock = 0x4000_2800 as *const _;
990 #[doc = r"Return the pointer to the register block"]
991 #[inline(always)]
992 pub const fn ptr() -> *const rtc::RegisterBlock {
993 Self::PTR
994 }
995}
996impl Deref for RTC {
997 type Target = rtc::RegisterBlock;
998 #[inline(always)]
999 fn deref(&self) -> &Self::Target {
1000 unsafe { &*Self::PTR }
1001 }
1002}
1003impl core::fmt::Debug for RTC {
1004 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1005 f.debug_struct("RTC").finish()
1006 }
1007}
1008#[doc = "desc RTC"]
1009pub mod rtc;
1010#[doc = "desc SDIO"]
1011pub struct SDIO {
1012 _marker: PhantomData<*const ()>,
1013}
1014unsafe impl Send for SDIO {}
1015impl SDIO {
1016 #[doc = r"Pointer to the register block"]
1017 pub const PTR: *const sdio::RegisterBlock = 0x4001_8000 as *const _;
1018 #[doc = r"Return the pointer to the register block"]
1019 #[inline(always)]
1020 pub const fn ptr() -> *const sdio::RegisterBlock {
1021 Self::PTR
1022 }
1023}
1024impl Deref for SDIO {
1025 type Target = sdio::RegisterBlock;
1026 #[inline(always)]
1027 fn deref(&self) -> &Self::Target {
1028 unsafe { &*Self::PTR }
1029 }
1030}
1031impl core::fmt::Debug for SDIO {
1032 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1033 f.debug_struct("SDIO").finish()
1034 }
1035}
1036#[doc = "desc SDIO"]
1037pub mod sdio;
1038#[doc = "desc SPI"]
1039pub struct SPI1 {
1040 _marker: PhantomData<*const ()>,
1041}
1042unsafe impl Send for SPI1 {}
1043impl SPI1 {
1044 #[doc = r"Pointer to the register block"]
1045 pub const PTR: *const spi1::RegisterBlock = 0x4001_3000 as *const _;
1046 #[doc = r"Return the pointer to the register block"]
1047 #[inline(always)]
1048 pub const fn ptr() -> *const spi1::RegisterBlock {
1049 Self::PTR
1050 }
1051}
1052impl Deref for SPI1 {
1053 type Target = spi1::RegisterBlock;
1054 #[inline(always)]
1055 fn deref(&self) -> &Self::Target {
1056 unsafe { &*Self::PTR }
1057 }
1058}
1059impl core::fmt::Debug for SPI1 {
1060 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1061 f.debug_struct("SPI1").finish()
1062 }
1063}
1064#[doc = "desc SPI"]
1065pub mod spi1;
1066#[doc = "desc SPI"]
1067pub struct SPI2 {
1068 _marker: PhantomData<*const ()>,
1069}
1070unsafe impl Send for SPI2 {}
1071impl SPI2 {
1072 #[doc = r"Pointer to the register block"]
1073 pub const PTR: *const spi1::RegisterBlock = 0x4000_3800 as *const _;
1074 #[doc = r"Return the pointer to the register block"]
1075 #[inline(always)]
1076 pub const fn ptr() -> *const spi1::RegisterBlock {
1077 Self::PTR
1078 }
1079}
1080impl Deref for SPI2 {
1081 type Target = spi1::RegisterBlock;
1082 #[inline(always)]
1083 fn deref(&self) -> &Self::Target {
1084 unsafe { &*Self::PTR }
1085 }
1086}
1087impl core::fmt::Debug for SPI2 {
1088 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1089 f.debug_struct("SPI2").finish()
1090 }
1091}
1092#[doc = "desc SPI"]
1093pub use spi1 as spi2;
1094#[doc = "desc SPI"]
1095pub struct SPI3 {
1096 _marker: PhantomData<*const ()>,
1097}
1098unsafe impl Send for SPI3 {}
1099impl SPI3 {
1100 #[doc = r"Pointer to the register block"]
1101 pub const PTR: *const spi1::RegisterBlock = 0x4000_3c00 as *const _;
1102 #[doc = r"Return the pointer to the register block"]
1103 #[inline(always)]
1104 pub const fn ptr() -> *const spi1::RegisterBlock {
1105 Self::PTR
1106 }
1107}
1108impl Deref for SPI3 {
1109 type Target = spi1::RegisterBlock;
1110 #[inline(always)]
1111 fn deref(&self) -> &Self::Target {
1112 unsafe { &*Self::PTR }
1113 }
1114}
1115impl core::fmt::Debug for SPI3 {
1116 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1117 f.debug_struct("SPI3").finish()
1118 }
1119}
1120#[doc = "desc SPI"]
1121pub use spi1 as spi3;
1122#[doc = "desc SYSCFG"]
1123pub struct SYSCFG {
1124 _marker: PhantomData<*const ()>,
1125}
1126unsafe impl Send for SYSCFG {}
1127impl SYSCFG {
1128 #[doc = r"Pointer to the register block"]
1129 pub const PTR: *const syscfg::RegisterBlock = 0x4001_0000 as *const _;
1130 #[doc = r"Return the pointer to the register block"]
1131 #[inline(always)]
1132 pub const fn ptr() -> *const syscfg::RegisterBlock {
1133 Self::PTR
1134 }
1135}
1136impl Deref for SYSCFG {
1137 type Target = syscfg::RegisterBlock;
1138 #[inline(always)]
1139 fn deref(&self) -> &Self::Target {
1140 unsafe { &*Self::PTR }
1141 }
1142}
1143impl core::fmt::Debug for SYSCFG {
1144 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1145 f.debug_struct("SYSCFG").finish()
1146 }
1147}
1148#[doc = "desc SYSCFG"]
1149pub mod syscfg;
1150#[doc = "desc TIM"]
1151pub struct TIM1 {
1152 _marker: PhantomData<*const ()>,
1153}
1154unsafe impl Send for TIM1 {}
1155impl TIM1 {
1156 #[doc = r"Pointer to the register block"]
1157 pub const PTR: *const tim1::RegisterBlock = 0x4001_2c00 as *const _;
1158 #[doc = r"Return the pointer to the register block"]
1159 #[inline(always)]
1160 pub const fn ptr() -> *const tim1::RegisterBlock {
1161 Self::PTR
1162 }
1163}
1164impl Deref for TIM1 {
1165 type Target = tim1::RegisterBlock;
1166 #[inline(always)]
1167 fn deref(&self) -> &Self::Target {
1168 unsafe { &*Self::PTR }
1169 }
1170}
1171impl core::fmt::Debug for TIM1 {
1172 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1173 f.debug_struct("TIM1").finish()
1174 }
1175}
1176#[doc = "desc TIM"]
1177pub mod tim1;
1178#[doc = "desc TIM"]
1179pub struct TIM2 {
1180 _marker: PhantomData<*const ()>,
1181}
1182unsafe impl Send for TIM2 {}
1183impl TIM2 {
1184 #[doc = r"Pointer to the register block"]
1185 pub const PTR: *const tim2::RegisterBlock = 0x4000_0000 as *const _;
1186 #[doc = r"Return the pointer to the register block"]
1187 #[inline(always)]
1188 pub const fn ptr() -> *const tim2::RegisterBlock {
1189 Self::PTR
1190 }
1191}
1192impl Deref for TIM2 {
1193 type Target = tim2::RegisterBlock;
1194 #[inline(always)]
1195 fn deref(&self) -> &Self::Target {
1196 unsafe { &*Self::PTR }
1197 }
1198}
1199impl core::fmt::Debug for TIM2 {
1200 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1201 f.debug_struct("TIM2").finish()
1202 }
1203}
1204#[doc = "desc TIM"]
1205pub mod tim2;
1206#[doc = "desc TIM"]
1207pub struct TIM3 {
1208 _marker: PhantomData<*const ()>,
1209}
1210unsafe impl Send for TIM3 {}
1211impl TIM3 {
1212 #[doc = r"Pointer to the register block"]
1213 pub const PTR: *const tim2::RegisterBlock = 0x4000_0400 as *const _;
1214 #[doc = r"Return the pointer to the register block"]
1215 #[inline(always)]
1216 pub const fn ptr() -> *const tim2::RegisterBlock {
1217 Self::PTR
1218 }
1219}
1220impl Deref for TIM3 {
1221 type Target = tim2::RegisterBlock;
1222 #[inline(always)]
1223 fn deref(&self) -> &Self::Target {
1224 unsafe { &*Self::PTR }
1225 }
1226}
1227impl core::fmt::Debug for TIM3 {
1228 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1229 f.debug_struct("TIM3").finish()
1230 }
1231}
1232#[doc = "desc TIM"]
1233pub use tim2 as tim3;
1234#[doc = "desc TIM"]
1235pub struct TIM4 {
1236 _marker: PhantomData<*const ()>,
1237}
1238unsafe impl Send for TIM4 {}
1239impl TIM4 {
1240 #[doc = r"Pointer to the register block"]
1241 pub const PTR: *const tim2::RegisterBlock = 0x4000_0800 as *const _;
1242 #[doc = r"Return the pointer to the register block"]
1243 #[inline(always)]
1244 pub const fn ptr() -> *const tim2::RegisterBlock {
1245 Self::PTR
1246 }
1247}
1248impl Deref for TIM4 {
1249 type Target = tim2::RegisterBlock;
1250 #[inline(always)]
1251 fn deref(&self) -> &Self::Target {
1252 unsafe { &*Self::PTR }
1253 }
1254}
1255impl core::fmt::Debug for TIM4 {
1256 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1257 f.debug_struct("TIM4").finish()
1258 }
1259}
1260#[doc = "desc TIM"]
1261pub use tim2 as tim4;
1262#[doc = "desc TIM"]
1263pub struct TIM5 {
1264 _marker: PhantomData<*const ()>,
1265}
1266unsafe impl Send for TIM5 {}
1267impl TIM5 {
1268 #[doc = r"Pointer to the register block"]
1269 pub const PTR: *const tim2::RegisterBlock = 0x4000_0c00 as *const _;
1270 #[doc = r"Return the pointer to the register block"]
1271 #[inline(always)]
1272 pub const fn ptr() -> *const tim2::RegisterBlock {
1273 Self::PTR
1274 }
1275}
1276impl Deref for TIM5 {
1277 type Target = tim2::RegisterBlock;
1278 #[inline(always)]
1279 fn deref(&self) -> &Self::Target {
1280 unsafe { &*Self::PTR }
1281 }
1282}
1283impl core::fmt::Debug for TIM5 {
1284 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1285 f.debug_struct("TIM5").finish()
1286 }
1287}
1288#[doc = "desc TIM"]
1289pub use tim2 as tim5;
1290#[doc = "desc TIM"]
1291pub struct TIM6 {
1292 _marker: PhantomData<*const ()>,
1293}
1294unsafe impl Send for TIM6 {}
1295impl TIM6 {
1296 #[doc = r"Pointer to the register block"]
1297 pub const PTR: *const tim6::RegisterBlock = 0x4000_1000 as *const _;
1298 #[doc = r"Return the pointer to the register block"]
1299 #[inline(always)]
1300 pub const fn ptr() -> *const tim6::RegisterBlock {
1301 Self::PTR
1302 }
1303}
1304impl Deref for TIM6 {
1305 type Target = tim6::RegisterBlock;
1306 #[inline(always)]
1307 fn deref(&self) -> &Self::Target {
1308 unsafe { &*Self::PTR }
1309 }
1310}
1311impl core::fmt::Debug for TIM6 {
1312 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1313 f.debug_struct("TIM6").finish()
1314 }
1315}
1316#[doc = "desc TIM"]
1317pub mod tim6;
1318#[doc = "desc TIM"]
1319pub struct TIM7 {
1320 _marker: PhantomData<*const ()>,
1321}
1322unsafe impl Send for TIM7 {}
1323impl TIM7 {
1324 #[doc = r"Pointer to the register block"]
1325 pub const PTR: *const tim6::RegisterBlock = 0x4000_1400 as *const _;
1326 #[doc = r"Return the pointer to the register block"]
1327 #[inline(always)]
1328 pub const fn ptr() -> *const tim6::RegisterBlock {
1329 Self::PTR
1330 }
1331}
1332impl Deref for TIM7 {
1333 type Target = tim6::RegisterBlock;
1334 #[inline(always)]
1335 fn deref(&self) -> &Self::Target {
1336 unsafe { &*Self::PTR }
1337 }
1338}
1339impl core::fmt::Debug for TIM7 {
1340 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1341 f.debug_struct("TIM7").finish()
1342 }
1343}
1344#[doc = "desc TIM"]
1345pub use tim6 as tim7;
1346#[doc = "desc TIM"]
1347pub struct TIM8 {
1348 _marker: PhantomData<*const ()>,
1349}
1350unsafe impl Send for TIM8 {}
1351impl TIM8 {
1352 #[doc = r"Pointer to the register block"]
1353 pub const PTR: *const tim1::RegisterBlock = 0x4001_3400 as *const _;
1354 #[doc = r"Return the pointer to the register block"]
1355 #[inline(always)]
1356 pub const fn ptr() -> *const tim1::RegisterBlock {
1357 Self::PTR
1358 }
1359}
1360impl Deref for TIM8 {
1361 type Target = tim1::RegisterBlock;
1362 #[inline(always)]
1363 fn deref(&self) -> &Self::Target {
1364 unsafe { &*Self::PTR }
1365 }
1366}
1367impl core::fmt::Debug for TIM8 {
1368 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1369 f.debug_struct("TIM8").finish()
1370 }
1371}
1372#[doc = "desc TIM"]
1373pub use tim1 as tim8;
1374#[doc = "desc TIM"]
1375pub struct TIM9 {
1376 _marker: PhantomData<*const ()>,
1377}
1378unsafe impl Send for TIM9 {}
1379impl TIM9 {
1380 #[doc = r"Pointer to the register block"]
1381 pub const PTR: *const tim9::RegisterBlock = 0x4001_4c00 as *const _;
1382 #[doc = r"Return the pointer to the register block"]
1383 #[inline(always)]
1384 pub const fn ptr() -> *const tim9::RegisterBlock {
1385 Self::PTR
1386 }
1387}
1388impl Deref for TIM9 {
1389 type Target = tim9::RegisterBlock;
1390 #[inline(always)]
1391 fn deref(&self) -> &Self::Target {
1392 unsafe { &*Self::PTR }
1393 }
1394}
1395impl core::fmt::Debug for TIM9 {
1396 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1397 f.debug_struct("TIM9").finish()
1398 }
1399}
1400#[doc = "desc TIM"]
1401pub mod tim9;
1402#[doc = "desc TIM"]
1403pub struct TIM10 {
1404 _marker: PhantomData<*const ()>,
1405}
1406unsafe impl Send for TIM10 {}
1407impl TIM10 {
1408 #[doc = r"Pointer to the register block"]
1409 pub const PTR: *const tim10::RegisterBlock = 0x4001_5000 as *const _;
1410 #[doc = r"Return the pointer to the register block"]
1411 #[inline(always)]
1412 pub const fn ptr() -> *const tim10::RegisterBlock {
1413 Self::PTR
1414 }
1415}
1416impl Deref for TIM10 {
1417 type Target = tim10::RegisterBlock;
1418 #[inline(always)]
1419 fn deref(&self) -> &Self::Target {
1420 unsafe { &*Self::PTR }
1421 }
1422}
1423impl core::fmt::Debug for TIM10 {
1424 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1425 f.debug_struct("TIM10").finish()
1426 }
1427}
1428#[doc = "desc TIM"]
1429pub mod tim10;
1430#[doc = "desc TIM"]
1431pub struct TIM11 {
1432 _marker: PhantomData<*const ()>,
1433}
1434unsafe impl Send for TIM11 {}
1435impl TIM11 {
1436 #[doc = r"Pointer to the register block"]
1437 pub const PTR: *const tim10::RegisterBlock = 0x4001_5400 as *const _;
1438 #[doc = r"Return the pointer to the register block"]
1439 #[inline(always)]
1440 pub const fn ptr() -> *const tim10::RegisterBlock {
1441 Self::PTR
1442 }
1443}
1444impl Deref for TIM11 {
1445 type Target = tim10::RegisterBlock;
1446 #[inline(always)]
1447 fn deref(&self) -> &Self::Target {
1448 unsafe { &*Self::PTR }
1449 }
1450}
1451impl core::fmt::Debug for TIM11 {
1452 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1453 f.debug_struct("TIM11").finish()
1454 }
1455}
1456#[doc = "desc TIM"]
1457pub use tim10 as tim11;
1458#[doc = "desc TIM"]
1459pub struct TIM12 {
1460 _marker: PhantomData<*const ()>,
1461}
1462unsafe impl Send for TIM12 {}
1463impl TIM12 {
1464 #[doc = r"Pointer to the register block"]
1465 pub const PTR: *const tim9::RegisterBlock = 0x4000_1800 as *const _;
1466 #[doc = r"Return the pointer to the register block"]
1467 #[inline(always)]
1468 pub const fn ptr() -> *const tim9::RegisterBlock {
1469 Self::PTR
1470 }
1471}
1472impl Deref for TIM12 {
1473 type Target = tim9::RegisterBlock;
1474 #[inline(always)]
1475 fn deref(&self) -> &Self::Target {
1476 unsafe { &*Self::PTR }
1477 }
1478}
1479impl core::fmt::Debug for TIM12 {
1480 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1481 f.debug_struct("TIM12").finish()
1482 }
1483}
1484#[doc = "desc TIM"]
1485pub use tim9 as tim12;
1486#[doc = "desc TIM"]
1487pub struct TIM13 {
1488 _marker: PhantomData<*const ()>,
1489}
1490unsafe impl Send for TIM13 {}
1491impl TIM13 {
1492 #[doc = r"Pointer to the register block"]
1493 pub const PTR: *const tim10::RegisterBlock = 0x4000_1c00 as *const _;
1494 #[doc = r"Return the pointer to the register block"]
1495 #[inline(always)]
1496 pub const fn ptr() -> *const tim10::RegisterBlock {
1497 Self::PTR
1498 }
1499}
1500impl Deref for TIM13 {
1501 type Target = tim10::RegisterBlock;
1502 #[inline(always)]
1503 fn deref(&self) -> &Self::Target {
1504 unsafe { &*Self::PTR }
1505 }
1506}
1507impl core::fmt::Debug for TIM13 {
1508 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1509 f.debug_struct("TIM13").finish()
1510 }
1511}
1512#[doc = "desc TIM"]
1513pub use tim10 as tim13;
1514#[doc = "desc TIM"]
1515pub struct TIM14 {
1516 _marker: PhantomData<*const ()>,
1517}
1518unsafe impl Send for TIM14 {}
1519impl TIM14 {
1520 #[doc = r"Pointer to the register block"]
1521 pub const PTR: *const tim10::RegisterBlock = 0x4000_2000 as *const _;
1522 #[doc = r"Return the pointer to the register block"]
1523 #[inline(always)]
1524 pub const fn ptr() -> *const tim10::RegisterBlock {
1525 Self::PTR
1526 }
1527}
1528impl Deref for TIM14 {
1529 type Target = tim10::RegisterBlock;
1530 #[inline(always)]
1531 fn deref(&self) -> &Self::Target {
1532 unsafe { &*Self::PTR }
1533 }
1534}
1535impl core::fmt::Debug for TIM14 {
1536 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1537 f.debug_struct("TIM14").finish()
1538 }
1539}
1540#[doc = "desc TIM"]
1541pub use tim10 as tim14;
1542#[doc = "desc USART"]
1543pub struct USART1 {
1544 _marker: PhantomData<*const ()>,
1545}
1546unsafe impl Send for USART1 {}
1547impl USART1 {
1548 #[doc = r"Pointer to the register block"]
1549 pub const PTR: *const usart1::RegisterBlock = 0x4001_3800 as *const _;
1550 #[doc = r"Return the pointer to the register block"]
1551 #[inline(always)]
1552 pub const fn ptr() -> *const usart1::RegisterBlock {
1553 Self::PTR
1554 }
1555}
1556impl Deref for USART1 {
1557 type Target = usart1::RegisterBlock;
1558 #[inline(always)]
1559 fn deref(&self) -> &Self::Target {
1560 unsafe { &*Self::PTR }
1561 }
1562}
1563impl core::fmt::Debug for USART1 {
1564 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1565 f.debug_struct("USART1").finish()
1566 }
1567}
1568#[doc = "desc USART"]
1569pub mod usart1;
1570#[doc = "desc USART"]
1571pub struct USART2 {
1572 _marker: PhantomData<*const ()>,
1573}
1574unsafe impl Send for USART2 {}
1575impl USART2 {
1576 #[doc = r"Pointer to the register block"]
1577 pub const PTR: *const usart1::RegisterBlock = 0x4000_4400 as *const _;
1578 #[doc = r"Return the pointer to the register block"]
1579 #[inline(always)]
1580 pub const fn ptr() -> *const usart1::RegisterBlock {
1581 Self::PTR
1582 }
1583}
1584impl Deref for USART2 {
1585 type Target = usart1::RegisterBlock;
1586 #[inline(always)]
1587 fn deref(&self) -> &Self::Target {
1588 unsafe { &*Self::PTR }
1589 }
1590}
1591impl core::fmt::Debug for USART2 {
1592 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1593 f.debug_struct("USART2").finish()
1594 }
1595}
1596#[doc = "desc USART"]
1597pub use usart1 as usart2;
1598#[doc = "desc USART"]
1599pub struct USART3 {
1600 _marker: PhantomData<*const ()>,
1601}
1602unsafe impl Send for USART3 {}
1603impl USART3 {
1604 #[doc = r"Pointer to the register block"]
1605 pub const PTR: *const usart1::RegisterBlock = 0x4000_4800 as *const _;
1606 #[doc = r"Return the pointer to the register block"]
1607 #[inline(always)]
1608 pub const fn ptr() -> *const usart1::RegisterBlock {
1609 Self::PTR
1610 }
1611}
1612impl Deref for USART3 {
1613 type Target = usart1::RegisterBlock;
1614 #[inline(always)]
1615 fn deref(&self) -> &Self::Target {
1616 unsafe { &*Self::PTR }
1617 }
1618}
1619impl core::fmt::Debug for USART3 {
1620 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1621 f.debug_struct("USART3").finish()
1622 }
1623}
1624#[doc = "desc USART"]
1625pub use usart1 as usart3;
1626#[doc = "desc USART"]
1627pub struct USART4 {
1628 _marker: PhantomData<*const ()>,
1629}
1630unsafe impl Send for USART4 {}
1631impl USART4 {
1632 #[doc = r"Pointer to the register block"]
1633 pub const PTR: *const usart1::RegisterBlock = 0x4000_4c00 as *const _;
1634 #[doc = r"Return the pointer to the register block"]
1635 #[inline(always)]
1636 pub const fn ptr() -> *const usart1::RegisterBlock {
1637 Self::PTR
1638 }
1639}
1640impl Deref for USART4 {
1641 type Target = usart1::RegisterBlock;
1642 #[inline(always)]
1643 fn deref(&self) -> &Self::Target {
1644 unsafe { &*Self::PTR }
1645 }
1646}
1647impl core::fmt::Debug for USART4 {
1648 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1649 f.debug_struct("USART4").finish()
1650 }
1651}
1652#[doc = "desc USART"]
1653pub use usart1 as usart4;
1654#[doc = "desc USART"]
1655pub struct USART5 {
1656 _marker: PhantomData<*const ()>,
1657}
1658unsafe impl Send for USART5 {}
1659impl USART5 {
1660 #[doc = r"Pointer to the register block"]
1661 pub const PTR: *const usart1::RegisterBlock = 0x4000_5000 as *const _;
1662 #[doc = r"Return the pointer to the register block"]
1663 #[inline(always)]
1664 pub const fn ptr() -> *const usart1::RegisterBlock {
1665 Self::PTR
1666 }
1667}
1668impl Deref for USART5 {
1669 type Target = usart1::RegisterBlock;
1670 #[inline(always)]
1671 fn deref(&self) -> &Self::Target {
1672 unsafe { &*Self::PTR }
1673 }
1674}
1675impl core::fmt::Debug for USART5 {
1676 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1677 f.debug_struct("USART5").finish()
1678 }
1679}
1680#[doc = "desc USART"]
1681pub use usart1 as usart5;
1682#[doc = "USB"]
1683pub struct USB {
1684 _marker: PhantomData<*const ()>,
1685}
1686unsafe impl Send for USB {}
1687impl USB {
1688 #[doc = r"Pointer to the register block"]
1689 pub const PTR: *const usb::RegisterBlock = 0x4000_5c00 as *const _;
1690 #[doc = r"Return the pointer to the register block"]
1691 #[inline(always)]
1692 pub const fn ptr() -> *const usb::RegisterBlock {
1693 Self::PTR
1694 }
1695}
1696impl Deref for USB {
1697 type Target = usb::RegisterBlock;
1698 #[inline(always)]
1699 fn deref(&self) -> &Self::Target {
1700 unsafe { &*Self::PTR }
1701 }
1702}
1703impl core::fmt::Debug for USB {
1704 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1705 f.debug_struct("USB").finish()
1706 }
1707}
1708#[doc = "USB"]
1709pub mod usb;
1710#[doc = "desc WWDG"]
1711pub struct WWDG {
1712 _marker: PhantomData<*const ()>,
1713}
1714unsafe impl Send for WWDG {}
1715impl WWDG {
1716 #[doc = r"Pointer to the register block"]
1717 pub const PTR: *const wwdg::RegisterBlock = 0x4000_2c00 as *const _;
1718 #[doc = r"Return the pointer to the register block"]
1719 #[inline(always)]
1720 pub const fn ptr() -> *const wwdg::RegisterBlock {
1721 Self::PTR
1722 }
1723}
1724impl Deref for WWDG {
1725 type Target = wwdg::RegisterBlock;
1726 #[inline(always)]
1727 fn deref(&self) -> &Self::Target {
1728 unsafe { &*Self::PTR }
1729 }
1730}
1731impl core::fmt::Debug for WWDG {
1732 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1733 f.debug_struct("WWDG").finish()
1734 }
1735}
1736#[doc = "desc WWDG"]
1737pub mod wwdg;
1738#[no_mangle]
1739static mut DEVICE_PERIPHERALS: bool = false;
1740#[doc = r"All the peripherals"]
1741#[allow(non_snake_case)]
1742pub struct Peripherals {
1743 #[doc = "ADC1"]
1744 pub ADC1: ADC1,
1745 #[doc = "ADC2"]
1746 pub ADC2: ADC2,
1747 #[doc = "ADC3"]
1748 pub ADC3: ADC3,
1749 #[doc = "BKP"]
1750 pub BKP: BKP,
1751 #[doc = "CANFD"]
1752 pub CANFD: CANFD,
1753 #[doc = "CRC"]
1754 pub CRC: CRC,
1755 #[doc = "CTC"]
1756 pub CTC: CTC,
1757 #[doc = "DBGMCU"]
1758 pub DBGMCU: DBGMCU,
1759 #[doc = "DMA1"]
1760 pub DMA1: DMA1,
1761 #[doc = "DMA2"]
1762 pub DMA2: DMA2,
1763 #[doc = "ESMC"]
1764 pub ESMC: ESMC,
1765 #[doc = "EXTI"]
1766 pub EXTI: EXTI,
1767 #[doc = "FLASH"]
1768 pub FLASH: FLASH,
1769 #[doc = "GPIOA"]
1770 pub GPIOA: GPIOA,
1771 #[doc = "GPIOB"]
1772 pub GPIOB: GPIOB,
1773 #[doc = "GPIOC"]
1774 pub GPIOC: GPIOC,
1775 #[doc = "GPIOD"]
1776 pub GPIOD: GPIOD,
1777 #[doc = "GPIOE"]
1778 pub GPIOE: GPIOE,
1779 #[doc = "I2C1"]
1780 pub I2C1: I2C1,
1781 #[doc = "I2C2"]
1782 pub I2C2: I2C2,
1783 #[doc = "IWDG"]
1784 pub IWDG: IWDG,
1785 #[doc = "PWR"]
1786 pub PWR: PWR,
1787 #[doc = "RCC"]
1788 pub RCC: RCC,
1789 #[doc = "RTC"]
1790 pub RTC: RTC,
1791 #[doc = "SDIO"]
1792 pub SDIO: SDIO,
1793 #[doc = "SPI1"]
1794 pub SPI1: SPI1,
1795 #[doc = "SPI2"]
1796 pub SPI2: SPI2,
1797 #[doc = "SPI3"]
1798 pub SPI3: SPI3,
1799 #[doc = "SYSCFG"]
1800 pub SYSCFG: SYSCFG,
1801 #[doc = "TIM1"]
1802 pub TIM1: TIM1,
1803 #[doc = "TIM2"]
1804 pub TIM2: TIM2,
1805 #[doc = "TIM3"]
1806 pub TIM3: TIM3,
1807 #[doc = "TIM4"]
1808 pub TIM4: TIM4,
1809 #[doc = "TIM5"]
1810 pub TIM5: TIM5,
1811 #[doc = "TIM6"]
1812 pub TIM6: TIM6,
1813 #[doc = "TIM7"]
1814 pub TIM7: TIM7,
1815 #[doc = "TIM8"]
1816 pub TIM8: TIM8,
1817 #[doc = "TIM9"]
1818 pub TIM9: TIM9,
1819 #[doc = "TIM10"]
1820 pub TIM10: TIM10,
1821 #[doc = "TIM11"]
1822 pub TIM11: TIM11,
1823 #[doc = "TIM12"]
1824 pub TIM12: TIM12,
1825 #[doc = "TIM13"]
1826 pub TIM13: TIM13,
1827 #[doc = "TIM14"]
1828 pub TIM14: TIM14,
1829 #[doc = "USART1"]
1830 pub USART1: USART1,
1831 #[doc = "USART2"]
1832 pub USART2: USART2,
1833 #[doc = "USART3"]
1834 pub USART3: USART3,
1835 #[doc = "USART4"]
1836 pub USART4: USART4,
1837 #[doc = "USART5"]
1838 pub USART5: USART5,
1839 #[doc = "USB"]
1840 pub USB: USB,
1841 #[doc = "WWDG"]
1842 pub WWDG: WWDG,
1843}
1844impl Peripherals {
1845 #[doc = r"Returns all the peripherals *once*"]
1846 #[inline]
1847 pub fn take() -> Option<Self> {
1848 cortex_m::interrupt::free(|_| {
1849 if unsafe { DEVICE_PERIPHERALS } {
1850 None
1851 } else {
1852 Some(unsafe { Peripherals::steal() })
1853 }
1854 })
1855 }
1856 #[doc = r"Unchecked version of `Peripherals::take`"]
1857 #[inline]
1858 pub unsafe fn steal() -> Self {
1859 DEVICE_PERIPHERALS = true;
1860 Peripherals {
1861 ADC1: ADC1 {
1862 _marker: PhantomData,
1863 },
1864 ADC2: ADC2 {
1865 _marker: PhantomData,
1866 },
1867 ADC3: ADC3 {
1868 _marker: PhantomData,
1869 },
1870 BKP: BKP {
1871 _marker: PhantomData,
1872 },
1873 CANFD: CANFD {
1874 _marker: PhantomData,
1875 },
1876 CRC: CRC {
1877 _marker: PhantomData,
1878 },
1879 CTC: CTC {
1880 _marker: PhantomData,
1881 },
1882 DBGMCU: DBGMCU {
1883 _marker: PhantomData,
1884 },
1885 DMA1: DMA1 {
1886 _marker: PhantomData,
1887 },
1888 DMA2: DMA2 {
1889 _marker: PhantomData,
1890 },
1891 ESMC: ESMC {
1892 _marker: PhantomData,
1893 },
1894 EXTI: EXTI {
1895 _marker: PhantomData,
1896 },
1897 FLASH: FLASH {
1898 _marker: PhantomData,
1899 },
1900 GPIOA: GPIOA {
1901 _marker: PhantomData,
1902 },
1903 GPIOB: GPIOB {
1904 _marker: PhantomData,
1905 },
1906 GPIOC: GPIOC {
1907 _marker: PhantomData,
1908 },
1909 GPIOD: GPIOD {
1910 _marker: PhantomData,
1911 },
1912 GPIOE: GPIOE {
1913 _marker: PhantomData,
1914 },
1915 I2C1: I2C1 {
1916 _marker: PhantomData,
1917 },
1918 I2C2: I2C2 {
1919 _marker: PhantomData,
1920 },
1921 IWDG: IWDG {
1922 _marker: PhantomData,
1923 },
1924 PWR: PWR {
1925 _marker: PhantomData,
1926 },
1927 RCC: RCC {
1928 _marker: PhantomData,
1929 },
1930 RTC: RTC {
1931 _marker: PhantomData,
1932 },
1933 SDIO: SDIO {
1934 _marker: PhantomData,
1935 },
1936 SPI1: SPI1 {
1937 _marker: PhantomData,
1938 },
1939 SPI2: SPI2 {
1940 _marker: PhantomData,
1941 },
1942 SPI3: SPI3 {
1943 _marker: PhantomData,
1944 },
1945 SYSCFG: SYSCFG {
1946 _marker: PhantomData,
1947 },
1948 TIM1: TIM1 {
1949 _marker: PhantomData,
1950 },
1951 TIM2: TIM2 {
1952 _marker: PhantomData,
1953 },
1954 TIM3: TIM3 {
1955 _marker: PhantomData,
1956 },
1957 TIM4: TIM4 {
1958 _marker: PhantomData,
1959 },
1960 TIM5: TIM5 {
1961 _marker: PhantomData,
1962 },
1963 TIM6: TIM6 {
1964 _marker: PhantomData,
1965 },
1966 TIM7: TIM7 {
1967 _marker: PhantomData,
1968 },
1969 TIM8: TIM8 {
1970 _marker: PhantomData,
1971 },
1972 TIM9: TIM9 {
1973 _marker: PhantomData,
1974 },
1975 TIM10: TIM10 {
1976 _marker: PhantomData,
1977 },
1978 TIM11: TIM11 {
1979 _marker: PhantomData,
1980 },
1981 TIM12: TIM12 {
1982 _marker: PhantomData,
1983 },
1984 TIM13: TIM13 {
1985 _marker: PhantomData,
1986 },
1987 TIM14: TIM14 {
1988 _marker: PhantomData,
1989 },
1990 USART1: USART1 {
1991 _marker: PhantomData,
1992 },
1993 USART2: USART2 {
1994 _marker: PhantomData,
1995 },
1996 USART3: USART3 {
1997 _marker: PhantomData,
1998 },
1999 USART4: USART4 {
2000 _marker: PhantomData,
2001 },
2002 USART5: USART5 {
2003 _marker: PhantomData,
2004 },
2005 USB: USB {
2006 _marker: PhantomData,
2007 },
2008 WWDG: WWDG {
2009 _marker: PhantomData,
2010 },
2011 }
2012 }
2013}