1#![doc = "Peripheral access API for STM32F0X0 microcontrollers (generated using svd2rust v0.24.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.24.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"]
3use core::marker::PhantomData;
4use core::ops::Deref;
5#[doc = r"Number available in the NVIC for configuring priority"]
6pub const NVIC_PRIO_BITS: u8 = 2;
7#[cfg(feature = "rt")]
8pub use self::Interrupt as interrupt;
9pub use cortex_m::peripheral::Peripherals as CorePeripherals;
10pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, ITM, MPU, NVIC, SCB, SYST, TPIU};
11#[cfg(feature = "rt")]
12pub use cortex_m_rt::interrupt;
13#[cfg(feature = "rt")]
14extern "C" {
15 fn WWDG();
16 fn PVD();
17 fn RTC();
18 fn FLASH();
19 fn RCC();
20 fn EXTI0_1();
21 fn EXTI2_3();
22 fn EXTI4_15();
23 fn DMA1_CH1();
24 fn DMA1_CH2_3();
25 fn DMA1_CH4_5();
26 fn ADC();
27 fn TIM1_BRK_UP_TRG_COM();
28 fn TIM1_CC();
29 fn TIM3();
30 fn TIM6();
31 fn TIM14();
32 fn TIM15();
33 fn TIM16();
34 fn TIM17();
35 fn I2C1();
36 fn I2C2();
37 fn SPI1();
38 fn SPI2();
39 fn USART1();
40 fn USART2();
41 fn USART3_4_5_6();
42 fn USB();
43}
44#[doc(hidden)]
45pub union Vector {
46 _handler: unsafe extern "C" fn(),
47 _reserved: u32,
48}
49#[cfg(feature = "rt")]
50#[doc(hidden)]
51#[link_section = ".vector_table.interrupts"]
52#[no_mangle]
53pub static __INTERRUPTS: [Vector; 32] = [
54 Vector { _handler: WWDG },
55 Vector { _handler: PVD },
56 Vector { _handler: RTC },
57 Vector { _handler: FLASH },
58 Vector { _handler: RCC },
59 Vector { _handler: EXTI0_1 },
60 Vector { _handler: EXTI2_3 },
61 Vector { _handler: EXTI4_15 },
62 Vector { _reserved: 0 },
63 Vector { _handler: DMA1_CH1 },
64 Vector {
65 _handler: DMA1_CH2_3,
66 },
67 Vector {
68 _handler: DMA1_CH4_5,
69 },
70 Vector { _handler: ADC },
71 Vector {
72 _handler: TIM1_BRK_UP_TRG_COM,
73 },
74 Vector { _handler: TIM1_CC },
75 Vector { _reserved: 0 },
76 Vector { _handler: TIM3 },
77 Vector { _handler: TIM6 },
78 Vector { _reserved: 0 },
79 Vector { _handler: TIM14 },
80 Vector { _handler: TIM15 },
81 Vector { _handler: TIM16 },
82 Vector { _handler: TIM17 },
83 Vector { _handler: I2C1 },
84 Vector { _handler: I2C2 },
85 Vector { _handler: SPI1 },
86 Vector { _handler: SPI2 },
87 Vector { _handler: USART1 },
88 Vector { _handler: USART2 },
89 Vector {
90 _handler: USART3_4_5_6,
91 },
92 Vector { _reserved: 0 },
93 Vector { _handler: USB },
94];
95#[doc = r"Enumeration of all the interrupts."]
96#[derive(Copy, Clone, Debug, PartialEq, Eq)]
97#[repr(u16)]
98pub enum Interrupt {
99 #[doc = "0 - Window Watchdog interrupt"]
100 WWDG = 0,
101 #[doc = "1 - PVD and VDDIO2 supply comparator interrupt"]
102 PVD = 1,
103 #[doc = "2 - RTC interrupts"]
104 RTC = 2,
105 #[doc = "3 - Flash global interrupt"]
106 FLASH = 3,
107 #[doc = "4 - RCC global interruptr"]
108 RCC = 4,
109 #[doc = "5 - EXTI Line\\[1:0\\]
110interrupts"]
111 EXTI0_1 = 5,
112 #[doc = "6 - EXTI Line\\[3:2\\]
113interrupts"]
114 EXTI2_3 = 6,
115 #[doc = "7 - EXTI Line15 and EXTI4 interrupts"]
116 EXTI4_15 = 7,
117 #[doc = "9 - DMA1 channel 1 interrupt"]
118 DMA1_CH1 = 9,
119 #[doc = "10 - DMA1 channel 2 and 3 interrupt"]
120 DMA1_CH2_3 = 10,
121 #[doc = "11 - DMA1 channel 4 and 5 interrupt"]
122 DMA1_CH4_5 = 11,
123 #[doc = "12 - ADC interrupt"]
124 ADC = 12,
125 #[doc = "13 - TIM1 break, update, trigger and commutation interrupt"]
126 TIM1_BRK_UP_TRG_COM = 13,
127 #[doc = "14 - TIM1 Capture Compare interrupt"]
128 TIM1_CC = 14,
129 #[doc = "16 - TIM3 global interrupt"]
130 TIM3 = 16,
131 #[doc = "17 - TIM6 global interrupt"]
132 TIM6 = 17,
133 #[doc = "19 - TIM14 global interrupt"]
134 TIM14 = 19,
135 #[doc = "20 - TIM15 global interrupt"]
136 TIM15 = 20,
137 #[doc = "21 - TIM16 global interrupt"]
138 TIM16 = 21,
139 #[doc = "22 - TIM17 global interrupt"]
140 TIM17 = 22,
141 #[doc = "23 - I2C1 global interrupt"]
142 I2C1 = 23,
143 #[doc = "24 - I2C2 global interrupt"]
144 I2C2 = 24,
145 #[doc = "25 - SPI1_global_interrupt"]
146 SPI1 = 25,
147 #[doc = "26 - SPI2 global interrupt"]
148 SPI2 = 26,
149 #[doc = "27 - USART1 global interrupt"]
150 USART1 = 27,
151 #[doc = "28 - USART2 global interrupt"]
152 USART2 = 28,
153 #[doc = "29 - USART3, USART4, USART5, USART6 global interrupt"]
154 USART3_4_5_6 = 29,
155 #[doc = "31 - USB global interrupt"]
156 USB = 31,
157}
158unsafe impl cortex_m::interrupt::InterruptNumber for Interrupt {
159 #[inline(always)]
160 fn number(self) -> u16 {
161 self as u16
162 }
163}
164#[doc = "cyclic redundancy check calculation unit"]
165pub struct CRC {
166 _marker: PhantomData<*const ()>,
167}
168unsafe impl Send for CRC {}
169impl CRC {
170 #[doc = r"Pointer to the register block"]
171 pub const PTR: *const crc::RegisterBlock = 0x4002_3000 as *const _;
172 #[doc = r"Return the pointer to the register block"]
173 #[inline(always)]
174 pub const fn ptr() -> *const crc::RegisterBlock {
175 Self::PTR
176 }
177}
178impl Deref for CRC {
179 type Target = crc::RegisterBlock;
180 #[inline(always)]
181 fn deref(&self) -> &Self::Target {
182 unsafe { &*Self::PTR }
183 }
184}
185impl core::fmt::Debug for CRC {
186 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
187 f.debug_struct("CRC").finish()
188 }
189}
190#[doc = "cyclic redundancy check calculation unit"]
191pub mod crc;
192#[doc = "General-purpose I/Os"]
193pub struct GPIOF {
194 _marker: PhantomData<*const ()>,
195}
196unsafe impl Send for GPIOF {}
197impl GPIOF {
198 #[doc = r"Pointer to the register block"]
199 pub const PTR: *const gpiof::RegisterBlock = 0x4800_1400 as *const _;
200 #[doc = r"Return the pointer to the register block"]
201 #[inline(always)]
202 pub const fn ptr() -> *const gpiof::RegisterBlock {
203 Self::PTR
204 }
205}
206impl Deref for GPIOF {
207 type Target = gpiof::RegisterBlock;
208 #[inline(always)]
209 fn deref(&self) -> &Self::Target {
210 unsafe { &*Self::PTR }
211 }
212}
213impl core::fmt::Debug for GPIOF {
214 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
215 f.debug_struct("GPIOF").finish()
216 }
217}
218#[doc = "General-purpose I/Os"]
219pub mod gpiof;
220#[doc = "General-purpose I/Os"]
221pub struct GPIOD {
222 _marker: PhantomData<*const ()>,
223}
224unsafe impl Send for GPIOD {}
225impl GPIOD {
226 #[doc = r"Pointer to the register block"]
227 pub const PTR: *const gpiof::RegisterBlock = 0x4800_0c00 as *const _;
228 #[doc = r"Return the pointer to the register block"]
229 #[inline(always)]
230 pub const fn ptr() -> *const gpiof::RegisterBlock {
231 Self::PTR
232 }
233}
234impl Deref for GPIOD {
235 type Target = gpiof::RegisterBlock;
236 #[inline(always)]
237 fn deref(&self) -> &Self::Target {
238 unsafe { &*Self::PTR }
239 }
240}
241impl core::fmt::Debug for GPIOD {
242 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
243 f.debug_struct("GPIOD").finish()
244 }
245}
246#[doc = "General-purpose I/Os"]
247pub use gpiof as gpiod;
248#[doc = "General-purpose I/Os"]
249pub struct GPIOC {
250 _marker: PhantomData<*const ()>,
251}
252unsafe impl Send for GPIOC {}
253impl GPIOC {
254 #[doc = r"Pointer to the register block"]
255 pub const PTR: *const gpiof::RegisterBlock = 0x4800_0800 as *const _;
256 #[doc = r"Return the pointer to the register block"]
257 #[inline(always)]
258 pub const fn ptr() -> *const gpiof::RegisterBlock {
259 Self::PTR
260 }
261}
262impl Deref for GPIOC {
263 type Target = gpiof::RegisterBlock;
264 #[inline(always)]
265 fn deref(&self) -> &Self::Target {
266 unsafe { &*Self::PTR }
267 }
268}
269impl core::fmt::Debug for GPIOC {
270 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
271 f.debug_struct("GPIOC").finish()
272 }
273}
274#[doc = "General-purpose I/Os"]
275pub use gpiof as gpioc;
276#[doc = "General-purpose I/Os"]
277pub struct GPIOB {
278 _marker: PhantomData<*const ()>,
279}
280unsafe impl Send for GPIOB {}
281impl GPIOB {
282 #[doc = r"Pointer to the register block"]
283 pub const PTR: *const gpiof::RegisterBlock = 0x4800_0400 as *const _;
284 #[doc = r"Return the pointer to the register block"]
285 #[inline(always)]
286 pub const fn ptr() -> *const gpiof::RegisterBlock {
287 Self::PTR
288 }
289}
290impl Deref for GPIOB {
291 type Target = gpiof::RegisterBlock;
292 #[inline(always)]
293 fn deref(&self) -> &Self::Target {
294 unsafe { &*Self::PTR }
295 }
296}
297impl core::fmt::Debug for GPIOB {
298 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
299 f.debug_struct("GPIOB").finish()
300 }
301}
302#[doc = "General-purpose I/Os"]
303pub use gpiof as gpiob;
304#[doc = "General-purpose I/Os"]
305pub struct GPIOA {
306 _marker: PhantomData<*const ()>,
307}
308unsafe impl Send for GPIOA {}
309impl GPIOA {
310 #[doc = r"Pointer to the register block"]
311 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0000 as *const _;
312 #[doc = r"Return the pointer to the register block"]
313 #[inline(always)]
314 pub const fn ptr() -> *const gpioa::RegisterBlock {
315 Self::PTR
316 }
317}
318impl Deref for GPIOA {
319 type Target = gpioa::RegisterBlock;
320 #[inline(always)]
321 fn deref(&self) -> &Self::Target {
322 unsafe { &*Self::PTR }
323 }
324}
325impl core::fmt::Debug for GPIOA {
326 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
327 f.debug_struct("GPIOA").finish()
328 }
329}
330#[doc = "General-purpose I/Os"]
331pub mod gpioa;
332#[doc = "Serial peripheral interface"]
333pub struct SPI1 {
334 _marker: PhantomData<*const ()>,
335}
336unsafe impl Send for SPI1 {}
337impl SPI1 {
338 #[doc = r"Pointer to the register block"]
339 pub const PTR: *const spi1::RegisterBlock = 0x4001_3000 as *const _;
340 #[doc = r"Return the pointer to the register block"]
341 #[inline(always)]
342 pub const fn ptr() -> *const spi1::RegisterBlock {
343 Self::PTR
344 }
345}
346impl Deref for SPI1 {
347 type Target = spi1::RegisterBlock;
348 #[inline(always)]
349 fn deref(&self) -> &Self::Target {
350 unsafe { &*Self::PTR }
351 }
352}
353impl core::fmt::Debug for SPI1 {
354 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
355 f.debug_struct("SPI1").finish()
356 }
357}
358#[doc = "Serial peripheral interface"]
359pub mod spi1;
360#[doc = "Serial peripheral interface"]
361pub struct SPI2 {
362 _marker: PhantomData<*const ()>,
363}
364unsafe impl Send for SPI2 {}
365impl SPI2 {
366 #[doc = r"Pointer to the register block"]
367 pub const PTR: *const spi1::RegisterBlock = 0x4000_3800 as *const _;
368 #[doc = r"Return the pointer to the register block"]
369 #[inline(always)]
370 pub const fn ptr() -> *const spi1::RegisterBlock {
371 Self::PTR
372 }
373}
374impl Deref for SPI2 {
375 type Target = spi1::RegisterBlock;
376 #[inline(always)]
377 fn deref(&self) -> &Self::Target {
378 unsafe { &*Self::PTR }
379 }
380}
381impl core::fmt::Debug for SPI2 {
382 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
383 f.debug_struct("SPI2").finish()
384 }
385}
386#[doc = "Serial peripheral interface"]
387pub use spi1 as spi2;
388#[doc = "Power control"]
389pub struct PWR {
390 _marker: PhantomData<*const ()>,
391}
392unsafe impl Send for PWR {}
393impl PWR {
394 #[doc = r"Pointer to the register block"]
395 pub const PTR: *const pwr::RegisterBlock = 0x4000_7000 as *const _;
396 #[doc = r"Return the pointer to the register block"]
397 #[inline(always)]
398 pub const fn ptr() -> *const pwr::RegisterBlock {
399 Self::PTR
400 }
401}
402impl Deref for PWR {
403 type Target = pwr::RegisterBlock;
404 #[inline(always)]
405 fn deref(&self) -> &Self::Target {
406 unsafe { &*Self::PTR }
407 }
408}
409impl core::fmt::Debug for PWR {
410 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
411 f.debug_struct("PWR").finish()
412 }
413}
414#[doc = "Power control"]
415pub mod pwr;
416#[doc = "Inter-integrated circuit"]
417pub struct I2C1 {
418 _marker: PhantomData<*const ()>,
419}
420unsafe impl Send for I2C1 {}
421impl I2C1 {
422 #[doc = r"Pointer to the register block"]
423 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5400 as *const _;
424 #[doc = r"Return the pointer to the register block"]
425 #[inline(always)]
426 pub const fn ptr() -> *const i2c1::RegisterBlock {
427 Self::PTR
428 }
429}
430impl Deref for I2C1 {
431 type Target = i2c1::RegisterBlock;
432 #[inline(always)]
433 fn deref(&self) -> &Self::Target {
434 unsafe { &*Self::PTR }
435 }
436}
437impl core::fmt::Debug for I2C1 {
438 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
439 f.debug_struct("I2C1").finish()
440 }
441}
442#[doc = "Inter-integrated circuit"]
443pub mod i2c1;
444#[doc = "Inter-integrated circuit"]
445pub struct I2C2 {
446 _marker: PhantomData<*const ()>,
447}
448unsafe impl Send for I2C2 {}
449impl I2C2 {
450 #[doc = r"Pointer to the register block"]
451 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5800 as *const _;
452 #[doc = r"Return the pointer to the register block"]
453 #[inline(always)]
454 pub const fn ptr() -> *const i2c1::RegisterBlock {
455 Self::PTR
456 }
457}
458impl Deref for I2C2 {
459 type Target = i2c1::RegisterBlock;
460 #[inline(always)]
461 fn deref(&self) -> &Self::Target {
462 unsafe { &*Self::PTR }
463 }
464}
465impl core::fmt::Debug for I2C2 {
466 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
467 f.debug_struct("I2C2").finish()
468 }
469}
470#[doc = "Inter-integrated circuit"]
471pub use i2c1 as i2c2;
472#[doc = "Independent watchdog"]
473pub struct IWDG {
474 _marker: PhantomData<*const ()>,
475}
476unsafe impl Send for IWDG {}
477impl IWDG {
478 #[doc = r"Pointer to the register block"]
479 pub const PTR: *const iwdg::RegisterBlock = 0x4000_3000 as *const _;
480 #[doc = r"Return the pointer to the register block"]
481 #[inline(always)]
482 pub const fn ptr() -> *const iwdg::RegisterBlock {
483 Self::PTR
484 }
485}
486impl Deref for IWDG {
487 type Target = iwdg::RegisterBlock;
488 #[inline(always)]
489 fn deref(&self) -> &Self::Target {
490 unsafe { &*Self::PTR }
491 }
492}
493impl core::fmt::Debug for IWDG {
494 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
495 f.debug_struct("IWDG").finish()
496 }
497}
498#[doc = "Independent watchdog"]
499pub mod iwdg;
500#[doc = "Window watchdog"]
501pub struct WWDG {
502 _marker: PhantomData<*const ()>,
503}
504unsafe impl Send for WWDG {}
505impl WWDG {
506 #[doc = r"Pointer to the register block"]
507 pub const PTR: *const wwdg::RegisterBlock = 0x4000_2c00 as *const _;
508 #[doc = r"Return the pointer to the register block"]
509 #[inline(always)]
510 pub const fn ptr() -> *const wwdg::RegisterBlock {
511 Self::PTR
512 }
513}
514impl Deref for WWDG {
515 type Target = wwdg::RegisterBlock;
516 #[inline(always)]
517 fn deref(&self) -> &Self::Target {
518 unsafe { &*Self::PTR }
519 }
520}
521impl core::fmt::Debug for WWDG {
522 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
523 f.debug_struct("WWDG").finish()
524 }
525}
526#[doc = "Window watchdog"]
527pub mod wwdg;
528#[doc = "Advanced-timers"]
529pub struct TIM1 {
530 _marker: PhantomData<*const ()>,
531}
532unsafe impl Send for TIM1 {}
533impl TIM1 {
534 #[doc = r"Pointer to the register block"]
535 pub const PTR: *const tim1::RegisterBlock = 0x4001_2c00 as *const _;
536 #[doc = r"Return the pointer to the register block"]
537 #[inline(always)]
538 pub const fn ptr() -> *const tim1::RegisterBlock {
539 Self::PTR
540 }
541}
542impl Deref for TIM1 {
543 type Target = tim1::RegisterBlock;
544 #[inline(always)]
545 fn deref(&self) -> &Self::Target {
546 unsafe { &*Self::PTR }
547 }
548}
549impl core::fmt::Debug for TIM1 {
550 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
551 f.debug_struct("TIM1").finish()
552 }
553}
554#[doc = "Advanced-timers"]
555pub mod tim1;
556#[doc = "General-purpose-timers"]
557pub struct TIM3 {
558 _marker: PhantomData<*const ()>,
559}
560unsafe impl Send for TIM3 {}
561impl TIM3 {
562 #[doc = r"Pointer to the register block"]
563 pub const PTR: *const tim3::RegisterBlock = 0x4000_0400 as *const _;
564 #[doc = r"Return the pointer to the register block"]
565 #[inline(always)]
566 pub const fn ptr() -> *const tim3::RegisterBlock {
567 Self::PTR
568 }
569}
570impl Deref for TIM3 {
571 type Target = tim3::RegisterBlock;
572 #[inline(always)]
573 fn deref(&self) -> &Self::Target {
574 unsafe { &*Self::PTR }
575 }
576}
577impl core::fmt::Debug for TIM3 {
578 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
579 f.debug_struct("TIM3").finish()
580 }
581}
582#[doc = "General-purpose-timers"]
583pub mod tim3;
584#[doc = "General-purpose-timers"]
585pub struct TIM14 {
586 _marker: PhantomData<*const ()>,
587}
588unsafe impl Send for TIM14 {}
589impl TIM14 {
590 #[doc = r"Pointer to the register block"]
591 pub const PTR: *const tim14::RegisterBlock = 0x4000_2000 as *const _;
592 #[doc = r"Return the pointer to the register block"]
593 #[inline(always)]
594 pub const fn ptr() -> *const tim14::RegisterBlock {
595 Self::PTR
596 }
597}
598impl Deref for TIM14 {
599 type Target = tim14::RegisterBlock;
600 #[inline(always)]
601 fn deref(&self) -> &Self::Target {
602 unsafe { &*Self::PTR }
603 }
604}
605impl core::fmt::Debug for TIM14 {
606 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
607 f.debug_struct("TIM14").finish()
608 }
609}
610#[doc = "General-purpose-timers"]
611pub mod tim14;
612#[doc = "Basic-timers"]
613pub struct TIM6 {
614 _marker: PhantomData<*const ()>,
615}
616unsafe impl Send for TIM6 {}
617impl TIM6 {
618 #[doc = r"Pointer to the register block"]
619 pub const PTR: *const tim6::RegisterBlock = 0x4000_1000 as *const _;
620 #[doc = r"Return the pointer to the register block"]
621 #[inline(always)]
622 pub const fn ptr() -> *const tim6::RegisterBlock {
623 Self::PTR
624 }
625}
626impl Deref for TIM6 {
627 type Target = tim6::RegisterBlock;
628 #[inline(always)]
629 fn deref(&self) -> &Self::Target {
630 unsafe { &*Self::PTR }
631 }
632}
633impl core::fmt::Debug for TIM6 {
634 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
635 f.debug_struct("TIM6").finish()
636 }
637}
638#[doc = "Basic-timers"]
639pub mod tim6;
640#[doc = "Basic-timers"]
641pub struct TIM7 {
642 _marker: PhantomData<*const ()>,
643}
644unsafe impl Send for TIM7 {}
645impl TIM7 {
646 #[doc = r"Pointer to the register block"]
647 pub const PTR: *const tim6::RegisterBlock = 0x4000_1400 as *const _;
648 #[doc = r"Return the pointer to the register block"]
649 #[inline(always)]
650 pub const fn ptr() -> *const tim6::RegisterBlock {
651 Self::PTR
652 }
653}
654impl Deref for TIM7 {
655 type Target = tim6::RegisterBlock;
656 #[inline(always)]
657 fn deref(&self) -> &Self::Target {
658 unsafe { &*Self::PTR }
659 }
660}
661impl core::fmt::Debug for TIM7 {
662 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
663 f.debug_struct("TIM7").finish()
664 }
665}
666#[doc = "Basic-timers"]
667pub use tim6 as tim7;
668#[doc = "External interrupt/event controller"]
669pub struct EXTI {
670 _marker: PhantomData<*const ()>,
671}
672unsafe impl Send for EXTI {}
673impl EXTI {
674 #[doc = r"Pointer to the register block"]
675 pub const PTR: *const exti::RegisterBlock = 0x4001_0400 as *const _;
676 #[doc = r"Return the pointer to the register block"]
677 #[inline(always)]
678 pub const fn ptr() -> *const exti::RegisterBlock {
679 Self::PTR
680 }
681}
682impl Deref for EXTI {
683 type Target = exti::RegisterBlock;
684 #[inline(always)]
685 fn deref(&self) -> &Self::Target {
686 unsafe { &*Self::PTR }
687 }
688}
689impl core::fmt::Debug for EXTI {
690 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
691 f.debug_struct("EXTI").finish()
692 }
693}
694#[doc = "External interrupt/event controller"]
695pub mod exti;
696#[doc = "DMA controller"]
697pub struct DMA1 {
698 _marker: PhantomData<*const ()>,
699}
700unsafe impl Send for DMA1 {}
701impl DMA1 {
702 #[doc = r"Pointer to the register block"]
703 pub const PTR: *const dma1::RegisterBlock = 0x4002_0000 as *const _;
704 #[doc = r"Return the pointer to the register block"]
705 #[inline(always)]
706 pub const fn ptr() -> *const dma1::RegisterBlock {
707 Self::PTR
708 }
709}
710impl Deref for DMA1 {
711 type Target = dma1::RegisterBlock;
712 #[inline(always)]
713 fn deref(&self) -> &Self::Target {
714 unsafe { &*Self::PTR }
715 }
716}
717impl core::fmt::Debug for DMA1 {
718 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
719 f.debug_struct("DMA1").finish()
720 }
721}
722#[doc = "DMA controller"]
723pub mod dma1;
724#[doc = "Reset and clock control"]
725pub struct RCC {
726 _marker: PhantomData<*const ()>,
727}
728unsafe impl Send for RCC {}
729impl RCC {
730 #[doc = r"Pointer to the register block"]
731 pub const PTR: *const rcc::RegisterBlock = 0x4002_1000 as *const _;
732 #[doc = r"Return the pointer to the register block"]
733 #[inline(always)]
734 pub const fn ptr() -> *const rcc::RegisterBlock {
735 Self::PTR
736 }
737}
738impl Deref for RCC {
739 type Target = rcc::RegisterBlock;
740 #[inline(always)]
741 fn deref(&self) -> &Self::Target {
742 unsafe { &*Self::PTR }
743 }
744}
745impl core::fmt::Debug for RCC {
746 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
747 f.debug_struct("RCC").finish()
748 }
749}
750#[doc = "Reset and clock control"]
751pub mod rcc;
752#[doc = "System configuration controller"]
753pub struct SYSCFG {
754 _marker: PhantomData<*const ()>,
755}
756unsafe impl Send for SYSCFG {}
757impl SYSCFG {
758 #[doc = r"Pointer to the register block"]
759 pub const PTR: *const syscfg::RegisterBlock = 0x4001_0000 as *const _;
760 #[doc = r"Return the pointer to the register block"]
761 #[inline(always)]
762 pub const fn ptr() -> *const syscfg::RegisterBlock {
763 Self::PTR
764 }
765}
766impl Deref for SYSCFG {
767 type Target = syscfg::RegisterBlock;
768 #[inline(always)]
769 fn deref(&self) -> &Self::Target {
770 unsafe { &*Self::PTR }
771 }
772}
773impl core::fmt::Debug for SYSCFG {
774 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
775 f.debug_struct("SYSCFG").finish()
776 }
777}
778#[doc = "System configuration controller"]
779pub mod syscfg;
780#[doc = "Analog-to-digital converter"]
781pub struct ADC {
782 _marker: PhantomData<*const ()>,
783}
784unsafe impl Send for ADC {}
785impl ADC {
786 #[doc = r"Pointer to the register block"]
787 pub const PTR: *const adc::RegisterBlock = 0x4001_2400 as *const _;
788 #[doc = r"Return the pointer to the register block"]
789 #[inline(always)]
790 pub const fn ptr() -> *const adc::RegisterBlock {
791 Self::PTR
792 }
793}
794impl Deref for ADC {
795 type Target = adc::RegisterBlock;
796 #[inline(always)]
797 fn deref(&self) -> &Self::Target {
798 unsafe { &*Self::PTR }
799 }
800}
801impl core::fmt::Debug for ADC {
802 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
803 f.debug_struct("ADC").finish()
804 }
805}
806#[doc = "Analog-to-digital converter"]
807pub mod adc;
808#[doc = "Universal synchronous asynchronous receiver transmitter"]
809pub struct USART1 {
810 _marker: PhantomData<*const ()>,
811}
812unsafe impl Send for USART1 {}
813impl USART1 {
814 #[doc = r"Pointer to the register block"]
815 pub const PTR: *const usart1::RegisterBlock = 0x4001_3800 as *const _;
816 #[doc = r"Return the pointer to the register block"]
817 #[inline(always)]
818 pub const fn ptr() -> *const usart1::RegisterBlock {
819 Self::PTR
820 }
821}
822impl Deref for USART1 {
823 type Target = usart1::RegisterBlock;
824 #[inline(always)]
825 fn deref(&self) -> &Self::Target {
826 unsafe { &*Self::PTR }
827 }
828}
829impl core::fmt::Debug for USART1 {
830 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
831 f.debug_struct("USART1").finish()
832 }
833}
834#[doc = "Universal synchronous asynchronous receiver transmitter"]
835pub mod usart1;
836#[doc = "Universal synchronous asynchronous receiver transmitter"]
837pub struct USART2 {
838 _marker: PhantomData<*const ()>,
839}
840unsafe impl Send for USART2 {}
841impl USART2 {
842 #[doc = r"Pointer to the register block"]
843 pub const PTR: *const usart1::RegisterBlock = 0x4000_4400 as *const _;
844 #[doc = r"Return the pointer to the register block"]
845 #[inline(always)]
846 pub const fn ptr() -> *const usart1::RegisterBlock {
847 Self::PTR
848 }
849}
850impl Deref for USART2 {
851 type Target = usart1::RegisterBlock;
852 #[inline(always)]
853 fn deref(&self) -> &Self::Target {
854 unsafe { &*Self::PTR }
855 }
856}
857impl core::fmt::Debug for USART2 {
858 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
859 f.debug_struct("USART2").finish()
860 }
861}
862#[doc = "Universal synchronous asynchronous receiver transmitter"]
863pub use usart1 as usart2;
864#[doc = "Universal synchronous asynchronous receiver transmitter"]
865pub struct USART3 {
866 _marker: PhantomData<*const ()>,
867}
868unsafe impl Send for USART3 {}
869impl USART3 {
870 #[doc = r"Pointer to the register block"]
871 pub const PTR: *const usart1::RegisterBlock = 0x4000_4800 as *const _;
872 #[doc = r"Return the pointer to the register block"]
873 #[inline(always)]
874 pub const fn ptr() -> *const usart1::RegisterBlock {
875 Self::PTR
876 }
877}
878impl Deref for USART3 {
879 type Target = usart1::RegisterBlock;
880 #[inline(always)]
881 fn deref(&self) -> &Self::Target {
882 unsafe { &*Self::PTR }
883 }
884}
885impl core::fmt::Debug for USART3 {
886 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
887 f.debug_struct("USART3").finish()
888 }
889}
890#[doc = "Universal synchronous asynchronous receiver transmitter"]
891pub use usart1 as usart3;
892#[doc = "Universal synchronous asynchronous receiver transmitter"]
893pub struct USART4 {
894 _marker: PhantomData<*const ()>,
895}
896unsafe impl Send for USART4 {}
897impl USART4 {
898 #[doc = r"Pointer to the register block"]
899 pub const PTR: *const usart1::RegisterBlock = 0x4000_4c00 as *const _;
900 #[doc = r"Return the pointer to the register block"]
901 #[inline(always)]
902 pub const fn ptr() -> *const usart1::RegisterBlock {
903 Self::PTR
904 }
905}
906impl Deref for USART4 {
907 type Target = usart1::RegisterBlock;
908 #[inline(always)]
909 fn deref(&self) -> &Self::Target {
910 unsafe { &*Self::PTR }
911 }
912}
913impl core::fmt::Debug for USART4 {
914 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
915 f.debug_struct("USART4").finish()
916 }
917}
918#[doc = "Universal synchronous asynchronous receiver transmitter"]
919pub use usart1 as usart4;
920#[doc = "Universal synchronous asynchronous receiver transmitter"]
921pub struct USART6 {
922 _marker: PhantomData<*const ()>,
923}
924unsafe impl Send for USART6 {}
925impl USART6 {
926 #[doc = r"Pointer to the register block"]
927 pub const PTR: *const usart1::RegisterBlock = 0x4001_1400 as *const _;
928 #[doc = r"Return the pointer to the register block"]
929 #[inline(always)]
930 pub const fn ptr() -> *const usart1::RegisterBlock {
931 Self::PTR
932 }
933}
934impl Deref for USART6 {
935 type Target = usart1::RegisterBlock;
936 #[inline(always)]
937 fn deref(&self) -> &Self::Target {
938 unsafe { &*Self::PTR }
939 }
940}
941impl core::fmt::Debug for USART6 {
942 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
943 f.debug_struct("USART6").finish()
944 }
945}
946#[doc = "Universal synchronous asynchronous receiver transmitter"]
947pub use usart1 as usart6;
948#[doc = "Universal synchronous asynchronous receiver transmitter"]
949pub struct USART5 {
950 _marker: PhantomData<*const ()>,
951}
952unsafe impl Send for USART5 {}
953impl USART5 {
954 #[doc = r"Pointer to the register block"]
955 pub const PTR: *const usart1::RegisterBlock = 0x4000_5000 as *const _;
956 #[doc = r"Return the pointer to the register block"]
957 #[inline(always)]
958 pub const fn ptr() -> *const usart1::RegisterBlock {
959 Self::PTR
960 }
961}
962impl Deref for USART5 {
963 type Target = usart1::RegisterBlock;
964 #[inline(always)]
965 fn deref(&self) -> &Self::Target {
966 unsafe { &*Self::PTR }
967 }
968}
969impl core::fmt::Debug for USART5 {
970 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
971 f.debug_struct("USART5").finish()
972 }
973}
974#[doc = "Universal synchronous asynchronous receiver transmitter"]
975pub use usart1 as usart5;
976#[doc = "Real-time clock"]
977pub struct RTC {
978 _marker: PhantomData<*const ()>,
979}
980unsafe impl Send for RTC {}
981impl RTC {
982 #[doc = r"Pointer to the register block"]
983 pub const PTR: *const rtc::RegisterBlock = 0x4000_2800 as *const _;
984 #[doc = r"Return the pointer to the register block"]
985 #[inline(always)]
986 pub const fn ptr() -> *const rtc::RegisterBlock {
987 Self::PTR
988 }
989}
990impl Deref for RTC {
991 type Target = rtc::RegisterBlock;
992 #[inline(always)]
993 fn deref(&self) -> &Self::Target {
994 unsafe { &*Self::PTR }
995 }
996}
997impl core::fmt::Debug for RTC {
998 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
999 f.debug_struct("RTC").finish()
1000 }
1001}
1002#[doc = "Real-time clock"]
1003pub mod rtc;
1004#[doc = "General-purpose-timers"]
1005pub struct TIM15 {
1006 _marker: PhantomData<*const ()>,
1007}
1008unsafe impl Send for TIM15 {}
1009impl TIM15 {
1010 #[doc = r"Pointer to the register block"]
1011 pub const PTR: *const tim15::RegisterBlock = 0x4001_4000 as *const _;
1012 #[doc = r"Return the pointer to the register block"]
1013 #[inline(always)]
1014 pub const fn ptr() -> *const tim15::RegisterBlock {
1015 Self::PTR
1016 }
1017}
1018impl Deref for TIM15 {
1019 type Target = tim15::RegisterBlock;
1020 #[inline(always)]
1021 fn deref(&self) -> &Self::Target {
1022 unsafe { &*Self::PTR }
1023 }
1024}
1025impl core::fmt::Debug for TIM15 {
1026 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1027 f.debug_struct("TIM15").finish()
1028 }
1029}
1030#[doc = "General-purpose-timers"]
1031pub mod tim15;
1032#[doc = "General-purpose-timers"]
1033pub struct TIM16 {
1034 _marker: PhantomData<*const ()>,
1035}
1036unsafe impl Send for TIM16 {}
1037impl TIM16 {
1038 #[doc = r"Pointer to the register block"]
1039 pub const PTR: *const tim16::RegisterBlock = 0x4001_4400 as *const _;
1040 #[doc = r"Return the pointer to the register block"]
1041 #[inline(always)]
1042 pub const fn ptr() -> *const tim16::RegisterBlock {
1043 Self::PTR
1044 }
1045}
1046impl Deref for TIM16 {
1047 type Target = tim16::RegisterBlock;
1048 #[inline(always)]
1049 fn deref(&self) -> &Self::Target {
1050 unsafe { &*Self::PTR }
1051 }
1052}
1053impl core::fmt::Debug for TIM16 {
1054 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1055 f.debug_struct("TIM16").finish()
1056 }
1057}
1058#[doc = "General-purpose-timers"]
1059pub mod tim16;
1060#[doc = "General-purpose-timers"]
1061pub struct TIM17 {
1062 _marker: PhantomData<*const ()>,
1063}
1064unsafe impl Send for TIM17 {}
1065impl TIM17 {
1066 #[doc = r"Pointer to the register block"]
1067 pub const PTR: *const tim16::RegisterBlock = 0x4001_4800 as *const _;
1068 #[doc = r"Return the pointer to the register block"]
1069 #[inline(always)]
1070 pub const fn ptr() -> *const tim16::RegisterBlock {
1071 Self::PTR
1072 }
1073}
1074impl Deref for TIM17 {
1075 type Target = tim16::RegisterBlock;
1076 #[inline(always)]
1077 fn deref(&self) -> &Self::Target {
1078 unsafe { &*Self::PTR }
1079 }
1080}
1081impl core::fmt::Debug for TIM17 {
1082 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1083 f.debug_struct("TIM17").finish()
1084 }
1085}
1086#[doc = "General-purpose-timers"]
1087pub use tim16 as tim17;
1088#[doc = "Flash"]
1089pub struct FLASH {
1090 _marker: PhantomData<*const ()>,
1091}
1092unsafe impl Send for FLASH {}
1093impl FLASH {
1094 #[doc = r"Pointer to the register block"]
1095 pub const PTR: *const flash::RegisterBlock = 0x4002_2000 as *const _;
1096 #[doc = r"Return the pointer to the register block"]
1097 #[inline(always)]
1098 pub const fn ptr() -> *const flash::RegisterBlock {
1099 Self::PTR
1100 }
1101}
1102impl Deref for FLASH {
1103 type Target = flash::RegisterBlock;
1104 #[inline(always)]
1105 fn deref(&self) -> &Self::Target {
1106 unsafe { &*Self::PTR }
1107 }
1108}
1109impl core::fmt::Debug for FLASH {
1110 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1111 f.debug_struct("FLASH").finish()
1112 }
1113}
1114#[doc = "Flash"]
1115pub mod flash;
1116#[doc = "Debug support"]
1117pub struct DBGMCU {
1118 _marker: PhantomData<*const ()>,
1119}
1120unsafe impl Send for DBGMCU {}
1121impl DBGMCU {
1122 #[doc = r"Pointer to the register block"]
1123 pub const PTR: *const dbgmcu::RegisterBlock = 0x4001_5800 as *const _;
1124 #[doc = r"Return the pointer to the register block"]
1125 #[inline(always)]
1126 pub const fn ptr() -> *const dbgmcu::RegisterBlock {
1127 Self::PTR
1128 }
1129}
1130impl Deref for DBGMCU {
1131 type Target = dbgmcu::RegisterBlock;
1132 #[inline(always)]
1133 fn deref(&self) -> &Self::Target {
1134 unsafe { &*Self::PTR }
1135 }
1136}
1137impl core::fmt::Debug for DBGMCU {
1138 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1139 f.debug_struct("DBGMCU").finish()
1140 }
1141}
1142#[doc = "Debug support"]
1143pub mod dbgmcu;
1144#[doc = "Universal serial bus full-speed device interface"]
1145pub struct USB {
1146 _marker: PhantomData<*const ()>,
1147}
1148unsafe impl Send for USB {}
1149impl USB {
1150 #[doc = r"Pointer to the register block"]
1151 pub const PTR: *const usb::RegisterBlock = 0x4000_5c00 as *const _;
1152 #[doc = r"Return the pointer to the register block"]
1153 #[inline(always)]
1154 pub const fn ptr() -> *const usb::RegisterBlock {
1155 Self::PTR
1156 }
1157}
1158impl Deref for USB {
1159 type Target = usb::RegisterBlock;
1160 #[inline(always)]
1161 fn deref(&self) -> &Self::Target {
1162 unsafe { &*Self::PTR }
1163 }
1164}
1165impl core::fmt::Debug for USB {
1166 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1167 f.debug_struct("USB").finish()
1168 }
1169}
1170#[doc = "Universal serial bus full-speed device interface"]
1171pub mod usb;
1172#[doc = "SysTick timer"]
1173pub struct STK {
1174 _marker: PhantomData<*const ()>,
1175}
1176unsafe impl Send for STK {}
1177impl STK {
1178 #[doc = r"Pointer to the register block"]
1179 pub const PTR: *const stk::RegisterBlock = 0xe000_e010 as *const _;
1180 #[doc = r"Return the pointer to the register block"]
1181 #[inline(always)]
1182 pub const fn ptr() -> *const stk::RegisterBlock {
1183 Self::PTR
1184 }
1185}
1186impl Deref for STK {
1187 type Target = stk::RegisterBlock;
1188 #[inline(always)]
1189 fn deref(&self) -> &Self::Target {
1190 unsafe { &*Self::PTR }
1191 }
1192}
1193impl core::fmt::Debug for STK {
1194 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1195 f.debug_struct("STK").finish()
1196 }
1197}
1198#[doc = "SysTick timer"]
1199pub mod stk;
1200#[no_mangle]
1201static mut DEVICE_PERIPHERALS: bool = false;
1202#[doc = r"All the peripherals"]
1203#[allow(non_snake_case)]
1204pub struct Peripherals {
1205 #[doc = "CRC"]
1206 pub CRC: CRC,
1207 #[doc = "GPIOF"]
1208 pub GPIOF: GPIOF,
1209 #[doc = "GPIOD"]
1210 pub GPIOD: GPIOD,
1211 #[doc = "GPIOC"]
1212 pub GPIOC: GPIOC,
1213 #[doc = "GPIOB"]
1214 pub GPIOB: GPIOB,
1215 #[doc = "GPIOA"]
1216 pub GPIOA: GPIOA,
1217 #[doc = "SPI1"]
1218 pub SPI1: SPI1,
1219 #[doc = "SPI2"]
1220 pub SPI2: SPI2,
1221 #[doc = "PWR"]
1222 pub PWR: PWR,
1223 #[doc = "I2C1"]
1224 pub I2C1: I2C1,
1225 #[doc = "I2C2"]
1226 pub I2C2: I2C2,
1227 #[doc = "IWDG"]
1228 pub IWDG: IWDG,
1229 #[doc = "WWDG"]
1230 pub WWDG: WWDG,
1231 #[doc = "TIM1"]
1232 pub TIM1: TIM1,
1233 #[doc = "TIM3"]
1234 pub TIM3: TIM3,
1235 #[doc = "TIM14"]
1236 pub TIM14: TIM14,
1237 #[doc = "TIM6"]
1238 pub TIM6: TIM6,
1239 #[doc = "TIM7"]
1240 pub TIM7: TIM7,
1241 #[doc = "EXTI"]
1242 pub EXTI: EXTI,
1243 #[doc = "DMA1"]
1244 pub DMA1: DMA1,
1245 #[doc = "RCC"]
1246 pub RCC: RCC,
1247 #[doc = "SYSCFG"]
1248 pub SYSCFG: SYSCFG,
1249 #[doc = "ADC"]
1250 pub ADC: ADC,
1251 #[doc = "USART1"]
1252 pub USART1: USART1,
1253 #[doc = "USART2"]
1254 pub USART2: USART2,
1255 #[doc = "USART3"]
1256 pub USART3: USART3,
1257 #[doc = "USART4"]
1258 pub USART4: USART4,
1259 #[doc = "USART6"]
1260 pub USART6: USART6,
1261 #[doc = "USART5"]
1262 pub USART5: USART5,
1263 #[doc = "RTC"]
1264 pub RTC: RTC,
1265 #[doc = "TIM15"]
1266 pub TIM15: TIM15,
1267 #[doc = "TIM16"]
1268 pub TIM16: TIM16,
1269 #[doc = "TIM17"]
1270 pub TIM17: TIM17,
1271 #[doc = "FLASH"]
1272 pub FLASH: FLASH,
1273 #[doc = "DBGMCU"]
1274 pub DBGMCU: DBGMCU,
1275 #[doc = "USB"]
1276 pub USB: USB,
1277 #[doc = "STK"]
1278 pub STK: STK,
1279}
1280impl Peripherals {
1281 #[doc = r"Returns all the peripherals *once*"]
1282 #[inline]
1283 pub fn take() -> Option<Self> {
1284 cortex_m::interrupt::free(|_| {
1285 if unsafe { DEVICE_PERIPHERALS } {
1286 None
1287 } else {
1288 Some(unsafe { Peripherals::steal() })
1289 }
1290 })
1291 }
1292 #[doc = r"Unchecked version of `Peripherals::take`"]
1293 #[inline]
1294 pub unsafe fn steal() -> Self {
1295 DEVICE_PERIPHERALS = true;
1296 Peripherals {
1297 CRC: CRC {
1298 _marker: PhantomData,
1299 },
1300 GPIOF: GPIOF {
1301 _marker: PhantomData,
1302 },
1303 GPIOD: GPIOD {
1304 _marker: PhantomData,
1305 },
1306 GPIOC: GPIOC {
1307 _marker: PhantomData,
1308 },
1309 GPIOB: GPIOB {
1310 _marker: PhantomData,
1311 },
1312 GPIOA: GPIOA {
1313 _marker: PhantomData,
1314 },
1315 SPI1: SPI1 {
1316 _marker: PhantomData,
1317 },
1318 SPI2: SPI2 {
1319 _marker: PhantomData,
1320 },
1321 PWR: PWR {
1322 _marker: PhantomData,
1323 },
1324 I2C1: I2C1 {
1325 _marker: PhantomData,
1326 },
1327 I2C2: I2C2 {
1328 _marker: PhantomData,
1329 },
1330 IWDG: IWDG {
1331 _marker: PhantomData,
1332 },
1333 WWDG: WWDG {
1334 _marker: PhantomData,
1335 },
1336 TIM1: TIM1 {
1337 _marker: PhantomData,
1338 },
1339 TIM3: TIM3 {
1340 _marker: PhantomData,
1341 },
1342 TIM14: TIM14 {
1343 _marker: PhantomData,
1344 },
1345 TIM6: TIM6 {
1346 _marker: PhantomData,
1347 },
1348 TIM7: TIM7 {
1349 _marker: PhantomData,
1350 },
1351 EXTI: EXTI {
1352 _marker: PhantomData,
1353 },
1354 DMA1: DMA1 {
1355 _marker: PhantomData,
1356 },
1357 RCC: RCC {
1358 _marker: PhantomData,
1359 },
1360 SYSCFG: SYSCFG {
1361 _marker: PhantomData,
1362 },
1363 ADC: ADC {
1364 _marker: PhantomData,
1365 },
1366 USART1: USART1 {
1367 _marker: PhantomData,
1368 },
1369 USART2: USART2 {
1370 _marker: PhantomData,
1371 },
1372 USART3: USART3 {
1373 _marker: PhantomData,
1374 },
1375 USART4: USART4 {
1376 _marker: PhantomData,
1377 },
1378 USART6: USART6 {
1379 _marker: PhantomData,
1380 },
1381 USART5: USART5 {
1382 _marker: PhantomData,
1383 },
1384 RTC: RTC {
1385 _marker: PhantomData,
1386 },
1387 TIM15: TIM15 {
1388 _marker: PhantomData,
1389 },
1390 TIM16: TIM16 {
1391 _marker: PhantomData,
1392 },
1393 TIM17: TIM17 {
1394 _marker: PhantomData,
1395 },
1396 FLASH: FLASH {
1397 _marker: PhantomData,
1398 },
1399 DBGMCU: DBGMCU {
1400 _marker: PhantomData,
1401 },
1402 USB: USB {
1403 _marker: PhantomData,
1404 },
1405 STK: STK {
1406 _marker: PhantomData,
1407 },
1408 }
1409 }
1410}