1#![doc = "Peripheral access API for PY32F303 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 DAC"]
535pub struct DAC1 {
536 _marker: PhantomData<*const ()>,
537}
538unsafe impl Send for DAC1 {}
539impl DAC1 {
540 #[doc = r"Pointer to the register block"]
541 pub const PTR: *const dac1::RegisterBlock = 0x4000_7400 as *const _;
542 #[doc = r"Return the pointer to the register block"]
543 #[inline(always)]
544 pub const fn ptr() -> *const dac1::RegisterBlock {
545 Self::PTR
546 }
547}
548impl Deref for DAC1 {
549 type Target = dac1::RegisterBlock;
550 #[inline(always)]
551 fn deref(&self) -> &Self::Target {
552 unsafe { &*Self::PTR }
553 }
554}
555impl core::fmt::Debug for DAC1 {
556 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
557 f.debug_struct("DAC1").finish()
558 }
559}
560#[doc = "desc DAC"]
561pub mod dac1;
562#[doc = "desc DBGMCU"]
563pub struct DBGMCU {
564 _marker: PhantomData<*const ()>,
565}
566unsafe impl Send for DBGMCU {}
567impl DBGMCU {
568 #[doc = r"Pointer to the register block"]
569 pub const PTR: *const dbgmcu::RegisterBlock = 0xe004_2000 as *const _;
570 #[doc = r"Return the pointer to the register block"]
571 #[inline(always)]
572 pub const fn ptr() -> *const dbgmcu::RegisterBlock {
573 Self::PTR
574 }
575}
576impl Deref for DBGMCU {
577 type Target = dbgmcu::RegisterBlock;
578 #[inline(always)]
579 fn deref(&self) -> &Self::Target {
580 unsafe { &*Self::PTR }
581 }
582}
583impl core::fmt::Debug for DBGMCU {
584 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
585 f.debug_struct("DBGMCU").finish()
586 }
587}
588#[doc = "desc DBGMCU"]
589pub mod dbgmcu;
590#[doc = "desc DMA"]
591pub struct DMA1 {
592 _marker: PhantomData<*const ()>,
593}
594unsafe impl Send for DMA1 {}
595impl DMA1 {
596 #[doc = r"Pointer to the register block"]
597 pub const PTR: *const dma1::RegisterBlock = 0x4002_0000 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 DMA1 {
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 DMA1 {
612 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
613 f.debug_struct("DMA1").finish()
614 }
615}
616#[doc = "desc DMA"]
617pub mod dma1;
618#[doc = "desc DMA"]
619pub struct DMA2 {
620 _marker: PhantomData<*const ()>,
621}
622unsafe impl Send for DMA2 {}
623impl DMA2 {
624 #[doc = r"Pointer to the register block"]
625 pub const PTR: *const dma1::RegisterBlock = 0x4002_0400 as *const _;
626 #[doc = r"Return the pointer to the register block"]
627 #[inline(always)]
628 pub const fn ptr() -> *const dma1::RegisterBlock {
629 Self::PTR
630 }
631}
632impl Deref for DMA2 {
633 type Target = dma1::RegisterBlock;
634 #[inline(always)]
635 fn deref(&self) -> &Self::Target {
636 unsafe { &*Self::PTR }
637 }
638}
639impl core::fmt::Debug for DMA2 {
640 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
641 f.debug_struct("DMA2").finish()
642 }
643}
644#[doc = "desc DMA"]
645pub use dma1 as dma2;
646#[doc = "desc ESMC"]
647pub struct ESMC {
648 _marker: PhantomData<*const ()>,
649}
650unsafe impl Send for ESMC {}
651impl ESMC {
652 #[doc = r"Pointer to the register block"]
653 pub const PTR: *const esmc::RegisterBlock = 0xa000_1000 as *const _;
654 #[doc = r"Return the pointer to the register block"]
655 #[inline(always)]
656 pub const fn ptr() -> *const esmc::RegisterBlock {
657 Self::PTR
658 }
659}
660impl Deref for ESMC {
661 type Target = esmc::RegisterBlock;
662 #[inline(always)]
663 fn deref(&self) -> &Self::Target {
664 unsafe { &*Self::PTR }
665 }
666}
667impl core::fmt::Debug for ESMC {
668 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
669 f.debug_struct("ESMC").finish()
670 }
671}
672#[doc = "desc ESMC"]
673pub mod esmc;
674#[doc = "desc EXTI"]
675pub struct EXTI {
676 _marker: PhantomData<*const ()>,
677}
678unsafe impl Send for EXTI {}
679impl EXTI {
680 #[doc = r"Pointer to the register block"]
681 pub const PTR: *const exti::RegisterBlock = 0x4001_0400 as *const _;
682 #[doc = r"Return the pointer to the register block"]
683 #[inline(always)]
684 pub const fn ptr() -> *const exti::RegisterBlock {
685 Self::PTR
686 }
687}
688impl Deref for EXTI {
689 type Target = exti::RegisterBlock;
690 #[inline(always)]
691 fn deref(&self) -> &Self::Target {
692 unsafe { &*Self::PTR }
693 }
694}
695impl core::fmt::Debug for EXTI {
696 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
697 f.debug_struct("EXTI").finish()
698 }
699}
700#[doc = "desc EXTI"]
701pub mod exti;
702#[doc = "desc FLASH"]
703pub struct FLASH {
704 _marker: PhantomData<*const ()>,
705}
706unsafe impl Send for FLASH {}
707impl FLASH {
708 #[doc = r"Pointer to the register block"]
709 pub const PTR: *const flash::RegisterBlock = 0x4002_2000 as *const _;
710 #[doc = r"Return the pointer to the register block"]
711 #[inline(always)]
712 pub const fn ptr() -> *const flash::RegisterBlock {
713 Self::PTR
714 }
715}
716impl Deref for FLASH {
717 type Target = flash::RegisterBlock;
718 #[inline(always)]
719 fn deref(&self) -> &Self::Target {
720 unsafe { &*Self::PTR }
721 }
722}
723impl core::fmt::Debug for FLASH {
724 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
725 f.debug_struct("FLASH").finish()
726 }
727}
728#[doc = "desc FLASH"]
729pub mod flash;
730#[doc = "desc GPIO"]
731pub struct GPIOA {
732 _marker: PhantomData<*const ()>,
733}
734unsafe impl Send for GPIOA {}
735impl GPIOA {
736 #[doc = r"Pointer to the register block"]
737 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0000 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 GPIOA {
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 GPIOA {
752 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
753 f.debug_struct("GPIOA").finish()
754 }
755}
756#[doc = "desc GPIO"]
757pub mod gpioa;
758#[doc = "desc GPIO"]
759pub struct GPIOB {
760 _marker: PhantomData<*const ()>,
761}
762unsafe impl Send for GPIOB {}
763impl GPIOB {
764 #[doc = r"Pointer to the register block"]
765 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0400 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 GPIOB {
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 GPIOB {
780 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
781 f.debug_struct("GPIOB").finish()
782 }
783}
784#[doc = "desc GPIO"]
785pub use gpioa as gpiob;
786#[doc = "desc GPIO"]
787pub struct GPIOC {
788 _marker: PhantomData<*const ()>,
789}
790unsafe impl Send for GPIOC {}
791impl GPIOC {
792 #[doc = r"Pointer to the register block"]
793 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0800 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 GPIOC {
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 GPIOC {
808 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
809 f.debug_struct("GPIOC").finish()
810 }
811}
812#[doc = "desc GPIO"]
813pub use gpioa as gpioc;
814#[doc = "desc GPIO"]
815pub struct GPIOD {
816 _marker: PhantomData<*const ()>,
817}
818unsafe impl Send for GPIOD {}
819impl GPIOD {
820 #[doc = r"Pointer to the register block"]
821 pub const PTR: *const gpioa::RegisterBlock = 0x4800_0c00 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 GPIOD {
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 GPIOD {
836 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
837 f.debug_struct("GPIOD").finish()
838 }
839}
840#[doc = "desc GPIO"]
841pub use gpioa as gpiod;
842#[doc = "desc GPIO"]
843pub struct GPIOE {
844 _marker: PhantomData<*const ()>,
845}
846unsafe impl Send for GPIOE {}
847impl GPIOE {
848 #[doc = r"Pointer to the register block"]
849 pub const PTR: *const gpioa::RegisterBlock = 0x4800_1000 as *const _;
850 #[doc = r"Return the pointer to the register block"]
851 #[inline(always)]
852 pub const fn ptr() -> *const gpioa::RegisterBlock {
853 Self::PTR
854 }
855}
856impl Deref for GPIOE {
857 type Target = gpioa::RegisterBlock;
858 #[inline(always)]
859 fn deref(&self) -> &Self::Target {
860 unsafe { &*Self::PTR }
861 }
862}
863impl core::fmt::Debug for GPIOE {
864 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
865 f.debug_struct("GPIOE").finish()
866 }
867}
868#[doc = "desc GPIO"]
869pub use gpioa as gpioe;
870#[doc = "desc I2C"]
871pub struct I2C1 {
872 _marker: PhantomData<*const ()>,
873}
874unsafe impl Send for I2C1 {}
875impl I2C1 {
876 #[doc = r"Pointer to the register block"]
877 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5400 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 I2C1 {
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 I2C1 {
892 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
893 f.debug_struct("I2C1").finish()
894 }
895}
896#[doc = "desc I2C"]
897pub mod i2c1;
898#[doc = "desc I2C"]
899pub struct I2C2 {
900 _marker: PhantomData<*const ()>,
901}
902unsafe impl Send for I2C2 {}
903impl I2C2 {
904 #[doc = r"Pointer to the register block"]
905 pub const PTR: *const i2c1::RegisterBlock = 0x4000_5800 as *const _;
906 #[doc = r"Return the pointer to the register block"]
907 #[inline(always)]
908 pub const fn ptr() -> *const i2c1::RegisterBlock {
909 Self::PTR
910 }
911}
912impl Deref for I2C2 {
913 type Target = i2c1::RegisterBlock;
914 #[inline(always)]
915 fn deref(&self) -> &Self::Target {
916 unsafe { &*Self::PTR }
917 }
918}
919impl core::fmt::Debug for I2C2 {
920 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
921 f.debug_struct("I2C2").finish()
922 }
923}
924#[doc = "desc I2C"]
925pub use i2c1 as i2c2;
926#[doc = "desc IWDG"]
927pub struct IWDG {
928 _marker: PhantomData<*const ()>,
929}
930unsafe impl Send for IWDG {}
931impl IWDG {
932 #[doc = r"Pointer to the register block"]
933 pub const PTR: *const iwdg::RegisterBlock = 0x4000_3000 as *const _;
934 #[doc = r"Return the pointer to the register block"]
935 #[inline(always)]
936 pub const fn ptr() -> *const iwdg::RegisterBlock {
937 Self::PTR
938 }
939}
940impl Deref for IWDG {
941 type Target = iwdg::RegisterBlock;
942 #[inline(always)]
943 fn deref(&self) -> &Self::Target {
944 unsafe { &*Self::PTR }
945 }
946}
947impl core::fmt::Debug for IWDG {
948 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
949 f.debug_struct("IWDG").finish()
950 }
951}
952#[doc = "desc IWDG"]
953pub mod iwdg;
954#[doc = "desc PWR"]
955pub struct PWR {
956 _marker: PhantomData<*const ()>,
957}
958unsafe impl Send for PWR {}
959impl PWR {
960 #[doc = r"Pointer to the register block"]
961 pub const PTR: *const pwr::RegisterBlock = 0x4000_7000 as *const _;
962 #[doc = r"Return the pointer to the register block"]
963 #[inline(always)]
964 pub const fn ptr() -> *const pwr::RegisterBlock {
965 Self::PTR
966 }
967}
968impl Deref for PWR {
969 type Target = pwr::RegisterBlock;
970 #[inline(always)]
971 fn deref(&self) -> &Self::Target {
972 unsafe { &*Self::PTR }
973 }
974}
975impl core::fmt::Debug for PWR {
976 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
977 f.debug_struct("PWR").finish()
978 }
979}
980#[doc = "desc PWR"]
981pub mod pwr;
982#[doc = "desc RCC"]
983pub struct RCC {
984 _marker: PhantomData<*const ()>,
985}
986unsafe impl Send for RCC {}
987impl RCC {
988 #[doc = r"Pointer to the register block"]
989 pub const PTR: *const rcc::RegisterBlock = 0x4002_1000 as *const _;
990 #[doc = r"Return the pointer to the register block"]
991 #[inline(always)]
992 pub const fn ptr() -> *const rcc::RegisterBlock {
993 Self::PTR
994 }
995}
996impl Deref for RCC {
997 type Target = rcc::RegisterBlock;
998 #[inline(always)]
999 fn deref(&self) -> &Self::Target {
1000 unsafe { &*Self::PTR }
1001 }
1002}
1003impl core::fmt::Debug for RCC {
1004 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1005 f.debug_struct("RCC").finish()
1006 }
1007}
1008#[doc = "desc RCC"]
1009pub mod rcc;
1010#[doc = "desc RTC"]
1011pub struct RTC {
1012 _marker: PhantomData<*const ()>,
1013}
1014unsafe impl Send for RTC {}
1015impl RTC {
1016 #[doc = r"Pointer to the register block"]
1017 pub const PTR: *const rtc::RegisterBlock = 0x4000_2800 as *const _;
1018 #[doc = r"Return the pointer to the register block"]
1019 #[inline(always)]
1020 pub const fn ptr() -> *const rtc::RegisterBlock {
1021 Self::PTR
1022 }
1023}
1024impl Deref for RTC {
1025 type Target = rtc::RegisterBlock;
1026 #[inline(always)]
1027 fn deref(&self) -> &Self::Target {
1028 unsafe { &*Self::PTR }
1029 }
1030}
1031impl core::fmt::Debug for RTC {
1032 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1033 f.debug_struct("RTC").finish()
1034 }
1035}
1036#[doc = "desc RTC"]
1037pub mod rtc;
1038#[doc = "desc SDIO"]
1039pub struct SDIO {
1040 _marker: PhantomData<*const ()>,
1041}
1042unsafe impl Send for SDIO {}
1043impl SDIO {
1044 #[doc = r"Pointer to the register block"]
1045 pub const PTR: *const sdio::RegisterBlock = 0x4001_8000 as *const _;
1046 #[doc = r"Return the pointer to the register block"]
1047 #[inline(always)]
1048 pub const fn ptr() -> *const sdio::RegisterBlock {
1049 Self::PTR
1050 }
1051}
1052impl Deref for SDIO {
1053 type Target = sdio::RegisterBlock;
1054 #[inline(always)]
1055 fn deref(&self) -> &Self::Target {
1056 unsafe { &*Self::PTR }
1057 }
1058}
1059impl core::fmt::Debug for SDIO {
1060 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1061 f.debug_struct("SDIO").finish()
1062 }
1063}
1064#[doc = "desc SDIO"]
1065pub mod sdio;
1066#[doc = "desc SPI"]
1067pub struct SPI1 {
1068 _marker: PhantomData<*const ()>,
1069}
1070unsafe impl Send for SPI1 {}
1071impl SPI1 {
1072 #[doc = r"Pointer to the register block"]
1073 pub const PTR: *const spi1::RegisterBlock = 0x4001_3000 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 SPI1 {
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 SPI1 {
1088 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1089 f.debug_struct("SPI1").finish()
1090 }
1091}
1092#[doc = "desc SPI"]
1093pub mod spi1;
1094#[doc = "desc SPI"]
1095pub struct SPI2 {
1096 _marker: PhantomData<*const ()>,
1097}
1098unsafe impl Send for SPI2 {}
1099impl SPI2 {
1100 #[doc = r"Pointer to the register block"]
1101 pub const PTR: *const spi1::RegisterBlock = 0x4000_3800 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 SPI2 {
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 SPI2 {
1116 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1117 f.debug_struct("SPI2").finish()
1118 }
1119}
1120#[doc = "desc SPI"]
1121pub use spi1 as spi2;
1122#[doc = "desc SPI"]
1123pub struct SPI3 {
1124 _marker: PhantomData<*const ()>,
1125}
1126unsafe impl Send for SPI3 {}
1127impl SPI3 {
1128 #[doc = r"Pointer to the register block"]
1129 pub const PTR: *const spi1::RegisterBlock = 0x4000_3c00 as *const _;
1130 #[doc = r"Return the pointer to the register block"]
1131 #[inline(always)]
1132 pub const fn ptr() -> *const spi1::RegisterBlock {
1133 Self::PTR
1134 }
1135}
1136impl Deref for SPI3 {
1137 type Target = spi1::RegisterBlock;
1138 #[inline(always)]
1139 fn deref(&self) -> &Self::Target {
1140 unsafe { &*Self::PTR }
1141 }
1142}
1143impl core::fmt::Debug for SPI3 {
1144 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1145 f.debug_struct("SPI3").finish()
1146 }
1147}
1148#[doc = "desc SPI"]
1149pub use spi1 as spi3;
1150#[doc = "desc SYSCFG"]
1151pub struct SYSCFG {
1152 _marker: PhantomData<*const ()>,
1153}
1154unsafe impl Send for SYSCFG {}
1155impl SYSCFG {
1156 #[doc = r"Pointer to the register block"]
1157 pub const PTR: *const syscfg::RegisterBlock = 0x4001_0000 as *const _;
1158 #[doc = r"Return the pointer to the register block"]
1159 #[inline(always)]
1160 pub const fn ptr() -> *const syscfg::RegisterBlock {
1161 Self::PTR
1162 }
1163}
1164impl Deref for SYSCFG {
1165 type Target = syscfg::RegisterBlock;
1166 #[inline(always)]
1167 fn deref(&self) -> &Self::Target {
1168 unsafe { &*Self::PTR }
1169 }
1170}
1171impl core::fmt::Debug for SYSCFG {
1172 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1173 f.debug_struct("SYSCFG").finish()
1174 }
1175}
1176#[doc = "desc SYSCFG"]
1177pub mod syscfg;
1178#[doc = "desc TIM"]
1179pub struct TIM1 {
1180 _marker: PhantomData<*const ()>,
1181}
1182unsafe impl Send for TIM1 {}
1183impl TIM1 {
1184 #[doc = r"Pointer to the register block"]
1185 pub const PTR: *const tim1::RegisterBlock = 0x4001_2c00 as *const _;
1186 #[doc = r"Return the pointer to the register block"]
1187 #[inline(always)]
1188 pub const fn ptr() -> *const tim1::RegisterBlock {
1189 Self::PTR
1190 }
1191}
1192impl Deref for TIM1 {
1193 type Target = tim1::RegisterBlock;
1194 #[inline(always)]
1195 fn deref(&self) -> &Self::Target {
1196 unsafe { &*Self::PTR }
1197 }
1198}
1199impl core::fmt::Debug for TIM1 {
1200 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1201 f.debug_struct("TIM1").finish()
1202 }
1203}
1204#[doc = "desc TIM"]
1205pub mod tim1;
1206#[doc = "desc TIM"]
1207pub struct TIM2 {
1208 _marker: PhantomData<*const ()>,
1209}
1210unsafe impl Send for TIM2 {}
1211impl TIM2 {
1212 #[doc = r"Pointer to the register block"]
1213 pub const PTR: *const tim2::RegisterBlock = 0x4000_0000 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 TIM2 {
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 TIM2 {
1228 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1229 f.debug_struct("TIM2").finish()
1230 }
1231}
1232#[doc = "desc TIM"]
1233pub mod tim2;
1234#[doc = "desc TIM"]
1235pub struct TIM3 {
1236 _marker: PhantomData<*const ()>,
1237}
1238unsafe impl Send for TIM3 {}
1239impl TIM3 {
1240 #[doc = r"Pointer to the register block"]
1241 pub const PTR: *const tim2::RegisterBlock = 0x4000_0400 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 TIM3 {
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 TIM3 {
1256 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1257 f.debug_struct("TIM3").finish()
1258 }
1259}
1260#[doc = "desc TIM"]
1261pub use tim2 as tim3;
1262#[doc = "desc TIM"]
1263pub struct TIM4 {
1264 _marker: PhantomData<*const ()>,
1265}
1266unsafe impl Send for TIM4 {}
1267impl TIM4 {
1268 #[doc = r"Pointer to the register block"]
1269 pub const PTR: *const tim2::RegisterBlock = 0x4000_0800 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 TIM4 {
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 TIM4 {
1284 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1285 f.debug_struct("TIM4").finish()
1286 }
1287}
1288#[doc = "desc TIM"]
1289pub use tim2 as tim4;
1290#[doc = "desc TIM"]
1291pub struct TIM5 {
1292 _marker: PhantomData<*const ()>,
1293}
1294unsafe impl Send for TIM5 {}
1295impl TIM5 {
1296 #[doc = r"Pointer to the register block"]
1297 pub const PTR: *const tim2::RegisterBlock = 0x4000_0c00 as *const _;
1298 #[doc = r"Return the pointer to the register block"]
1299 #[inline(always)]
1300 pub const fn ptr() -> *const tim2::RegisterBlock {
1301 Self::PTR
1302 }
1303}
1304impl Deref for TIM5 {
1305 type Target = tim2::RegisterBlock;
1306 #[inline(always)]
1307 fn deref(&self) -> &Self::Target {
1308 unsafe { &*Self::PTR }
1309 }
1310}
1311impl core::fmt::Debug for TIM5 {
1312 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1313 f.debug_struct("TIM5").finish()
1314 }
1315}
1316#[doc = "desc TIM"]
1317pub use tim2 as tim5;
1318#[doc = "desc TIM"]
1319pub struct TIM6 {
1320 _marker: PhantomData<*const ()>,
1321}
1322unsafe impl Send for TIM6 {}
1323impl TIM6 {
1324 #[doc = r"Pointer to the register block"]
1325 pub const PTR: *const tim6::RegisterBlock = 0x4000_1000 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 TIM6 {
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 TIM6 {
1340 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1341 f.debug_struct("TIM6").finish()
1342 }
1343}
1344#[doc = "desc TIM"]
1345pub mod tim6;
1346#[doc = "desc TIM"]
1347pub struct TIM7 {
1348 _marker: PhantomData<*const ()>,
1349}
1350unsafe impl Send for TIM7 {}
1351impl TIM7 {
1352 #[doc = r"Pointer to the register block"]
1353 pub const PTR: *const tim6::RegisterBlock = 0x4000_1400 as *const _;
1354 #[doc = r"Return the pointer to the register block"]
1355 #[inline(always)]
1356 pub const fn ptr() -> *const tim6::RegisterBlock {
1357 Self::PTR
1358 }
1359}
1360impl Deref for TIM7 {
1361 type Target = tim6::RegisterBlock;
1362 #[inline(always)]
1363 fn deref(&self) -> &Self::Target {
1364 unsafe { &*Self::PTR }
1365 }
1366}
1367impl core::fmt::Debug for TIM7 {
1368 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1369 f.debug_struct("TIM7").finish()
1370 }
1371}
1372#[doc = "desc TIM"]
1373pub use tim6 as tim7;
1374#[doc = "desc TIM"]
1375pub struct TIM8 {
1376 _marker: PhantomData<*const ()>,
1377}
1378unsafe impl Send for TIM8 {}
1379impl TIM8 {
1380 #[doc = r"Pointer to the register block"]
1381 pub const PTR: *const tim1::RegisterBlock = 0x4001_3400 as *const _;
1382 #[doc = r"Return the pointer to the register block"]
1383 #[inline(always)]
1384 pub const fn ptr() -> *const tim1::RegisterBlock {
1385 Self::PTR
1386 }
1387}
1388impl Deref for TIM8 {
1389 type Target = tim1::RegisterBlock;
1390 #[inline(always)]
1391 fn deref(&self) -> &Self::Target {
1392 unsafe { &*Self::PTR }
1393 }
1394}
1395impl core::fmt::Debug for TIM8 {
1396 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1397 f.debug_struct("TIM8").finish()
1398 }
1399}
1400#[doc = "desc TIM"]
1401pub use tim1 as tim8;
1402#[doc = "desc TIM"]
1403pub struct TIM9 {
1404 _marker: PhantomData<*const ()>,
1405}
1406unsafe impl Send for TIM9 {}
1407impl TIM9 {
1408 #[doc = r"Pointer to the register block"]
1409 pub const PTR: *const tim9::RegisterBlock = 0x4001_4c00 as *const _;
1410 #[doc = r"Return the pointer to the register block"]
1411 #[inline(always)]
1412 pub const fn ptr() -> *const tim9::RegisterBlock {
1413 Self::PTR
1414 }
1415}
1416impl Deref for TIM9 {
1417 type Target = tim9::RegisterBlock;
1418 #[inline(always)]
1419 fn deref(&self) -> &Self::Target {
1420 unsafe { &*Self::PTR }
1421 }
1422}
1423impl core::fmt::Debug for TIM9 {
1424 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1425 f.debug_struct("TIM9").finish()
1426 }
1427}
1428#[doc = "desc TIM"]
1429pub mod tim9;
1430#[doc = "desc TIM"]
1431pub struct TIM10 {
1432 _marker: PhantomData<*const ()>,
1433}
1434unsafe impl Send for TIM10 {}
1435impl TIM10 {
1436 #[doc = r"Pointer to the register block"]
1437 pub const PTR: *const tim10::RegisterBlock = 0x4001_5000 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 TIM10 {
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 TIM10 {
1452 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1453 f.debug_struct("TIM10").finish()
1454 }
1455}
1456#[doc = "desc TIM"]
1457pub mod tim10;
1458#[doc = "desc TIM"]
1459pub struct TIM11 {
1460 _marker: PhantomData<*const ()>,
1461}
1462unsafe impl Send for TIM11 {}
1463impl TIM11 {
1464 #[doc = r"Pointer to the register block"]
1465 pub const PTR: *const tim10::RegisterBlock = 0x4001_5400 as *const _;
1466 #[doc = r"Return the pointer to the register block"]
1467 #[inline(always)]
1468 pub const fn ptr() -> *const tim10::RegisterBlock {
1469 Self::PTR
1470 }
1471}
1472impl Deref for TIM11 {
1473 type Target = tim10::RegisterBlock;
1474 #[inline(always)]
1475 fn deref(&self) -> &Self::Target {
1476 unsafe { &*Self::PTR }
1477 }
1478}
1479impl core::fmt::Debug for TIM11 {
1480 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1481 f.debug_struct("TIM11").finish()
1482 }
1483}
1484#[doc = "desc TIM"]
1485pub use tim10 as tim11;
1486#[doc = "desc TIM"]
1487pub struct TIM12 {
1488 _marker: PhantomData<*const ()>,
1489}
1490unsafe impl Send for TIM12 {}
1491impl TIM12 {
1492 #[doc = r"Pointer to the register block"]
1493 pub const PTR: *const tim9::RegisterBlock = 0x4000_1800 as *const _;
1494 #[doc = r"Return the pointer to the register block"]
1495 #[inline(always)]
1496 pub const fn ptr() -> *const tim9::RegisterBlock {
1497 Self::PTR
1498 }
1499}
1500impl Deref for TIM12 {
1501 type Target = tim9::RegisterBlock;
1502 #[inline(always)]
1503 fn deref(&self) -> &Self::Target {
1504 unsafe { &*Self::PTR }
1505 }
1506}
1507impl core::fmt::Debug for TIM12 {
1508 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1509 f.debug_struct("TIM12").finish()
1510 }
1511}
1512#[doc = "desc TIM"]
1513pub use tim9 as tim12;
1514#[doc = "desc TIM"]
1515pub struct TIM13 {
1516 _marker: PhantomData<*const ()>,
1517}
1518unsafe impl Send for TIM13 {}
1519impl TIM13 {
1520 #[doc = r"Pointer to the register block"]
1521 pub const PTR: *const tim10::RegisterBlock = 0x4000_1c00 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 TIM13 {
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 TIM13 {
1536 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1537 f.debug_struct("TIM13").finish()
1538 }
1539}
1540#[doc = "desc TIM"]
1541pub use tim10 as tim13;
1542#[doc = "desc TIM"]
1543pub struct TIM14 {
1544 _marker: PhantomData<*const ()>,
1545}
1546unsafe impl Send for TIM14 {}
1547impl TIM14 {
1548 #[doc = r"Pointer to the register block"]
1549 pub const PTR: *const tim10::RegisterBlock = 0x4000_2000 as *const _;
1550 #[doc = r"Return the pointer to the register block"]
1551 #[inline(always)]
1552 pub const fn ptr() -> *const tim10::RegisterBlock {
1553 Self::PTR
1554 }
1555}
1556impl Deref for TIM14 {
1557 type Target = tim10::RegisterBlock;
1558 #[inline(always)]
1559 fn deref(&self) -> &Self::Target {
1560 unsafe { &*Self::PTR }
1561 }
1562}
1563impl core::fmt::Debug for TIM14 {
1564 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1565 f.debug_struct("TIM14").finish()
1566 }
1567}
1568#[doc = "desc TIM"]
1569pub use tim10 as tim14;
1570#[doc = "desc USART"]
1571pub struct USART1 {
1572 _marker: PhantomData<*const ()>,
1573}
1574unsafe impl Send for USART1 {}
1575impl USART1 {
1576 #[doc = r"Pointer to the register block"]
1577 pub const PTR: *const usart1::RegisterBlock = 0x4001_3800 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 USART1 {
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 USART1 {
1592 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1593 f.debug_struct("USART1").finish()
1594 }
1595}
1596#[doc = "desc USART"]
1597pub mod usart1;
1598#[doc = "desc USART"]
1599pub struct USART2 {
1600 _marker: PhantomData<*const ()>,
1601}
1602unsafe impl Send for USART2 {}
1603impl USART2 {
1604 #[doc = r"Pointer to the register block"]
1605 pub const PTR: *const usart1::RegisterBlock = 0x4000_4400 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 USART2 {
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 USART2 {
1620 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1621 f.debug_struct("USART2").finish()
1622 }
1623}
1624#[doc = "desc USART"]
1625pub use usart1 as usart2;
1626#[doc = "desc USART"]
1627pub struct USART3 {
1628 _marker: PhantomData<*const ()>,
1629}
1630unsafe impl Send for USART3 {}
1631impl USART3 {
1632 #[doc = r"Pointer to the register block"]
1633 pub const PTR: *const usart1::RegisterBlock = 0x4000_4800 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 USART3 {
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 USART3 {
1648 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1649 f.debug_struct("USART3").finish()
1650 }
1651}
1652#[doc = "desc USART"]
1653pub use usart1 as usart3;
1654#[doc = "desc USART"]
1655pub struct USART4 {
1656 _marker: PhantomData<*const ()>,
1657}
1658unsafe impl Send for USART4 {}
1659impl USART4 {
1660 #[doc = r"Pointer to the register block"]
1661 pub const PTR: *const usart1::RegisterBlock = 0x4000_4c00 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 USART4 {
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 USART4 {
1676 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1677 f.debug_struct("USART4").finish()
1678 }
1679}
1680#[doc = "desc USART"]
1681pub use usart1 as usart4;
1682#[doc = "desc USART"]
1683pub struct USART5 {
1684 _marker: PhantomData<*const ()>,
1685}
1686unsafe impl Send for USART5 {}
1687impl USART5 {
1688 #[doc = r"Pointer to the register block"]
1689 pub const PTR: *const usart1::RegisterBlock = 0x4000_5000 as *const _;
1690 #[doc = r"Return the pointer to the register block"]
1691 #[inline(always)]
1692 pub const fn ptr() -> *const usart1::RegisterBlock {
1693 Self::PTR
1694 }
1695}
1696impl Deref for USART5 {
1697 type Target = usart1::RegisterBlock;
1698 #[inline(always)]
1699 fn deref(&self) -> &Self::Target {
1700 unsafe { &*Self::PTR }
1701 }
1702}
1703impl core::fmt::Debug for USART5 {
1704 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1705 f.debug_struct("USART5").finish()
1706 }
1707}
1708#[doc = "desc USART"]
1709pub use usart1 as usart5;
1710#[doc = "USB"]
1711pub struct USB {
1712 _marker: PhantomData<*const ()>,
1713}
1714unsafe impl Send for USB {}
1715impl USB {
1716 #[doc = r"Pointer to the register block"]
1717 pub const PTR: *const usb::RegisterBlock = 0x4000_5c00 as *const _;
1718 #[doc = r"Return the pointer to the register block"]
1719 #[inline(always)]
1720 pub const fn ptr() -> *const usb::RegisterBlock {
1721 Self::PTR
1722 }
1723}
1724impl Deref for USB {
1725 type Target = usb::RegisterBlock;
1726 #[inline(always)]
1727 fn deref(&self) -> &Self::Target {
1728 unsafe { &*Self::PTR }
1729 }
1730}
1731impl core::fmt::Debug for USB {
1732 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1733 f.debug_struct("USB").finish()
1734 }
1735}
1736#[doc = "USB"]
1737pub mod usb;
1738#[doc = "desc WWDG"]
1739pub struct WWDG {
1740 _marker: PhantomData<*const ()>,
1741}
1742unsafe impl Send for WWDG {}
1743impl WWDG {
1744 #[doc = r"Pointer to the register block"]
1745 pub const PTR: *const wwdg::RegisterBlock = 0x4000_2c00 as *const _;
1746 #[doc = r"Return the pointer to the register block"]
1747 #[inline(always)]
1748 pub const fn ptr() -> *const wwdg::RegisterBlock {
1749 Self::PTR
1750 }
1751}
1752impl Deref for WWDG {
1753 type Target = wwdg::RegisterBlock;
1754 #[inline(always)]
1755 fn deref(&self) -> &Self::Target {
1756 unsafe { &*Self::PTR }
1757 }
1758}
1759impl core::fmt::Debug for WWDG {
1760 fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
1761 f.debug_struct("WWDG").finish()
1762 }
1763}
1764#[doc = "desc WWDG"]
1765pub mod wwdg;
1766#[no_mangle]
1767static mut DEVICE_PERIPHERALS: bool = false;
1768#[doc = r"All the peripherals"]
1769#[allow(non_snake_case)]
1770pub struct Peripherals {
1771 #[doc = "ADC1"]
1772 pub ADC1: ADC1,
1773 #[doc = "ADC2"]
1774 pub ADC2: ADC2,
1775 #[doc = "ADC3"]
1776 pub ADC3: ADC3,
1777 #[doc = "BKP"]
1778 pub BKP: BKP,
1779 #[doc = "CANFD"]
1780 pub CANFD: CANFD,
1781 #[doc = "CRC"]
1782 pub CRC: CRC,
1783 #[doc = "CTC"]
1784 pub CTC: CTC,
1785 #[doc = "DAC1"]
1786 pub DAC1: DAC1,
1787 #[doc = "DBGMCU"]
1788 pub DBGMCU: DBGMCU,
1789 #[doc = "DMA1"]
1790 pub DMA1: DMA1,
1791 #[doc = "DMA2"]
1792 pub DMA2: DMA2,
1793 #[doc = "ESMC"]
1794 pub ESMC: ESMC,
1795 #[doc = "EXTI"]
1796 pub EXTI: EXTI,
1797 #[doc = "FLASH"]
1798 pub FLASH: FLASH,
1799 #[doc = "GPIOA"]
1800 pub GPIOA: GPIOA,
1801 #[doc = "GPIOB"]
1802 pub GPIOB: GPIOB,
1803 #[doc = "GPIOC"]
1804 pub GPIOC: GPIOC,
1805 #[doc = "GPIOD"]
1806 pub GPIOD: GPIOD,
1807 #[doc = "GPIOE"]
1808 pub GPIOE: GPIOE,
1809 #[doc = "I2C1"]
1810 pub I2C1: I2C1,
1811 #[doc = "I2C2"]
1812 pub I2C2: I2C2,
1813 #[doc = "IWDG"]
1814 pub IWDG: IWDG,
1815 #[doc = "PWR"]
1816 pub PWR: PWR,
1817 #[doc = "RCC"]
1818 pub RCC: RCC,
1819 #[doc = "RTC"]
1820 pub RTC: RTC,
1821 #[doc = "SDIO"]
1822 pub SDIO: SDIO,
1823 #[doc = "SPI1"]
1824 pub SPI1: SPI1,
1825 #[doc = "SPI2"]
1826 pub SPI2: SPI2,
1827 #[doc = "SPI3"]
1828 pub SPI3: SPI3,
1829 #[doc = "SYSCFG"]
1830 pub SYSCFG: SYSCFG,
1831 #[doc = "TIM1"]
1832 pub TIM1: TIM1,
1833 #[doc = "TIM2"]
1834 pub TIM2: TIM2,
1835 #[doc = "TIM3"]
1836 pub TIM3: TIM3,
1837 #[doc = "TIM4"]
1838 pub TIM4: TIM4,
1839 #[doc = "TIM5"]
1840 pub TIM5: TIM5,
1841 #[doc = "TIM6"]
1842 pub TIM6: TIM6,
1843 #[doc = "TIM7"]
1844 pub TIM7: TIM7,
1845 #[doc = "TIM8"]
1846 pub TIM8: TIM8,
1847 #[doc = "TIM9"]
1848 pub TIM9: TIM9,
1849 #[doc = "TIM10"]
1850 pub TIM10: TIM10,
1851 #[doc = "TIM11"]
1852 pub TIM11: TIM11,
1853 #[doc = "TIM12"]
1854 pub TIM12: TIM12,
1855 #[doc = "TIM13"]
1856 pub TIM13: TIM13,
1857 #[doc = "TIM14"]
1858 pub TIM14: TIM14,
1859 #[doc = "USART1"]
1860 pub USART1: USART1,
1861 #[doc = "USART2"]
1862 pub USART2: USART2,
1863 #[doc = "USART3"]
1864 pub USART3: USART3,
1865 #[doc = "USART4"]
1866 pub USART4: USART4,
1867 #[doc = "USART5"]
1868 pub USART5: USART5,
1869 #[doc = "USB"]
1870 pub USB: USB,
1871 #[doc = "WWDG"]
1872 pub WWDG: WWDG,
1873}
1874impl Peripherals {
1875 #[doc = r"Returns all the peripherals *once*"]
1876 #[inline]
1877 pub fn take() -> Option<Self> {
1878 cortex_m::interrupt::free(|_| {
1879 if unsafe { DEVICE_PERIPHERALS } {
1880 None
1881 } else {
1882 Some(unsafe { Peripherals::steal() })
1883 }
1884 })
1885 }
1886 #[doc = r"Unchecked version of `Peripherals::take`"]
1887 #[inline]
1888 pub unsafe fn steal() -> Self {
1889 DEVICE_PERIPHERALS = true;
1890 Peripherals {
1891 ADC1: ADC1 {
1892 _marker: PhantomData,
1893 },
1894 ADC2: ADC2 {
1895 _marker: PhantomData,
1896 },
1897 ADC3: ADC3 {
1898 _marker: PhantomData,
1899 },
1900 BKP: BKP {
1901 _marker: PhantomData,
1902 },
1903 CANFD: CANFD {
1904 _marker: PhantomData,
1905 },
1906 CRC: CRC {
1907 _marker: PhantomData,
1908 },
1909 CTC: CTC {
1910 _marker: PhantomData,
1911 },
1912 DAC1: DAC1 {
1913 _marker: PhantomData,
1914 },
1915 DBGMCU: DBGMCU {
1916 _marker: PhantomData,
1917 },
1918 DMA1: DMA1 {
1919 _marker: PhantomData,
1920 },
1921 DMA2: DMA2 {
1922 _marker: PhantomData,
1923 },
1924 ESMC: ESMC {
1925 _marker: PhantomData,
1926 },
1927 EXTI: EXTI {
1928 _marker: PhantomData,
1929 },
1930 FLASH: FLASH {
1931 _marker: PhantomData,
1932 },
1933 GPIOA: GPIOA {
1934 _marker: PhantomData,
1935 },
1936 GPIOB: GPIOB {
1937 _marker: PhantomData,
1938 },
1939 GPIOC: GPIOC {
1940 _marker: PhantomData,
1941 },
1942 GPIOD: GPIOD {
1943 _marker: PhantomData,
1944 },
1945 GPIOE: GPIOE {
1946 _marker: PhantomData,
1947 },
1948 I2C1: I2C1 {
1949 _marker: PhantomData,
1950 },
1951 I2C2: I2C2 {
1952 _marker: PhantomData,
1953 },
1954 IWDG: IWDG {
1955 _marker: PhantomData,
1956 },
1957 PWR: PWR {
1958 _marker: PhantomData,
1959 },
1960 RCC: RCC {
1961 _marker: PhantomData,
1962 },
1963 RTC: RTC {
1964 _marker: PhantomData,
1965 },
1966 SDIO: SDIO {
1967 _marker: PhantomData,
1968 },
1969 SPI1: SPI1 {
1970 _marker: PhantomData,
1971 },
1972 SPI2: SPI2 {
1973 _marker: PhantomData,
1974 },
1975 SPI3: SPI3 {
1976 _marker: PhantomData,
1977 },
1978 SYSCFG: SYSCFG {
1979 _marker: PhantomData,
1980 },
1981 TIM1: TIM1 {
1982 _marker: PhantomData,
1983 },
1984 TIM2: TIM2 {
1985 _marker: PhantomData,
1986 },
1987 TIM3: TIM3 {
1988 _marker: PhantomData,
1989 },
1990 TIM4: TIM4 {
1991 _marker: PhantomData,
1992 },
1993 TIM5: TIM5 {
1994 _marker: PhantomData,
1995 },
1996 TIM6: TIM6 {
1997 _marker: PhantomData,
1998 },
1999 TIM7: TIM7 {
2000 _marker: PhantomData,
2001 },
2002 TIM8: TIM8 {
2003 _marker: PhantomData,
2004 },
2005 TIM9: TIM9 {
2006 _marker: PhantomData,
2007 },
2008 TIM10: TIM10 {
2009 _marker: PhantomData,
2010 },
2011 TIM11: TIM11 {
2012 _marker: PhantomData,
2013 },
2014 TIM12: TIM12 {
2015 _marker: PhantomData,
2016 },
2017 TIM13: TIM13 {
2018 _marker: PhantomData,
2019 },
2020 TIM14: TIM14 {
2021 _marker: PhantomData,
2022 },
2023 USART1: USART1 {
2024 _marker: PhantomData,
2025 },
2026 USART2: USART2 {
2027 _marker: PhantomData,
2028 },
2029 USART3: USART3 {
2030 _marker: PhantomData,
2031 },
2032 USART4: USART4 {
2033 _marker: PhantomData,
2034 },
2035 USART5: USART5 {
2036 _marker: PhantomData,
2037 },
2038 USB: USB {
2039 _marker: PhantomData,
2040 },
2041 WWDG: WWDG {
2042 _marker: PhantomData,
2043 },
2044 }
2045 }
2046}