Skip to content
Snippets Groups Projects
Select Git revision
  • fb1f90a722c4b88c4255e9ff933b96ebc661bb09
  • master default protected
2 results

deref_assign.rs

Blame
  • lib.rs 59.26 KiB
    #![doc = "Peripheral access API for STM32F413 microcontrollers (generated using svd2rust v0.14.0)\n\nYou can find an overview of the API [here].\n\n[here]: https://docs.rs/svd2rust/0.14.0/svd2rust/#peripheral-api"]
    #![deny(missing_docs)]
    #![deny(warnings)]
    #![allow(non_camel_case_types)]
    #![no_std]
    extern crate bare_metal;
    extern crate cortex_m;
    #[cfg(feature = "rt")]
    extern crate cortex_m_rt;
    extern crate vcell;
    use core::marker::PhantomData;
    use core::ops::Deref;
    #[doc = r" Number available in the NVIC for configuring priority"]
    pub const NVIC_PRIO_BITS: u8 = 4;
    #[cfg(feature = "rt")]
    extern "C" {
        fn WWDG();
        fn PVD();
        fn TAMP_STAMP();
        fn RTC_WKUP();
        fn FLASH();
        fn RCC();
        fn EXTI0();
        fn EXTI1();
        fn EXTI2();
        fn EXTI3();
        fn EXTI4();
        fn DMA1_STREAM0();
        fn DMA1_STREAM1();
        fn DMA1_STREAM2();
        fn DMA1_STREAM3();
        fn DMA1_STREAM4();
        fn DMA1_STREAM5();
        fn DMA1_STREAM6();
        fn ADC();
        fn CAN1_TX();
        fn CAN1_RX0();
        fn CAN1_RX1();
        fn CAN1_SCE();
        fn EXTI9_5();
        fn TIM1_BRK_TIM9();
        fn TIM1_UP_TIM10();
        fn TIM1_TRG_COM_TIM11();
        fn TIM1_CC();
        fn TIM2();
        fn TIM3();
        fn TIM4();
        fn I2C1_EVT();
        fn I2C1_ERR();
        fn I2C2_EVT();
        fn I2C2_ERR();
        fn SPI1();
        fn SPI2();
        fn USART1();
        fn USART2();
        fn USART3();
        fn EXTI15_10();
        fn EXTI17_RTC_ALARM();
        fn EXTI18_OTG_FS_WKUP();
        fn TIM8_BRK_TIM12();
        fn TIM8_UP_TIM13();
        fn TIM8_TRG_COM_TIM14();
        fn TIM8_CC();
        fn DMA1_STREAM7();
        fn FSMC();
        fn SDIO();
        fn TIM5();
        fn SPI3();
        fn USART4();
        fn UART5();
        fn TIM6_GLB_IT_DAC1_DAC2();
        fn TIM7();
        fn DMA2_STREAM0();
        fn DMA2_STREAM1();
        fn DMA2_STREAM2();
        fn DMA2_STREAM3();
        fn DMA2_STREAM4();
        fn DFSDM1_FLT0();
        fn DFSDM1_FLT1();
        fn CAN2_TX();
        fn CAN2_RX0();
        fn CAN2_RX1();
        fn CAN2_SCE();
        fn OTG_FS_USB();
        fn DMA2_STREAM5();
        fn DMA2_STREAM6();
        fn DMA2_STREAM7();
        fn USART6();
        fn I2C3_EV();
        fn I2C3_ER();
        fn CAN3_TX();
        fn CAN3_RX0();
        fn CAN3_RX1();
        fn CAN3_SCE();
        fn CRYPTO();
        fn RNG();
        fn FPU();
        fn USART7();
        fn USART8();
        fn SPI4();
        fn SPI5();
        fn SAI1();
        fn UART9();
        fn UART10();
        fn QUADSPI();
        fn I2CFMP1EVENT();
        fn I2CFMP1ERROR();
        fn LPTIM1_OR_IT_EIT_23();
        fn DFSDM2_FILTER1();
        fn DFSDM2_FILTER2();
        fn DFSDM2_FILTER3();
        fn DFSDM2_FILTER4();
    }
    #[doc(hidden)]
    pub union Vector {
        _handler: unsafe extern "C" fn(),
        _reserved: u32,
    }
    #[cfg(feature = "rt")]
    #[doc(hidden)]
    #[link_section = ".vector_table.interrupts"]
    #[no_mangle]
    pub static __INTERRUPTS: [Vector; 102] = [
        Vector { _handler: WWDG },
        Vector { _handler: PVD },
        Vector {
            _handler: TAMP_STAMP,
        },
        Vector { _handler: RTC_WKUP },
        Vector { _handler: FLASH },
        Vector { _handler: RCC },
        Vector { _handler: EXTI0 },
        Vector { _handler: EXTI1 },
        Vector { _handler: EXTI2 },
        Vector { _handler: EXTI3 },
        Vector { _handler: EXTI4 },
        Vector {
            _handler: DMA1_STREAM0,
        },
        Vector {
            _handler: DMA1_STREAM1,
        },
        Vector {
            _handler: DMA1_STREAM2,
        },
        Vector {
            _handler: DMA1_STREAM3,
        },
        Vector {
            _handler: DMA1_STREAM4,
        },
        Vector {
            _handler: DMA1_STREAM5,
        },
        Vector {
            _handler: DMA1_STREAM6,
        },
        Vector { _handler: ADC },
        Vector { _handler: CAN1_TX },
        Vector { _handler: CAN1_RX0 },
        Vector { _handler: CAN1_RX1 },
        Vector { _handler: CAN1_SCE },
        Vector { _handler: EXTI9_5 },
        Vector {
            _handler: TIM1_BRK_TIM9,
        },
        Vector {
            _handler: TIM1_UP_TIM10,
        },
        Vector {
            _handler: TIM1_TRG_COM_TIM11,
        },
        Vector { _handler: TIM1_CC },
        Vector { _handler: TIM2 },
        Vector { _handler: TIM3 },
        Vector { _handler: TIM4 },
        Vector { _handler: I2C1_EVT },
        Vector { _handler: I2C1_ERR },
        Vector { _handler: I2C2_EVT },
        Vector { _handler: I2C2_ERR },
        Vector { _handler: SPI1 },
        Vector { _handler: SPI2 },
        Vector { _handler: USART1 },
        Vector { _handler: USART2 },
        Vector { _handler: USART3 },
        Vector {
            _handler: EXTI15_10,
        },
        Vector {
            _handler: EXTI17_RTC_ALARM,
        },
        Vector {
            _handler: EXTI18_OTG_FS_WKUP,
        },
        Vector {
            _handler: TIM8_BRK_TIM12,
        },
        Vector {
            _handler: TIM8_UP_TIM13,
        },
        Vector {
            _handler: TIM8_TRG_COM_TIM14,
        },
        Vector { _handler: TIM8_CC },
        Vector {
            _handler: DMA1_STREAM7,
        },
        Vector { _handler: FSMC },
        Vector { _handler: SDIO },
        Vector { _handler: TIM5 },
        Vector { _handler: SPI3 },
        Vector { _handler: USART4 },
        Vector { _handler: UART5 },
        Vector {
            _handler: TIM6_GLB_IT_DAC1_DAC2,
        },
        Vector { _handler: TIM7 },
        Vector {
            _handler: DMA2_STREAM0,
        },
        Vector {
            _handler: DMA2_STREAM1,
        },
        Vector {
            _handler: DMA2_STREAM2,
        },
        Vector {
            _handler: DMA2_STREAM3,
        },
        Vector {
            _handler: DMA2_STREAM4,
        },
        Vector {
            _handler: DFSDM1_FLT0,
        },
        Vector {
            _handler: DFSDM1_FLT1,
        },
        Vector { _handler: CAN2_TX },
        Vector { _handler: CAN2_RX0 },
        Vector { _handler: CAN2_RX1 },
        Vector { _handler: CAN2_SCE },
        Vector {
            _handler: OTG_FS_USB,
        },
        Vector {
            _handler: DMA2_STREAM5,
        },
        Vector {
            _handler: DMA2_STREAM6,
        },
        Vector {
            _handler: DMA2_STREAM7,
        },
        Vector { _handler: USART6 },
        Vector { _handler: I2C3_EV },
        Vector { _handler: I2C3_ER },
        Vector { _handler: CAN3_TX },
        Vector { _handler: CAN3_RX0 },
        Vector { _handler: CAN3_RX1 },
        Vector { _handler: CAN3_SCE },
        Vector { _reserved: 0 },
        Vector { _handler: CRYPTO },
        Vector { _handler: RNG },
        Vector { _handler: FPU },
        Vector { _handler: USART7 },
        Vector { _handler: USART8 },
        Vector { _handler: SPI4 },
        Vector { _handler: SPI5 },
        Vector { _reserved: 0 },
        Vector { _handler: SAI1 },
        Vector { _handler: UART9 },
        Vector { _handler: UART10 },
        Vector { _reserved: 0 },
        Vector { _reserved: 0 },
        Vector { _handler: QUADSPI },
        Vector { _reserved: 0 },
        Vector { _reserved: 0 },
        Vector {
            _handler: I2CFMP1EVENT,
        },
        Vector {
            _handler: I2CFMP1ERROR,
        },
        Vector {
            _handler: LPTIM1_OR_IT_EIT_23,
        },
        Vector {
            _handler: DFSDM2_FILTER1,
        },
        Vector {
            _handler: DFSDM2_FILTER2,
        },
        Vector {
            _handler: DFSDM2_FILTER3,
        },
        Vector {
            _handler: DFSDM2_FILTER4,
        },
    ];
    #[doc = r" Enumeration of all the interrupts"]
    pub enum Interrupt {
        #[doc = "0 - Window Watchdog interrupt"]
        WWDG,
        #[doc = "1 - PVD through EXTI line detection interrupt"]
        PVD,
        #[doc = "2 - Tamper and TimeStamp interrupts through the EXTI line"]
        TAMP_STAMP,
        #[doc = "3 - RTC Wakeup interrupt through the EXTI line"]
        RTC_WKUP,
        #[doc = "4 - FLASH global interrupt"]
        FLASH,
        #[doc = "5 - RCC global interrupt"]
        RCC,
        #[doc = "6 - EXTI Line0 interrupt"]
        EXTI0,
        #[doc = "7 - EXTI Line1 interrupt"]
        EXTI1,
        #[doc = "8 - EXTI Line2 interrupt"]
        EXTI2,
        #[doc = "9 - EXTI Line3 interrupt"]
        EXTI3,
        #[doc = "10 - EXTI Line4 interrupt"]
        EXTI4,
        #[doc = "11 - DMA1 Stream0 global interrupt"]
        DMA1_STREAM0,
        #[doc = "12 - DMA1 Stream1 global interrupt"]
        DMA1_STREAM1,
        #[doc = "13 - DMA1 Stream2 global interrupt"]
        DMA1_STREAM2,
        #[doc = "14 - DMA1 Stream3 global interrupt"]
        DMA1_STREAM3,
        #[doc = "15 - DMA1 Stream4 global interrupt"]
        DMA1_STREAM4,
        #[doc = "16 - DMA1 Stream5 global interrupt"]
        DMA1_STREAM5,
        #[doc = "17 - DMA1 Stream6 global interrupt"]
        DMA1_STREAM6,
        #[doc = "18 - ADC1 global interrupt"]
        ADC,
        #[doc = "19 - CAN1 TX interrupts"]
        CAN1_TX,
        #[doc = "20 - CAN1 RX0 interrupts"]
        CAN1_RX0,
        #[doc = "21 - CAN1 RX1 interrupts"]
        CAN1_RX1,
        #[doc = "22 - CAN1 SCE interrupt"]
        CAN1_SCE,
        #[doc = "23 - EXTI Line\\[9:5\\] interrupts"]
        EXTI9_5,
        #[doc = "24 - TIM1 Break interrupt and TIM9 global interrupt"]
        TIM1_BRK_TIM9,
        #[doc = "25 - TIM1 Update interrupt and TIM10 global interrupt"]
        TIM1_UP_TIM10,
        #[doc = "26 - TIM1 Trigger and Commutation interrupts and TIM11 global interrupt"]
        TIM1_TRG_COM_TIM11,
        #[doc = "27 - TIM1 Capture Compare interrupt"]
        TIM1_CC,
        #[doc = "28 - TIM2 global interrupt"]
        TIM2,
        #[doc = "29 - TIM3 global interrupt"]
        TIM3,
        #[doc = "30 - TIM4 global interrupt"]
        TIM4,
        #[doc = "31 - I2C1 event interrupt"]
        I2C1_EVT,
        #[doc = "32 - I2C1 error interrupt"]
        I2C1_ERR,
        #[doc = "33 - I2C2 event interrupt"]
        I2C2_EVT,
        #[doc = "34 - I2C2 error interrupt"]
        I2C2_ERR,
        #[doc = "35 - SPI1 global interrupt"]
        SPI1,
        #[doc = "36 - SPI2 global interrupt"]
        SPI2,
        #[doc = "37 - USART1 global interrupt"]
        USART1,
        #[doc = "38 - USART2 global interrupt"]
        USART2,
        #[doc = "39 - USART3 global interrupt"]
        USART3,
        #[doc = "40 - EXTI Line\\[15:10\\] interrupts"]
        EXTI15_10,
        #[doc = "41 - RTC Alarms (A and B) through EXTI line interrupt"]
        EXTI17_RTC_ALARM,
        #[doc = "42 - USB On-The-Go FS Wakeup through EXTI line interrupt"]
        EXTI18_OTG_FS_WKUP,
        #[doc = "43 - Timer 12 global interrupt"]
        TIM8_BRK_TIM12,
        #[doc = "44 - Timer 13 global interrupt"]
        TIM8_UP_TIM13,
        #[doc = "45 - Timer 14 global interrupt"]
        TIM8_TRG_COM_TIM14,
        #[doc = "46 - TIM8 Cap/Com interrupt"]
        TIM8_CC,
        #[doc = "47 - DMA1 global interrupt Channel 7"]
        DMA1_STREAM7,
        #[doc = "48 - FSMC global interrupt"]
        FSMC,
        #[doc = "49 - SDIO global interrupt"]
        SDIO,
        #[doc = "50 - TIM5 global interrupt"]
        TIM5,
        #[doc = "51 - SPI3 global interrupt"]
        SPI3,
        #[doc = "52 - UART 4 global interrupt"]
        USART4,
        #[doc = "53 - UART 5global interrupt"]
        UART5,
        #[doc = "54 - TIM6 global and DAC12 underrun interrupts"]
        TIM6_GLB_IT_DAC1_DAC2,
        #[doc = "55 - TIM7 global interrupt"]
        TIM7,
        #[doc = "56 - DMA2 Stream0 global interrupt"]
        DMA2_STREAM0,
        #[doc = "57 - DMA2 Stream1 global interrupt"]
        DMA2_STREAM1,
        #[doc = "58 - DMA2 Stream2 global interrupt"]
        DMA2_STREAM2,
        #[doc = "59 - DMA2 Stream3 global interrupt"]
        DMA2_STREAM3,
        #[doc = "60 - DMA2 Stream4 global interrupt"]
        DMA2_STREAM4,
        #[doc = "61 - SD filter0 global interrupt"]
        DFSDM1_FLT0,
        #[doc = "62 - SD filter1 global interrupt"]
        DFSDM1_FLT1,
        #[doc = "63 - CAN2 TX interrupt"]
        CAN2_TX,
        #[doc = "64 - BXCAN2 RX0 interrupt"]
        CAN2_RX0,
        #[doc = "65 - BXCAN2 RX1 interrupt"]
        CAN2_RX1,
        #[doc = "66 - CAN2 SCE interrupt"]
        CAN2_SCE,
        #[doc = "67 - USB On The Go FS global interrupt"]
        OTG_FS_USB,
        #[doc = "68 - DMA2 Stream5 global interrupt"]
        DMA2_STREAM5,
        #[doc = "69 - DMA2 Stream6 global interrupt"]
        DMA2_STREAM6,
        #[doc = "70 - DMA2 Stream7 global interrupt"]
        DMA2_STREAM7,
        #[doc = "71 - USART6 global interrupt"]
        USART6,
        #[doc = "72 - I2C3 event interrupt"]
        I2C3_EV,
        #[doc = "73 - I2C3 error interrupt"]
        I2C3_ER,
        #[doc = "74 - CAN 3 TX interrupt"]
        CAN3_TX,
        #[doc = "75 - BxCAN 3 RX0 interrupt"]
        CAN3_RX0,
        #[doc = "76 - BxCAN 3 RX1 interrupt"]
        CAN3_RX1,
        #[doc = "77 - CAN 3 SCE interrupt"]
        CAN3_SCE,
        #[doc = "79 - AES global interrupt"]
        CRYPTO,
        #[doc = "80 - Rng global interrupt"]
        RNG,
        #[doc = "81 - FPU global interrupt"]
        FPU,
        #[doc = "82 - USART7 global interrupt"]
        USART7,
        #[doc = "83 - USART8 global interrupt"]
        USART8,
        #[doc = "84 - SPI4 global interrupt"]
        SPI4,
        #[doc = "85 - SPI5 global interrupt"]
        SPI5,
        #[doc = "87 - SAI1 global interrupt"]
        SAI1,
        #[doc = "88 - UART9 global interrupt"]
        UART9,
        #[doc = "89 - UART10 global interrupt"]
        UART10,
        #[doc = "92 - Quad-SPI global interrupt"]
        QUADSPI,
        #[doc = "95 - I2CFMP1 event interrupt"]
        I2CFMP1EVENT,
        #[doc = "96 - I2CFMP1 error interrupt"]
        I2CFMP1ERROR,
        #[doc = "97 - LP Timer global interrupt or EXT1 interrupt line 23"]
        LPTIM1_OR_IT_EIT_23,
        #[doc = "98 - DFSDM2 SD filter 1 global interrupt"]
        DFSDM2_FILTER1,
        #[doc = "99 - DFSDM2 SD filter 2 global interrupt"]
        DFSDM2_FILTER2,
        #[doc = "100 - DFSDM2 SD filter 3 global interrupt"]
        DFSDM2_FILTER3,
        #[doc = "101 - DFSDM2 SD filter 4 global interrupt"]
        DFSDM2_FILTER4,
    }
    unsafe impl ::bare_metal::Nr for Interrupt {
        #[inline]
        fn nr(&self) -> u8 {
            match *self {
                Interrupt::WWDG => 0,
                Interrupt::PVD => 1,
                Interrupt::TAMP_STAMP => 2,
                Interrupt::RTC_WKUP => 3,
                Interrupt::FLASH => 4,
                Interrupt::RCC => 5,
                Interrupt::EXTI0 => 6,
                Interrupt::EXTI1 => 7,
                Interrupt::EXTI2 => 8,
                Interrupt::EXTI3 => 9,
                Interrupt::EXTI4 => 10,
                Interrupt::DMA1_STREAM0 => 11,
                Interrupt::DMA1_STREAM1 => 12,
                Interrupt::DMA1_STREAM2 => 13,
                Interrupt::DMA1_STREAM3 => 14,
                Interrupt::DMA1_STREAM4 => 15,
                Interrupt::DMA1_STREAM5 => 16,
                Interrupt::DMA1_STREAM6 => 17,
                Interrupt::ADC => 18,
                Interrupt::CAN1_TX => 19,
                Interrupt::CAN1_RX0 => 20,
                Interrupt::CAN1_RX1 => 21,
                Interrupt::CAN1_SCE => 22,
                Interrupt::EXTI9_5 => 23,
                Interrupt::TIM1_BRK_TIM9 => 24,
                Interrupt::TIM1_UP_TIM10 => 25,
                Interrupt::TIM1_TRG_COM_TIM11 => 26,
                Interrupt::TIM1_CC => 27,
                Interrupt::TIM2 => 28,
                Interrupt::TIM3 => 29,
                Interrupt::TIM4 => 30,
                Interrupt::I2C1_EVT => 31,
                Interrupt::I2C1_ERR => 32,
                Interrupt::I2C2_EVT => 33,
                Interrupt::I2C2_ERR => 34,
                Interrupt::SPI1 => 35,
                Interrupt::SPI2 => 36,
                Interrupt::USART1 => 37,
                Interrupt::USART2 => 38,
                Interrupt::USART3 => 39,
                Interrupt::EXTI15_10 => 40,
                Interrupt::EXTI17_RTC_ALARM => 41,
                Interrupt::EXTI18_OTG_FS_WKUP => 42,
                Interrupt::TIM8_BRK_TIM12 => 43,
                Interrupt::TIM8_UP_TIM13 => 44,
                Interrupt::TIM8_TRG_COM_TIM14 => 45,
                Interrupt::TIM8_CC => 46,
                Interrupt::DMA1_STREAM7 => 47,
                Interrupt::FSMC => 48,
                Interrupt::SDIO => 49,
                Interrupt::TIM5 => 50,
                Interrupt::SPI3 => 51,
                Interrupt::USART4 => 52,
                Interrupt::UART5 => 53,
                Interrupt::TIM6_GLB_IT_DAC1_DAC2 => 54,
                Interrupt::TIM7 => 55,
                Interrupt::DMA2_STREAM0 => 56,
                Interrupt::DMA2_STREAM1 => 57,
                Interrupt::DMA2_STREAM2 => 58,
                Interrupt::DMA2_STREAM3 => 59,
                Interrupt::DMA2_STREAM4 => 60,
                Interrupt::DFSDM1_FLT0 => 61,
                Interrupt::DFSDM1_FLT1 => 62,
                Interrupt::CAN2_TX => 63,
                Interrupt::CAN2_RX0 => 64,
                Interrupt::CAN2_RX1 => 65,
                Interrupt::CAN2_SCE => 66,
                Interrupt::OTG_FS_USB => 67,
                Interrupt::DMA2_STREAM5 => 68,
                Interrupt::DMA2_STREAM6 => 69,
                Interrupt::DMA2_STREAM7 => 70,
                Interrupt::USART6 => 71,
                Interrupt::I2C3_EV => 72,
                Interrupt::I2C3_ER => 73,
                Interrupt::CAN3_TX => 74,
                Interrupt::CAN3_RX0 => 75,
                Interrupt::CAN3_RX1 => 76,
                Interrupt::CAN3_SCE => 77,
                Interrupt::CRYPTO => 79,
                Interrupt::RNG => 80,
                Interrupt::FPU => 81,
                Interrupt::USART7 => 82,
                Interrupt::USART8 => 83,
                Interrupt::SPI4 => 84,
                Interrupt::SPI5 => 85,
                Interrupt::SAI1 => 87,
                Interrupt::UART9 => 88,
                Interrupt::UART10 => 89,
                Interrupt::QUADSPI => 92,
                Interrupt::I2CFMP1EVENT => 95,
                Interrupt::I2CFMP1ERROR => 96,
                Interrupt::LPTIM1_OR_IT_EIT_23 => 97,
                Interrupt::DFSDM2_FILTER1 => 98,
                Interrupt::DFSDM2_FILTER2 => 99,
                Interrupt::DFSDM2_FILTER3 => 100,
                Interrupt::DFSDM2_FILTER4 => 101,
            }
        }
    }
    #[cfg(feature = "rt")]
    pub use self::Interrupt as interrupt;
    pub use cortex_m::peripheral::Peripherals as CorePeripherals;
    pub use cortex_m::peripheral::{CBP, CPUID, DCB, DWT, FPB, FPU, ITM, MPU, NVIC, SCB, SYST, TPIU};
    #[cfg(feature = "rt")]
    pub use cortex_m_rt::interrupt;
    #[doc = "Analog-to-digital converter"]
    pub struct ADC1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for ADC1 {}
    impl ADC1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const adc1::RegisterBlock {
            1073815552 as *const _
        }
    }
    impl Deref for ADC1 {
        type Target = adc1::RegisterBlock;
        fn deref(&self) -> &adc1::RegisterBlock {
            unsafe { &*ADC1::ptr() }
        }
    }
    #[doc = "Analog-to-digital converter"]
    pub mod adc1;
    #[doc = "Cryptographic processor"]
    pub struct CRC {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for CRC {}
    impl CRC {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const crc::RegisterBlock {
            1073885184 as *const _
        }
    }
    impl Deref for CRC {
        type Target = crc::RegisterBlock;
        fn deref(&self) -> &crc::RegisterBlock {
            unsafe { &*CRC::ptr() }
        }
    }
    #[doc = "Cryptographic processor"]
    pub mod crc;
    #[doc = "Debug support"]
    pub struct DBG {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for DBG {}
    impl DBG {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const dbg::RegisterBlock {
            3758366720 as *const _
        }
    }
    impl Deref for DBG {
        type Target = dbg::RegisterBlock;
        fn deref(&self) -> &dbg::RegisterBlock {
            unsafe { &*DBG::ptr() }
        }
    }
    #[doc = "Debug support"]
    pub mod dbg;
    #[doc = "External interrupt/event controller"]
    pub struct EXTI {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for EXTI {}
    impl EXTI {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const exti::RegisterBlock {
            1073822720 as *const _
        }
    }
    impl Deref for EXTI {
        type Target = exti::RegisterBlock;
        fn deref(&self) -> &exti::RegisterBlock {
            unsafe { &*EXTI::ptr() }
        }
    }
    #[doc = "External interrupt/event controller"]
    pub mod exti;
    #[doc = "FLASH"]
    pub struct FLASH {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for FLASH {}
    impl FLASH {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const flash::RegisterBlock {
            1073888256 as *const _
        }
    }
    impl Deref for FLASH {
        type Target = flash::RegisterBlock;
        fn deref(&self) -> &flash::RegisterBlock {
            unsafe { &*FLASH::ptr() }
        }
    }
    #[doc = "FLASH"]
    pub mod flash;
    #[doc = "Independent watchdog"]
    pub struct IWDG {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for IWDG {}
    impl IWDG {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const iwdg::RegisterBlock {
            1073754112 as *const _
        }
    }
    impl Deref for IWDG {
        type Target = iwdg::RegisterBlock;
        fn deref(&self) -> &iwdg::RegisterBlock {
            unsafe { &*IWDG::ptr() }
        }
    }
    #[doc = "Independent watchdog"]
    pub mod iwdg;
    #[doc = "Power control"]
    pub struct PWR {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for PWR {}
    impl PWR {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const pwr::RegisterBlock {
            1073770496 as *const _
        }
    }
    impl Deref for PWR {
        type Target = pwr::RegisterBlock;
        fn deref(&self) -> &pwr::RegisterBlock {
            unsafe { &*PWR::ptr() }
        }
    }
    #[doc = "Power control"]
    pub mod pwr;
    #[doc = "Reset and clock control"]
    pub struct RCC {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for RCC {}
    impl RCC {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const rcc::RegisterBlock {
            1073887232 as *const _
        }
    }
    impl Deref for RCC {
        type Target = rcc::RegisterBlock;
        fn deref(&self) -> &rcc::RegisterBlock {
            unsafe { &*RCC::ptr() }
        }
    }
    #[doc = "Reset and clock control"]
    pub mod rcc;
    #[doc = "Real-time clock"]
    pub struct RTC {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for RTC {}
    impl RTC {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const rtc::RegisterBlock {
            1073752064 as *const _
        }
    }
    impl Deref for RTC {
        type Target = rtc::RegisterBlock;
        fn deref(&self) -> &rtc::RegisterBlock {
            unsafe { &*RTC::ptr() }
        }
    }
    #[doc = "Real-time clock"]
    pub mod rtc;
    #[doc = "Secure digital input/output interface"]
    pub struct SDIO {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SDIO {}
    impl SDIO {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const sdio::RegisterBlock {
            1073818624 as *const _
        }
    }
    impl Deref for SDIO {
        type Target = sdio::RegisterBlock;
        fn deref(&self) -> &sdio::RegisterBlock {
            unsafe { &*SDIO::ptr() }
        }
    }
    #[doc = "Secure digital input/output interface"]
    pub mod sdio;
    #[doc = "System configuration controller"]
    pub struct SYSCFG {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SYSCFG {}
    impl SYSCFG {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const syscfg::RegisterBlock {
            1073821696 as *const _
        }
    }
    impl Deref for SYSCFG {
        type Target = syscfg::RegisterBlock;
        fn deref(&self) -> &syscfg::RegisterBlock {
            unsafe { &*SYSCFG::ptr() }
        }
    }
    #[doc = "System configuration controller"]
    pub mod syscfg;
    #[doc = "Advanced-timers"]
    pub struct TIM1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM1 {}
    impl TIM1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim1::RegisterBlock {
            1073807360 as *const _
        }
    }
    impl Deref for TIM1 {
        type Target = tim1::RegisterBlock;
        fn deref(&self) -> &tim1::RegisterBlock {
            unsafe { &*TIM1::ptr() }
        }
    }
    #[doc = "Advanced-timers"]
    pub mod tim1;
    #[doc = "TIM8"]
    pub struct TIM8 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM8 {}
    impl TIM8 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim1::RegisterBlock {
            1073808384 as *const _
        }
    }
    impl Deref for TIM8 {
        type Target = tim1::RegisterBlock;
        fn deref(&self) -> &tim1::RegisterBlock {
            unsafe { &*TIM8::ptr() }
        }
    }
    #[doc = "General-purpose-timers"]
    pub struct TIM10 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM10 {}
    impl TIM10 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim10::RegisterBlock {
            1073824768 as *const _
        }
    }
    impl Deref for TIM10 {
        type Target = tim10::RegisterBlock;
        fn deref(&self) -> &tim10::RegisterBlock {
            unsafe { &*TIM10::ptr() }
        }
    }
    #[doc = "General-purpose-timers"]
    pub mod tim10;
    #[doc = "General-purpose-timers"]
    pub struct TIM11 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM11 {}
    impl TIM11 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim11::RegisterBlock {
            1073825792 as *const _
        }
    }
    impl Deref for TIM11 {
        type Target = tim11::RegisterBlock;
        fn deref(&self) -> &tim11::RegisterBlock {
            unsafe { &*TIM11::ptr() }
        }
    }
    #[doc = "General-purpose-timers"]
    pub mod tim11;
    #[doc = "General purpose timers"]
    pub struct TIM2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM2 {}
    impl TIM2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim2::RegisterBlock {
            1073741824 as *const _
        }
    }
    impl Deref for TIM2 {
        type Target = tim2::RegisterBlock;
        fn deref(&self) -> &tim2::RegisterBlock {
            unsafe { &*TIM2::ptr() }
        }
    }
    #[doc = "General purpose timers"]
    pub mod tim2;
    #[doc = "General purpose timers"]
    pub struct TIM3 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM3 {}
    impl TIM3 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim3::RegisterBlock {
            1073742848 as *const _
        }
    }
    impl Deref for TIM3 {
        type Target = tim3::RegisterBlock;
        fn deref(&self) -> &tim3::RegisterBlock {
            unsafe { &*TIM3::ptr() }
        }
    }
    #[doc = "General purpose timers"]
    pub mod tim3;
    #[doc = "TIM4"]
    pub struct TIM4 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM4 {}
    impl TIM4 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim3::RegisterBlock {
            1073743872 as *const _
        }
    }
    impl Deref for TIM4 {
        type Target = tim3::RegisterBlock;
        fn deref(&self) -> &tim3::RegisterBlock {
            unsafe { &*TIM4::ptr() }
        }
    }
    #[doc = "General-purpose-timers"]
    pub struct TIM5 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM5 {}
    impl TIM5 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim5::RegisterBlock {
            1073744896 as *const _
        }
    }
    impl Deref for TIM5 {
        type Target = tim5::RegisterBlock;
        fn deref(&self) -> &tim5::RegisterBlock {
            unsafe { &*TIM5::ptr() }
        }
    }
    #[doc = "General-purpose-timers"]
    pub mod tim5;
    #[doc = "General purpose timers"]
    pub struct TIM9 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM9 {}
    impl TIM9 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim9::RegisterBlock {
            1073823744 as *const _
        }
    }
    impl Deref for TIM9 {
        type Target = tim9::RegisterBlock;
        fn deref(&self) -> &tim9::RegisterBlock {
            unsafe { &*TIM9::ptr() }
        }
    }
    #[doc = "General purpose timers"]
    pub mod tim9;
    #[doc = "Universal synchronous asynchronous receiver transmitter"]
    pub struct USART1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for USART1 {}
    impl USART1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073811456 as *const _
        }
    }
    impl Deref for USART1 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*USART1::ptr() }
        }
    }
    #[doc = "Universal synchronous asynchronous receiver transmitter"]
    pub mod usart1;
    #[doc = "USART2"]
    pub struct USART2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for USART2 {}
    impl USART2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073759232 as *const _
        }
    }
    impl Deref for USART2 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*USART2::ptr() }
        }
    }
    #[doc = "USART6"]
    pub struct USART6 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for USART6 {}
    impl USART6 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073812480 as *const _
        }
    }
    impl Deref for USART6 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*USART6::ptr() }
        }
    }
    #[doc = "USART3"]
    pub struct USART3 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for USART3 {}
    impl USART3 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073760256 as *const _
        }
    }
    impl Deref for USART3 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*USART3::ptr() }
        }
    }
    #[doc = "UART4"]
    pub struct UART4 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for UART4 {}
    impl UART4 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073761280 as *const _
        }
    }
    impl Deref for UART4 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*UART4::ptr() }
        }
    }
    #[doc = "UART5"]
    pub struct UART5 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for UART5 {}
    impl UART5 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073762304 as *const _
        }
    }
    impl Deref for UART5 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*UART5::ptr() }
        }
    }
    #[doc = "UART7"]
    pub struct UART7 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for UART7 {}
    impl UART7 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073772544 as *const _
        }
    }
    impl Deref for UART7 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*UART7::ptr() }
        }
    }
    #[doc = "UART8"]
    pub struct UART8 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for UART8 {}
    impl UART8 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073773568 as *const _
        }
    }
    impl Deref for UART8 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*UART8::ptr() }
        }
    }
    #[doc = "UART9"]
    pub struct UART9 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for UART9 {}
    impl UART9 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073813504 as *const _
        }
    }
    impl Deref for UART9 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*UART9::ptr() }
        }
    }
    #[doc = "UART10"]
    pub struct UART10 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for UART10 {}
    impl UART10 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const usart1::RegisterBlock {
            1073814528 as *const _
        }
    }
    impl Deref for UART10 {
        type Target = usart1::RegisterBlock;
        fn deref(&self) -> &usart1::RegisterBlock {
            unsafe { &*UART10::ptr() }
        }
    }
    #[doc = "Window watchdog"]
    pub struct WWDG {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for WWDG {}
    impl WWDG {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const wwdg::RegisterBlock {
            1073753088 as *const _
        }
    }
    impl Deref for WWDG {
        type Target = wwdg::RegisterBlock;
        fn deref(&self) -> &wwdg::RegisterBlock {
            unsafe { &*WWDG::ptr() }
        }
    }
    #[doc = "Window watchdog"]
    pub mod wwdg;
    #[doc = "DMA controller"]
    pub struct DMA2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for DMA2 {}
    impl DMA2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const dma2::RegisterBlock {
            1073898496 as *const _
        }
    }
    impl Deref for DMA2 {
        type Target = dma2::RegisterBlock;
        fn deref(&self) -> &dma2::RegisterBlock {
            unsafe { &*DMA2::ptr() }
        }
    }
    #[doc = "DMA controller"]
    pub mod dma2;
    #[doc = "DMA1"]
    pub struct DMA1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for DMA1 {}
    impl DMA1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const dma2::RegisterBlock {
            1073897472 as *const _
        }
    }
    impl Deref for DMA1 {
        type Target = dma2::RegisterBlock;
        fn deref(&self) -> &dma2::RegisterBlock {
            unsafe { &*DMA1::ptr() }
        }
    }
    #[doc = "General-purpose I/Os"]
    pub struct GPIOH {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOH {}
    impl GPIOH {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioh::RegisterBlock {
            1073880064 as *const _
        }
    }
    impl Deref for GPIOH {
        type Target = gpioh::RegisterBlock;
        fn deref(&self) -> &gpioh::RegisterBlock {
            unsafe { &*GPIOH::ptr() }
        }
    }
    #[doc = "General-purpose I/Os"]
    pub mod gpioh;
    #[doc = "GPIOE"]
    pub struct GPIOE {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOE {}
    impl GPIOE {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioh::RegisterBlock {
            1073876992 as *const _
        }
    }
    impl Deref for GPIOE {
        type Target = gpioh::RegisterBlock;
        fn deref(&self) -> &gpioh::RegisterBlock {
            unsafe { &*GPIOE::ptr() }
        }
    }
    #[doc = "GPIOD"]
    pub struct GPIOD {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOD {}
    impl GPIOD {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioh::RegisterBlock {
            1073875968 as *const _
        }
    }
    impl Deref for GPIOD {
        type Target = gpioh::RegisterBlock;
        fn deref(&self) -> &gpioh::RegisterBlock {
            unsafe { &*GPIOD::ptr() }
        }
    }
    #[doc = "GPIOC"]
    pub struct GPIOC {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOC {}
    impl GPIOC {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioh::RegisterBlock {
            1073874944 as *const _
        }
    }
    impl Deref for GPIOC {
        type Target = gpioh::RegisterBlock;
        fn deref(&self) -> &gpioh::RegisterBlock {
            unsafe { &*GPIOC::ptr() }
        }
    }
    #[doc = "GPIOF"]
    pub struct GPIOF {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOF {}
    impl GPIOF {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioh::RegisterBlock {
            1073878016 as *const _
        }
    }
    impl Deref for GPIOF {
        type Target = gpioh::RegisterBlock;
        fn deref(&self) -> &gpioh::RegisterBlock {
            unsafe { &*GPIOF::ptr() }
        }
    }
    #[doc = "GPIOG"]
    pub struct GPIOG {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOG {}
    impl GPIOG {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioh::RegisterBlock {
            1073879040 as *const _
        }
    }
    impl Deref for GPIOG {
        type Target = gpioh::RegisterBlock;
        fn deref(&self) -> &gpioh::RegisterBlock {
            unsafe { &*GPIOG::ptr() }
        }
    }
    #[doc = "General-purpose I/Os"]
    pub struct GPIOB {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOB {}
    impl GPIOB {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpiob::RegisterBlock {
            1073873920 as *const _
        }
    }
    impl Deref for GPIOB {
        type Target = gpiob::RegisterBlock;
        fn deref(&self) -> &gpiob::RegisterBlock {
            unsafe { &*GPIOB::ptr() }
        }
    }
    #[doc = "General-purpose I/Os"]
    pub mod gpiob;
    #[doc = "General-purpose I/Os"]
    pub struct GPIOA {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for GPIOA {}
    impl GPIOA {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const gpioa::RegisterBlock {
            1073872896 as *const _
        }
    }
    impl Deref for GPIOA {
        type Target = gpioa::RegisterBlock;
        fn deref(&self) -> &gpioa::RegisterBlock {
            unsafe { &*GPIOA::ptr() }
        }
    }
    #[doc = "General-purpose I/Os"]
    pub mod gpioa;
    #[doc = "Inter-integrated circuit"]
    pub struct I2C3 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for I2C3 {}
    impl I2C3 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2c3::RegisterBlock {
            1073765376 as *const _
        }
    }
    impl Deref for I2C3 {
        type Target = i2c3::RegisterBlock;
        fn deref(&self) -> &i2c3::RegisterBlock {
            unsafe { &*I2C3::ptr() }
        }
    }
    #[doc = "Inter-integrated circuit"]
    pub mod i2c3;
    #[doc = "I2C2"]
    pub struct I2C2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for I2C2 {}
    impl I2C2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2c3::RegisterBlock {
            1073764352 as *const _
        }
    }
    impl Deref for I2C2 {
        type Target = i2c3::RegisterBlock;
        fn deref(&self) -> &i2c3::RegisterBlock {
            unsafe { &*I2C2::ptr() }
        }
    }
    #[doc = "I2C1"]
    pub struct I2C1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for I2C1 {}
    impl I2C1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2c3::RegisterBlock {
            1073763328 as *const _
        }
    }
    impl Deref for I2C1 {
        type Target = i2c3::RegisterBlock;
        fn deref(&self) -> &i2c3::RegisterBlock {
            unsafe { &*I2C1::ptr() }
        }
    }
    #[doc = "Serial peripheral interface"]
    pub struct I2S2EXT {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for I2S2EXT {}
    impl I2S2EXT {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073755136 as *const _
        }
    }
    impl Deref for I2S2EXT {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*I2S2EXT::ptr() }
        }
    }
    #[doc = "Serial peripheral interface"]
    pub mod i2s2ext;
    #[doc = "I2S3ext"]
    pub struct I2S3EXT {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for I2S3EXT {}
    impl I2S3EXT {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073758208 as *const _
        }
    }
    impl Deref for I2S3EXT {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*I2S3EXT::ptr() }
        }
    }
    #[doc = "SPI1"]
    pub struct SPI1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SPI1 {}
    impl SPI1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073819648 as *const _
        }
    }
    impl Deref for SPI1 {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*SPI1::ptr() }
        }
    }
    #[doc = "SPI2"]
    pub struct SPI2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SPI2 {}
    impl SPI2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073756160 as *const _
        }
    }
    impl Deref for SPI2 {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*SPI2::ptr() }
        }
    }
    #[doc = "SPI3"]
    pub struct SPI3 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SPI3 {}
    impl SPI3 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073757184 as *const _
        }
    }
    impl Deref for SPI3 {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*SPI3::ptr() }
        }
    }
    #[doc = "SPI4"]
    pub struct SPI4 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SPI4 {}
    impl SPI4 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073820672 as *const _
        }
    }
    impl Deref for SPI4 {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*SPI4::ptr() }
        }
    }
    #[doc = "SPI5"]
    pub struct SPI5 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SPI5 {}
    impl SPI5 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073827840 as *const _
        }
    }
    impl Deref for SPI5 {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*SPI5::ptr() }
        }
    }
    #[doc = "SPI6"]
    pub struct SPI6 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SPI6 {}
    impl SPI6 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const i2s2ext::RegisterBlock {
            1073828864 as *const _
        }
    }
    impl Deref for SPI6 {
        type Target = i2s2ext::RegisterBlock;
        fn deref(&self) -> &i2s2ext::RegisterBlock {
            unsafe { &*SPI6::ptr() }
        }
    }
    #[doc = "Digital filter for sigma delta modulators"]
    pub struct DFSDM1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for DFSDM1 {}
    impl DFSDM1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const dfsdm1::RegisterBlock {
            1073831936 as *const _
        }
    }
    impl Deref for DFSDM1 {
        type Target = dfsdm1::RegisterBlock;
        fn deref(&self) -> &dfsdm1::RegisterBlock {
            unsafe { &*DFSDM1::ptr() }
        }
    }
    #[doc = "Digital filter for sigma delta modulators"]
    pub mod dfsdm1;
    #[doc = "DFSDM2"]
    pub struct DFSDM2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for DFSDM2 {}
    impl DFSDM2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const dfsdm1::RegisterBlock {
            1073832960 as *const _
        }
    }
    impl Deref for DFSDM2 {
        type Target = dfsdm1::RegisterBlock;
        fn deref(&self) -> &dfsdm1::RegisterBlock {
            unsafe { &*DFSDM2::ptr() }
        }
    }
    #[doc = "Basic timers"]
    pub struct TIM6 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM6 {}
    impl TIM6 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim6::RegisterBlock {
            1073745920 as *const _
        }
    }
    impl Deref for TIM6 {
        type Target = tim6::RegisterBlock;
        fn deref(&self) -> &tim6::RegisterBlock {
            unsafe { &*TIM6::ptr() }
        }
    }
    #[doc = "Basic timers"]
    pub mod tim6;
    #[doc = "TIM7"]
    pub struct TIM7 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM7 {}
    impl TIM7 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim6::RegisterBlock {
            1073746944 as *const _
        }
    }
    impl Deref for TIM7 {
        type Target = tim6::RegisterBlock;
        fn deref(&self) -> &tim6::RegisterBlock {
            unsafe { &*TIM7::ptr() }
        }
    }
    #[doc = "General purpose timers"]
    pub struct TIM12 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM12 {}
    impl TIM12 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim12::RegisterBlock {
            1073747968 as *const _
        }
    }
    impl Deref for TIM12 {
        type Target = tim12::RegisterBlock;
        fn deref(&self) -> &tim12::RegisterBlock {
            unsafe { &*TIM12::ptr() }
        }
    }
    #[doc = "General purpose timers"]
    pub mod tim12;
    #[doc = "General purpose timers"]
    pub struct TIM13 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM13 {}
    impl TIM13 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim13::RegisterBlock {
            1073748992 as *const _
        }
    }
    impl Deref for TIM13 {
        type Target = tim13::RegisterBlock;
        fn deref(&self) -> &tim13::RegisterBlock {
            unsafe { &*TIM13::ptr() }
        }
    }
    #[doc = "General purpose timers"]
    pub mod tim13;
    #[doc = "TIM14"]
    pub struct TIM14 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for TIM14 {}
    impl TIM14 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const tim13::RegisterBlock {
            1073750016 as *const _
        }
    }
    impl Deref for TIM14 {
        type Target = tim13::RegisterBlock;
        fn deref(&self) -> &tim13::RegisterBlock {
            unsafe { &*TIM14::ptr() }
        }
    }
    #[doc = "Random number generator"]
    pub struct RNG {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for RNG {}
    impl RNG {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const rng::RegisterBlock {
            1342572544 as *const _
        }
    }
    impl Deref for RNG {
        type Target = rng::RegisterBlock;
        fn deref(&self) -> &rng::RegisterBlock {
            unsafe { &*RNG::ptr() }
        }
    }
    #[doc = "Random number generator"]
    pub mod rng;
    #[doc = "Controller area network"]
    pub struct CAN1 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for CAN1 {}
    impl CAN1 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const can1::RegisterBlock {
            1073767424 as *const _
        }
    }
    impl Deref for CAN1 {
        type Target = can1::RegisterBlock;
        fn deref(&self) -> &can1::RegisterBlock {
            unsafe { &*CAN1::ptr() }
        }
    }
    #[doc = "Controller area network"]
    pub mod can1;
    #[doc = "CAN2"]
    pub struct CAN2 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for CAN2 {}
    impl CAN2 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const can1::RegisterBlock {
            1073768448 as *const _
        }
    }
    impl Deref for CAN2 {
        type Target = can1::RegisterBlock;
        fn deref(&self) -> &can1::RegisterBlock {
            unsafe { &*CAN2::ptr() }
        }
    }
    #[doc = "CAN3"]
    pub struct CAN3 {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for CAN3 {}
    impl CAN3 {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const can1::RegisterBlock {
            1073769472 as *const _
        }
    }
    impl Deref for CAN3 {
        type Target = can1::RegisterBlock;
        fn deref(&self) -> &can1::RegisterBlock {
            unsafe { &*CAN3::ptr() }
        }
    }
    #[doc = "fast-mode Inter-integrated circuit"]
    pub struct FMPI2C {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for FMPI2C {}
    impl FMPI2C {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const fmpi2c::RegisterBlock {
            1073766400 as *const _
        }
    }
    impl Deref for FMPI2C {
        type Target = fmpi2c::RegisterBlock;
        fn deref(&self) -> &fmpi2c::RegisterBlock {
            unsafe { &*FMPI2C::ptr() }
        }
    }
    #[doc = "fast-mode Inter-integrated circuit"]
    pub mod fmpi2c;
    #[doc = "Flexible static memory controller"]
    pub struct FSMC {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for FSMC {}
    impl FSMC {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const fsmc::RegisterBlock {
            2684354560 as *const _
        }
    }
    impl Deref for FSMC {
        type Target = fsmc::RegisterBlock;
        fn deref(&self) -> &fsmc::RegisterBlock {
            unsafe { &*FSMC::ptr() }
        }
    }
    #[doc = "Flexible static memory controller"]
    pub mod fsmc;
    #[doc = "USB on the go full speed"]
    pub struct OTG_FS_GLOBAL {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for OTG_FS_GLOBAL {}
    impl OTG_FS_GLOBAL {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const otg_fs_global::RegisterBlock {
            1342177280 as *const _
        }
    }
    impl Deref for OTG_FS_GLOBAL {
        type Target = otg_fs_global::RegisterBlock;
        fn deref(&self) -> &otg_fs_global::RegisterBlock {
            unsafe { &*OTG_FS_GLOBAL::ptr() }
        }
    }
    #[doc = "USB on the go full speed"]
    pub mod otg_fs_global;
    #[doc = "USB on the go full speed"]
    pub struct OTG_FS_HOST {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for OTG_FS_HOST {}
    impl OTG_FS_HOST {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const otg_fs_host::RegisterBlock {
            1342178304 as *const _
        }
    }
    impl Deref for OTG_FS_HOST {
        type Target = otg_fs_host::RegisterBlock;
        fn deref(&self) -> &otg_fs_host::RegisterBlock {
            unsafe { &*OTG_FS_HOST::ptr() }
        }
    }
    #[doc = "USB on the go full speed"]
    pub mod otg_fs_host;
    #[doc = "USB on the go full speed"]
    pub struct OTG_FS_DEVICE {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for OTG_FS_DEVICE {}
    impl OTG_FS_DEVICE {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const otg_fs_device::RegisterBlock {
            1342179328 as *const _
        }
    }
    impl Deref for OTG_FS_DEVICE {
        type Target = otg_fs_device::RegisterBlock;
        fn deref(&self) -> &otg_fs_device::RegisterBlock {
            unsafe { &*OTG_FS_DEVICE::ptr() }
        }
    }
    #[doc = "USB on the go full speed"]
    pub mod otg_fs_device;
    #[doc = "USB on the go full speed"]
    pub struct OTG_FS_PWRCLK {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for OTG_FS_PWRCLK {}
    impl OTG_FS_PWRCLK {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const otg_fs_pwrclk::RegisterBlock {
            1342180864 as *const _
        }
    }
    impl Deref for OTG_FS_PWRCLK {
        type Target = otg_fs_pwrclk::RegisterBlock;
        fn deref(&self) -> &otg_fs_pwrclk::RegisterBlock {
            unsafe { &*OTG_FS_PWRCLK::ptr() }
        }
    }
    #[doc = "USB on the go full speed"]
    pub mod otg_fs_pwrclk;
    #[doc = "QuadSPI interface"]
    pub struct QUADSPI {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for QUADSPI {}
    impl QUADSPI {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const quadspi::RegisterBlock {
            2684358656 as *const _
        }
    }
    impl Deref for QUADSPI {
        type Target = quadspi::RegisterBlock;
        fn deref(&self) -> &quadspi::RegisterBlock {
            unsafe { &*QUADSPI::ptr() }
        }
    }
    #[doc = "QuadSPI interface"]
    pub mod quadspi;
    #[doc = "Low power timer"]
    pub struct LPTIM {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for LPTIM {}
    impl LPTIM {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const lptim::RegisterBlock {
            1073751040 as *const _
        }
    }
    impl Deref for LPTIM {
        type Target = lptim::RegisterBlock;
        fn deref(&self) -> &lptim::RegisterBlock {
            unsafe { &*LPTIM::ptr() }
        }
    }
    #[doc = "Low power timer"]
    pub mod lptim;
    #[doc = "Digital-to-analog converter"]
    pub struct DAC {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for DAC {}
    impl DAC {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const dac::RegisterBlock {
            1073771520 as *const _
        }
    }
    impl Deref for DAC {
        type Target = dac::RegisterBlock;
        fn deref(&self) -> &dac::RegisterBlock {
            unsafe { &*DAC::ptr() }
        }
    }
    #[doc = "Digital-to-analog converter"]
    pub mod dac;
    #[doc = "Serial audio interface"]
    pub struct SAI {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for SAI {}
    impl SAI {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const sai::RegisterBlock {
            1073829888 as *const _
        }
    }
    impl Deref for SAI {
        type Target = sai::RegisterBlock;
        fn deref(&self) -> &sai::RegisterBlock {
            unsafe { &*SAI::ptr() }
        }
    }
    #[doc = "Serial audio interface"]
    pub mod sai;
    #[doc = "Advanced encryption standard hardware accelerator"]
    pub struct AES {
        _marker: PhantomData<*const ()>,
    }
    unsafe impl Send for AES {}
    impl AES {
        #[doc = r" Returns a pointer to the register block"]
        pub fn ptr() -> *const aes::RegisterBlock {
            1342570496 as *const _
        }
    }
    impl Deref for AES {
        type Target = aes::RegisterBlock;
        fn deref(&self) -> &aes::RegisterBlock {
            unsafe { &*AES::ptr() }
        }
    }
    #[doc = "Advanced encryption standard hardware accelerator"]
    pub mod aes;
    #[allow(renamed_and_removed_lints)]
    #[allow(private_no_mangle_statics)]
    #[no_mangle]
    static mut DEVICE_PERIPHERALS: bool = false;
    #[doc = r" All the peripherals"]
    #[allow(non_snake_case)]
    pub struct Peripherals {
        #[doc = "ADC1"]
        pub ADC1: ADC1,
        #[doc = "CRC"]
        pub CRC: CRC,
        #[doc = "DBG"]
        pub DBG: DBG,
        #[doc = "EXTI"]
        pub EXTI: EXTI,
        #[doc = "FLASH"]
        pub FLASH: FLASH,
        #[doc = "IWDG"]
        pub IWDG: IWDG,
        #[doc = "PWR"]
        pub PWR: PWR,
        #[doc = "RCC"]
        pub RCC: RCC,
        #[doc = "RTC"]
        pub RTC: RTC,
        #[doc = "SDIO"]
        pub SDIO: SDIO,
        #[doc = "SYSCFG"]
        pub SYSCFG: SYSCFG,
        #[doc = "TIM1"]
        pub TIM1: TIM1,
        #[doc = "TIM8"]
        pub TIM8: TIM8,
        #[doc = "TIM10"]
        pub TIM10: TIM10,
        #[doc = "TIM11"]
        pub TIM11: TIM11,
        #[doc = "TIM2"]
        pub TIM2: TIM2,
        #[doc = "TIM3"]
        pub TIM3: TIM3,
        #[doc = "TIM4"]
        pub TIM4: TIM4,
        #[doc = "TIM5"]
        pub TIM5: TIM5,
        #[doc = "TIM9"]
        pub TIM9: TIM9,
        #[doc = "USART1"]
        pub USART1: USART1,
        #[doc = "USART2"]
        pub USART2: USART2,
        #[doc = "USART6"]
        pub USART6: USART6,
        #[doc = "USART3"]
        pub USART3: USART3,
        #[doc = "UART4"]
        pub UART4: UART4,
        #[doc = "UART5"]
        pub UART5: UART5,
        #[doc = "UART7"]
        pub UART7: UART7,
        #[doc = "UART8"]
        pub UART8: UART8,
        #[doc = "UART9"]
        pub UART9: UART9,
        #[doc = "UART10"]
        pub UART10: UART10,
        #[doc = "WWDG"]
        pub WWDG: WWDG,
        #[doc = "DMA2"]
        pub DMA2: DMA2,
        #[doc = "DMA1"]
        pub DMA1: DMA1,
        #[doc = "GPIOH"]
        pub GPIOH: GPIOH,
        #[doc = "GPIOE"]
        pub GPIOE: GPIOE,
        #[doc = "GPIOD"]
        pub GPIOD: GPIOD,
        #[doc = "GPIOC"]
        pub GPIOC: GPIOC,
        #[doc = "GPIOF"]
        pub GPIOF: GPIOF,
        #[doc = "GPIOG"]
        pub GPIOG: GPIOG,
        #[doc = "GPIOB"]
        pub GPIOB: GPIOB,
        #[doc = "GPIOA"]
        pub GPIOA: GPIOA,
        #[doc = "I2C3"]
        pub I2C3: I2C3,
        #[doc = "I2C2"]
        pub I2C2: I2C2,
        #[doc = "I2C1"]
        pub I2C1: I2C1,
        #[doc = "I2S2EXT"]
        pub I2S2EXT: I2S2EXT,
        #[doc = "I2S3EXT"]
        pub I2S3EXT: I2S3EXT,
        #[doc = "SPI1"]
        pub SPI1: SPI1,
        #[doc = "SPI2"]
        pub SPI2: SPI2,
        #[doc = "SPI3"]
        pub SPI3: SPI3,
        #[doc = "SPI4"]
        pub SPI4: SPI4,
        #[doc = "SPI5"]
        pub SPI5: SPI5,
        #[doc = "SPI6"]
        pub SPI6: SPI6,
        #[doc = "DFSDM1"]
        pub DFSDM1: DFSDM1,
        #[doc = "DFSDM2"]
        pub DFSDM2: DFSDM2,
        #[doc = "TIM6"]
        pub TIM6: TIM6,
        #[doc = "TIM7"]
        pub TIM7: TIM7,
        #[doc = "TIM12"]
        pub TIM12: TIM12,
        #[doc = "TIM13"]
        pub TIM13: TIM13,
        #[doc = "TIM14"]
        pub TIM14: TIM14,
        #[doc = "RNG"]
        pub RNG: RNG,
        #[doc = "CAN1"]
        pub CAN1: CAN1,
        #[doc = "CAN2"]
        pub CAN2: CAN2,
        #[doc = "CAN3"]
        pub CAN3: CAN3,
        #[doc = "FMPI2C"]
        pub FMPI2C: FMPI2C,
        #[doc = "FSMC"]
        pub FSMC: FSMC,
        #[doc = "OTG_FS_GLOBAL"]
        pub OTG_FS_GLOBAL: OTG_FS_GLOBAL,
        #[doc = "OTG_FS_HOST"]
        pub OTG_FS_HOST: OTG_FS_HOST,
        #[doc = "OTG_FS_DEVICE"]
        pub OTG_FS_DEVICE: OTG_FS_DEVICE,
        #[doc = "OTG_FS_PWRCLK"]
        pub OTG_FS_PWRCLK: OTG_FS_PWRCLK,
        #[doc = "QUADSPI"]
        pub QUADSPI: QUADSPI,
        #[doc = "LPTIM"]
        pub LPTIM: LPTIM,
        #[doc = "DAC"]
        pub DAC: DAC,
        #[doc = "SAI"]
        pub SAI: SAI,
        #[doc = "AES"]
        pub AES: AES,
    }
    impl Peripherals {
        #[doc = r" Returns all the peripherals *once*"]
        #[inline]
        pub fn take() -> Option<Self> {
            cortex_m::interrupt::free(|_| {
                if unsafe { DEVICE_PERIPHERALS } {
                    None
                } else {
                    Some(unsafe { Peripherals::steal() })
                }
            })
        }
        #[doc = r" Unchecked version of `Peripherals::take`"]
        pub unsafe fn steal() -> Self {
            debug_assert!(!DEVICE_PERIPHERALS);
            DEVICE_PERIPHERALS = true;
            Peripherals {
                ADC1: ADC1 {
                    _marker: PhantomData,
                },
                CRC: CRC {
                    _marker: PhantomData,
                },
                DBG: DBG {
                    _marker: PhantomData,
                },
                EXTI: EXTI {
                    _marker: PhantomData,
                },
                FLASH: FLASH {
                    _marker: PhantomData,
                },
                IWDG: IWDG {
                    _marker: PhantomData,
                },
                PWR: PWR {
                    _marker: PhantomData,
                },
                RCC: RCC {
                    _marker: PhantomData,
                },
                RTC: RTC {
                    _marker: PhantomData,
                },
                SDIO: SDIO {
                    _marker: PhantomData,
                },
                SYSCFG: SYSCFG {
                    _marker: PhantomData,
                },
                TIM1: TIM1 {
                    _marker: PhantomData,
                },
                TIM8: TIM8 {
                    _marker: PhantomData,
                },
                TIM10: TIM10 {
                    _marker: PhantomData,
                },
                TIM11: TIM11 {
                    _marker: PhantomData,
                },
                TIM2: TIM2 {
                    _marker: PhantomData,
                },
                TIM3: TIM3 {
                    _marker: PhantomData,
                },
                TIM4: TIM4 {
                    _marker: PhantomData,
                },
                TIM5: TIM5 {
                    _marker: PhantomData,
                },
                TIM9: TIM9 {
                    _marker: PhantomData,
                },
                USART1: USART1 {
                    _marker: PhantomData,
                },
                USART2: USART2 {
                    _marker: PhantomData,
                },
                USART6: USART6 {
                    _marker: PhantomData,
                },
                USART3: USART3 {
                    _marker: PhantomData,
                },
                UART4: UART4 {
                    _marker: PhantomData,
                },
                UART5: UART5 {
                    _marker: PhantomData,
                },
                UART7: UART7 {
                    _marker: PhantomData,
                },
                UART8: UART8 {
                    _marker: PhantomData,
                },
                UART9: UART9 {
                    _marker: PhantomData,
                },
                UART10: UART10 {
                    _marker: PhantomData,
                },
                WWDG: WWDG {
                    _marker: PhantomData,
                },
                DMA2: DMA2 {
                    _marker: PhantomData,
                },
                DMA1: DMA1 {
                    _marker: PhantomData,
                },
                GPIOH: GPIOH {
                    _marker: PhantomData,
                },
                GPIOE: GPIOE {
                    _marker: PhantomData,
                },
                GPIOD: GPIOD {
                    _marker: PhantomData,
                },
                GPIOC: GPIOC {
                    _marker: PhantomData,
                },
                GPIOF: GPIOF {
                    _marker: PhantomData,
                },
                GPIOG: GPIOG {
                    _marker: PhantomData,
                },
                GPIOB: GPIOB {
                    _marker: PhantomData,
                },
                GPIOA: GPIOA {
                    _marker: PhantomData,
                },
                I2C3: I2C3 {
                    _marker: PhantomData,
                },
                I2C2: I2C2 {
                    _marker: PhantomData,
                },
                I2C1: I2C1 {
                    _marker: PhantomData,
                },
                I2S2EXT: I2S2EXT {
                    _marker: PhantomData,
                },
                I2S3EXT: I2S3EXT {
                    _marker: PhantomData,
                },
                SPI1: SPI1 {
                    _marker: PhantomData,
                },
                SPI2: SPI2 {
                    _marker: PhantomData,
                },
                SPI3: SPI3 {
                    _marker: PhantomData,
                },
                SPI4: SPI4 {
                    _marker: PhantomData,
                },
                SPI5: SPI5 {
                    _marker: PhantomData,
                },
                SPI6: SPI6 {
                    _marker: PhantomData,
                },
                DFSDM1: DFSDM1 {
                    _marker: PhantomData,
                },
                DFSDM2: DFSDM2 {
                    _marker: PhantomData,
                },
                TIM6: TIM6 {
                    _marker: PhantomData,
                },
                TIM7: TIM7 {
                    _marker: PhantomData,
                },
                TIM12: TIM12 {
                    _marker: PhantomData,
                },
                TIM13: TIM13 {
                    _marker: PhantomData,
                },
                TIM14: TIM14 {
                    _marker: PhantomData,
                },
                RNG: RNG {
                    _marker: PhantomData,
                },
                CAN1: CAN1 {
                    _marker: PhantomData,
                },
                CAN2: CAN2 {
                    _marker: PhantomData,
                },
                CAN3: CAN3 {
                    _marker: PhantomData,
                },
                FMPI2C: FMPI2C {
                    _marker: PhantomData,
                },
                FSMC: FSMC {
                    _marker: PhantomData,
                },
                OTG_FS_GLOBAL: OTG_FS_GLOBAL {
                    _marker: PhantomData,
                },
                OTG_FS_HOST: OTG_FS_HOST {
                    _marker: PhantomData,
                },
                OTG_FS_DEVICE: OTG_FS_DEVICE {
                    _marker: PhantomData,
                },
                OTG_FS_PWRCLK: OTG_FS_PWRCLK {
                    _marker: PhantomData,
                },
                QUADSPI: QUADSPI {
                    _marker: PhantomData,
                },
                LPTIM: LPTIM {
                    _marker: PhantomData,
                },
                DAC: DAC {
                    _marker: PhantomData,
                },
                SAI: SAI {
                    _marker: PhantomData,
                },
                AES: AES {
                    _marker: PhantomData,
                },
            }
        }
    }