//! reeee~ #![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; #[cfg(feature = "rt")] extern "C" { fn WWDG(); fn PVD(); fn RCC_CRS(); fn EXTI0_1(); fn EXTI2_3(); fn EXTI4_15(); fn DMA_CH1(); fn DMA_CH2_3(); fn DMA_CH4_5_6_7(); fn ADC_COMP(); fn TIM1_BRK_UP_TRG_COM(); fn TIM1_CC(); fn TIM2(); fn TIM3(); fn TIM6_DAC(); fn TIM7(); fn TIM14(); fn I2C1(); fn I2C2(); fn SPI1(); fn SPI2(); fn USART1(); fn USART2(); fn USART3_4(); } #[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; 30] = [ Vector { _handler: WWDG }, Vector { _handler: PVD }, Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _handler: RCC_CRS }, Vector { _handler: EXTI0_1 }, Vector { _handler: EXTI2_3 }, Vector { _handler: EXTI4_15 }, Vector { _reserved: 0 }, Vector { _handler: DMA_CH1 }, Vector { _handler: DMA_CH2_3, }, Vector { _handler: DMA_CH4_5_6_7, }, Vector { _handler: ADC_COMP }, Vector { _handler: TIM1_BRK_UP_TRG_COM, }, Vector { _handler: TIM1_CC }, Vector { _handler: TIM2 }, Vector { _handler: TIM3 }, Vector { _handler: TIM6_DAC }, Vector { _handler: TIM7 }, Vector { _handler: TIM14 }, Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _reserved: 0 }, Vector { _handler: I2C1 }, Vector { _handler: I2C2 }, Vector { _handler: SPI1 }, Vector { _handler: SPI2 }, Vector { _handler: USART1 }, Vector { _handler: USART2 }, Vector { _handler: USART3_4 }, ]; #[doc = r" Macro to override a device specific interrupt handler"] #[doc = r""] #[doc = r" # Syntax"] #[doc = r""] #[doc = r" ``` ignore"] #[doc = r" interrupt!("] #[doc = r" // Name of the interrupt"] #[doc = r" $Name:ident,"] #[doc = r""] #[doc = r" // Path to the interrupt handler (a function)"] #[doc = r" $handler:path,"] #[doc = r""] #[doc = r" // Optional, state preserved across invocations of the handler"] #[doc = r" state: $State:ty = $initial_state:expr,"] #[doc = r" );"] #[doc = r" ```"] #[doc = r""] #[doc = r" Where `$Name` must match the name of one of the variants of the `Interrupt`"] #[doc = r" enum."] #[doc = r""] #[doc = r" The handler must have signature `fn()` is no state was associated to it;"] #[doc = r" otherwise its signature must be `fn(&mut $State)`."] #[cfg(feature = "rt")] #[macro_export] macro_rules! interrupt { ( $ Name : ident , $ handler : path , state : $ State : ty = $ initial_state : expr ) => { #[allow(unsafe_code)] #[deny(private_no_mangle_fns)] #[no_mangle] pub unsafe extern "C" fn $Name() { static mut STATE: $State = $initial_state; let _ = $crate::Interrupt::$Name; let f: fn(&mut $State) = $handler; f(&mut STATE) } }; ( $ Name : ident , $ handler : path ) => { #[allow(unsafe_code)] #[deny(private_no_mangle_fns)] #[no_mangle] pub unsafe extern "C" fn $Name() { let _ = $crate::Interrupt::$Name; let f: fn() = $handler; f() } }; } #[doc = r" Enumeration of all the interrupts"] pub enum Interrupt { #[doc = "0 - Window Watchdog interrupt"] WWDG, #[doc = "1 - PVD and VDDIO2 supply comparator interrupt"] PVD, #[doc = "4 - RCC and CRS global interrupts"] RCC_CRS, #[doc = "5 - EXTI Line[1:0] interrupts"] EXTI0_1, #[doc = "6 - EXTI Line[3:2] interrupts"] EXTI2_3, #[doc = "7 - EXTI Line15 and EXTI4 interrupts"] EXTI4_15, #[doc = "9 - DMA channel 1 interrupt"] DMA_CH1, #[doc = "10 - DMA channel 2 and 3 interrupts"] DMA_CH2_3, #[doc = "11 - DMA channel 4, 5, 6 and 7 interrupts"] DMA_CH4_5_6_7, #[doc = "12 - ADC and comparator interrupts"] ADC_COMP, #[doc = "13 - TIM1 break, update, trigger and commutation interrupt"] TIM1_BRK_UP_TRG_COM, #[doc = "14 - TIM1 Capture Compare interrupt"] TIM1_CC, #[doc = "15 - TIM2 global interrupt"] TIM2, #[doc = "16 - TIM3 global interrupt"] TIM3, #[doc = "17 - TIM6 global interrupt and DAC underrun interrupt"] TIM6_DAC, #[doc = "18 - TIM7 global interrupt"] TIM7, #[doc = "19 - TIM14 global interrupt"] TIM14, #[doc = "23 - I2C1 global interrupt"] I2C1, #[doc = "24 - I2C2 global interrupt"] I2C2, #[doc = "25 - SPI1_global_interrupt"] SPI1, #[doc = "26 - SPI2 global interrupt"] SPI2, #[doc = "27 - USART1 global interrupt"] USART1, #[doc = "28 - USART2 global interrupt"] USART2, #[doc = "29 - USART3 and USART4 global interrupt"] USART3_4, } unsafe impl ::bare_metal::Nr for Interrupt { #[inline] fn nr(&self) -> u8 { match *self { Interrupt::WWDG => 0, Interrupt::PVD => 1, Interrupt::RCC_CRS => 4, Interrupt::EXTI0_1 => 5, Interrupt::EXTI2_3 => 6, Interrupt::EXTI4_15 => 7, Interrupt::DMA_CH1 => 9, Interrupt::DMA_CH2_3 => 10, Interrupt::DMA_CH4_5_6_7 => 11, Interrupt::ADC_COMP => 12, Interrupt::TIM1_BRK_UP_TRG_COM => 13, Interrupt::TIM1_CC => 14, Interrupt::TIM2 => 15, Interrupt::TIM3 => 16, Interrupt::TIM6_DAC => 17, Interrupt::TIM7 => 18, Interrupt::TIM14 => 19, Interrupt::I2C1 => 23, Interrupt::I2C2 => 24, Interrupt::SPI1 => 25, Interrupt::SPI2 => 26, Interrupt::USART1 => 27, Interrupt::USART2 => 28, Interrupt::USART3_4 => 29, } } } #[doc(hidden)] pub mod 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}; #[doc = "cyclic redundancy check calculation unit"] 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 { 0x4002_3000 as *const _ } } impl Deref for CRC { type Target = crc::RegisterBlock; fn deref(&self) -> &crc::RegisterBlock { unsafe { &*CRC::ptr() } } } #[doc = "cyclic redundancy check calculation unit"] pub mod crc { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Data register"] pub dr: DR, #[doc = "0x04 - Independent data register"] pub idr: IDR, #[doc = "0x08 - Control register"] pub cr: CR, #[doc = "0x0c - Initial CRC value"] pub init: INIT, } #[doc = "Data register"] pub struct DR { register: ::vcell::VolatileCell, } #[doc = "Data register"] pub mod dr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DRR { bits: u32, } impl DRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _DRW<'a> { w: &'a mut W, } impl<'a> _DRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Data register bits"] #[inline] pub fn dr(&self) -> DRR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; DRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0xffff_ffff } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Data register bits"] #[inline] pub fn dr(&mut self) -> _DRW { _DRW { w: self } } } } #[doc = "Independent data register"] pub struct IDR { register: ::vcell::VolatileCell, } #[doc = "Independent data register"] pub mod idr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::IDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IDRR { bits: u8, } impl IDRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IDRW<'a> { w: &'a mut W, } impl<'a> _IDRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - General-purpose 8-bit data register bits"] #[inline] pub fn idr(&self) -> IDRR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IDRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - General-purpose 8-bit data register bits"] #[inline] pub fn idr(&mut self) -> _IDRW { _IDRW { w: self } } } } #[doc = "Control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "Control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct RESETR { bits: bool, } impl RESETR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct REV_INR { bits: u8, } impl REV_INR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct REV_OUTR { bits: bool, } impl REV_OUTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _RESETW<'a> { w: &'a mut W, } impl<'a> _RESETW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _REV_INW<'a> { w: &'a mut W, } impl<'a> _REV_INW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _REV_OUTW<'a> { w: &'a mut W, } impl<'a> _REV_OUTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - reset bit"] #[inline] pub fn reset(&self) -> RESETR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RESETR { bits } } #[doc = "Bits 5:6 - Reverse input data"] #[inline] pub fn rev_in(&self) -> REV_INR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) as u8 }; REV_INR { bits } } #[doc = "Bit 7 - Reverse output data"] #[inline] pub fn rev_out(&self) -> REV_OUTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; REV_OUTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - reset bit"] #[inline] pub fn reset(&mut self) -> _RESETW { _RESETW { w: self } } #[doc = "Bits 5:6 - Reverse input data"] #[inline] pub fn rev_in(&mut self) -> _REV_INW { _REV_INW { w: self } } #[doc = "Bit 7 - Reverse output data"] #[inline] pub fn rev_out(&mut self) -> _REV_OUTW { _REV_OUTW { w: self } } } } #[doc = "Initial CRC value"] pub struct INIT { register: ::vcell::VolatileCell, } #[doc = "Initial CRC value"] pub mod init { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::INIT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct INITR { bits: u32, } impl INITR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _INITW<'a> { w: &'a mut W, } impl<'a> _INITW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Programmable initial CRC value"] #[inline] pub fn init(&self) -> INITR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; INITR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0xffff_ffff } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Programmable initial CRC value"] #[inline] pub fn init(&mut self) -> _INITW { _INITW { w: self } } } } } #[doc = "General-purpose I/Os"] 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 gpiof::RegisterBlock { 0x4800_1400 as *const _ } } impl Deref for GPIOF { type Target = gpiof::RegisterBlock; fn deref(&self) -> &gpiof::RegisterBlock { unsafe { &*GPIOF::ptr() } } } #[doc = "General-purpose I/Os"] pub mod gpiof { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - GPIO port mode register"] pub moder: MODER, #[doc = "0x04 - GPIO port output type register"] pub otyper: OTYPER, #[doc = "0x08 - GPIO port output speed register"] pub ospeedr: OSPEEDR, #[doc = "0x0c - GPIO port pull-up/pull-down register"] pub pupdr: PUPDR, #[doc = "0x10 - GPIO port input data register"] pub idr: IDR, #[doc = "0x14 - GPIO port output data register"] pub odr: ODR, #[doc = "0x18 - GPIO port bit set/reset register"] pub bsrr: BSRR, #[doc = "0x1c - GPIO port configuration lock register"] pub lckr: LCKR, #[doc = "0x20 - GPIO alternate function low register"] pub afrl: AFRL, #[doc = "0x24 - GPIO alternate function high register"] pub afrh: AFRH, #[doc = "0x28 - Port bit reset register"] pub brr: BRR, } #[doc = "GPIO port mode register"] pub struct MODER { register: ::vcell::VolatileCell, } #[doc = "GPIO port mode register"] pub mod moder { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::MODER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MODER15R { bits: u8, } impl MODER15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER14R { bits: u8, } impl MODER14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER13R { bits: u8, } impl MODER13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER12R { bits: u8, } impl MODER12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER11R { bits: u8, } impl MODER11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER10R { bits: u8, } impl MODER10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER9R { bits: u8, } impl MODER9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER8R { bits: u8, } impl MODER8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER7R { bits: u8, } impl MODER7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER6R { bits: u8, } impl MODER6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER5R { bits: u8, } impl MODER5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER4R { bits: u8, } impl MODER4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER3R { bits: u8, } impl MODER3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER2R { bits: u8, } impl MODER2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER1R { bits: u8, } impl MODER1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER0R { bits: u8, } impl MODER0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MODER15W<'a> { w: &'a mut W, } impl<'a> _MODER15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER14W<'a> { w: &'a mut W, } impl<'a> _MODER14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER13W<'a> { w: &'a mut W, } impl<'a> _MODER13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER12W<'a> { w: &'a mut W, } impl<'a> _MODER12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER11W<'a> { w: &'a mut W, } impl<'a> _MODER11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER10W<'a> { w: &'a mut W, } impl<'a> _MODER10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER9W<'a> { w: &'a mut W, } impl<'a> _MODER9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER8W<'a> { w: &'a mut W, } impl<'a> _MODER8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER7W<'a> { w: &'a mut W, } impl<'a> _MODER7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER6W<'a> { w: &'a mut W, } impl<'a> _MODER6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER5W<'a> { w: &'a mut W, } impl<'a> _MODER5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER4W<'a> { w: &'a mut W, } impl<'a> _MODER4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER3W<'a> { w: &'a mut W, } impl<'a> _MODER3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER2W<'a> { w: &'a mut W, } impl<'a> _MODER2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER1W<'a> { w: &'a mut W, } impl<'a> _MODER1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER0W<'a> { w: &'a mut W, } impl<'a> _MODER0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder15(&self) -> MODER15R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER15R { bits } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder14(&self) -> MODER14R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER14R { bits } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder13(&self) -> MODER13R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER13R { bits } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder12(&self) -> MODER12R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER12R { bits } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder11(&self) -> MODER11R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER11R { bits } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder10(&self) -> MODER10R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER10R { bits } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder9(&self) -> MODER9R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER9R { bits } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder8(&self) -> MODER8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER8R { bits } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder7(&self) -> MODER7R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER7R { bits } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder6(&self) -> MODER6R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER6R { bits } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder5(&self) -> MODER5R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER5R { bits } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder4(&self) -> MODER4R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER4R { bits } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder3(&self) -> MODER3R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER3R { bits } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder2(&self) -> MODER2R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER2R { bits } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder1(&self) -> MODER1R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER1R { bits } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder0(&self) -> MODER0R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder15(&mut self) -> _MODER15W { _MODER15W { w: self } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder14(&mut self) -> _MODER14W { _MODER14W { w: self } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder13(&mut self) -> _MODER13W { _MODER13W { w: self } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder12(&mut self) -> _MODER12W { _MODER12W { w: self } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder11(&mut self) -> _MODER11W { _MODER11W { w: self } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder10(&mut self) -> _MODER10W { _MODER10W { w: self } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder9(&mut self) -> _MODER9W { _MODER9W { w: self } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder8(&mut self) -> _MODER8W { _MODER8W { w: self } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder7(&mut self) -> _MODER7W { _MODER7W { w: self } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder6(&mut self) -> _MODER6W { _MODER6W { w: self } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder5(&mut self) -> _MODER5W { _MODER5W { w: self } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder4(&mut self) -> _MODER4W { _MODER4W { w: self } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder3(&mut self) -> _MODER3W { _MODER3W { w: self } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder2(&mut self) -> _MODER2W { _MODER2W { w: self } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder1(&mut self) -> _MODER1W { _MODER1W { w: self } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder0(&mut self) -> _MODER0W { _MODER0W { w: self } } } } #[doc = "GPIO port output type register"] pub struct OTYPER { register: ::vcell::VolatileCell, } #[doc = "GPIO port output type register"] pub mod otyper { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OTYPER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OT15R { bits: bool, } impl OT15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT14R { bits: bool, } impl OT14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT13R { bits: bool, } impl OT13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT12R { bits: bool, } impl OT12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT11R { bits: bool, } impl OT11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT10R { bits: bool, } impl OT10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT9R { bits: bool, } impl OT9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT8R { bits: bool, } impl OT8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT7R { bits: bool, } impl OT7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT6R { bits: bool, } impl OT6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT5R { bits: bool, } impl OT5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT4R { bits: bool, } impl OT4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT3R { bits: bool, } impl OT3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT2R { bits: bool, } impl OT2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT1R { bits: bool, } impl OT1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT0R { bits: bool, } impl OT0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OT15W<'a> { w: &'a mut W, } impl<'a> _OT15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT14W<'a> { w: &'a mut W, } impl<'a> _OT14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT13W<'a> { w: &'a mut W, } impl<'a> _OT13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT12W<'a> { w: &'a mut W, } impl<'a> _OT12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT11W<'a> { w: &'a mut W, } impl<'a> _OT11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT10W<'a> { w: &'a mut W, } impl<'a> _OT10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT9W<'a> { w: &'a mut W, } impl<'a> _OT9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT8W<'a> { w: &'a mut W, } impl<'a> _OT8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT7W<'a> { w: &'a mut W, } impl<'a> _OT7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT6W<'a> { w: &'a mut W, } impl<'a> _OT6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT5W<'a> { w: &'a mut W, } impl<'a> _OT5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT4W<'a> { w: &'a mut W, } impl<'a> _OT4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT3W<'a> { w: &'a mut W, } impl<'a> _OT3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT2W<'a> { w: &'a mut W, } impl<'a> _OT2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT1W<'a> { w: &'a mut W, } impl<'a> _OT1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT0W<'a> { w: &'a mut W, } impl<'a> _OT0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Port x configuration bit 15"] #[inline] pub fn ot15(&self) -> OT15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT15R { bits } } #[doc = "Bit 14 - Port x configuration bit 14"] #[inline] pub fn ot14(&self) -> OT14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT14R { bits } } #[doc = "Bit 13 - Port x configuration bit 13"] #[inline] pub fn ot13(&self) -> OT13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT13R { bits } } #[doc = "Bit 12 - Port x configuration bit 12"] #[inline] pub fn ot12(&self) -> OT12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT12R { bits } } #[doc = "Bit 11 - Port x configuration bit 11"] #[inline] pub fn ot11(&self) -> OT11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT11R { bits } } #[doc = "Bit 10 - Port x configuration bit 10"] #[inline] pub fn ot10(&self) -> OT10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT10R { bits } } #[doc = "Bit 9 - Port x configuration bit 9"] #[inline] pub fn ot9(&self) -> OT9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT9R { bits } } #[doc = "Bit 8 - Port x configuration bit 8"] #[inline] pub fn ot8(&self) -> OT8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT8R { bits } } #[doc = "Bit 7 - Port x configuration bit 7"] #[inline] pub fn ot7(&self) -> OT7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT7R { bits } } #[doc = "Bit 6 - Port x configuration bit 6"] #[inline] pub fn ot6(&self) -> OT6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT6R { bits } } #[doc = "Bit 5 - Port x configuration bit 5"] #[inline] pub fn ot5(&self) -> OT5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT5R { bits } } #[doc = "Bit 4 - Port x configuration bit 4"] #[inline] pub fn ot4(&self) -> OT4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT4R { bits } } #[doc = "Bit 3 - Port x configuration bit 3"] #[inline] pub fn ot3(&self) -> OT3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT3R { bits } } #[doc = "Bit 2 - Port x configuration bit 2"] #[inline] pub fn ot2(&self) -> OT2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT2R { bits } } #[doc = "Bit 1 - Port x configuration bit 1"] #[inline] pub fn ot1(&self) -> OT1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT1R { bits } } #[doc = "Bit 0 - Port x configuration bit 0"] #[inline] pub fn ot0(&self) -> OT0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Port x configuration bit 15"] #[inline] pub fn ot15(&mut self) -> _OT15W { _OT15W { w: self } } #[doc = "Bit 14 - Port x configuration bit 14"] #[inline] pub fn ot14(&mut self) -> _OT14W { _OT14W { w: self } } #[doc = "Bit 13 - Port x configuration bit 13"] #[inline] pub fn ot13(&mut self) -> _OT13W { _OT13W { w: self } } #[doc = "Bit 12 - Port x configuration bit 12"] #[inline] pub fn ot12(&mut self) -> _OT12W { _OT12W { w: self } } #[doc = "Bit 11 - Port x configuration bit 11"] #[inline] pub fn ot11(&mut self) -> _OT11W { _OT11W { w: self } } #[doc = "Bit 10 - Port x configuration bit 10"] #[inline] pub fn ot10(&mut self) -> _OT10W { _OT10W { w: self } } #[doc = "Bit 9 - Port x configuration bit 9"] #[inline] pub fn ot9(&mut self) -> _OT9W { _OT9W { w: self } } #[doc = "Bit 8 - Port x configuration bit 8"] #[inline] pub fn ot8(&mut self) -> _OT8W { _OT8W { w: self } } #[doc = "Bit 7 - Port x configuration bit 7"] #[inline] pub fn ot7(&mut self) -> _OT7W { _OT7W { w: self } } #[doc = "Bit 6 - Port x configuration bit 6"] #[inline] pub fn ot6(&mut self) -> _OT6W { _OT6W { w: self } } #[doc = "Bit 5 - Port x configuration bit 5"] #[inline] pub fn ot5(&mut self) -> _OT5W { _OT5W { w: self } } #[doc = "Bit 4 - Port x configuration bit 4"] #[inline] pub fn ot4(&mut self) -> _OT4W { _OT4W { w: self } } #[doc = "Bit 3 - Port x configuration bit 3"] #[inline] pub fn ot3(&mut self) -> _OT3W { _OT3W { w: self } } #[doc = "Bit 2 - Port x configuration bit 2"] #[inline] pub fn ot2(&mut self) -> _OT2W { _OT2W { w: self } } #[doc = "Bit 1 - Port x configuration bit 1"] #[inline] pub fn ot1(&mut self) -> _OT1W { _OT1W { w: self } } #[doc = "Bit 0 - Port x configuration bit 0"] #[inline] pub fn ot0(&mut self) -> _OT0W { _OT0W { w: self } } } } #[doc = "GPIO port output speed register"] pub struct OSPEEDR { register: ::vcell::VolatileCell, } #[doc = "GPIO port output speed register"] pub mod ospeedr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OSPEEDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OSPEEDR15R { bits: u8, } impl OSPEEDR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR14R { bits: u8, } impl OSPEEDR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR13R { bits: u8, } impl OSPEEDR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR12R { bits: u8, } impl OSPEEDR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR11R { bits: u8, } impl OSPEEDR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR10R { bits: u8, } impl OSPEEDR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR9R { bits: u8, } impl OSPEEDR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR8R { bits: u8, } impl OSPEEDR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR7R { bits: u8, } impl OSPEEDR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR6R { bits: u8, } impl OSPEEDR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR5R { bits: u8, } impl OSPEEDR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR4R { bits: u8, } impl OSPEEDR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR3R { bits: u8, } impl OSPEEDR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR2R { bits: u8, } impl OSPEEDR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR1R { bits: u8, } impl OSPEEDR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR0R { bits: u8, } impl OSPEEDR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OSPEEDR15W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR14W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR13W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR12W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR11W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR10W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR9W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR8W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR7W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR6W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR5W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR4W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR3W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR2W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR1W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR0W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr15(&self) -> OSPEEDR15R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR15R { bits } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr14(&self) -> OSPEEDR14R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR14R { bits } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr13(&self) -> OSPEEDR13R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR13R { bits } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr12(&self) -> OSPEEDR12R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR12R { bits } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr11(&self) -> OSPEEDR11R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR11R { bits } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr10(&self) -> OSPEEDR10R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR10R { bits } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr9(&self) -> OSPEEDR9R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR9R { bits } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr8(&self) -> OSPEEDR8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR8R { bits } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr7(&self) -> OSPEEDR7R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR7R { bits } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr6(&self) -> OSPEEDR6R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR6R { bits } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr5(&self) -> OSPEEDR5R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR5R { bits } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr4(&self) -> OSPEEDR4R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR4R { bits } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr3(&self) -> OSPEEDR3R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR3R { bits } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr2(&self) -> OSPEEDR2R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR2R { bits } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr1(&self) -> OSPEEDR1R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR1R { bits } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr0(&self) -> OSPEEDR0R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr15(&mut self) -> _OSPEEDR15W { _OSPEEDR15W { w: self } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr14(&mut self) -> _OSPEEDR14W { _OSPEEDR14W { w: self } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr13(&mut self) -> _OSPEEDR13W { _OSPEEDR13W { w: self } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr12(&mut self) -> _OSPEEDR12W { _OSPEEDR12W { w: self } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr11(&mut self) -> _OSPEEDR11W { _OSPEEDR11W { w: self } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr10(&mut self) -> _OSPEEDR10W { _OSPEEDR10W { w: self } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr9(&mut self) -> _OSPEEDR9W { _OSPEEDR9W { w: self } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr8(&mut self) -> _OSPEEDR8W { _OSPEEDR8W { w: self } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr7(&mut self) -> _OSPEEDR7W { _OSPEEDR7W { w: self } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr6(&mut self) -> _OSPEEDR6W { _OSPEEDR6W { w: self } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr5(&mut self) -> _OSPEEDR5W { _OSPEEDR5W { w: self } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr4(&mut self) -> _OSPEEDR4W { _OSPEEDR4W { w: self } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr3(&mut self) -> _OSPEEDR3W { _OSPEEDR3W { w: self } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr2(&mut self) -> _OSPEEDR2W { _OSPEEDR2W { w: self } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr1(&mut self) -> _OSPEEDR1W { _OSPEEDR1W { w: self } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr0(&mut self) -> _OSPEEDR0W { _OSPEEDR0W { w: self } } } } #[doc = "GPIO port pull-up/pull-down register"] pub struct PUPDR { register: ::vcell::VolatileCell, } #[doc = "GPIO port pull-up/pull-down register"] pub mod pupdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PUPDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PUPDR15R { bits: u8, } impl PUPDR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR14R { bits: u8, } impl PUPDR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR13R { bits: u8, } impl PUPDR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR12R { bits: u8, } impl PUPDR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR11R { bits: u8, } impl PUPDR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR10R { bits: u8, } impl PUPDR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR9R { bits: u8, } impl PUPDR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR8R { bits: u8, } impl PUPDR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR7R { bits: u8, } impl PUPDR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR6R { bits: u8, } impl PUPDR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR5R { bits: u8, } impl PUPDR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR4R { bits: u8, } impl PUPDR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR3R { bits: u8, } impl PUPDR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR2R { bits: u8, } impl PUPDR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR1R { bits: u8, } impl PUPDR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR0R { bits: u8, } impl PUPDR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _PUPDR15W<'a> { w: &'a mut W, } impl<'a> _PUPDR15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR14W<'a> { w: &'a mut W, } impl<'a> _PUPDR14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR13W<'a> { w: &'a mut W, } impl<'a> _PUPDR13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR12W<'a> { w: &'a mut W, } impl<'a> _PUPDR12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR11W<'a> { w: &'a mut W, } impl<'a> _PUPDR11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR10W<'a> { w: &'a mut W, } impl<'a> _PUPDR10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR9W<'a> { w: &'a mut W, } impl<'a> _PUPDR9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR8W<'a> { w: &'a mut W, } impl<'a> _PUPDR8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR7W<'a> { w: &'a mut W, } impl<'a> _PUPDR7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR6W<'a> { w: &'a mut W, } impl<'a> _PUPDR6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR5W<'a> { w: &'a mut W, } impl<'a> _PUPDR5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR4W<'a> { w: &'a mut W, } impl<'a> _PUPDR4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR3W<'a> { w: &'a mut W, } impl<'a> _PUPDR3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR2W<'a> { w: &'a mut W, } impl<'a> _PUPDR2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR1W<'a> { w: &'a mut W, } impl<'a> _PUPDR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR0W<'a> { w: &'a mut W, } impl<'a> _PUPDR0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr15(&self) -> PUPDR15R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR15R { bits } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr14(&self) -> PUPDR14R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR14R { bits } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr13(&self) -> PUPDR13R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR13R { bits } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr12(&self) -> PUPDR12R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR12R { bits } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr11(&self) -> PUPDR11R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR11R { bits } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr10(&self) -> PUPDR10R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR10R { bits } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr9(&self) -> PUPDR9R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR9R { bits } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr8(&self) -> PUPDR8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR8R { bits } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr7(&self) -> PUPDR7R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR7R { bits } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr6(&self) -> PUPDR6R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR6R { bits } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr5(&self) -> PUPDR5R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR5R { bits } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr4(&self) -> PUPDR4R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR4R { bits } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr3(&self) -> PUPDR3R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR3R { bits } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr2(&self) -> PUPDR2R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR2R { bits } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr1(&self) -> PUPDR1R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR1R { bits } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr0(&self) -> PUPDR0R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr15(&mut self) -> _PUPDR15W { _PUPDR15W { w: self } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr14(&mut self) -> _PUPDR14W { _PUPDR14W { w: self } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr13(&mut self) -> _PUPDR13W { _PUPDR13W { w: self } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr12(&mut self) -> _PUPDR12W { _PUPDR12W { w: self } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr11(&mut self) -> _PUPDR11W { _PUPDR11W { w: self } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr10(&mut self) -> _PUPDR10W { _PUPDR10W { w: self } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr9(&mut self) -> _PUPDR9W { _PUPDR9W { w: self } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr8(&mut self) -> _PUPDR8W { _PUPDR8W { w: self } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr7(&mut self) -> _PUPDR7W { _PUPDR7W { w: self } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr6(&mut self) -> _PUPDR6W { _PUPDR6W { w: self } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr5(&mut self) -> _PUPDR5W { _PUPDR5W { w: self } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr4(&mut self) -> _PUPDR4W { _PUPDR4W { w: self } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr3(&mut self) -> _PUPDR3W { _PUPDR3W { w: self } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr2(&mut self) -> _PUPDR2W { _PUPDR2W { w: self } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr1(&mut self) -> _PUPDR1W { _PUPDR1W { w: self } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr0(&mut self) -> _PUPDR0W { _PUPDR0W { w: self } } } } #[doc = "GPIO port input data register"] pub struct IDR { register: ::vcell::VolatileCell, } #[doc = "GPIO port input data register"] pub mod idr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::IDR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct IDR15R { bits: bool, } impl IDR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR14R { bits: bool, } impl IDR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR13R { bits: bool, } impl IDR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR12R { bits: bool, } impl IDR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR11R { bits: bool, } impl IDR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR10R { bits: bool, } impl IDR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR9R { bits: bool, } impl IDR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR8R { bits: bool, } impl IDR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR7R { bits: bool, } impl IDR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR6R { bits: bool, } impl IDR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR5R { bits: bool, } impl IDR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR4R { bits: bool, } impl IDR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR3R { bits: bool, } impl IDR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR2R { bits: bool, } impl IDR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR1R { bits: bool, } impl IDR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR0R { bits: bool, } impl IDR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Port input data (y = 0..15)"] #[inline] pub fn idr15(&self) -> IDR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR15R { bits } } #[doc = "Bit 14 - Port input data (y = 0..15)"] #[inline] pub fn idr14(&self) -> IDR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR14R { bits } } #[doc = "Bit 13 - Port input data (y = 0..15)"] #[inline] pub fn idr13(&self) -> IDR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR13R { bits } } #[doc = "Bit 12 - Port input data (y = 0..15)"] #[inline] pub fn idr12(&self) -> IDR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR12R { bits } } #[doc = "Bit 11 - Port input data (y = 0..15)"] #[inline] pub fn idr11(&self) -> IDR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR11R { bits } } #[doc = "Bit 10 - Port input data (y = 0..15)"] #[inline] pub fn idr10(&self) -> IDR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR10R { bits } } #[doc = "Bit 9 - Port input data (y = 0..15)"] #[inline] pub fn idr9(&self) -> IDR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR9R { bits } } #[doc = "Bit 8 - Port input data (y = 0..15)"] #[inline] pub fn idr8(&self) -> IDR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR8R { bits } } #[doc = "Bit 7 - Port input data (y = 0..15)"] #[inline] pub fn idr7(&self) -> IDR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR7R { bits } } #[doc = "Bit 6 - Port input data (y = 0..15)"] #[inline] pub fn idr6(&self) -> IDR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR6R { bits } } #[doc = "Bit 5 - Port input data (y = 0..15)"] #[inline] pub fn idr5(&self) -> IDR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR5R { bits } } #[doc = "Bit 4 - Port input data (y = 0..15)"] #[inline] pub fn idr4(&self) -> IDR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR4R { bits } } #[doc = "Bit 3 - Port input data (y = 0..15)"] #[inline] pub fn idr3(&self) -> IDR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR3R { bits } } #[doc = "Bit 2 - Port input data (y = 0..15)"] #[inline] pub fn idr2(&self) -> IDR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR2R { bits } } #[doc = "Bit 1 - Port input data (y = 0..15)"] #[inline] pub fn idr1(&self) -> IDR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR1R { bits } } #[doc = "Bit 0 - Port input data (y = 0..15)"] #[inline] pub fn idr0(&self) -> IDR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR0R { bits } } } } #[doc = "GPIO port output data register"] pub struct ODR { register: ::vcell::VolatileCell, } #[doc = "GPIO port output data register"] pub mod odr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ODR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ODR15R { bits: bool, } impl ODR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR14R { bits: bool, } impl ODR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR13R { bits: bool, } impl ODR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR12R { bits: bool, } impl ODR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR11R { bits: bool, } impl ODR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR10R { bits: bool, } impl ODR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR9R { bits: bool, } impl ODR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR8R { bits: bool, } impl ODR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR7R { bits: bool, } impl ODR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR6R { bits: bool, } impl ODR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR5R { bits: bool, } impl ODR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR4R { bits: bool, } impl ODR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR3R { bits: bool, } impl ODR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR2R { bits: bool, } impl ODR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR1R { bits: bool, } impl ODR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR0R { bits: bool, } impl ODR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ODR15W<'a> { w: &'a mut W, } impl<'a> _ODR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR14W<'a> { w: &'a mut W, } impl<'a> _ODR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR13W<'a> { w: &'a mut W, } impl<'a> _ODR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR12W<'a> { w: &'a mut W, } impl<'a> _ODR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR11W<'a> { w: &'a mut W, } impl<'a> _ODR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR10W<'a> { w: &'a mut W, } impl<'a> _ODR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR9W<'a> { w: &'a mut W, } impl<'a> _ODR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR8W<'a> { w: &'a mut W, } impl<'a> _ODR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR7W<'a> { w: &'a mut W, } impl<'a> _ODR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR6W<'a> { w: &'a mut W, } impl<'a> _ODR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR5W<'a> { w: &'a mut W, } impl<'a> _ODR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR4W<'a> { w: &'a mut W, } impl<'a> _ODR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR3W<'a> { w: &'a mut W, } impl<'a> _ODR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR2W<'a> { w: &'a mut W, } impl<'a> _ODR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR1W<'a> { w: &'a mut W, } impl<'a> _ODR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR0W<'a> { w: &'a mut W, } impl<'a> _ODR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Port output data (y = 0..15)"] #[inline] pub fn odr15(&self) -> ODR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR15R { bits } } #[doc = "Bit 14 - Port output data (y = 0..15)"] #[inline] pub fn odr14(&self) -> ODR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR14R { bits } } #[doc = "Bit 13 - Port output data (y = 0..15)"] #[inline] pub fn odr13(&self) -> ODR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR13R { bits } } #[doc = "Bit 12 - Port output data (y = 0..15)"] #[inline] pub fn odr12(&self) -> ODR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR12R { bits } } #[doc = "Bit 11 - Port output data (y = 0..15)"] #[inline] pub fn odr11(&self) -> ODR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR11R { bits } } #[doc = "Bit 10 - Port output data (y = 0..15)"] #[inline] pub fn odr10(&self) -> ODR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR10R { bits } } #[doc = "Bit 9 - Port output data (y = 0..15)"] #[inline] pub fn odr9(&self) -> ODR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR9R { bits } } #[doc = "Bit 8 - Port output data (y = 0..15)"] #[inline] pub fn odr8(&self) -> ODR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR8R { bits } } #[doc = "Bit 7 - Port output data (y = 0..15)"] #[inline] pub fn odr7(&self) -> ODR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR7R { bits } } #[doc = "Bit 6 - Port output data (y = 0..15)"] #[inline] pub fn odr6(&self) -> ODR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR6R { bits } } #[doc = "Bit 5 - Port output data (y = 0..15)"] #[inline] pub fn odr5(&self) -> ODR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR5R { bits } } #[doc = "Bit 4 - Port output data (y = 0..15)"] #[inline] pub fn odr4(&self) -> ODR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR4R { bits } } #[doc = "Bit 3 - Port output data (y = 0..15)"] #[inline] pub fn odr3(&self) -> ODR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR3R { bits } } #[doc = "Bit 2 - Port output data (y = 0..15)"] #[inline] pub fn odr2(&self) -> ODR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR2R { bits } } #[doc = "Bit 1 - Port output data (y = 0..15)"] #[inline] pub fn odr1(&self) -> ODR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR1R { bits } } #[doc = "Bit 0 - Port output data (y = 0..15)"] #[inline] pub fn odr0(&self) -> ODR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Port output data (y = 0..15)"] #[inline] pub fn odr15(&mut self) -> _ODR15W { _ODR15W { w: self } } #[doc = "Bit 14 - Port output data (y = 0..15)"] #[inline] pub fn odr14(&mut self) -> _ODR14W { _ODR14W { w: self } } #[doc = "Bit 13 - Port output data (y = 0..15)"] #[inline] pub fn odr13(&mut self) -> _ODR13W { _ODR13W { w: self } } #[doc = "Bit 12 - Port output data (y = 0..15)"] #[inline] pub fn odr12(&mut self) -> _ODR12W { _ODR12W { w: self } } #[doc = "Bit 11 - Port output data (y = 0..15)"] #[inline] pub fn odr11(&mut self) -> _ODR11W { _ODR11W { w: self } } #[doc = "Bit 10 - Port output data (y = 0..15)"] #[inline] pub fn odr10(&mut self) -> _ODR10W { _ODR10W { w: self } } #[doc = "Bit 9 - Port output data (y = 0..15)"] #[inline] pub fn odr9(&mut self) -> _ODR9W { _ODR9W { w: self } } #[doc = "Bit 8 - Port output data (y = 0..15)"] #[inline] pub fn odr8(&mut self) -> _ODR8W { _ODR8W { w: self } } #[doc = "Bit 7 - Port output data (y = 0..15)"] #[inline] pub fn odr7(&mut self) -> _ODR7W { _ODR7W { w: self } } #[doc = "Bit 6 - Port output data (y = 0..15)"] #[inline] pub fn odr6(&mut self) -> _ODR6W { _ODR6W { w: self } } #[doc = "Bit 5 - Port output data (y = 0..15)"] #[inline] pub fn odr5(&mut self) -> _ODR5W { _ODR5W { w: self } } #[doc = "Bit 4 - Port output data (y = 0..15)"] #[inline] pub fn odr4(&mut self) -> _ODR4W { _ODR4W { w: self } } #[doc = "Bit 3 - Port output data (y = 0..15)"] #[inline] pub fn odr3(&mut self) -> _ODR3W { _ODR3W { w: self } } #[doc = "Bit 2 - Port output data (y = 0..15)"] #[inline] pub fn odr2(&mut self) -> _ODR2W { _ODR2W { w: self } } #[doc = "Bit 1 - Port output data (y = 0..15)"] #[inline] pub fn odr1(&mut self) -> _ODR1W { _ODR1W { w: self } } #[doc = "Bit 0 - Port output data (y = 0..15)"] #[inline] pub fn odr0(&mut self) -> _ODR0W { _ODR0W { w: self } } } } #[doc = "GPIO port bit set/reset register"] pub struct BSRR { register: ::vcell::VolatileCell, } #[doc = "GPIO port bit set/reset register"] pub mod bsrr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BSRR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BR15W<'a> { w: &'a mut W, } impl<'a> _BR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR14W<'a> { w: &'a mut W, } impl<'a> _BR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR13W<'a> { w: &'a mut W, } impl<'a> _BR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 29; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR12W<'a> { w: &'a mut W, } impl<'a> _BR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR11W<'a> { w: &'a mut W, } impl<'a> _BR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR10W<'a> { w: &'a mut W, } impl<'a> _BR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR9W<'a> { w: &'a mut W, } impl<'a> _BR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR8W<'a> { w: &'a mut W, } impl<'a> _BR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR7W<'a> { w: &'a mut W, } impl<'a> _BR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR6W<'a> { w: &'a mut W, } impl<'a> _BR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR5W<'a> { w: &'a mut W, } impl<'a> _BR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR4W<'a> { w: &'a mut W, } impl<'a> _BR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR3W<'a> { w: &'a mut W, } impl<'a> _BR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR2W<'a> { w: &'a mut W, } impl<'a> _BR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR1W<'a> { w: &'a mut W, } impl<'a> _BR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR0W<'a> { w: &'a mut W, } impl<'a> _BR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS15W<'a> { w: &'a mut W, } impl<'a> _BS15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS14W<'a> { w: &'a mut W, } impl<'a> _BS14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS13W<'a> { w: &'a mut W, } impl<'a> _BS13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS12W<'a> { w: &'a mut W, } impl<'a> _BS12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS11W<'a> { w: &'a mut W, } impl<'a> _BS11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS10W<'a> { w: &'a mut W, } impl<'a> _BS10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS9W<'a> { w: &'a mut W, } impl<'a> _BS9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS8W<'a> { w: &'a mut W, } impl<'a> _BS8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS7W<'a> { w: &'a mut W, } impl<'a> _BS7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS6W<'a> { w: &'a mut W, } impl<'a> _BS6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS5W<'a> { w: &'a mut W, } impl<'a> _BS5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS4W<'a> { w: &'a mut W, } impl<'a> _BS4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS3W<'a> { w: &'a mut W, } impl<'a> _BS3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS2W<'a> { w: &'a mut W, } impl<'a> _BS2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS1W<'a> { w: &'a mut W, } impl<'a> _BS1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS0W<'a> { w: &'a mut W, } impl<'a> _BS0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br15(&mut self) -> _BR15W { _BR15W { w: self } } #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br14(&mut self) -> _BR14W { _BR14W { w: self } } #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br13(&mut self) -> _BR13W { _BR13W { w: self } } #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br12(&mut self) -> _BR12W { _BR12W { w: self } } #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br11(&mut self) -> _BR11W { _BR11W { w: self } } #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br10(&mut self) -> _BR10W { _BR10W { w: self } } #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br9(&mut self) -> _BR9W { _BR9W { w: self } } #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br8(&mut self) -> _BR8W { _BR8W { w: self } } #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br7(&mut self) -> _BR7W { _BR7W { w: self } } #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br6(&mut self) -> _BR6W { _BR6W { w: self } } #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br5(&mut self) -> _BR5W { _BR5W { w: self } } #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br4(&mut self) -> _BR4W { _BR4W { w: self } } #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br3(&mut self) -> _BR3W { _BR3W { w: self } } #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br2(&mut self) -> _BR2W { _BR2W { w: self } } #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br1(&mut self) -> _BR1W { _BR1W { w: self } } #[doc = "Bit 16 - Port x set bit y (y= 0..15)"] #[inline] pub fn br0(&mut self) -> _BR0W { _BR0W { w: self } } #[doc = "Bit 15 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs15(&mut self) -> _BS15W { _BS15W { w: self } } #[doc = "Bit 14 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs14(&mut self) -> _BS14W { _BS14W { w: self } } #[doc = "Bit 13 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs13(&mut self) -> _BS13W { _BS13W { w: self } } #[doc = "Bit 12 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs12(&mut self) -> _BS12W { _BS12W { w: self } } #[doc = "Bit 11 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs11(&mut self) -> _BS11W { _BS11W { w: self } } #[doc = "Bit 10 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs10(&mut self) -> _BS10W { _BS10W { w: self } } #[doc = "Bit 9 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs9(&mut self) -> _BS9W { _BS9W { w: self } } #[doc = "Bit 8 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs8(&mut self) -> _BS8W { _BS8W { w: self } } #[doc = "Bit 7 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs7(&mut self) -> _BS7W { _BS7W { w: self } } #[doc = "Bit 6 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs6(&mut self) -> _BS6W { _BS6W { w: self } } #[doc = "Bit 5 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs5(&mut self) -> _BS5W { _BS5W { w: self } } #[doc = "Bit 4 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs4(&mut self) -> _BS4W { _BS4W { w: self } } #[doc = "Bit 3 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs3(&mut self) -> _BS3W { _BS3W { w: self } } #[doc = "Bit 2 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs2(&mut self) -> _BS2W { _BS2W { w: self } } #[doc = "Bit 1 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs1(&mut self) -> _BS1W { _BS1W { w: self } } #[doc = "Bit 0 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs0(&mut self) -> _BS0W { _BS0W { w: self } } } } #[doc = "GPIO port configuration lock register"] pub struct LCKR { register: ::vcell::VolatileCell, } #[doc = "GPIO port configuration lock register"] pub mod lckr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::LCKR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct LCKKR { bits: bool, } impl LCKKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK15R { bits: bool, } impl LCK15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK14R { bits: bool, } impl LCK14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK13R { bits: bool, } impl LCK13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK12R { bits: bool, } impl LCK12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK11R { bits: bool, } impl LCK11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK10R { bits: bool, } impl LCK10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK9R { bits: bool, } impl LCK9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK8R { bits: bool, } impl LCK8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK7R { bits: bool, } impl LCK7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK6R { bits: bool, } impl LCK6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK5R { bits: bool, } impl LCK5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK4R { bits: bool, } impl LCK4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK3R { bits: bool, } impl LCK3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK2R { bits: bool, } impl LCK2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK1R { bits: bool, } impl LCK1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK0R { bits: bool, } impl LCK0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _LCKKW<'a> { w: &'a mut W, } impl<'a> _LCKKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK15W<'a> { w: &'a mut W, } impl<'a> _LCK15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK14W<'a> { w: &'a mut W, } impl<'a> _LCK14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK13W<'a> { w: &'a mut W, } impl<'a> _LCK13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK12W<'a> { w: &'a mut W, } impl<'a> _LCK12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK11W<'a> { w: &'a mut W, } impl<'a> _LCK11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK10W<'a> { w: &'a mut W, } impl<'a> _LCK10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK9W<'a> { w: &'a mut W, } impl<'a> _LCK9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK8W<'a> { w: &'a mut W, } impl<'a> _LCK8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK7W<'a> { w: &'a mut W, } impl<'a> _LCK7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK6W<'a> { w: &'a mut W, } impl<'a> _LCK6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK5W<'a> { w: &'a mut W, } impl<'a> _LCK5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK4W<'a> { w: &'a mut W, } impl<'a> _LCK4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK3W<'a> { w: &'a mut W, } impl<'a> _LCK3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK2W<'a> { w: &'a mut W, } impl<'a> _LCK2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK1W<'a> { w: &'a mut W, } impl<'a> _LCK1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK0W<'a> { w: &'a mut W, } impl<'a> _LCK0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 16 - Port x lock bit y"] #[inline] pub fn lckk(&self) -> LCKKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCKKR { bits } } #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck15(&self) -> LCK15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK15R { bits } } #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck14(&self) -> LCK14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK14R { bits } } #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck13(&self) -> LCK13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK13R { bits } } #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck12(&self) -> LCK12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK12R { bits } } #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck11(&self) -> LCK11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK11R { bits } } #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck10(&self) -> LCK10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK10R { bits } } #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck9(&self) -> LCK9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK9R { bits } } #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck8(&self) -> LCK8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK8R { bits } } #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck7(&self) -> LCK7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK7R { bits } } #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck6(&self) -> LCK6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK6R { bits } } #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck5(&self) -> LCK5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK5R { bits } } #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck4(&self) -> LCK4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK4R { bits } } #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck3(&self) -> LCK3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK3R { bits } } #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck2(&self) -> LCK2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK2R { bits } } #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck1(&self) -> LCK1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK1R { bits } } #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck0(&self) -> LCK0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 16 - Port x lock bit y"] #[inline] pub fn lckk(&mut self) -> _LCKKW { _LCKKW { w: self } } #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck15(&mut self) -> _LCK15W { _LCK15W { w: self } } #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck14(&mut self) -> _LCK14W { _LCK14W { w: self } } #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck13(&mut self) -> _LCK13W { _LCK13W { w: self } } #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck12(&mut self) -> _LCK12W { _LCK12W { w: self } } #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck11(&mut self) -> _LCK11W { _LCK11W { w: self } } #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck10(&mut self) -> _LCK10W { _LCK10W { w: self } } #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck9(&mut self) -> _LCK9W { _LCK9W { w: self } } #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck8(&mut self) -> _LCK8W { _LCK8W { w: self } } #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck7(&mut self) -> _LCK7W { _LCK7W { w: self } } #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck6(&mut self) -> _LCK6W { _LCK6W { w: self } } #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck5(&mut self) -> _LCK5W { _LCK5W { w: self } } #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck4(&mut self) -> _LCK4W { _LCK4W { w: self } } #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck3(&mut self) -> _LCK3W { _LCK3W { w: self } } #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck2(&mut self) -> _LCK2W { _LCK2W { w: self } } #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck1(&mut self) -> _LCK1W { _LCK1W { w: self } } #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck0(&mut self) -> _LCK0W { _LCK0W { w: self } } } } #[doc = "GPIO alternate function low register"] pub struct AFRL { register: ::vcell::VolatileCell, } #[doc = "GPIO alternate function low register"] pub mod afrl { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AFRL { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AFRL7R { bits: u8, } impl AFRL7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL6R { bits: u8, } impl AFRL6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL5R { bits: u8, } impl AFRL5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL4R { bits: u8, } impl AFRL4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL3R { bits: u8, } impl AFRL3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL2R { bits: u8, } impl AFRL2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL1R { bits: u8, } impl AFRL1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL0R { bits: u8, } impl AFRL0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _AFRL7W<'a> { w: &'a mut W, } impl<'a> _AFRL7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL6W<'a> { w: &'a mut W, } impl<'a> _AFRL6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL5W<'a> { w: &'a mut W, } impl<'a> _AFRL5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL4W<'a> { w: &'a mut W, } impl<'a> _AFRL4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL3W<'a> { w: &'a mut W, } impl<'a> _AFRL3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL2W<'a> { w: &'a mut W, } impl<'a> _AFRL2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL1W<'a> { w: &'a mut W, } impl<'a> _AFRL1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL0W<'a> { w: &'a mut W, } impl<'a> _AFRL0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl7(&self) -> AFRL7R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL7R { bits } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl6(&self) -> AFRL6R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL6R { bits } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl5(&self) -> AFRL5R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL5R { bits } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl4(&self) -> AFRL4R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL4R { bits } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl3(&self) -> AFRL3R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL3R { bits } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl2(&self) -> AFRL2R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL2R { bits } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl1(&self) -> AFRL1R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL1R { bits } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl0(&self) -> AFRL0R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl7(&mut self) -> _AFRL7W { _AFRL7W { w: self } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl6(&mut self) -> _AFRL6W { _AFRL6W { w: self } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl5(&mut self) -> _AFRL5W { _AFRL5W { w: self } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl4(&mut self) -> _AFRL4W { _AFRL4W { w: self } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl3(&mut self) -> _AFRL3W { _AFRL3W { w: self } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl2(&mut self) -> _AFRL2W { _AFRL2W { w: self } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl1(&mut self) -> _AFRL1W { _AFRL1W { w: self } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl0(&mut self) -> _AFRL0W { _AFRL0W { w: self } } } } #[doc = "GPIO alternate function high register"] pub struct AFRH { register: ::vcell::VolatileCell, } #[doc = "GPIO alternate function high register"] pub mod afrh { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AFRH { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AFRH15R { bits: u8, } impl AFRH15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH14R { bits: u8, } impl AFRH14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH13R { bits: u8, } impl AFRH13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH12R { bits: u8, } impl AFRH12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH11R { bits: u8, } impl AFRH11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH10R { bits: u8, } impl AFRH10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH9R { bits: u8, } impl AFRH9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH8R { bits: u8, } impl AFRH8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _AFRH15W<'a> { w: &'a mut W, } impl<'a> _AFRH15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH14W<'a> { w: &'a mut W, } impl<'a> _AFRH14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH13W<'a> { w: &'a mut W, } impl<'a> _AFRH13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH12W<'a> { w: &'a mut W, } impl<'a> _AFRH12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH11W<'a> { w: &'a mut W, } impl<'a> _AFRH11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH10W<'a> { w: &'a mut W, } impl<'a> _AFRH10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH9W<'a> { w: &'a mut W, } impl<'a> _AFRH9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH8W<'a> { w: &'a mut W, } impl<'a> _AFRH8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh15(&self) -> AFRH15R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH15R { bits } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh14(&self) -> AFRH14R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH14R { bits } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh13(&self) -> AFRH13R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH13R { bits } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh12(&self) -> AFRH12R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH12R { bits } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh11(&self) -> AFRH11R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH11R { bits } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh10(&self) -> AFRH10R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH10R { bits } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh9(&self) -> AFRH9R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH9R { bits } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh8(&self) -> AFRH8R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH8R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh15(&mut self) -> _AFRH15W { _AFRH15W { w: self } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh14(&mut self) -> _AFRH14W { _AFRH14W { w: self } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh13(&mut self) -> _AFRH13W { _AFRH13W { w: self } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh12(&mut self) -> _AFRH12W { _AFRH12W { w: self } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh11(&mut self) -> _AFRH11W { _AFRH11W { w: self } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh10(&mut self) -> _AFRH10W { _AFRH10W { w: self } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh9(&mut self) -> _AFRH9W { _AFRH9W { w: self } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh8(&mut self) -> _AFRH8W { _AFRH8W { w: self } } } } #[doc = "Port bit reset register"] pub struct BRR { register: ::vcell::VolatileCell, } #[doc = "Port bit reset register"] pub mod brr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BRR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BR0W<'a> { w: &'a mut W, } impl<'a> _BR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR1W<'a> { w: &'a mut W, } impl<'a> _BR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR2W<'a> { w: &'a mut W, } impl<'a> _BR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR3W<'a> { w: &'a mut W, } impl<'a> _BR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR4W<'a> { w: &'a mut W, } impl<'a> _BR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR5W<'a> { w: &'a mut W, } impl<'a> _BR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR6W<'a> { w: &'a mut W, } impl<'a> _BR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR7W<'a> { w: &'a mut W, } impl<'a> _BR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR8W<'a> { w: &'a mut W, } impl<'a> _BR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR9W<'a> { w: &'a mut W, } impl<'a> _BR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR10W<'a> { w: &'a mut W, } impl<'a> _BR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR11W<'a> { w: &'a mut W, } impl<'a> _BR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR12W<'a> { w: &'a mut W, } impl<'a> _BR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR13W<'a> { w: &'a mut W, } impl<'a> _BR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR14W<'a> { w: &'a mut W, } impl<'a> _BR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR15W<'a> { w: &'a mut W, } impl<'a> _BR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Port x Reset bit y"] #[inline] pub fn br0(&mut self) -> _BR0W { _BR0W { w: self } } #[doc = "Bit 1 - Port x Reset bit y"] #[inline] pub fn br1(&mut self) -> _BR1W { _BR1W { w: self } } #[doc = "Bit 2 - Port x Reset bit y"] #[inline] pub fn br2(&mut self) -> _BR2W { _BR2W { w: self } } #[doc = "Bit 3 - Port x Reset bit y"] #[inline] pub fn br3(&mut self) -> _BR3W { _BR3W { w: self } } #[doc = "Bit 4 - Port x Reset bit y"] #[inline] pub fn br4(&mut self) -> _BR4W { _BR4W { w: self } } #[doc = "Bit 5 - Port x Reset bit y"] #[inline] pub fn br5(&mut self) -> _BR5W { _BR5W { w: self } } #[doc = "Bit 6 - Port x Reset bit y"] #[inline] pub fn br6(&mut self) -> _BR6W { _BR6W { w: self } } #[doc = "Bit 7 - Port x Reset bit y"] #[inline] pub fn br7(&mut self) -> _BR7W { _BR7W { w: self } } #[doc = "Bit 8 - Port x Reset bit y"] #[inline] pub fn br8(&mut self) -> _BR8W { _BR8W { w: self } } #[doc = "Bit 9 - Port x Reset bit y"] #[inline] pub fn br9(&mut self) -> _BR9W { _BR9W { w: self } } #[doc = "Bit 10 - Port x Reset bit y"] #[inline] pub fn br10(&mut self) -> _BR10W { _BR10W { w: self } } #[doc = "Bit 11 - Port x Reset bit y"] #[inline] pub fn br11(&mut self) -> _BR11W { _BR11W { w: self } } #[doc = "Bit 12 - Port x Reset bit y"] #[inline] pub fn br12(&mut self) -> _BR12W { _BR12W { w: self } } #[doc = "Bit 13 - Port x Reset bit y"] #[inline] pub fn br13(&mut self) -> _BR13W { _BR13W { w: self } } #[doc = "Bit 14 - Port x Reset bit y"] #[inline] pub fn br14(&mut self) -> _BR14W { _BR14W { w: self } } #[doc = "Bit 15 - Port x Reset bit y"] #[inline] pub fn br15(&mut self) -> _BR15W { _BR15W { w: self } } } } } #[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 gpiof::RegisterBlock { 0x4800_0c00 as *const _ } } impl Deref for GPIOD { type Target = gpiof::RegisterBlock; fn deref(&self) -> &gpiof::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 gpiof::RegisterBlock { 0x4800_0800 as *const _ } } impl Deref for GPIOC { type Target = gpiof::RegisterBlock; fn deref(&self) -> &gpiof::RegisterBlock { unsafe { &*GPIOC::ptr() } } } #[doc = "GPIOB"] 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 gpiof::RegisterBlock { 0x4800_0400 as *const _ } } impl Deref for GPIOB { type Target = gpiof::RegisterBlock; fn deref(&self) -> &gpiof::RegisterBlock { unsafe { &*GPIOB::ptr() } } } #[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 { 0x4800_0000 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - GPIO port mode register"] pub moder: MODER, #[doc = "0x04 - GPIO port output type register"] pub otyper: OTYPER, #[doc = "0x08 - GPIO port output speed register"] pub ospeedr: OSPEEDR, #[doc = "0x0c - GPIO port pull-up/pull-down register"] pub pupdr: PUPDR, #[doc = "0x10 - GPIO port input data register"] pub idr: IDR, #[doc = "0x14 - GPIO port output data register"] pub odr: ODR, #[doc = "0x18 - GPIO port bit set/reset register"] pub bsrr: BSRR, #[doc = "0x1c - GPIO port configuration lock register"] pub lckr: LCKR, #[doc = "0x20 - GPIO alternate function low register"] pub afrl: AFRL, #[doc = "0x24 - GPIO alternate function high register"] pub afrh: AFRH, #[doc = "0x28 - Port bit reset register"] pub brr: BRR, } #[doc = "GPIO port mode register"] pub struct MODER { register: ::vcell::VolatileCell, } #[doc = "GPIO port mode register"] pub mod moder { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::MODER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MODER15R { bits: u8, } impl MODER15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER14R { bits: u8, } impl MODER14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER13R { bits: u8, } impl MODER13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER12R { bits: u8, } impl MODER12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER11R { bits: u8, } impl MODER11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER10R { bits: u8, } impl MODER10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER9R { bits: u8, } impl MODER9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER8R { bits: u8, } impl MODER8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER7R { bits: u8, } impl MODER7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER6R { bits: u8, } impl MODER6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER5R { bits: u8, } impl MODER5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER4R { bits: u8, } impl MODER4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER3R { bits: u8, } impl MODER3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER2R { bits: u8, } impl MODER2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER1R { bits: u8, } impl MODER1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MODER0R { bits: u8, } impl MODER0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MODER15W<'a> { w: &'a mut W, } impl<'a> _MODER15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER14W<'a> { w: &'a mut W, } impl<'a> _MODER14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER13W<'a> { w: &'a mut W, } impl<'a> _MODER13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER12W<'a> { w: &'a mut W, } impl<'a> _MODER12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER11W<'a> { w: &'a mut W, } impl<'a> _MODER11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER10W<'a> { w: &'a mut W, } impl<'a> _MODER10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER9W<'a> { w: &'a mut W, } impl<'a> _MODER9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER8W<'a> { w: &'a mut W, } impl<'a> _MODER8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER7W<'a> { w: &'a mut W, } impl<'a> _MODER7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER6W<'a> { w: &'a mut W, } impl<'a> _MODER6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER5W<'a> { w: &'a mut W, } impl<'a> _MODER5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER4W<'a> { w: &'a mut W, } impl<'a> _MODER4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER3W<'a> { w: &'a mut W, } impl<'a> _MODER3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER2W<'a> { w: &'a mut W, } impl<'a> _MODER2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER1W<'a> { w: &'a mut W, } impl<'a> _MODER1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MODER0W<'a> { w: &'a mut W, } impl<'a> _MODER0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder15(&self) -> MODER15R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER15R { bits } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder14(&self) -> MODER14R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER14R { bits } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder13(&self) -> MODER13R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER13R { bits } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder12(&self) -> MODER12R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER12R { bits } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder11(&self) -> MODER11R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER11R { bits } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder10(&self) -> MODER10R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER10R { bits } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder9(&self) -> MODER9R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER9R { bits } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder8(&self) -> MODER8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER8R { bits } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder7(&self) -> MODER7R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER7R { bits } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder6(&self) -> MODER6R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER6R { bits } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder5(&self) -> MODER5R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER5R { bits } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder4(&self) -> MODER4R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER4R { bits } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder3(&self) -> MODER3R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER3R { bits } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder2(&self) -> MODER2R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER2R { bits } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder1(&self) -> MODER1R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER1R { bits } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder0(&self) -> MODER0R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MODER0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x2800_0000 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder15(&mut self) -> _MODER15W { _MODER15W { w: self } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder14(&mut self) -> _MODER14W { _MODER14W { w: self } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder13(&mut self) -> _MODER13W { _MODER13W { w: self } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder12(&mut self) -> _MODER12W { _MODER12W { w: self } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder11(&mut self) -> _MODER11W { _MODER11W { w: self } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder10(&mut self) -> _MODER10W { _MODER10W { w: self } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder9(&mut self) -> _MODER9W { _MODER9W { w: self } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder8(&mut self) -> _MODER8W { _MODER8W { w: self } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder7(&mut self) -> _MODER7W { _MODER7W { w: self } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder6(&mut self) -> _MODER6W { _MODER6W { w: self } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder5(&mut self) -> _MODER5W { _MODER5W { w: self } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder4(&mut self) -> _MODER4W { _MODER4W { w: self } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder3(&mut self) -> _MODER3W { _MODER3W { w: self } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder2(&mut self) -> _MODER2W { _MODER2W { w: self } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder1(&mut self) -> _MODER1W { _MODER1W { w: self } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn moder0(&mut self) -> _MODER0W { _MODER0W { w: self } } } } #[doc = "GPIO port output type register"] pub struct OTYPER { register: ::vcell::VolatileCell, } #[doc = "GPIO port output type register"] pub mod otyper { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OTYPER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OT15R { bits: bool, } impl OT15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT14R { bits: bool, } impl OT14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT13R { bits: bool, } impl OT13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT12R { bits: bool, } impl OT12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT11R { bits: bool, } impl OT11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT10R { bits: bool, } impl OT10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT9R { bits: bool, } impl OT9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT8R { bits: bool, } impl OT8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT7R { bits: bool, } impl OT7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT6R { bits: bool, } impl OT6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT5R { bits: bool, } impl OT5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT4R { bits: bool, } impl OT4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT3R { bits: bool, } impl OT3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT2R { bits: bool, } impl OT2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT1R { bits: bool, } impl OT1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OT0R { bits: bool, } impl OT0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OT15W<'a> { w: &'a mut W, } impl<'a> _OT15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT14W<'a> { w: &'a mut W, } impl<'a> _OT14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT13W<'a> { w: &'a mut W, } impl<'a> _OT13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT12W<'a> { w: &'a mut W, } impl<'a> _OT12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT11W<'a> { w: &'a mut W, } impl<'a> _OT11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT10W<'a> { w: &'a mut W, } impl<'a> _OT10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT9W<'a> { w: &'a mut W, } impl<'a> _OT9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT8W<'a> { w: &'a mut W, } impl<'a> _OT8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT7W<'a> { w: &'a mut W, } impl<'a> _OT7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT6W<'a> { w: &'a mut W, } impl<'a> _OT6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT5W<'a> { w: &'a mut W, } impl<'a> _OT5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT4W<'a> { w: &'a mut W, } impl<'a> _OT4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT3W<'a> { w: &'a mut W, } impl<'a> _OT3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT2W<'a> { w: &'a mut W, } impl<'a> _OT2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT1W<'a> { w: &'a mut W, } impl<'a> _OT1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OT0W<'a> { w: &'a mut W, } impl<'a> _OT0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot15(&self) -> OT15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT15R { bits } } #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot14(&self) -> OT14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT14R { bits } } #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot13(&self) -> OT13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT13R { bits } } #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot12(&self) -> OT12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT12R { bits } } #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot11(&self) -> OT11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT11R { bits } } #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot10(&self) -> OT10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT10R { bits } } #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot9(&self) -> OT9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT9R { bits } } #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot8(&self) -> OT8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT8R { bits } } #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot7(&self) -> OT7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT7R { bits } } #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot6(&self) -> OT6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT6R { bits } } #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot5(&self) -> OT5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT5R { bits } } #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot4(&self) -> OT4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT4R { bits } } #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot3(&self) -> OT3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT3R { bits } } #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot2(&self) -> OT2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT2R { bits } } #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot1(&self) -> OT1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT1R { bits } } #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot0(&self) -> OT0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OT0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot15(&mut self) -> _OT15W { _OT15W { w: self } } #[doc = "Bit 14 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot14(&mut self) -> _OT14W { _OT14W { w: self } } #[doc = "Bit 13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot13(&mut self) -> _OT13W { _OT13W { w: self } } #[doc = "Bit 12 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot12(&mut self) -> _OT12W { _OT12W { w: self } } #[doc = "Bit 11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot11(&mut self) -> _OT11W { _OT11W { w: self } } #[doc = "Bit 10 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot10(&mut self) -> _OT10W { _OT10W { w: self } } #[doc = "Bit 9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot9(&mut self) -> _OT9W { _OT9W { w: self } } #[doc = "Bit 8 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot8(&mut self) -> _OT8W { _OT8W { w: self } } #[doc = "Bit 7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot7(&mut self) -> _OT7W { _OT7W { w: self } } #[doc = "Bit 6 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot6(&mut self) -> _OT6W { _OT6W { w: self } } #[doc = "Bit 5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot5(&mut self) -> _OT5W { _OT5W { w: self } } #[doc = "Bit 4 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot4(&mut self) -> _OT4W { _OT4W { w: self } } #[doc = "Bit 3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot3(&mut self) -> _OT3W { _OT3W { w: self } } #[doc = "Bit 2 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot2(&mut self) -> _OT2W { _OT2W { w: self } } #[doc = "Bit 1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot1(&mut self) -> _OT1W { _OT1W { w: self } } #[doc = "Bit 0 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ot0(&mut self) -> _OT0W { _OT0W { w: self } } } } #[doc = "GPIO port output speed register"] pub struct OSPEEDR { register: ::vcell::VolatileCell, } #[doc = "GPIO port output speed register"] pub mod ospeedr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OSPEEDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OSPEEDR15R { bits: u8, } impl OSPEEDR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR14R { bits: u8, } impl OSPEEDR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR13R { bits: u8, } impl OSPEEDR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR12R { bits: u8, } impl OSPEEDR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR11R { bits: u8, } impl OSPEEDR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR10R { bits: u8, } impl OSPEEDR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR9R { bits: u8, } impl OSPEEDR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR8R { bits: u8, } impl OSPEEDR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR7R { bits: u8, } impl OSPEEDR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR6R { bits: u8, } impl OSPEEDR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR5R { bits: u8, } impl OSPEEDR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR4R { bits: u8, } impl OSPEEDR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR3R { bits: u8, } impl OSPEEDR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR2R { bits: u8, } impl OSPEEDR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR1R { bits: u8, } impl OSPEEDR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OSPEEDR0R { bits: u8, } impl OSPEEDR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OSPEEDR15W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR14W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR13W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR12W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR11W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR10W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR9W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR8W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR7W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR6W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR5W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR4W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR3W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR2W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR1W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSPEEDR0W<'a> { w: &'a mut W, } impl<'a> _OSPEEDR0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr15(&self) -> OSPEEDR15R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR15R { bits } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr14(&self) -> OSPEEDR14R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR14R { bits } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr13(&self) -> OSPEEDR13R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR13R { bits } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr12(&self) -> OSPEEDR12R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR12R { bits } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr11(&self) -> OSPEEDR11R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR11R { bits } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr10(&self) -> OSPEEDR10R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR10R { bits } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr9(&self) -> OSPEEDR9R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR9R { bits } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr8(&self) -> OSPEEDR8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR8R { bits } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr7(&self) -> OSPEEDR7R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR7R { bits } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr6(&self) -> OSPEEDR6R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR6R { bits } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr5(&self) -> OSPEEDR5R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR5R { bits } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr4(&self) -> OSPEEDR4R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR4R { bits } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr3(&self) -> OSPEEDR3R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR3R { bits } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr2(&self) -> OSPEEDR2R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR2R { bits } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr1(&self) -> OSPEEDR1R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR1R { bits } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr0(&self) -> OSPEEDR0R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSPEEDR0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr15(&mut self) -> _OSPEEDR15W { _OSPEEDR15W { w: self } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr14(&mut self) -> _OSPEEDR14W { _OSPEEDR14W { w: self } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr13(&mut self) -> _OSPEEDR13W { _OSPEEDR13W { w: self } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr12(&mut self) -> _OSPEEDR12W { _OSPEEDR12W { w: self } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr11(&mut self) -> _OSPEEDR11W { _OSPEEDR11W { w: self } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr10(&mut self) -> _OSPEEDR10W { _OSPEEDR10W { w: self } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr9(&mut self) -> _OSPEEDR9W { _OSPEEDR9W { w: self } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr8(&mut self) -> _OSPEEDR8W { _OSPEEDR8W { w: self } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr7(&mut self) -> _OSPEEDR7W { _OSPEEDR7W { w: self } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr6(&mut self) -> _OSPEEDR6W { _OSPEEDR6W { w: self } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr5(&mut self) -> _OSPEEDR5W { _OSPEEDR5W { w: self } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr4(&mut self) -> _OSPEEDR4W { _OSPEEDR4W { w: self } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr3(&mut self) -> _OSPEEDR3W { _OSPEEDR3W { w: self } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr2(&mut self) -> _OSPEEDR2W { _OSPEEDR2W { w: self } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr1(&mut self) -> _OSPEEDR1W { _OSPEEDR1W { w: self } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn ospeedr0(&mut self) -> _OSPEEDR0W { _OSPEEDR0W { w: self } } } } #[doc = "GPIO port pull-up/pull-down register"] pub struct PUPDR { register: ::vcell::VolatileCell, } #[doc = "GPIO port pull-up/pull-down register"] pub mod pupdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PUPDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PUPDR15R { bits: u8, } impl PUPDR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR14R { bits: u8, } impl PUPDR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR13R { bits: u8, } impl PUPDR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR12R { bits: u8, } impl PUPDR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR11R { bits: u8, } impl PUPDR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR10R { bits: u8, } impl PUPDR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR9R { bits: u8, } impl PUPDR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR8R { bits: u8, } impl PUPDR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR7R { bits: u8, } impl PUPDR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR6R { bits: u8, } impl PUPDR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR5R { bits: u8, } impl PUPDR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR4R { bits: u8, } impl PUPDR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR3R { bits: u8, } impl PUPDR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR2R { bits: u8, } impl PUPDR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR1R { bits: u8, } impl PUPDR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PUPDR0R { bits: u8, } impl PUPDR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _PUPDR15W<'a> { w: &'a mut W, } impl<'a> _PUPDR15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR14W<'a> { w: &'a mut W, } impl<'a> _PUPDR14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR13W<'a> { w: &'a mut W, } impl<'a> _PUPDR13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR12W<'a> { w: &'a mut W, } impl<'a> _PUPDR12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR11W<'a> { w: &'a mut W, } impl<'a> _PUPDR11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR10W<'a> { w: &'a mut W, } impl<'a> _PUPDR10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR9W<'a> { w: &'a mut W, } impl<'a> _PUPDR9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR8W<'a> { w: &'a mut W, } impl<'a> _PUPDR8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR7W<'a> { w: &'a mut W, } impl<'a> _PUPDR7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR6W<'a> { w: &'a mut W, } impl<'a> _PUPDR6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR5W<'a> { w: &'a mut W, } impl<'a> _PUPDR5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR4W<'a> { w: &'a mut W, } impl<'a> _PUPDR4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR3W<'a> { w: &'a mut W, } impl<'a> _PUPDR3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR2W<'a> { w: &'a mut W, } impl<'a> _PUPDR2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR1W<'a> { w: &'a mut W, } impl<'a> _PUPDR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PUPDR0W<'a> { w: &'a mut W, } impl<'a> _PUPDR0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr15(&self) -> PUPDR15R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR15R { bits } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr14(&self) -> PUPDR14R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR14R { bits } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr13(&self) -> PUPDR13R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR13R { bits } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr12(&self) -> PUPDR12R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR12R { bits } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr11(&self) -> PUPDR11R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR11R { bits } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr10(&self) -> PUPDR10R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR10R { bits } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr9(&self) -> PUPDR9R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR9R { bits } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr8(&self) -> PUPDR8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR8R { bits } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr7(&self) -> PUPDR7R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR7R { bits } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr6(&self) -> PUPDR6R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR6R { bits } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr5(&self) -> PUPDR5R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR5R { bits } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr4(&self) -> PUPDR4R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR4R { bits } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr3(&self) -> PUPDR3R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR3R { bits } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr2(&self) -> PUPDR2R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR2R { bits } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr1(&self) -> PUPDR1R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR1R { bits } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr0(&self) -> PUPDR0R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PUPDR0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x2400_0000 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 30:31 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr15(&mut self) -> _PUPDR15W { _PUPDR15W { w: self } } #[doc = "Bits 28:29 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr14(&mut self) -> _PUPDR14W { _PUPDR14W { w: self } } #[doc = "Bits 26:27 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr13(&mut self) -> _PUPDR13W { _PUPDR13W { w: self } } #[doc = "Bits 24:25 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr12(&mut self) -> _PUPDR12W { _PUPDR12W { w: self } } #[doc = "Bits 22:23 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr11(&mut self) -> _PUPDR11W { _PUPDR11W { w: self } } #[doc = "Bits 20:21 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr10(&mut self) -> _PUPDR10W { _PUPDR10W { w: self } } #[doc = "Bits 18:19 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr9(&mut self) -> _PUPDR9W { _PUPDR9W { w: self } } #[doc = "Bits 16:17 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr8(&mut self) -> _PUPDR8W { _PUPDR8W { w: self } } #[doc = "Bits 14:15 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr7(&mut self) -> _PUPDR7W { _PUPDR7W { w: self } } #[doc = "Bits 12:13 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr6(&mut self) -> _PUPDR6W { _PUPDR6W { w: self } } #[doc = "Bits 10:11 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr5(&mut self) -> _PUPDR5W { _PUPDR5W { w: self } } #[doc = "Bits 8:9 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr4(&mut self) -> _PUPDR4W { _PUPDR4W { w: self } } #[doc = "Bits 6:7 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr3(&mut self) -> _PUPDR3W { _PUPDR3W { w: self } } #[doc = "Bits 4:5 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr2(&mut self) -> _PUPDR2W { _PUPDR2W { w: self } } #[doc = "Bits 2:3 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr1(&mut self) -> _PUPDR1W { _PUPDR1W { w: self } } #[doc = "Bits 0:1 - Port x configuration bits (y = 0..15)"] #[inline] pub fn pupdr0(&mut self) -> _PUPDR0W { _PUPDR0W { w: self } } } } #[doc = "GPIO port input data register"] pub struct IDR { register: ::vcell::VolatileCell, } #[doc = "GPIO port input data register"] pub mod idr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::IDR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct IDR15R { bits: bool, } impl IDR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR14R { bits: bool, } impl IDR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR13R { bits: bool, } impl IDR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR12R { bits: bool, } impl IDR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR11R { bits: bool, } impl IDR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR10R { bits: bool, } impl IDR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR9R { bits: bool, } impl IDR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR8R { bits: bool, } impl IDR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR7R { bits: bool, } impl IDR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR6R { bits: bool, } impl IDR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR5R { bits: bool, } impl IDR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR4R { bits: bool, } impl IDR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR3R { bits: bool, } impl IDR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR2R { bits: bool, } impl IDR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR1R { bits: bool, } impl IDR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDR0R { bits: bool, } impl IDR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Port input data (y = 0..15)"] #[inline] pub fn idr15(&self) -> IDR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR15R { bits } } #[doc = "Bit 14 - Port input data (y = 0..15)"] #[inline] pub fn idr14(&self) -> IDR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR14R { bits } } #[doc = "Bit 13 - Port input data (y = 0..15)"] #[inline] pub fn idr13(&self) -> IDR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR13R { bits } } #[doc = "Bit 12 - Port input data (y = 0..15)"] #[inline] pub fn idr12(&self) -> IDR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR12R { bits } } #[doc = "Bit 11 - Port input data (y = 0..15)"] #[inline] pub fn idr11(&self) -> IDR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR11R { bits } } #[doc = "Bit 10 - Port input data (y = 0..15)"] #[inline] pub fn idr10(&self) -> IDR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR10R { bits } } #[doc = "Bit 9 - Port input data (y = 0..15)"] #[inline] pub fn idr9(&self) -> IDR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR9R { bits } } #[doc = "Bit 8 - Port input data (y = 0..15)"] #[inline] pub fn idr8(&self) -> IDR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR8R { bits } } #[doc = "Bit 7 - Port input data (y = 0..15)"] #[inline] pub fn idr7(&self) -> IDR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR7R { bits } } #[doc = "Bit 6 - Port input data (y = 0..15)"] #[inline] pub fn idr6(&self) -> IDR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR6R { bits } } #[doc = "Bit 5 - Port input data (y = 0..15)"] #[inline] pub fn idr5(&self) -> IDR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR5R { bits } } #[doc = "Bit 4 - Port input data (y = 0..15)"] #[inline] pub fn idr4(&self) -> IDR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR4R { bits } } #[doc = "Bit 3 - Port input data (y = 0..15)"] #[inline] pub fn idr3(&self) -> IDR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR3R { bits } } #[doc = "Bit 2 - Port input data (y = 0..15)"] #[inline] pub fn idr2(&self) -> IDR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR2R { bits } } #[doc = "Bit 1 - Port input data (y = 0..15)"] #[inline] pub fn idr1(&self) -> IDR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR1R { bits } } #[doc = "Bit 0 - Port input data (y = 0..15)"] #[inline] pub fn idr0(&self) -> IDR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDR0R { bits } } } } #[doc = "GPIO port output data register"] pub struct ODR { register: ::vcell::VolatileCell, } #[doc = "GPIO port output data register"] pub mod odr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ODR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ODR15R { bits: bool, } impl ODR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR14R { bits: bool, } impl ODR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR13R { bits: bool, } impl ODR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR12R { bits: bool, } impl ODR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR11R { bits: bool, } impl ODR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR10R { bits: bool, } impl ODR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR9R { bits: bool, } impl ODR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR8R { bits: bool, } impl ODR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR7R { bits: bool, } impl ODR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR6R { bits: bool, } impl ODR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR5R { bits: bool, } impl ODR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR4R { bits: bool, } impl ODR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR3R { bits: bool, } impl ODR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR2R { bits: bool, } impl ODR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR1R { bits: bool, } impl ODR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODR0R { bits: bool, } impl ODR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ODR15W<'a> { w: &'a mut W, } impl<'a> _ODR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR14W<'a> { w: &'a mut W, } impl<'a> _ODR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR13W<'a> { w: &'a mut W, } impl<'a> _ODR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR12W<'a> { w: &'a mut W, } impl<'a> _ODR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR11W<'a> { w: &'a mut W, } impl<'a> _ODR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR10W<'a> { w: &'a mut W, } impl<'a> _ODR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR9W<'a> { w: &'a mut W, } impl<'a> _ODR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR8W<'a> { w: &'a mut W, } impl<'a> _ODR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR7W<'a> { w: &'a mut W, } impl<'a> _ODR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR6W<'a> { w: &'a mut W, } impl<'a> _ODR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR5W<'a> { w: &'a mut W, } impl<'a> _ODR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR4W<'a> { w: &'a mut W, } impl<'a> _ODR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR3W<'a> { w: &'a mut W, } impl<'a> _ODR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR2W<'a> { w: &'a mut W, } impl<'a> _ODR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR1W<'a> { w: &'a mut W, } impl<'a> _ODR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODR0W<'a> { w: &'a mut W, } impl<'a> _ODR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Port output data (y = 0..15)"] #[inline] pub fn odr15(&self) -> ODR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR15R { bits } } #[doc = "Bit 14 - Port output data (y = 0..15)"] #[inline] pub fn odr14(&self) -> ODR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR14R { bits } } #[doc = "Bit 13 - Port output data (y = 0..15)"] #[inline] pub fn odr13(&self) -> ODR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR13R { bits } } #[doc = "Bit 12 - Port output data (y = 0..15)"] #[inline] pub fn odr12(&self) -> ODR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR12R { bits } } #[doc = "Bit 11 - Port output data (y = 0..15)"] #[inline] pub fn odr11(&self) -> ODR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR11R { bits } } #[doc = "Bit 10 - Port output data (y = 0..15)"] #[inline] pub fn odr10(&self) -> ODR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR10R { bits } } #[doc = "Bit 9 - Port output data (y = 0..15)"] #[inline] pub fn odr9(&self) -> ODR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR9R { bits } } #[doc = "Bit 8 - Port output data (y = 0..15)"] #[inline] pub fn odr8(&self) -> ODR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR8R { bits } } #[doc = "Bit 7 - Port output data (y = 0..15)"] #[inline] pub fn odr7(&self) -> ODR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR7R { bits } } #[doc = "Bit 6 - Port output data (y = 0..15)"] #[inline] pub fn odr6(&self) -> ODR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR6R { bits } } #[doc = "Bit 5 - Port output data (y = 0..15)"] #[inline] pub fn odr5(&self) -> ODR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR5R { bits } } #[doc = "Bit 4 - Port output data (y = 0..15)"] #[inline] pub fn odr4(&self) -> ODR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR4R { bits } } #[doc = "Bit 3 - Port output data (y = 0..15)"] #[inline] pub fn odr3(&self) -> ODR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR3R { bits } } #[doc = "Bit 2 - Port output data (y = 0..15)"] #[inline] pub fn odr2(&self) -> ODR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR2R { bits } } #[doc = "Bit 1 - Port output data (y = 0..15)"] #[inline] pub fn odr1(&self) -> ODR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR1R { bits } } #[doc = "Bit 0 - Port output data (y = 0..15)"] #[inline] pub fn odr0(&self) -> ODR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODR0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Port output data (y = 0..15)"] #[inline] pub fn odr15(&mut self) -> _ODR15W { _ODR15W { w: self } } #[doc = "Bit 14 - Port output data (y = 0..15)"] #[inline] pub fn odr14(&mut self) -> _ODR14W { _ODR14W { w: self } } #[doc = "Bit 13 - Port output data (y = 0..15)"] #[inline] pub fn odr13(&mut self) -> _ODR13W { _ODR13W { w: self } } #[doc = "Bit 12 - Port output data (y = 0..15)"] #[inline] pub fn odr12(&mut self) -> _ODR12W { _ODR12W { w: self } } #[doc = "Bit 11 - Port output data (y = 0..15)"] #[inline] pub fn odr11(&mut self) -> _ODR11W { _ODR11W { w: self } } #[doc = "Bit 10 - Port output data (y = 0..15)"] #[inline] pub fn odr10(&mut self) -> _ODR10W { _ODR10W { w: self } } #[doc = "Bit 9 - Port output data (y = 0..15)"] #[inline] pub fn odr9(&mut self) -> _ODR9W { _ODR9W { w: self } } #[doc = "Bit 8 - Port output data (y = 0..15)"] #[inline] pub fn odr8(&mut self) -> _ODR8W { _ODR8W { w: self } } #[doc = "Bit 7 - Port output data (y = 0..15)"] #[inline] pub fn odr7(&mut self) -> _ODR7W { _ODR7W { w: self } } #[doc = "Bit 6 - Port output data (y = 0..15)"] #[inline] pub fn odr6(&mut self) -> _ODR6W { _ODR6W { w: self } } #[doc = "Bit 5 - Port output data (y = 0..15)"] #[inline] pub fn odr5(&mut self) -> _ODR5W { _ODR5W { w: self } } #[doc = "Bit 4 - Port output data (y = 0..15)"] #[inline] pub fn odr4(&mut self) -> _ODR4W { _ODR4W { w: self } } #[doc = "Bit 3 - Port output data (y = 0..15)"] #[inline] pub fn odr3(&mut self) -> _ODR3W { _ODR3W { w: self } } #[doc = "Bit 2 - Port output data (y = 0..15)"] #[inline] pub fn odr2(&mut self) -> _ODR2W { _ODR2W { w: self } } #[doc = "Bit 1 - Port output data (y = 0..15)"] #[inline] pub fn odr1(&mut self) -> _ODR1W { _ODR1W { w: self } } #[doc = "Bit 0 - Port output data (y = 0..15)"] #[inline] pub fn odr0(&mut self) -> _ODR0W { _ODR0W { w: self } } } } #[doc = "GPIO port bit set/reset register"] pub struct BSRR { register: ::vcell::VolatileCell, } #[doc = "GPIO port bit set/reset register"] pub mod bsrr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BSRR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BR15W<'a> { w: &'a mut W, } impl<'a> _BR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR14W<'a> { w: &'a mut W, } impl<'a> _BR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR13W<'a> { w: &'a mut W, } impl<'a> _BR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 29; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR12W<'a> { w: &'a mut W, } impl<'a> _BR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR11W<'a> { w: &'a mut W, } impl<'a> _BR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR10W<'a> { w: &'a mut W, } impl<'a> _BR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR9W<'a> { w: &'a mut W, } impl<'a> _BR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR8W<'a> { w: &'a mut W, } impl<'a> _BR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR7W<'a> { w: &'a mut W, } impl<'a> _BR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR6W<'a> { w: &'a mut W, } impl<'a> _BR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR5W<'a> { w: &'a mut W, } impl<'a> _BR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR4W<'a> { w: &'a mut W, } impl<'a> _BR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR3W<'a> { w: &'a mut W, } impl<'a> _BR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR2W<'a> { w: &'a mut W, } impl<'a> _BR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR1W<'a> { w: &'a mut W, } impl<'a> _BR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR0W<'a> { w: &'a mut W, } impl<'a> _BR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS15W<'a> { w: &'a mut W, } impl<'a> _BS15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS14W<'a> { w: &'a mut W, } impl<'a> _BS14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS13W<'a> { w: &'a mut W, } impl<'a> _BS13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS12W<'a> { w: &'a mut W, } impl<'a> _BS12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS11W<'a> { w: &'a mut W, } impl<'a> _BS11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS10W<'a> { w: &'a mut W, } impl<'a> _BS10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS9W<'a> { w: &'a mut W, } impl<'a> _BS9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS8W<'a> { w: &'a mut W, } impl<'a> _BS8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS7W<'a> { w: &'a mut W, } impl<'a> _BS7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS6W<'a> { w: &'a mut W, } impl<'a> _BS6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS5W<'a> { w: &'a mut W, } impl<'a> _BS5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS4W<'a> { w: &'a mut W, } impl<'a> _BS4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS3W<'a> { w: &'a mut W, } impl<'a> _BS3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS2W<'a> { w: &'a mut W, } impl<'a> _BS2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS1W<'a> { w: &'a mut W, } impl<'a> _BS1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BS0W<'a> { w: &'a mut W, } impl<'a> _BS0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 31 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br15(&mut self) -> _BR15W { _BR15W { w: self } } #[doc = "Bit 30 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br14(&mut self) -> _BR14W { _BR14W { w: self } } #[doc = "Bit 29 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br13(&mut self) -> _BR13W { _BR13W { w: self } } #[doc = "Bit 28 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br12(&mut self) -> _BR12W { _BR12W { w: self } } #[doc = "Bit 27 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br11(&mut self) -> _BR11W { _BR11W { w: self } } #[doc = "Bit 26 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br10(&mut self) -> _BR10W { _BR10W { w: self } } #[doc = "Bit 25 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br9(&mut self) -> _BR9W { _BR9W { w: self } } #[doc = "Bit 24 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br8(&mut self) -> _BR8W { _BR8W { w: self } } #[doc = "Bit 23 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br7(&mut self) -> _BR7W { _BR7W { w: self } } #[doc = "Bit 22 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br6(&mut self) -> _BR6W { _BR6W { w: self } } #[doc = "Bit 21 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br5(&mut self) -> _BR5W { _BR5W { w: self } } #[doc = "Bit 20 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br4(&mut self) -> _BR4W { _BR4W { w: self } } #[doc = "Bit 19 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br3(&mut self) -> _BR3W { _BR3W { w: self } } #[doc = "Bit 18 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br2(&mut self) -> _BR2W { _BR2W { w: self } } #[doc = "Bit 17 - Port x reset bit y (y = 0..15)"] #[inline] pub fn br1(&mut self) -> _BR1W { _BR1W { w: self } } #[doc = "Bit 16 - Port x set bit y (y= 0..15)"] #[inline] pub fn br0(&mut self) -> _BR0W { _BR0W { w: self } } #[doc = "Bit 15 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs15(&mut self) -> _BS15W { _BS15W { w: self } } #[doc = "Bit 14 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs14(&mut self) -> _BS14W { _BS14W { w: self } } #[doc = "Bit 13 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs13(&mut self) -> _BS13W { _BS13W { w: self } } #[doc = "Bit 12 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs12(&mut self) -> _BS12W { _BS12W { w: self } } #[doc = "Bit 11 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs11(&mut self) -> _BS11W { _BS11W { w: self } } #[doc = "Bit 10 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs10(&mut self) -> _BS10W { _BS10W { w: self } } #[doc = "Bit 9 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs9(&mut self) -> _BS9W { _BS9W { w: self } } #[doc = "Bit 8 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs8(&mut self) -> _BS8W { _BS8W { w: self } } #[doc = "Bit 7 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs7(&mut self) -> _BS7W { _BS7W { w: self } } #[doc = "Bit 6 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs6(&mut self) -> _BS6W { _BS6W { w: self } } #[doc = "Bit 5 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs5(&mut self) -> _BS5W { _BS5W { w: self } } #[doc = "Bit 4 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs4(&mut self) -> _BS4W { _BS4W { w: self } } #[doc = "Bit 3 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs3(&mut self) -> _BS3W { _BS3W { w: self } } #[doc = "Bit 2 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs2(&mut self) -> _BS2W { _BS2W { w: self } } #[doc = "Bit 1 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs1(&mut self) -> _BS1W { _BS1W { w: self } } #[doc = "Bit 0 - Port x set bit y (y= 0..15)"] #[inline] pub fn bs0(&mut self) -> _BS0W { _BS0W { w: self } } } } #[doc = "GPIO port configuration lock register"] pub struct LCKR { register: ::vcell::VolatileCell, } #[doc = "GPIO port configuration lock register"] pub mod lckr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::LCKR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct LCKKR { bits: bool, } impl LCKKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK15R { bits: bool, } impl LCK15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK14R { bits: bool, } impl LCK14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK13R { bits: bool, } impl LCK13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK12R { bits: bool, } impl LCK12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK11R { bits: bool, } impl LCK11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK10R { bits: bool, } impl LCK10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK9R { bits: bool, } impl LCK9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK8R { bits: bool, } impl LCK8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK7R { bits: bool, } impl LCK7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK6R { bits: bool, } impl LCK6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK5R { bits: bool, } impl LCK5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK4R { bits: bool, } impl LCK4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK3R { bits: bool, } impl LCK3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK2R { bits: bool, } impl LCK2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK1R { bits: bool, } impl LCK1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LCK0R { bits: bool, } impl LCK0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _LCKKW<'a> { w: &'a mut W, } impl<'a> _LCKKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK15W<'a> { w: &'a mut W, } impl<'a> _LCK15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK14W<'a> { w: &'a mut W, } impl<'a> _LCK14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK13W<'a> { w: &'a mut W, } impl<'a> _LCK13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK12W<'a> { w: &'a mut W, } impl<'a> _LCK12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK11W<'a> { w: &'a mut W, } impl<'a> _LCK11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK10W<'a> { w: &'a mut W, } impl<'a> _LCK10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK9W<'a> { w: &'a mut W, } impl<'a> _LCK9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK8W<'a> { w: &'a mut W, } impl<'a> _LCK8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK7W<'a> { w: &'a mut W, } impl<'a> _LCK7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK6W<'a> { w: &'a mut W, } impl<'a> _LCK6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK5W<'a> { w: &'a mut W, } impl<'a> _LCK5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK4W<'a> { w: &'a mut W, } impl<'a> _LCK4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK3W<'a> { w: &'a mut W, } impl<'a> _LCK3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK2W<'a> { w: &'a mut W, } impl<'a> _LCK2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK1W<'a> { w: &'a mut W, } impl<'a> _LCK1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LCK0W<'a> { w: &'a mut W, } impl<'a> _LCK0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lckk(&self) -> LCKKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCKKR { bits } } #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck15(&self) -> LCK15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK15R { bits } } #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck14(&self) -> LCK14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK14R { bits } } #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck13(&self) -> LCK13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK13R { bits } } #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck12(&self) -> LCK12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK12R { bits } } #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck11(&self) -> LCK11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK11R { bits } } #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck10(&self) -> LCK10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK10R { bits } } #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck9(&self) -> LCK9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK9R { bits } } #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck8(&self) -> LCK8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK8R { bits } } #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck7(&self) -> LCK7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK7R { bits } } #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck6(&self) -> LCK6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK6R { bits } } #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck5(&self) -> LCK5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK5R { bits } } #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck4(&self) -> LCK4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK4R { bits } } #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck3(&self) -> LCK3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK3R { bits } } #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck2(&self) -> LCK2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK2R { bits } } #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck1(&self) -> LCK1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK1R { bits } } #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck0(&self) -> LCK0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LCK0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 16 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lckk(&mut self) -> _LCKKW { _LCKKW { w: self } } #[doc = "Bit 15 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck15(&mut self) -> _LCK15W { _LCK15W { w: self } } #[doc = "Bit 14 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck14(&mut self) -> _LCK14W { _LCK14W { w: self } } #[doc = "Bit 13 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck13(&mut self) -> _LCK13W { _LCK13W { w: self } } #[doc = "Bit 12 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck12(&mut self) -> _LCK12W { _LCK12W { w: self } } #[doc = "Bit 11 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck11(&mut self) -> _LCK11W { _LCK11W { w: self } } #[doc = "Bit 10 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck10(&mut self) -> _LCK10W { _LCK10W { w: self } } #[doc = "Bit 9 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck9(&mut self) -> _LCK9W { _LCK9W { w: self } } #[doc = "Bit 8 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck8(&mut self) -> _LCK8W { _LCK8W { w: self } } #[doc = "Bit 7 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck7(&mut self) -> _LCK7W { _LCK7W { w: self } } #[doc = "Bit 6 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck6(&mut self) -> _LCK6W { _LCK6W { w: self } } #[doc = "Bit 5 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck5(&mut self) -> _LCK5W { _LCK5W { w: self } } #[doc = "Bit 4 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck4(&mut self) -> _LCK4W { _LCK4W { w: self } } #[doc = "Bit 3 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck3(&mut self) -> _LCK3W { _LCK3W { w: self } } #[doc = "Bit 2 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck2(&mut self) -> _LCK2W { _LCK2W { w: self } } #[doc = "Bit 1 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck1(&mut self) -> _LCK1W { _LCK1W { w: self } } #[doc = "Bit 0 - Port x lock bit y (y= 0..15)"] #[inline] pub fn lck0(&mut self) -> _LCK0W { _LCK0W { w: self } } } } #[doc = "GPIO alternate function low register"] pub struct AFRL { register: ::vcell::VolatileCell, } #[doc = "GPIO alternate function low register"] pub mod afrl { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AFRL { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AFRL7R { bits: u8, } impl AFRL7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL6R { bits: u8, } impl AFRL6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL5R { bits: u8, } impl AFRL5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL4R { bits: u8, } impl AFRL4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL3R { bits: u8, } impl AFRL3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL2R { bits: u8, } impl AFRL2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL1R { bits: u8, } impl AFRL1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRL0R { bits: u8, } impl AFRL0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _AFRL7W<'a> { w: &'a mut W, } impl<'a> _AFRL7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL6W<'a> { w: &'a mut W, } impl<'a> _AFRL6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL5W<'a> { w: &'a mut W, } impl<'a> _AFRL5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL4W<'a> { w: &'a mut W, } impl<'a> _AFRL4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL3W<'a> { w: &'a mut W, } impl<'a> _AFRL3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL2W<'a> { w: &'a mut W, } impl<'a> _AFRL2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL1W<'a> { w: &'a mut W, } impl<'a> _AFRL1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRL0W<'a> { w: &'a mut W, } impl<'a> _AFRL0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl7(&self) -> AFRL7R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL7R { bits } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl6(&self) -> AFRL6R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL6R { bits } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl5(&self) -> AFRL5R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL5R { bits } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl4(&self) -> AFRL4R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL4R { bits } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl3(&self) -> AFRL3R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL3R { bits } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl2(&self) -> AFRL2R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL2R { bits } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl1(&self) -> AFRL1R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL1R { bits } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl0(&self) -> AFRL0R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRL0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl7(&mut self) -> _AFRL7W { _AFRL7W { w: self } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl6(&mut self) -> _AFRL6W { _AFRL6W { w: self } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl5(&mut self) -> _AFRL5W { _AFRL5W { w: self } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl4(&mut self) -> _AFRL4W { _AFRL4W { w: self } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl3(&mut self) -> _AFRL3W { _AFRL3W { w: self } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl2(&mut self) -> _AFRL2W { _AFRL2W { w: self } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl1(&mut self) -> _AFRL1W { _AFRL1W { w: self } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 0..7)"] #[inline] pub fn afrl0(&mut self) -> _AFRL0W { _AFRL0W { w: self } } } } #[doc = "GPIO alternate function high register"] pub struct AFRH { register: ::vcell::VolatileCell, } #[doc = "GPIO alternate function high register"] pub mod afrh { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AFRH { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AFRH15R { bits: u8, } impl AFRH15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH14R { bits: u8, } impl AFRH14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH13R { bits: u8, } impl AFRH13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH12R { bits: u8, } impl AFRH12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH11R { bits: u8, } impl AFRH11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH10R { bits: u8, } impl AFRH10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH9R { bits: u8, } impl AFRH9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AFRH8R { bits: u8, } impl AFRH8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _AFRH15W<'a> { w: &'a mut W, } impl<'a> _AFRH15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH14W<'a> { w: &'a mut W, } impl<'a> _AFRH14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH13W<'a> { w: &'a mut W, } impl<'a> _AFRH13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH12W<'a> { w: &'a mut W, } impl<'a> _AFRH12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH11W<'a> { w: &'a mut W, } impl<'a> _AFRH11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH10W<'a> { w: &'a mut W, } impl<'a> _AFRH10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH9W<'a> { w: &'a mut W, } impl<'a> _AFRH9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AFRH8W<'a> { w: &'a mut W, } impl<'a> _AFRH8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh15(&self) -> AFRH15R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH15R { bits } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh14(&self) -> AFRH14R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH14R { bits } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh13(&self) -> AFRH13R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH13R { bits } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh12(&self) -> AFRH12R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH12R { bits } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh11(&self) -> AFRH11R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH11R { bits } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh10(&self) -> AFRH10R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH10R { bits } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh9(&self) -> AFRH9R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH9R { bits } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh8(&self) -> AFRH8R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AFRH8R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 28:31 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh15(&mut self) -> _AFRH15W { _AFRH15W { w: self } } #[doc = "Bits 24:27 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh14(&mut self) -> _AFRH14W { _AFRH14W { w: self } } #[doc = "Bits 20:23 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh13(&mut self) -> _AFRH13W { _AFRH13W { w: self } } #[doc = "Bits 16:19 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh12(&mut self) -> _AFRH12W { _AFRH12W { w: self } } #[doc = "Bits 12:15 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh11(&mut self) -> _AFRH11W { _AFRH11W { w: self } } #[doc = "Bits 8:11 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh10(&mut self) -> _AFRH10W { _AFRH10W { w: self } } #[doc = "Bits 4:7 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh9(&mut self) -> _AFRH9W { _AFRH9W { w: self } } #[doc = "Bits 0:3 - Alternate function selection for port x bit y (y = 8..15)"] #[inline] pub fn afrh8(&mut self) -> _AFRH8W { _AFRH8W { w: self } } } } #[doc = "Port bit reset register"] pub struct BRR { register: ::vcell::VolatileCell, } #[doc = "Port bit reset register"] pub mod brr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BRR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BR0W<'a> { w: &'a mut W, } impl<'a> _BR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR1W<'a> { w: &'a mut W, } impl<'a> _BR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR2W<'a> { w: &'a mut W, } impl<'a> _BR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR3W<'a> { w: &'a mut W, } impl<'a> _BR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR4W<'a> { w: &'a mut W, } impl<'a> _BR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR5W<'a> { w: &'a mut W, } impl<'a> _BR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR6W<'a> { w: &'a mut W, } impl<'a> _BR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR7W<'a> { w: &'a mut W, } impl<'a> _BR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR8W<'a> { w: &'a mut W, } impl<'a> _BR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR9W<'a> { w: &'a mut W, } impl<'a> _BR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR10W<'a> { w: &'a mut W, } impl<'a> _BR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR11W<'a> { w: &'a mut W, } impl<'a> _BR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR12W<'a> { w: &'a mut W, } impl<'a> _BR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR13W<'a> { w: &'a mut W, } impl<'a> _BR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR14W<'a> { w: &'a mut W, } impl<'a> _BR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BR15W<'a> { w: &'a mut W, } impl<'a> _BR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Port x Reset bit y"] #[inline] pub fn br0(&mut self) -> _BR0W { _BR0W { w: self } } #[doc = "Bit 1 - Port x Reset bit y"] #[inline] pub fn br1(&mut self) -> _BR1W { _BR1W { w: self } } #[doc = "Bit 2 - Port x Reset bit y"] #[inline] pub fn br2(&mut self) -> _BR2W { _BR2W { w: self } } #[doc = "Bit 3 - Port x Reset bit y"] #[inline] pub fn br3(&mut self) -> _BR3W { _BR3W { w: self } } #[doc = "Bit 4 - Port x Reset bit y"] #[inline] pub fn br4(&mut self) -> _BR4W { _BR4W { w: self } } #[doc = "Bit 5 - Port x Reset bit y"] #[inline] pub fn br5(&mut self) -> _BR5W { _BR5W { w: self } } #[doc = "Bit 6 - Port x Reset bit y"] #[inline] pub fn br6(&mut self) -> _BR6W { _BR6W { w: self } } #[doc = "Bit 7 - Port x Reset bit y"] #[inline] pub fn br7(&mut self) -> _BR7W { _BR7W { w: self } } #[doc = "Bit 8 - Port x Reset bit y"] #[inline] pub fn br8(&mut self) -> _BR8W { _BR8W { w: self } } #[doc = "Bit 9 - Port x Reset bit y"] #[inline] pub fn br9(&mut self) -> _BR9W { _BR9W { w: self } } #[doc = "Bit 10 - Port x Reset bit y"] #[inline] pub fn br10(&mut self) -> _BR10W { _BR10W { w: self } } #[doc = "Bit 11 - Port x Reset bit y"] #[inline] pub fn br11(&mut self) -> _BR11W { _BR11W { w: self } } #[doc = "Bit 12 - Port x Reset bit y"] #[inline] pub fn br12(&mut self) -> _BR12W { _BR12W { w: self } } #[doc = "Bit 13 - Port x Reset bit y"] #[inline] pub fn br13(&mut self) -> _BR13W { _BR13W { w: self } } #[doc = "Bit 14 - Port x Reset bit y"] #[inline] pub fn br14(&mut self) -> _BR14W { _BR14W { w: self } } #[doc = "Bit 15 - Port x Reset bit y"] #[inline] pub fn br15(&mut self) -> _BR15W { _BR15W { w: self } } } } } #[doc = "Serial peripheral interface"] 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 spi1::RegisterBlock { 0x4001_3000 as *const _ } } impl Deref for SPI1 { type Target = spi1::RegisterBlock; fn deref(&self) -> &spi1::RegisterBlock { unsafe { &*SPI1::ptr() } } } #[doc = "Serial peripheral interface"] pub mod spi1 { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, #[doc = "0x04 - control register 2"] pub cr2: CR2, #[doc = "0x08 - status register"] pub sr: SR, #[doc = "0x0c - data register"] pub dr: DR, #[doc = "0x10 - CRC polynomial register"] pub crcpr: CRCPR, #[doc = "0x14 - RX CRC register"] pub rxcrcr: RXCRCR, #[doc = "0x18 - TX CRC register"] pub txcrcr: TXCRCR, #[doc = "0x1c - I2S configuration register"] pub i2scfgr: I2SCFGR, #[doc = "0x20 - I2S prescaler register"] pub i2spr: I2SPR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BIDIMODER { bits: bool, } impl BIDIMODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIDIOER { bits: bool, } impl BIDIOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CRCENR { bits: bool, } impl CRCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CRCNEXTR { bits: bool, } impl CRCNEXTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DFFR { bits: bool, } impl DFFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXONLYR { bits: bool, } impl RXONLYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SSMR { bits: bool, } impl SSMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SSIR { bits: bool, } impl SSIR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSBFIRSTR { bits: bool, } impl LSBFIRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SPER { bits: bool, } impl SPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BRR { bits: u8, } impl BRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSTRR { bits: bool, } impl MSTRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CPOLR { bits: bool, } impl CPOLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CPHAR { bits: bool, } impl CPHAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _BIDIMODEW<'a> { w: &'a mut W, } impl<'a> _BIDIMODEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIDIOEW<'a> { w: &'a mut W, } impl<'a> _BIDIOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CRCENW<'a> { w: &'a mut W, } impl<'a> _CRCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CRCNEXTW<'a> { w: &'a mut W, } impl<'a> _CRCNEXTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DFFW<'a> { w: &'a mut W, } impl<'a> _DFFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXONLYW<'a> { w: &'a mut W, } impl<'a> _RXONLYW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SSMW<'a> { w: &'a mut W, } impl<'a> _SSMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SSIW<'a> { w: &'a mut W, } impl<'a> _SSIW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LSBFIRSTW<'a> { w: &'a mut W, } impl<'a> _LSBFIRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SPEW<'a> { w: &'a mut W, } impl<'a> _SPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BRW<'a> { w: &'a mut W, } impl<'a> _BRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSTRW<'a> { w: &'a mut W, } impl<'a> _MSTRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CPOLW<'a> { w: &'a mut W, } impl<'a> _CPOLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CPHAW<'a> { w: &'a mut W, } impl<'a> _CPHAW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Bidirectional data mode enable"] #[inline] pub fn bidimode(&self) -> BIDIMODER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIDIMODER { bits } } #[doc = "Bit 14 - Output enable in bidirectional mode"] #[inline] pub fn bidioe(&self) -> BIDIOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIDIOER { bits } } #[doc = "Bit 13 - Hardware CRC calculation enable"] #[inline] pub fn crcen(&self) -> CRCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CRCENR { bits } } #[doc = "Bit 12 - CRC transfer next"] #[inline] pub fn crcnext(&self) -> CRCNEXTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CRCNEXTR { bits } } #[doc = "Bit 11 - Data frame format"] #[inline] pub fn dff(&self) -> DFFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DFFR { bits } } #[doc = "Bit 10 - Receive only"] #[inline] pub fn rxonly(&self) -> RXONLYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXONLYR { bits } } #[doc = "Bit 9 - Software slave management"] #[inline] pub fn ssm(&self) -> SSMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SSMR { bits } } #[doc = "Bit 8 - Internal slave select"] #[inline] pub fn ssi(&self) -> SSIR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SSIR { bits } } #[doc = "Bit 7 - Frame format"] #[inline] pub fn lsbfirst(&self) -> LSBFIRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSBFIRSTR { bits } } #[doc = "Bit 6 - SPI enable"] #[inline] pub fn spe(&self) -> SPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SPER { bits } } #[doc = "Bits 3:5 - Baud rate control"] #[inline] pub fn br(&self) -> BRR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) as u8 }; BRR { bits } } #[doc = "Bit 2 - Master selection"] #[inline] pub fn mstr(&self) -> MSTRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSTRR { bits } } #[doc = "Bit 1 - Clock polarity"] #[inline] pub fn cpol(&self) -> CPOLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CPOLR { bits } } #[doc = "Bit 0 - Clock phase"] #[inline] pub fn cpha(&self) -> CPHAR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CPHAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Bidirectional data mode enable"] #[inline] pub fn bidimode(&mut self) -> _BIDIMODEW { _BIDIMODEW { w: self } } #[doc = "Bit 14 - Output enable in bidirectional mode"] #[inline] pub fn bidioe(&mut self) -> _BIDIOEW { _BIDIOEW { w: self } } #[doc = "Bit 13 - Hardware CRC calculation enable"] #[inline] pub fn crcen(&mut self) -> _CRCENW { _CRCENW { w: self } } #[doc = "Bit 12 - CRC transfer next"] #[inline] pub fn crcnext(&mut self) -> _CRCNEXTW { _CRCNEXTW { w: self } } #[doc = "Bit 11 - Data frame format"] #[inline] pub fn dff(&mut self) -> _DFFW { _DFFW { w: self } } #[doc = "Bit 10 - Receive only"] #[inline] pub fn rxonly(&mut self) -> _RXONLYW { _RXONLYW { w: self } } #[doc = "Bit 9 - Software slave management"] #[inline] pub fn ssm(&mut self) -> _SSMW { _SSMW { w: self } } #[doc = "Bit 8 - Internal slave select"] #[inline] pub fn ssi(&mut self) -> _SSIW { _SSIW { w: self } } #[doc = "Bit 7 - Frame format"] #[inline] pub fn lsbfirst(&mut self) -> _LSBFIRSTW { _LSBFIRSTW { w: self } } #[doc = "Bit 6 - SPI enable"] #[inline] pub fn spe(&mut self) -> _SPEW { _SPEW { w: self } } #[doc = "Bits 3:5 - Baud rate control"] #[inline] pub fn br(&mut self) -> _BRW { _BRW { w: self } } #[doc = "Bit 2 - Master selection"] #[inline] pub fn mstr(&mut self) -> _MSTRW { _MSTRW { w: self } } #[doc = "Bit 1 - Clock polarity"] #[inline] pub fn cpol(&mut self) -> _CPOLW { _CPOLW { w: self } } #[doc = "Bit 0 - Clock phase"] #[inline] pub fn cpha(&mut self) -> _CPHAW { _CPHAW { w: self } } } } #[doc = "control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct RXDMAENR { bits: bool, } impl RXDMAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXDMAENR { bits: bool, } impl TXDMAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SSOER { bits: bool, } impl SSOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NSSPR { bits: bool, } impl NSSPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct FRFR { bits: bool, } impl FRFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ERRIER { bits: bool, } impl ERRIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXNEIER { bits: bool, } impl RXNEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXEIER { bits: bool, } impl TXEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DSR { bits: u8, } impl DSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct FRXTHR { bits: bool, } impl FRXTHR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LDMA_RXR { bits: bool, } impl LDMA_RXR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LDMA_TXR { bits: bool, } impl LDMA_TXR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _RXDMAENW<'a> { w: &'a mut W, } impl<'a> _RXDMAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXDMAENW<'a> { w: &'a mut W, } impl<'a> _TXDMAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SSOEW<'a> { w: &'a mut W, } impl<'a> _SSOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NSSPW<'a> { w: &'a mut W, } impl<'a> _NSSPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _FRFW<'a> { w: &'a mut W, } impl<'a> _FRFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ERRIEW<'a> { w: &'a mut W, } impl<'a> _ERRIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXNEIEW<'a> { w: &'a mut W, } impl<'a> _RXNEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXEIEW<'a> { w: &'a mut W, } impl<'a> _TXEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DSW<'a> { w: &'a mut W, } impl<'a> _DSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _FRXTHW<'a> { w: &'a mut W, } impl<'a> _FRXTHW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LDMA_RXW<'a> { w: &'a mut W, } impl<'a> _LDMA_RXW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LDMA_TXW<'a> { w: &'a mut W, } impl<'a> _LDMA_TXW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Rx buffer DMA enable"] #[inline] pub fn rxdmaen(&self) -> RXDMAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXDMAENR { bits } } #[doc = "Bit 1 - Tx buffer DMA enable"] #[inline] pub fn txdmaen(&self) -> TXDMAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXDMAENR { bits } } #[doc = "Bit 2 - SS output enable"] #[inline] pub fn ssoe(&self) -> SSOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SSOER { bits } } #[doc = "Bit 3 - NSS pulse management"] #[inline] pub fn nssp(&self) -> NSSPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NSSPR { bits } } #[doc = "Bit 4 - Frame format"] #[inline] pub fn frf(&self) -> FRFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FRFR { bits } } #[doc = "Bit 5 - Error interrupt enable"] #[inline] pub fn errie(&self) -> ERRIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ERRIER { bits } } #[doc = "Bit 6 - RX buffer not empty interrupt enable"] #[inline] pub fn rxneie(&self) -> RXNEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXNEIER { bits } } #[doc = "Bit 7 - Tx buffer empty interrupt enable"] #[inline] pub fn txeie(&self) -> TXEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXEIER { bits } } #[doc = "Bits 8:11 - Data size"] #[inline] pub fn ds(&self) -> DSR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DSR { bits } } #[doc = "Bit 12 - FIFO reception threshold"] #[inline] pub fn frxth(&self) -> FRXTHR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FRXTHR { bits } } #[doc = "Bit 13 - Last DMA transfer for reception"] #[inline] pub fn ldma_rx(&self) -> LDMA_RXR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LDMA_RXR { bits } } #[doc = "Bit 14 - Last DMA transfer for transmission"] #[inline] pub fn ldma_tx(&self) -> LDMA_TXR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LDMA_TXR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Rx buffer DMA enable"] #[inline] pub fn rxdmaen(&mut self) -> _RXDMAENW { _RXDMAENW { w: self } } #[doc = "Bit 1 - Tx buffer DMA enable"] #[inline] pub fn txdmaen(&mut self) -> _TXDMAENW { _TXDMAENW { w: self } } #[doc = "Bit 2 - SS output enable"] #[inline] pub fn ssoe(&mut self) -> _SSOEW { _SSOEW { w: self } } #[doc = "Bit 3 - NSS pulse management"] #[inline] pub fn nssp(&mut self) -> _NSSPW { _NSSPW { w: self } } #[doc = "Bit 4 - Frame format"] #[inline] pub fn frf(&mut self) -> _FRFW { _FRFW { w: self } } #[doc = "Bit 5 - Error interrupt enable"] #[inline] pub fn errie(&mut self) -> _ERRIEW { _ERRIEW { w: self } } #[doc = "Bit 6 - RX buffer not empty interrupt enable"] #[inline] pub fn rxneie(&mut self) -> _RXNEIEW { _RXNEIEW { w: self } } #[doc = "Bit 7 - Tx buffer empty interrupt enable"] #[inline] pub fn txeie(&mut self) -> _TXEIEW { _TXEIEW { w: self } } #[doc = "Bits 8:11 - Data size"] #[inline] pub fn ds(&mut self) -> _DSW { _DSW { w: self } } #[doc = "Bit 12 - FIFO reception threshold"] #[inline] pub fn frxth(&mut self) -> _FRXTHW { _FRXTHW { w: self } } #[doc = "Bit 13 - Last DMA transfer for reception"] #[inline] pub fn ldma_rx(&mut self) -> _LDMA_RXW { _LDMA_RXW { w: self } } #[doc = "Bit 14 - Last DMA transfer for transmission"] #[inline] pub fn ldma_tx(&mut self) -> _LDMA_TXW { _LDMA_TXW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct RXNER { bits: bool, } impl RXNER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXER { bits: bool, } impl TXER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSIDER { bits: bool, } impl CHSIDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDRR { bits: bool, } impl UDRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CRCERRR { bits: bool, } impl CRCERRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MODFR { bits: bool, } impl MODFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVRR { bits: bool, } impl OVRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BSYR { bits: bool, } impl BSYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIFRFER { bits: bool, } impl TIFRFER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct FRLVLR { bits: u8, } impl FRLVLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct FTLVLR { bits: u8, } impl FTLVLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _CRCERRW<'a> { w: &'a mut W, } impl<'a> _CRCERRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Receive buffer not empty"] #[inline] pub fn rxne(&self) -> RXNER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXNER { bits } } #[doc = "Bit 1 - Transmit buffer empty"] #[inline] pub fn txe(&self) -> TXER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXER { bits } } #[doc = "Bit 2 - Channel side"] #[inline] pub fn chside(&self) -> CHSIDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSIDER { bits } } #[doc = "Bit 3 - Underrun flag"] #[inline] pub fn udr(&self) -> UDRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDRR { bits } } #[doc = "Bit 4 - CRC error flag"] #[inline] pub fn crcerr(&self) -> CRCERRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CRCERRR { bits } } #[doc = "Bit 5 - Mode fault"] #[inline] pub fn modf(&self) -> MODFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MODFR { bits } } #[doc = "Bit 6 - Overrun flag"] #[inline] pub fn ovr(&self) -> OVRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVRR { bits } } #[doc = "Bit 7 - Busy flag"] #[inline] pub fn bsy(&self) -> BSYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BSYR { bits } } #[doc = "Bit 8 - TI frame format error"] #[inline] pub fn tifrfe(&self) -> TIFRFER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIFRFER { bits } } #[doc = "Bits 9:10 - FIFO reception level"] #[inline] pub fn frlvl(&self) -> FRLVLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) as u8 }; FRLVLR { bits } } #[doc = "Bits 11:12 - FIFO transmission level"] #[inline] pub fn ftlvl(&self) -> FTLVLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) as u8 }; FTLVLR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x02 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 4 - CRC error flag"] #[inline] pub fn crcerr(&mut self) -> _CRCERRW { _CRCERRW { w: self } } } } #[doc = "data register"] pub struct DR { register: ::vcell::VolatileCell, } #[doc = "data register"] pub mod dr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DRR { bits: u16, } impl DRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _DRW<'a> { w: &'a mut W, } impl<'a> _DRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Data register"] #[inline] pub fn dr(&self) -> DRR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Data register"] #[inline] pub fn dr(&mut self) -> _DRW { _DRW { w: self } } } } #[doc = "CRC polynomial register"] pub struct CRCPR { register: ::vcell::VolatileCell, } #[doc = "CRC polynomial register"] pub mod crcpr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CRCPR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CRCPOLYR { bits: u16, } impl CRCPOLYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CRCPOLYW<'a> { w: &'a mut W, } impl<'a> _CRCPOLYW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - CRC polynomial register"] #[inline] pub fn crcpoly(&self) -> CRCPOLYR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CRCPOLYR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x07 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - CRC polynomial register"] #[inline] pub fn crcpoly(&mut self) -> _CRCPOLYW { _CRCPOLYW { w: self } } } } #[doc = "RX CRC register"] pub struct RXCRCR { register: ::vcell::VolatileCell, } #[doc = "RX CRC register"] pub mod rxcrcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::RXCRCR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct RXCRCR { bits: u16, } impl RXCRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Rx CRC register"] #[inline] pub fn rx_crc(&self) -> RXCRCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; RXCRCR { bits } } } } #[doc = "TX CRC register"] pub struct TXCRCR { register: ::vcell::VolatileCell, } #[doc = "TX CRC register"] pub mod txcrcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::TXCRCR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct TXCRCR { bits: u16, } impl TXCRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Tx CRC register"] #[inline] pub fn tx_crc(&self) -> TXCRCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; TXCRCR { bits } } } } #[doc = "I2S configuration register"] pub struct I2SCFGR { register: ::vcell::VolatileCell, } #[doc = "I2S configuration register"] pub mod i2scfgr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::I2SCFGR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct I2SMODR { bits: bool, } impl I2SMODR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2SER { bits: bool, } impl I2SER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2SCFGR { bits: u8, } impl I2SCFGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PCMSYNCR { bits: bool, } impl PCMSYNCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2SSTDR { bits: u8, } impl I2SSTDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CKPOLR { bits: bool, } impl CKPOLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DATLENR { bits: u8, } impl DATLENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CHLENR { bits: bool, } impl CHLENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _I2SMODW<'a> { w: &'a mut W, } impl<'a> _I2SMODW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2SEW<'a> { w: &'a mut W, } impl<'a> _I2SEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2SCFGW<'a> { w: &'a mut W, } impl<'a> _I2SCFGW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PCMSYNCW<'a> { w: &'a mut W, } impl<'a> _PCMSYNCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2SSTDW<'a> { w: &'a mut W, } impl<'a> _I2SSTDW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CKPOLW<'a> { w: &'a mut W, } impl<'a> _CKPOLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DATLENW<'a> { w: &'a mut W, } impl<'a> _DATLENW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHLENW<'a> { w: &'a mut W, } impl<'a> _CHLENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 11 - I2S mode selection"] #[inline] pub fn i2smod(&self) -> I2SMODR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2SMODR { bits } } #[doc = "Bit 10 - I2S Enable"] #[inline] pub fn i2se(&self) -> I2SER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2SER { bits } } #[doc = "Bits 8:9 - I2S configuration mode"] #[inline] pub fn i2scfg(&self) -> I2SCFGR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; I2SCFGR { bits } } #[doc = "Bit 7 - PCM frame synchronization"] #[inline] pub fn pcmsync(&self) -> PCMSYNCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PCMSYNCR { bits } } #[doc = "Bits 4:5 - I2S standard selection"] #[inline] pub fn i2sstd(&self) -> I2SSTDR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; I2SSTDR { bits } } #[doc = "Bit 3 - Steady state clock polarity"] #[inline] pub fn ckpol(&self) -> CKPOLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CKPOLR { bits } } #[doc = "Bits 1:2 - Data length to be transferred"] #[inline] pub fn datlen(&self) -> DATLENR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DATLENR { bits } } #[doc = "Bit 0 - Channel length (number of bits per audio channel)"] #[inline] pub fn chlen(&self) -> CHLENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHLENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 11 - I2S mode selection"] #[inline] pub fn i2smod(&mut self) -> _I2SMODW { _I2SMODW { w: self } } #[doc = "Bit 10 - I2S Enable"] #[inline] pub fn i2se(&mut self) -> _I2SEW { _I2SEW { w: self } } #[doc = "Bits 8:9 - I2S configuration mode"] #[inline] pub fn i2scfg(&mut self) -> _I2SCFGW { _I2SCFGW { w: self } } #[doc = "Bit 7 - PCM frame synchronization"] #[inline] pub fn pcmsync(&mut self) -> _PCMSYNCW { _PCMSYNCW { w: self } } #[doc = "Bits 4:5 - I2S standard selection"] #[inline] pub fn i2sstd(&mut self) -> _I2SSTDW { _I2SSTDW { w: self } } #[doc = "Bit 3 - Steady state clock polarity"] #[inline] pub fn ckpol(&mut self) -> _CKPOLW { _CKPOLW { w: self } } #[doc = "Bits 1:2 - Data length to be transferred"] #[inline] pub fn datlen(&mut self) -> _DATLENW { _DATLENW { w: self } } #[doc = "Bit 0 - Channel length (number of bits per audio channel)"] #[inline] pub fn chlen(&mut self) -> _CHLENW { _CHLENW { w: self } } } } #[doc = "I2S prescaler register"] pub struct I2SPR { register: ::vcell::VolatileCell, } #[doc = "I2S prescaler register"] pub mod i2spr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::I2SPR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MCKOER { bits: bool, } impl MCKOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ODDR { bits: bool, } impl ODDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2SDIVR { bits: u8, } impl I2SDIVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MCKOEW<'a> { w: &'a mut W, } impl<'a> _MCKOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ODDW<'a> { w: &'a mut W, } impl<'a> _ODDW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2SDIVW<'a> { w: &'a mut W, } impl<'a> _I2SDIVW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Master clock output enable"] #[inline] pub fn mckoe(&self) -> MCKOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MCKOER { bits } } #[doc = "Bit 8 - Odd factor for the prescaler"] #[inline] pub fn odd(&self) -> ODDR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ODDR { bits } } #[doc = "Bits 0:7 - I2S Linear prescaler"] #[inline] pub fn i2sdiv(&self) -> I2SDIVR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; I2SDIVR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x10 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Master clock output enable"] #[inline] pub fn mckoe(&mut self) -> _MCKOEW { _MCKOEW { w: self } } #[doc = "Bit 8 - Odd factor for the prescaler"] #[inline] pub fn odd(&mut self) -> _ODDW { _ODDW { w: self } } #[doc = "Bits 0:7 - I2S Linear prescaler"] #[inline] pub fn i2sdiv(&mut self) -> _I2SDIVW { _I2SDIVW { w: self } } } } } #[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 spi1::RegisterBlock { 0x4000_3800 as *const _ } } impl Deref for SPI2 { type Target = spi1::RegisterBlock; fn deref(&self) -> &spi1::RegisterBlock { unsafe { &*SPI2::ptr() } } } #[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 { 0x4000_7000 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - power control register"] pub cr: CR, #[doc = "0x04 - power control/status register"] pub csr: CSR, } #[doc = "power control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "power control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct FPDSR { bits: bool, } impl FPDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBPR { bits: bool, } impl DBPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLSR { bits: u8, } impl PLSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PVDER { bits: bool, } impl PVDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CSBFR { bits: bool, } impl CSBFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CWUFR { bits: bool, } impl CWUFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PDDSR { bits: bool, } impl PDDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LPDSR { bits: bool, } impl LPDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _FPDSW<'a> { w: &'a mut W, } impl<'a> _FPDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBPW<'a> { w: &'a mut W, } impl<'a> _DBPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLSW<'a> { w: &'a mut W, } impl<'a> _PLSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PVDEW<'a> { w: &'a mut W, } impl<'a> _PVDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CSBFW<'a> { w: &'a mut W, } impl<'a> _CSBFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CWUFW<'a> { w: &'a mut W, } impl<'a> _CWUFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PDDSW<'a> { w: &'a mut W, } impl<'a> _PDDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LPDSW<'a> { w: &'a mut W, } impl<'a> _LPDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Flash power down in Stop mode"] #[inline] pub fn fpds(&self) -> FPDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FPDSR { bits } } #[doc = "Bit 8 - Disable backup domain write protection"] #[inline] pub fn dbp(&self) -> DBPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBPR { bits } } #[doc = "Bits 5:7 - PVD level selection"] #[inline] pub fn pls(&self) -> PLSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLSR { bits } } #[doc = "Bit 4 - Power voltage detector enable"] #[inline] pub fn pvde(&self) -> PVDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PVDER { bits } } #[doc = "Bit 3 - Clear standby flag"] #[inline] pub fn csbf(&self) -> CSBFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CSBFR { bits } } #[doc = "Bit 2 - Clear wakeup flag"] #[inline] pub fn cwuf(&self) -> CWUFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CWUFR { bits } } #[doc = "Bit 1 - Power down deepsleep"] #[inline] pub fn pdds(&self) -> PDDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PDDSR { bits } } #[doc = "Bit 0 - Low-power deep sleep"] #[inline] pub fn lpds(&self) -> LPDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LPDSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Flash power down in Stop mode"] #[inline] pub fn fpds(&mut self) -> _FPDSW { _FPDSW { w: self } } #[doc = "Bit 8 - Disable backup domain write protection"] #[inline] pub fn dbp(&mut self) -> _DBPW { _DBPW { w: self } } #[doc = "Bits 5:7 - PVD level selection"] #[inline] pub fn pls(&mut self) -> _PLSW { _PLSW { w: self } } #[doc = "Bit 4 - Power voltage detector enable"] #[inline] pub fn pvde(&mut self) -> _PVDEW { _PVDEW { w: self } } #[doc = "Bit 3 - Clear standby flag"] #[inline] pub fn csbf(&mut self) -> _CSBFW { _CSBFW { w: self } } #[doc = "Bit 2 - Clear wakeup flag"] #[inline] pub fn cwuf(&mut self) -> _CWUFW { _CWUFW { w: self } } #[doc = "Bit 1 - Power down deepsleep"] #[inline] pub fn pdds(&mut self) -> _PDDSW { _PDDSW { w: self } } #[doc = "Bit 0 - Low-power deep sleep"] #[inline] pub fn lpds(&mut self) -> _LPDSW { _LPDSW { w: self } } } } #[doc = "power control/status register"] pub struct CSR { register: ::vcell::VolatileCell, } #[doc = "power control/status register"] pub mod csr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CSR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BRER { bits: bool, } impl BRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EWUPR { bits: bool, } impl EWUPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BRRR { bits: bool, } impl BRRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PVDOR { bits: bool, } impl PVDOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SBFR { bits: bool, } impl SBFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WUFR { bits: bool, } impl WUFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _BREW<'a> { w: &'a mut W, } impl<'a> _BREW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EWUPW<'a> { w: &'a mut W, } impl<'a> _EWUPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Backup regulator enable"] #[inline] pub fn bre(&self) -> BRER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BRER { bits } } #[doc = "Bit 8 - Enable WKUP pin"] #[inline] pub fn ewup(&self) -> EWUPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EWUPR { bits } } #[doc = "Bit 3 - Backup regulator ready"] #[inline] pub fn brr(&self) -> BRRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BRRR { bits } } #[doc = "Bit 2 - PVD output"] #[inline] pub fn pvdo(&self) -> PVDOR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PVDOR { bits } } #[doc = "Bit 1 - Standby flag"] #[inline] pub fn sbf(&self) -> SBFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SBFR { bits } } #[doc = "Bit 0 - Wakeup flag"] #[inline] pub fn wuf(&self) -> WUFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WUFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Backup regulator enable"] #[inline] pub fn bre(&mut self) -> _BREW { _BREW { w: self } } #[doc = "Bit 8 - Enable WKUP pin"] #[inline] pub fn ewup(&mut self) -> _EWUPW { _EWUPW { w: self } } } } } #[doc = "Inter-integrated circuit"] 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 i2c1::RegisterBlock { 0x4000_5400 as *const _ } } impl Deref for I2C1 { type Target = i2c1::RegisterBlock; fn deref(&self) -> &i2c1::RegisterBlock { unsafe { &*I2C1::ptr() } } } #[doc = "Inter-integrated circuit"] pub mod i2c1 { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Control register 1"] pub cr1: CR1, #[doc = "0x04 - Control register 2"] pub cr2: CR2, #[doc = "0x08 - Own address register 1"] pub oar1: OAR1, #[doc = "0x0c - Own address register 2"] pub oar2: OAR2, #[doc = "0x10 - Timing register"] pub timingr: TIMINGR, #[doc = "0x14 - Status register 1"] pub timeoutr: TIMEOUTR, #[doc = "0x18 - Interrupt and Status register"] pub isr: ISR, #[doc = "0x1c - Interrupt clear register"] pub icr: ICR, #[doc = "0x20 - PEC register"] pub pecr: PECR, #[doc = "0x24 - Receive data register"] pub rxdr: RXDR, #[doc = "0x28 - Transmit data register"] pub txdr: TXDR, } #[doc = "Control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "Control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PER { bits: bool, } impl PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXIER { bits: bool, } impl TXIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXIER { bits: bool, } impl RXIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADDRIER { bits: bool, } impl ADDRIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NACKIER { bits: bool, } impl NACKIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STOPIER { bits: bool, } impl STOPIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ERRIER { bits: bool, } impl ERRIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DNFR { bits: u8, } impl DNFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ANFOFFR { bits: bool, } impl ANFOFFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXDMAENR { bits: bool, } impl TXDMAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXDMAENR { bits: bool, } impl RXDMAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SBCR { bits: bool, } impl SBCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NOSTRETCHR { bits: bool, } impl NOSTRETCHR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WUPENR { bits: bool, } impl WUPENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GCENR { bits: bool, } impl GCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SMBHENR { bits: bool, } impl SMBHENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SMBDENR { bits: bool, } impl SMBDENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ALERTENR { bits: bool, } impl ALERTENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PECENR { bits: bool, } impl PECENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _PEW<'a> { w: &'a mut W, } impl<'a> _PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXIEW<'a> { w: &'a mut W, } impl<'a> _TXIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXIEW<'a> { w: &'a mut W, } impl<'a> _RXIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADDRIEW<'a> { w: &'a mut W, } impl<'a> _ADDRIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NACKIEW<'a> { w: &'a mut W, } impl<'a> _NACKIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STOPIEW<'a> { w: &'a mut W, } impl<'a> _STOPIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ERRIEW<'a> { w: &'a mut W, } impl<'a> _ERRIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DNFW<'a> { w: &'a mut W, } impl<'a> _DNFW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ANFOFFW<'a> { w: &'a mut W, } impl<'a> _ANFOFFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWRSTW<'a> { w: &'a mut W, } impl<'a> _SWRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXDMAENW<'a> { w: &'a mut W, } impl<'a> _TXDMAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXDMAENW<'a> { w: &'a mut W, } impl<'a> _RXDMAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SBCW<'a> { w: &'a mut W, } impl<'a> _SBCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NOSTRETCHW<'a> { w: &'a mut W, } impl<'a> _NOSTRETCHW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WUPENW<'a> { w: &'a mut W, } impl<'a> _WUPENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _GCENW<'a> { w: &'a mut W, } impl<'a> _GCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SMBHENW<'a> { w: &'a mut W, } impl<'a> _SMBHENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SMBDENW<'a> { w: &'a mut W, } impl<'a> _SMBDENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ALERTENW<'a> { w: &'a mut W, } impl<'a> _ALERTENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PECENW<'a> { w: &'a mut W, } impl<'a> _PECENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Peripheral enable"] #[inline] pub fn pe(&self) -> PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PER { bits } } #[doc = "Bit 1 - TX Interrupt enable"] #[inline] pub fn txie(&self) -> TXIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXIER { bits } } #[doc = "Bit 2 - RX Interrupt enable"] #[inline] pub fn rxie(&self) -> RXIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXIER { bits } } #[doc = "Bit 3 - Address match interrupt enable (slave only)"] #[inline] pub fn addrie(&self) -> ADDRIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADDRIER { bits } } #[doc = "Bit 4 - Not acknowledge received interrupt enable"] #[inline] pub fn nackie(&self) -> NACKIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NACKIER { bits } } #[doc = "Bit 5 - STOP detection Interrupt enable"] #[inline] pub fn stopie(&self) -> STOPIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; STOPIER { bits } } #[doc = "Bit 6 - Transfer Complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 7 - Error interrupts enable"] #[inline] pub fn errie(&self) -> ERRIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ERRIER { bits } } #[doc = "Bits 8:11 - Digital noise filter"] #[inline] pub fn dnf(&self) -> DNFR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DNFR { bits } } #[doc = "Bit 12 - Analog noise filter OFF"] #[inline] pub fn anfoff(&self) -> ANFOFFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ANFOFFR { bits } } #[doc = "Bit 14 - DMA transmission requests enable"] #[inline] pub fn txdmaen(&self) -> TXDMAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXDMAENR { bits } } #[doc = "Bit 15 - DMA reception requests enable"] #[inline] pub fn rxdmaen(&self) -> RXDMAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXDMAENR { bits } } #[doc = "Bit 16 - Slave byte control"] #[inline] pub fn sbc(&self) -> SBCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SBCR { bits } } #[doc = "Bit 17 - Clock stretching disable"] #[inline] pub fn nostretch(&self) -> NOSTRETCHR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NOSTRETCHR { bits } } #[doc = "Bit 18 - Wakeup from STOP enable"] #[inline] pub fn wupen(&self) -> WUPENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WUPENR { bits } } #[doc = "Bit 19 - General call enable"] #[inline] pub fn gcen(&self) -> GCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GCENR { bits } } #[doc = "Bit 20 - SMBus Host address enable"] #[inline] pub fn smbhen(&self) -> SMBHENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SMBHENR { bits } } #[doc = "Bit 21 - SMBus Device Default address enable"] #[inline] pub fn smbden(&self) -> SMBDENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SMBDENR { bits } } #[doc = "Bit 22 - SMBUS alert enable"] #[inline] pub fn alerten(&self) -> ALERTENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALERTENR { bits } } #[doc = "Bit 23 - PEC enable"] #[inline] pub fn pecen(&self) -> PECENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PECENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Peripheral enable"] #[inline] pub fn pe(&mut self) -> _PEW { _PEW { w: self } } #[doc = "Bit 1 - TX Interrupt enable"] #[inline] pub fn txie(&mut self) -> _TXIEW { _TXIEW { w: self } } #[doc = "Bit 2 - RX Interrupt enable"] #[inline] pub fn rxie(&mut self) -> _RXIEW { _RXIEW { w: self } } #[doc = "Bit 3 - Address match interrupt enable (slave only)"] #[inline] pub fn addrie(&mut self) -> _ADDRIEW { _ADDRIEW { w: self } } #[doc = "Bit 4 - Not acknowledge received interrupt enable"] #[inline] pub fn nackie(&mut self) -> _NACKIEW { _NACKIEW { w: self } } #[doc = "Bit 5 - STOP detection Interrupt enable"] #[inline] pub fn stopie(&mut self) -> _STOPIEW { _STOPIEW { w: self } } #[doc = "Bit 6 - Transfer Complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 7 - Error interrupts enable"] #[inline] pub fn errie(&mut self) -> _ERRIEW { _ERRIEW { w: self } } #[doc = "Bits 8:11 - Digital noise filter"] #[inline] pub fn dnf(&mut self) -> _DNFW { _DNFW { w: self } } #[doc = "Bit 12 - Analog noise filter OFF"] #[inline] pub fn anfoff(&mut self) -> _ANFOFFW { _ANFOFFW { w: self } } #[doc = "Bit 13 - Software reset"] #[inline] pub fn swrst(&mut self) -> _SWRSTW { _SWRSTW { w: self } } #[doc = "Bit 14 - DMA transmission requests enable"] #[inline] pub fn txdmaen(&mut self) -> _TXDMAENW { _TXDMAENW { w: self } } #[doc = "Bit 15 - DMA reception requests enable"] #[inline] pub fn rxdmaen(&mut self) -> _RXDMAENW { _RXDMAENW { w: self } } #[doc = "Bit 16 - Slave byte control"] #[inline] pub fn sbc(&mut self) -> _SBCW { _SBCW { w: self } } #[doc = "Bit 17 - Clock stretching disable"] #[inline] pub fn nostretch(&mut self) -> _NOSTRETCHW { _NOSTRETCHW { w: self } } #[doc = "Bit 18 - Wakeup from STOP enable"] #[inline] pub fn wupen(&mut self) -> _WUPENW { _WUPENW { w: self } } #[doc = "Bit 19 - General call enable"] #[inline] pub fn gcen(&mut self) -> _GCENW { _GCENW { w: self } } #[doc = "Bit 20 - SMBus Host address enable"] #[inline] pub fn smbhen(&mut self) -> _SMBHENW { _SMBHENW { w: self } } #[doc = "Bit 21 - SMBus Device Default address enable"] #[inline] pub fn smbden(&mut self) -> _SMBDENW { _SMBDENW { w: self } } #[doc = "Bit 22 - SMBUS alert enable"] #[inline] pub fn alerten(&mut self) -> _ALERTENW { _ALERTENW { w: self } } #[doc = "Bit 23 - PEC enable"] #[inline] pub fn pecen(&mut self) -> _PECENW { _PECENW { w: self } } } } #[doc = "Control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "Control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PECBYTER { bits: bool, } impl PECBYTER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AUTOENDR { bits: bool, } impl AUTOENDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RELOADR { bits: bool, } impl RELOADR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NBYTESR { bits: u8, } impl NBYTESR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct NACKR { bits: bool, } impl NACKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STOPR { bits: bool, } impl STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STARTR { bits: bool, } impl STARTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HEAD10RR { bits: bool, } impl HEAD10RR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADD10R { bits: bool, } impl ADD10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RD_WRNR { bits: bool, } impl RD_WRNR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SADD8R { bits: u8, } impl SADD8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SADD1R { bits: u8, } impl SADD1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SADD0R { bits: bool, } impl SADD0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _PECBYTEW<'a> { w: &'a mut W, } impl<'a> _PECBYTEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AUTOENDW<'a> { w: &'a mut W, } impl<'a> _AUTOENDW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RELOADW<'a> { w: &'a mut W, } impl<'a> _RELOADW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NBYTESW<'a> { w: &'a mut W, } impl<'a> _NBYTESW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NACKW<'a> { w: &'a mut W, } impl<'a> _NACKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STOPW<'a> { w: &'a mut W, } impl<'a> _STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STARTW<'a> { w: &'a mut W, } impl<'a> _STARTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HEAD10RW<'a> { w: &'a mut W, } impl<'a> _HEAD10RW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADD10W<'a> { w: &'a mut W, } impl<'a> _ADD10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RD_WRNW<'a> { w: &'a mut W, } impl<'a> _RD_WRNW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SADD8W<'a> { w: &'a mut W, } impl<'a> _SADD8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SADD1W<'a> { w: &'a mut W, } impl<'a> _SADD1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x7f; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SADD0W<'a> { w: &'a mut W, } impl<'a> _SADD0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 26 - Packet error checking byte"] #[inline] pub fn pecbyte(&self) -> PECBYTER { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PECBYTER { bits } } #[doc = "Bit 25 - Automatic end mode (master mode)"] #[inline] pub fn autoend(&self) -> AUTOENDR { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AUTOENDR { bits } } #[doc = "Bit 24 - NBYTES reload mode"] #[inline] pub fn reload(&self) -> RELOADR { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RELOADR { bits } } #[doc = "Bits 16:23 - Number of bytes"] #[inline] pub fn nbytes(&self) -> NBYTESR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; NBYTESR { bits } } #[doc = "Bit 15 - NACK generation (slave mode)"] #[inline] pub fn nack(&self) -> NACKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NACKR { bits } } #[doc = "Bit 14 - Stop generation (master mode)"] #[inline] pub fn stop(&self) -> STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; STOPR { bits } } #[doc = "Bit 13 - Start generation"] #[inline] pub fn start(&self) -> STARTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; STARTR { bits } } #[doc = "Bit 12 - 10-bit address header only read direction (master receiver mode)"] #[inline] pub fn head10r(&self) -> HEAD10RR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HEAD10RR { bits } } #[doc = "Bit 11 - 10-bit addressing mode (master mode)"] #[inline] pub fn add10(&self) -> ADD10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADD10R { bits } } #[doc = "Bit 10 - Transfer direction (master mode)"] #[inline] pub fn rd_wrn(&self) -> RD_WRNR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RD_WRNR { bits } } #[doc = "Bits 8:9 - Slave address bit 9:8 (master mode)"] #[inline] pub fn sadd8(&self) -> SADD8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SADD8R { bits } } #[doc = "Bits 1:7 - Slave address bit 7:1 (master mode)"] #[inline] pub fn sadd1(&self) -> SADD1R { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SADD1R { bits } } #[doc = "Bit 0 - Slave address bit 0 (master mode)"] #[inline] pub fn sadd0(&self) -> SADD0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SADD0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 26 - Packet error checking byte"] #[inline] pub fn pecbyte(&mut self) -> _PECBYTEW { _PECBYTEW { w: self } } #[doc = "Bit 25 - Automatic end mode (master mode)"] #[inline] pub fn autoend(&mut self) -> _AUTOENDW { _AUTOENDW { w: self } } #[doc = "Bit 24 - NBYTES reload mode"] #[inline] pub fn reload(&mut self) -> _RELOADW { _RELOADW { w: self } } #[doc = "Bits 16:23 - Number of bytes"] #[inline] pub fn nbytes(&mut self) -> _NBYTESW { _NBYTESW { w: self } } #[doc = "Bit 15 - NACK generation (slave mode)"] #[inline] pub fn nack(&mut self) -> _NACKW { _NACKW { w: self } } #[doc = "Bit 14 - Stop generation (master mode)"] #[inline] pub fn stop(&mut self) -> _STOPW { _STOPW { w: self } } #[doc = "Bit 13 - Start generation"] #[inline] pub fn start(&mut self) -> _STARTW { _STARTW { w: self } } #[doc = "Bit 12 - 10-bit address header only read direction (master receiver mode)"] #[inline] pub fn head10r(&mut self) -> _HEAD10RW { _HEAD10RW { w: self } } #[doc = "Bit 11 - 10-bit addressing mode (master mode)"] #[inline] pub fn add10(&mut self) -> _ADD10W { _ADD10W { w: self } } #[doc = "Bit 10 - Transfer direction (master mode)"] #[inline] pub fn rd_wrn(&mut self) -> _RD_WRNW { _RD_WRNW { w: self } } #[doc = "Bits 8:9 - Slave address bit 9:8 (master mode)"] #[inline] pub fn sadd8(&mut self) -> _SADD8W { _SADD8W { w: self } } #[doc = "Bits 1:7 - Slave address bit 7:1 (master mode)"] #[inline] pub fn sadd1(&mut self) -> _SADD1W { _SADD1W { w: self } } #[doc = "Bit 0 - Slave address bit 0 (master mode)"] #[inline] pub fn sadd0(&mut self) -> _SADD0W { _SADD0W { w: self } } } } #[doc = "Own address register 1"] pub struct OAR1 { register: ::vcell::VolatileCell, } #[doc = "Own address register 1"] pub mod oar1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OAR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OA1_0R { bits: bool, } impl OA1_0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OA1_1R { bits: u8, } impl OA1_1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OA1_8R { bits: u8, } impl OA1_8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OA1MODER { bits: bool, } impl OA1MODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OA1ENR { bits: bool, } impl OA1ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OA1_0W<'a> { w: &'a mut W, } impl<'a> _OA1_0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OA1_1W<'a> { w: &'a mut W, } impl<'a> _OA1_1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x7f; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OA1_8W<'a> { w: &'a mut W, } impl<'a> _OA1_8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OA1MODEW<'a> { w: &'a mut W, } impl<'a> _OA1MODEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OA1ENW<'a> { w: &'a mut W, } impl<'a> _OA1ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Interface address"] #[inline] pub fn oa1_0(&self) -> OA1_0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OA1_0R { bits } } #[doc = "Bits 1:7 - Interface address"] #[inline] pub fn oa1_1(&self) -> OA1_1R { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OA1_1R { bits } } #[doc = "Bits 8:9 - Interface address"] #[inline] pub fn oa1_8(&self) -> OA1_8R { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OA1_8R { bits } } #[doc = "Bit 10 - Own Address 1 10-bit mode"] #[inline] pub fn oa1mode(&self) -> OA1MODER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OA1MODER { bits } } #[doc = "Bit 15 - Own Address 1 enable"] #[inline] pub fn oa1en(&self) -> OA1ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OA1ENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Interface address"] #[inline] pub fn oa1_0(&mut self) -> _OA1_0W { _OA1_0W { w: self } } #[doc = "Bits 1:7 - Interface address"] #[inline] pub fn oa1_1(&mut self) -> _OA1_1W { _OA1_1W { w: self } } #[doc = "Bits 8:9 - Interface address"] #[inline] pub fn oa1_8(&mut self) -> _OA1_8W { _OA1_8W { w: self } } #[doc = "Bit 10 - Own Address 1 10-bit mode"] #[inline] pub fn oa1mode(&mut self) -> _OA1MODEW { _OA1MODEW { w: self } } #[doc = "Bit 15 - Own Address 1 enable"] #[inline] pub fn oa1en(&mut self) -> _OA1ENW { _OA1ENW { w: self } } } } #[doc = "Own address register 2"] pub struct OAR2 { register: ::vcell::VolatileCell, } #[doc = "Own address register 2"] pub mod oar2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OAR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OA2R { bits: u8, } impl OA2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OA2MSKR { bits: u8, } impl OA2MSKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OA2ENR { bits: bool, } impl OA2ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OA2W<'a> { w: &'a mut W, } impl<'a> _OA2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x7f; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OA2MSKW<'a> { w: &'a mut W, } impl<'a> _OA2MSKW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OA2ENW<'a> { w: &'a mut W, } impl<'a> _OA2ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 1:7 - Interface address"] #[inline] pub fn oa2(&self) -> OA2R { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OA2R { bits } } #[doc = "Bits 8:10 - Own Address 2 masks"] #[inline] pub fn oa2msk(&self) -> OA2MSKR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OA2MSKR { bits } } #[doc = "Bit 15 - Own Address 2 enable"] #[inline] pub fn oa2en(&self) -> OA2ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OA2ENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 1:7 - Interface address"] #[inline] pub fn oa2(&mut self) -> _OA2W { _OA2W { w: self } } #[doc = "Bits 8:10 - Own Address 2 masks"] #[inline] pub fn oa2msk(&mut self) -> _OA2MSKW { _OA2MSKW { w: self } } #[doc = "Bit 15 - Own Address 2 enable"] #[inline] pub fn oa2en(&mut self) -> _OA2ENW { _OA2ENW { w: self } } } } #[doc = "Timing register"] pub struct TIMINGR { register: ::vcell::VolatileCell, } #[doc = "Timing register"] pub mod timingr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TIMINGR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SCLLR { bits: u8, } impl SCLLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SCLHR { bits: u8, } impl SCLHR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SDADELR { bits: u8, } impl SDADELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SCLDELR { bits: u8, } impl SCLDELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PRESCR { bits: u8, } impl PRESCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _SCLLW<'a> { w: &'a mut W, } impl<'a> _SCLLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SCLHW<'a> { w: &'a mut W, } impl<'a> _SCLHW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SDADELW<'a> { w: &'a mut W, } impl<'a> _SDADELW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SCLDELW<'a> { w: &'a mut W, } impl<'a> _SCLDELW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PRESCW<'a> { w: &'a mut W, } impl<'a> _PRESCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - SCL low period (master mode)"] #[inline] pub fn scll(&self) -> SCLLR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SCLLR { bits } } #[doc = "Bits 8:15 - SCL high period (master mode)"] #[inline] pub fn sclh(&self) -> SCLHR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SCLHR { bits } } #[doc = "Bits 16:19 - Data hold time"] #[inline] pub fn sdadel(&self) -> SDADELR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SDADELR { bits } } #[doc = "Bits 20:23 - Data setup time"] #[inline] pub fn scldel(&self) -> SCLDELR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SCLDELR { bits } } #[doc = "Bits 28:31 - Timing prescaler"] #[inline] pub fn presc(&self) -> PRESCR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PRESCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - SCL low period (master mode)"] #[inline] pub fn scll(&mut self) -> _SCLLW { _SCLLW { w: self } } #[doc = "Bits 8:15 - SCL high period (master mode)"] #[inline] pub fn sclh(&mut self) -> _SCLHW { _SCLHW { w: self } } #[doc = "Bits 16:19 - Data hold time"] #[inline] pub fn sdadel(&mut self) -> _SDADELW { _SDADELW { w: self } } #[doc = "Bits 20:23 - Data setup time"] #[inline] pub fn scldel(&mut self) -> _SCLDELW { _SCLDELW { w: self } } #[doc = "Bits 28:31 - Timing prescaler"] #[inline] pub fn presc(&mut self) -> _PRESCW { _PRESCW { w: self } } } } #[doc = "Status register 1"] pub struct TIMEOUTR { register: ::vcell::VolatileCell, } #[doc = "Status register 1"] pub mod timeoutr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TIMEOUTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TIMEOUTAR { bits: u16, } impl TIMEOUTAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct TIDLER { bits: bool, } impl TIDLER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIMOUTENR { bits: bool, } impl TIMOUTENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIMEOUTBR { bits: u16, } impl TIMEOUTBR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct TEXTENR { bits: bool, } impl TEXTENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TIMEOUTAW<'a> { w: &'a mut W, } impl<'a> _TIMEOUTAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIDLEW<'a> { w: &'a mut W, } impl<'a> _TIDLEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIMOUTENW<'a> { w: &'a mut W, } impl<'a> _TIMOUTENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIMEOUTBW<'a> { w: &'a mut W, } impl<'a> _TIMEOUTBW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEXTENW<'a> { w: &'a mut W, } impl<'a> _TEXTENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:11 - Bus timeout A"] #[inline] pub fn timeouta(&self) -> TIMEOUTAR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; TIMEOUTAR { bits } } #[doc = "Bit 12 - Idle clock timeout detection"] #[inline] pub fn tidle(&self) -> TIDLER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIDLER { bits } } #[doc = "Bit 15 - Clock timeout enable"] #[inline] pub fn timouten(&self) -> TIMOUTENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIMOUTENR { bits } } #[doc = "Bits 16:27 - Bus timeout B"] #[inline] pub fn timeoutb(&self) -> TIMEOUTBR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; TIMEOUTBR { bits } } #[doc = "Bit 31 - Extended clock timeout enable"] #[inline] pub fn texten(&self) -> TEXTENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 31; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEXTENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:11 - Bus timeout A"] #[inline] pub fn timeouta(&mut self) -> _TIMEOUTAW { _TIMEOUTAW { w: self } } #[doc = "Bit 12 - Idle clock timeout detection"] #[inline] pub fn tidle(&mut self) -> _TIDLEW { _TIDLEW { w: self } } #[doc = "Bit 15 - Clock timeout enable"] #[inline] pub fn timouten(&mut self) -> _TIMOUTENW { _TIMOUTENW { w: self } } #[doc = "Bits 16:27 - Bus timeout B"] #[inline] pub fn timeoutb(&mut self) -> _TIMEOUTBW { _TIMEOUTBW { w: self } } #[doc = "Bit 31 - Extended clock timeout enable"] #[inline] pub fn texten(&mut self) -> _TEXTENW { _TEXTENW { w: self } } } } #[doc = "Interrupt and Status register"] pub struct ISR { register: ::vcell::VolatileCell, } #[doc = "Interrupt and Status register"] pub mod isr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ISR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ADDCODER { bits: u8, } impl ADDCODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BUSYR { bits: bool, } impl BUSYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ALERTR { bits: bool, } impl ALERTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIMEOUTR { bits: bool, } impl TIMEOUTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PECERRR { bits: bool, } impl PECERRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVRR { bits: bool, } impl OVRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ARLOR { bits: bool, } impl ARLOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BERRR { bits: bool, } impl BERRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCRR { bits: bool, } impl TCRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCR { bits: bool, } impl TCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STOPFR { bits: bool, } impl STOPFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NACKFR { bits: bool, } impl NACKFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADDRR { bits: bool, } impl ADDRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXNER { bits: bool, } impl RXNER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXISR { bits: bool, } impl TXISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXER { bits: bool, } impl TXER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TXISW<'a> { w: &'a mut W, } impl<'a> _TXISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXEW<'a> { w: &'a mut W, } impl<'a> _TXEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 17:23 - Address match code (Slave mode)"] #[inline] pub fn addcode(&self) -> ADDCODER { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ADDCODER { bits } } #[doc = "Bit 16 - Transfer direction (Slave mode)"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 15 - Bus busy"] #[inline] pub fn busy(&self) -> BUSYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BUSYR { bits } } #[doc = "Bit 13 - SMBus alert"] #[inline] pub fn alert(&self) -> ALERTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALERTR { bits } } #[doc = "Bit 12 - Timeout or t_low detection flag"] #[inline] pub fn timeout(&self) -> TIMEOUTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIMEOUTR { bits } } #[doc = "Bit 11 - PEC Error in reception"] #[inline] pub fn pecerr(&self) -> PECERRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PECERRR { bits } } #[doc = "Bit 10 - Overrun/Underrun (slave mode)"] #[inline] pub fn ovr(&self) -> OVRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVRR { bits } } #[doc = "Bit 9 - Arbitration lost"] #[inline] pub fn arlo(&self) -> ARLOR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARLOR { bits } } #[doc = "Bit 8 - Bus error"] #[inline] pub fn berr(&self) -> BERRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BERRR { bits } } #[doc = "Bit 7 - Transfer Complete Reload"] #[inline] pub fn tcr(&self) -> TCRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCRR { bits } } #[doc = "Bit 6 - Transfer Complete (master mode)"] #[inline] pub fn tc(&self) -> TCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCR { bits } } #[doc = "Bit 5 - Stop detection flag"] #[inline] pub fn stopf(&self) -> STOPFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; STOPFR { bits } } #[doc = "Bit 4 - Not acknowledge received flag"] #[inline] pub fn nackf(&self) -> NACKFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NACKFR { bits } } #[doc = "Bit 3 - Address matched (slave mode)"] #[inline] pub fn addr(&self) -> ADDRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADDRR { bits } } #[doc = "Bit 2 - Receive data register not empty (receivers)"] #[inline] pub fn rxne(&self) -> RXNER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXNER { bits } } #[doc = "Bit 1 - Transmit interrupt status (transmitters)"] #[inline] pub fn txis(&self) -> TXISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXISR { bits } } #[doc = "Bit 0 - Transmit data register empty (transmitters)"] #[inline] pub fn txe(&self) -> TXER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x01 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 1 - Transmit interrupt status (transmitters)"] #[inline] pub fn txis(&mut self) -> _TXISW { _TXISW { w: self } } #[doc = "Bit 0 - Transmit data register empty (transmitters)"] #[inline] pub fn txe(&mut self) -> _TXEW { _TXEW { w: self } } } } #[doc = "Interrupt clear register"] pub struct ICR { register: ::vcell::VolatileCell, } #[doc = "Interrupt clear register"] pub mod icr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ICR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _ALERTCFW<'a> { w: &'a mut W, } impl<'a> _ALERTCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIMOUTCFW<'a> { w: &'a mut W, } impl<'a> _TIMOUTCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PECCFW<'a> { w: &'a mut W, } impl<'a> _PECCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OVRCFW<'a> { w: &'a mut W, } impl<'a> _OVRCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARLOCFW<'a> { w: &'a mut W, } impl<'a> _ARLOCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BERRCFW<'a> { w: &'a mut W, } impl<'a> _BERRCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STOPCFW<'a> { w: &'a mut W, } impl<'a> _STOPCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NACKCFW<'a> { w: &'a mut W, } impl<'a> _NACKCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADDRCFW<'a> { w: &'a mut W, } impl<'a> _ADDRCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 13 - Alert flag clear"] #[inline] pub fn alertcf(&mut self) -> _ALERTCFW { _ALERTCFW { w: self } } #[doc = "Bit 12 - Timeout detection flag clear"] #[inline] pub fn timoutcf(&mut self) -> _TIMOUTCFW { _TIMOUTCFW { w: self } } #[doc = "Bit 11 - PEC Error flag clear"] #[inline] pub fn peccf(&mut self) -> _PECCFW { _PECCFW { w: self } } #[doc = "Bit 10 - Overrun/Underrun flag clear"] #[inline] pub fn ovrcf(&mut self) -> _OVRCFW { _OVRCFW { w: self } } #[doc = "Bit 9 - Arbitration lost flag clear"] #[inline] pub fn arlocf(&mut self) -> _ARLOCFW { _ARLOCFW { w: self } } #[doc = "Bit 8 - Bus error flag clear"] #[inline] pub fn berrcf(&mut self) -> _BERRCFW { _BERRCFW { w: self } } #[doc = "Bit 5 - Stop detection flag clear"] #[inline] pub fn stopcf(&mut self) -> _STOPCFW { _STOPCFW { w: self } } #[doc = "Bit 4 - Not Acknowledge flag clear"] #[inline] pub fn nackcf(&mut self) -> _NACKCFW { _NACKCFW { w: self } } #[doc = "Bit 3 - Address Matched flag clear"] #[inline] pub fn addrcf(&mut self) -> _ADDRCFW { _ADDRCFW { w: self } } } } #[doc = "PEC register"] pub struct PECR { register: ::vcell::VolatileCell, } #[doc = "PEC register"] pub mod pecr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::PECR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct PECR { bits: u8, } impl PECR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - Packet error checking register"] #[inline] pub fn pec(&self) -> PECR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PECR { bits } } } } #[doc = "Receive data register"] pub struct RXDR { register: ::vcell::VolatileCell, } #[doc = "Receive data register"] pub mod rxdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::RXDR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct RXDATAR { bits: u8, } impl RXDATAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - 8-bit receive data"] #[inline] pub fn rxdata(&self) -> RXDATAR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; RXDATAR { bits } } } } #[doc = "Transmit data register"] pub struct TXDR { register: ::vcell::VolatileCell, } #[doc = "Transmit data register"] pub mod txdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TXDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TXDATAR { bits: u8, } impl TXDATAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _TXDATAW<'a> { w: &'a mut W, } impl<'a> _TXDATAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - 8-bit transmit data"] #[inline] pub fn txdata(&self) -> TXDATAR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TXDATAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - 8-bit transmit data"] #[inline] pub fn txdata(&mut self) -> _TXDATAW { _TXDATAW { w: self } } } } } #[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 i2c1::RegisterBlock { 0x4000_5800 as *const _ } } impl Deref for I2C2 { type Target = i2c1::RegisterBlock; fn deref(&self) -> &i2c1::RegisterBlock { unsafe { &*I2C2::ptr() } } } #[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 { 0x4000_3000 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Key register"] pub kr: KR, #[doc = "0x04 - Prescaler register"] pub pr: PR, #[doc = "0x08 - Reload register"] pub rlr: RLR, #[doc = "0x0c - Status register"] pub sr: SR, #[doc = "0x10 - Window register"] pub winr: WINR, } #[doc = "Key register"] pub struct KR { register: ::vcell::VolatileCell, } #[doc = "Key register"] pub mod kr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::KR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _KEYW<'a> { w: &'a mut W, } impl<'a> _KEYW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Key value"] #[inline] pub fn key(&mut self) -> _KEYW { _KEYW { w: self } } } } #[doc = "Prescaler register"] pub struct PR { register: ::vcell::VolatileCell, } #[doc = "Prescaler register"] pub mod pr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PRR { bits: u8, } impl PRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _PRW<'a> { w: &'a mut W, } impl<'a> _PRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:2 - Prescaler divider"] #[inline] pub fn pr(&self) -> PRR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:2 - Prescaler divider"] #[inline] pub fn pr(&mut self) -> _PRW { _PRW { w: self } } } } #[doc = "Reload register"] pub struct RLR { register: ::vcell::VolatileCell, } #[doc = "Reload register"] pub mod rlr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RLR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct RLR { bits: u16, } impl RLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _RLW<'a> { w: &'a mut W, } impl<'a> _RLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:11 - Watchdog counter reload value"] #[inline] pub fn rl(&self) -> RLR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; RLR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x0fff } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:11 - Watchdog counter reload value"] #[inline] pub fn rl(&mut self) -> _RLW { _RLW { w: self } } } } #[doc = "Status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "Status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::SR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct PVUR { bits: bool, } impl PVUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RVUR { bits: bool, } impl RVUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WVUR { bits: bool, } impl WVUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Watchdog prescaler value update"] #[inline] pub fn pvu(&self) -> PVUR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PVUR { bits } } #[doc = "Bit 1 - Watchdog counter reload value update"] #[inline] pub fn rvu(&self) -> RVUR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RVUR { bits } } #[doc = "Bit 2 - Watchdog counter window value update"] #[inline] pub fn wvu(&self) -> WVUR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WVUR { bits } } } } #[doc = "Window register"] pub struct WINR { register: ::vcell::VolatileCell, } #[doc = "Window register"] pub mod winr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::WINR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct WINR { bits: u16, } impl WINR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _WINW<'a> { w: &'a mut W, } impl<'a> _WINW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:11 - Watchdog counter window value"] #[inline] pub fn win(&self) -> WINR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; WINR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x0fff } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:11 - Watchdog counter window value"] #[inline] pub fn win(&mut self) -> _WINW { _WINW { w: self } } } } } #[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 { 0x4000_2c00 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Control register"] pub cr: CR, #[doc = "0x04 - Configuration register"] pub cfr: CFR, #[doc = "0x08 - Status register"] pub sr: SR, } #[doc = "Control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "Control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct WDGAR { bits: bool, } impl WDGAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR { bits: u8, } impl TR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _WDGAW<'a> { w: &'a mut W, } impl<'a> _WDGAW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TW<'a> { w: &'a mut W, } impl<'a> _TW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x7f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - Activation bit"] #[inline] pub fn wdga(&self) -> WDGAR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WDGAR { bits } } #[doc = "Bits 0:6 - 7-bit counter"] #[inline] pub fn t(&self) -> TR { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x7f } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Activation bit"] #[inline] pub fn wdga(&mut self) -> _WDGAW { _WDGAW { w: self } } #[doc = "Bits 0:6 - 7-bit counter"] #[inline] pub fn t(&mut self) -> _TW { _TW { w: self } } } } #[doc = "Configuration register"] pub struct CFR { register: ::vcell::VolatileCell, } #[doc = "Configuration register"] pub mod cfr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EWIR { bits: bool, } impl EWIR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WDGTBR { bits: u8, } impl WDGTBR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct WR { bits: u8, } impl WR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _EWIW<'a> { w: &'a mut W, } impl<'a> _EWIW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WDGTBW<'a> { w: &'a mut W, } impl<'a> _WDGTBW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WW<'a> { w: &'a mut W, } impl<'a> _WW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x7f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Early wakeup interrupt"] #[inline] pub fn ewi(&self) -> EWIR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EWIR { bits } } #[doc = "Bits 7:8 - Timer base"] #[inline] pub fn wdgtb(&self) -> WDGTBR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) as u8 }; WDGTBR { bits } } #[doc = "Bits 0:6 - 7-bit window value"] #[inline] pub fn w(&self) -> WR { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; WR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x7f } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Early wakeup interrupt"] #[inline] pub fn ewi(&mut self) -> _EWIW { _EWIW { w: self } } #[doc = "Bits 7:8 - Timer base"] #[inline] pub fn wdgtb(&mut self) -> _WDGTBW { _WDGTBW { w: self } } #[doc = "Bits 0:6 - 7-bit window value"] #[inline] pub fn w(&mut self) -> _WW { _WW { w: self } } } } #[doc = "Status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "Status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EWIFR { bits: bool, } impl EWIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _EWIFW<'a> { w: &'a mut W, } impl<'a> _EWIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Early wakeup interrupt flag"] #[inline] pub fn ewif(&self) -> EWIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EWIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Early wakeup interrupt flag"] #[inline] pub fn ewif(&mut self) -> _EWIFW { _EWIFW { w: self } } } } } #[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 { 0x4001_2c00 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, #[doc = "0x04 - control register 2"] pub cr2: CR2, #[doc = "0x08 - slave mode control register"] pub smcr: SMCR, #[doc = "0x0c - DMA/Interrupt enable register"] pub dier: DIER, #[doc = "0x10 - status register"] pub sr: SR, #[doc = "0x14 - event generation register"] pub egr: EGR, #[doc = "0x18 - capture/compare mode register (output mode)"] pub ccmr1_output: CCMR1_OUTPUT, #[doc = "0x1c - capture/compare mode register (output mode)"] pub ccmr2_output: CCMR2_OUTPUT, #[doc = "0x20 - capture/compare enable register"] pub ccer: CCER, #[doc = "0x24 - counter"] pub cnt: CNT, #[doc = "0x28 - prescaler"] pub psc: PSC, #[doc = "0x2c - auto-reload register"] pub arr: ARR, #[doc = "0x30 - repetition counter register"] pub rcr: RCR, #[doc = "0x34 - capture/compare register 1"] pub ccr1: CCR1, #[doc = "0x38 - capture/compare register 2"] pub ccr2: CCR2, #[doc = "0x3c - capture/compare register 3"] pub ccr3: CCR3, #[doc = "0x40 - capture/compare register 4"] pub ccr4: CCR4, #[doc = "0x44 - break and dead-time register"] pub bdtr: BDTR, #[doc = "0x48 - DMA control register"] pub dcr: DCR, #[doc = "0x4c - DMA address for full transfer"] pub dmar: DMAR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CKDR { bits: u8, } impl CKDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ARPER { bits: bool, } impl ARPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CMSR { bits: u8, } impl CMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPMR { bits: bool, } impl OPMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct URSR { bits: bool, } impl URSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDISR { bits: bool, } impl UDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CENR { bits: bool, } impl CENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CKDW<'a> { w: &'a mut W, } impl<'a> _CKDW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARPEW<'a> { w: &'a mut W, } impl<'a> _ARPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CMSW<'a> { w: &'a mut W, } impl<'a> _CMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPMW<'a> { w: &'a mut W, } impl<'a> _OPMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _URSW<'a> { w: &'a mut W, } impl<'a> _URSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDISW<'a> { w: &'a mut W, } impl<'a> _UDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CENW<'a> { w: &'a mut W, } impl<'a> _CENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&self) -> CKDR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CKDR { bits } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&self) -> ARPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARPER { bits } } #[doc = "Bits 5:6 - Center-aligned mode selection"] #[inline] pub fn cms(&self) -> CMSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CMSR { bits } } #[doc = "Bit 4 - Direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&self) -> OPMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPMR { bits } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&self) -> URSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; URSR { bits } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&self) -> UDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDISR { bits } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&self) -> CENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&mut self) -> _CKDW { _CKDW { w: self } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&mut self) -> _ARPEW { _ARPEW { w: self } } #[doc = "Bits 5:6 - Center-aligned mode selection"] #[inline] pub fn cms(&mut self) -> _CMSW { _CMSW { w: self } } #[doc = "Bit 4 - Direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&mut self) -> _OPMW { _OPMW { w: self } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&mut self) -> _URSW { _URSW { w: self } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&mut self) -> _UDISW { _UDISW { w: self } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&mut self) -> _CENW { _CENW { w: self } } } } #[doc = "control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OIS4R { bits: bool, } impl OIS4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS3NR { bits: bool, } impl OIS3NR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS3R { bits: bool, } impl OIS3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS2NR { bits: bool, } impl OIS2NR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS2R { bits: bool, } impl OIS2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS1NR { bits: bool, } impl OIS1NR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS1R { bits: bool, } impl OIS1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TI1SR { bits: bool, } impl TI1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MMSR { bits: u8, } impl MMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CCDSR { bits: bool, } impl CCDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCUSR { bits: bool, } impl CCUSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCPCR { bits: bool, } impl CCPCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OIS4W<'a> { w: &'a mut W, } impl<'a> _OIS4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS3NW<'a> { w: &'a mut W, } impl<'a> _OIS3NW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS3W<'a> { w: &'a mut W, } impl<'a> _OIS3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS2NW<'a> { w: &'a mut W, } impl<'a> _OIS2NW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS2W<'a> { w: &'a mut W, } impl<'a> _OIS2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS1NW<'a> { w: &'a mut W, } impl<'a> _OIS1NW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS1W<'a> { w: &'a mut W, } impl<'a> _OIS1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TI1SW<'a> { w: &'a mut W, } impl<'a> _TI1SW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MMSW<'a> { w: &'a mut W, } impl<'a> _MMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCDSW<'a> { w: &'a mut W, } impl<'a> _CCDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCUSW<'a> { w: &'a mut W, } impl<'a> _CCUSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCPCW<'a> { w: &'a mut W, } impl<'a> _CCPCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 14 - Output Idle state 4"] #[inline] pub fn ois4(&self) -> OIS4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS4R { bits } } #[doc = "Bit 13 - Output Idle state 3"] #[inline] pub fn ois3n(&self) -> OIS3NR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS3NR { bits } } #[doc = "Bit 12 - Output Idle state 3"] #[inline] pub fn ois3(&self) -> OIS3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS3R { bits } } #[doc = "Bit 11 - Output Idle state 2"] #[inline] pub fn ois2n(&self) -> OIS2NR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS2NR { bits } } #[doc = "Bit 10 - Output Idle state 2"] #[inline] pub fn ois2(&self) -> OIS2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS2R { bits } } #[doc = "Bit 9 - Output Idle state 1"] #[inline] pub fn ois1n(&self) -> OIS1NR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS1NR { bits } } #[doc = "Bit 8 - Output Idle state 1"] #[inline] pub fn ois1(&self) -> OIS1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS1R { bits } } #[doc = "Bit 7 - TI1 selection"] #[inline] pub fn ti1s(&self) -> TI1SR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TI1SR { bits } } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&self) -> MMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MMSR { bits } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&self) -> CCDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCDSR { bits } } #[doc = "Bit 2 - Capture/compare control update selection"] #[inline] pub fn ccus(&self) -> CCUSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCUSR { bits } } #[doc = "Bit 0 - Capture/compare preloaded control"] #[inline] pub fn ccpc(&self) -> CCPCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCPCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 14 - Output Idle state 4"] #[inline] pub fn ois4(&mut self) -> _OIS4W { _OIS4W { w: self } } #[doc = "Bit 13 - Output Idle state 3"] #[inline] pub fn ois3n(&mut self) -> _OIS3NW { _OIS3NW { w: self } } #[doc = "Bit 12 - Output Idle state 3"] #[inline] pub fn ois3(&mut self) -> _OIS3W { _OIS3W { w: self } } #[doc = "Bit 11 - Output Idle state 2"] #[inline] pub fn ois2n(&mut self) -> _OIS2NW { _OIS2NW { w: self } } #[doc = "Bit 10 - Output Idle state 2"] #[inline] pub fn ois2(&mut self) -> _OIS2W { _OIS2W { w: self } } #[doc = "Bit 9 - Output Idle state 1"] #[inline] pub fn ois1n(&mut self) -> _OIS1NW { _OIS1NW { w: self } } #[doc = "Bit 8 - Output Idle state 1"] #[inline] pub fn ois1(&mut self) -> _OIS1W { _OIS1W { w: self } } #[doc = "Bit 7 - TI1 selection"] #[inline] pub fn ti1s(&mut self) -> _TI1SW { _TI1SW { w: self } } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&mut self) -> _MMSW { _MMSW { w: self } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&mut self) -> _CCDSW { _CCDSW { w: self } } #[doc = "Bit 2 - Capture/compare control update selection"] #[inline] pub fn ccus(&mut self) -> _CCUSW { _CCUSW { w: self } } #[doc = "Bit 0 - Capture/compare preloaded control"] #[inline] pub fn ccpc(&mut self) -> _CCPCW { _CCPCW { w: self } } } } #[doc = "slave mode control register"] pub struct SMCR { register: ::vcell::VolatileCell, } #[doc = "slave mode control register"] pub mod smcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SMCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ETPR { bits: bool, } impl ETPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ECER { bits: bool, } impl ECER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ETPSR { bits: u8, } impl ETPSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ETFR { bits: u8, } impl ETFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSMR { bits: bool, } impl MSMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSR { bits: u8, } impl TSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SMSR { bits: u8, } impl SMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _ETPW<'a> { w: &'a mut W, } impl<'a> _ETPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ECEW<'a> { w: &'a mut W, } impl<'a> _ECEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ETPSW<'a> { w: &'a mut W, } impl<'a> _ETPSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ETFW<'a> { w: &'a mut W, } impl<'a> _ETFW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSMW<'a> { w: &'a mut W, } impl<'a> _MSMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSW<'a> { w: &'a mut W, } impl<'a> _TSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SMSW<'a> { w: &'a mut W, } impl<'a> _SMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - External trigger polarity"] #[inline] pub fn etp(&self) -> ETPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ETPR { bits } } #[doc = "Bit 14 - External clock enable"] #[inline] pub fn ece(&self) -> ECER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ECER { bits } } #[doc = "Bits 12:13 - External trigger prescaler"] #[inline] pub fn etps(&self) -> ETPSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ETPSR { bits } } #[doc = "Bits 8:11 - External trigger filter"] #[inline] pub fn etf(&self) -> ETFR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ETFR { bits } } #[doc = "Bit 7 - Master/Slave mode"] #[inline] pub fn msm(&self) -> MSMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSMR { bits } } #[doc = "Bits 4:6 - Trigger selection"] #[inline] pub fn ts(&self) -> TSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TSR { bits } } #[doc = "Bits 0:2 - Slave mode selection"] #[inline] pub fn sms(&self) -> SMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SMSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - External trigger polarity"] #[inline] pub fn etp(&mut self) -> _ETPW { _ETPW { w: self } } #[doc = "Bit 14 - External clock enable"] #[inline] pub fn ece(&mut self) -> _ECEW { _ECEW { w: self } } #[doc = "Bits 12:13 - External trigger prescaler"] #[inline] pub fn etps(&mut self) -> _ETPSW { _ETPSW { w: self } } #[doc = "Bits 8:11 - External trigger filter"] #[inline] pub fn etf(&mut self) -> _ETFW { _ETFW { w: self } } #[doc = "Bit 7 - Master/Slave mode"] #[inline] pub fn msm(&mut self) -> _MSMW { _MSMW { w: self } } #[doc = "Bits 4:6 - Trigger selection"] #[inline] pub fn ts(&mut self) -> _TSW { _TSW { w: self } } #[doc = "Bits 0:2 - Slave mode selection"] #[inline] pub fn sms(&mut self) -> _SMSW { _SMSW { w: self } } } } #[doc = "DMA/Interrupt enable register"] pub struct DIER { register: ::vcell::VolatileCell, } #[doc = "DMA/Interrupt enable register"] pub mod dier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TDER { bits: bool, } impl TDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMDER { bits: bool, } impl COMDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4DER { bits: bool, } impl CC4DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3DER { bits: bool, } impl CC3DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2DER { bits: bool, } impl CC2DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1DER { bits: bool, } impl CC1DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDER { bits: bool, } impl UDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIER { bits: bool, } impl BIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIER { bits: bool, } impl TIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMIER { bits: bool, } impl COMIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4IER { bits: bool, } impl CC4IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3IER { bits: bool, } impl CC3IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2IER { bits: bool, } impl CC2IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IER { bits: bool, } impl CC1IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIER { bits: bool, } impl UIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TDEW<'a> { w: &'a mut W, } impl<'a> _TDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMDEW<'a> { w: &'a mut W, } impl<'a> _COMDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4DEW<'a> { w: &'a mut W, } impl<'a> _CC4DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3DEW<'a> { w: &'a mut W, } impl<'a> _CC3DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2DEW<'a> { w: &'a mut W, } impl<'a> _CC2DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1DEW<'a> { w: &'a mut W, } impl<'a> _CC1DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDEW<'a> { w: &'a mut W, } impl<'a> _UDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIEW<'a> { w: &'a mut W, } impl<'a> _BIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIEW<'a> { w: &'a mut W, } impl<'a> _TIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMIEW<'a> { w: &'a mut W, } impl<'a> _COMIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4IEW<'a> { w: &'a mut W, } impl<'a> _CC4IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3IEW<'a> { w: &'a mut W, } impl<'a> _CC3IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2IEW<'a> { w: &'a mut W, } impl<'a> _CC2IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IEW<'a> { w: &'a mut W, } impl<'a> _CC1IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIEW<'a> { w: &'a mut W, } impl<'a> _UIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&self) -> TDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TDER { bits } } #[doc = "Bit 13 - Reserved"] #[inline] pub fn comde(&self) -> COMDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMDER { bits } } #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] #[inline] pub fn cc4de(&self) -> CC4DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4DER { bits } } #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] #[inline] pub fn cc3de(&self) -> CC3DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3DER { bits } } #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] #[inline] pub fn cc2de(&self) -> CC2DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2DER { bits } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&self) -> CC1DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1DER { bits } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&self) -> UDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDER { bits } } #[doc = "Bit 7 - Break interrupt enable"] #[inline] pub fn bie(&self) -> BIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIER { bits } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&self) -> TIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIER { bits } } #[doc = "Bit 5 - COM interrupt enable"] #[inline] pub fn comie(&self) -> COMIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMIER { bits } } #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] #[inline] pub fn cc4ie(&self) -> CC4IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4IER { bits } } #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] #[inline] pub fn cc3ie(&self) -> CC3IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3IER { bits } } #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] #[inline] pub fn cc2ie(&self) -> CC2IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2IER { bits } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&self) -> CC1IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IER { bits } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&self) -> UIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&mut self) -> _TDEW { _TDEW { w: self } } #[doc = "Bit 13 - Reserved"] #[inline] pub fn comde(&mut self) -> _COMDEW { _COMDEW { w: self } } #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] #[inline] pub fn cc4de(&mut self) -> _CC4DEW { _CC4DEW { w: self } } #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] #[inline] pub fn cc3de(&mut self) -> _CC3DEW { _CC3DEW { w: self } } #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] #[inline] pub fn cc2de(&mut self) -> _CC2DEW { _CC2DEW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&mut self) -> _CC1DEW { _CC1DEW { w: self } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&mut self) -> _UDEW { _UDEW { w: self } } #[doc = "Bit 7 - Break interrupt enable"] #[inline] pub fn bie(&mut self) -> _BIEW { _BIEW { w: self } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&mut self) -> _TIEW { _TIEW { w: self } } #[doc = "Bit 5 - COM interrupt enable"] #[inline] pub fn comie(&mut self) -> _COMIEW { _COMIEW { w: self } } #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] #[inline] pub fn cc4ie(&mut self) -> _CC4IEW { _CC4IEW { w: self } } #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] #[inline] pub fn cc3ie(&mut self) -> _CC3IEW { _CC3IEW { w: self } } #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] #[inline] pub fn cc2ie(&mut self) -> _CC2IEW { _CC2IEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&mut self) -> _CC1IEW { _CC1IEW { w: self } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&mut self) -> _UIEW { _UIEW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC4OFR { bits: bool, } impl CC4OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3OFR { bits: bool, } impl CC3OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2OFR { bits: bool, } impl CC2OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1OFR { bits: bool, } impl CC1OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIFR { bits: bool, } impl BIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIFR { bits: bool, } impl TIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMIFR { bits: bool, } impl COMIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4IFR { bits: bool, } impl CC4IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3IFR { bits: bool, } impl CC3IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2IFR { bits: bool, } impl CC2IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IFR { bits: bool, } impl CC1IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIFR { bits: bool, } impl UIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC4OFW<'a> { w: &'a mut W, } impl<'a> _CC4OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3OFW<'a> { w: &'a mut W, } impl<'a> _CC3OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2OFW<'a> { w: &'a mut W, } impl<'a> _CC2OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1OFW<'a> { w: &'a mut W, } impl<'a> _CC1OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIFW<'a> { w: &'a mut W, } impl<'a> _BIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIFW<'a> { w: &'a mut W, } impl<'a> _TIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMIFW<'a> { w: &'a mut W, } impl<'a> _COMIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4IFW<'a> { w: &'a mut W, } impl<'a> _CC4IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3IFW<'a> { w: &'a mut W, } impl<'a> _CC3IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2IFW<'a> { w: &'a mut W, } impl<'a> _CC2IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IFW<'a> { w: &'a mut W, } impl<'a> _CC1IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIFW<'a> { w: &'a mut W, } impl<'a> _UIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] #[inline] pub fn cc4of(&self) -> CC4OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4OFR { bits } } #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] #[inline] pub fn cc3of(&self) -> CC3OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3OFR { bits } } #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] #[inline] pub fn cc2of(&self) -> CC2OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2OFR { bits } } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&self) -> CC1OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1OFR { bits } } #[doc = "Bit 7 - Break interrupt flag"] #[inline] pub fn bif(&self) -> BIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIFR { bits } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&self) -> TIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIFR { bits } } #[doc = "Bit 5 - COM interrupt flag"] #[inline] pub fn comif(&self) -> COMIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMIFR { bits } } #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] #[inline] pub fn cc4if(&self) -> CC4IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4IFR { bits } } #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] #[inline] pub fn cc3if(&self) -> CC3IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3IFR { bits } } #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] #[inline] pub fn cc2if(&self) -> CC2IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2IFR { bits } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&self) -> CC1IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IFR { bits } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&self) -> UIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] #[inline] pub fn cc4of(&mut self) -> _CC4OFW { _CC4OFW { w: self } } #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] #[inline] pub fn cc3of(&mut self) -> _CC3OFW { _CC3OFW { w: self } } #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] #[inline] pub fn cc2of(&mut self) -> _CC2OFW { _CC2OFW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&mut self) -> _CC1OFW { _CC1OFW { w: self } } #[doc = "Bit 7 - Break interrupt flag"] #[inline] pub fn bif(&mut self) -> _BIFW { _BIFW { w: self } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&mut self) -> _TIFW { _TIFW { w: self } } #[doc = "Bit 5 - COM interrupt flag"] #[inline] pub fn comif(&mut self) -> _COMIFW { _COMIFW { w: self } } #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] #[inline] pub fn cc4if(&mut self) -> _CC4IFW { _CC4IFW { w: self } } #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] #[inline] pub fn cc3if(&mut self) -> _CC3IFW { _CC3IFW { w: self } } #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] #[inline] pub fn cc2if(&mut self) -> _CC2IFW { _CC2IFW { w: self } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&mut self) -> _CC1IFW { _CC1IFW { w: self } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&mut self) -> _UIFW { _UIFW { w: self } } } } #[doc = "event generation register"] pub struct EGR { register: ::vcell::VolatileCell, } #[doc = "event generation register"] pub mod egr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EGR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BGW<'a> { w: &'a mut W, } impl<'a> _BGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TGW<'a> { w: &'a mut W, } impl<'a> _TGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMGW<'a> { w: &'a mut W, } impl<'a> _COMGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4GW<'a> { w: &'a mut W, } impl<'a> _CC4GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3GW<'a> { w: &'a mut W, } impl<'a> _CC3GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2GW<'a> { w: &'a mut W, } impl<'a> _CC2GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1GW<'a> { w: &'a mut W, } impl<'a> _CC1GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UGW<'a> { w: &'a mut W, } impl<'a> _UGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Break generation"] #[inline] pub fn bg(&mut self) -> _BGW { _BGW { w: self } } #[doc = "Bit 6 - Trigger generation"] #[inline] pub fn tg(&mut self) -> _TGW { _TGW { w: self } } #[doc = "Bit 5 - Capture/Compare control update generation"] #[inline] pub fn comg(&mut self) -> _COMGW { _COMGW { w: self } } #[doc = "Bit 4 - Capture/compare 4 generation"] #[inline] pub fn cc4g(&mut self) -> _CC4GW { _CC4GW { w: self } } #[doc = "Bit 3 - Capture/compare 3 generation"] #[inline] pub fn cc3g(&mut self) -> _CC3GW { _CC3GW { w: self } } #[doc = "Bit 2 - Capture/compare 2 generation"] #[inline] pub fn cc2g(&mut self) -> _CC2GW { _CC2GW { w: self } } #[doc = "Bit 1 - Capture/compare 1 generation"] #[inline] pub fn cc1g(&mut self) -> _CC1GW { _CC1GW { w: self } } #[doc = "Bit 0 - Update generation"] #[inline] pub fn ug(&mut self) -> _UGW { _UGW { w: self } } } } #[doc = "capture/compare mode register (output mode)"] pub struct CCMR1_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register (output mode)"] pub mod ccmr1_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OC2CER { bits: bool, } impl OC2CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC2MR { bits: u8, } impl OC2MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC2PER { bits: bool, } impl OC2PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC2FER { bits: bool, } impl OC2FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2SR { bits: u8, } impl CC2SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1CER { bits: bool, } impl OC1CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1MR { bits: u8, } impl OC1MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1PER { bits: bool, } impl OC1PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1FER { bits: bool, } impl OC1FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OC2CEW<'a> { w: &'a mut W, } impl<'a> _OC2CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2MW<'a> { w: &'a mut W, } impl<'a> _OC2MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2PEW<'a> { w: &'a mut W, } impl<'a> _OC2PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2FEW<'a> { w: &'a mut W, } impl<'a> _OC2FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2SW<'a> { w: &'a mut W, } impl<'a> _CC2SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1CEW<'a> { w: &'a mut W, } impl<'a> _OC1CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1MW<'a> { w: &'a mut W, } impl<'a> _OC1MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1PEW<'a> { w: &'a mut W, } impl<'a> _OC1PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1FEW<'a> { w: &'a mut W, } impl<'a> _OC1FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Output Compare 2 clear enable"] #[inline] pub fn oc2ce(&self) -> OC2CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2CER { bits } } #[doc = "Bits 12:14 - Output Compare 2 mode"] #[inline] pub fn oc2m(&self) -> OC2MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC2MR { bits } } #[doc = "Bit 11 - Output Compare 2 preload enable"] #[inline] pub fn oc2pe(&self) -> OC2PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2PER { bits } } #[doc = "Bit 10 - Output Compare 2 fast enable"] #[inline] pub fn oc2fe(&self) -> OC2FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2FER { bits } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&self) -> CC2SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC2SR { bits } } #[doc = "Bit 7 - Output Compare 1 clear enable"] #[inline] pub fn oc1ce(&self) -> OC1CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1CER { bits } } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&self) -> OC1MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC1MR { bits } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&self) -> OC1PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1PER { bits } } #[doc = "Bit 2 - Output Compare 1 fast enable"] #[inline] pub fn oc1fe(&self) -> OC1FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1FER { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Output Compare 2 clear enable"] #[inline] pub fn oc2ce(&mut self) -> _OC2CEW { _OC2CEW { w: self } } #[doc = "Bits 12:14 - Output Compare 2 mode"] #[inline] pub fn oc2m(&mut self) -> _OC2MW { _OC2MW { w: self } } #[doc = "Bit 11 - Output Compare 2 preload enable"] #[inline] pub fn oc2pe(&mut self) -> _OC2PEW { _OC2PEW { w: self } } #[doc = "Bit 10 - Output Compare 2 fast enable"] #[inline] pub fn oc2fe(&mut self) -> _OC2FEW { _OC2FEW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&mut self) -> _CC2SW { _CC2SW { w: self } } #[doc = "Bit 7 - Output Compare 1 clear enable"] #[inline] pub fn oc1ce(&mut self) -> _OC1CEW { _OC1CEW { w: self } } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&mut self) -> _OC1MW { _OC1MW { w: self } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&mut self) -> _OC1PEW { _OC1PEW { w: self } } #[doc = "Bit 2 - Output Compare 1 fast enable"] #[inline] pub fn oc1fe(&mut self) -> _OC1FEW { _OC1FEW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare mode register 1 (input mode)"] pub struct CCMR1_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 1 (input mode)"] pub mod ccmr1_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC2FR { bits: u8, } impl IC2FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC2PCSR { bits: u8, } impl IC2PCSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC2SR { bits: u8, } impl CC2SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1FR { bits: u8, } impl IC1FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1PCSR { bits: u8, } impl IC1PCSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC2FW<'a> { w: &'a mut W, } impl<'a> _IC2FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC2PCSW<'a> { w: &'a mut W, } impl<'a> _IC2PCSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2SW<'a> { w: &'a mut W, } impl<'a> _CC2SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1FW<'a> { w: &'a mut W, } impl<'a> _IC1FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1PCSW<'a> { w: &'a mut W, } impl<'a> _IC1PCSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - Input capture 2 filter"] #[inline] pub fn ic2f(&self) -> IC2FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC2FR { bits } } #[doc = "Bits 10:11 - Input capture 2 prescaler"] #[inline] pub fn ic2pcs(&self) -> IC2PCSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC2PCSR { bits } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&self) -> CC2SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC2SR { bits } } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&self) -> IC1FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1FR { bits } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1pcs(&self) -> IC1PCSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1PCSR { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - Input capture 2 filter"] #[inline] pub fn ic2f(&mut self) -> _IC2FW { _IC2FW { w: self } } #[doc = "Bits 10:11 - Input capture 2 prescaler"] #[inline] pub fn ic2pcs(&mut self) -> _IC2PCSW { _IC2PCSW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&mut self) -> _CC2SW { _CC2SW { w: self } } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&mut self) -> _IC1FW { _IC1FW { w: self } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1pcs(&mut self) -> _IC1PCSW { _IC1PCSW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare mode register (output mode)"] pub struct CCMR2_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register (output mode)"] pub mod ccmr2_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR2_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OC4CER { bits: bool, } impl OC4CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC4MR { bits: u8, } impl OC4MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC4PER { bits: bool, } impl OC4PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC4FER { bits: bool, } impl OC4FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4SR { bits: u8, } impl CC4SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC3CER { bits: bool, } impl OC3CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC3MR { bits: u8, } impl OC3MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC3PER { bits: bool, } impl OC3PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC3FER { bits: bool, } impl OC3FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3SR { bits: u8, } impl CC3SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OC4CEW<'a> { w: &'a mut W, } impl<'a> _OC4CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC4MW<'a> { w: &'a mut W, } impl<'a> _OC4MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC4PEW<'a> { w: &'a mut W, } impl<'a> _OC4PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC4FEW<'a> { w: &'a mut W, } impl<'a> _OC4FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4SW<'a> { w: &'a mut W, } impl<'a> _CC4SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3CEW<'a> { w: &'a mut W, } impl<'a> _OC3CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3MW<'a> { w: &'a mut W, } impl<'a> _OC3MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3PEW<'a> { w: &'a mut W, } impl<'a> _OC3PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3FEW<'a> { w: &'a mut W, } impl<'a> _OC3FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3SW<'a> { w: &'a mut W, } impl<'a> _CC3SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Output compare 4 clear enable"] #[inline] pub fn oc4ce(&self) -> OC4CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC4CER { bits } } #[doc = "Bits 12:14 - Output compare 4 mode"] #[inline] pub fn oc4m(&self) -> OC4MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC4MR { bits } } #[doc = "Bit 11 - Output compare 4 preload enable"] #[inline] pub fn oc4pe(&self) -> OC4PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC4PER { bits } } #[doc = "Bit 10 - Output compare 4 fast enable"] #[inline] pub fn oc4fe(&self) -> OC4FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC4FER { bits } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&self) -> CC4SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC4SR { bits } } #[doc = "Bit 7 - Output compare 3 clear enable"] #[inline] pub fn oc3ce(&self) -> OC3CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC3CER { bits } } #[doc = "Bits 4:6 - Output compare 3 mode"] #[inline] pub fn oc3m(&self) -> OC3MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC3MR { bits } } #[doc = "Bit 3 - Output compare 3 preload enable"] #[inline] pub fn oc3pe(&self) -> OC3PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC3PER { bits } } #[doc = "Bit 2 - Output compare 3 fast enable"] #[inline] pub fn oc3fe(&self) -> OC3FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC3FER { bits } } #[doc = "Bits 0:1 - Capture/Compare 3 selection"] #[inline] pub fn cc3s(&self) -> CC3SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC3SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Output compare 4 clear enable"] #[inline] pub fn oc4ce(&mut self) -> _OC4CEW { _OC4CEW { w: self } } #[doc = "Bits 12:14 - Output compare 4 mode"] #[inline] pub fn oc4m(&mut self) -> _OC4MW { _OC4MW { w: self } } #[doc = "Bit 11 - Output compare 4 preload enable"] #[inline] pub fn oc4pe(&mut self) -> _OC4PEW { _OC4PEW { w: self } } #[doc = "Bit 10 - Output compare 4 fast enable"] #[inline] pub fn oc4fe(&mut self) -> _OC4FEW { _OC4FEW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&mut self) -> _CC4SW { _CC4SW { w: self } } #[doc = "Bit 7 - Output compare 3 clear enable"] #[inline] pub fn oc3ce(&mut self) -> _OC3CEW { _OC3CEW { w: self } } #[doc = "Bits 4:6 - Output compare 3 mode"] #[inline] pub fn oc3m(&mut self) -> _OC3MW { _OC3MW { w: self } } #[doc = "Bit 3 - Output compare 3 preload enable"] #[inline] pub fn oc3pe(&mut self) -> _OC3PEW { _OC3PEW { w: self } } #[doc = "Bit 2 - Output compare 3 fast enable"] #[inline] pub fn oc3fe(&mut self) -> _OC3FEW { _OC3FEW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 3 selection"] #[inline] pub fn cc3s(&mut self) -> _CC3SW { _CC3SW { w: self } } } } #[doc = "capture/compare mode register 2 (input mode)"] pub struct CCMR2_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 2 (input mode)"] pub mod ccmr2_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR2_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC4FR { bits: u8, } impl IC4FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC4PSCR { bits: u8, } impl IC4PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC4SR { bits: u8, } impl CC4SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC3FR { bits: u8, } impl IC3FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC3PSCR { bits: u8, } impl IC3PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC3SR { bits: u8, } impl CC3SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC4FW<'a> { w: &'a mut W, } impl<'a> _IC4FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC4PSCW<'a> { w: &'a mut W, } impl<'a> _IC4PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4SW<'a> { w: &'a mut W, } impl<'a> _CC4SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC3FW<'a> { w: &'a mut W, } impl<'a> _IC3FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC3PSCW<'a> { w: &'a mut W, } impl<'a> _IC3PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3SW<'a> { w: &'a mut W, } impl<'a> _CC3SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - Input capture 4 filter"] #[inline] pub fn ic4f(&self) -> IC4FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC4FR { bits } } #[doc = "Bits 10:11 - Input capture 4 prescaler"] #[inline] pub fn ic4psc(&self) -> IC4PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC4PSCR { bits } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&self) -> CC4SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC4SR { bits } } #[doc = "Bits 4:7 - Input capture 3 filter"] #[inline] pub fn ic3f(&self) -> IC3FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC3FR { bits } } #[doc = "Bits 2:3 - Input capture 3 prescaler"] #[inline] pub fn ic3psc(&self) -> IC3PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC3PSCR { bits } } #[doc = "Bits 0:1 - Capture/compare 3 selection"] #[inline] pub fn cc3s(&self) -> CC3SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC3SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - Input capture 4 filter"] #[inline] pub fn ic4f(&mut self) -> _IC4FW { _IC4FW { w: self } } #[doc = "Bits 10:11 - Input capture 4 prescaler"] #[inline] pub fn ic4psc(&mut self) -> _IC4PSCW { _IC4PSCW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&mut self) -> _CC4SW { _CC4SW { w: self } } #[doc = "Bits 4:7 - Input capture 3 filter"] #[inline] pub fn ic3f(&mut self) -> _IC3FW { _IC3FW { w: self } } #[doc = "Bits 2:3 - Input capture 3 prescaler"] #[inline] pub fn ic3psc(&mut self) -> _IC3PSCW { _IC3PSCW { w: self } } #[doc = "Bits 0:1 - Capture/compare 3 selection"] #[inline] pub fn cc3s(&mut self) -> _CC3SW { _CC3SW { w: self } } } } #[doc = "capture/compare enable register"] pub struct CCER { register: ::vcell::VolatileCell, } #[doc = "capture/compare enable register"] pub mod ccer { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC4PR { bits: bool, } impl CC4PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4ER { bits: bool, } impl CC4ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3NPR { bits: bool, } impl CC3NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3NER { bits: bool, } impl CC3NER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3PR { bits: bool, } impl CC3PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3ER { bits: bool, } impl CC3ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2NPR { bits: bool, } impl CC2NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2NER { bits: bool, } impl CC2NER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2PR { bits: bool, } impl CC2PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2ER { bits: bool, } impl CC2ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1NPR { bits: bool, } impl CC1NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1NER { bits: bool, } impl CC1NER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1PR { bits: bool, } impl CC1PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1ER { bits: bool, } impl CC1ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC4PW<'a> { w: &'a mut W, } impl<'a> _CC4PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4EW<'a> { w: &'a mut W, } impl<'a> _CC4EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3NPW<'a> { w: &'a mut W, } impl<'a> _CC3NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3NEW<'a> { w: &'a mut W, } impl<'a> _CC3NEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3PW<'a> { w: &'a mut W, } impl<'a> _CC3PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3EW<'a> { w: &'a mut W, } impl<'a> _CC3EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2NPW<'a> { w: &'a mut W, } impl<'a> _CC2NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2NEW<'a> { w: &'a mut W, } impl<'a> _CC2NEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2PW<'a> { w: &'a mut W, } impl<'a> _CC2PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2EW<'a> { w: &'a mut W, } impl<'a> _CC2EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1NPW<'a> { w: &'a mut W, } impl<'a> _CC1NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1NEW<'a> { w: &'a mut W, } impl<'a> _CC1NEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1PW<'a> { w: &'a mut W, } impl<'a> _CC1PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1EW<'a> { w: &'a mut W, } impl<'a> _CC1EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc4p(&self) -> CC4PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4PR { bits } } #[doc = "Bit 12 - Capture/Compare 4 output enable"] #[inline] pub fn cc4e(&self) -> CC4ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4ER { bits } } #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3np(&self) -> CC3NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3NPR { bits } } #[doc = "Bit 10 - Capture/Compare 3 complementary output enable"] #[inline] pub fn cc3ne(&self) -> CC3NER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3NER { bits } } #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3p(&self) -> CC3PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3PR { bits } } #[doc = "Bit 8 - Capture/Compare 3 output enable"] #[inline] pub fn cc3e(&self) -> CC3ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3ER { bits } } #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2np(&self) -> CC2NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2NPR { bits } } #[doc = "Bit 6 - Capture/Compare 2 complementary output enable"] #[inline] pub fn cc2ne(&self) -> CC2NER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2NER { bits } } #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2p(&self) -> CC2PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2PR { bits } } #[doc = "Bit 4 - Capture/Compare 2 output enable"] #[inline] pub fn cc2e(&self) -> CC2ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2ER { bits } } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&self) -> CC1NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NPR { bits } } #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] #[inline] pub fn cc1ne(&self) -> CC1NER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NER { bits } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&self) -> CC1PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1PR { bits } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&self) -> CC1ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1ER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc4p(&mut self) -> _CC4PW { _CC4PW { w: self } } #[doc = "Bit 12 - Capture/Compare 4 output enable"] #[inline] pub fn cc4e(&mut self) -> _CC4EW { _CC4EW { w: self } } #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3np(&mut self) -> _CC3NPW { _CC3NPW { w: self } } #[doc = "Bit 10 - Capture/Compare 3 complementary output enable"] #[inline] pub fn cc3ne(&mut self) -> _CC3NEW { _CC3NEW { w: self } } #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3p(&mut self) -> _CC3PW { _CC3PW { w: self } } #[doc = "Bit 8 - Capture/Compare 3 output enable"] #[inline] pub fn cc3e(&mut self) -> _CC3EW { _CC3EW { w: self } } #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2np(&mut self) -> _CC2NPW { _CC2NPW { w: self } } #[doc = "Bit 6 - Capture/Compare 2 complementary output enable"] #[inline] pub fn cc2ne(&mut self) -> _CC2NEW { _CC2NEW { w: self } } #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2p(&mut self) -> _CC2PW { _CC2PW { w: self } } #[doc = "Bit 4 - Capture/Compare 2 output enable"] #[inline] pub fn cc2e(&mut self) -> _CC2EW { _CC2EW { w: self } } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&mut self) -> _CC1NPW { _CC1NPW { w: self } } #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] #[inline] pub fn cc1ne(&mut self) -> _CC1NEW { _CC1NEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&mut self) -> _CC1PW { _CC1PW { w: self } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&mut self) -> _CC1EW { _CC1EW { w: self } } } } #[doc = "counter"] pub struct CNT { register: ::vcell::VolatileCell, } #[doc = "counter"] pub mod cnt { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CNTR { bits: u16, } impl CNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CNTW<'a> { w: &'a mut W, } impl<'a> _CNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&self) -> CNTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&mut self) -> _CNTW { _CNTW { w: self } } } } #[doc = "prescaler"] pub struct PSC { register: ::vcell::VolatileCell, } #[doc = "prescaler"] pub mod psc { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PSC { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PSCR { bits: u16, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "auto-reload register"] pub struct ARR { register: ::vcell::VolatileCell, } #[doc = "auto-reload register"] pub mod arr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ARR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARRR { bits: u16, } impl ARRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _ARRW<'a> { w: &'a mut W, } impl<'a> _ARRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&self) -> ARRR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&mut self) -> _ARRW { _ARRW { w: self } } } } #[doc = "repetition counter register"] pub struct RCR { register: ::vcell::VolatileCell, } #[doc = "repetition counter register"] pub mod rcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct REPR { bits: u8, } impl REPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _REPW<'a> { w: &'a mut W, } impl<'a> _REPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - Repetition counter value"] #[inline] pub fn rep(&self) -> REPR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; REPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - Repetition counter value"] #[inline] pub fn rep(&mut self) -> _REPW { _REPW { w: self } } } } #[doc = "capture/compare register 1"] pub struct CCR1 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 1"] pub mod ccr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR1R { bits: u16, } impl CCR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR1W<'a> { w: &'a mut W, } impl<'a> _CCR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&self) -> CCR1R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR1R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&mut self) -> _CCR1W { _CCR1W { w: self } } } } #[doc = "capture/compare register 2"] pub struct CCR2 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 2"] pub mod ccr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR2R { bits: u16, } impl CCR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR2W<'a> { w: &'a mut W, } impl<'a> _CCR2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 2 value"] #[inline] pub fn ccr2(&self) -> CCR2R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR2R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 2 value"] #[inline] pub fn ccr2(&mut self) -> _CCR2W { _CCR2W { w: self } } } } #[doc = "capture/compare register 3"] pub struct CCR3 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 3"] pub mod ccr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR3R { bits: u16, } impl CCR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR3W<'a> { w: &'a mut W, } impl<'a> _CCR3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 3 value"] #[inline] pub fn ccr3(&self) -> CCR3R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR3R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 3 value"] #[inline] pub fn ccr3(&mut self) -> _CCR3W { _CCR3W { w: self } } } } #[doc = "capture/compare register 4"] pub struct CCR4 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 4"] pub mod ccr4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR4R { bits: u16, } impl CCR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR4W<'a> { w: &'a mut W, } impl<'a> _CCR4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 3 value"] #[inline] pub fn ccr4(&self) -> CCR4R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR4R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 3 value"] #[inline] pub fn ccr4(&mut self) -> _CCR4W { _CCR4W { w: self } } } } #[doc = "break and dead-time register"] pub struct BDTR { register: ::vcell::VolatileCell, } #[doc = "break and dead-time register"] pub mod bdtr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BDTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MOER { bits: bool, } impl MOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AOER { bits: bool, } impl AOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKPR { bits: bool, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKER { bits: bool, } impl BKER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSSRR { bits: bool, } impl OSSRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSSIR { bits: bool, } impl OSSIR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LOCKR { bits: u8, } impl LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DTGR { bits: u8, } impl DTGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MOEW<'a> { w: &'a mut W, } impl<'a> _MOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AOEW<'a> { w: &'a mut W, } impl<'a> _AOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKEW<'a> { w: &'a mut W, } impl<'a> _BKEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSSRW<'a> { w: &'a mut W, } impl<'a> _OSSRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSSIW<'a> { w: &'a mut W, } impl<'a> _OSSIW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LOCKW<'a> { w: &'a mut W, } impl<'a> _LOCKW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DTGW<'a> { w: &'a mut W, } impl<'a> _DTGW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Main output enable"] #[inline] pub fn moe(&self) -> MOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MOER { bits } } #[doc = "Bit 14 - Automatic output enable"] #[inline] pub fn aoe(&self) -> AOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AOER { bits } } #[doc = "Bit 13 - Break polarity"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKPR { bits } } #[doc = "Bit 12 - Break enable"] #[inline] pub fn bke(&self) -> BKER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKER { bits } } #[doc = "Bit 11 - Off-state selection for Run mode"] #[inline] pub fn ossr(&self) -> OSSRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OSSRR { bits } } #[doc = "Bit 10 - Off-state selection for Idle mode"] #[inline] pub fn ossi(&self) -> OSSIR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OSSIR { bits } } #[doc = "Bits 8:9 - Lock configuration"] #[inline] pub fn lock(&self) -> LOCKR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; LOCKR { bits } } #[doc = "Bits 0:7 - Dead-time generator setup"] #[inline] pub fn dtg(&self) -> DTGR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DTGR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Main output enable"] #[inline] pub fn moe(&mut self) -> _MOEW { _MOEW { w: self } } #[doc = "Bit 14 - Automatic output enable"] #[inline] pub fn aoe(&mut self) -> _AOEW { _AOEW { w: self } } #[doc = "Bit 13 - Break polarity"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } #[doc = "Bit 12 - Break enable"] #[inline] pub fn bke(&mut self) -> _BKEW { _BKEW { w: self } } #[doc = "Bit 11 - Off-state selection for Run mode"] #[inline] pub fn ossr(&mut self) -> _OSSRW { _OSSRW { w: self } } #[doc = "Bit 10 - Off-state selection for Idle mode"] #[inline] pub fn ossi(&mut self) -> _OSSIW { _OSSIW { w: self } } #[doc = "Bits 8:9 - Lock configuration"] #[inline] pub fn lock(&mut self) -> _LOCKW { _LOCKW { w: self } } #[doc = "Bits 0:7 - Dead-time generator setup"] #[inline] pub fn dtg(&mut self) -> _DTGW { _DTGW { w: self } } } } #[doc = "DMA control register"] pub struct DCR { register: ::vcell::VolatileCell, } #[doc = "DMA control register"] pub mod dcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBLR { bits: u8, } impl DBLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DBAR { bits: u8, } impl DBAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _DBLW<'a> { w: &'a mut W, } impl<'a> _DBLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBAW<'a> { w: &'a mut W, } impl<'a> _DBAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&self) -> DBLR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBLR { bits } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&self) -> DBAR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&mut self) -> _DBLW { _DBLW { w: self } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&mut self) -> _DBAW { _DBAW { w: self } } } } #[doc = "DMA address for full transfer"] pub struct DMAR { register: ::vcell::VolatileCell, } #[doc = "DMA address for full transfer"] pub mod dmar { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DMAR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DMABR { bits: u16, } impl DMABR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _DMABW<'a> { w: &'a mut W, } impl<'a> _DMABW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmab(&self) -> DMABR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DMABR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmab(&mut self) -> _DMABW { _DMABW { w: self } } } } } #[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 { 0x4000_0400 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, #[doc = "0x04 - control register 2"] pub cr2: CR2, #[doc = "0x08 - slave mode control register"] pub smcr: SMCR, #[doc = "0x0c - DMA/Interrupt enable register"] pub dier: DIER, #[doc = "0x10 - status register"] pub sr: SR, #[doc = "0x14 - event generation register"] pub egr: EGR, #[doc = "0x18 - capture/compare mode register 1 (output mode)"] pub ccmr1_output: CCMR1_OUTPUT, #[doc = "0x1c - capture/compare mode register 2 (output mode)"] pub ccmr2_output: CCMR2_OUTPUT, #[doc = "0x20 - capture/compare enable register"] pub ccer: CCER, #[doc = "0x24 - counter"] pub cnt: CNT, #[doc = "0x28 - prescaler"] pub psc: PSC, #[doc = "0x2c - auto-reload register"] pub arr: ARR, _reserved0: [u8; 4usize], #[doc = "0x34 - capture/compare register 1"] pub ccr1: CCR1, #[doc = "0x38 - capture/compare register 2"] pub ccr2: CCR2, #[doc = "0x3c - capture/compare register 3"] pub ccr3: CCR3, #[doc = "0x40 - capture/compare register 4"] pub ccr4: CCR4, _reserved1: [u8; 4usize], #[doc = "0x48 - DMA control register"] pub dcr: DCR, #[doc = "0x4c - DMA address for full transfer"] pub dmar: DMAR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CKDR { bits: u8, } impl CKDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ARPER { bits: bool, } impl ARPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CMSR { bits: u8, } impl CMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPMR { bits: bool, } impl OPMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct URSR { bits: bool, } impl URSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDISR { bits: bool, } impl UDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CENR { bits: bool, } impl CENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CKDW<'a> { w: &'a mut W, } impl<'a> _CKDW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARPEW<'a> { w: &'a mut W, } impl<'a> _ARPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CMSW<'a> { w: &'a mut W, } impl<'a> _CMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPMW<'a> { w: &'a mut W, } impl<'a> _OPMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _URSW<'a> { w: &'a mut W, } impl<'a> _URSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDISW<'a> { w: &'a mut W, } impl<'a> _UDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CENW<'a> { w: &'a mut W, } impl<'a> _CENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&self) -> CKDR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CKDR { bits } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&self) -> ARPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARPER { bits } } #[doc = "Bits 5:6 - Center-aligned mode selection"] #[inline] pub fn cms(&self) -> CMSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CMSR { bits } } #[doc = "Bit 4 - Direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&self) -> OPMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPMR { bits } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&self) -> URSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; URSR { bits } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&self) -> UDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDISR { bits } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&self) -> CENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&mut self) -> _CKDW { _CKDW { w: self } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&mut self) -> _ARPEW { _ARPEW { w: self } } #[doc = "Bits 5:6 - Center-aligned mode selection"] #[inline] pub fn cms(&mut self) -> _CMSW { _CMSW { w: self } } #[doc = "Bit 4 - Direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&mut self) -> _OPMW { _OPMW { w: self } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&mut self) -> _URSW { _URSW { w: self } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&mut self) -> _UDISW { _UDISW { w: self } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&mut self) -> _CENW { _CENW { w: self } } } } #[doc = "control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TI1SR { bits: bool, } impl TI1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MMSR { bits: u8, } impl MMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CCDSR { bits: bool, } impl CCDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TI1SW<'a> { w: &'a mut W, } impl<'a> _TI1SW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MMSW<'a> { w: &'a mut W, } impl<'a> _MMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCDSW<'a> { w: &'a mut W, } impl<'a> _CCDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - TI1 selection"] #[inline] pub fn ti1s(&self) -> TI1SR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TI1SR { bits } } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&self) -> MMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MMSR { bits } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&self) -> CCDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCDSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - TI1 selection"] #[inline] pub fn ti1s(&mut self) -> _TI1SW { _TI1SW { w: self } } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&mut self) -> _MMSW { _MMSW { w: self } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&mut self) -> _CCDSW { _CCDSW { w: self } } } } #[doc = "slave mode control register"] pub struct SMCR { register: ::vcell::VolatileCell, } #[doc = "slave mode control register"] pub mod smcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SMCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ETPR { bits: bool, } impl ETPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ECER { bits: bool, } impl ECER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ETPSR { bits: u8, } impl ETPSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ETFR { bits: u8, } impl ETFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSMR { bits: bool, } impl MSMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSR { bits: u8, } impl TSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SMSR { bits: u8, } impl SMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _ETPW<'a> { w: &'a mut W, } impl<'a> _ETPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ECEW<'a> { w: &'a mut W, } impl<'a> _ECEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ETPSW<'a> { w: &'a mut W, } impl<'a> _ETPSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ETFW<'a> { w: &'a mut W, } impl<'a> _ETFW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSMW<'a> { w: &'a mut W, } impl<'a> _MSMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSW<'a> { w: &'a mut W, } impl<'a> _TSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SMSW<'a> { w: &'a mut W, } impl<'a> _SMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - External trigger polarity"] #[inline] pub fn etp(&self) -> ETPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ETPR { bits } } #[doc = "Bit 14 - External clock enable"] #[inline] pub fn ece(&self) -> ECER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ECER { bits } } #[doc = "Bits 12:13 - External trigger prescaler"] #[inline] pub fn etps(&self) -> ETPSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ETPSR { bits } } #[doc = "Bits 8:11 - External trigger filter"] #[inline] pub fn etf(&self) -> ETFR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ETFR { bits } } #[doc = "Bit 7 - Master/Slave mode"] #[inline] pub fn msm(&self) -> MSMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSMR { bits } } #[doc = "Bits 4:6 - Trigger selection"] #[inline] pub fn ts(&self) -> TSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TSR { bits } } #[doc = "Bits 0:2 - Slave mode selection"] #[inline] pub fn sms(&self) -> SMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SMSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - External trigger polarity"] #[inline] pub fn etp(&mut self) -> _ETPW { _ETPW { w: self } } #[doc = "Bit 14 - External clock enable"] #[inline] pub fn ece(&mut self) -> _ECEW { _ECEW { w: self } } #[doc = "Bits 12:13 - External trigger prescaler"] #[inline] pub fn etps(&mut self) -> _ETPSW { _ETPSW { w: self } } #[doc = "Bits 8:11 - External trigger filter"] #[inline] pub fn etf(&mut self) -> _ETFW { _ETFW { w: self } } #[doc = "Bit 7 - Master/Slave mode"] #[inline] pub fn msm(&mut self) -> _MSMW { _MSMW { w: self } } #[doc = "Bits 4:6 - Trigger selection"] #[inline] pub fn ts(&mut self) -> _TSW { _TSW { w: self } } #[doc = "Bits 0:2 - Slave mode selection"] #[inline] pub fn sms(&mut self) -> _SMSW { _SMSW { w: self } } } } #[doc = "DMA/Interrupt enable register"] pub struct DIER { register: ::vcell::VolatileCell, } #[doc = "DMA/Interrupt enable register"] pub mod dier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TDER { bits: bool, } impl TDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMDER { bits: bool, } impl COMDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4DER { bits: bool, } impl CC4DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3DER { bits: bool, } impl CC3DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2DER { bits: bool, } impl CC2DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1DER { bits: bool, } impl CC1DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDER { bits: bool, } impl UDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIER { bits: bool, } impl TIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4IER { bits: bool, } impl CC4IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3IER { bits: bool, } impl CC3IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2IER { bits: bool, } impl CC2IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IER { bits: bool, } impl CC1IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIER { bits: bool, } impl UIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TDEW<'a> { w: &'a mut W, } impl<'a> _TDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMDEW<'a> { w: &'a mut W, } impl<'a> _COMDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4DEW<'a> { w: &'a mut W, } impl<'a> _CC4DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3DEW<'a> { w: &'a mut W, } impl<'a> _CC3DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2DEW<'a> { w: &'a mut W, } impl<'a> _CC2DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1DEW<'a> { w: &'a mut W, } impl<'a> _CC1DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDEW<'a> { w: &'a mut W, } impl<'a> _UDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIEW<'a> { w: &'a mut W, } impl<'a> _TIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4IEW<'a> { w: &'a mut W, } impl<'a> _CC4IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3IEW<'a> { w: &'a mut W, } impl<'a> _CC3IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2IEW<'a> { w: &'a mut W, } impl<'a> _CC2IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IEW<'a> { w: &'a mut W, } impl<'a> _CC1IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIEW<'a> { w: &'a mut W, } impl<'a> _UIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&self) -> TDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TDER { bits } } #[doc = "Bit 13 - Reserved"] #[inline] pub fn comde(&self) -> COMDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMDER { bits } } #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] #[inline] pub fn cc4de(&self) -> CC4DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4DER { bits } } #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] #[inline] pub fn cc3de(&self) -> CC3DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3DER { bits } } #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] #[inline] pub fn cc2de(&self) -> CC2DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2DER { bits } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&self) -> CC1DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1DER { bits } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&self) -> UDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDER { bits } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&self) -> TIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIER { bits } } #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] #[inline] pub fn cc4ie(&self) -> CC4IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4IER { bits } } #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] #[inline] pub fn cc3ie(&self) -> CC3IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3IER { bits } } #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] #[inline] pub fn cc2ie(&self) -> CC2IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2IER { bits } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&self) -> CC1IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IER { bits } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&self) -> UIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&mut self) -> _TDEW { _TDEW { w: self } } #[doc = "Bit 13 - Reserved"] #[inline] pub fn comde(&mut self) -> _COMDEW { _COMDEW { w: self } } #[doc = "Bit 12 - Capture/Compare 4 DMA request enable"] #[inline] pub fn cc4de(&mut self) -> _CC4DEW { _CC4DEW { w: self } } #[doc = "Bit 11 - Capture/Compare 3 DMA request enable"] #[inline] pub fn cc3de(&mut self) -> _CC3DEW { _CC3DEW { w: self } } #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] #[inline] pub fn cc2de(&mut self) -> _CC2DEW { _CC2DEW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&mut self) -> _CC1DEW { _CC1DEW { w: self } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&mut self) -> _UDEW { _UDEW { w: self } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&mut self) -> _TIEW { _TIEW { w: self } } #[doc = "Bit 4 - Capture/Compare 4 interrupt enable"] #[inline] pub fn cc4ie(&mut self) -> _CC4IEW { _CC4IEW { w: self } } #[doc = "Bit 3 - Capture/Compare 3 interrupt enable"] #[inline] pub fn cc3ie(&mut self) -> _CC3IEW { _CC3IEW { w: self } } #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] #[inline] pub fn cc2ie(&mut self) -> _CC2IEW { _CC2IEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&mut self) -> _CC1IEW { _CC1IEW { w: self } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&mut self) -> _UIEW { _UIEW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC4OFR { bits: bool, } impl CC4OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3OFR { bits: bool, } impl CC3OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2OFR { bits: bool, } impl CC2OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1OFR { bits: bool, } impl CC1OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIFR { bits: bool, } impl TIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4IFR { bits: bool, } impl CC4IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3IFR { bits: bool, } impl CC3IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2IFR { bits: bool, } impl CC2IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IFR { bits: bool, } impl CC1IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIFR { bits: bool, } impl UIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC4OFW<'a> { w: &'a mut W, } impl<'a> _CC4OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3OFW<'a> { w: &'a mut W, } impl<'a> _CC3OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2OFW<'a> { w: &'a mut W, } impl<'a> _CC2OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1OFW<'a> { w: &'a mut W, } impl<'a> _CC1OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIFW<'a> { w: &'a mut W, } impl<'a> _TIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4IFW<'a> { w: &'a mut W, } impl<'a> _CC4IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3IFW<'a> { w: &'a mut W, } impl<'a> _CC3IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2IFW<'a> { w: &'a mut W, } impl<'a> _CC2IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IFW<'a> { w: &'a mut W, } impl<'a> _CC1IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIFW<'a> { w: &'a mut W, } impl<'a> _UIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] #[inline] pub fn cc4of(&self) -> CC4OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4OFR { bits } } #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] #[inline] pub fn cc3of(&self) -> CC3OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3OFR { bits } } #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] #[inline] pub fn cc2of(&self) -> CC2OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2OFR { bits } } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&self) -> CC1OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1OFR { bits } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&self) -> TIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIFR { bits } } #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] #[inline] pub fn cc4if(&self) -> CC4IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4IFR { bits } } #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] #[inline] pub fn cc3if(&self) -> CC3IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3IFR { bits } } #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] #[inline] pub fn cc2if(&self) -> CC2IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2IFR { bits } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&self) -> CC1IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IFR { bits } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&self) -> UIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 12 - Capture/Compare 4 overcapture flag"] #[inline] pub fn cc4of(&mut self) -> _CC4OFW { _CC4OFW { w: self } } #[doc = "Bit 11 - Capture/Compare 3 overcapture flag"] #[inline] pub fn cc3of(&mut self) -> _CC3OFW { _CC3OFW { w: self } } #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] #[inline] pub fn cc2of(&mut self) -> _CC2OFW { _CC2OFW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&mut self) -> _CC1OFW { _CC1OFW { w: self } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&mut self) -> _TIFW { _TIFW { w: self } } #[doc = "Bit 4 - Capture/Compare 4 interrupt flag"] #[inline] pub fn cc4if(&mut self) -> _CC4IFW { _CC4IFW { w: self } } #[doc = "Bit 3 - Capture/Compare 3 interrupt flag"] #[inline] pub fn cc3if(&mut self) -> _CC3IFW { _CC3IFW { w: self } } #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] #[inline] pub fn cc2if(&mut self) -> _CC2IFW { _CC2IFW { w: self } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&mut self) -> _CC1IFW { _CC1IFW { w: self } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&mut self) -> _UIFW { _UIFW { w: self } } } } #[doc = "event generation register"] pub struct EGR { register: ::vcell::VolatileCell, } #[doc = "event generation register"] pub mod egr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EGR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _TGW<'a> { w: &'a mut W, } impl<'a> _TGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4GW<'a> { w: &'a mut W, } impl<'a> _CC4GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3GW<'a> { w: &'a mut W, } impl<'a> _CC3GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2GW<'a> { w: &'a mut W, } impl<'a> _CC2GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1GW<'a> { w: &'a mut W, } impl<'a> _CC1GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UGW<'a> { w: &'a mut W, } impl<'a> _UGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 6 - Trigger generation"] #[inline] pub fn tg(&mut self) -> _TGW { _TGW { w: self } } #[doc = "Bit 4 - Capture/compare 4 generation"] #[inline] pub fn cc4g(&mut self) -> _CC4GW { _CC4GW { w: self } } #[doc = "Bit 3 - Capture/compare 3 generation"] #[inline] pub fn cc3g(&mut self) -> _CC3GW { _CC3GW { w: self } } #[doc = "Bit 2 - Capture/compare 2 generation"] #[inline] pub fn cc2g(&mut self) -> _CC2GW { _CC2GW { w: self } } #[doc = "Bit 1 - Capture/compare 1 generation"] #[inline] pub fn cc1g(&mut self) -> _CC1GW { _CC1GW { w: self } } #[doc = "Bit 0 - Update generation"] #[inline] pub fn ug(&mut self) -> _UGW { _UGW { w: self } } } } #[doc = "capture/compare mode register 1 (output mode)"] pub struct CCMR1_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 1 (output mode)"] pub mod ccmr1_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OC2CER { bits: bool, } impl OC2CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC2MR { bits: u8, } impl OC2MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC2PER { bits: bool, } impl OC2PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC2FER { bits: bool, } impl OC2FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2SR { bits: u8, } impl CC2SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1CER { bits: bool, } impl OC1CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1MR { bits: u8, } impl OC1MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1PER { bits: bool, } impl OC1PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1FER { bits: bool, } impl OC1FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OC2CEW<'a> { w: &'a mut W, } impl<'a> _OC2CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2MW<'a> { w: &'a mut W, } impl<'a> _OC2MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2PEW<'a> { w: &'a mut W, } impl<'a> _OC2PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2FEW<'a> { w: &'a mut W, } impl<'a> _OC2FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2SW<'a> { w: &'a mut W, } impl<'a> _CC2SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1CEW<'a> { w: &'a mut W, } impl<'a> _OC1CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1MW<'a> { w: &'a mut W, } impl<'a> _OC1MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1PEW<'a> { w: &'a mut W, } impl<'a> _OC1PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1FEW<'a> { w: &'a mut W, } impl<'a> _OC1FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Output compare 2 clear enable"] #[inline] pub fn oc2ce(&self) -> OC2CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2CER { bits } } #[doc = "Bits 12:14 - Output compare 2 mode"] #[inline] pub fn oc2m(&self) -> OC2MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC2MR { bits } } #[doc = "Bit 11 - Output compare 2 preload enable"] #[inline] pub fn oc2pe(&self) -> OC2PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2PER { bits } } #[doc = "Bit 10 - Output compare 2 fast enable"] #[inline] pub fn oc2fe(&self) -> OC2FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2FER { bits } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&self) -> CC2SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC2SR { bits } } #[doc = "Bit 7 - Output compare 1 clear enable"] #[inline] pub fn oc1ce(&self) -> OC1CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1CER { bits } } #[doc = "Bits 4:6 - Output compare 1 mode"] #[inline] pub fn oc1m(&self) -> OC1MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC1MR { bits } } #[doc = "Bit 3 - Output compare 1 preload enable"] #[inline] pub fn oc1pe(&self) -> OC1PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1PER { bits } } #[doc = "Bit 2 - Output compare 1 fast enable"] #[inline] pub fn oc1fe(&self) -> OC1FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1FER { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Output compare 2 clear enable"] #[inline] pub fn oc2ce(&mut self) -> _OC2CEW { _OC2CEW { w: self } } #[doc = "Bits 12:14 - Output compare 2 mode"] #[inline] pub fn oc2m(&mut self) -> _OC2MW { _OC2MW { w: self } } #[doc = "Bit 11 - Output compare 2 preload enable"] #[inline] pub fn oc2pe(&mut self) -> _OC2PEW { _OC2PEW { w: self } } #[doc = "Bit 10 - Output compare 2 fast enable"] #[inline] pub fn oc2fe(&mut self) -> _OC2FEW { _OC2FEW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&mut self) -> _CC2SW { _CC2SW { w: self } } #[doc = "Bit 7 - Output compare 1 clear enable"] #[inline] pub fn oc1ce(&mut self) -> _OC1CEW { _OC1CEW { w: self } } #[doc = "Bits 4:6 - Output compare 1 mode"] #[inline] pub fn oc1m(&mut self) -> _OC1MW { _OC1MW { w: self } } #[doc = "Bit 3 - Output compare 1 preload enable"] #[inline] pub fn oc1pe(&mut self) -> _OC1PEW { _OC1PEW { w: self } } #[doc = "Bit 2 - Output compare 1 fast enable"] #[inline] pub fn oc1fe(&mut self) -> _OC1FEW { _OC1FEW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare mode register 1 (input mode)"] pub struct CCMR1_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 1 (input mode)"] pub mod ccmr1_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC2FR { bits: u8, } impl IC2FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC2PSCR { bits: u8, } impl IC2PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC2SR { bits: u8, } impl CC2SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1FR { bits: u8, } impl IC1FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1PSCR { bits: u8, } impl IC1PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC2FW<'a> { w: &'a mut W, } impl<'a> _IC2FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC2PSCW<'a> { w: &'a mut W, } impl<'a> _IC2PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2SW<'a> { w: &'a mut W, } impl<'a> _CC2SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1FW<'a> { w: &'a mut W, } impl<'a> _IC1FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1PSCW<'a> { w: &'a mut W, } impl<'a> _IC1PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - Input capture 2 filter"] #[inline] pub fn ic2f(&self) -> IC2FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC2FR { bits } } #[doc = "Bits 10:11 - Input capture 2 prescaler"] #[inline] pub fn ic2psc(&self) -> IC2PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC2PSCR { bits } } #[doc = "Bits 8:9 - Capture/compare 2 selection"] #[inline] pub fn cc2s(&self) -> CC2SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC2SR { bits } } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&self) -> IC1FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1FR { bits } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&self) -> IC1PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1PSCR { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - Input capture 2 filter"] #[inline] pub fn ic2f(&mut self) -> _IC2FW { _IC2FW { w: self } } #[doc = "Bits 10:11 - Input capture 2 prescaler"] #[inline] pub fn ic2psc(&mut self) -> _IC2PSCW { _IC2PSCW { w: self } } #[doc = "Bits 8:9 - Capture/compare 2 selection"] #[inline] pub fn cc2s(&mut self) -> _CC2SW { _CC2SW { w: self } } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&mut self) -> _IC1FW { _IC1FW { w: self } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&mut self) -> _IC1PSCW { _IC1PSCW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare mode register 2 (output mode)"] pub struct CCMR2_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 2 (output mode)"] pub mod ccmr2_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR2_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OC4CER { bits: bool, } impl OC4CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC4MR { bits: u8, } impl OC4MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC4PER { bits: bool, } impl OC4PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC4FER { bits: bool, } impl OC4FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4SR { bits: u8, } impl CC4SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC3CER { bits: bool, } impl OC3CER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC3MR { bits: u8, } impl OC3MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC3PER { bits: bool, } impl OC3PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC3FER { bits: bool, } impl OC3FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3SR { bits: u8, } impl CC3SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OC4CEW<'a> { w: &'a mut W, } impl<'a> _OC4CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC4MW<'a> { w: &'a mut W, } impl<'a> _OC4MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC4PEW<'a> { w: &'a mut W, } impl<'a> _OC4PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC4FEW<'a> { w: &'a mut W, } impl<'a> _OC4FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4SW<'a> { w: &'a mut W, } impl<'a> _CC4SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3CEW<'a> { w: &'a mut W, } impl<'a> _OC3CEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3MW<'a> { w: &'a mut W, } impl<'a> _OC3MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3PEW<'a> { w: &'a mut W, } impl<'a> _OC3PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC3FEW<'a> { w: &'a mut W, } impl<'a> _OC3FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3SW<'a> { w: &'a mut W, } impl<'a> _CC3SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Output compare 4 clear enable"] #[inline] pub fn oc4ce(&self) -> OC4CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC4CER { bits } } #[doc = "Bits 12:14 - Output compare 4 mode"] #[inline] pub fn oc4m(&self) -> OC4MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC4MR { bits } } #[doc = "Bit 11 - Output compare 4 preload enable"] #[inline] pub fn oc4pe(&self) -> OC4PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC4PER { bits } } #[doc = "Bit 10 - Output compare 4 fast enable"] #[inline] pub fn oc4fe(&self) -> OC4FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC4FER { bits } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&self) -> CC4SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC4SR { bits } } #[doc = "Bit 7 - Output compare 3 clear enable"] #[inline] pub fn oc3ce(&self) -> OC3CER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC3CER { bits } } #[doc = "Bits 4:6 - Output compare 3 mode"] #[inline] pub fn oc3m(&self) -> OC3MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC3MR { bits } } #[doc = "Bit 3 - Output compare 3 preload enable"] #[inline] pub fn oc3pe(&self) -> OC3PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC3PER { bits } } #[doc = "Bit 2 - Output compare 3 fast enable"] #[inline] pub fn oc3fe(&self) -> OC3FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC3FER { bits } } #[doc = "Bits 0:1 - Capture/Compare 3 selection"] #[inline] pub fn cc3s(&self) -> CC3SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC3SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Output compare 4 clear enable"] #[inline] pub fn oc4ce(&mut self) -> _OC4CEW { _OC4CEW { w: self } } #[doc = "Bits 12:14 - Output compare 4 mode"] #[inline] pub fn oc4m(&mut self) -> _OC4MW { _OC4MW { w: self } } #[doc = "Bit 11 - Output compare 4 preload enable"] #[inline] pub fn oc4pe(&mut self) -> _OC4PEW { _OC4PEW { w: self } } #[doc = "Bit 10 - Output compare 4 fast enable"] #[inline] pub fn oc4fe(&mut self) -> _OC4FEW { _OC4FEW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&mut self) -> _CC4SW { _CC4SW { w: self } } #[doc = "Bit 7 - Output compare 3 clear enable"] #[inline] pub fn oc3ce(&mut self) -> _OC3CEW { _OC3CEW { w: self } } #[doc = "Bits 4:6 - Output compare 3 mode"] #[inline] pub fn oc3m(&mut self) -> _OC3MW { _OC3MW { w: self } } #[doc = "Bit 3 - Output compare 3 preload enable"] #[inline] pub fn oc3pe(&mut self) -> _OC3PEW { _OC3PEW { w: self } } #[doc = "Bit 2 - Output compare 3 fast enable"] #[inline] pub fn oc3fe(&mut self) -> _OC3FEW { _OC3FEW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 3 selection"] #[inline] pub fn cc3s(&mut self) -> _CC3SW { _CC3SW { w: self } } } } #[doc = "capture/compare mode register 2 (input mode)"] pub struct CCMR2_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 2 (input mode)"] pub mod ccmr2_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR2_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC4FR { bits: u8, } impl IC4FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC4PSCR { bits: u8, } impl IC4PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC4SR { bits: u8, } impl CC4SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC3FR { bits: u8, } impl IC3FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC3PSCR { bits: u8, } impl IC3PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC3SR { bits: u8, } impl CC3SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC4FW<'a> { w: &'a mut W, } impl<'a> _IC4FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC4PSCW<'a> { w: &'a mut W, } impl<'a> _IC4PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4SW<'a> { w: &'a mut W, } impl<'a> _CC4SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC3FW<'a> { w: &'a mut W, } impl<'a> _IC3FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC3PSCW<'a> { w: &'a mut W, } impl<'a> _IC3PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3SW<'a> { w: &'a mut W, } impl<'a> _CC3SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - Input capture 4 filter"] #[inline] pub fn ic4f(&self) -> IC4FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC4FR { bits } } #[doc = "Bits 10:11 - Input capture 4 prescaler"] #[inline] pub fn ic4psc(&self) -> IC4PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC4PSCR { bits } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&self) -> CC4SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC4SR { bits } } #[doc = "Bits 4:7 - Input capture 3 filter"] #[inline] pub fn ic3f(&self) -> IC3FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC3FR { bits } } #[doc = "Bits 2:3 - Input capture 3 prescaler"] #[inline] pub fn ic3psc(&self) -> IC3PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC3PSCR { bits } } #[doc = "Bits 0:1 - Capture/Compare 3 selection"] #[inline] pub fn cc3s(&self) -> CC3SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC3SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - Input capture 4 filter"] #[inline] pub fn ic4f(&mut self) -> _IC4FW { _IC4FW { w: self } } #[doc = "Bits 10:11 - Input capture 4 prescaler"] #[inline] pub fn ic4psc(&mut self) -> _IC4PSCW { _IC4PSCW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 4 selection"] #[inline] pub fn cc4s(&mut self) -> _CC4SW { _CC4SW { w: self } } #[doc = "Bits 4:7 - Input capture 3 filter"] #[inline] pub fn ic3f(&mut self) -> _IC3FW { _IC3FW { w: self } } #[doc = "Bits 2:3 - Input capture 3 prescaler"] #[inline] pub fn ic3psc(&mut self) -> _IC3PSCW { _IC3PSCW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 3 selection"] #[inline] pub fn cc3s(&mut self) -> _CC3SW { _CC3SW { w: self } } } } #[doc = "capture/compare enable register"] pub struct CCER { register: ::vcell::VolatileCell, } #[doc = "capture/compare enable register"] pub mod ccer { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC4NPR { bits: bool, } impl CC4NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4PR { bits: bool, } impl CC4PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC4ER { bits: bool, } impl CC4ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3NPR { bits: bool, } impl CC3NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3PR { bits: bool, } impl CC3PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC3ER { bits: bool, } impl CC3ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2NPR { bits: bool, } impl CC2NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2PR { bits: bool, } impl CC2PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2ER { bits: bool, } impl CC2ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1NPR { bits: bool, } impl CC1NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1PR { bits: bool, } impl CC1PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1ER { bits: bool, } impl CC1ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC4NPW<'a> { w: &'a mut W, } impl<'a> _CC4NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4PW<'a> { w: &'a mut W, } impl<'a> _CC4PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC4EW<'a> { w: &'a mut W, } impl<'a> _CC4EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3NPW<'a> { w: &'a mut W, } impl<'a> _CC3NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3PW<'a> { w: &'a mut W, } impl<'a> _CC3PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC3EW<'a> { w: &'a mut W, } impl<'a> _CC3EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2NPW<'a> { w: &'a mut W, } impl<'a> _CC2NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2PW<'a> { w: &'a mut W, } impl<'a> _CC2PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2EW<'a> { w: &'a mut W, } impl<'a> _CC2EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1NPW<'a> { w: &'a mut W, } impl<'a> _CC1NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1PW<'a> { w: &'a mut W, } impl<'a> _CC1PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1EW<'a> { w: &'a mut W, } impl<'a> _CC1EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] #[inline] pub fn cc4np(&self) -> CC4NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4NPR { bits } } #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc4p(&self) -> CC4PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4PR { bits } } #[doc = "Bit 12 - Capture/Compare 4 output enable"] #[inline] pub fn cc4e(&self) -> CC4ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC4ER { bits } } #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3np(&self) -> CC3NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3NPR { bits } } #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3p(&self) -> CC3PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3PR { bits } } #[doc = "Bit 8 - Capture/Compare 3 output enable"] #[inline] pub fn cc3e(&self) -> CC3ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC3ER { bits } } #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2np(&self) -> CC2NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2NPR { bits } } #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2p(&self) -> CC2PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2PR { bits } } #[doc = "Bit 4 - Capture/Compare 2 output enable"] #[inline] pub fn cc2e(&self) -> CC2ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2ER { bits } } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&self) -> CC1NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NPR { bits } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&self) -> CC1PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1PR { bits } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&self) -> CC1ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1ER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Capture/Compare 4 output Polarity"] #[inline] pub fn cc4np(&mut self) -> _CC4NPW { _CC4NPW { w: self } } #[doc = "Bit 13 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc4p(&mut self) -> _CC4PW { _CC4PW { w: self } } #[doc = "Bit 12 - Capture/Compare 4 output enable"] #[inline] pub fn cc4e(&mut self) -> _CC4EW { _CC4EW { w: self } } #[doc = "Bit 11 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3np(&mut self) -> _CC3NPW { _CC3NPW { w: self } } #[doc = "Bit 9 - Capture/Compare 3 output Polarity"] #[inline] pub fn cc3p(&mut self) -> _CC3PW { _CC3PW { w: self } } #[doc = "Bit 8 - Capture/Compare 3 output enable"] #[inline] pub fn cc3e(&mut self) -> _CC3EW { _CC3EW { w: self } } #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2np(&mut self) -> _CC2NPW { _CC2NPW { w: self } } #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2p(&mut self) -> _CC2PW { _CC2PW { w: self } } #[doc = "Bit 4 - Capture/Compare 2 output enable"] #[inline] pub fn cc2e(&mut self) -> _CC2EW { _CC2EW { w: self } } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&mut self) -> _CC1NPW { _CC1NPW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&mut self) -> _CC1PW { _CC1PW { w: self } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&mut self) -> _CC1EW { _CC1EW { w: self } } } } #[doc = "counter"] pub struct CNT { register: ::vcell::VolatileCell, } #[doc = "counter"] pub mod cnt { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CNT_HR { bits: u16, } impl CNT_HR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct CNT_LR { bits: u16, } impl CNT_LR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CNT_HW<'a> { w: &'a mut W, } impl<'a> _CNT_HW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CNT_LW<'a> { w: &'a mut W, } impl<'a> _CNT_LW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:31 - High counter value (TIM2 only)"] #[inline] pub fn cnt_h(&self) -> CNT_HR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNT_HR { bits } } #[doc = "Bits 0:15 - Low counter value"] #[inline] pub fn cnt_l(&self) -> CNT_LR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNT_LR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:31 - High counter value (TIM2 only)"] #[inline] pub fn cnt_h(&mut self) -> _CNT_HW { _CNT_HW { w: self } } #[doc = "Bits 0:15 - Low counter value"] #[inline] pub fn cnt_l(&mut self) -> _CNT_LW { _CNT_LW { w: self } } } } #[doc = "prescaler"] pub struct PSC { register: ::vcell::VolatileCell, } #[doc = "prescaler"] pub mod psc { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PSC { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PSCR { bits: u16, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "auto-reload register"] pub struct ARR { register: ::vcell::VolatileCell, } #[doc = "auto-reload register"] pub mod arr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ARR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARR_HR { bits: u16, } impl ARR_HR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct ARR_LR { bits: u16, } impl ARR_LR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _ARR_HW<'a> { w: &'a mut W, } impl<'a> _ARR_HW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARR_LW<'a> { w: &'a mut W, } impl<'a> _ARR_LW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:31 - High Auto-reload value (TIM2 only)"] #[inline] pub fn arr_h(&self) -> ARR_HR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARR_HR { bits } } #[doc = "Bits 0:15 - Low Auto-reload value"] #[inline] pub fn arr_l(&self) -> ARR_LR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARR_LR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:31 - High Auto-reload value (TIM2 only)"] #[inline] pub fn arr_h(&mut self) -> _ARR_HW { _ARR_HW { w: self } } #[doc = "Bits 0:15 - Low Auto-reload value"] #[inline] pub fn arr_l(&mut self) -> _ARR_LW { _ARR_LW { w: self } } } } #[doc = "capture/compare register 1"] pub struct CCR1 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 1"] pub mod ccr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR1_HR { bits: u16, } impl CCR1_HR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct CCR1_LR { bits: u16, } impl CCR1_LR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR1_HW<'a> { w: &'a mut W, } impl<'a> _CCR1_HW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCR1_LW<'a> { w: &'a mut W, } impl<'a> _CCR1_LW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:31 - High Capture/Compare 1 value (TIM2 only)"] #[inline] pub fn ccr1_h(&self) -> CCR1_HR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR1_HR { bits } } #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] #[inline] pub fn ccr1_l(&self) -> CCR1_LR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR1_LR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:31 - High Capture/Compare 1 value (TIM2 only)"] #[inline] pub fn ccr1_h(&mut self) -> _CCR1_HW { _CCR1_HW { w: self } } #[doc = "Bits 0:15 - Low Capture/Compare 1 value"] #[inline] pub fn ccr1_l(&mut self) -> _CCR1_LW { _CCR1_LW { w: self } } } } #[doc = "capture/compare register 2"] pub struct CCR2 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 2"] pub mod ccr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR2_HR { bits: u16, } impl CCR2_HR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct CCR2_LR { bits: u16, } impl CCR2_LR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR2_HW<'a> { w: &'a mut W, } impl<'a> _CCR2_HW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCR2_LW<'a> { w: &'a mut W, } impl<'a> _CCR2_LW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:31 - High Capture/Compare 2 value (TIM2 only)"] #[inline] pub fn ccr2_h(&self) -> CCR2_HR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR2_HR { bits } } #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] #[inline] pub fn ccr2_l(&self) -> CCR2_LR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR2_LR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:31 - High Capture/Compare 2 value (TIM2 only)"] #[inline] pub fn ccr2_h(&mut self) -> _CCR2_HW { _CCR2_HW { w: self } } #[doc = "Bits 0:15 - Low Capture/Compare 2 value"] #[inline] pub fn ccr2_l(&mut self) -> _CCR2_LW { _CCR2_LW { w: self } } } } #[doc = "capture/compare register 3"] pub struct CCR3 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 3"] pub mod ccr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR3_HR { bits: u16, } impl CCR3_HR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct CCR3_LR { bits: u16, } impl CCR3_LR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR3_HW<'a> { w: &'a mut W, } impl<'a> _CCR3_HW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCR3_LW<'a> { w: &'a mut W, } impl<'a> _CCR3_LW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:31 - High Capture/Compare value (TIM2 only)"] #[inline] pub fn ccr3_h(&self) -> CCR3_HR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR3_HR { bits } } #[doc = "Bits 0:15 - Low Capture/Compare value"] #[inline] pub fn ccr3_l(&self) -> CCR3_LR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR3_LR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:31 - High Capture/Compare value (TIM2 only)"] #[inline] pub fn ccr3_h(&mut self) -> _CCR3_HW { _CCR3_HW { w: self } } #[doc = "Bits 0:15 - Low Capture/Compare value"] #[inline] pub fn ccr3_l(&mut self) -> _CCR3_LW { _CCR3_LW { w: self } } } } #[doc = "capture/compare register 4"] pub struct CCR4 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 4"] pub mod ccr4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR4_HR { bits: u16, } impl CCR4_HR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct CCR4_LR { bits: u16, } impl CCR4_LR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR4_HW<'a> { w: &'a mut W, } impl<'a> _CCR4_HW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCR4_LW<'a> { w: &'a mut W, } impl<'a> _CCR4_LW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:31 - High Capture/Compare value (TIM2 only)"] #[inline] pub fn ccr4_h(&self) -> CCR4_HR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR4_HR { bits } } #[doc = "Bits 0:15 - Low Capture/Compare value"] #[inline] pub fn ccr4_l(&self) -> CCR4_LR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR4_LR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:31 - High Capture/Compare value (TIM2 only)"] #[inline] pub fn ccr4_h(&mut self) -> _CCR4_HW { _CCR4_HW { w: self } } #[doc = "Bits 0:15 - Low Capture/Compare value"] #[inline] pub fn ccr4_l(&mut self) -> _CCR4_LW { _CCR4_LW { w: self } } } } #[doc = "DMA control register"] pub struct DCR { register: ::vcell::VolatileCell, } #[doc = "DMA control register"] pub mod dcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBLR { bits: u8, } impl DBLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DBAR { bits: u8, } impl DBAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _DBLW<'a> { w: &'a mut W, } impl<'a> _DBLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBAW<'a> { w: &'a mut W, } impl<'a> _DBAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&self) -> DBLR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBLR { bits } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&self) -> DBAR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&mut self) -> _DBLW { _DBLW { w: self } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&mut self) -> _DBAW { _DBAW { w: self } } } } #[doc = "DMA address for full transfer"] pub struct DMAR { register: ::vcell::VolatileCell, } #[doc = "DMA address for full transfer"] pub mod dmar { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DMAR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DMARR { bits: u16, } impl DMARR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _DMARW<'a> { w: &'a mut W, } impl<'a> _DMARW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmar(&self) -> DMARR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DMARR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmar(&mut self) -> _DMARW { _DMARW { w: self } } } } } #[doc = "General-purpose-timers"] 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 tim14::RegisterBlock { 0x4000_2000 as *const _ } } impl Deref for TIM14 { type Target = tim14::RegisterBlock; fn deref(&self) -> &tim14::RegisterBlock { unsafe { &*TIM14::ptr() } } } #[doc = "General-purpose-timers"] pub mod tim14 { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, _reserved0: [u8; 8usize], #[doc = "0x0c - DMA/Interrupt enable register"] pub dier: DIER, #[doc = "0x10 - status register"] pub sr: SR, #[doc = "0x14 - event generation register"] pub egr: EGR, #[doc = "0x18 - capture/compare mode register (output mode)"] pub ccmr1_output: CCMR1_OUTPUT, _reserved1: [u8; 4usize], #[doc = "0x20 - capture/compare enable register"] pub ccer: CCER, #[doc = "0x24 - counter"] pub cnt: CNT, #[doc = "0x28 - prescaler"] pub psc: PSC, #[doc = "0x2c - auto-reload register"] pub arr: ARR, _reserved2: [u8; 4usize], #[doc = "0x34 - capture/compare register 1"] pub ccr1: CCR1, _reserved3: [u8; 24usize], #[doc = "0x50 - option register"] pub or: OR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CKDR { bits: u8, } impl CKDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ARPER { bits: bool, } impl ARPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct URSR { bits: bool, } impl URSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDISR { bits: bool, } impl UDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CENR { bits: bool, } impl CENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CKDW<'a> { w: &'a mut W, } impl<'a> _CKDW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARPEW<'a> { w: &'a mut W, } impl<'a> _ARPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _URSW<'a> { w: &'a mut W, } impl<'a> _URSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDISW<'a> { w: &'a mut W, } impl<'a> _UDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CENW<'a> { w: &'a mut W, } impl<'a> _CENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&self) -> CKDR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CKDR { bits } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&self) -> ARPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARPER { bits } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&self) -> URSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; URSR { bits } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&self) -> UDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDISR { bits } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&self) -> CENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&mut self) -> _CKDW { _CKDW { w: self } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&mut self) -> _ARPEW { _ARPEW { w: self } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&mut self) -> _URSW { _URSW { w: self } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&mut self) -> _UDISW { _UDISW { w: self } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&mut self) -> _CENW { _CENW { w: self } } } } #[doc = "DMA/Interrupt enable register"] pub struct DIER { register: ::vcell::VolatileCell, } #[doc = "DMA/Interrupt enable register"] pub mod dier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC1IER { bits: bool, } impl CC1IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIER { bits: bool, } impl UIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC1IEW<'a> { w: &'a mut W, } impl<'a> _CC1IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIEW<'a> { w: &'a mut W, } impl<'a> _UIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&self) -> CC1IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IER { bits } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&self) -> UIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&mut self) -> _CC1IEW { _CC1IEW { w: self } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&mut self) -> _UIEW { _UIEW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC1OFR { bits: bool, } impl CC1OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IFR { bits: bool, } impl CC1IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIFR { bits: bool, } impl UIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC1OFW<'a> { w: &'a mut W, } impl<'a> _CC1OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IFW<'a> { w: &'a mut W, } impl<'a> _CC1IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIFW<'a> { w: &'a mut W, } impl<'a> _UIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&self) -> CC1OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1OFR { bits } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&self) -> CC1IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IFR { bits } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&self) -> UIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&mut self) -> _CC1OFW { _CC1OFW { w: self } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&mut self) -> _CC1IFW { _CC1IFW { w: self } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&mut self) -> _UIFW { _UIFW { w: self } } } } #[doc = "event generation register"] pub struct EGR { register: ::vcell::VolatileCell, } #[doc = "event generation register"] pub mod egr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EGR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _CC1GW<'a> { w: &'a mut W, } impl<'a> _CC1GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UGW<'a> { w: &'a mut W, } impl<'a> _UGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 1 - Capture/compare 1 generation"] #[inline] pub fn cc1g(&mut self) -> _CC1GW { _CC1GW { w: self } } #[doc = "Bit 0 - Update generation"] #[inline] pub fn ug(&mut self) -> _UGW { _UGW { w: self } } } } #[doc = "capture/compare mode register (output mode)"] pub struct CCMR1_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register (output mode)"] pub mod ccmr1_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1FER { bits: bool, } impl OC1FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1PER { bits: bool, } impl OC1PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1MR { bits: u8, } impl OC1MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1FEW<'a> { w: &'a mut W, } impl<'a> _OC1FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1PEW<'a> { w: &'a mut W, } impl<'a> _OC1PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1MW<'a> { w: &'a mut W, } impl<'a> _OC1MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } #[doc = "Bit 2 - Output compare 1 fast enable"] #[inline] pub fn oc1fe(&self) -> OC1FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1FER { bits } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&self) -> OC1PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1PER { bits } } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&self) -> OC1MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC1MR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } #[doc = "Bit 2 - Output compare 1 fast enable"] #[inline] pub fn oc1fe(&mut self) -> _OC1FEW { _OC1FEW { w: self } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&mut self) -> _OC1PEW { _OC1PEW { w: self } } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&mut self) -> _OC1MW { _OC1MW { w: self } } } } #[doc = "capture/compare mode register (input mode)"] pub struct CCMR1_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register (input mode)"] pub mod ccmr1_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC1FR { bits: u8, } impl IC1FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1PSCR { bits: u8, } impl IC1PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC1FW<'a> { w: &'a mut W, } impl<'a> _IC1FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1PSCW<'a> { w: &'a mut W, } impl<'a> _IC1PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&self) -> IC1FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1FR { bits } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&self) -> IC1PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1PSCR { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&mut self) -> _IC1FW { _IC1FW { w: self } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&mut self) -> _IC1PSCW { _IC1PSCW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare enable register"] pub struct CCER { register: ::vcell::VolatileCell, } #[doc = "capture/compare enable register"] pub mod ccer { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC1NPR { bits: bool, } impl CC1NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1PR { bits: bool, } impl CC1PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1ER { bits: bool, } impl CC1ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC1NPW<'a> { w: &'a mut W, } impl<'a> _CC1NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1PW<'a> { w: &'a mut W, } impl<'a> _CC1PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1EW<'a> { w: &'a mut W, } impl<'a> _CC1EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&self) -> CC1NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NPR { bits } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&self) -> CC1PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1PR { bits } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&self) -> CC1ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1ER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&mut self) -> _CC1NPW { _CC1NPW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&mut self) -> _CC1PW { _CC1PW { w: self } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&mut self) -> _CC1EW { _CC1EW { w: self } } } } #[doc = "counter"] pub struct CNT { register: ::vcell::VolatileCell, } #[doc = "counter"] pub mod cnt { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CNTR { bits: u16, } impl CNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CNTW<'a> { w: &'a mut W, } impl<'a> _CNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&self) -> CNTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&mut self) -> _CNTW { _CNTW { w: self } } } } #[doc = "prescaler"] pub struct PSC { register: ::vcell::VolatileCell, } #[doc = "prescaler"] pub mod psc { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PSC { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PSCR { bits: u16, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "auto-reload register"] pub struct ARR { register: ::vcell::VolatileCell, } #[doc = "auto-reload register"] pub mod arr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ARR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARRR { bits: u16, } impl ARRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _ARRW<'a> { w: &'a mut W, } impl<'a> _ARRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&self) -> ARRR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&mut self) -> _ARRW { _ARRW { w: self } } } } #[doc = "capture/compare register 1"] pub struct CCR1 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 1"] pub mod ccr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR1R { bits: u16, } impl CCR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR1W<'a> { w: &'a mut W, } impl<'a> _CCR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&self) -> CCR1R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR1R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&mut self) -> _CCR1W { _CCR1W { w: self } } } } #[doc = "option register"] pub struct OR { register: ::vcell::VolatileCell, } #[doc = "option register"] pub mod or { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct RMPR { bits: u8, } impl RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _RMPW<'a> { w: &'a mut W, } impl<'a> _RMPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:1 - Timer input 1 remap"] #[inline] pub fn rmp(&self) -> RMPR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; RMPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:1 - Timer input 1 remap"] #[inline] pub fn rmp(&mut self) -> _RMPW { _RMPW { w: self } } } } } #[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 { 0x4000_1000 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, #[doc = "0x04 - control register 2"] pub cr2: CR2, _reserved0: [u8; 4usize], #[doc = "0x0c - DMA/Interrupt enable register"] pub dier: DIER, #[doc = "0x10 - status register"] pub sr: SR, #[doc = "0x14 - event generation register"] pub egr: EGR, _reserved1: [u8; 12usize], #[doc = "0x24 - counter"] pub cnt: CNT, #[doc = "0x28 - prescaler"] pub psc: PSC, #[doc = "0x2c - auto-reload register"] pub arr: ARR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARPER { bits: bool, } impl ARPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPMR { bits: bool, } impl OPMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct URSR { bits: bool, } impl URSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDISR { bits: bool, } impl UDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CENR { bits: bool, } impl CENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ARPEW<'a> { w: &'a mut W, } impl<'a> _ARPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPMW<'a> { w: &'a mut W, } impl<'a> _OPMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _URSW<'a> { w: &'a mut W, } impl<'a> _URSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDISW<'a> { w: &'a mut W, } impl<'a> _UDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CENW<'a> { w: &'a mut W, } impl<'a> _CENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&self) -> ARPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARPER { bits } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&self) -> OPMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPMR { bits } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&self) -> URSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; URSR { bits } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&self) -> UDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDISR { bits } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&self) -> CENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&mut self) -> _ARPEW { _ARPEW { w: self } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&mut self) -> _OPMW { _OPMW { w: self } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&mut self) -> _URSW { _URSW { w: self } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&mut self) -> _UDISW { _UDISW { w: self } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&mut self) -> _CENW { _CENW { w: self } } } } #[doc = "control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MMSR { bits: u8, } impl MMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MMSW<'a> { w: &'a mut W, } impl<'a> _MMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&self) -> MMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MMSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&mut self) -> _MMSW { _MMSW { w: self } } } } #[doc = "DMA/Interrupt enable register"] pub struct DIER { register: ::vcell::VolatileCell, } #[doc = "DMA/Interrupt enable register"] pub mod dier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct UDER { bits: bool, } impl UDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIER { bits: bool, } impl UIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _UDEW<'a> { w: &'a mut W, } impl<'a> _UDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIEW<'a> { w: &'a mut W, } impl<'a> _UIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&self) -> UDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDER { bits } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&self) -> UIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&mut self) -> _UDEW { _UDEW { w: self } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&mut self) -> _UIEW { _UIEW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct UIFR { bits: bool, } impl UIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _UIFW<'a> { w: &'a mut W, } impl<'a> _UIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&self) -> UIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&mut self) -> _UIFW { _UIFW { w: self } } } } #[doc = "event generation register"] pub struct EGR { register: ::vcell::VolatileCell, } #[doc = "event generation register"] pub mod egr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EGR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _UGW<'a> { w: &'a mut W, } impl<'a> _UGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Update generation"] #[inline] pub fn ug(&mut self) -> _UGW { _UGW { w: self } } } } #[doc = "counter"] pub struct CNT { register: ::vcell::VolatileCell, } #[doc = "counter"] pub mod cnt { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CNTR { bits: u16, } impl CNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CNTW<'a> { w: &'a mut W, } impl<'a> _CNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Low counter value"] #[inline] pub fn cnt(&self) -> CNTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Low counter value"] #[inline] pub fn cnt(&mut self) -> _CNTW { _CNTW { w: self } } } } #[doc = "prescaler"] pub struct PSC { register: ::vcell::VolatileCell, } #[doc = "prescaler"] pub mod psc { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PSC { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PSCR { bits: u16, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "auto-reload register"] pub struct ARR { register: ::vcell::VolatileCell, } #[doc = "auto-reload register"] pub mod arr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ARR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARRR { bits: u16, } impl ARRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _ARRW<'a> { w: &'a mut W, } impl<'a> _ARRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Low Auto-reload value"] #[inline] pub fn arr(&self) -> ARRR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Low Auto-reload value"] #[inline] pub fn arr(&mut self) -> _ARRW { _ARRW { w: self } } } } } #[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 { 0x4001_0400 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Interrupt mask register (EXTI_IMR)"] pub imr: IMR, #[doc = "0x04 - Event mask register (EXTI_EMR)"] pub emr: EMR, #[doc = "0x08 - Rising Trigger selection register (EXTI_RTSR)"] pub rtsr: RTSR, #[doc = "0x0c - Falling Trigger selection register (EXTI_FTSR)"] pub ftsr: FTSR, #[doc = "0x10 - Software interrupt event register (EXTI_SWIER)"] pub swier: SWIER, #[doc = "0x14 - Pending register (EXTI_PR)"] pub pr: PR, } #[doc = "Interrupt mask register (EXTI_IMR)"] pub struct IMR { register: ::vcell::VolatileCell, } #[doc = "Interrupt mask register (EXTI_IMR)"] pub mod imr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::IMR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MR0R { bits: bool, } impl MR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR1R { bits: bool, } impl MR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR2R { bits: bool, } impl MR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR3R { bits: bool, } impl MR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR4R { bits: bool, } impl MR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR5R { bits: bool, } impl MR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR6R { bits: bool, } impl MR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR7R { bits: bool, } impl MR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR8R { bits: bool, } impl MR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR9R { bits: bool, } impl MR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR10R { bits: bool, } impl MR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR11R { bits: bool, } impl MR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR12R { bits: bool, } impl MR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR13R { bits: bool, } impl MR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR14R { bits: bool, } impl MR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR15R { bits: bool, } impl MR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR16R { bits: bool, } impl MR16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR17R { bits: bool, } impl MR17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR18R { bits: bool, } impl MR18R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR19R { bits: bool, } impl MR19R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR20R { bits: bool, } impl MR20R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR21R { bits: bool, } impl MR21R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR22R { bits: bool, } impl MR22R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR23R { bits: bool, } impl MR23R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR24R { bits: bool, } impl MR24R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR25R { bits: bool, } impl MR25R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR26R { bits: bool, } impl MR26R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR27R { bits: bool, } impl MR27R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _MR0W<'a> { w: &'a mut W, } impl<'a> _MR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR1W<'a> { w: &'a mut W, } impl<'a> _MR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR2W<'a> { w: &'a mut W, } impl<'a> _MR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR3W<'a> { w: &'a mut W, } impl<'a> _MR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR4W<'a> { w: &'a mut W, } impl<'a> _MR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR5W<'a> { w: &'a mut W, } impl<'a> _MR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR6W<'a> { w: &'a mut W, } impl<'a> _MR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR7W<'a> { w: &'a mut W, } impl<'a> _MR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR8W<'a> { w: &'a mut W, } impl<'a> _MR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR9W<'a> { w: &'a mut W, } impl<'a> _MR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR10W<'a> { w: &'a mut W, } impl<'a> _MR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR11W<'a> { w: &'a mut W, } impl<'a> _MR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR12W<'a> { w: &'a mut W, } impl<'a> _MR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR13W<'a> { w: &'a mut W, } impl<'a> _MR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR14W<'a> { w: &'a mut W, } impl<'a> _MR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR15W<'a> { w: &'a mut W, } impl<'a> _MR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR16W<'a> { w: &'a mut W, } impl<'a> _MR16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR17W<'a> { w: &'a mut W, } impl<'a> _MR17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR18W<'a> { w: &'a mut W, } impl<'a> _MR18W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR19W<'a> { w: &'a mut W, } impl<'a> _MR19W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR20W<'a> { w: &'a mut W, } impl<'a> _MR20W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR21W<'a> { w: &'a mut W, } impl<'a> _MR21W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR22W<'a> { w: &'a mut W, } impl<'a> _MR22W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR23W<'a> { w: &'a mut W, } impl<'a> _MR23W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR24W<'a> { w: &'a mut W, } impl<'a> _MR24W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR25W<'a> { w: &'a mut W, } impl<'a> _MR25W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR26W<'a> { w: &'a mut W, } impl<'a> _MR26W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR27W<'a> { w: &'a mut W, } impl<'a> _MR27W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Interrupt Mask on line 0"] #[inline] pub fn mr0(&self) -> MR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR0R { bits } } #[doc = "Bit 1 - Interrupt Mask on line 1"] #[inline] pub fn mr1(&self) -> MR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR1R { bits } } #[doc = "Bit 2 - Interrupt Mask on line 2"] #[inline] pub fn mr2(&self) -> MR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR2R { bits } } #[doc = "Bit 3 - Interrupt Mask on line 3"] #[inline] pub fn mr3(&self) -> MR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR3R { bits } } #[doc = "Bit 4 - Interrupt Mask on line 4"] #[inline] pub fn mr4(&self) -> MR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR4R { bits } } #[doc = "Bit 5 - Interrupt Mask on line 5"] #[inline] pub fn mr5(&self) -> MR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR5R { bits } } #[doc = "Bit 6 - Interrupt Mask on line 6"] #[inline] pub fn mr6(&self) -> MR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR6R { bits } } #[doc = "Bit 7 - Interrupt Mask on line 7"] #[inline] pub fn mr7(&self) -> MR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR7R { bits } } #[doc = "Bit 8 - Interrupt Mask on line 8"] #[inline] pub fn mr8(&self) -> MR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR8R { bits } } #[doc = "Bit 9 - Interrupt Mask on line 9"] #[inline] pub fn mr9(&self) -> MR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR9R { bits } } #[doc = "Bit 10 - Interrupt Mask on line 10"] #[inline] pub fn mr10(&self) -> MR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR10R { bits } } #[doc = "Bit 11 - Interrupt Mask on line 11"] #[inline] pub fn mr11(&self) -> MR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR11R { bits } } #[doc = "Bit 12 - Interrupt Mask on line 12"] #[inline] pub fn mr12(&self) -> MR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR12R { bits } } #[doc = "Bit 13 - Interrupt Mask on line 13"] #[inline] pub fn mr13(&self) -> MR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR13R { bits } } #[doc = "Bit 14 - Interrupt Mask on line 14"] #[inline] pub fn mr14(&self) -> MR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR14R { bits } } #[doc = "Bit 15 - Interrupt Mask on line 15"] #[inline] pub fn mr15(&self) -> MR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR15R { bits } } #[doc = "Bit 16 - Interrupt Mask on line 16"] #[inline] pub fn mr16(&self) -> MR16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR16R { bits } } #[doc = "Bit 17 - Interrupt Mask on line 17"] #[inline] pub fn mr17(&self) -> MR17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR17R { bits } } #[doc = "Bit 18 - Interrupt Mask on line 18"] #[inline] pub fn mr18(&self) -> MR18R { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR18R { bits } } #[doc = "Bit 19 - Interrupt Mask on line 19"] #[inline] pub fn mr19(&self) -> MR19R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR19R { bits } } #[doc = "Bit 20 - Interrupt Mask on line 20"] #[inline] pub fn mr20(&self) -> MR20R { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR20R { bits } } #[doc = "Bit 21 - Interrupt Mask on line 21"] #[inline] pub fn mr21(&self) -> MR21R { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR21R { bits } } #[doc = "Bit 22 - Interrupt Mask on line 22"] #[inline] pub fn mr22(&self) -> MR22R { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR22R { bits } } #[doc = "Bit 23 - Interrupt Mask on line 23"] #[inline] pub fn mr23(&self) -> MR23R { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR23R { bits } } #[doc = "Bit 24 - Interrupt Mask on line 24"] #[inline] pub fn mr24(&self) -> MR24R { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR24R { bits } } #[doc = "Bit 25 - Interrupt Mask on line 25"] #[inline] pub fn mr25(&self) -> MR25R { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR25R { bits } } #[doc = "Bit 26 - Interrupt Mask on line 26"] #[inline] pub fn mr26(&self) -> MR26R { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR26R { bits } } #[doc = "Bit 27 - Interrupt Mask on line 27"] #[inline] pub fn mr27(&self) -> MR27R { let bits = { const MASK: bool = true; const OFFSET: u8 = 27; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR27R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x0f94_0000 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Interrupt Mask on line 0"] #[inline] pub fn mr0(&mut self) -> _MR0W { _MR0W { w: self } } #[doc = "Bit 1 - Interrupt Mask on line 1"] #[inline] pub fn mr1(&mut self) -> _MR1W { _MR1W { w: self } } #[doc = "Bit 2 - Interrupt Mask on line 2"] #[inline] pub fn mr2(&mut self) -> _MR2W { _MR2W { w: self } } #[doc = "Bit 3 - Interrupt Mask on line 3"] #[inline] pub fn mr3(&mut self) -> _MR3W { _MR3W { w: self } } #[doc = "Bit 4 - Interrupt Mask on line 4"] #[inline] pub fn mr4(&mut self) -> _MR4W { _MR4W { w: self } } #[doc = "Bit 5 - Interrupt Mask on line 5"] #[inline] pub fn mr5(&mut self) -> _MR5W { _MR5W { w: self } } #[doc = "Bit 6 - Interrupt Mask on line 6"] #[inline] pub fn mr6(&mut self) -> _MR6W { _MR6W { w: self } } #[doc = "Bit 7 - Interrupt Mask on line 7"] #[inline] pub fn mr7(&mut self) -> _MR7W { _MR7W { w: self } } #[doc = "Bit 8 - Interrupt Mask on line 8"] #[inline] pub fn mr8(&mut self) -> _MR8W { _MR8W { w: self } } #[doc = "Bit 9 - Interrupt Mask on line 9"] #[inline] pub fn mr9(&mut self) -> _MR9W { _MR9W { w: self } } #[doc = "Bit 10 - Interrupt Mask on line 10"] #[inline] pub fn mr10(&mut self) -> _MR10W { _MR10W { w: self } } #[doc = "Bit 11 - Interrupt Mask on line 11"] #[inline] pub fn mr11(&mut self) -> _MR11W { _MR11W { w: self } } #[doc = "Bit 12 - Interrupt Mask on line 12"] #[inline] pub fn mr12(&mut self) -> _MR12W { _MR12W { w: self } } #[doc = "Bit 13 - Interrupt Mask on line 13"] #[inline] pub fn mr13(&mut self) -> _MR13W { _MR13W { w: self } } #[doc = "Bit 14 - Interrupt Mask on line 14"] #[inline] pub fn mr14(&mut self) -> _MR14W { _MR14W { w: self } } #[doc = "Bit 15 - Interrupt Mask on line 15"] #[inline] pub fn mr15(&mut self) -> _MR15W { _MR15W { w: self } } #[doc = "Bit 16 - Interrupt Mask on line 16"] #[inline] pub fn mr16(&mut self) -> _MR16W { _MR16W { w: self } } #[doc = "Bit 17 - Interrupt Mask on line 17"] #[inline] pub fn mr17(&mut self) -> _MR17W { _MR17W { w: self } } #[doc = "Bit 18 - Interrupt Mask on line 18"] #[inline] pub fn mr18(&mut self) -> _MR18W { _MR18W { w: self } } #[doc = "Bit 19 - Interrupt Mask on line 19"] #[inline] pub fn mr19(&mut self) -> _MR19W { _MR19W { w: self } } #[doc = "Bit 20 - Interrupt Mask on line 20"] #[inline] pub fn mr20(&mut self) -> _MR20W { _MR20W { w: self } } #[doc = "Bit 21 - Interrupt Mask on line 21"] #[inline] pub fn mr21(&mut self) -> _MR21W { _MR21W { w: self } } #[doc = "Bit 22 - Interrupt Mask on line 22"] #[inline] pub fn mr22(&mut self) -> _MR22W { _MR22W { w: self } } #[doc = "Bit 23 - Interrupt Mask on line 23"] #[inline] pub fn mr23(&mut self) -> _MR23W { _MR23W { w: self } } #[doc = "Bit 24 - Interrupt Mask on line 24"] #[inline] pub fn mr24(&mut self) -> _MR24W { _MR24W { w: self } } #[doc = "Bit 25 - Interrupt Mask on line 25"] #[inline] pub fn mr25(&mut self) -> _MR25W { _MR25W { w: self } } #[doc = "Bit 26 - Interrupt Mask on line 26"] #[inline] pub fn mr26(&mut self) -> _MR26W { _MR26W { w: self } } #[doc = "Bit 27 - Interrupt Mask on line 27"] #[inline] pub fn mr27(&mut self) -> _MR27W { _MR27W { w: self } } } } #[doc = "Event mask register (EXTI_EMR)"] pub struct EMR { register: ::vcell::VolatileCell, } #[doc = "Event mask register (EXTI_EMR)"] pub mod emr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EMR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MR0R { bits: bool, } impl MR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR1R { bits: bool, } impl MR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR2R { bits: bool, } impl MR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR3R { bits: bool, } impl MR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR4R { bits: bool, } impl MR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR5R { bits: bool, } impl MR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR6R { bits: bool, } impl MR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR7R { bits: bool, } impl MR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR8R { bits: bool, } impl MR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR9R { bits: bool, } impl MR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR10R { bits: bool, } impl MR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR11R { bits: bool, } impl MR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR12R { bits: bool, } impl MR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR13R { bits: bool, } impl MR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR14R { bits: bool, } impl MR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR15R { bits: bool, } impl MR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR16R { bits: bool, } impl MR16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR17R { bits: bool, } impl MR17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR18R { bits: bool, } impl MR18R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR19R { bits: bool, } impl MR19R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR20R { bits: bool, } impl MR20R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR21R { bits: bool, } impl MR21R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR22R { bits: bool, } impl MR22R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR23R { bits: bool, } impl MR23R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR24R { bits: bool, } impl MR24R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR25R { bits: bool, } impl MR25R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR26R { bits: bool, } impl MR26R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR27R { bits: bool, } impl MR27R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _MR0W<'a> { w: &'a mut W, } impl<'a> _MR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR1W<'a> { w: &'a mut W, } impl<'a> _MR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR2W<'a> { w: &'a mut W, } impl<'a> _MR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR3W<'a> { w: &'a mut W, } impl<'a> _MR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR4W<'a> { w: &'a mut W, } impl<'a> _MR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR5W<'a> { w: &'a mut W, } impl<'a> _MR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR6W<'a> { w: &'a mut W, } impl<'a> _MR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR7W<'a> { w: &'a mut W, } impl<'a> _MR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR8W<'a> { w: &'a mut W, } impl<'a> _MR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR9W<'a> { w: &'a mut W, } impl<'a> _MR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR10W<'a> { w: &'a mut W, } impl<'a> _MR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR11W<'a> { w: &'a mut W, } impl<'a> _MR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR12W<'a> { w: &'a mut W, } impl<'a> _MR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR13W<'a> { w: &'a mut W, } impl<'a> _MR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR14W<'a> { w: &'a mut W, } impl<'a> _MR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR15W<'a> { w: &'a mut W, } impl<'a> _MR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR16W<'a> { w: &'a mut W, } impl<'a> _MR16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR17W<'a> { w: &'a mut W, } impl<'a> _MR17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR18W<'a> { w: &'a mut W, } impl<'a> _MR18W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR19W<'a> { w: &'a mut W, } impl<'a> _MR19W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR20W<'a> { w: &'a mut W, } impl<'a> _MR20W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR21W<'a> { w: &'a mut W, } impl<'a> _MR21W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR22W<'a> { w: &'a mut W, } impl<'a> _MR22W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR23W<'a> { w: &'a mut W, } impl<'a> _MR23W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR24W<'a> { w: &'a mut W, } impl<'a> _MR24W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR25W<'a> { w: &'a mut W, } impl<'a> _MR25W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR26W<'a> { w: &'a mut W, } impl<'a> _MR26W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MR27W<'a> { w: &'a mut W, } impl<'a> _MR27W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Event Mask on line 0"] #[inline] pub fn mr0(&self) -> MR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR0R { bits } } #[doc = "Bit 1 - Event Mask on line 1"] #[inline] pub fn mr1(&self) -> MR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR1R { bits } } #[doc = "Bit 2 - Event Mask on line 2"] #[inline] pub fn mr2(&self) -> MR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR2R { bits } } #[doc = "Bit 3 - Event Mask on line 3"] #[inline] pub fn mr3(&self) -> MR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR3R { bits } } #[doc = "Bit 4 - Event Mask on line 4"] #[inline] pub fn mr4(&self) -> MR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR4R { bits } } #[doc = "Bit 5 - Event Mask on line 5"] #[inline] pub fn mr5(&self) -> MR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR5R { bits } } #[doc = "Bit 6 - Event Mask on line 6"] #[inline] pub fn mr6(&self) -> MR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR6R { bits } } #[doc = "Bit 7 - Event Mask on line 7"] #[inline] pub fn mr7(&self) -> MR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR7R { bits } } #[doc = "Bit 8 - Event Mask on line 8"] #[inline] pub fn mr8(&self) -> MR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR8R { bits } } #[doc = "Bit 9 - Event Mask on line 9"] #[inline] pub fn mr9(&self) -> MR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR9R { bits } } #[doc = "Bit 10 - Event Mask on line 10"] #[inline] pub fn mr10(&self) -> MR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR10R { bits } } #[doc = "Bit 11 - Event Mask on line 11"] #[inline] pub fn mr11(&self) -> MR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR11R { bits } } #[doc = "Bit 12 - Event Mask on line 12"] #[inline] pub fn mr12(&self) -> MR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR12R { bits } } #[doc = "Bit 13 - Event Mask on line 13"] #[inline] pub fn mr13(&self) -> MR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR13R { bits } } #[doc = "Bit 14 - Event Mask on line 14"] #[inline] pub fn mr14(&self) -> MR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR14R { bits } } #[doc = "Bit 15 - Event Mask on line 15"] #[inline] pub fn mr15(&self) -> MR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR15R { bits } } #[doc = "Bit 16 - Event Mask on line 16"] #[inline] pub fn mr16(&self) -> MR16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR16R { bits } } #[doc = "Bit 17 - Event Mask on line 17"] #[inline] pub fn mr17(&self) -> MR17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR17R { bits } } #[doc = "Bit 18 - Event Mask on line 18"] #[inline] pub fn mr18(&self) -> MR18R { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR18R { bits } } #[doc = "Bit 19 - Event Mask on line 19"] #[inline] pub fn mr19(&self) -> MR19R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR19R { bits } } #[doc = "Bit 20 - Event Mask on line 20"] #[inline] pub fn mr20(&self) -> MR20R { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR20R { bits } } #[doc = "Bit 21 - Event Mask on line 21"] #[inline] pub fn mr21(&self) -> MR21R { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR21R { bits } } #[doc = "Bit 22 - Event Mask on line 22"] #[inline] pub fn mr22(&self) -> MR22R { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR22R { bits } } #[doc = "Bit 23 - Event Mask on line 23"] #[inline] pub fn mr23(&self) -> MR23R { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR23R { bits } } #[doc = "Bit 24 - Event Mask on line 24"] #[inline] pub fn mr24(&self) -> MR24R { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR24R { bits } } #[doc = "Bit 25 - Event Mask on line 25"] #[inline] pub fn mr25(&self) -> MR25R { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR25R { bits } } #[doc = "Bit 26 - Event Mask on line 26"] #[inline] pub fn mr26(&self) -> MR26R { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR26R { bits } } #[doc = "Bit 27 - Event Mask on line 27"] #[inline] pub fn mr27(&self) -> MR27R { let bits = { const MASK: bool = true; const OFFSET: u8 = 27; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR27R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Event Mask on line 0"] #[inline] pub fn mr0(&mut self) -> _MR0W { _MR0W { w: self } } #[doc = "Bit 1 - Event Mask on line 1"] #[inline] pub fn mr1(&mut self) -> _MR1W { _MR1W { w: self } } #[doc = "Bit 2 - Event Mask on line 2"] #[inline] pub fn mr2(&mut self) -> _MR2W { _MR2W { w: self } } #[doc = "Bit 3 - Event Mask on line 3"] #[inline] pub fn mr3(&mut self) -> _MR3W { _MR3W { w: self } } #[doc = "Bit 4 - Event Mask on line 4"] #[inline] pub fn mr4(&mut self) -> _MR4W { _MR4W { w: self } } #[doc = "Bit 5 - Event Mask on line 5"] #[inline] pub fn mr5(&mut self) -> _MR5W { _MR5W { w: self } } #[doc = "Bit 6 - Event Mask on line 6"] #[inline] pub fn mr6(&mut self) -> _MR6W { _MR6W { w: self } } #[doc = "Bit 7 - Event Mask on line 7"] #[inline] pub fn mr7(&mut self) -> _MR7W { _MR7W { w: self } } #[doc = "Bit 8 - Event Mask on line 8"] #[inline] pub fn mr8(&mut self) -> _MR8W { _MR8W { w: self } } #[doc = "Bit 9 - Event Mask on line 9"] #[inline] pub fn mr9(&mut self) -> _MR9W { _MR9W { w: self } } #[doc = "Bit 10 - Event Mask on line 10"] #[inline] pub fn mr10(&mut self) -> _MR10W { _MR10W { w: self } } #[doc = "Bit 11 - Event Mask on line 11"] #[inline] pub fn mr11(&mut self) -> _MR11W { _MR11W { w: self } } #[doc = "Bit 12 - Event Mask on line 12"] #[inline] pub fn mr12(&mut self) -> _MR12W { _MR12W { w: self } } #[doc = "Bit 13 - Event Mask on line 13"] #[inline] pub fn mr13(&mut self) -> _MR13W { _MR13W { w: self } } #[doc = "Bit 14 - Event Mask on line 14"] #[inline] pub fn mr14(&mut self) -> _MR14W { _MR14W { w: self } } #[doc = "Bit 15 - Event Mask on line 15"] #[inline] pub fn mr15(&mut self) -> _MR15W { _MR15W { w: self } } #[doc = "Bit 16 - Event Mask on line 16"] #[inline] pub fn mr16(&mut self) -> _MR16W { _MR16W { w: self } } #[doc = "Bit 17 - Event Mask on line 17"] #[inline] pub fn mr17(&mut self) -> _MR17W { _MR17W { w: self } } #[doc = "Bit 18 - Event Mask on line 18"] #[inline] pub fn mr18(&mut self) -> _MR18W { _MR18W { w: self } } #[doc = "Bit 19 - Event Mask on line 19"] #[inline] pub fn mr19(&mut self) -> _MR19W { _MR19W { w: self } } #[doc = "Bit 20 - Event Mask on line 20"] #[inline] pub fn mr20(&mut self) -> _MR20W { _MR20W { w: self } } #[doc = "Bit 21 - Event Mask on line 21"] #[inline] pub fn mr21(&mut self) -> _MR21W { _MR21W { w: self } } #[doc = "Bit 22 - Event Mask on line 22"] #[inline] pub fn mr22(&mut self) -> _MR22W { _MR22W { w: self } } #[doc = "Bit 23 - Event Mask on line 23"] #[inline] pub fn mr23(&mut self) -> _MR23W { _MR23W { w: self } } #[doc = "Bit 24 - Event Mask on line 24"] #[inline] pub fn mr24(&mut self) -> _MR24W { _MR24W { w: self } } #[doc = "Bit 25 - Event Mask on line 25"] #[inline] pub fn mr25(&mut self) -> _MR25W { _MR25W { w: self } } #[doc = "Bit 26 - Event Mask on line 26"] #[inline] pub fn mr26(&mut self) -> _MR26W { _MR26W { w: self } } #[doc = "Bit 27 - Event Mask on line 27"] #[inline] pub fn mr27(&mut self) -> _MR27W { _MR27W { w: self } } } } #[doc = "Rising Trigger selection register (EXTI_RTSR)"] pub struct RTSR { register: ::vcell::VolatileCell, } #[doc = "Rising Trigger selection register (EXTI_RTSR)"] pub mod rtsr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RTSR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TR0R { bits: bool, } impl TR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR1R { bits: bool, } impl TR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR2R { bits: bool, } impl TR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR3R { bits: bool, } impl TR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR4R { bits: bool, } impl TR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR5R { bits: bool, } impl TR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR6R { bits: bool, } impl TR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR7R { bits: bool, } impl TR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR8R { bits: bool, } impl TR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR9R { bits: bool, } impl TR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR10R { bits: bool, } impl TR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR11R { bits: bool, } impl TR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR12R { bits: bool, } impl TR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR13R { bits: bool, } impl TR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR14R { bits: bool, } impl TR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR15R { bits: bool, } impl TR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR16R { bits: bool, } impl TR16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR17R { bits: bool, } impl TR17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR19R { bits: bool, } impl TR19R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TR0W<'a> { w: &'a mut W, } impl<'a> _TR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR1W<'a> { w: &'a mut W, } impl<'a> _TR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR2W<'a> { w: &'a mut W, } impl<'a> _TR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR3W<'a> { w: &'a mut W, } impl<'a> _TR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR4W<'a> { w: &'a mut W, } impl<'a> _TR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR5W<'a> { w: &'a mut W, } impl<'a> _TR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR6W<'a> { w: &'a mut W, } impl<'a> _TR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR7W<'a> { w: &'a mut W, } impl<'a> _TR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR8W<'a> { w: &'a mut W, } impl<'a> _TR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR9W<'a> { w: &'a mut W, } impl<'a> _TR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR10W<'a> { w: &'a mut W, } impl<'a> _TR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR11W<'a> { w: &'a mut W, } impl<'a> _TR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR12W<'a> { w: &'a mut W, } impl<'a> _TR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR13W<'a> { w: &'a mut W, } impl<'a> _TR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR14W<'a> { w: &'a mut W, } impl<'a> _TR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR15W<'a> { w: &'a mut W, } impl<'a> _TR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR16W<'a> { w: &'a mut W, } impl<'a> _TR16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR17W<'a> { w: &'a mut W, } impl<'a> _TR17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR19W<'a> { w: &'a mut W, } impl<'a> _TR19W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Rising trigger event configuration of line 0"] #[inline] pub fn tr0(&self) -> TR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR0R { bits } } #[doc = "Bit 1 - Rising trigger event configuration of line 1"] #[inline] pub fn tr1(&self) -> TR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR1R { bits } } #[doc = "Bit 2 - Rising trigger event configuration of line 2"] #[inline] pub fn tr2(&self) -> TR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR2R { bits } } #[doc = "Bit 3 - Rising trigger event configuration of line 3"] #[inline] pub fn tr3(&self) -> TR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR3R { bits } } #[doc = "Bit 4 - Rising trigger event configuration of line 4"] #[inline] pub fn tr4(&self) -> TR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR4R { bits } } #[doc = "Bit 5 - Rising trigger event configuration of line 5"] #[inline] pub fn tr5(&self) -> TR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR5R { bits } } #[doc = "Bit 6 - Rising trigger event configuration of line 6"] #[inline] pub fn tr6(&self) -> TR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR6R { bits } } #[doc = "Bit 7 - Rising trigger event configuration of line 7"] #[inline] pub fn tr7(&self) -> TR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR7R { bits } } #[doc = "Bit 8 - Rising trigger event configuration of line 8"] #[inline] pub fn tr8(&self) -> TR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR8R { bits } } #[doc = "Bit 9 - Rising trigger event configuration of line 9"] #[inline] pub fn tr9(&self) -> TR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR9R { bits } } #[doc = "Bit 10 - Rising trigger event configuration of line 10"] #[inline] pub fn tr10(&self) -> TR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR10R { bits } } #[doc = "Bit 11 - Rising trigger event configuration of line 11"] #[inline] pub fn tr11(&self) -> TR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR11R { bits } } #[doc = "Bit 12 - Rising trigger event configuration of line 12"] #[inline] pub fn tr12(&self) -> TR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR12R { bits } } #[doc = "Bit 13 - Rising trigger event configuration of line 13"] #[inline] pub fn tr13(&self) -> TR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR13R { bits } } #[doc = "Bit 14 - Rising trigger event configuration of line 14"] #[inline] pub fn tr14(&self) -> TR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR14R { bits } } #[doc = "Bit 15 - Rising trigger event configuration of line 15"] #[inline] pub fn tr15(&self) -> TR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR15R { bits } } #[doc = "Bit 16 - Rising trigger event configuration of line 16"] #[inline] pub fn tr16(&self) -> TR16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR16R { bits } } #[doc = "Bit 17 - Rising trigger event configuration of line 17"] #[inline] pub fn tr17(&self) -> TR17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR17R { bits } } #[doc = "Bit 19 - Rising trigger event configuration of line 19"] #[inline] pub fn tr19(&self) -> TR19R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR19R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Rising trigger event configuration of line 0"] #[inline] pub fn tr0(&mut self) -> _TR0W { _TR0W { w: self } } #[doc = "Bit 1 - Rising trigger event configuration of line 1"] #[inline] pub fn tr1(&mut self) -> _TR1W { _TR1W { w: self } } #[doc = "Bit 2 - Rising trigger event configuration of line 2"] #[inline] pub fn tr2(&mut self) -> _TR2W { _TR2W { w: self } } #[doc = "Bit 3 - Rising trigger event configuration of line 3"] #[inline] pub fn tr3(&mut self) -> _TR3W { _TR3W { w: self } } #[doc = "Bit 4 - Rising trigger event configuration of line 4"] #[inline] pub fn tr4(&mut self) -> _TR4W { _TR4W { w: self } } #[doc = "Bit 5 - Rising trigger event configuration of line 5"] #[inline] pub fn tr5(&mut self) -> _TR5W { _TR5W { w: self } } #[doc = "Bit 6 - Rising trigger event configuration of line 6"] #[inline] pub fn tr6(&mut self) -> _TR6W { _TR6W { w: self } } #[doc = "Bit 7 - Rising trigger event configuration of line 7"] #[inline] pub fn tr7(&mut self) -> _TR7W { _TR7W { w: self } } #[doc = "Bit 8 - Rising trigger event configuration of line 8"] #[inline] pub fn tr8(&mut self) -> _TR8W { _TR8W { w: self } } #[doc = "Bit 9 - Rising trigger event configuration of line 9"] #[inline] pub fn tr9(&mut self) -> _TR9W { _TR9W { w: self } } #[doc = "Bit 10 - Rising trigger event configuration of line 10"] #[inline] pub fn tr10(&mut self) -> _TR10W { _TR10W { w: self } } #[doc = "Bit 11 - Rising trigger event configuration of line 11"] #[inline] pub fn tr11(&mut self) -> _TR11W { _TR11W { w: self } } #[doc = "Bit 12 - Rising trigger event configuration of line 12"] #[inline] pub fn tr12(&mut self) -> _TR12W { _TR12W { w: self } } #[doc = "Bit 13 - Rising trigger event configuration of line 13"] #[inline] pub fn tr13(&mut self) -> _TR13W { _TR13W { w: self } } #[doc = "Bit 14 - Rising trigger event configuration of line 14"] #[inline] pub fn tr14(&mut self) -> _TR14W { _TR14W { w: self } } #[doc = "Bit 15 - Rising trigger event configuration of line 15"] #[inline] pub fn tr15(&mut self) -> _TR15W { _TR15W { w: self } } #[doc = "Bit 16 - Rising trigger event configuration of line 16"] #[inline] pub fn tr16(&mut self) -> _TR16W { _TR16W { w: self } } #[doc = "Bit 17 - Rising trigger event configuration of line 17"] #[inline] pub fn tr17(&mut self) -> _TR17W { _TR17W { w: self } } #[doc = "Bit 19 - Rising trigger event configuration of line 19"] #[inline] pub fn tr19(&mut self) -> _TR19W { _TR19W { w: self } } } } #[doc = "Falling Trigger selection register (EXTI_FTSR)"] pub struct FTSR { register: ::vcell::VolatileCell, } #[doc = "Falling Trigger selection register (EXTI_FTSR)"] pub mod ftsr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::FTSR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TR0R { bits: bool, } impl TR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR1R { bits: bool, } impl TR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR2R { bits: bool, } impl TR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR3R { bits: bool, } impl TR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR4R { bits: bool, } impl TR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR5R { bits: bool, } impl TR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR6R { bits: bool, } impl TR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR7R { bits: bool, } impl TR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR8R { bits: bool, } impl TR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR9R { bits: bool, } impl TR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR10R { bits: bool, } impl TR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR11R { bits: bool, } impl TR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR12R { bits: bool, } impl TR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR13R { bits: bool, } impl TR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR14R { bits: bool, } impl TR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR15R { bits: bool, } impl TR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR16R { bits: bool, } impl TR16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR17R { bits: bool, } impl TR17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TR19R { bits: bool, } impl TR19R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TR0W<'a> { w: &'a mut W, } impl<'a> _TR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR1W<'a> { w: &'a mut W, } impl<'a> _TR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR2W<'a> { w: &'a mut W, } impl<'a> _TR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR3W<'a> { w: &'a mut W, } impl<'a> _TR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR4W<'a> { w: &'a mut W, } impl<'a> _TR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR5W<'a> { w: &'a mut W, } impl<'a> _TR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR6W<'a> { w: &'a mut W, } impl<'a> _TR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR7W<'a> { w: &'a mut W, } impl<'a> _TR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR8W<'a> { w: &'a mut W, } impl<'a> _TR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR9W<'a> { w: &'a mut W, } impl<'a> _TR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR10W<'a> { w: &'a mut W, } impl<'a> _TR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR11W<'a> { w: &'a mut W, } impl<'a> _TR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR12W<'a> { w: &'a mut W, } impl<'a> _TR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR13W<'a> { w: &'a mut W, } impl<'a> _TR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR14W<'a> { w: &'a mut W, } impl<'a> _TR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR15W<'a> { w: &'a mut W, } impl<'a> _TR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR16W<'a> { w: &'a mut W, } impl<'a> _TR16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR17W<'a> { w: &'a mut W, } impl<'a> _TR17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TR19W<'a> { w: &'a mut W, } impl<'a> _TR19W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Falling trigger event configuration of line 0"] #[inline] pub fn tr0(&self) -> TR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR0R { bits } } #[doc = "Bit 1 - Falling trigger event configuration of line 1"] #[inline] pub fn tr1(&self) -> TR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR1R { bits } } #[doc = "Bit 2 - Falling trigger event configuration of line 2"] #[inline] pub fn tr2(&self) -> TR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR2R { bits } } #[doc = "Bit 3 - Falling trigger event configuration of line 3"] #[inline] pub fn tr3(&self) -> TR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR3R { bits } } #[doc = "Bit 4 - Falling trigger event configuration of line 4"] #[inline] pub fn tr4(&self) -> TR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR4R { bits } } #[doc = "Bit 5 - Falling trigger event configuration of line 5"] #[inline] pub fn tr5(&self) -> TR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR5R { bits } } #[doc = "Bit 6 - Falling trigger event configuration of line 6"] #[inline] pub fn tr6(&self) -> TR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR6R { bits } } #[doc = "Bit 7 - Falling trigger event configuration of line 7"] #[inline] pub fn tr7(&self) -> TR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR7R { bits } } #[doc = "Bit 8 - Falling trigger event configuration of line 8"] #[inline] pub fn tr8(&self) -> TR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR8R { bits } } #[doc = "Bit 9 - Falling trigger event configuration of line 9"] #[inline] pub fn tr9(&self) -> TR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR9R { bits } } #[doc = "Bit 10 - Falling trigger event configuration of line 10"] #[inline] pub fn tr10(&self) -> TR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR10R { bits } } #[doc = "Bit 11 - Falling trigger event configuration of line 11"] #[inline] pub fn tr11(&self) -> TR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR11R { bits } } #[doc = "Bit 12 - Falling trigger event configuration of line 12"] #[inline] pub fn tr12(&self) -> TR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR12R { bits } } #[doc = "Bit 13 - Falling trigger event configuration of line 13"] #[inline] pub fn tr13(&self) -> TR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR13R { bits } } #[doc = "Bit 14 - Falling trigger event configuration of line 14"] #[inline] pub fn tr14(&self) -> TR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR14R { bits } } #[doc = "Bit 15 - Falling trigger event configuration of line 15"] #[inline] pub fn tr15(&self) -> TR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR15R { bits } } #[doc = "Bit 16 - Falling trigger event configuration of line 16"] #[inline] pub fn tr16(&self) -> TR16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR16R { bits } } #[doc = "Bit 17 - Falling trigger event configuration of line 17"] #[inline] pub fn tr17(&self) -> TR17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR17R { bits } } #[doc = "Bit 19 - Falling trigger event configuration of line 19"] #[inline] pub fn tr19(&self) -> TR19R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TR19R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Falling trigger event configuration of line 0"] #[inline] pub fn tr0(&mut self) -> _TR0W { _TR0W { w: self } } #[doc = "Bit 1 - Falling trigger event configuration of line 1"] #[inline] pub fn tr1(&mut self) -> _TR1W { _TR1W { w: self } } #[doc = "Bit 2 - Falling trigger event configuration of line 2"] #[inline] pub fn tr2(&mut self) -> _TR2W { _TR2W { w: self } } #[doc = "Bit 3 - Falling trigger event configuration of line 3"] #[inline] pub fn tr3(&mut self) -> _TR3W { _TR3W { w: self } } #[doc = "Bit 4 - Falling trigger event configuration of line 4"] #[inline] pub fn tr4(&mut self) -> _TR4W { _TR4W { w: self } } #[doc = "Bit 5 - Falling trigger event configuration of line 5"] #[inline] pub fn tr5(&mut self) -> _TR5W { _TR5W { w: self } } #[doc = "Bit 6 - Falling trigger event configuration of line 6"] #[inline] pub fn tr6(&mut self) -> _TR6W { _TR6W { w: self } } #[doc = "Bit 7 - Falling trigger event configuration of line 7"] #[inline] pub fn tr7(&mut self) -> _TR7W { _TR7W { w: self } } #[doc = "Bit 8 - Falling trigger event configuration of line 8"] #[inline] pub fn tr8(&mut self) -> _TR8W { _TR8W { w: self } } #[doc = "Bit 9 - Falling trigger event configuration of line 9"] #[inline] pub fn tr9(&mut self) -> _TR9W { _TR9W { w: self } } #[doc = "Bit 10 - Falling trigger event configuration of line 10"] #[inline] pub fn tr10(&mut self) -> _TR10W { _TR10W { w: self } } #[doc = "Bit 11 - Falling trigger event configuration of line 11"] #[inline] pub fn tr11(&mut self) -> _TR11W { _TR11W { w: self } } #[doc = "Bit 12 - Falling trigger event configuration of line 12"] #[inline] pub fn tr12(&mut self) -> _TR12W { _TR12W { w: self } } #[doc = "Bit 13 - Falling trigger event configuration of line 13"] #[inline] pub fn tr13(&mut self) -> _TR13W { _TR13W { w: self } } #[doc = "Bit 14 - Falling trigger event configuration of line 14"] #[inline] pub fn tr14(&mut self) -> _TR14W { _TR14W { w: self } } #[doc = "Bit 15 - Falling trigger event configuration of line 15"] #[inline] pub fn tr15(&mut self) -> _TR15W { _TR15W { w: self } } #[doc = "Bit 16 - Falling trigger event configuration of line 16"] #[inline] pub fn tr16(&mut self) -> _TR16W { _TR16W { w: self } } #[doc = "Bit 17 - Falling trigger event configuration of line 17"] #[inline] pub fn tr17(&mut self) -> _TR17W { _TR17W { w: self } } #[doc = "Bit 19 - Falling trigger event configuration of line 19"] #[inline] pub fn tr19(&mut self) -> _TR19W { _TR19W { w: self } } } } #[doc = "Software interrupt event register (EXTI_SWIER)"] pub struct SWIER { register: ::vcell::VolatileCell, } #[doc = "Software interrupt event register (EXTI_SWIER)"] pub mod swier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SWIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SWIER0R { bits: bool, } impl SWIER0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER1R { bits: bool, } impl SWIER1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER2R { bits: bool, } impl SWIER2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER3R { bits: bool, } impl SWIER3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER4R { bits: bool, } impl SWIER4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER5R { bits: bool, } impl SWIER5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER6R { bits: bool, } impl SWIER6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER7R { bits: bool, } impl SWIER7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER8R { bits: bool, } impl SWIER8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER9R { bits: bool, } impl SWIER9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER10R { bits: bool, } impl SWIER10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER11R { bits: bool, } impl SWIER11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER12R { bits: bool, } impl SWIER12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER13R { bits: bool, } impl SWIER13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER14R { bits: bool, } impl SWIER14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER15R { bits: bool, } impl SWIER15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER16R { bits: bool, } impl SWIER16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER17R { bits: bool, } impl SWIER17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWIER19R { bits: bool, } impl SWIER19R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _SWIER0W<'a> { w: &'a mut W, } impl<'a> _SWIER0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER1W<'a> { w: &'a mut W, } impl<'a> _SWIER1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER2W<'a> { w: &'a mut W, } impl<'a> _SWIER2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER3W<'a> { w: &'a mut W, } impl<'a> _SWIER3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER4W<'a> { w: &'a mut W, } impl<'a> _SWIER4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER5W<'a> { w: &'a mut W, } impl<'a> _SWIER5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER6W<'a> { w: &'a mut W, } impl<'a> _SWIER6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER7W<'a> { w: &'a mut W, } impl<'a> _SWIER7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER8W<'a> { w: &'a mut W, } impl<'a> _SWIER8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER9W<'a> { w: &'a mut W, } impl<'a> _SWIER9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER10W<'a> { w: &'a mut W, } impl<'a> _SWIER10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER11W<'a> { w: &'a mut W, } impl<'a> _SWIER11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER12W<'a> { w: &'a mut W, } impl<'a> _SWIER12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER13W<'a> { w: &'a mut W, } impl<'a> _SWIER13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER14W<'a> { w: &'a mut W, } impl<'a> _SWIER14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER15W<'a> { w: &'a mut W, } impl<'a> _SWIER15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER16W<'a> { w: &'a mut W, } impl<'a> _SWIER16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER17W<'a> { w: &'a mut W, } impl<'a> _SWIER17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWIER19W<'a> { w: &'a mut W, } impl<'a> _SWIER19W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Software Interrupt on line 0"] #[inline] pub fn swier0(&self) -> SWIER0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER0R { bits } } #[doc = "Bit 1 - Software Interrupt on line 1"] #[inline] pub fn swier1(&self) -> SWIER1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER1R { bits } } #[doc = "Bit 2 - Software Interrupt on line 2"] #[inline] pub fn swier2(&self) -> SWIER2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER2R { bits } } #[doc = "Bit 3 - Software Interrupt on line 3"] #[inline] pub fn swier3(&self) -> SWIER3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER3R { bits } } #[doc = "Bit 4 - Software Interrupt on line 4"] #[inline] pub fn swier4(&self) -> SWIER4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER4R { bits } } #[doc = "Bit 5 - Software Interrupt on line 5"] #[inline] pub fn swier5(&self) -> SWIER5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER5R { bits } } #[doc = "Bit 6 - Software Interrupt on line 6"] #[inline] pub fn swier6(&self) -> SWIER6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER6R { bits } } #[doc = "Bit 7 - Software Interrupt on line 7"] #[inline] pub fn swier7(&self) -> SWIER7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER7R { bits } } #[doc = "Bit 8 - Software Interrupt on line 8"] #[inline] pub fn swier8(&self) -> SWIER8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER8R { bits } } #[doc = "Bit 9 - Software Interrupt on line 9"] #[inline] pub fn swier9(&self) -> SWIER9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER9R { bits } } #[doc = "Bit 10 - Software Interrupt on line 10"] #[inline] pub fn swier10(&self) -> SWIER10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER10R { bits } } #[doc = "Bit 11 - Software Interrupt on line 11"] #[inline] pub fn swier11(&self) -> SWIER11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER11R { bits } } #[doc = "Bit 12 - Software Interrupt on line 12"] #[inline] pub fn swier12(&self) -> SWIER12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER12R { bits } } #[doc = "Bit 13 - Software Interrupt on line 13"] #[inline] pub fn swier13(&self) -> SWIER13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER13R { bits } } #[doc = "Bit 14 - Software Interrupt on line 14"] #[inline] pub fn swier14(&self) -> SWIER14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER14R { bits } } #[doc = "Bit 15 - Software Interrupt on line 15"] #[inline] pub fn swier15(&self) -> SWIER15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER15R { bits } } #[doc = "Bit 16 - Software Interrupt on line 16"] #[inline] pub fn swier16(&self) -> SWIER16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER16R { bits } } #[doc = "Bit 17 - Software Interrupt on line 17"] #[inline] pub fn swier17(&self) -> SWIER17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER17R { bits } } #[doc = "Bit 19 - Software Interrupt on line 19"] #[inline] pub fn swier19(&self) -> SWIER19R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWIER19R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Software Interrupt on line 0"] #[inline] pub fn swier0(&mut self) -> _SWIER0W { _SWIER0W { w: self } } #[doc = "Bit 1 - Software Interrupt on line 1"] #[inline] pub fn swier1(&mut self) -> _SWIER1W { _SWIER1W { w: self } } #[doc = "Bit 2 - Software Interrupt on line 2"] #[inline] pub fn swier2(&mut self) -> _SWIER2W { _SWIER2W { w: self } } #[doc = "Bit 3 - Software Interrupt on line 3"] #[inline] pub fn swier3(&mut self) -> _SWIER3W { _SWIER3W { w: self } } #[doc = "Bit 4 - Software Interrupt on line 4"] #[inline] pub fn swier4(&mut self) -> _SWIER4W { _SWIER4W { w: self } } #[doc = "Bit 5 - Software Interrupt on line 5"] #[inline] pub fn swier5(&mut self) -> _SWIER5W { _SWIER5W { w: self } } #[doc = "Bit 6 - Software Interrupt on line 6"] #[inline] pub fn swier6(&mut self) -> _SWIER6W { _SWIER6W { w: self } } #[doc = "Bit 7 - Software Interrupt on line 7"] #[inline] pub fn swier7(&mut self) -> _SWIER7W { _SWIER7W { w: self } } #[doc = "Bit 8 - Software Interrupt on line 8"] #[inline] pub fn swier8(&mut self) -> _SWIER8W { _SWIER8W { w: self } } #[doc = "Bit 9 - Software Interrupt on line 9"] #[inline] pub fn swier9(&mut self) -> _SWIER9W { _SWIER9W { w: self } } #[doc = "Bit 10 - Software Interrupt on line 10"] #[inline] pub fn swier10(&mut self) -> _SWIER10W { _SWIER10W { w: self } } #[doc = "Bit 11 - Software Interrupt on line 11"] #[inline] pub fn swier11(&mut self) -> _SWIER11W { _SWIER11W { w: self } } #[doc = "Bit 12 - Software Interrupt on line 12"] #[inline] pub fn swier12(&mut self) -> _SWIER12W { _SWIER12W { w: self } } #[doc = "Bit 13 - Software Interrupt on line 13"] #[inline] pub fn swier13(&mut self) -> _SWIER13W { _SWIER13W { w: self } } #[doc = "Bit 14 - Software Interrupt on line 14"] #[inline] pub fn swier14(&mut self) -> _SWIER14W { _SWIER14W { w: self } } #[doc = "Bit 15 - Software Interrupt on line 15"] #[inline] pub fn swier15(&mut self) -> _SWIER15W { _SWIER15W { w: self } } #[doc = "Bit 16 - Software Interrupt on line 16"] #[inline] pub fn swier16(&mut self) -> _SWIER16W { _SWIER16W { w: self } } #[doc = "Bit 17 - Software Interrupt on line 17"] #[inline] pub fn swier17(&mut self) -> _SWIER17W { _SWIER17W { w: self } } #[doc = "Bit 19 - Software Interrupt on line 19"] #[inline] pub fn swier19(&mut self) -> _SWIER19W { _SWIER19W { w: self } } } } #[doc = "Pending register (EXTI_PR)"] pub struct PR { register: ::vcell::VolatileCell, } #[doc = "Pending register (EXTI_PR)"] pub mod pr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PR0R { bits: bool, } impl PR0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR1R { bits: bool, } impl PR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR2R { bits: bool, } impl PR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR3R { bits: bool, } impl PR3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR4R { bits: bool, } impl PR4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR5R { bits: bool, } impl PR5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR6R { bits: bool, } impl PR6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR7R { bits: bool, } impl PR7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR8R { bits: bool, } impl PR8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR9R { bits: bool, } impl PR9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR10R { bits: bool, } impl PR10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR11R { bits: bool, } impl PR11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR12R { bits: bool, } impl PR12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR13R { bits: bool, } impl PR13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR14R { bits: bool, } impl PR14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR15R { bits: bool, } impl PR15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR16R { bits: bool, } impl PR16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR17R { bits: bool, } impl PR17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PR19R { bits: bool, } impl PR19R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _PR0W<'a> { w: &'a mut W, } impl<'a> _PR0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR1W<'a> { w: &'a mut W, } impl<'a> _PR1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR2W<'a> { w: &'a mut W, } impl<'a> _PR2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR3W<'a> { w: &'a mut W, } impl<'a> _PR3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR4W<'a> { w: &'a mut W, } impl<'a> _PR4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR5W<'a> { w: &'a mut W, } impl<'a> _PR5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR6W<'a> { w: &'a mut W, } impl<'a> _PR6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR7W<'a> { w: &'a mut W, } impl<'a> _PR7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR8W<'a> { w: &'a mut W, } impl<'a> _PR8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR9W<'a> { w: &'a mut W, } impl<'a> _PR9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR10W<'a> { w: &'a mut W, } impl<'a> _PR10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR11W<'a> { w: &'a mut W, } impl<'a> _PR11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR12W<'a> { w: &'a mut W, } impl<'a> _PR12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR13W<'a> { w: &'a mut W, } impl<'a> _PR13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR14W<'a> { w: &'a mut W, } impl<'a> _PR14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR15W<'a> { w: &'a mut W, } impl<'a> _PR15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR16W<'a> { w: &'a mut W, } impl<'a> _PR16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR17W<'a> { w: &'a mut W, } impl<'a> _PR17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PR19W<'a> { w: &'a mut W, } impl<'a> _PR19W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Pending bit 0"] #[inline] pub fn pr0(&self) -> PR0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR0R { bits } } #[doc = "Bit 1 - Pending bit 1"] #[inline] pub fn pr1(&self) -> PR1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR1R { bits } } #[doc = "Bit 2 - Pending bit 2"] #[inline] pub fn pr2(&self) -> PR2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR2R { bits } } #[doc = "Bit 3 - Pending bit 3"] #[inline] pub fn pr3(&self) -> PR3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR3R { bits } } #[doc = "Bit 4 - Pending bit 4"] #[inline] pub fn pr4(&self) -> PR4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR4R { bits } } #[doc = "Bit 5 - Pending bit 5"] #[inline] pub fn pr5(&self) -> PR5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR5R { bits } } #[doc = "Bit 6 - Pending bit 6"] #[inline] pub fn pr6(&self) -> PR6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR6R { bits } } #[doc = "Bit 7 - Pending bit 7"] #[inline] pub fn pr7(&self) -> PR7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR7R { bits } } #[doc = "Bit 8 - Pending bit 8"] #[inline] pub fn pr8(&self) -> PR8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR8R { bits } } #[doc = "Bit 9 - Pending bit 9"] #[inline] pub fn pr9(&self) -> PR9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR9R { bits } } #[doc = "Bit 10 - Pending bit 10"] #[inline] pub fn pr10(&self) -> PR10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR10R { bits } } #[doc = "Bit 11 - Pending bit 11"] #[inline] pub fn pr11(&self) -> PR11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR11R { bits } } #[doc = "Bit 12 - Pending bit 12"] #[inline] pub fn pr12(&self) -> PR12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR12R { bits } } #[doc = "Bit 13 - Pending bit 13"] #[inline] pub fn pr13(&self) -> PR13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR13R { bits } } #[doc = "Bit 14 - Pending bit 14"] #[inline] pub fn pr14(&self) -> PR14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR14R { bits } } #[doc = "Bit 15 - Pending bit 15"] #[inline] pub fn pr15(&self) -> PR15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR15R { bits } } #[doc = "Bit 16 - Pending bit 16"] #[inline] pub fn pr16(&self) -> PR16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR16R { bits } } #[doc = "Bit 17 - Pending bit 17"] #[inline] pub fn pr17(&self) -> PR17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR17R { bits } } #[doc = "Bit 19 - Pending bit 19"] #[inline] pub fn pr19(&self) -> PR19R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PR19R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Pending bit 0"] #[inline] pub fn pr0(&mut self) -> _PR0W { _PR0W { w: self } } #[doc = "Bit 1 - Pending bit 1"] #[inline] pub fn pr1(&mut self) -> _PR1W { _PR1W { w: self } } #[doc = "Bit 2 - Pending bit 2"] #[inline] pub fn pr2(&mut self) -> _PR2W { _PR2W { w: self } } #[doc = "Bit 3 - Pending bit 3"] #[inline] pub fn pr3(&mut self) -> _PR3W { _PR3W { w: self } } #[doc = "Bit 4 - Pending bit 4"] #[inline] pub fn pr4(&mut self) -> _PR4W { _PR4W { w: self } } #[doc = "Bit 5 - Pending bit 5"] #[inline] pub fn pr5(&mut self) -> _PR5W { _PR5W { w: self } } #[doc = "Bit 6 - Pending bit 6"] #[inline] pub fn pr6(&mut self) -> _PR6W { _PR6W { w: self } } #[doc = "Bit 7 - Pending bit 7"] #[inline] pub fn pr7(&mut self) -> _PR7W { _PR7W { w: self } } #[doc = "Bit 8 - Pending bit 8"] #[inline] pub fn pr8(&mut self) -> _PR8W { _PR8W { w: self } } #[doc = "Bit 9 - Pending bit 9"] #[inline] pub fn pr9(&mut self) -> _PR9W { _PR9W { w: self } } #[doc = "Bit 10 - Pending bit 10"] #[inline] pub fn pr10(&mut self) -> _PR10W { _PR10W { w: self } } #[doc = "Bit 11 - Pending bit 11"] #[inline] pub fn pr11(&mut self) -> _PR11W { _PR11W { w: self } } #[doc = "Bit 12 - Pending bit 12"] #[inline] pub fn pr12(&mut self) -> _PR12W { _PR12W { w: self } } #[doc = "Bit 13 - Pending bit 13"] #[inline] pub fn pr13(&mut self) -> _PR13W { _PR13W { w: self } } #[doc = "Bit 14 - Pending bit 14"] #[inline] pub fn pr14(&mut self) -> _PR14W { _PR14W { w: self } } #[doc = "Bit 15 - Pending bit 15"] #[inline] pub fn pr15(&mut self) -> _PR15W { _PR15W { w: self } } #[doc = "Bit 16 - Pending bit 16"] #[inline] pub fn pr16(&mut self) -> _PR16W { _PR16W { w: self } } #[doc = "Bit 17 - Pending bit 17"] #[inline] pub fn pr17(&mut self) -> _PR17W { _PR17W { w: self } } #[doc = "Bit 19 - Pending bit 19"] #[inline] pub fn pr19(&mut self) -> _PR19W { _PR19W { w: self } } } } } #[doc = "DMA controller"] pub struct DMA { _marker: PhantomData<*const ()>, } unsafe impl Send for DMA {} impl DMA { #[doc = r" Returns a pointer to the register block"] pub fn ptr() -> *const dma::RegisterBlock { 0x4002_0000 as *const _ } } impl Deref for DMA { type Target = dma::RegisterBlock; fn deref(&self) -> &dma::RegisterBlock { unsafe { &*DMA::ptr() } } } #[doc = "DMA controller"] pub mod dma { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - DMA interrupt status register (DMA_ISR)"] pub isr: ISR, #[doc = "0x04 - DMA interrupt flag clear register (DMA_IFCR)"] pub ifcr: IFCR, #[doc = "0x08 - DMA channel configuration register (DMA_CCR)"] pub ccr1: CCR1, #[doc = "0x0c - DMA channel 1 number of data register"] pub cndtr1: CNDTR1, #[doc = "0x10 - DMA channel 1 peripheral address register"] pub cpar1: CPAR1, #[doc = "0x14 - DMA channel 1 memory address register"] pub cmar1: CMAR1, _reserved0: [u8; 4usize], #[doc = "0x1c - DMA channel configuration register (DMA_CCR)"] pub ccr2: CCR2, #[doc = "0x20 - DMA channel 2 number of data register"] pub cndtr2: CNDTR2, #[doc = "0x24 - DMA channel 2 peripheral address register"] pub cpar2: CPAR2, #[doc = "0x28 - DMA channel 2 memory address register"] pub cmar2: CMAR2, _reserved1: [u8; 4usize], #[doc = "0x30 - DMA channel configuration register (DMA_CCR)"] pub ccr3: CCR3, #[doc = "0x34 - DMA channel 3 number of data register"] pub cndtr3: CNDTR3, #[doc = "0x38 - DMA channel 3 peripheral address register"] pub cpar3: CPAR3, #[doc = "0x3c - DMA channel 3 memory address register"] pub cmar3: CMAR3, _reserved2: [u8; 4usize], #[doc = "0x44 - DMA channel configuration register (DMA_CCR)"] pub ccr4: CCR4, #[doc = "0x48 - DMA channel 4 number of data register"] pub cndtr4: CNDTR4, #[doc = "0x4c - DMA channel 4 peripheral address register"] pub cpar4: CPAR4, #[doc = "0x50 - DMA channel 4 memory address register"] pub cmar4: CMAR4, _reserved3: [u8; 4usize], #[doc = "0x58 - DMA channel configuration register (DMA_CCR)"] pub ccr5: CCR5, #[doc = "0x5c - DMA channel 5 number of data register"] pub cndtr5: CNDTR5, #[doc = "0x60 - DMA channel 5 peripheral address register"] pub cpar5: CPAR5, #[doc = "0x64 - DMA channel 5 memory address register"] pub cmar5: CMAR5, _reserved4: [u8; 4usize], #[doc = "0x6c - DMA channel configuration register (DMA_CCR)"] pub ccr6: CCR6, #[doc = "0x70 - DMA channel 6 number of data register"] pub cndtr6: CNDTR6, #[doc = "0x74 - DMA channel 6 peripheral address register"] pub cpar6: CPAR6, #[doc = "0x78 - DMA channel 6 memory address register"] pub cmar6: CMAR6, _reserved5: [u8; 4usize], #[doc = "0x80 - DMA channel configuration register (DMA_CCR)"] pub ccr7: CCR7, #[doc = "0x84 - DMA channel 7 number of data register"] pub cndtr7: CNDTR7, #[doc = "0x88 - DMA channel 7 peripheral address register"] pub cpar7: CPAR7, #[doc = "0x8c - DMA channel 7 memory address register"] pub cmar7: CMAR7, } #[doc = "DMA interrupt status register (DMA_ISR)"] pub struct ISR { register: ::vcell::VolatileCell, } #[doc = "DMA interrupt status register (DMA_ISR)"] pub mod isr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::ISR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct GIF1R { bits: bool, } impl GIF1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF1R { bits: bool, } impl TCIF1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF1R { bits: bool, } impl HTIF1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF1R { bits: bool, } impl TEIF1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GIF2R { bits: bool, } impl GIF2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF2R { bits: bool, } impl TCIF2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF2R { bits: bool, } impl HTIF2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF2R { bits: bool, } impl TEIF2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GIF3R { bits: bool, } impl GIF3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF3R { bits: bool, } impl TCIF3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF3R { bits: bool, } impl HTIF3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF3R { bits: bool, } impl TEIF3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GIF4R { bits: bool, } impl GIF4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF4R { bits: bool, } impl TCIF4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF4R { bits: bool, } impl HTIF4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF4R { bits: bool, } impl TEIF4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GIF5R { bits: bool, } impl GIF5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF5R { bits: bool, } impl TCIF5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF5R { bits: bool, } impl HTIF5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF5R { bits: bool, } impl TEIF5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GIF6R { bits: bool, } impl GIF6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF6R { bits: bool, } impl TCIF6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF6R { bits: bool, } impl HTIF6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF6R { bits: bool, } impl TEIF6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct GIF7R { bits: bool, } impl GIF7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIF7R { bits: bool, } impl TCIF7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIF7R { bits: bool, } impl HTIF7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIF7R { bits: bool, } impl TEIF7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel 1 Global interrupt flag"] #[inline] pub fn gif1(&self) -> GIF1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF1R { bits } } #[doc = "Bit 1 - Channel 1 Transfer Complete flag"] #[inline] pub fn tcif1(&self) -> TCIF1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF1R { bits } } #[doc = "Bit 2 - Channel 1 Half Transfer Complete flag"] #[inline] pub fn htif1(&self) -> HTIF1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF1R { bits } } #[doc = "Bit 3 - Channel 1 Transfer Error flag"] #[inline] pub fn teif1(&self) -> TEIF1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF1R { bits } } #[doc = "Bit 4 - Channel 2 Global interrupt flag"] #[inline] pub fn gif2(&self) -> GIF2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF2R { bits } } #[doc = "Bit 5 - Channel 2 Transfer Complete flag"] #[inline] pub fn tcif2(&self) -> TCIF2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF2R { bits } } #[doc = "Bit 6 - Channel 2 Half Transfer Complete flag"] #[inline] pub fn htif2(&self) -> HTIF2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF2R { bits } } #[doc = "Bit 7 - Channel 2 Transfer Error flag"] #[inline] pub fn teif2(&self) -> TEIF2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF2R { bits } } #[doc = "Bit 8 - Channel 3 Global interrupt flag"] #[inline] pub fn gif3(&self) -> GIF3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF3R { bits } } #[doc = "Bit 9 - Channel 3 Transfer Complete flag"] #[inline] pub fn tcif3(&self) -> TCIF3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF3R { bits } } #[doc = "Bit 10 - Channel 3 Half Transfer Complete flag"] #[inline] pub fn htif3(&self) -> HTIF3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF3R { bits } } #[doc = "Bit 11 - Channel 3 Transfer Error flag"] #[inline] pub fn teif3(&self) -> TEIF3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF3R { bits } } #[doc = "Bit 12 - Channel 4 Global interrupt flag"] #[inline] pub fn gif4(&self) -> GIF4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF4R { bits } } #[doc = "Bit 13 - Channel 4 Transfer Complete flag"] #[inline] pub fn tcif4(&self) -> TCIF4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF4R { bits } } #[doc = "Bit 14 - Channel 4 Half Transfer Complete flag"] #[inline] pub fn htif4(&self) -> HTIF4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF4R { bits } } #[doc = "Bit 15 - Channel 4 Transfer Error flag"] #[inline] pub fn teif4(&self) -> TEIF4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF4R { bits } } #[doc = "Bit 16 - Channel 5 Global interrupt flag"] #[inline] pub fn gif5(&self) -> GIF5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF5R { bits } } #[doc = "Bit 17 - Channel 5 Transfer Complete flag"] #[inline] pub fn tcif5(&self) -> TCIF5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF5R { bits } } #[doc = "Bit 18 - Channel 5 Half Transfer Complete flag"] #[inline] pub fn htif5(&self) -> HTIF5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF5R { bits } } #[doc = "Bit 19 - Channel 5 Transfer Error flag"] #[inline] pub fn teif5(&self) -> TEIF5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF5R { bits } } #[doc = "Bit 20 - Channel 6 Global interrupt flag"] #[inline] pub fn gif6(&self) -> GIF6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF6R { bits } } #[doc = "Bit 21 - Channel 6 Transfer Complete flag"] #[inline] pub fn tcif6(&self) -> TCIF6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF6R { bits } } #[doc = "Bit 22 - Channel 6 Half Transfer Complete flag"] #[inline] pub fn htif6(&self) -> HTIF6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF6R { bits } } #[doc = "Bit 23 - Channel 6 Transfer Error flag"] #[inline] pub fn teif6(&self) -> TEIF6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF6R { bits } } #[doc = "Bit 24 - Channel 7 Global interrupt flag"] #[inline] pub fn gif7(&self) -> GIF7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; GIF7R { bits } } #[doc = "Bit 25 - Channel 7 Transfer Complete flag"] #[inline] pub fn tcif7(&self) -> TCIF7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIF7R { bits } } #[doc = "Bit 26 - Channel 7 Half Transfer Complete flag"] #[inline] pub fn htif7(&self) -> HTIF7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIF7R { bits } } #[doc = "Bit 27 - Channel 7 Transfer Error flag"] #[inline] pub fn teif7(&self) -> TEIF7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 27; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIF7R { bits } } } } #[doc = "DMA interrupt flag clear register (DMA_IFCR)"] pub struct IFCR { register: ::vcell::VolatileCell, } #[doc = "DMA interrupt flag clear register (DMA_IFCR)"] pub mod ifcr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::IFCR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _CGIF1W<'a> { w: &'a mut W, } impl<'a> _CGIF1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF1W<'a> { w: &'a mut W, } impl<'a> _CTCIF1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF1W<'a> { w: &'a mut W, } impl<'a> _CHTIF1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF1W<'a> { w: &'a mut W, } impl<'a> _CTEIF1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CGIF2W<'a> { w: &'a mut W, } impl<'a> _CGIF2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF2W<'a> { w: &'a mut W, } impl<'a> _CTCIF2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF2W<'a> { w: &'a mut W, } impl<'a> _CHTIF2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF2W<'a> { w: &'a mut W, } impl<'a> _CTEIF2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CGIF3W<'a> { w: &'a mut W, } impl<'a> _CGIF3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF3W<'a> { w: &'a mut W, } impl<'a> _CTCIF3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF3W<'a> { w: &'a mut W, } impl<'a> _CHTIF3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF3W<'a> { w: &'a mut W, } impl<'a> _CTEIF3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CGIF4W<'a> { w: &'a mut W, } impl<'a> _CGIF4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF4W<'a> { w: &'a mut W, } impl<'a> _CTCIF4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF4W<'a> { w: &'a mut W, } impl<'a> _CHTIF4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF4W<'a> { w: &'a mut W, } impl<'a> _CTEIF4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CGIF5W<'a> { w: &'a mut W, } impl<'a> _CGIF5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF5W<'a> { w: &'a mut W, } impl<'a> _CTCIF5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF5W<'a> { w: &'a mut W, } impl<'a> _CHTIF5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF5W<'a> { w: &'a mut W, } impl<'a> _CTEIF5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CGIF6W<'a> { w: &'a mut W, } impl<'a> _CGIF6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF6W<'a> { w: &'a mut W, } impl<'a> _CTCIF6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF6W<'a> { w: &'a mut W, } impl<'a> _CHTIF6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF6W<'a> { w: &'a mut W, } impl<'a> _CTEIF6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CGIF7W<'a> { w: &'a mut W, } impl<'a> _CGIF7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTCIF7W<'a> { w: &'a mut W, } impl<'a> _CTCIF7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHTIF7W<'a> { w: &'a mut W, } impl<'a> _CHTIF7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTEIF7W<'a> { w: &'a mut W, } impl<'a> _CTEIF7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel 1 Global interrupt clear"] #[inline] pub fn cgif1(&mut self) -> _CGIF1W { _CGIF1W { w: self } } #[doc = "Bit 1 - Channel 1 Transfer Complete clear"] #[inline] pub fn ctcif1(&mut self) -> _CTCIF1W { _CTCIF1W { w: self } } #[doc = "Bit 2 - Channel 1 Half Transfer clear"] #[inline] pub fn chtif1(&mut self) -> _CHTIF1W { _CHTIF1W { w: self } } #[doc = "Bit 3 - Channel 1 Transfer Error clear"] #[inline] pub fn cteif1(&mut self) -> _CTEIF1W { _CTEIF1W { w: self } } #[doc = "Bit 4 - Channel 2 Global interrupt clear"] #[inline] pub fn cgif2(&mut self) -> _CGIF2W { _CGIF2W { w: self } } #[doc = "Bit 5 - Channel 2 Transfer Complete clear"] #[inline] pub fn ctcif2(&mut self) -> _CTCIF2W { _CTCIF2W { w: self } } #[doc = "Bit 6 - Channel 2 Half Transfer clear"] #[inline] pub fn chtif2(&mut self) -> _CHTIF2W { _CHTIF2W { w: self } } #[doc = "Bit 7 - Channel 2 Transfer Error clear"] #[inline] pub fn cteif2(&mut self) -> _CTEIF2W { _CTEIF2W { w: self } } #[doc = "Bit 8 - Channel 3 Global interrupt clear"] #[inline] pub fn cgif3(&mut self) -> _CGIF3W { _CGIF3W { w: self } } #[doc = "Bit 9 - Channel 3 Transfer Complete clear"] #[inline] pub fn ctcif3(&mut self) -> _CTCIF3W { _CTCIF3W { w: self } } #[doc = "Bit 10 - Channel 3 Half Transfer clear"] #[inline] pub fn chtif3(&mut self) -> _CHTIF3W { _CHTIF3W { w: self } } #[doc = "Bit 11 - Channel 3 Transfer Error clear"] #[inline] pub fn cteif3(&mut self) -> _CTEIF3W { _CTEIF3W { w: self } } #[doc = "Bit 12 - Channel 4 Global interrupt clear"] #[inline] pub fn cgif4(&mut self) -> _CGIF4W { _CGIF4W { w: self } } #[doc = "Bit 13 - Channel 4 Transfer Complete clear"] #[inline] pub fn ctcif4(&mut self) -> _CTCIF4W { _CTCIF4W { w: self } } #[doc = "Bit 14 - Channel 4 Half Transfer clear"] #[inline] pub fn chtif4(&mut self) -> _CHTIF4W { _CHTIF4W { w: self } } #[doc = "Bit 15 - Channel 4 Transfer Error clear"] #[inline] pub fn cteif4(&mut self) -> _CTEIF4W { _CTEIF4W { w: self } } #[doc = "Bit 16 - Channel 5 Global interrupt clear"] #[inline] pub fn cgif5(&mut self) -> _CGIF5W { _CGIF5W { w: self } } #[doc = "Bit 17 - Channel 5 Transfer Complete clear"] #[inline] pub fn ctcif5(&mut self) -> _CTCIF5W { _CTCIF5W { w: self } } #[doc = "Bit 18 - Channel 5 Half Transfer clear"] #[inline] pub fn chtif5(&mut self) -> _CHTIF5W { _CHTIF5W { w: self } } #[doc = "Bit 19 - Channel 5 Transfer Error clear"] #[inline] pub fn cteif5(&mut self) -> _CTEIF5W { _CTEIF5W { w: self } } #[doc = "Bit 20 - Channel 6 Global interrupt clear"] #[inline] pub fn cgif6(&mut self) -> _CGIF6W { _CGIF6W { w: self } } #[doc = "Bit 21 - Channel 6 Transfer Complete clear"] #[inline] pub fn ctcif6(&mut self) -> _CTCIF6W { _CTCIF6W { w: self } } #[doc = "Bit 22 - Channel 6 Half Transfer clear"] #[inline] pub fn chtif6(&mut self) -> _CHTIF6W { _CHTIF6W { w: self } } #[doc = "Bit 23 - Channel 6 Transfer Error clear"] #[inline] pub fn cteif6(&mut self) -> _CTEIF6W { _CTEIF6W { w: self } } #[doc = "Bit 24 - Channel 7 Global interrupt clear"] #[inline] pub fn cgif7(&mut self) -> _CGIF7W { _CGIF7W { w: self } } #[doc = "Bit 25 - Channel 7 Transfer Complete clear"] #[inline] pub fn ctcif7(&mut self) -> _CTCIF7W { _CTCIF7W { w: self } } #[doc = "Bit 26 - Channel 7 Half Transfer clear"] #[inline] pub fn chtif7(&mut self) -> _CHTIF7W { _CHTIF7W { w: self } } #[doc = "Bit 27 - Channel 7 Transfer Error clear"] #[inline] pub fn cteif7(&mut self) -> _CTEIF7W { _CTEIF7W { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR1 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 1 number of data register"] pub struct CNDTR1 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 1 number of data register"] pub mod cndtr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 1 peripheral address register"] pub struct CPAR1 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 1 peripheral address register"] pub mod cpar1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 1 memory address register"] pub struct CMAR1 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 1 memory address register"] pub mod cmar1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR2 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 2 number of data register"] pub struct CNDTR2 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 2 number of data register"] pub mod cndtr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 2 peripheral address register"] pub struct CPAR2 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 2 peripheral address register"] pub mod cpar2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 2 memory address register"] pub struct CMAR2 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 2 memory address register"] pub mod cmar2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR3 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 3 number of data register"] pub struct CNDTR3 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 3 number of data register"] pub mod cndtr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 3 peripheral address register"] pub struct CPAR3 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 3 peripheral address register"] pub mod cpar3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 3 memory address register"] pub struct CMAR3 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 3 memory address register"] pub mod cmar3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR4 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 4 number of data register"] pub struct CNDTR4 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 4 number of data register"] pub mod cndtr4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 4 peripheral address register"] pub struct CPAR4 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 4 peripheral address register"] pub mod cpar4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 4 memory address register"] pub struct CMAR4 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 4 memory address register"] pub mod cmar4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR5 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr5 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR5 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 5 number of data register"] pub struct CNDTR5 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 5 number of data register"] pub mod cndtr5 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR5 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 5 peripheral address register"] pub struct CPAR5 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 5 peripheral address register"] pub mod cpar5 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR5 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 5 memory address register"] pub struct CMAR5 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 5 memory address register"] pub mod cmar5 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR5 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR6 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr6 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR6 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 6 number of data register"] pub struct CNDTR6 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 6 number of data register"] pub mod cndtr6 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR6 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 6 peripheral address register"] pub struct CPAR6 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 6 peripheral address register"] pub mod cpar6 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR6 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 6 memory address register"] pub struct CMAR6 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 6 memory address register"] pub mod cmar6 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR6 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } #[doc = "DMA channel configuration register (DMA_CCR)"] pub struct CCR7 { register: ::vcell::VolatileCell, } #[doc = "DMA channel configuration register (DMA_CCR)"] pub mod ccr7 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR7 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ENR { bits: bool, } impl ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTIER { bits: bool, } impl HTIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEIER { bits: bool, } impl TEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DIRR { bits: bool, } impl DIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CIRCR { bits: bool, } impl CIRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINCR { bits: bool, } impl PINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MINCR { bits: bool, } impl MINCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSIZER { bits: u8, } impl PSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSIZER { bits: u8, } impl MSIZER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLR { bits: u8, } impl PLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MEM2MEMR { bits: bool, } impl MEM2MEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ENW<'a> { w: &'a mut W, } impl<'a> _ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTIEW<'a> { w: &'a mut W, } impl<'a> _HTIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEIEW<'a> { w: &'a mut W, } impl<'a> _TEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIRW<'a> { w: &'a mut W, } impl<'a> _DIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CIRCW<'a> { w: &'a mut W, } impl<'a> _CIRCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINCW<'a> { w: &'a mut W, } impl<'a> _PINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MINCW<'a> { w: &'a mut W, } impl<'a> _MINCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSIZEW<'a> { w: &'a mut W, } impl<'a> _PSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSIZEW<'a> { w: &'a mut W, } impl<'a> _MSIZEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLW<'a> { w: &'a mut W, } impl<'a> _PLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MEM2MEMW<'a> { w: &'a mut W, } impl<'a> _MEM2MEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&self) -> ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ENR { bits } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&self) -> HTIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HTIER { bits } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&self) -> TEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEIER { bits } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&self) -> DIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DIRR { bits } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&self) -> CIRCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CIRCR { bits } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&self) -> PINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINCR { bits } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&self) -> MINCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MINCR { bits } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&self) -> PSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSIZER { bits } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&self) -> MSIZER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MSIZER { bits } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&self) -> PLR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLR { bits } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&self) -> MEM2MEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MEM2MEMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Channel enable"] #[inline] pub fn en(&mut self) -> _ENW { _ENW { w: self } } #[doc = "Bit 1 - Transfer complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 2 - Half Transfer interrupt enable"] #[inline] pub fn htie(&mut self) -> _HTIEW { _HTIEW { w: self } } #[doc = "Bit 3 - Transfer error interrupt enable"] #[inline] pub fn teie(&mut self) -> _TEIEW { _TEIEW { w: self } } #[doc = "Bit 4 - Data transfer direction"] #[inline] pub fn dir(&mut self) -> _DIRW { _DIRW { w: self } } #[doc = "Bit 5 - Circular mode"] #[inline] pub fn circ(&mut self) -> _CIRCW { _CIRCW { w: self } } #[doc = "Bit 6 - Peripheral increment mode"] #[inline] pub fn pinc(&mut self) -> _PINCW { _PINCW { w: self } } #[doc = "Bit 7 - Memory increment mode"] #[inline] pub fn minc(&mut self) -> _MINCW { _MINCW { w: self } } #[doc = "Bits 8:9 - Peripheral size"] #[inline] pub fn psize(&mut self) -> _PSIZEW { _PSIZEW { w: self } } #[doc = "Bits 10:11 - Memory size"] #[inline] pub fn msize(&mut self) -> _MSIZEW { _MSIZEW { w: self } } #[doc = "Bits 12:13 - Channel Priority level"] #[inline] pub fn pl(&mut self) -> _PLW { _PLW { w: self } } #[doc = "Bit 14 - Memory to memory mode"] #[inline] pub fn mem2mem(&mut self) -> _MEM2MEMW { _MEM2MEMW { w: self } } } } #[doc = "DMA channel 7 number of data register"] pub struct CNDTR7 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 7 number of data register"] pub mod cndtr7 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNDTR7 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct NDTR { bits: u16, } impl NDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _NDTW<'a> { w: &'a mut W, } impl<'a> _NDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&self) -> NDTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; NDTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Number of data to transfer"] #[inline] pub fn ndt(&mut self) -> _NDTW { _NDTW { w: self } } } } #[doc = "DMA channel 7 peripheral address register"] pub struct CPAR7 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 7 peripheral address register"] pub mod cpar7 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CPAR7 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PAR { bits: u32, } impl PAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _PAW<'a> { w: &'a mut W, } impl<'a> _PAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&self) -> PAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; PAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Peripheral address"] #[inline] pub fn pa(&mut self) -> _PAW { _PAW { w: self } } } } #[doc = "DMA channel 7 memory address register"] pub struct CMAR7 { register: ::vcell::VolatileCell, } #[doc = "DMA channel 7 memory address register"] pub mod cmar7 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CMAR7 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MAR { bits: u32, } impl MAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _MAW<'a> { w: &'a mut W, } impl<'a> _MAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&self) -> MAR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; MAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Memory address"] #[inline] pub fn ma(&mut self) -> _MAW { _MAW { w: self } } } } } #[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 { 0x4002_1000 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Clock control register"] pub cr: CR, #[doc = "0x04 - Clock configuration register (RCC_CFGR)"] pub cfgr: CFGR, #[doc = "0x08 - Clock interrupt register (RCC_CIR)"] pub cir: CIR, #[doc = "0x0c - APB2 peripheral reset register (RCC_APB2RSTR)"] pub apb2rstr: APB2RSTR, #[doc = "0x10 - APB1 peripheral reset register (RCC_APB1RSTR)"] pub apb1rstr: APB1RSTR, #[doc = "0x14 - AHB Peripheral Clock enable register (RCC_AHBENR)"] pub ahbenr: AHBENR, #[doc = "0x18 - APB2 peripheral clock enable register (RCC_APB2ENR)"] pub apb2enr: APB2ENR, #[doc = "0x1c - APB1 peripheral clock enable register (RCC_APB1ENR)"] pub apb1enr: APB1ENR, #[doc = "0x20 - Backup domain control register (RCC_BDCR)"] pub bdcr: BDCR, #[doc = "0x24 - Control/status register (RCC_CSR)"] pub csr: CSR, #[doc = "0x28 - AHB peripheral reset register"] pub ahbrstr: AHBRSTR, #[doc = "0x2c - Clock configuration register 2"] pub cfgr2: CFGR2, #[doc = "0x30 - Clock configuration register 3"] pub cfgr3: CFGR3, #[doc = "0x34 - Clock control register 2"] pub cr2: CR2, } #[doc = "Clock control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "Clock control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct HSIONR { bits: bool, } impl HSIONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSIRDYR { bits: bool, } impl HSIRDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSITRIMR { bits: u8, } impl HSITRIMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HSICALR { bits: u8, } impl HSICALR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HSEONR { bits: bool, } impl HSEONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSERDYR { bits: bool, } impl HSERDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSEBYPR { bits: bool, } impl HSEBYPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CSSONR { bits: bool, } impl CSSONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLLONR { bits: bool, } impl PLLONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLLRDYR { bits: bool, } impl PLLRDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _HSIONW<'a> { w: &'a mut W, } impl<'a> _HSIONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSITRIMW<'a> { w: &'a mut W, } impl<'a> _HSITRIMW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSEONW<'a> { w: &'a mut W, } impl<'a> _HSEONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSEBYPW<'a> { w: &'a mut W, } impl<'a> _HSEBYPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CSSONW<'a> { w: &'a mut W, } impl<'a> _CSSONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLONW<'a> { w: &'a mut W, } impl<'a> _PLLONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Internal High Speed clock enable"] #[inline] pub fn hsion(&self) -> HSIONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSIONR { bits } } #[doc = "Bit 1 - Internal High Speed clock ready flag"] #[inline] pub fn hsirdy(&self) -> HSIRDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSIRDYR { bits } } #[doc = "Bits 3:7 - Internal High Speed clock trimming"] #[inline] pub fn hsitrim(&self) -> HSITRIMR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HSITRIMR { bits } } #[doc = "Bits 8:15 - Internal High Speed clock Calibration"] #[inline] pub fn hsical(&self) -> HSICALR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HSICALR { bits } } #[doc = "Bit 16 - External High Speed clock enable"] #[inline] pub fn hseon(&self) -> HSEONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSEONR { bits } } #[doc = "Bit 17 - External High Speed clock ready flag"] #[inline] pub fn hserdy(&self) -> HSERDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSERDYR { bits } } #[doc = "Bit 18 - External High Speed clock Bypass"] #[inline] pub fn hsebyp(&self) -> HSEBYPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSEBYPR { bits } } #[doc = "Bit 19 - Clock Security System enable"] #[inline] pub fn csson(&self) -> CSSONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CSSONR { bits } } #[doc = "Bit 24 - PLL enable"] #[inline] pub fn pllon(&self) -> PLLONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PLLONR { bits } } #[doc = "Bit 25 - PLL clock ready flag"] #[inline] pub fn pllrdy(&self) -> PLLRDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PLLRDYR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x83 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Internal High Speed clock enable"] #[inline] pub fn hsion(&mut self) -> _HSIONW { _HSIONW { w: self } } #[doc = "Bits 3:7 - Internal High Speed clock trimming"] #[inline] pub fn hsitrim(&mut self) -> _HSITRIMW { _HSITRIMW { w: self } } #[doc = "Bit 16 - External High Speed clock enable"] #[inline] pub fn hseon(&mut self) -> _HSEONW { _HSEONW { w: self } } #[doc = "Bit 18 - External High Speed clock Bypass"] #[inline] pub fn hsebyp(&mut self) -> _HSEBYPW { _HSEBYPW { w: self } } #[doc = "Bit 19 - Clock Security System enable"] #[inline] pub fn csson(&mut self) -> _CSSONW { _CSSONW { w: self } } #[doc = "Bit 24 - PLL enable"] #[inline] pub fn pllon(&mut self) -> _PLLONW { _PLLONW { w: self } } } } #[doc = "Clock configuration register (RCC_CFGR)"] pub struct CFGR { register: ::vcell::VolatileCell, } #[doc = "Clock configuration register (RCC_CFGR)"] pub mod cfgr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SWR { bits: u8, } impl SWR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SWSR { bits: u8, } impl SWSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HPRER { bits: u8, } impl HPRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PPRER { bits: u8, } impl PPRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ADCPRER { bits: bool, } impl ADCPRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLLSRCR { bits: u8, } impl PLLSRCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLLXTPRER { bits: bool, } impl PLLXTPRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLLMULR { bits: u8, } impl PLLMULR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MCOR { bits: u8, } impl MCOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MCOPRER { bits: u8, } impl MCOPRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PLLNODIVR { bits: bool, } impl PLLNODIVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _SWW<'a> { w: &'a mut W, } impl<'a> _SWW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HPREW<'a> { w: &'a mut W, } impl<'a> _HPREW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PPREW<'a> { w: &'a mut W, } impl<'a> _PPREW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADCPREW<'a> { w: &'a mut W, } impl<'a> _ADCPREW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLSRCW<'a> { w: &'a mut W, } impl<'a> _PLLSRCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLXTPREW<'a> { w: &'a mut W, } impl<'a> _PLLXTPREW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLMULW<'a> { w: &'a mut W, } impl<'a> _PLLMULW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MCOW<'a> { w: &'a mut W, } impl<'a> _MCOW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MCOPREW<'a> { w: &'a mut W, } impl<'a> _MCOPREW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLNODIVW<'a> { w: &'a mut W, } impl<'a> _PLLNODIVW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:1 - System clock Switch"] #[inline] pub fn sw(&self) -> SWR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SWR { bits } } #[doc = "Bits 2:3 - System Clock Switch Status"] #[inline] pub fn sws(&self) -> SWSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SWSR { bits } } #[doc = "Bits 4:7 - AHB prescaler"] #[inline] pub fn hpre(&self) -> HPRER { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HPRER { bits } } #[doc = "Bits 8:10 - APB Low speed prescaler (APB1)"] #[inline] pub fn ppre(&self) -> PPRER { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PPRER { bits } } #[doc = "Bit 14 - ADC prescaler"] #[inline] pub fn adcpre(&self) -> ADCPRER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADCPRER { bits } } #[doc = "Bits 15:16 - PLL input clock source"] #[inline] pub fn pllsrc(&self) -> PLLSRCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLLSRCR { bits } } #[doc = "Bit 17 - HSE divider for PLL entry"] #[inline] pub fn pllxtpre(&self) -> PLLXTPRER { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PLLXTPRER { bits } } #[doc = "Bits 18:21 - PLL Multiplication Factor"] #[inline] pub fn pllmul(&self) -> PLLMULR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PLLMULR { bits } } #[doc = "Bits 24:26 - Microcontroller clock output"] #[inline] pub fn mco(&self) -> MCOR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MCOR { bits } } #[doc = "Bits 28:30 - Microcontroller Clock Output Prescaler"] #[inline] pub fn mcopre(&self) -> MCOPRER { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MCOPRER { bits } } #[doc = "Bit 31 - PLL clock not divided for MCO"] #[inline] pub fn pllnodiv(&self) -> PLLNODIVR { let bits = { const MASK: bool = true; const OFFSET: u8 = 31; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PLLNODIVR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:1 - System clock Switch"] #[inline] pub fn sw(&mut self) -> _SWW { _SWW { w: self } } #[doc = "Bits 4:7 - AHB prescaler"] #[inline] pub fn hpre(&mut self) -> _HPREW { _HPREW { w: self } } #[doc = "Bits 8:10 - APB Low speed prescaler (APB1)"] #[inline] pub fn ppre(&mut self) -> _PPREW { _PPREW { w: self } } #[doc = "Bit 14 - ADC prescaler"] #[inline] pub fn adcpre(&mut self) -> _ADCPREW { _ADCPREW { w: self } } #[doc = "Bits 15:16 - PLL input clock source"] #[inline] pub fn pllsrc(&mut self) -> _PLLSRCW { _PLLSRCW { w: self } } #[doc = "Bit 17 - HSE divider for PLL entry"] #[inline] pub fn pllxtpre(&mut self) -> _PLLXTPREW { _PLLXTPREW { w: self } } #[doc = "Bits 18:21 - PLL Multiplication Factor"] #[inline] pub fn pllmul(&mut self) -> _PLLMULW { _PLLMULW { w: self } } #[doc = "Bits 24:26 - Microcontroller clock output"] #[inline] pub fn mco(&mut self) -> _MCOW { _MCOW { w: self } } #[doc = "Bits 28:30 - Microcontroller Clock Output Prescaler"] #[inline] pub fn mcopre(&mut self) -> _MCOPREW { _MCOPREW { w: self } } #[doc = "Bit 31 - PLL clock not divided for MCO"] #[inline] pub fn pllnodiv(&mut self) -> _PLLNODIVW { _PLLNODIVW { w: self } } } } #[doc = "Clock interrupt register (RCC_CIR)"] pub struct CIR { register: ::vcell::VolatileCell, } #[doc = "Clock interrupt register (RCC_CIR)"] pub mod cir { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CIR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct LSIRDYFR { bits: bool, } impl LSIRDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSERDYFR { bits: bool, } impl LSERDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSIRDYFR { bits: bool, } impl HSIRDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSERDYFR { bits: bool, } impl HSERDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLLRDYFR { bits: bool, } impl PLLRDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI14RDYFR { bits: bool, } impl HSI14RDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI48RDYFR { bits: bool, } impl HSI48RDYFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CSSFR { bits: bool, } impl CSSFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSIRDYIER { bits: bool, } impl LSIRDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSERDYIER { bits: bool, } impl LSERDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSIRDYIER { bits: bool, } impl HSIRDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSERDYIER { bits: bool, } impl HSERDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PLLRDYIER { bits: bool, } impl PLLRDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI14RDYER { bits: bool, } impl HSI14RDYER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI48RDYIER { bits: bool, } impl HSI48RDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _LSIRDYIEW<'a> { w: &'a mut W, } impl<'a> _LSIRDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LSERDYIEW<'a> { w: &'a mut W, } impl<'a> _LSERDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSIRDYIEW<'a> { w: &'a mut W, } impl<'a> _HSIRDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSERDYIEW<'a> { w: &'a mut W, } impl<'a> _HSERDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLRDYIEW<'a> { w: &'a mut W, } impl<'a> _PLLRDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI14RDYEW<'a> { w: &'a mut W, } impl<'a> _HSI14RDYEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI48RDYIEW<'a> { w: &'a mut W, } impl<'a> _HSI48RDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LSIRDYCW<'a> { w: &'a mut W, } impl<'a> _LSIRDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LSERDYCW<'a> { w: &'a mut W, } impl<'a> _LSERDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSIRDYCW<'a> { w: &'a mut W, } impl<'a> _HSIRDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSERDYCW<'a> { w: &'a mut W, } impl<'a> _HSERDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PLLRDYCW<'a> { w: &'a mut W, } impl<'a> _PLLRDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI14RDYCW<'a> { w: &'a mut W, } impl<'a> _HSI14RDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI48RDYCW<'a> { w: &'a mut W, } impl<'a> _HSI48RDYCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CSSCW<'a> { w: &'a mut W, } impl<'a> _CSSCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - LSI Ready Interrupt flag"] #[inline] pub fn lsirdyf(&self) -> LSIRDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSIRDYFR { bits } } #[doc = "Bit 1 - LSE Ready Interrupt flag"] #[inline] pub fn lserdyf(&self) -> LSERDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSERDYFR { bits } } #[doc = "Bit 2 - HSI Ready Interrupt flag"] #[inline] pub fn hsirdyf(&self) -> HSIRDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSIRDYFR { bits } } #[doc = "Bit 3 - HSE Ready Interrupt flag"] #[inline] pub fn hserdyf(&self) -> HSERDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSERDYFR { bits } } #[doc = "Bit 4 - PLL Ready Interrupt flag"] #[inline] pub fn pllrdyf(&self) -> PLLRDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PLLRDYFR { bits } } #[doc = "Bit 5 - HSI14 ready interrupt flag"] #[inline] pub fn hsi14rdyf(&self) -> HSI14RDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI14RDYFR { bits } } #[doc = "Bit 6 - HSI48 ready interrupt flag"] #[inline] pub fn hsi48rdyf(&self) -> HSI48RDYFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI48RDYFR { bits } } #[doc = "Bit 7 - Clock Security System Interrupt flag"] #[inline] pub fn cssf(&self) -> CSSFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CSSFR { bits } } #[doc = "Bit 8 - LSI Ready Interrupt Enable"] #[inline] pub fn lsirdyie(&self) -> LSIRDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSIRDYIER { bits } } #[doc = "Bit 9 - LSE Ready Interrupt Enable"] #[inline] pub fn lserdyie(&self) -> LSERDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSERDYIER { bits } } #[doc = "Bit 10 - HSI Ready Interrupt Enable"] #[inline] pub fn hsirdyie(&self) -> HSIRDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSIRDYIER { bits } } #[doc = "Bit 11 - HSE Ready Interrupt Enable"] #[inline] pub fn hserdyie(&self) -> HSERDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSERDYIER { bits } } #[doc = "Bit 12 - PLL Ready Interrupt Enable"] #[inline] pub fn pllrdyie(&self) -> PLLRDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PLLRDYIER { bits } } #[doc = "Bit 13 - HSI14 ready interrupt enable"] #[inline] pub fn hsi14rdye(&self) -> HSI14RDYER { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI14RDYER { bits } } #[doc = "Bit 14 - HSI48 ready interrupt enable"] #[inline] pub fn hsi48rdyie(&self) -> HSI48RDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI48RDYIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 8 - LSI Ready Interrupt Enable"] #[inline] pub fn lsirdyie(&mut self) -> _LSIRDYIEW { _LSIRDYIEW { w: self } } #[doc = "Bit 9 - LSE Ready Interrupt Enable"] #[inline] pub fn lserdyie(&mut self) -> _LSERDYIEW { _LSERDYIEW { w: self } } #[doc = "Bit 10 - HSI Ready Interrupt Enable"] #[inline] pub fn hsirdyie(&mut self) -> _HSIRDYIEW { _HSIRDYIEW { w: self } } #[doc = "Bit 11 - HSE Ready Interrupt Enable"] #[inline] pub fn hserdyie(&mut self) -> _HSERDYIEW { _HSERDYIEW { w: self } } #[doc = "Bit 12 - PLL Ready Interrupt Enable"] #[inline] pub fn pllrdyie(&mut self) -> _PLLRDYIEW { _PLLRDYIEW { w: self } } #[doc = "Bit 13 - HSI14 ready interrupt enable"] #[inline] pub fn hsi14rdye(&mut self) -> _HSI14RDYEW { _HSI14RDYEW { w: self } } #[doc = "Bit 14 - HSI48 ready interrupt enable"] #[inline] pub fn hsi48rdyie(&mut self) -> _HSI48RDYIEW { _HSI48RDYIEW { w: self } } #[doc = "Bit 16 - LSI Ready Interrupt Clear"] #[inline] pub fn lsirdyc(&mut self) -> _LSIRDYCW { _LSIRDYCW { w: self } } #[doc = "Bit 17 - LSE Ready Interrupt Clear"] #[inline] pub fn lserdyc(&mut self) -> _LSERDYCW { _LSERDYCW { w: self } } #[doc = "Bit 18 - HSI Ready Interrupt Clear"] #[inline] pub fn hsirdyc(&mut self) -> _HSIRDYCW { _HSIRDYCW { w: self } } #[doc = "Bit 19 - HSE Ready Interrupt Clear"] #[inline] pub fn hserdyc(&mut self) -> _HSERDYCW { _HSERDYCW { w: self } } #[doc = "Bit 20 - PLL Ready Interrupt Clear"] #[inline] pub fn pllrdyc(&mut self) -> _PLLRDYCW { _PLLRDYCW { w: self } } #[doc = "Bit 21 - HSI 14 MHz Ready Interrupt Clear"] #[inline] pub fn hsi14rdyc(&mut self) -> _HSI14RDYCW { _HSI14RDYCW { w: self } } #[doc = "Bit 22 - HSI48 Ready Interrupt Clear"] #[inline] pub fn hsi48rdyc(&mut self) -> _HSI48RDYCW { _HSI48RDYCW { w: self } } #[doc = "Bit 23 - Clock security system interrupt clear"] #[inline] pub fn cssc(&mut self) -> _CSSCW { _CSSCW { w: self } } } } #[doc = "APB2 peripheral reset register (RCC_APB2RSTR)"] pub struct APB2RSTR { register: ::vcell::VolatileCell, } #[doc = "APB2 peripheral reset register (RCC_APB2RSTR)"] pub mod apb2rstr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::APB2RSTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SYSCFGRSTR { bits: bool, } impl SYSCFGRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADCRSTR { bits: bool, } impl ADCRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM1RSTR { bits: bool, } impl TIM1RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SPI1RSTR { bits: bool, } impl SPI1RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART1RSTR { bits: bool, } impl USART1RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM15RSTR { bits: bool, } impl TIM15RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM16RSTR { bits: bool, } impl TIM16RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM17RSTR { bits: bool, } impl TIM17RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBGMCURSTR { bits: bool, } impl DBGMCURSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _SYSCFGRSTW<'a> { w: &'a mut W, } impl<'a> _SYSCFGRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADCRSTW<'a> { w: &'a mut W, } impl<'a> _ADCRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM1RSTW<'a> { w: &'a mut W, } impl<'a> _TIM1RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SPI1RSTW<'a> { w: &'a mut W, } impl<'a> _SPI1RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART1RSTW<'a> { w: &'a mut W, } impl<'a> _USART1RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM15RSTW<'a> { w: &'a mut W, } impl<'a> _TIM15RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM16RSTW<'a> { w: &'a mut W, } impl<'a> _TIM16RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM17RSTW<'a> { w: &'a mut W, } impl<'a> _TIM17RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBGMCURSTW<'a> { w: &'a mut W, } impl<'a> _DBGMCURSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - SYSCFG and COMP reset"] #[inline] pub fn syscfgrst(&self) -> SYSCFGRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SYSCFGRSTR { bits } } #[doc = "Bit 9 - ADC interface reset"] #[inline] pub fn adcrst(&self) -> ADCRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADCRSTR { bits } } #[doc = "Bit 11 - TIM1 timer reset"] #[inline] pub fn tim1rst(&self) -> TIM1RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM1RSTR { bits } } #[doc = "Bit 12 - SPI 1 reset"] #[inline] pub fn spi1rst(&self) -> SPI1RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SPI1RSTR { bits } } #[doc = "Bit 14 - USART1 reset"] #[inline] pub fn usart1rst(&self) -> USART1RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART1RSTR { bits } } #[doc = "Bit 16 - TIM15 timer reset"] #[inline] pub fn tim15rst(&self) -> TIM15RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM15RSTR { bits } } #[doc = "Bit 17 - TIM16 timer reset"] #[inline] pub fn tim16rst(&self) -> TIM16RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM16RSTR { bits } } #[doc = "Bit 18 - TIM17 timer reset"] #[inline] pub fn tim17rst(&self) -> TIM17RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM17RSTR { bits } } #[doc = "Bit 22 - Debug MCU reset"] #[inline] pub fn dbgmcurst(&self) -> DBGMCURSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBGMCURSTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - SYSCFG and COMP reset"] #[inline] pub fn syscfgrst(&mut self) -> _SYSCFGRSTW { _SYSCFGRSTW { w: self } } #[doc = "Bit 9 - ADC interface reset"] #[inline] pub fn adcrst(&mut self) -> _ADCRSTW { _ADCRSTW { w: self } } #[doc = "Bit 11 - TIM1 timer reset"] #[inline] pub fn tim1rst(&mut self) -> _TIM1RSTW { _TIM1RSTW { w: self } } #[doc = "Bit 12 - SPI 1 reset"] #[inline] pub fn spi1rst(&mut self) -> _SPI1RSTW { _SPI1RSTW { w: self } } #[doc = "Bit 14 - USART1 reset"] #[inline] pub fn usart1rst(&mut self) -> _USART1RSTW { _USART1RSTW { w: self } } #[doc = "Bit 16 - TIM15 timer reset"] #[inline] pub fn tim15rst(&mut self) -> _TIM15RSTW { _TIM15RSTW { w: self } } #[doc = "Bit 17 - TIM16 timer reset"] #[inline] pub fn tim16rst(&mut self) -> _TIM16RSTW { _TIM16RSTW { w: self } } #[doc = "Bit 18 - TIM17 timer reset"] #[inline] pub fn tim17rst(&mut self) -> _TIM17RSTW { _TIM17RSTW { w: self } } #[doc = "Bit 22 - Debug MCU reset"] #[inline] pub fn dbgmcurst(&mut self) -> _DBGMCURSTW { _DBGMCURSTW { w: self } } } } #[doc = "APB1 peripheral reset register (RCC_APB1RSTR)"] pub struct APB1RSTR { register: ::vcell::VolatileCell, } #[doc = "APB1 peripheral reset register (RCC_APB1RSTR)"] pub mod apb1rstr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::APB1RSTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TIM3RSTR { bits: bool, } impl TIM3RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM6RSTR { bits: bool, } impl TIM6RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM14RSTR { bits: bool, } impl TIM14RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WWDGRSTR { bits: bool, } impl WWDGRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SPI2RSTR { bits: bool, } impl SPI2RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART2RSTR { bits: bool, } impl USART2RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C1RSTR { bits: bool, } impl I2C1RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C2RSTR { bits: bool, } impl I2C2RSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PWRRSTR { bits: bool, } impl PWRRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TIM3RSTW<'a> { w: &'a mut W, } impl<'a> _TIM3RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM6RSTW<'a> { w: &'a mut W, } impl<'a> _TIM6RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM14RSTW<'a> { w: &'a mut W, } impl<'a> _TIM14RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WWDGRSTW<'a> { w: &'a mut W, } impl<'a> _WWDGRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SPI2RSTW<'a> { w: &'a mut W, } impl<'a> _SPI2RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART2RSTW<'a> { w: &'a mut W, } impl<'a> _USART2RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C1RSTW<'a> { w: &'a mut W, } impl<'a> _I2C1RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C2RSTW<'a> { w: &'a mut W, } impl<'a> _I2C2RSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PWRRSTW<'a> { w: &'a mut W, } impl<'a> _PWRRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 1 - Timer 3 reset"] #[inline] pub fn tim3rst(&self) -> TIM3RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM3RSTR { bits } } #[doc = "Bit 4 - Timer 6 reset"] #[inline] pub fn tim6rst(&self) -> TIM6RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM6RSTR { bits } } #[doc = "Bit 8 - Timer 14 reset"] #[inline] pub fn tim14rst(&self) -> TIM14RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM14RSTR { bits } } #[doc = "Bit 11 - Window watchdog reset"] #[inline] pub fn wwdgrst(&self) -> WWDGRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WWDGRSTR { bits } } #[doc = "Bit 14 - SPI2 reset"] #[inline] pub fn spi2rst(&self) -> SPI2RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SPI2RSTR { bits } } #[doc = "Bit 17 - USART 2 reset"] #[inline] pub fn usart2rst(&self) -> USART2RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART2RSTR { bits } } #[doc = "Bit 21 - I2C1 reset"] #[inline] pub fn i2c1rst(&self) -> I2C1RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C1RSTR { bits } } #[doc = "Bit 22 - I2C2 reset"] #[inline] pub fn i2c2rst(&self) -> I2C2RSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C2RSTR { bits } } #[doc = "Bit 28 - Power interface reset"] #[inline] pub fn pwrrst(&self) -> PWRRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PWRRSTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 1 - Timer 3 reset"] #[inline] pub fn tim3rst(&mut self) -> _TIM3RSTW { _TIM3RSTW { w: self } } #[doc = "Bit 4 - Timer 6 reset"] #[inline] pub fn tim6rst(&mut self) -> _TIM6RSTW { _TIM6RSTW { w: self } } #[doc = "Bit 8 - Timer 14 reset"] #[inline] pub fn tim14rst(&mut self) -> _TIM14RSTW { _TIM14RSTW { w: self } } #[doc = "Bit 11 - Window watchdog reset"] #[inline] pub fn wwdgrst(&mut self) -> _WWDGRSTW { _WWDGRSTW { w: self } } #[doc = "Bit 14 - SPI2 reset"] #[inline] pub fn spi2rst(&mut self) -> _SPI2RSTW { _SPI2RSTW { w: self } } #[doc = "Bit 17 - USART 2 reset"] #[inline] pub fn usart2rst(&mut self) -> _USART2RSTW { _USART2RSTW { w: self } } #[doc = "Bit 21 - I2C1 reset"] #[inline] pub fn i2c1rst(&mut self) -> _I2C1RSTW { _I2C1RSTW { w: self } } #[doc = "Bit 22 - I2C2 reset"] #[inline] pub fn i2c2rst(&mut self) -> _I2C2RSTW { _I2C2RSTW { w: self } } #[doc = "Bit 28 - Power interface reset"] #[inline] pub fn pwrrst(&mut self) -> _PWRRSTW { _PWRRSTW { w: self } } } } #[doc = "AHB Peripheral Clock enable register (RCC_AHBENR)"] pub struct AHBENR { register: ::vcell::VolatileCell, } #[doc = "AHB Peripheral Clock enable register (RCC_AHBENR)"] pub mod ahbenr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AHBENR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DMAENR { bits: bool, } impl DMAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SRAMENR { bits: bool, } impl SRAMENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct FLITFENR { bits: bool, } impl FLITFENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CRCENR { bits: bool, } impl CRCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPAENR { bits: bool, } impl IOPAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPBENR { bits: bool, } impl IOPBENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPCENR { bits: bool, } impl IOPCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPDENR { bits: bool, } impl IOPDENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPFENR { bits: bool, } impl IOPFENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _DMAENW<'a> { w: &'a mut W, } impl<'a> _DMAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SRAMENW<'a> { w: &'a mut W, } impl<'a> _SRAMENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _FLITFENW<'a> { w: &'a mut W, } impl<'a> _FLITFENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CRCENW<'a> { w: &'a mut W, } impl<'a> _CRCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPAENW<'a> { w: &'a mut W, } impl<'a> _IOPAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPBENW<'a> { w: &'a mut W, } impl<'a> _IOPBENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPCENW<'a> { w: &'a mut W, } impl<'a> _IOPCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPDENW<'a> { w: &'a mut W, } impl<'a> _IOPDENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPFENW<'a> { w: &'a mut W, } impl<'a> _IOPFENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - DMA1 clock enable"] #[inline] pub fn dmaen(&self) -> DMAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DMAENR { bits } } #[doc = "Bit 2 - SRAM interface clock enable"] #[inline] pub fn sramen(&self) -> SRAMENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SRAMENR { bits } } #[doc = "Bit 4 - FLITF clock enable"] #[inline] pub fn flitfen(&self) -> FLITFENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FLITFENR { bits } } #[doc = "Bit 6 - CRC clock enable"] #[inline] pub fn crcen(&self) -> CRCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CRCENR { bits } } #[doc = "Bit 17 - I/O port A clock enable"] #[inline] pub fn iopaen(&self) -> IOPAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPAENR { bits } } #[doc = "Bit 18 - I/O port B clock enable"] #[inline] pub fn iopben(&self) -> IOPBENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPBENR { bits } } #[doc = "Bit 19 - I/O port C clock enable"] #[inline] pub fn iopcen(&self) -> IOPCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPCENR { bits } } #[doc = "Bit 20 - I/O port D clock enable"] #[inline] pub fn iopden(&self) -> IOPDENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPDENR { bits } } #[doc = "Bit 22 - I/O port F clock enable"] #[inline] pub fn iopfen(&self) -> IOPFENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPFENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x14 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - DMA1 clock enable"] #[inline] pub fn dmaen(&mut self) -> _DMAENW { _DMAENW { w: self } } #[doc = "Bit 2 - SRAM interface clock enable"] #[inline] pub fn sramen(&mut self) -> _SRAMENW { _SRAMENW { w: self } } #[doc = "Bit 4 - FLITF clock enable"] #[inline] pub fn flitfen(&mut self) -> _FLITFENW { _FLITFENW { w: self } } #[doc = "Bit 6 - CRC clock enable"] #[inline] pub fn crcen(&mut self) -> _CRCENW { _CRCENW { w: self } } #[doc = "Bit 17 - I/O port A clock enable"] #[inline] pub fn iopaen(&mut self) -> _IOPAENW { _IOPAENW { w: self } } #[doc = "Bit 18 - I/O port B clock enable"] #[inline] pub fn iopben(&mut self) -> _IOPBENW { _IOPBENW { w: self } } #[doc = "Bit 19 - I/O port C clock enable"] #[inline] pub fn iopcen(&mut self) -> _IOPCENW { _IOPCENW { w: self } } #[doc = "Bit 20 - I/O port D clock enable"] #[inline] pub fn iopden(&mut self) -> _IOPDENW { _IOPDENW { w: self } } #[doc = "Bit 22 - I/O port F clock enable"] #[inline] pub fn iopfen(&mut self) -> _IOPFENW { _IOPFENW { w: self } } } } #[doc = "APB2 peripheral clock enable register (RCC_APB2ENR)"] pub struct APB2ENR { register: ::vcell::VolatileCell, } #[doc = "APB2 peripheral clock enable register (RCC_APB2ENR)"] pub mod apb2enr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::APB2ENR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SYSCFGENR { bits: bool, } impl SYSCFGENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADCENR { bits: bool, } impl ADCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM1ENR { bits: bool, } impl TIM1ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SPI1ENR { bits: bool, } impl SPI1ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART1ENR { bits: bool, } impl USART1ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM15ENR { bits: bool, } impl TIM15ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM16ENR { bits: bool, } impl TIM16ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM17ENR { bits: bool, } impl TIM17ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBGMCUENR { bits: bool, } impl DBGMCUENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _SYSCFGENW<'a> { w: &'a mut W, } impl<'a> _SYSCFGENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADCENW<'a> { w: &'a mut W, } impl<'a> _ADCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM1ENW<'a> { w: &'a mut W, } impl<'a> _TIM1ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SPI1ENW<'a> { w: &'a mut W, } impl<'a> _SPI1ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART1ENW<'a> { w: &'a mut W, } impl<'a> _USART1ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM15ENW<'a> { w: &'a mut W, } impl<'a> _TIM15ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM16ENW<'a> { w: &'a mut W, } impl<'a> _TIM16ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM17ENW<'a> { w: &'a mut W, } impl<'a> _TIM17ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBGMCUENW<'a> { w: &'a mut W, } impl<'a> _DBGMCUENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - SYSCFG clock enable"] #[inline] pub fn syscfgen(&self) -> SYSCFGENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SYSCFGENR { bits } } #[doc = "Bit 9 - ADC 1 interface clock enable"] #[inline] pub fn adcen(&self) -> ADCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADCENR { bits } } #[doc = "Bit 11 - TIM1 Timer clock enable"] #[inline] pub fn tim1en(&self) -> TIM1ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM1ENR { bits } } #[doc = "Bit 12 - SPI 1 clock enable"] #[inline] pub fn spi1en(&self) -> SPI1ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SPI1ENR { bits } } #[doc = "Bit 14 - USART1 clock enable"] #[inline] pub fn usart1en(&self) -> USART1ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART1ENR { bits } } #[doc = "Bit 16 - TIM15 timer clock enable"] #[inline] pub fn tim15en(&self) -> TIM15ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM15ENR { bits } } #[doc = "Bit 17 - TIM16 timer clock enable"] #[inline] pub fn tim16en(&self) -> TIM16ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM16ENR { bits } } #[doc = "Bit 18 - TIM17 timer clock enable"] #[inline] pub fn tim17en(&self) -> TIM17ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM17ENR { bits } } #[doc = "Bit 22 - MCU debug module clock enable"] #[inline] pub fn dbgmcuen(&self) -> DBGMCUENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBGMCUENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - SYSCFG clock enable"] #[inline] pub fn syscfgen(&mut self) -> _SYSCFGENW { _SYSCFGENW { w: self } } #[doc = "Bit 9 - ADC 1 interface clock enable"] #[inline] pub fn adcen(&mut self) -> _ADCENW { _ADCENW { w: self } } #[doc = "Bit 11 - TIM1 Timer clock enable"] #[inline] pub fn tim1en(&mut self) -> _TIM1ENW { _TIM1ENW { w: self } } #[doc = "Bit 12 - SPI 1 clock enable"] #[inline] pub fn spi1en(&mut self) -> _SPI1ENW { _SPI1ENW { w: self } } #[doc = "Bit 14 - USART1 clock enable"] #[inline] pub fn usart1en(&mut self) -> _USART1ENW { _USART1ENW { w: self } } #[doc = "Bit 16 - TIM15 timer clock enable"] #[inline] pub fn tim15en(&mut self) -> _TIM15ENW { _TIM15ENW { w: self } } #[doc = "Bit 17 - TIM16 timer clock enable"] #[inline] pub fn tim16en(&mut self) -> _TIM16ENW { _TIM16ENW { w: self } } #[doc = "Bit 18 - TIM17 timer clock enable"] #[inline] pub fn tim17en(&mut self) -> _TIM17ENW { _TIM17ENW { w: self } } #[doc = "Bit 22 - MCU debug module clock enable"] #[inline] pub fn dbgmcuen(&mut self) -> _DBGMCUENW { _DBGMCUENW { w: self } } } } #[doc = "APB1 peripheral clock enable register (RCC_APB1ENR)"] pub struct APB1ENR { register: ::vcell::VolatileCell, } #[doc = "APB1 peripheral clock enable register (RCC_APB1ENR)"] pub mod apb1enr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::APB1ENR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TIM3ENR { bits: bool, } impl TIM3ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM6ENR { bits: bool, } impl TIM6ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM14ENR { bits: bool, } impl TIM14ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WWDGENR { bits: bool, } impl WWDGENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SPI2ENR { bits: bool, } impl SPI2ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART2ENR { bits: bool, } impl USART2ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C1ENR { bits: bool, } impl I2C1ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C2ENR { bits: bool, } impl I2C2ENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PWRENR { bits: bool, } impl PWRENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TIM3ENW<'a> { w: &'a mut W, } impl<'a> _TIM3ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM6ENW<'a> { w: &'a mut W, } impl<'a> _TIM6ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM14ENW<'a> { w: &'a mut W, } impl<'a> _TIM14ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WWDGENW<'a> { w: &'a mut W, } impl<'a> _WWDGENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SPI2ENW<'a> { w: &'a mut W, } impl<'a> _SPI2ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART2ENW<'a> { w: &'a mut W, } impl<'a> _USART2ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C1ENW<'a> { w: &'a mut W, } impl<'a> _I2C1ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C2ENW<'a> { w: &'a mut W, } impl<'a> _I2C2ENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PWRENW<'a> { w: &'a mut W, } impl<'a> _PWRENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 1 - Timer 3 clock enable"] #[inline] pub fn tim3en(&self) -> TIM3ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM3ENR { bits } } #[doc = "Bit 4 - Timer 6 clock enable"] #[inline] pub fn tim6en(&self) -> TIM6ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM6ENR { bits } } #[doc = "Bit 8 - Timer 14 clock enable"] #[inline] pub fn tim14en(&self) -> TIM14ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM14ENR { bits } } #[doc = "Bit 11 - Window watchdog clock enable"] #[inline] pub fn wwdgen(&self) -> WWDGENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WWDGENR { bits } } #[doc = "Bit 14 - SPI 2 clock enable"] #[inline] pub fn spi2en(&self) -> SPI2ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SPI2ENR { bits } } #[doc = "Bit 17 - USART 2 clock enable"] #[inline] pub fn usart2en(&self) -> USART2ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART2ENR { bits } } #[doc = "Bit 21 - I2C 1 clock enable"] #[inline] pub fn i2c1en(&self) -> I2C1ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C1ENR { bits } } #[doc = "Bit 22 - I2C 2 clock enable"] #[inline] pub fn i2c2en(&self) -> I2C2ENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C2ENR { bits } } #[doc = "Bit 28 - Power interface clock enable"] #[inline] pub fn pwren(&self) -> PWRENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PWRENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 1 - Timer 3 clock enable"] #[inline] pub fn tim3en(&mut self) -> _TIM3ENW { _TIM3ENW { w: self } } #[doc = "Bit 4 - Timer 6 clock enable"] #[inline] pub fn tim6en(&mut self) -> _TIM6ENW { _TIM6ENW { w: self } } #[doc = "Bit 8 - Timer 14 clock enable"] #[inline] pub fn tim14en(&mut self) -> _TIM14ENW { _TIM14ENW { w: self } } #[doc = "Bit 11 - Window watchdog clock enable"] #[inline] pub fn wwdgen(&mut self) -> _WWDGENW { _WWDGENW { w: self } } #[doc = "Bit 14 - SPI 2 clock enable"] #[inline] pub fn spi2en(&mut self) -> _SPI2ENW { _SPI2ENW { w: self } } #[doc = "Bit 17 - USART 2 clock enable"] #[inline] pub fn usart2en(&mut self) -> _USART2ENW { _USART2ENW { w: self } } #[doc = "Bit 21 - I2C 1 clock enable"] #[inline] pub fn i2c1en(&mut self) -> _I2C1ENW { _I2C1ENW { w: self } } #[doc = "Bit 22 - I2C 2 clock enable"] #[inline] pub fn i2c2en(&mut self) -> _I2C2ENW { _I2C2ENW { w: self } } #[doc = "Bit 28 - Power interface clock enable"] #[inline] pub fn pwren(&mut self) -> _PWRENW { _PWRENW { w: self } } } } #[doc = "Backup domain control register (RCC_BDCR)"] pub struct BDCR { register: ::vcell::VolatileCell, } #[doc = "Backup domain control register (RCC_BDCR)"] pub mod bdcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BDCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct LSEONR { bits: bool, } impl LSEONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSERDYR { bits: bool, } impl LSERDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSEBYPR { bits: bool, } impl LSEBYPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSEDRVR { bits: u8, } impl LSEDRVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct RTCSELR { bits: u8, } impl RTCSELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct RTCENR { bits: bool, } impl RTCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BDRSTR { bits: bool, } impl BDRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _LSEONW<'a> { w: &'a mut W, } impl<'a> _LSEONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LSEBYPW<'a> { w: &'a mut W, } impl<'a> _LSEBYPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LSEDRVW<'a> { w: &'a mut W, } impl<'a> _LSEDRVW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTCSELW<'a> { w: &'a mut W, } impl<'a> _RTCSELW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTCENW<'a> { w: &'a mut W, } impl<'a> _RTCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BDRSTW<'a> { w: &'a mut W, } impl<'a> _BDRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - External Low Speed oscillator enable"] #[inline] pub fn lseon(&self) -> LSEONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSEONR { bits } } #[doc = "Bit 1 - External Low Speed oscillator ready"] #[inline] pub fn lserdy(&self) -> LSERDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSERDYR { bits } } #[doc = "Bit 2 - External Low Speed oscillator bypass"] #[inline] pub fn lsebyp(&self) -> LSEBYPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSEBYPR { bits } } #[doc = "Bits 3:4 - LSE oscillator drive capability"] #[inline] pub fn lsedrv(&self) -> LSEDRVR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) as u8 }; LSEDRVR { bits } } #[doc = "Bits 8:9 - RTC clock source selection"] #[inline] pub fn rtcsel(&self) -> RTCSELR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; RTCSELR { bits } } #[doc = "Bit 15 - RTC clock enable"] #[inline] pub fn rtcen(&self) -> RTCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RTCENR { bits } } #[doc = "Bit 16 - Backup domain software reset"] #[inline] pub fn bdrst(&self) -> BDRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BDRSTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - External Low Speed oscillator enable"] #[inline] pub fn lseon(&mut self) -> _LSEONW { _LSEONW { w: self } } #[doc = "Bit 2 - External Low Speed oscillator bypass"] #[inline] pub fn lsebyp(&mut self) -> _LSEBYPW { _LSEBYPW { w: self } } #[doc = "Bits 3:4 - LSE oscillator drive capability"] #[inline] pub fn lsedrv(&mut self) -> _LSEDRVW { _LSEDRVW { w: self } } #[doc = "Bits 8:9 - RTC clock source selection"] #[inline] pub fn rtcsel(&mut self) -> _RTCSELW { _RTCSELW { w: self } } #[doc = "Bit 15 - RTC clock enable"] #[inline] pub fn rtcen(&mut self) -> _RTCENW { _RTCENW { w: self } } #[doc = "Bit 16 - Backup domain software reset"] #[inline] pub fn bdrst(&mut self) -> _BDRSTW { _BDRSTW { w: self } } } } #[doc = "Control/status register (RCC_CSR)"] pub struct CSR { register: ::vcell::VolatileCell, } #[doc = "Control/status register (RCC_CSR)"] pub mod csr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CSR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct LSIONR { bits: bool, } impl LSIONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LSIRDYR { bits: bool, } impl LSIRDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RMVFR { bits: bool, } impl RMVFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OBLRSTFR { bits: bool, } impl OBLRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PINRSTFR { bits: bool, } impl PINRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PORRSTFR { bits: bool, } impl PORRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SFTRSTFR { bits: bool, } impl SFTRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IWDGRSTFR { bits: bool, } impl IWDGRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WWDGRSTFR { bits: bool, } impl WWDGRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LPWRRSTFR { bits: bool, } impl LPWRRSTFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _LSIONW<'a> { w: &'a mut W, } impl<'a> _LSIONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RMVFW<'a> { w: &'a mut W, } impl<'a> _RMVFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OBLRSTFW<'a> { w: &'a mut W, } impl<'a> _OBLRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PINRSTFW<'a> { w: &'a mut W, } impl<'a> _PINRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PORRSTFW<'a> { w: &'a mut W, } impl<'a> _PORRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SFTRSTFW<'a> { w: &'a mut W, } impl<'a> _SFTRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IWDGRSTFW<'a> { w: &'a mut W, } impl<'a> _IWDGRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 29; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WWDGRSTFW<'a> { w: &'a mut W, } impl<'a> _WWDGRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LPWRRSTFW<'a> { w: &'a mut W, } impl<'a> _LPWRRSTFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Internal low speed oscillator enable"] #[inline] pub fn lsion(&self) -> LSIONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSIONR { bits } } #[doc = "Bit 1 - Internal low speed oscillator ready"] #[inline] pub fn lsirdy(&self) -> LSIRDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LSIRDYR { bits } } #[doc = "Bit 24 - Remove reset flag"] #[inline] pub fn rmvf(&self) -> RMVFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RMVFR { bits } } #[doc = "Bit 25 - Option byte loader reset flag"] #[inline] pub fn oblrstf(&self) -> OBLRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OBLRSTFR { bits } } #[doc = "Bit 26 - PIN reset flag"] #[inline] pub fn pinrstf(&self) -> PINRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PINRSTFR { bits } } #[doc = "Bit 27 - POR/PDR reset flag"] #[inline] pub fn porrstf(&self) -> PORRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 27; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PORRSTFR { bits } } #[doc = "Bit 28 - Software reset flag"] #[inline] pub fn sftrstf(&self) -> SFTRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SFTRSTFR { bits } } #[doc = "Bit 29 - Independent watchdog reset flag"] #[inline] pub fn iwdgrstf(&self) -> IWDGRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 29; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IWDGRSTFR { bits } } #[doc = "Bit 30 - Window watchdog reset flag"] #[inline] pub fn wwdgrstf(&self) -> WWDGRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WWDGRSTFR { bits } } #[doc = "Bit 31 - Low-power reset flag"] #[inline] pub fn lpwrrstf(&self) -> LPWRRSTFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 31; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LPWRRSTFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x0c00_0000 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Internal low speed oscillator enable"] #[inline] pub fn lsion(&mut self) -> _LSIONW { _LSIONW { w: self } } #[doc = "Bit 24 - Remove reset flag"] #[inline] pub fn rmvf(&mut self) -> _RMVFW { _RMVFW { w: self } } #[doc = "Bit 25 - Option byte loader reset flag"] #[inline] pub fn oblrstf(&mut self) -> _OBLRSTFW { _OBLRSTFW { w: self } } #[doc = "Bit 26 - PIN reset flag"] #[inline] pub fn pinrstf(&mut self) -> _PINRSTFW { _PINRSTFW { w: self } } #[doc = "Bit 27 - POR/PDR reset flag"] #[inline] pub fn porrstf(&mut self) -> _PORRSTFW { _PORRSTFW { w: self } } #[doc = "Bit 28 - Software reset flag"] #[inline] pub fn sftrstf(&mut self) -> _SFTRSTFW { _SFTRSTFW { w: self } } #[doc = "Bit 29 - Independent watchdog reset flag"] #[inline] pub fn iwdgrstf(&mut self) -> _IWDGRSTFW { _IWDGRSTFW { w: self } } #[doc = "Bit 30 - Window watchdog reset flag"] #[inline] pub fn wwdgrstf(&mut self) -> _WWDGRSTFW { _WWDGRSTFW { w: self } } #[doc = "Bit 31 - Low-power reset flag"] #[inline] pub fn lpwrrstf(&mut self) -> _LPWRRSTFW { _LPWRRSTFW { w: self } } } } #[doc = "AHB peripheral reset register"] pub struct AHBRSTR { register: ::vcell::VolatileCell, } #[doc = "AHB peripheral reset register"] pub mod ahbrstr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AHBRSTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IOPARSTR { bits: bool, } impl IOPARSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPBRSTR { bits: bool, } impl IOPBRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPCRSTR { bits: bool, } impl IOPCRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPDRSTR { bits: bool, } impl IOPDRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IOPFRSTR { bits: bool, } impl IOPFRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _IOPARSTW<'a> { w: &'a mut W, } impl<'a> _IOPARSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPBRSTW<'a> { w: &'a mut W, } impl<'a> _IOPBRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPCRSTW<'a> { w: &'a mut W, } impl<'a> _IOPCRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPDRSTW<'a> { w: &'a mut W, } impl<'a> _IOPDRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IOPFRSTW<'a> { w: &'a mut W, } impl<'a> _IOPFRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 17 - I/O port A reset"] #[inline] pub fn ioparst(&self) -> IOPARSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPARSTR { bits } } #[doc = "Bit 18 - I/O port B reset"] #[inline] pub fn iopbrst(&self) -> IOPBRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPBRSTR { bits } } #[doc = "Bit 19 - I/O port C reset"] #[inline] pub fn iopcrst(&self) -> IOPCRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPCRSTR { bits } } #[doc = "Bit 20 - I/O port D reset"] #[inline] pub fn iopdrst(&self) -> IOPDRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPDRSTR { bits } } #[doc = "Bit 22 - I/O port F reset"] #[inline] pub fn iopfrst(&self) -> IOPFRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IOPFRSTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 17 - I/O port A reset"] #[inline] pub fn ioparst(&mut self) -> _IOPARSTW { _IOPARSTW { w: self } } #[doc = "Bit 18 - I/O port B reset"] #[inline] pub fn iopbrst(&mut self) -> _IOPBRSTW { _IOPBRSTW { w: self } } #[doc = "Bit 19 - I/O port C reset"] #[inline] pub fn iopcrst(&mut self) -> _IOPCRSTW { _IOPCRSTW { w: self } } #[doc = "Bit 20 - I/O port D reset"] #[inline] pub fn iopdrst(&mut self) -> _IOPDRSTW { _IOPDRSTW { w: self } } #[doc = "Bit 22 - I/O port F reset"] #[inline] pub fn iopfrst(&mut self) -> _IOPFRSTW { _IOPFRSTW { w: self } } } } #[doc = "Clock configuration register 2"] pub struct CFGR2 { register: ::vcell::VolatileCell, } #[doc = "Clock configuration register 2"] pub mod cfgr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PREDIVR { bits: u8, } impl PREDIVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _PREDIVW<'a> { w: &'a mut W, } impl<'a> _PREDIVW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:3 - PREDIV division factor"] #[inline] pub fn prediv(&self) -> PREDIVR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PREDIVR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:3 - PREDIV division factor"] #[inline] pub fn prediv(&mut self) -> _PREDIVW { _PREDIVW { w: self } } } } #[doc = "Clock configuration register 3"] pub struct CFGR3 { register: ::vcell::VolatileCell, } #[doc = "Clock configuration register 3"] pub mod cfgr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct USART1SWR { bits: u8, } impl USART1SWR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct I2C1SWR { bits: bool, } impl I2C1SWR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADCSWR { bits: bool, } impl ADCSWR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART2SWR { bits: u8, } impl USART2SWR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _USART1SWW<'a> { w: &'a mut W, } impl<'a> _USART1SWW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C1SWW<'a> { w: &'a mut W, } impl<'a> _I2C1SWW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADCSWW<'a> { w: &'a mut W, } impl<'a> _ADCSWW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART2SWW<'a> { w: &'a mut W, } impl<'a> _USART2SWW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:1 - USART1 clock source selection"] #[inline] pub fn usart1sw(&self) -> USART1SWR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; USART1SWR { bits } } #[doc = "Bit 4 - I2C1 clock source selection"] #[inline] pub fn i2c1sw(&self) -> I2C1SWR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C1SWR { bits } } #[doc = "Bit 8 - ADC clock source selection"] #[inline] pub fn adcsw(&self) -> ADCSWR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADCSWR { bits } } #[doc = "Bits 16:17 - USART2 clock source selection"] #[inline] pub fn usart2sw(&self) -> USART2SWR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; USART2SWR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:1 - USART1 clock source selection"] #[inline] pub fn usart1sw(&mut self) -> _USART1SWW { _USART1SWW { w: self } } #[doc = "Bit 4 - I2C1 clock source selection"] #[inline] pub fn i2c1sw(&mut self) -> _I2C1SWW { _I2C1SWW { w: self } } #[doc = "Bit 8 - ADC clock source selection"] #[inline] pub fn adcsw(&mut self) -> _ADCSWW { _ADCSWW { w: self } } #[doc = "Bits 16:17 - USART2 clock source selection"] #[inline] pub fn usart2sw(&mut self) -> _USART2SWW { _USART2SWW { w: self } } } } #[doc = "Clock control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "Clock control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct HSI14ONR { bits: bool, } impl HSI14ONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI14RDYR { bits: bool, } impl HSI14RDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI14DISR { bits: bool, } impl HSI14DISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI14TRIMR { bits: u8, } impl HSI14TRIMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HSI14CALR { bits: u8, } impl HSI14CALR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HSI48ONR { bits: bool, } impl HSI48ONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI48RDYR { bits: bool, } impl HSI48RDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HSI48CALR { bits: bool, } impl HSI48CALR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _HSI14ONW<'a> { w: &'a mut W, } impl<'a> _HSI14ONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI14DISW<'a> { w: &'a mut W, } impl<'a> _HSI14DISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI14TRIMW<'a> { w: &'a mut W, } impl<'a> _HSI14TRIMW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HSI48ONW<'a> { w: &'a mut W, } impl<'a> _HSI48ONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - HSI14 clock enable"] #[inline] pub fn hsi14on(&self) -> HSI14ONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI14ONR { bits } } #[doc = "Bit 1 - HR14 clock ready flag"] #[inline] pub fn hsi14rdy(&self) -> HSI14RDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI14RDYR { bits } } #[doc = "Bit 2 - HSI14 clock request from ADC disable"] #[inline] pub fn hsi14dis(&self) -> HSI14DISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI14DISR { bits } } #[doc = "Bits 3:7 - HSI14 clock trimming"] #[inline] pub fn hsi14trim(&self) -> HSI14TRIMR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HSI14TRIMR { bits } } #[doc = "Bits 8:15 - HSI14 clock calibration"] #[inline] pub fn hsi14cal(&self) -> HSI14CALR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HSI14CALR { bits } } #[doc = "Bit 16 - HSI48 clock enable"] #[inline] pub fn hsi48on(&self) -> HSI48ONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI48ONR { bits } } #[doc = "Bit 17 - HSI48 clock ready flag"] #[inline] pub fn hsi48rdy(&self) -> HSI48RDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI48RDYR { bits } } #[doc = "Bit 24 - HSI48 factory clock calibration"] #[inline] pub fn hsi48cal(&self) -> HSI48CALR { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HSI48CALR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x80 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - HSI14 clock enable"] #[inline] pub fn hsi14on(&mut self) -> _HSI14ONW { _HSI14ONW { w: self } } #[doc = "Bit 2 - HSI14 clock request from ADC disable"] #[inline] pub fn hsi14dis(&mut self) -> _HSI14DISW { _HSI14DISW { w: self } } #[doc = "Bits 3:7 - HSI14 clock trimming"] #[inline] pub fn hsi14trim(&mut self) -> _HSI14TRIMW { _HSI14TRIMW { w: self } } #[doc = "Bit 16 - HSI48 clock enable"] #[inline] pub fn hsi48on(&mut self) -> _HSI48ONW { _HSI48ONW { w: self } } } } } #[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 { 0x4001_0000 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - configuration register 1"] pub cfgr1: CFGR1, _reserved0: [u8; 4usize], #[doc = "0x08 - external interrupt configuration register 1"] pub exticr1: EXTICR1, #[doc = "0x0c - external interrupt configuration register 2"] pub exticr2: EXTICR2, #[doc = "0x10 - external interrupt configuration register 3"] pub exticr3: EXTICR3, #[doc = "0x14 - external interrupt configuration register 4"] pub exticr4: EXTICR4, #[doc = "0x18 - configuration register 2"] pub cfgr2: CFGR2, } #[doc = "configuration register 1"] pub struct CFGR1 { register: ::vcell::VolatileCell, } #[doc = "configuration register 1"] pub mod cfgr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MEM_MODER { bits: u8, } impl MEM_MODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ADC_DMA_RMPR { bits: bool, } impl ADC_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART1_TX_DMA_RMPR { bits: bool, } impl USART1_TX_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART1_RX_DMA_RMPR { bits: bool, } impl USART1_RX_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM16_DMA_RMPR { bits: bool, } impl TIM16_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM17_DMA_RMPR { bits: bool, } impl TIM17_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C_PB6_FMR { bits: bool, } impl I2C_PB6_FMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C_PB7_FMR { bits: bool, } impl I2C_PB7_FMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C_PB8_FMR { bits: bool, } impl I2C_PB8_FMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C_PB9_FMR { bits: bool, } impl I2C_PB9_FMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C1_FM_PLUSR { bits: bool, } impl I2C1_FM_PLUSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C2_FM_PLUSR { bits: bool, } impl I2C2_FM_PLUSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SPI2_DMA_RMPR { bits: bool, } impl SPI2_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART2_DMA_RMPR { bits: bool, } impl USART2_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct USART3_DMA_RMPR { bits: bool, } impl USART3_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C1_DMA_RMPR { bits: bool, } impl I2C1_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM1_DMA_RMPR { bits: bool, } impl TIM1_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM2_DMA_RMPR { bits: bool, } impl TIM2_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIM3_DMA_RMPR { bits: bool, } impl TIM3_DMA_RMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _MEM_MODEW<'a> { w: &'a mut W, } impl<'a> _MEM_MODEW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADC_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _ADC_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART1_TX_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _USART1_TX_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART1_RX_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _USART1_RX_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM16_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _TIM16_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM17_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _TIM17_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C_PB6_FMW<'a> { w: &'a mut W, } impl<'a> _I2C_PB6_FMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C_PB7_FMW<'a> { w: &'a mut W, } impl<'a> _I2C_PB7_FMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C_PB8_FMW<'a> { w: &'a mut W, } impl<'a> _I2C_PB8_FMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C_PB9_FMW<'a> { w: &'a mut W, } impl<'a> _I2C_PB9_FMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C1_FM_PLUSW<'a> { w: &'a mut W, } impl<'a> _I2C1_FM_PLUSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C2_FM_PLUSW<'a> { w: &'a mut W, } impl<'a> _I2C2_FM_PLUSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SPI2_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _SPI2_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART2_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _USART2_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 25; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _USART3_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _USART3_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C1_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _I2C1_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM1_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _TIM1_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM2_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _TIM2_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 29; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIM3_DMA_RMPW<'a> { w: &'a mut W, } impl<'a> _TIM3_DMA_RMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:1 - Memory mapping selection bits"] #[inline] pub fn mem_mode(&self) -> MEM_MODER { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MEM_MODER { bits } } #[doc = "Bit 8 - ADC DMA remapping bit"] #[inline] pub fn adc_dma_rmp(&self) -> ADC_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADC_DMA_RMPR { bits } } #[doc = "Bit 9 - USART1_TX DMA remapping bit"] #[inline] pub fn usart1_tx_dma_rmp(&self) -> USART1_TX_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART1_TX_DMA_RMPR { bits } } #[doc = "Bit 10 - USART1_RX DMA request remapping bit"] #[inline] pub fn usart1_rx_dma_rmp(&self) -> USART1_RX_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART1_RX_DMA_RMPR { bits } } #[doc = "Bit 11 - TIM16 DMA request remapping bit"] #[inline] pub fn tim16_dma_rmp(&self) -> TIM16_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM16_DMA_RMPR { bits } } #[doc = "Bit 12 - TIM17 DMA request remapping bit"] #[inline] pub fn tim17_dma_rmp(&self) -> TIM17_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM17_DMA_RMPR { bits } } #[doc = "Bit 16 - Fast Mode Plus (FM plus) driving capability activation bits."] #[inline] pub fn i2c_pb6_fm(&self) -> I2C_PB6_FMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C_PB6_FMR { bits } } #[doc = "Bit 17 - Fast Mode Plus (FM+) driving capability activation bits."] #[inline] pub fn i2c_pb7_fm(&self) -> I2C_PB7_FMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C_PB7_FMR { bits } } #[doc = "Bit 18 - Fast Mode Plus (FM+) driving capability activation bits."] #[inline] pub fn i2c_pb8_fm(&self) -> I2C_PB8_FMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C_PB8_FMR { bits } } #[doc = "Bit 19 - Fast Mode Plus (FM+) driving capability activation bits."] #[inline] pub fn i2c_pb9_fm(&self) -> I2C_PB9_FMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C_PB9_FMR { bits } } #[doc = "Bit 20 - FM+ driving capability activation for I2C1"] #[inline] pub fn i2c1_fm_plus(&self) -> I2C1_FM_PLUSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C1_FM_PLUSR { bits } } #[doc = "Bit 21 - FM+ driving capability activation for I2C2"] #[inline] pub fn i2c2_fm_plus(&self) -> I2C2_FM_PLUSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C2_FM_PLUSR { bits } } #[doc = "Bit 24 - SPI2 DMA request remapping bit"] #[inline] pub fn spi2_dma_rmp(&self) -> SPI2_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SPI2_DMA_RMPR { bits } } #[doc = "Bit 25 - USART2 DMA request remapping bit"] #[inline] pub fn usart2_dma_rmp(&self) -> USART2_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 25; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART2_DMA_RMPR { bits } } #[doc = "Bit 26 - USART3 DMA request remapping bit"] #[inline] pub fn usart3_dma_rmp(&self) -> USART3_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; USART3_DMA_RMPR { bits } } #[doc = "Bit 27 - I2C1 DMA request remapping bit"] #[inline] pub fn i2c1_dma_rmp(&self) -> I2C1_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 27; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C1_DMA_RMPR { bits } } #[doc = "Bit 28 - TIM1 DMA request remapping bit"] #[inline] pub fn tim1_dma_rmp(&self) -> TIM1_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM1_DMA_RMPR { bits } } #[doc = "Bit 29 - TIM2 DMA request remapping bit"] #[inline] pub fn tim2_dma_rmp(&self) -> TIM2_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 29; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM2_DMA_RMPR { bits } } #[doc = "Bit 30 - TIM3 DMA request remapping bit"] #[inline] pub fn tim3_dma_rmp(&self) -> TIM3_DMA_RMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIM3_DMA_RMPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:1 - Memory mapping selection bits"] #[inline] pub fn mem_mode(&mut self) -> _MEM_MODEW { _MEM_MODEW { w: self } } #[doc = "Bit 8 - ADC DMA remapping bit"] #[inline] pub fn adc_dma_rmp(&mut self) -> _ADC_DMA_RMPW { _ADC_DMA_RMPW { w: self } } #[doc = "Bit 9 - USART1_TX DMA remapping bit"] #[inline] pub fn usart1_tx_dma_rmp(&mut self) -> _USART1_TX_DMA_RMPW { _USART1_TX_DMA_RMPW { w: self } } #[doc = "Bit 10 - USART1_RX DMA request remapping bit"] #[inline] pub fn usart1_rx_dma_rmp(&mut self) -> _USART1_RX_DMA_RMPW { _USART1_RX_DMA_RMPW { w: self } } #[doc = "Bit 11 - TIM16 DMA request remapping bit"] #[inline] pub fn tim16_dma_rmp(&mut self) -> _TIM16_DMA_RMPW { _TIM16_DMA_RMPW { w: self } } #[doc = "Bit 12 - TIM17 DMA request remapping bit"] #[inline] pub fn tim17_dma_rmp(&mut self) -> _TIM17_DMA_RMPW { _TIM17_DMA_RMPW { w: self } } #[doc = "Bit 16 - Fast Mode Plus (FM plus) driving capability activation bits."] #[inline] pub fn i2c_pb6_fm(&mut self) -> _I2C_PB6_FMW { _I2C_PB6_FMW { w: self } } #[doc = "Bit 17 - Fast Mode Plus (FM+) driving capability activation bits."] #[inline] pub fn i2c_pb7_fm(&mut self) -> _I2C_PB7_FMW { _I2C_PB7_FMW { w: self } } #[doc = "Bit 18 - Fast Mode Plus (FM+) driving capability activation bits."] #[inline] pub fn i2c_pb8_fm(&mut self) -> _I2C_PB8_FMW { _I2C_PB8_FMW { w: self } } #[doc = "Bit 19 - Fast Mode Plus (FM+) driving capability activation bits."] #[inline] pub fn i2c_pb9_fm(&mut self) -> _I2C_PB9_FMW { _I2C_PB9_FMW { w: self } } #[doc = "Bit 20 - FM+ driving capability activation for I2C1"] #[inline] pub fn i2c1_fm_plus(&mut self) -> _I2C1_FM_PLUSW { _I2C1_FM_PLUSW { w: self } } #[doc = "Bit 21 - FM+ driving capability activation for I2C2"] #[inline] pub fn i2c2_fm_plus(&mut self) -> _I2C2_FM_PLUSW { _I2C2_FM_PLUSW { w: self } } #[doc = "Bit 24 - SPI2 DMA request remapping bit"] #[inline] pub fn spi2_dma_rmp(&mut self) -> _SPI2_DMA_RMPW { _SPI2_DMA_RMPW { w: self } } #[doc = "Bit 25 - USART2 DMA request remapping bit"] #[inline] pub fn usart2_dma_rmp(&mut self) -> _USART2_DMA_RMPW { _USART2_DMA_RMPW { w: self } } #[doc = "Bit 26 - USART3 DMA request remapping bit"] #[inline] pub fn usart3_dma_rmp(&mut self) -> _USART3_DMA_RMPW { _USART3_DMA_RMPW { w: self } } #[doc = "Bit 27 - I2C1 DMA request remapping bit"] #[inline] pub fn i2c1_dma_rmp(&mut self) -> _I2C1_DMA_RMPW { _I2C1_DMA_RMPW { w: self } } #[doc = "Bit 28 - TIM1 DMA request remapping bit"] #[inline] pub fn tim1_dma_rmp(&mut self) -> _TIM1_DMA_RMPW { _TIM1_DMA_RMPW { w: self } } #[doc = "Bit 29 - TIM2 DMA request remapping bit"] #[inline] pub fn tim2_dma_rmp(&mut self) -> _TIM2_DMA_RMPW { _TIM2_DMA_RMPW { w: self } } #[doc = "Bit 30 - TIM3 DMA request remapping bit"] #[inline] pub fn tim3_dma_rmp(&mut self) -> _TIM3_DMA_RMPW { _TIM3_DMA_RMPW { w: self } } } } #[doc = "external interrupt configuration register 1"] pub struct EXTICR1 { register: ::vcell::VolatileCell, } #[doc = "external interrupt configuration register 1"] pub mod exticr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EXTICR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EXTI3R { bits: u8, } impl EXTI3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI2R { bits: u8, } impl EXTI2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI1R { bits: u8, } impl EXTI1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI0R { bits: u8, } impl EXTI0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _EXTI3W<'a> { w: &'a mut W, } impl<'a> _EXTI3W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI2W<'a> { w: &'a mut W, } impl<'a> _EXTI2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI1W<'a> { w: &'a mut W, } impl<'a> _EXTI1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI0W<'a> { w: &'a mut W, } impl<'a> _EXTI0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - EXTI 3 configuration bits"] #[inline] pub fn exti3(&self) -> EXTI3R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI3R { bits } } #[doc = "Bits 8:11 - EXTI 2 configuration bits"] #[inline] pub fn exti2(&self) -> EXTI2R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI2R { bits } } #[doc = "Bits 4:7 - EXTI 1 configuration bits"] #[inline] pub fn exti1(&self) -> EXTI1R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI1R { bits } } #[doc = "Bits 0:3 - EXTI 0 configuration bits"] #[inline] pub fn exti0(&self) -> EXTI0R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - EXTI 3 configuration bits"] #[inline] pub fn exti3(&mut self) -> _EXTI3W { _EXTI3W { w: self } } #[doc = "Bits 8:11 - EXTI 2 configuration bits"] #[inline] pub fn exti2(&mut self) -> _EXTI2W { _EXTI2W { w: self } } #[doc = "Bits 4:7 - EXTI 1 configuration bits"] #[inline] pub fn exti1(&mut self) -> _EXTI1W { _EXTI1W { w: self } } #[doc = "Bits 0:3 - EXTI 0 configuration bits"] #[inline] pub fn exti0(&mut self) -> _EXTI0W { _EXTI0W { w: self } } } } #[doc = "external interrupt configuration register 2"] pub struct EXTICR2 { register: ::vcell::VolatileCell, } #[doc = "external interrupt configuration register 2"] pub mod exticr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EXTICR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EXTI7R { bits: u8, } impl EXTI7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI6R { bits: u8, } impl EXTI6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI5R { bits: u8, } impl EXTI5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI4R { bits: u8, } impl EXTI4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _EXTI7W<'a> { w: &'a mut W, } impl<'a> _EXTI7W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI6W<'a> { w: &'a mut W, } impl<'a> _EXTI6W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI5W<'a> { w: &'a mut W, } impl<'a> _EXTI5W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI4W<'a> { w: &'a mut W, } impl<'a> _EXTI4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - EXTI 7 configuration bits"] #[inline] pub fn exti7(&self) -> EXTI7R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI7R { bits } } #[doc = "Bits 8:11 - EXTI 6 configuration bits"] #[inline] pub fn exti6(&self) -> EXTI6R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI6R { bits } } #[doc = "Bits 4:7 - EXTI 5 configuration bits"] #[inline] pub fn exti5(&self) -> EXTI5R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI5R { bits } } #[doc = "Bits 0:3 - EXTI 4 configuration bits"] #[inline] pub fn exti4(&self) -> EXTI4R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI4R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - EXTI 7 configuration bits"] #[inline] pub fn exti7(&mut self) -> _EXTI7W { _EXTI7W { w: self } } #[doc = "Bits 8:11 - EXTI 6 configuration bits"] #[inline] pub fn exti6(&mut self) -> _EXTI6W { _EXTI6W { w: self } } #[doc = "Bits 4:7 - EXTI 5 configuration bits"] #[inline] pub fn exti5(&mut self) -> _EXTI5W { _EXTI5W { w: self } } #[doc = "Bits 0:3 - EXTI 4 configuration bits"] #[inline] pub fn exti4(&mut self) -> _EXTI4W { _EXTI4W { w: self } } } } #[doc = "external interrupt configuration register 3"] pub struct EXTICR3 { register: ::vcell::VolatileCell, } #[doc = "external interrupt configuration register 3"] pub mod exticr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EXTICR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EXTI11R { bits: u8, } impl EXTI11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI10R { bits: u8, } impl EXTI10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI9R { bits: u8, } impl EXTI9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI8R { bits: u8, } impl EXTI8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _EXTI11W<'a> { w: &'a mut W, } impl<'a> _EXTI11W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI10W<'a> { w: &'a mut W, } impl<'a> _EXTI10W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI9W<'a> { w: &'a mut W, } impl<'a> _EXTI9W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI8W<'a> { w: &'a mut W, } impl<'a> _EXTI8W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - EXTI 11 configuration bits"] #[inline] pub fn exti11(&self) -> EXTI11R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI11R { bits } } #[doc = "Bits 8:11 - EXTI 10 configuration bits"] #[inline] pub fn exti10(&self) -> EXTI10R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI10R { bits } } #[doc = "Bits 4:7 - EXTI 9 configuration bits"] #[inline] pub fn exti9(&self) -> EXTI9R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI9R { bits } } #[doc = "Bits 0:3 - EXTI 8 configuration bits"] #[inline] pub fn exti8(&self) -> EXTI8R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI8R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - EXTI 11 configuration bits"] #[inline] pub fn exti11(&mut self) -> _EXTI11W { _EXTI11W { w: self } } #[doc = "Bits 8:11 - EXTI 10 configuration bits"] #[inline] pub fn exti10(&mut self) -> _EXTI10W { _EXTI10W { w: self } } #[doc = "Bits 4:7 - EXTI 9 configuration bits"] #[inline] pub fn exti9(&mut self) -> _EXTI9W { _EXTI9W { w: self } } #[doc = "Bits 0:3 - EXTI 8 configuration bits"] #[inline] pub fn exti8(&mut self) -> _EXTI8W { _EXTI8W { w: self } } } } #[doc = "external interrupt configuration register 4"] pub struct EXTICR4 { register: ::vcell::VolatileCell, } #[doc = "external interrupt configuration register 4"] pub mod exticr4 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EXTICR4 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EXTI15R { bits: u8, } impl EXTI15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI14R { bits: u8, } impl EXTI14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI13R { bits: u8, } impl EXTI13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTI12R { bits: u8, } impl EXTI12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _EXTI15W<'a> { w: &'a mut W, } impl<'a> _EXTI15W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI14W<'a> { w: &'a mut W, } impl<'a> _EXTI14W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI13W<'a> { w: &'a mut W, } impl<'a> _EXTI13W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTI12W<'a> { w: &'a mut W, } impl<'a> _EXTI12W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - EXTI 15 configuration bits"] #[inline] pub fn exti15(&self) -> EXTI15R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI15R { bits } } #[doc = "Bits 8:11 - EXTI 14 configuration bits"] #[inline] pub fn exti14(&self) -> EXTI14R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI14R { bits } } #[doc = "Bits 4:7 - EXTI 13 configuration bits"] #[inline] pub fn exti13(&self) -> EXTI13R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI13R { bits } } #[doc = "Bits 0:3 - EXTI 12 configuration bits"] #[inline] pub fn exti12(&self) -> EXTI12R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTI12R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - EXTI 15 configuration bits"] #[inline] pub fn exti15(&mut self) -> _EXTI15W { _EXTI15W { w: self } } #[doc = "Bits 8:11 - EXTI 14 configuration bits"] #[inline] pub fn exti14(&mut self) -> _EXTI14W { _EXTI14W { w: self } } #[doc = "Bits 4:7 - EXTI 13 configuration bits"] #[inline] pub fn exti13(&mut self) -> _EXTI13W { _EXTI13W { w: self } } #[doc = "Bits 0:3 - EXTI 12 configuration bits"] #[inline] pub fn exti12(&mut self) -> _EXTI12W { _EXTI12W { w: self } } } } #[doc = "configuration register 2"] pub struct CFGR2 { register: ::vcell::VolatileCell, } #[doc = "configuration register 2"] pub mod cfgr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SRAM_PEFR { bits: bool, } impl SRAM_PEFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PVD_LOCKR { bits: bool, } impl PVD_LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SRAM_PARITY_LOCKR { bits: bool, } impl SRAM_PARITY_LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LOCUP_LOCKR { bits: bool, } impl LOCUP_LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _SRAM_PEFW<'a> { w: &'a mut W, } impl<'a> _SRAM_PEFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PVD_LOCKW<'a> { w: &'a mut W, } impl<'a> _PVD_LOCKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SRAM_PARITY_LOCKW<'a> { w: &'a mut W, } impl<'a> _SRAM_PARITY_LOCKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LOCUP_LOCKW<'a> { w: &'a mut W, } impl<'a> _LOCUP_LOCKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 8 - SRAM parity flag"] #[inline] pub fn sram_pef(&self) -> SRAM_PEFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SRAM_PEFR { bits } } #[doc = "Bit 2 - PVD lock enable bit"] #[inline] pub fn pvd_lock(&self) -> PVD_LOCKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PVD_LOCKR { bits } } #[doc = "Bit 1 - SRAM parity lock bit"] #[inline] pub fn sram_parity_lock(&self) -> SRAM_PARITY_LOCKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SRAM_PARITY_LOCKR { bits } } #[doc = "Bit 0 - Cortex-M0 LOCKUP bit enable bit"] #[inline] pub fn locup_lock(&self) -> LOCUP_LOCKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LOCUP_LOCKR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 8 - SRAM parity flag"] #[inline] pub fn sram_pef(&mut self) -> _SRAM_PEFW { _SRAM_PEFW { w: self } } #[doc = "Bit 2 - PVD lock enable bit"] #[inline] pub fn pvd_lock(&mut self) -> _PVD_LOCKW { _PVD_LOCKW { w: self } } #[doc = "Bit 1 - SRAM parity lock bit"] #[inline] pub fn sram_parity_lock(&mut self) -> _SRAM_PARITY_LOCKW { _SRAM_PARITY_LOCKW { w: self } } #[doc = "Bit 0 - Cortex-M0 LOCKUP bit enable bit"] #[inline] pub fn locup_lock(&mut self) -> _LOCUP_LOCKW { _LOCUP_LOCKW { w: self } } } } } #[doc = "Analog-to-digital converter"] pub struct ADC { _marker: PhantomData<*const ()>, } unsafe impl Send for ADC {} impl ADC { #[doc = r" Returns a pointer to the register block"] pub fn ptr() -> *const adc::RegisterBlock { 0x4001_2400 as *const _ } } impl Deref for ADC { type Target = adc::RegisterBlock; fn deref(&self) -> &adc::RegisterBlock { unsafe { &*ADC::ptr() } } } #[doc = "Analog-to-digital converter"] pub mod adc { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - interrupt and status register"] pub isr: ISR, #[doc = "0x04 - interrupt enable register"] pub ier: IER, #[doc = "0x08 - control register"] pub cr: CR, #[doc = "0x0c - configuration register 1"] pub cfgr1: CFGR1, #[doc = "0x10 - configuration register 2"] pub cfgr2: CFGR2, #[doc = "0x14 - sampling time register"] pub smpr: SMPR, _reserved0: [u8; 8usize], #[doc = "0x20 - watchdog threshold register"] pub tr: TR, _reserved1: [u8; 4usize], #[doc = "0x28 - channel selection register"] pub chselr: CHSELR, _reserved2: [u8; 20usize], #[doc = "0x40 - data register"] pub dr: DR, _reserved3: [u8; 708usize], #[doc = "0x308 - common configuration register"] pub ccr: CCR, } #[doc = "interrupt and status register"] pub struct ISR { register: ::vcell::VolatileCell, } #[doc = "interrupt and status register"] pub mod isr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ISR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AWDR { bits: bool, } impl AWDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVRR { bits: bool, } impl OVRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOSR { bits: bool, } impl EOSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOCR { bits: bool, } impl EOCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOSMPR { bits: bool, } impl EOSMPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADRDYR { bits: bool, } impl ADRDYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _AWDW<'a> { w: &'a mut W, } impl<'a> _AWDW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OVRW<'a> { w: &'a mut W, } impl<'a> _OVRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOSW<'a> { w: &'a mut W, } impl<'a> _EOSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOCW<'a> { w: &'a mut W, } impl<'a> _EOCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOSMPW<'a> { w: &'a mut W, } impl<'a> _EOSMPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADRDYW<'a> { w: &'a mut W, } impl<'a> _ADRDYW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - Analog watchdog flag"] #[inline] pub fn awd(&self) -> AWDR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AWDR { bits } } #[doc = "Bit 4 - ADC overrun"] #[inline] pub fn ovr(&self) -> OVRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVRR { bits } } #[doc = "Bit 3 - End of sequence flag"] #[inline] pub fn eos(&self) -> EOSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOSR { bits } } #[doc = "Bit 2 - End of conversion flag"] #[inline] pub fn eoc(&self) -> EOCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOCR { bits } } #[doc = "Bit 1 - End of sampling flag"] #[inline] pub fn eosmp(&self) -> EOSMPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOSMPR { bits } } #[doc = "Bit 0 - ADC ready"] #[inline] pub fn adrdy(&self) -> ADRDYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADRDYR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Analog watchdog flag"] #[inline] pub fn awd(&mut self) -> _AWDW { _AWDW { w: self } } #[doc = "Bit 4 - ADC overrun"] #[inline] pub fn ovr(&mut self) -> _OVRW { _OVRW { w: self } } #[doc = "Bit 3 - End of sequence flag"] #[inline] pub fn eos(&mut self) -> _EOSW { _EOSW { w: self } } #[doc = "Bit 2 - End of conversion flag"] #[inline] pub fn eoc(&mut self) -> _EOCW { _EOCW { w: self } } #[doc = "Bit 1 - End of sampling flag"] #[inline] pub fn eosmp(&mut self) -> _EOSMPW { _EOSMPW { w: self } } #[doc = "Bit 0 - ADC ready"] #[inline] pub fn adrdy(&mut self) -> _ADRDYW { _ADRDYW { w: self } } } } #[doc = "interrupt enable register"] pub struct IER { register: ::vcell::VolatileCell, } #[doc = "interrupt enable register"] pub mod ier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::IER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AWDIER { bits: bool, } impl AWDIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVRIER { bits: bool, } impl OVRIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOSIER { bits: bool, } impl EOSIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOCIER { bits: bool, } impl EOCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOSMPIER { bits: bool, } impl EOSMPIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADRDYIER { bits: bool, } impl ADRDYIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _AWDIEW<'a> { w: &'a mut W, } impl<'a> _AWDIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OVRIEW<'a> { w: &'a mut W, } impl<'a> _OVRIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOSIEW<'a> { w: &'a mut W, } impl<'a> _EOSIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOCIEW<'a> { w: &'a mut W, } impl<'a> _EOCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOSMPIEW<'a> { w: &'a mut W, } impl<'a> _EOSMPIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADRDYIEW<'a> { w: &'a mut W, } impl<'a> _ADRDYIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - Analog watchdog interrupt enable"] #[inline] pub fn awdie(&self) -> AWDIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AWDIER { bits } } #[doc = "Bit 4 - Overrun interrupt enable"] #[inline] pub fn ovrie(&self) -> OVRIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVRIER { bits } } #[doc = "Bit 3 - End of conversion sequence interrupt enable"] #[inline] pub fn eosie(&self) -> EOSIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOSIER { bits } } #[doc = "Bit 2 - End of conversion interrupt enable"] #[inline] pub fn eocie(&self) -> EOCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOCIER { bits } } #[doc = "Bit 1 - End of sampling flag interrupt enable"] #[inline] pub fn eosmpie(&self) -> EOSMPIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOSMPIER { bits } } #[doc = "Bit 0 - ADC ready interrupt enable"] #[inline] pub fn adrdyie(&self) -> ADRDYIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADRDYIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Analog watchdog interrupt enable"] #[inline] pub fn awdie(&mut self) -> _AWDIEW { _AWDIEW { w: self } } #[doc = "Bit 4 - Overrun interrupt enable"] #[inline] pub fn ovrie(&mut self) -> _OVRIEW { _OVRIEW { w: self } } #[doc = "Bit 3 - End of conversion sequence interrupt enable"] #[inline] pub fn eosie(&mut self) -> _EOSIEW { _EOSIEW { w: self } } #[doc = "Bit 2 - End of conversion interrupt enable"] #[inline] pub fn eocie(&mut self) -> _EOCIEW { _EOCIEW { w: self } } #[doc = "Bit 1 - End of sampling flag interrupt enable"] #[inline] pub fn eosmpie(&mut self) -> _EOSMPIEW { _EOSMPIEW { w: self } } #[doc = "Bit 0 - ADC ready interrupt enable"] #[inline] pub fn adrdyie(&mut self) -> _ADRDYIEW { _ADRDYIEW { w: self } } } } #[doc = "control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ADCALR { bits: bool, } impl ADCALR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADSTPR { bits: bool, } impl ADSTPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADSTARTR { bits: bool, } impl ADSTARTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADDISR { bits: bool, } impl ADDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADENR { bits: bool, } impl ADENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ADCALW<'a> { w: &'a mut W, } impl<'a> _ADCALW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADSTPW<'a> { w: &'a mut W, } impl<'a> _ADSTPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADSTARTW<'a> { w: &'a mut W, } impl<'a> _ADSTARTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADDISW<'a> { w: &'a mut W, } impl<'a> _ADDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADENW<'a> { w: &'a mut W, } impl<'a> _ADENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 31 - ADC calibration"] #[inline] pub fn adcal(&self) -> ADCALR { let bits = { const MASK: bool = true; const OFFSET: u8 = 31; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADCALR { bits } } #[doc = "Bit 4 - ADC stop conversion command"] #[inline] pub fn adstp(&self) -> ADSTPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADSTPR { bits } } #[doc = "Bit 2 - ADC start conversion command"] #[inline] pub fn adstart(&self) -> ADSTARTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADSTARTR { bits } } #[doc = "Bit 1 - ADC disable command"] #[inline] pub fn addis(&self) -> ADDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADDISR { bits } } #[doc = "Bit 0 - ADC enable command"] #[inline] pub fn aden(&self) -> ADENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 31 - ADC calibration"] #[inline] pub fn adcal(&mut self) -> _ADCALW { _ADCALW { w: self } } #[doc = "Bit 4 - ADC stop conversion command"] #[inline] pub fn adstp(&mut self) -> _ADSTPW { _ADSTPW { w: self } } #[doc = "Bit 2 - ADC start conversion command"] #[inline] pub fn adstart(&mut self) -> _ADSTARTW { _ADSTARTW { w: self } } #[doc = "Bit 1 - ADC disable command"] #[inline] pub fn addis(&mut self) -> _ADDISW { _ADDISW { w: self } } #[doc = "Bit 0 - ADC enable command"] #[inline] pub fn aden(&mut self) -> _ADENW { _ADENW { w: self } } } } #[doc = "configuration register 1"] pub struct CFGR1 { register: ::vcell::VolatileCell, } #[doc = "configuration register 1"] pub mod cfgr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct AWDCHR { bits: u8, } impl AWDCHR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct AWDENR { bits: bool, } impl AWDENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AWDSGLR { bits: bool, } impl AWDSGLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DISCENR { bits: bool, } impl DISCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AUTOFFR { bits: bool, } impl AUTOFFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AUTDLYR { bits: bool, } impl AUTDLYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CONTR { bits: bool, } impl CONTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVRMODR { bits: bool, } impl OVRMODR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EXTENR { bits: u8, } impl EXTENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct EXTSELR { bits: u8, } impl EXTSELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ALIGNR { bits: bool, } impl ALIGNR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RESR { bits: u8, } impl RESR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SCANDIRR { bits: bool, } impl SCANDIRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DMACFGR { bits: bool, } impl DMACFGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DMAENR { bits: bool, } impl DMAENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _AWDCHW<'a> { w: &'a mut W, } impl<'a> _AWDCHW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AWDENW<'a> { w: &'a mut W, } impl<'a> _AWDENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AWDSGLW<'a> { w: &'a mut W, } impl<'a> _AWDSGLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DISCENW<'a> { w: &'a mut W, } impl<'a> _DISCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AUTOFFW<'a> { w: &'a mut W, } impl<'a> _AUTOFFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AUTDLYW<'a> { w: &'a mut W, } impl<'a> _AUTDLYW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CONTW<'a> { w: &'a mut W, } impl<'a> _CONTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OVRMODW<'a> { w: &'a mut W, } impl<'a> _OVRMODW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTENW<'a> { w: &'a mut W, } impl<'a> _EXTENW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EXTSELW<'a> { w: &'a mut W, } impl<'a> _EXTSELW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ALIGNW<'a> { w: &'a mut W, } impl<'a> _ALIGNW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RESW<'a> { w: &'a mut W, } impl<'a> _RESW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SCANDIRW<'a> { w: &'a mut W, } impl<'a> _SCANDIRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DMACFGW<'a> { w: &'a mut W, } impl<'a> _DMACFGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DMAENW<'a> { w: &'a mut W, } impl<'a> _DMAENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 26:30 - Analog watchdog channel selection"] #[inline] pub fn awdch(&self) -> AWDCHR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) as u8 }; AWDCHR { bits } } #[doc = "Bit 23 - Analog watchdog enable"] #[inline] pub fn awden(&self) -> AWDENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AWDENR { bits } } #[doc = "Bit 22 - Enable the watchdog on a single channel or on all channels"] #[inline] pub fn awdsgl(&self) -> AWDSGLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AWDSGLR { bits } } #[doc = "Bit 16 - Discontinuous mode"] #[inline] pub fn discen(&self) -> DISCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DISCENR { bits } } #[doc = "Bit 15 - Auto-off mode"] #[inline] pub fn autoff(&self) -> AUTOFFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AUTOFFR { bits } } #[doc = "Bit 14 - Auto-delayed conversion mode"] #[inline] pub fn autdly(&self) -> AUTDLYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AUTDLYR { bits } } #[doc = "Bit 13 - Single / continuous conversion mode"] #[inline] pub fn cont(&self) -> CONTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CONTR { bits } } #[doc = "Bit 12 - Overrun management mode"] #[inline] pub fn ovrmod(&self) -> OVRMODR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVRMODR { bits } } #[doc = "Bits 10:11 - External trigger enable and polarity selection"] #[inline] pub fn exten(&self) -> EXTENR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTENR { bits } } #[doc = "Bits 6:8 - External trigger selection"] #[inline] pub fn extsel(&self) -> EXTSELR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) as u8 }; EXTSELR { bits } } #[doc = "Bit 5 - Data alignment"] #[inline] pub fn align(&self) -> ALIGNR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALIGNR { bits } } #[doc = "Bits 3:4 - Data resolution"] #[inline] pub fn res(&self) -> RESR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) as u8 }; RESR { bits } } #[doc = "Bit 2 - Scan sequence direction"] #[inline] pub fn scandir(&self) -> SCANDIRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SCANDIRR { bits } } #[doc = "Bit 1 - Direct memery access configuration"] #[inline] pub fn dmacfg(&self) -> DMACFGR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DMACFGR { bits } } #[doc = "Bit 0 - Direct memory access enable"] #[inline] pub fn dmaen(&self) -> DMAENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DMAENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 26:30 - Analog watchdog channel selection"] #[inline] pub fn awdch(&mut self) -> _AWDCHW { _AWDCHW { w: self } } #[doc = "Bit 23 - Analog watchdog enable"] #[inline] pub fn awden(&mut self) -> _AWDENW { _AWDENW { w: self } } #[doc = "Bit 22 - Enable the watchdog on a single channel or on all channels"] #[inline] pub fn awdsgl(&mut self) -> _AWDSGLW { _AWDSGLW { w: self } } #[doc = "Bit 16 - Discontinuous mode"] #[inline] pub fn discen(&mut self) -> _DISCENW { _DISCENW { w: self } } #[doc = "Bit 15 - Auto-off mode"] #[inline] pub fn autoff(&mut self) -> _AUTOFFW { _AUTOFFW { w: self } } #[doc = "Bit 14 - Auto-delayed conversion mode"] #[inline] pub fn autdly(&mut self) -> _AUTDLYW { _AUTDLYW { w: self } } #[doc = "Bit 13 - Single / continuous conversion mode"] #[inline] pub fn cont(&mut self) -> _CONTW { _CONTW { w: self } } #[doc = "Bit 12 - Overrun management mode"] #[inline] pub fn ovrmod(&mut self) -> _OVRMODW { _OVRMODW { w: self } } #[doc = "Bits 10:11 - External trigger enable and polarity selection"] #[inline] pub fn exten(&mut self) -> _EXTENW { _EXTENW { w: self } } #[doc = "Bits 6:8 - External trigger selection"] #[inline] pub fn extsel(&mut self) -> _EXTSELW { _EXTSELW { w: self } } #[doc = "Bit 5 - Data alignment"] #[inline] pub fn align(&mut self) -> _ALIGNW { _ALIGNW { w: self } } #[doc = "Bits 3:4 - Data resolution"] #[inline] pub fn res(&mut self) -> _RESW { _RESW { w: self } } #[doc = "Bit 2 - Scan sequence direction"] #[inline] pub fn scandir(&mut self) -> _SCANDIRW { _SCANDIRW { w: self } } #[doc = "Bit 1 - Direct memery access configuration"] #[inline] pub fn dmacfg(&mut self) -> _DMACFGW { _DMACFGW { w: self } } #[doc = "Bit 0 - Direct memory access enable"] #[inline] pub fn dmaen(&mut self) -> _DMAENW { _DMAENW { w: self } } } } #[doc = "configuration register 2"] pub struct CFGR2 { register: ::vcell::VolatileCell, } #[doc = "configuration register 2"] pub mod cfgr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CFGR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct JITOFF_D4R { bits: bool, } impl JITOFF_D4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct JITOFF_D2R { bits: bool, } impl JITOFF_D2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _JITOFF_D4W<'a> { w: &'a mut W, } impl<'a> _JITOFF_D4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _JITOFF_D2W<'a> { w: &'a mut W, } impl<'a> _JITOFF_D2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 31 - JITOFF_D4"] #[inline] pub fn jitoff_d4(&self) -> JITOFF_D4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 31; ((self.bits >> OFFSET) & MASK as u32) != 0 }; JITOFF_D4R { bits } } #[doc = "Bit 30 - JITOFF_D2"] #[inline] pub fn jitoff_d2(&self) -> JITOFF_D2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) != 0 }; JITOFF_D2R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x8000 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 31 - JITOFF_D4"] #[inline] pub fn jitoff_d4(&mut self) -> _JITOFF_D4W { _JITOFF_D4W { w: self } } #[doc = "Bit 30 - JITOFF_D2"] #[inline] pub fn jitoff_d2(&mut self) -> _JITOFF_D2W { _JITOFF_D2W { w: self } } } } #[doc = "sampling time register"] pub struct SMPR { register: ::vcell::VolatileCell, } #[doc = "sampling time register"] pub mod smpr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SMPR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct SMPRR { bits: u8, } impl SMPRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _SMPRW<'a> { w: &'a mut W, } impl<'a> _SMPRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:2 - Sampling time selection"] #[inline] pub fn smpr(&self) -> SMPRR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SMPRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:2 - Sampling time selection"] #[inline] pub fn smpr(&mut self) -> _SMPRW { _SMPRW { w: self } } } } #[doc = "watchdog threshold register"] pub struct TR { register: ::vcell::VolatileCell, } #[doc = "watchdog threshold register"] pub mod tr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct HTR { bits: u16, } impl HTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct LTR { bits: u16, } impl LTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _HTW<'a> { w: &'a mut W, } impl<'a> _HTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LTW<'a> { w: &'a mut W, } impl<'a> _LTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:27 - Analog watchdog higher threshold"] #[inline] pub fn ht(&self) -> HTR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; HTR { bits } } #[doc = "Bits 0:11 - Analog watchdog lower threshold"] #[inline] pub fn lt(&self) -> LTR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; LTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x0fff } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:27 - Analog watchdog higher threshold"] #[inline] pub fn ht(&mut self) -> _HTW { _HTW { w: self } } #[doc = "Bits 0:11 - Analog watchdog lower threshold"] #[inline] pub fn lt(&mut self) -> _LTW { _LTW { w: self } } } } #[doc = "channel selection register"] pub struct CHSELR { register: ::vcell::VolatileCell, } #[doc = "channel selection register"] pub mod chselr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CHSELR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CHSEL18R { bits: bool, } impl CHSEL18R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL17R { bits: bool, } impl CHSEL17R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL16R { bits: bool, } impl CHSEL16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL15R { bits: bool, } impl CHSEL15R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL14R { bits: bool, } impl CHSEL14R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL13R { bits: bool, } impl CHSEL13R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL12R { bits: bool, } impl CHSEL12R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL11R { bits: bool, } impl CHSEL11R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL10R { bits: bool, } impl CHSEL10R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL9R { bits: bool, } impl CHSEL9R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL8R { bits: bool, } impl CHSEL8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL7R { bits: bool, } impl CHSEL7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL6R { bits: bool, } impl CHSEL6R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL5R { bits: bool, } impl CHSEL5R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL4R { bits: bool, } impl CHSEL4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL3R { bits: bool, } impl CHSEL3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL2R { bits: bool, } impl CHSEL2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL1R { bits: bool, } impl CHSEL1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CHSEL0R { bits: bool, } impl CHSEL0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CHSEL18W<'a> { w: &'a mut W, } impl<'a> _CHSEL18W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL17W<'a> { w: &'a mut W, } impl<'a> _CHSEL17W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL16W<'a> { w: &'a mut W, } impl<'a> _CHSEL16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL15W<'a> { w: &'a mut W, } impl<'a> _CHSEL15W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL14W<'a> { w: &'a mut W, } impl<'a> _CHSEL14W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL13W<'a> { w: &'a mut W, } impl<'a> _CHSEL13W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL12W<'a> { w: &'a mut W, } impl<'a> _CHSEL12W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL11W<'a> { w: &'a mut W, } impl<'a> _CHSEL11W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL10W<'a> { w: &'a mut W, } impl<'a> _CHSEL10W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL9W<'a> { w: &'a mut W, } impl<'a> _CHSEL9W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL8W<'a> { w: &'a mut W, } impl<'a> _CHSEL8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL7W<'a> { w: &'a mut W, } impl<'a> _CHSEL7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL6W<'a> { w: &'a mut W, } impl<'a> _CHSEL6W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL5W<'a> { w: &'a mut W, } impl<'a> _CHSEL5W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL4W<'a> { w: &'a mut W, } impl<'a> _CHSEL4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL3W<'a> { w: &'a mut W, } impl<'a> _CHSEL3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL2W<'a> { w: &'a mut W, } impl<'a> _CHSEL2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL1W<'a> { w: &'a mut W, } impl<'a> _CHSEL1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CHSEL0W<'a> { w: &'a mut W, } impl<'a> _CHSEL0W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 18 - Channel-x selection"] #[inline] pub fn chsel18(&self) -> CHSEL18R { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL18R { bits } } #[doc = "Bit 17 - Channel-x selection"] #[inline] pub fn chsel17(&self) -> CHSEL17R { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL17R { bits } } #[doc = "Bit 16 - Channel-x selection"] #[inline] pub fn chsel16(&self) -> CHSEL16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL16R { bits } } #[doc = "Bit 15 - Channel-x selection"] #[inline] pub fn chsel15(&self) -> CHSEL15R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL15R { bits } } #[doc = "Bit 14 - Channel-x selection"] #[inline] pub fn chsel14(&self) -> CHSEL14R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL14R { bits } } #[doc = "Bit 13 - Channel-x selection"] #[inline] pub fn chsel13(&self) -> CHSEL13R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL13R { bits } } #[doc = "Bit 12 - Channel-x selection"] #[inline] pub fn chsel12(&self) -> CHSEL12R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL12R { bits } } #[doc = "Bit 11 - Channel-x selection"] #[inline] pub fn chsel11(&self) -> CHSEL11R { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL11R { bits } } #[doc = "Bit 10 - Channel-x selection"] #[inline] pub fn chsel10(&self) -> CHSEL10R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL10R { bits } } #[doc = "Bit 9 - Channel-x selection"] #[inline] pub fn chsel9(&self) -> CHSEL9R { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL9R { bits } } #[doc = "Bit 8 - Channel-x selection"] #[inline] pub fn chsel8(&self) -> CHSEL8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL8R { bits } } #[doc = "Bit 7 - Channel-x selection"] #[inline] pub fn chsel7(&self) -> CHSEL7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL7R { bits } } #[doc = "Bit 6 - Channel-x selection"] #[inline] pub fn chsel6(&self) -> CHSEL6R { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL6R { bits } } #[doc = "Bit 5 - Channel-x selection"] #[inline] pub fn chsel5(&self) -> CHSEL5R { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL5R { bits } } #[doc = "Bit 4 - Channel-x selection"] #[inline] pub fn chsel4(&self) -> CHSEL4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL4R { bits } } #[doc = "Bit 3 - Channel-x selection"] #[inline] pub fn chsel3(&self) -> CHSEL3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL3R { bits } } #[doc = "Bit 2 - Channel-x selection"] #[inline] pub fn chsel2(&self) -> CHSEL2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL2R { bits } } #[doc = "Bit 1 - Channel-x selection"] #[inline] pub fn chsel1(&self) -> CHSEL1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL1R { bits } } #[doc = "Bit 0 - Channel-x selection"] #[inline] pub fn chsel0(&self) -> CHSEL0R { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CHSEL0R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 18 - Channel-x selection"] #[inline] pub fn chsel18(&mut self) -> _CHSEL18W { _CHSEL18W { w: self } } #[doc = "Bit 17 - Channel-x selection"] #[inline] pub fn chsel17(&mut self) -> _CHSEL17W { _CHSEL17W { w: self } } #[doc = "Bit 16 - Channel-x selection"] #[inline] pub fn chsel16(&mut self) -> _CHSEL16W { _CHSEL16W { w: self } } #[doc = "Bit 15 - Channel-x selection"] #[inline] pub fn chsel15(&mut self) -> _CHSEL15W { _CHSEL15W { w: self } } #[doc = "Bit 14 - Channel-x selection"] #[inline] pub fn chsel14(&mut self) -> _CHSEL14W { _CHSEL14W { w: self } } #[doc = "Bit 13 - Channel-x selection"] #[inline] pub fn chsel13(&mut self) -> _CHSEL13W { _CHSEL13W { w: self } } #[doc = "Bit 12 - Channel-x selection"] #[inline] pub fn chsel12(&mut self) -> _CHSEL12W { _CHSEL12W { w: self } } #[doc = "Bit 11 - Channel-x selection"] #[inline] pub fn chsel11(&mut self) -> _CHSEL11W { _CHSEL11W { w: self } } #[doc = "Bit 10 - Channel-x selection"] #[inline] pub fn chsel10(&mut self) -> _CHSEL10W { _CHSEL10W { w: self } } #[doc = "Bit 9 - Channel-x selection"] #[inline] pub fn chsel9(&mut self) -> _CHSEL9W { _CHSEL9W { w: self } } #[doc = "Bit 8 - Channel-x selection"] #[inline] pub fn chsel8(&mut self) -> _CHSEL8W { _CHSEL8W { w: self } } #[doc = "Bit 7 - Channel-x selection"] #[inline] pub fn chsel7(&mut self) -> _CHSEL7W { _CHSEL7W { w: self } } #[doc = "Bit 6 - Channel-x selection"] #[inline] pub fn chsel6(&mut self) -> _CHSEL6W { _CHSEL6W { w: self } } #[doc = "Bit 5 - Channel-x selection"] #[inline] pub fn chsel5(&mut self) -> _CHSEL5W { _CHSEL5W { w: self } } #[doc = "Bit 4 - Channel-x selection"] #[inline] pub fn chsel4(&mut self) -> _CHSEL4W { _CHSEL4W { w: self } } #[doc = "Bit 3 - Channel-x selection"] #[inline] pub fn chsel3(&mut self) -> _CHSEL3W { _CHSEL3W { w: self } } #[doc = "Bit 2 - Channel-x selection"] #[inline] pub fn chsel2(&mut self) -> _CHSEL2W { _CHSEL2W { w: self } } #[doc = "Bit 1 - Channel-x selection"] #[inline] pub fn chsel1(&mut self) -> _CHSEL1W { _CHSEL1W { w: self } } #[doc = "Bit 0 - Channel-x selection"] #[inline] pub fn chsel0(&mut self) -> _CHSEL0W { _CHSEL0W { w: self } } } } #[doc = "data register"] pub struct DR { register: ::vcell::VolatileCell, } #[doc = "data register"] pub mod dr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::DR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct DATAR { bits: u16, } impl DATAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Converted data"] #[inline] pub fn data(&self) -> DATAR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DATAR { bits } } } } #[doc = "common configuration register"] pub struct CCR { register: ::vcell::VolatileCell, } #[doc = "common configuration register"] pub mod ccr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct VBATENR { bits: bool, } impl VBATENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSENR { bits: bool, } impl TSENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct VREFENR { bits: bool, } impl VREFENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _VBATENW<'a> { w: &'a mut W, } impl<'a> _VBATENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSENW<'a> { w: &'a mut W, } impl<'a> _TSENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _VREFENW<'a> { w: &'a mut W, } impl<'a> _VREFENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 24 - VBAT enable"] #[inline] pub fn vbaten(&self) -> VBATENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) != 0 }; VBATENR { bits } } #[doc = "Bit 23 - Temperature sensor enable"] #[inline] pub fn tsen(&self) -> TSENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TSENR { bits } } #[doc = "Bit 22 - Temperature sensor and VREFINT enable"] #[inline] pub fn vrefen(&self) -> VREFENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; VREFENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 24 - VBAT enable"] #[inline] pub fn vbaten(&mut self) -> _VBATENW { _VBATENW { w: self } } #[doc = "Bit 23 - Temperature sensor enable"] #[inline] pub fn tsen(&mut self) -> _TSENW { _TSENW { w: self } } #[doc = "Bit 22 - Temperature sensor and VREFINT enable"] #[inline] pub fn vrefen(&mut self) -> _VREFENW { _VREFENW { w: self } } } } } #[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 { 0x4001_3800 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Control register 1"] pub cr1: CR1, #[doc = "0x04 - Control register 2"] pub cr2: CR2, #[doc = "0x08 - Control register 3"] pub cr3: CR3, #[doc = "0x0c - Baud rate register"] pub brr: BRR, #[doc = "0x10 - Guard time and prescaler register"] pub gtpr: GTPR, #[doc = "0x14 - Receiver timeout register"] pub rtor: RTOR, #[doc = "0x18 - Request register"] pub rqr: RQR, #[doc = "0x1c - Interrupt & status register"] pub isr: ISR, #[doc = "0x20 - Interrupt flag clear register"] pub icr: ICR, #[doc = "0x24 - Receive data register"] pub rdr: RDR, #[doc = "0x28 - Transmit data register"] pub tdr: TDR, } #[doc = "Control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "Control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct UER { bits: bool, } impl UER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UESMR { bits: bool, } impl UESMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RER { bits: bool, } impl RER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TER { bits: bool, } impl TER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDLEIER { bits: bool, } impl IDLEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXNEIER { bits: bool, } impl RXNEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCIER { bits: bool, } impl TCIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXEIER { bits: bool, } impl TXEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PEIER { bits: bool, } impl PEIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PSR { bits: bool, } impl PSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PCER { bits: bool, } impl PCER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WAKER { bits: bool, } impl WAKER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MR { bits: bool, } impl MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MMER { bits: bool, } impl MMER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CMIER { bits: bool, } impl CMIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVER8R { bits: bool, } impl OVER8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DEDTR { bits: u8, } impl DEDTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DEATR { bits: u8, } impl DEATR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct RTOIER { bits: bool, } impl RTOIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOBIER { bits: bool, } impl EOBIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct M1R { bits: bool, } impl M1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _UEW<'a> { w: &'a mut W, } impl<'a> _UEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UESMW<'a> { w: &'a mut W, } impl<'a> _UESMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _REW<'a> { w: &'a mut W, } impl<'a> _REW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TEW<'a> { w: &'a mut W, } impl<'a> _TEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IDLEIEW<'a> { w: &'a mut W, } impl<'a> _IDLEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXNEIEW<'a> { w: &'a mut W, } impl<'a> _RXNEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCIEW<'a> { w: &'a mut W, } impl<'a> _TCIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXEIEW<'a> { w: &'a mut W, } impl<'a> _TXEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PEIEW<'a> { w: &'a mut W, } impl<'a> _PEIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSW<'a> { w: &'a mut W, } impl<'a> _PSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PCEW<'a> { w: &'a mut W, } impl<'a> _PCEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WAKEW<'a> { w: &'a mut W, } impl<'a> _WAKEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MW<'a> { w: &'a mut W, } impl<'a> _MW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MMEW<'a> { w: &'a mut W, } impl<'a> _MMEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CMIEW<'a> { w: &'a mut W, } impl<'a> _CMIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OVER8W<'a> { w: &'a mut W, } impl<'a> _OVER8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DEDTW<'a> { w: &'a mut W, } impl<'a> _DEDTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DEATW<'a> { w: &'a mut W, } impl<'a> _DEATW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTOIEW<'a> { w: &'a mut W, } impl<'a> _RTOIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 26; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOBIEW<'a> { w: &'a mut W, } impl<'a> _EOBIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 27; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _M1W<'a> { w: &'a mut W, } impl<'a> _M1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - USART enable"] #[inline] pub fn ue(&self) -> UER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UER { bits } } #[doc = "Bit 1 - USART enable in Stop mode"] #[inline] pub fn uesm(&self) -> UESMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UESMR { bits } } #[doc = "Bit 2 - Receiver enable"] #[inline] pub fn re(&self) -> RER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RER { bits } } #[doc = "Bit 3 - Transmitter enable"] #[inline] pub fn te(&self) -> TER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TER { bits } } #[doc = "Bit 4 - IDLE interrupt enable"] #[inline] pub fn idleie(&self) -> IDLEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDLEIER { bits } } #[doc = "Bit 5 - RXNE interrupt enable"] #[inline] pub fn rxneie(&self) -> RXNEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXNEIER { bits } } #[doc = "Bit 6 - Transmission complete interrupt enable"] #[inline] pub fn tcie(&self) -> TCIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCIER { bits } } #[doc = "Bit 7 - interrupt enable"] #[inline] pub fn txeie(&self) -> TXEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXEIER { bits } } #[doc = "Bit 8 - PE interrupt enable"] #[inline] pub fn peie(&self) -> PEIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PEIER { bits } } #[doc = "Bit 9 - Parity selection"] #[inline] pub fn ps(&self) -> PSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PSR { bits } } #[doc = "Bit 10 - Parity control enable"] #[inline] pub fn pce(&self) -> PCER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PCER { bits } } #[doc = "Bit 11 - Receiver wakeup method"] #[inline] pub fn wake(&self) -> WAKER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WAKER { bits } } #[doc = "Bit 12 - Word length"] #[inline] pub fn m(&self) -> MR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MR { bits } } #[doc = "Bit 13 - Mute mode enable"] #[inline] pub fn mme(&self) -> MMER { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MMER { bits } } #[doc = "Bit 14 - Character match interrupt enable"] #[inline] pub fn cmie(&self) -> CMIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CMIER { bits } } #[doc = "Bit 15 - Oversampling mode"] #[inline] pub fn over8(&self) -> OVER8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVER8R { bits } } #[doc = "Bits 16:20 - Driver Enable deassertion time"] #[inline] pub fn dedt(&self) -> DEDTR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DEDTR { bits } } #[doc = "Bits 21:25 - Driver Enable assertion time"] #[inline] pub fn deat(&self) -> DEATR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DEATR { bits } } #[doc = "Bit 26 - Receiver timeout interrupt enable"] #[inline] pub fn rtoie(&self) -> RTOIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 26; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RTOIER { bits } } #[doc = "Bit 27 - End of Block interrupt enable"] #[inline] pub fn eobie(&self) -> EOBIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 27; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOBIER { bits } } #[doc = "Bit 28 - Word length"] #[inline] pub fn m1(&self) -> M1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) != 0 }; M1R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - USART enable"] #[inline] pub fn ue(&mut self) -> _UEW { _UEW { w: self } } #[doc = "Bit 1 - USART enable in Stop mode"] #[inline] pub fn uesm(&mut self) -> _UESMW { _UESMW { w: self } } #[doc = "Bit 2 - Receiver enable"] #[inline] pub fn re(&mut self) -> _REW { _REW { w: self } } #[doc = "Bit 3 - Transmitter enable"] #[inline] pub fn te(&mut self) -> _TEW { _TEW { w: self } } #[doc = "Bit 4 - IDLE interrupt enable"] #[inline] pub fn idleie(&mut self) -> _IDLEIEW { _IDLEIEW { w: self } } #[doc = "Bit 5 - RXNE interrupt enable"] #[inline] pub fn rxneie(&mut self) -> _RXNEIEW { _RXNEIEW { w: self } } #[doc = "Bit 6 - Transmission complete interrupt enable"] #[inline] pub fn tcie(&mut self) -> _TCIEW { _TCIEW { w: self } } #[doc = "Bit 7 - interrupt enable"] #[inline] pub fn txeie(&mut self) -> _TXEIEW { _TXEIEW { w: self } } #[doc = "Bit 8 - PE interrupt enable"] #[inline] pub fn peie(&mut self) -> _PEIEW { _PEIEW { w: self } } #[doc = "Bit 9 - Parity selection"] #[inline] pub fn ps(&mut self) -> _PSW { _PSW { w: self } } #[doc = "Bit 10 - Parity control enable"] #[inline] pub fn pce(&mut self) -> _PCEW { _PCEW { w: self } } #[doc = "Bit 11 - Receiver wakeup method"] #[inline] pub fn wake(&mut self) -> _WAKEW { _WAKEW { w: self } } #[doc = "Bit 12 - Word length"] #[inline] pub fn m(&mut self) -> _MW { _MW { w: self } } #[doc = "Bit 13 - Mute mode enable"] #[inline] pub fn mme(&mut self) -> _MMEW { _MMEW { w: self } } #[doc = "Bit 14 - Character match interrupt enable"] #[inline] pub fn cmie(&mut self) -> _CMIEW { _CMIEW { w: self } } #[doc = "Bit 15 - Oversampling mode"] #[inline] pub fn over8(&mut self) -> _OVER8W { _OVER8W { w: self } } #[doc = "Bits 16:20 - Driver Enable deassertion time"] #[inline] pub fn dedt(&mut self) -> _DEDTW { _DEDTW { w: self } } #[doc = "Bits 21:25 - Driver Enable assertion time"] #[inline] pub fn deat(&mut self) -> _DEATW { _DEATW { w: self } } #[doc = "Bit 26 - Receiver timeout interrupt enable"] #[inline] pub fn rtoie(&mut self) -> _RTOIEW { _RTOIEW { w: self } } #[doc = "Bit 27 - End of Block interrupt enable"] #[inline] pub fn eobie(&mut self) -> _EOBIEW { _EOBIEW { w: self } } #[doc = "Bit 28 - Word length"] #[inline] pub fn m1(&mut self) -> _M1W { _M1W { w: self } } } } #[doc = "Control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "Control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ADD4R { bits: u8, } impl ADD4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ADD0R { bits: u8, } impl ADD0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct RTOENR { bits: bool, } impl RTOENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ABRMODR { bits: u8, } impl ABRMODR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ABRENR { bits: bool, } impl ABRENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MSBFIRSTR { bits: bool, } impl MSBFIRSTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DATAINVR { bits: bool, } impl DATAINVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXINVR { bits: bool, } impl TXINVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXINVR { bits: bool, } impl RXINVR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SWAPR { bits: bool, } impl SWAPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LINENR { bits: bool, } impl LINENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STOPR { bits: u8, } impl STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CLKENR { bits: bool, } impl CLKENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CPOLR { bits: bool, } impl CPOLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CPHAR { bits: bool, } impl CPHAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LBCLR { bits: bool, } impl LBCLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LBDIER { bits: bool, } impl LBDIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LBDLR { bits: bool, } impl LBDLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ADDM7R { bits: bool, } impl ADDM7R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _ADD4W<'a> { w: &'a mut W, } impl<'a> _ADD4W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADD0W<'a> { w: &'a mut W, } impl<'a> _ADD0W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTOENW<'a> { w: &'a mut W, } impl<'a> _RTOENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ABRMODW<'a> { w: &'a mut W, } impl<'a> _ABRMODW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ABRENW<'a> { w: &'a mut W, } impl<'a> _ABRENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSBFIRSTW<'a> { w: &'a mut W, } impl<'a> _MSBFIRSTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DATAINVW<'a> { w: &'a mut W, } impl<'a> _DATAINVW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TXINVW<'a> { w: &'a mut W, } impl<'a> _TXINVW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXINVW<'a> { w: &'a mut W, } impl<'a> _RXINVW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SWAPW<'a> { w: &'a mut W, } impl<'a> _SWAPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LINENW<'a> { w: &'a mut W, } impl<'a> _LINENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STOPW<'a> { w: &'a mut W, } impl<'a> _STOPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CLKENW<'a> { w: &'a mut W, } impl<'a> _CLKENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CPOLW<'a> { w: &'a mut W, } impl<'a> _CPOLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CPHAW<'a> { w: &'a mut W, } impl<'a> _CPHAW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LBCLW<'a> { w: &'a mut W, } impl<'a> _LBCLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LBDIEW<'a> { w: &'a mut W, } impl<'a> _LBDIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LBDLW<'a> { w: &'a mut W, } impl<'a> _LBDLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADDM7W<'a> { w: &'a mut W, } impl<'a> _ADDM7W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 28:31 - Address of the USART node"] #[inline] pub fn add4(&self) -> ADD4R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ADD4R { bits } } #[doc = "Bits 24:27 - Address of the USART node"] #[inline] pub fn add0(&self) -> ADD0R { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ADD0R { bits } } #[doc = "Bit 23 - Receiver timeout enable"] #[inline] pub fn rtoen(&self) -> RTOENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RTOENR { bits } } #[doc = "Bits 21:22 - Auto baud rate mode"] #[inline] pub fn abrmod(&self) -> ABRMODR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) as u8 }; ABRMODR { bits } } #[doc = "Bit 20 - Auto baud rate enable"] #[inline] pub fn abren(&self) -> ABRENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ABRENR { bits } } #[doc = "Bit 19 - Most significant bit first"] #[inline] pub fn msbfirst(&self) -> MSBFIRSTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSBFIRSTR { bits } } #[doc = "Bit 18 - Binary data inversion"] #[inline] pub fn datainv(&self) -> DATAINVR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DATAINVR { bits } } #[doc = "Bit 17 - TX pin active level inversion"] #[inline] pub fn txinv(&self) -> TXINVR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXINVR { bits } } #[doc = "Bit 16 - RX pin active level inversion"] #[inline] pub fn rxinv(&self) -> RXINVR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXINVR { bits } } #[doc = "Bit 15 - Swap TX/RX pins"] #[inline] pub fn swap(&self) -> SWAPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SWAPR { bits } } #[doc = "Bit 14 - LIN mode enable"] #[inline] pub fn linen(&self) -> LINENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LINENR { bits } } #[doc = "Bits 12:13 - STOP bits"] #[inline] pub fn stop(&self) -> STOPR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; STOPR { bits } } #[doc = "Bit 11 - Clock enable"] #[inline] pub fn clken(&self) -> CLKENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CLKENR { bits } } #[doc = "Bit 10 - Clock polarity"] #[inline] pub fn cpol(&self) -> CPOLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CPOLR { bits } } #[doc = "Bit 9 - Clock phase"] #[inline] pub fn cpha(&self) -> CPHAR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CPHAR { bits } } #[doc = "Bit 8 - Last bit clock pulse"] #[inline] pub fn lbcl(&self) -> LBCLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LBCLR { bits } } #[doc = "Bit 6 - LIN break detection interrupt enable"] #[inline] pub fn lbdie(&self) -> LBDIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LBDIER { bits } } #[doc = "Bit 5 - LIN break detection length"] #[inline] pub fn lbdl(&self) -> LBDLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LBDLR { bits } } #[doc = "Bit 4 - 7-bit Address Detection/4-bit Address Detection"] #[inline] pub fn addm7(&self) -> ADDM7R { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ADDM7R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 28:31 - Address of the USART node"] #[inline] pub fn add4(&mut self) -> _ADD4W { _ADD4W { w: self } } #[doc = "Bits 24:27 - Address of the USART node"] #[inline] pub fn add0(&mut self) -> _ADD0W { _ADD0W { w: self } } #[doc = "Bit 23 - Receiver timeout enable"] #[inline] pub fn rtoen(&mut self) -> _RTOENW { _RTOENW { w: self } } #[doc = "Bits 21:22 - Auto baud rate mode"] #[inline] pub fn abrmod(&mut self) -> _ABRMODW { _ABRMODW { w: self } } #[doc = "Bit 20 - Auto baud rate enable"] #[inline] pub fn abren(&mut self) -> _ABRENW { _ABRENW { w: self } } #[doc = "Bit 19 - Most significant bit first"] #[inline] pub fn msbfirst(&mut self) -> _MSBFIRSTW { _MSBFIRSTW { w: self } } #[doc = "Bit 18 - Binary data inversion"] #[inline] pub fn datainv(&mut self) -> _DATAINVW { _DATAINVW { w: self } } #[doc = "Bit 17 - TX pin active level inversion"] #[inline] pub fn txinv(&mut self) -> _TXINVW { _TXINVW { w: self } } #[doc = "Bit 16 - RX pin active level inversion"] #[inline] pub fn rxinv(&mut self) -> _RXINVW { _RXINVW { w: self } } #[doc = "Bit 15 - Swap TX/RX pins"] #[inline] pub fn swap(&mut self) -> _SWAPW { _SWAPW { w: self } } #[doc = "Bit 14 - LIN mode enable"] #[inline] pub fn linen(&mut self) -> _LINENW { _LINENW { w: self } } #[doc = "Bits 12:13 - STOP bits"] #[inline] pub fn stop(&mut self) -> _STOPW { _STOPW { w: self } } #[doc = "Bit 11 - Clock enable"] #[inline] pub fn clken(&mut self) -> _CLKENW { _CLKENW { w: self } } #[doc = "Bit 10 - Clock polarity"] #[inline] pub fn cpol(&mut self) -> _CPOLW { _CPOLW { w: self } } #[doc = "Bit 9 - Clock phase"] #[inline] pub fn cpha(&mut self) -> _CPHAW { _CPHAW { w: self } } #[doc = "Bit 8 - Last bit clock pulse"] #[inline] pub fn lbcl(&mut self) -> _LBCLW { _LBCLW { w: self } } #[doc = "Bit 6 - LIN break detection interrupt enable"] #[inline] pub fn lbdie(&mut self) -> _LBDIEW { _LBDIEW { w: self } } #[doc = "Bit 5 - LIN break detection length"] #[inline] pub fn lbdl(&mut self) -> _LBDLW { _LBDLW { w: self } } #[doc = "Bit 4 - 7-bit Address Detection/4-bit Address Detection"] #[inline] pub fn addm7(&mut self) -> _ADDM7W { _ADDM7W { w: self } } } } #[doc = "Control register 3"] pub struct CR3 { register: ::vcell::VolatileCell, } #[doc = "Control register 3"] pub mod cr3 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR3 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct WUFIER { bits: bool, } impl WUFIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WUSR { bits: u8, } impl WUSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SCARCNTR { bits: u8, } impl SCARCNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DEPR { bits: bool, } impl DEPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DEMR { bits: bool, } impl DEMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DDRER { bits: bool, } impl DDRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OVRDISR { bits: bool, } impl OVRDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ONEBITR { bits: bool, } impl ONEBITR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CTSIER { bits: bool, } impl CTSIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CTSER { bits: bool, } impl CTSER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RTSER { bits: bool, } impl RTSER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DMATR { bits: bool, } impl DMATR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DMARR { bits: bool, } impl DMARR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SCENR { bits: bool, } impl SCENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NACKR { bits: bool, } impl NACKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HDSELR { bits: bool, } impl HDSELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IRLPR { bits: bool, } impl IRLPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IRENR { bits: bool, } impl IRENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EIER { bits: bool, } impl EIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _WUFIEW<'a> { w: &'a mut W, } impl<'a> _WUFIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WUSW<'a> { w: &'a mut W, } impl<'a> _WUSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SCARCNTW<'a> { w: &'a mut W, } impl<'a> _SCARCNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DEPW<'a> { w: &'a mut W, } impl<'a> _DEPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DEMW<'a> { w: &'a mut W, } impl<'a> _DEMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DDREW<'a> { w: &'a mut W, } impl<'a> _DDREW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OVRDISW<'a> { w: &'a mut W, } impl<'a> _OVRDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ONEBITW<'a> { w: &'a mut W, } impl<'a> _ONEBITW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTSIEW<'a> { w: &'a mut W, } impl<'a> _CTSIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTSEW<'a> { w: &'a mut W, } impl<'a> _CTSEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTSEW<'a> { w: &'a mut W, } impl<'a> _RTSEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DMATW<'a> { w: &'a mut W, } impl<'a> _DMATW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DMARW<'a> { w: &'a mut W, } impl<'a> _DMARW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SCENW<'a> { w: &'a mut W, } impl<'a> _SCENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NACKW<'a> { w: &'a mut W, } impl<'a> _NACKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HDSELW<'a> { w: &'a mut W, } impl<'a> _HDSELW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IRLPW<'a> { w: &'a mut W, } impl<'a> _IRLPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IRENW<'a> { w: &'a mut W, } impl<'a> _IRENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EIEW<'a> { w: &'a mut W, } impl<'a> _EIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 22 - Wakeup from Stop mode interrupt enable"] #[inline] pub fn wufie(&self) -> WUFIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WUFIER { bits } } #[doc = "Bits 20:21 - Wakeup from Stop mode interrupt flag selection"] #[inline] pub fn wus(&self) -> WUSR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; WUSR { bits } } #[doc = "Bits 17:19 - Smartcard auto-retry count"] #[inline] pub fn scarcnt(&self) -> SCARCNTR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SCARCNTR { bits } } #[doc = "Bit 15 - Driver enable polarity selection"] #[inline] pub fn dep(&self) -> DEPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DEPR { bits } } #[doc = "Bit 14 - Driver enable mode"] #[inline] pub fn dem(&self) -> DEMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DEMR { bits } } #[doc = "Bit 13 - DMA Disable on Reception Error"] #[inline] pub fn ddre(&self) -> DDRER { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DDRER { bits } } #[doc = "Bit 12 - Overrun Disable"] #[inline] pub fn ovrdis(&self) -> OVRDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OVRDISR { bits } } #[doc = "Bit 11 - One sample bit method enable"] #[inline] pub fn onebit(&self) -> ONEBITR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ONEBITR { bits } } #[doc = "Bit 10 - CTS interrupt enable"] #[inline] pub fn ctsie(&self) -> CTSIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CTSIER { bits } } #[doc = "Bit 9 - CTS enable"] #[inline] pub fn ctse(&self) -> CTSER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CTSER { bits } } #[doc = "Bit 8 - RTS enable"] #[inline] pub fn rtse(&self) -> RTSER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RTSER { bits } } #[doc = "Bit 7 - DMA enable transmitter"] #[inline] pub fn dmat(&self) -> DMATR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DMATR { bits } } #[doc = "Bit 6 - DMA enable receiver"] #[inline] pub fn dmar(&self) -> DMARR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DMARR { bits } } #[doc = "Bit 5 - Smartcard mode enable"] #[inline] pub fn scen(&self) -> SCENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SCENR { bits } } #[doc = "Bit 4 - Smartcard NACK enable"] #[inline] pub fn nack(&self) -> NACKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NACKR { bits } } #[doc = "Bit 3 - Half-duplex selection"] #[inline] pub fn hdsel(&self) -> HDSELR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; HDSELR { bits } } #[doc = "Bit 2 - IrDA low-power"] #[inline] pub fn irlp(&self) -> IRLPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IRLPR { bits } } #[doc = "Bit 1 - IrDA mode enable"] #[inline] pub fn iren(&self) -> IRENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IRENR { bits } } #[doc = "Bit 0 - Error interrupt enable"] #[inline] pub fn eie(&self) -> EIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 22 - Wakeup from Stop mode interrupt enable"] #[inline] pub fn wufie(&mut self) -> _WUFIEW { _WUFIEW { w: self } } #[doc = "Bits 20:21 - Wakeup from Stop mode interrupt flag selection"] #[inline] pub fn wus(&mut self) -> _WUSW { _WUSW { w: self } } #[doc = "Bits 17:19 - Smartcard auto-retry count"] #[inline] pub fn scarcnt(&mut self) -> _SCARCNTW { _SCARCNTW { w: self } } #[doc = "Bit 15 - Driver enable polarity selection"] #[inline] pub fn dep(&mut self) -> _DEPW { _DEPW { w: self } } #[doc = "Bit 14 - Driver enable mode"] #[inline] pub fn dem(&mut self) -> _DEMW { _DEMW { w: self } } #[doc = "Bit 13 - DMA Disable on Reception Error"] #[inline] pub fn ddre(&mut self) -> _DDREW { _DDREW { w: self } } #[doc = "Bit 12 - Overrun Disable"] #[inline] pub fn ovrdis(&mut self) -> _OVRDISW { _OVRDISW { w: self } } #[doc = "Bit 11 - One sample bit method enable"] #[inline] pub fn onebit(&mut self) -> _ONEBITW { _ONEBITW { w: self } } #[doc = "Bit 10 - CTS interrupt enable"] #[inline] pub fn ctsie(&mut self) -> _CTSIEW { _CTSIEW { w: self } } #[doc = "Bit 9 - CTS enable"] #[inline] pub fn ctse(&mut self) -> _CTSEW { _CTSEW { w: self } } #[doc = "Bit 8 - RTS enable"] #[inline] pub fn rtse(&mut self) -> _RTSEW { _RTSEW { w: self } } #[doc = "Bit 7 - DMA enable transmitter"] #[inline] pub fn dmat(&mut self) -> _DMATW { _DMATW { w: self } } #[doc = "Bit 6 - DMA enable receiver"] #[inline] pub fn dmar(&mut self) -> _DMARW { _DMARW { w: self } } #[doc = "Bit 5 - Smartcard mode enable"] #[inline] pub fn scen(&mut self) -> _SCENW { _SCENW { w: self } } #[doc = "Bit 4 - Smartcard NACK enable"] #[inline] pub fn nack(&mut self) -> _NACKW { _NACKW { w: self } } #[doc = "Bit 3 - Half-duplex selection"] #[inline] pub fn hdsel(&mut self) -> _HDSELW { _HDSELW { w: self } } #[doc = "Bit 2 - IrDA low-power"] #[inline] pub fn irlp(&mut self) -> _IRLPW { _IRLPW { w: self } } #[doc = "Bit 1 - IrDA mode enable"] #[inline] pub fn iren(&mut self) -> _IRENW { _IRENW { w: self } } #[doc = "Bit 0 - Error interrupt enable"] #[inline] pub fn eie(&mut self) -> _EIEW { _EIEW { w: self } } } } #[doc = "Baud rate register"] pub struct BRR { register: ::vcell::VolatileCell, } #[doc = "Baud rate register"] pub mod brr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BRR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DIV_MANTISSAR { bits: u16, } impl DIV_MANTISSAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct DIV_FRACTIONR { bits: u8, } impl DIV_FRACTIONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _DIV_MANTISSAW<'a> { w: &'a mut W, } impl<'a> _DIV_MANTISSAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x0fff; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DIV_FRACTIONW<'a> { w: &'a mut W, } impl<'a> _DIV_FRACTIONW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 4:15 - mantissa of USARTDIV"] #[inline] pub fn div_mantissa(&self) -> DIV_MANTISSAR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DIV_MANTISSAR { bits } } #[doc = "Bits 0:3 - fraction of USARTDIV"] #[inline] pub fn div_fraction(&self) -> DIV_FRACTIONR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DIV_FRACTIONR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 4:15 - mantissa of USARTDIV"] #[inline] pub fn div_mantissa(&mut self) -> _DIV_MANTISSAW { _DIV_MANTISSAW { w: self } } #[doc = "Bits 0:3 - fraction of USARTDIV"] #[inline] pub fn div_fraction(&mut self) -> _DIV_FRACTIONW { _DIV_FRACTIONW { w: self } } } } #[doc = "Guard time and prescaler register"] pub struct GTPR { register: ::vcell::VolatileCell, } #[doc = "Guard time and prescaler register"] pub mod gtpr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::GTPR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct GTR { bits: u8, } impl GTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PSCR { bits: u8, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _GTW<'a> { w: &'a mut W, } impl<'a> _GTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:15 - Guard time value"] #[inline] pub fn gt(&self) -> GTR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; GTR { bits } } #[doc = "Bits 0:7 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:15 - Guard time value"] #[inline] pub fn gt(&mut self) -> _GTW { _GTW { w: self } } #[doc = "Bits 0:7 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "Receiver timeout register"] pub struct RTOR { register: ::vcell::VolatileCell, } #[doc = "Receiver timeout register"] pub mod rtor { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RTOR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BLENR { bits: u8, } impl BLENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct RTOR { bits: u32, } impl RTOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _BLENW<'a> { w: &'a mut W, } impl<'a> _BLENW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTOW<'a> { w: &'a mut W, } impl<'a> _RTOW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0x00ff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 24:31 - Block Length"] #[inline] pub fn blen(&self) -> BLENR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; BLENR { bits } } #[doc = "Bits 0:23 - Receiver timeout value"] #[inline] pub fn rto(&self) -> RTOR { let bits = { const MASK: u32 = 0x00ff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; RTOR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 24:31 - Block Length"] #[inline] pub fn blen(&mut self) -> _BLENW { _BLENW { w: self } } #[doc = "Bits 0:23 - Receiver timeout value"] #[inline] pub fn rto(&mut self) -> _RTOW { _RTOW { w: self } } } } #[doc = "Request register"] pub struct RQR { register: ::vcell::VolatileCell, } #[doc = "Request register"] pub mod rqr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RQR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TXFRQR { bits: bool, } impl TXFRQR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXFRQR { bits: bool, } impl RXFRQR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MMRQR { bits: bool, } impl MMRQR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SBKRQR { bits: bool, } impl SBKRQR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ABRRQR { bits: bool, } impl ABRRQR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TXFRQW<'a> { w: &'a mut W, } impl<'a> _TXFRQW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RXFRQW<'a> { w: &'a mut W, } impl<'a> _RXFRQW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MMRQW<'a> { w: &'a mut W, } impl<'a> _MMRQW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SBKRQW<'a> { w: &'a mut W, } impl<'a> _SBKRQW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ABRRQW<'a> { w: &'a mut W, } impl<'a> _ABRRQW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 4 - Transmit data flush request"] #[inline] pub fn txfrq(&self) -> TXFRQR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXFRQR { bits } } #[doc = "Bit 3 - Receive data flush request"] #[inline] pub fn rxfrq(&self) -> RXFRQR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXFRQR { bits } } #[doc = "Bit 2 - Mute mode request"] #[inline] pub fn mmrq(&self) -> MMRQR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MMRQR { bits } } #[doc = "Bit 1 - Send break request"] #[inline] pub fn sbkrq(&self) -> SBKRQR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SBKRQR { bits } } #[doc = "Bit 0 - Auto baud rate request"] #[inline] pub fn abrrq(&self) -> ABRRQR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ABRRQR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 4 - Transmit data flush request"] #[inline] pub fn txfrq(&mut self) -> _TXFRQW { _TXFRQW { w: self } } #[doc = "Bit 3 - Receive data flush request"] #[inline] pub fn rxfrq(&mut self) -> _RXFRQW { _RXFRQW { w: self } } #[doc = "Bit 2 - Mute mode request"] #[inline] pub fn mmrq(&mut self) -> _MMRQW { _MMRQW { w: self } } #[doc = "Bit 1 - Send break request"] #[inline] pub fn sbkrq(&mut self) -> _SBKRQW { _SBKRQW { w: self } } #[doc = "Bit 0 - Auto baud rate request"] #[inline] pub fn abrrq(&mut self) -> _ABRRQW { _ABRRQW { w: self } } } } #[doc = "Interrupt & status register"] pub struct ISR { register: ::vcell::VolatileCell, } #[doc = "Interrupt & status register"] pub mod isr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::ISR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct REACKR { bits: bool, } impl REACKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TEACKR { bits: bool, } impl TEACKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WUFR { bits: bool, } impl WUFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RWUR { bits: bool, } impl RWUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SBKFR { bits: bool, } impl SBKFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CMFR { bits: bool, } impl CMFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BUSYR { bits: bool, } impl BUSYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ABRFR { bits: bool, } impl ABRFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ABRER { bits: bool, } impl ABRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOBFR { bits: bool, } impl EOBFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RTOFR { bits: bool, } impl RTOFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CTSR { bits: bool, } impl CTSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CTSIFR { bits: bool, } impl CTSIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LBDFR { bits: bool, } impl LBDFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TXER { bits: bool, } impl TXER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCR { bits: bool, } impl TCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RXNER { bits: bool, } impl RXNER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDLER { bits: bool, } impl IDLER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ORER { bits: bool, } impl ORER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NFR { bits: bool, } impl NFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct FER { bits: bool, } impl FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PER { bits: bool, } impl PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 22 - Receive enable acknowledge flag"] #[inline] pub fn reack(&self) -> REACKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; REACKR { bits } } #[doc = "Bit 21 - Transmit enable acknowledge flag"] #[inline] pub fn teack(&self) -> TEACKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TEACKR { bits } } #[doc = "Bit 20 - Wakeup from Stop mode flag"] #[inline] pub fn wuf(&self) -> WUFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WUFR { bits } } #[doc = "Bit 19 - Receiver wakeup from Mute mode"] #[inline] pub fn rwu(&self) -> RWUR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RWUR { bits } } #[doc = "Bit 18 - Send break flag"] #[inline] pub fn sbkf(&self) -> SBKFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SBKFR { bits } } #[doc = "Bit 17 - character match flag"] #[inline] pub fn cmf(&self) -> CMFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CMFR { bits } } #[doc = "Bit 16 - Busy flag"] #[inline] pub fn busy(&self) -> BUSYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BUSYR { bits } } #[doc = "Bit 15 - Auto baud rate flag"] #[inline] pub fn abrf(&self) -> ABRFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ABRFR { bits } } #[doc = "Bit 14 - Auto baud rate error"] #[inline] pub fn abre(&self) -> ABRER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ABRER { bits } } #[doc = "Bit 12 - End of block flag"] #[inline] pub fn eobf(&self) -> EOBFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOBFR { bits } } #[doc = "Bit 11 - Receiver timeout"] #[inline] pub fn rtof(&self) -> RTOFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RTOFR { bits } } #[doc = "Bit 10 - CTS flag"] #[inline] pub fn cts(&self) -> CTSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CTSR { bits } } #[doc = "Bit 9 - CTS interrupt flag"] #[inline] pub fn ctsif(&self) -> CTSIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CTSIFR { bits } } #[doc = "Bit 8 - LIN break detection flag"] #[inline] pub fn lbdf(&self) -> LBDFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LBDFR { bits } } #[doc = "Bit 7 - Transmit data register empty"] #[inline] pub fn txe(&self) -> TXER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TXER { bits } } #[doc = "Bit 6 - Transmission complete"] #[inline] pub fn tc(&self) -> TCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCR { bits } } #[doc = "Bit 5 - Read data register not empty"] #[inline] pub fn rxne(&self) -> RXNER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RXNER { bits } } #[doc = "Bit 4 - Idle line detected"] #[inline] pub fn idle(&self) -> IDLER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDLER { bits } } #[doc = "Bit 3 - Overrun error"] #[inline] pub fn ore(&self) -> ORER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ORER { bits } } #[doc = "Bit 2 - Noise detected flag"] #[inline] pub fn nf(&self) -> NFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NFR { bits } } #[doc = "Bit 1 - Framing error"] #[inline] pub fn fe(&self) -> FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FER { bits } } #[doc = "Bit 0 - Parity error"] #[inline] pub fn pe(&self) -> PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PER { bits } } } } #[doc = "Interrupt flag clear register"] pub struct ICR { register: ::vcell::VolatileCell, } #[doc = "Interrupt flag clear register"] pub mod icr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ICR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct WUCFR { bits: bool, } impl WUCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CMCFR { bits: bool, } impl CMCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOBCFR { bits: bool, } impl EOBCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RTOCFR { bits: bool, } impl RTOCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CTSCFR { bits: bool, } impl CTSCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LBDCFR { bits: bool, } impl LBDCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TCCFR { bits: bool, } impl TCCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct IDLECFR { bits: bool, } impl IDLECFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ORECFR { bits: bool, } impl ORECFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NCFR { bits: bool, } impl NCFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct FECFR { bits: bool, } impl FECFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PECFR { bits: bool, } impl PECFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _WUCFW<'a> { w: &'a mut W, } impl<'a> _WUCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CMCFW<'a> { w: &'a mut W, } impl<'a> _CMCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOBCFW<'a> { w: &'a mut W, } impl<'a> _EOBCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RTOCFW<'a> { w: &'a mut W, } impl<'a> _RTOCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CTSCFW<'a> { w: &'a mut W, } impl<'a> _CTSCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LBDCFW<'a> { w: &'a mut W, } impl<'a> _LBDCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TCCFW<'a> { w: &'a mut W, } impl<'a> _TCCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IDLECFW<'a> { w: &'a mut W, } impl<'a> _IDLECFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ORECFW<'a> { w: &'a mut W, } impl<'a> _ORECFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _NCFW<'a> { w: &'a mut W, } impl<'a> _NCFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _FECFW<'a> { w: &'a mut W, } impl<'a> _FECFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PECFW<'a> { w: &'a mut W, } impl<'a> _PECFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 20 - Wakeup from Stop mode clear flag"] #[inline] pub fn wucf(&self) -> WUCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WUCFR { bits } } #[doc = "Bit 17 - Character match clear flag"] #[inline] pub fn cmcf(&self) -> CMCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CMCFR { bits } } #[doc = "Bit 12 - End of timeout clear flag"] #[inline] pub fn eobcf(&self) -> EOBCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOBCFR { bits } } #[doc = "Bit 11 - Receiver timeout clear flag"] #[inline] pub fn rtocf(&self) -> RTOCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RTOCFR { bits } } #[doc = "Bit 9 - CTS clear flag"] #[inline] pub fn ctscf(&self) -> CTSCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CTSCFR { bits } } #[doc = "Bit 8 - LIN break detection clear flag"] #[inline] pub fn lbdcf(&self) -> LBDCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LBDCFR { bits } } #[doc = "Bit 6 - Transmission complete clear flag"] #[inline] pub fn tccf(&self) -> TCCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TCCFR { bits } } #[doc = "Bit 4 - Idle line detected clear flag"] #[inline] pub fn idlecf(&self) -> IDLECFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; IDLECFR { bits } } #[doc = "Bit 3 - Overrun error clear flag"] #[inline] pub fn orecf(&self) -> ORECFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ORECFR { bits } } #[doc = "Bit 2 - Noise detected clear flag"] #[inline] pub fn ncf(&self) -> NCFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NCFR { bits } } #[doc = "Bit 1 - Framing error clear flag"] #[inline] pub fn fecf(&self) -> FECFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FECFR { bits } } #[doc = "Bit 0 - Parity error clear flag"] #[inline] pub fn pecf(&self) -> PECFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PECFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 20 - Wakeup from Stop mode clear flag"] #[inline] pub fn wucf(&mut self) -> _WUCFW { _WUCFW { w: self } } #[doc = "Bit 17 - Character match clear flag"] #[inline] pub fn cmcf(&mut self) -> _CMCFW { _CMCFW { w: self } } #[doc = "Bit 12 - End of timeout clear flag"] #[inline] pub fn eobcf(&mut self) -> _EOBCFW { _EOBCFW { w: self } } #[doc = "Bit 11 - Receiver timeout clear flag"] #[inline] pub fn rtocf(&mut self) -> _RTOCFW { _RTOCFW { w: self } } #[doc = "Bit 9 - CTS clear flag"] #[inline] pub fn ctscf(&mut self) -> _CTSCFW { _CTSCFW { w: self } } #[doc = "Bit 8 - LIN break detection clear flag"] #[inline] pub fn lbdcf(&mut self) -> _LBDCFW { _LBDCFW { w: self } } #[doc = "Bit 6 - Transmission complete clear flag"] #[inline] pub fn tccf(&mut self) -> _TCCFW { _TCCFW { w: self } } #[doc = "Bit 4 - Idle line detected clear flag"] #[inline] pub fn idlecf(&mut self) -> _IDLECFW { _IDLECFW { w: self } } #[doc = "Bit 3 - Overrun error clear flag"] #[inline] pub fn orecf(&mut self) -> _ORECFW { _ORECFW { w: self } } #[doc = "Bit 2 - Noise detected clear flag"] #[inline] pub fn ncf(&mut self) -> _NCFW { _NCFW { w: self } } #[doc = "Bit 1 - Framing error clear flag"] #[inline] pub fn fecf(&mut self) -> _FECFW { _FECFW { w: self } } #[doc = "Bit 0 - Parity error clear flag"] #[inline] pub fn pecf(&mut self) -> _PECFW { _PECFW { w: self } } } } #[doc = "Receive data register"] pub struct RDR { register: ::vcell::VolatileCell, } #[doc = "Receive data register"] pub mod rdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::RDR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct RDRR { bits: u16, } impl RDRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:8 - Receive data value"] #[inline] pub fn rdr(&self) -> RDRR { let bits = { const MASK: u16 = 0x01ff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; RDRR { bits } } } } #[doc = "Transmit data register"] pub struct TDR { register: ::vcell::VolatileCell, } #[doc = "Transmit data register"] pub mod tdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TDR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TDRR { bits: u16, } impl TDRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _TDRW<'a> { w: &'a mut W, } impl<'a> _TDRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x01ff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:8 - Transmit data value"] #[inline] pub fn tdr(&self) -> TDRR { let bits = { const MASK: u16 = 0x01ff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; TDRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:8 - Transmit data value"] #[inline] pub fn tdr(&mut self) -> _TDRW { _TDRW { w: self } } } } } #[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 { 0x4000_4400 as *const _ } } impl Deref for USART2 { type Target = usart1::RegisterBlock; fn deref(&self) -> &usart1::RegisterBlock { unsafe { &*USART2::ptr() } } } #[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 { 0x4000_2800 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 = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - time register"] pub tr: TR, #[doc = "0x04 - date register"] pub dr: DR, #[doc = "0x08 - control register"] pub cr: CR, #[doc = "0x0c - initialization and status register"] pub isr: ISR, #[doc = "0x10 - prescaler register"] pub prer: PRER, _reserved0: [u8; 8usize], #[doc = "0x1c - alarm A register"] pub alrmar: ALRMAR, _reserved1: [u8; 4usize], #[doc = "0x24 - write protection register"] pub wpr: WPR, #[doc = "0x28 - sub second register"] pub ssr: SSR, #[doc = "0x2c - shift control register"] pub shiftr: SHIFTR, #[doc = "0x30 - timestamp time register"] pub tstr: TSTR, #[doc = "0x34 - timestamp date register"] pub tsdr: TSDR, #[doc = "0x38 - time-stamp sub second register"] pub tsssr: TSSSR, #[doc = "0x3c - calibration register"] pub calr: CALR, #[doc = "0x40 - tamper and alternate function configuration register"] pub tafcr: TAFCR, #[doc = "0x44 - alarm A sub second register"] pub alrmassr: ALRMASSR, _reserved2: [u8; 8usize], #[doc = "0x50 - backup register"] pub bkp0r: BKP0R, #[doc = "0x54 - backup register"] pub bkp1r: BKP1R, #[doc = "0x58 - backup register"] pub bkp2r: BKP2R, #[doc = "0x5c - backup register"] pub bkp3r: BKP3R, #[doc = "0x60 - backup register"] pub bkp4r: BKP4R, } #[doc = "time register"] pub struct TR { register: ::vcell::VolatileCell, } #[doc = "time register"] pub mod tr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PMR { bits: bool, } impl PMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTR { bits: u8, } impl HTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HUR { bits: u8, } impl HUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MNTR { bits: u8, } impl MNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MNUR { bits: u8, } impl MNUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct STR { bits: u8, } impl STR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SUR { bits: u8, } impl SUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _PMW<'a> { w: &'a mut W, } impl<'a> _PMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTW<'a> { w: &'a mut W, } impl<'a> _HTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HUW<'a> { w: &'a mut W, } impl<'a> _HUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MNTW<'a> { w: &'a mut W, } impl<'a> _MNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MNUW<'a> { w: &'a mut W, } impl<'a> _MNUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STW<'a> { w: &'a mut W, } impl<'a> _STW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SUW<'a> { w: &'a mut W, } impl<'a> _SUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 22 - AM/PM notation"] #[inline] pub fn pm(&self) -> PMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PMR { bits } } #[doc = "Bits 20:21 - Hour tens in BCD format"] #[inline] pub fn ht(&self) -> HTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HTR { bits } } #[doc = "Bits 16:19 - Hour units in BCD format"] #[inline] pub fn hu(&self) -> HUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HUR { bits } } #[doc = "Bits 12:14 - Minute tens in BCD format"] #[inline] pub fn mnt(&self) -> MNTR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MNTR { bits } } #[doc = "Bits 8:11 - Minute units in BCD format"] #[inline] pub fn mnu(&self) -> MNUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MNUR { bits } } #[doc = "Bits 4:6 - Second tens in BCD format"] #[inline] pub fn st(&self) -> STR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; STR { bits } } #[doc = "Bits 0:3 - Second units in BCD format"] #[inline] pub fn su(&self) -> SUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SUR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 22 - AM/PM notation"] #[inline] pub fn pm(&mut self) -> _PMW { _PMW { w: self } } #[doc = "Bits 20:21 - Hour tens in BCD format"] #[inline] pub fn ht(&mut self) -> _HTW { _HTW { w: self } } #[doc = "Bits 16:19 - Hour units in BCD format"] #[inline] pub fn hu(&mut self) -> _HUW { _HUW { w: self } } #[doc = "Bits 12:14 - Minute tens in BCD format"] #[inline] pub fn mnt(&mut self) -> _MNTW { _MNTW { w: self } } #[doc = "Bits 8:11 - Minute units in BCD format"] #[inline] pub fn mnu(&mut self) -> _MNUW { _MNUW { w: self } } #[doc = "Bits 4:6 - Second tens in BCD format"] #[inline] pub fn st(&mut self) -> _STW { _STW { w: self } } #[doc = "Bits 0:3 - Second units in BCD format"] #[inline] pub fn su(&mut self) -> _SUW { _SUW { w: self } } } } #[doc = "date register"] pub struct DR { register: ::vcell::VolatileCell, } #[doc = "date register"] pub mod dr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct YTR { bits: u8, } impl YTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct YUR { bits: u8, } impl YUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct WDUR { bits: u8, } impl WDUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MTR { bits: bool, } impl MTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MUR { bits: u8, } impl MUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DTR { bits: u8, } impl DTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DUR { bits: u8, } impl DUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _YTW<'a> { w: &'a mut W, } impl<'a> _YTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _YUW<'a> { w: &'a mut W, } impl<'a> _YUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WDUW<'a> { w: &'a mut W, } impl<'a> _WDUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MTW<'a> { w: &'a mut W, } impl<'a> _MTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MUW<'a> { w: &'a mut W, } impl<'a> _MUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DTW<'a> { w: &'a mut W, } impl<'a> _DTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DUW<'a> { w: &'a mut W, } impl<'a> _DUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 20:23 - Year tens in BCD format"] #[inline] pub fn yt(&self) -> YTR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; YTR { bits } } #[doc = "Bits 16:19 - Year units in BCD format"] #[inline] pub fn yu(&self) -> YUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; YUR { bits } } #[doc = "Bits 13:15 - Week day units"] #[inline] pub fn wdu(&self) -> WDUR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) as u8 }; WDUR { bits } } #[doc = "Bit 12 - Month tens in BCD format"] #[inline] pub fn mt(&self) -> MTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MTR { bits } } #[doc = "Bits 8:11 - Month units in BCD format"] #[inline] pub fn mu(&self) -> MUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MUR { bits } } #[doc = "Bits 4:5 - Date tens in BCD format"] #[inline] pub fn dt(&self) -> DTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DTR { bits } } #[doc = "Bits 0:3 - Date units in BCD format"] #[inline] pub fn du(&self) -> DUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DUR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x2101 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 20:23 - Year tens in BCD format"] #[inline] pub fn yt(&mut self) -> _YTW { _YTW { w: self } } #[doc = "Bits 16:19 - Year units in BCD format"] #[inline] pub fn yu(&mut self) -> _YUW { _YUW { w: self } } #[doc = "Bits 13:15 - Week day units"] #[inline] pub fn wdu(&mut self) -> _WDUW { _WDUW { w: self } } #[doc = "Bit 12 - Month tens in BCD format"] #[inline] pub fn mt(&mut self) -> _MTW { _MTW { w: self } } #[doc = "Bits 8:11 - Month units in BCD format"] #[inline] pub fn mu(&mut self) -> _MUW { _MUW { w: self } } #[doc = "Bits 4:5 - Date tens in BCD format"] #[inline] pub fn dt(&mut self) -> _DTW { _DTW { w: self } } #[doc = "Bits 0:3 - Date units in BCD format"] #[inline] pub fn du(&mut self) -> _DUW { _DUW { w: self } } } } #[doc = "control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TSEDGER { bits: bool, } impl TSEDGER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct REFCKONR { bits: bool, } impl REFCKONR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BYPSHADR { bits: bool, } impl BYPSHADR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct FMTR { bits: bool, } impl FMTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ALRAER { bits: bool, } impl ALRAER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSER { bits: bool, } impl TSER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ALRAIER { bits: bool, } impl ALRAIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSIER { bits: bool, } impl TSIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKPR { bits: bool, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COSELR { bits: bool, } impl COSELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct POLR { bits: bool, } impl POLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSELR { bits: u8, } impl OSELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct COER { bits: bool, } impl COER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TSEDGEW<'a> { w: &'a mut W, } impl<'a> _TSEDGEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _REFCKONW<'a> { w: &'a mut W, } impl<'a> _REFCKONW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BYPSHADW<'a> { w: &'a mut W, } impl<'a> _BYPSHADW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _FMTW<'a> { w: &'a mut W, } impl<'a> _FMTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ALRAEW<'a> { w: &'a mut W, } impl<'a> _ALRAEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSEW<'a> { w: &'a mut W, } impl<'a> _TSEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ALRAIEW<'a> { w: &'a mut W, } impl<'a> _ALRAIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSIEW<'a> { w: &'a mut W, } impl<'a> _TSIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ADD1HW<'a> { w: &'a mut W, } impl<'a> _ADD1HW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SUB1HW<'a> { w: &'a mut W, } impl<'a> _SUB1HW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COSELW<'a> { w: &'a mut W, } impl<'a> _COSELW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _POLW<'a> { w: &'a mut W, } impl<'a> _POLW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSELW<'a> { w: &'a mut W, } impl<'a> _OSELW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COEW<'a> { w: &'a mut W, } impl<'a> _COEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 3 - Time-stamp event active edge"] #[inline] pub fn tsedge(&self) -> TSEDGER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TSEDGER { bits } } #[doc = "Bit 4 - RTC_REFIN reference clock detection enable (50 or 60 Hz)"] #[inline] pub fn refckon(&self) -> REFCKONR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; REFCKONR { bits } } #[doc = "Bit 5 - Bypass the shadow registers"] #[inline] pub fn bypshad(&self) -> BYPSHADR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BYPSHADR { bits } } #[doc = "Bit 6 - Hour format"] #[inline] pub fn fmt(&self) -> FMTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FMTR { bits } } #[doc = "Bit 8 - Alarm A enable"] #[inline] pub fn alrae(&self) -> ALRAER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALRAER { bits } } #[doc = "Bit 11 - timestamp enable"] #[inline] pub fn tse(&self) -> TSER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TSER { bits } } #[doc = "Bit 12 - Alarm A interrupt enable"] #[inline] pub fn alraie(&self) -> ALRAIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALRAIER { bits } } #[doc = "Bit 15 - Time-stamp interrupt enable"] #[inline] pub fn tsie(&self) -> TSIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TSIER { bits } } #[doc = "Bit 18 - Backup"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKPR { bits } } #[doc = "Bit 19 - Calibration output selection"] #[inline] pub fn cosel(&self) -> COSELR { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COSELR { bits } } #[doc = "Bit 20 - Output polarity"] #[inline] pub fn pol(&self) -> POLR { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; POLR { bits } } #[doc = "Bits 21:22 - Output selection"] #[inline] pub fn osel(&self) -> OSELR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OSELR { bits } } #[doc = "Bit 23 - Calibration output enable"] #[inline] pub fn coe(&self) -> COER { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 3 - Time-stamp event active edge"] #[inline] pub fn tsedge(&mut self) -> _TSEDGEW { _TSEDGEW { w: self } } #[doc = "Bit 4 - RTC_REFIN reference clock detection enable (50 or 60 Hz)"] #[inline] pub fn refckon(&mut self) -> _REFCKONW { _REFCKONW { w: self } } #[doc = "Bit 5 - Bypass the shadow registers"] #[inline] pub fn bypshad(&mut self) -> _BYPSHADW { _BYPSHADW { w: self } } #[doc = "Bit 6 - Hour format"] #[inline] pub fn fmt(&mut self) -> _FMTW { _FMTW { w: self } } #[doc = "Bit 8 - Alarm A enable"] #[inline] pub fn alrae(&mut self) -> _ALRAEW { _ALRAEW { w: self } } #[doc = "Bit 11 - timestamp enable"] #[inline] pub fn tse(&mut self) -> _TSEW { _TSEW { w: self } } #[doc = "Bit 12 - Alarm A interrupt enable"] #[inline] pub fn alraie(&mut self) -> _ALRAIEW { _ALRAIEW { w: self } } #[doc = "Bit 15 - Time-stamp interrupt enable"] #[inline] pub fn tsie(&mut self) -> _TSIEW { _TSIEW { w: self } } #[doc = "Bit 16 - Add 1 hour (summer time change)"] #[inline] pub fn add1h(&mut self) -> _ADD1HW { _ADD1HW { w: self } } #[doc = "Bit 17 - Subtract 1 hour (winter time change)"] #[inline] pub fn sub1h(&mut self) -> _SUB1HW { _SUB1HW { w: self } } #[doc = "Bit 18 - Backup"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } #[doc = "Bit 19 - Calibration output selection"] #[inline] pub fn cosel(&mut self) -> _COSELW { _COSELW { w: self } } #[doc = "Bit 20 - Output polarity"] #[inline] pub fn pol(&mut self) -> _POLW { _POLW { w: self } } #[doc = "Bits 21:22 - Output selection"] #[inline] pub fn osel(&mut self) -> _OSELW { _OSELW { w: self } } #[doc = "Bit 23 - Calibration output enable"] #[inline] pub fn coe(&mut self) -> _COEW { _COEW { w: self } } } } #[doc = "initialization and status register"] pub struct ISR { register: ::vcell::VolatileCell, } #[doc = "initialization and status register"] pub mod isr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ISR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ALRAWFR { bits: bool, } impl ALRAWFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct SHPFR { bits: bool, } impl SHPFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct INITSR { bits: bool, } impl INITSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RSFR { bits: bool, } impl RSFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct INITFR { bits: bool, } impl INITFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct INITR { bits: bool, } impl INITR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ALRAFR { bits: bool, } impl ALRAFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSFR { bits: bool, } impl TSFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSOVFR { bits: bool, } impl TSOVFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP1FR { bits: bool, } impl TAMP1FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP2FR { bits: bool, } impl TAMP2FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct RECALPFR { bits: bool, } impl RECALPFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _SHPFW<'a> { w: &'a mut W, } impl<'a> _SHPFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _RSFW<'a> { w: &'a mut W, } impl<'a> _RSFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _INITW<'a> { w: &'a mut W, } impl<'a> _INITW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ALRAFW<'a> { w: &'a mut W, } impl<'a> _ALRAFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSFW<'a> { w: &'a mut W, } impl<'a> _TSFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSOVFW<'a> { w: &'a mut W, } impl<'a> _TSOVFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP1FW<'a> { w: &'a mut W, } impl<'a> _TAMP1FW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP2FW<'a> { w: &'a mut W, } impl<'a> _TAMP2FW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Alarm A write flag"] #[inline] pub fn alrawf(&self) -> ALRAWFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALRAWFR { bits } } #[doc = "Bit 3 - Shift operation pending"] #[inline] pub fn shpf(&self) -> SHPFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; SHPFR { bits } } #[doc = "Bit 4 - Initialization status flag"] #[inline] pub fn inits(&self) -> INITSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; INITSR { bits } } #[doc = "Bit 5 - Registers synchronization flag"] #[inline] pub fn rsf(&self) -> RSFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RSFR { bits } } #[doc = "Bit 6 - Initialization flag"] #[inline] pub fn initf(&self) -> INITFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; INITFR { bits } } #[doc = "Bit 7 - Initialization mode"] #[inline] pub fn init(&self) -> INITR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; INITR { bits } } #[doc = "Bit 8 - Alarm A flag"] #[inline] pub fn alraf(&self) -> ALRAFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ALRAFR { bits } } #[doc = "Bit 11 - Time-stamp flag"] #[inline] pub fn tsf(&self) -> TSFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TSFR { bits } } #[doc = "Bit 12 - Time-stamp overflow flag"] #[inline] pub fn tsovf(&self) -> TSOVFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TSOVFR { bits } } #[doc = "Bit 13 - RTC_TAMP1 detection flag"] #[inline] pub fn tamp1f(&self) -> TAMP1FR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP1FR { bits } } #[doc = "Bit 14 - RTC_TAMP2 detection flag"] #[inline] pub fn tamp2f(&self) -> TAMP2FR { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP2FR { bits } } #[doc = "Bit 16 - Recalibration pending Flag"] #[inline] pub fn recalpf(&self) -> RECALPFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; RECALPFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x07 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 3 - Shift operation pending"] #[inline] pub fn shpf(&mut self) -> _SHPFW { _SHPFW { w: self } } #[doc = "Bit 5 - Registers synchronization flag"] #[inline] pub fn rsf(&mut self) -> _RSFW { _RSFW { w: self } } #[doc = "Bit 7 - Initialization mode"] #[inline] pub fn init(&mut self) -> _INITW { _INITW { w: self } } #[doc = "Bit 8 - Alarm A flag"] #[inline] pub fn alraf(&mut self) -> _ALRAFW { _ALRAFW { w: self } } #[doc = "Bit 11 - Time-stamp flag"] #[inline] pub fn tsf(&mut self) -> _TSFW { _TSFW { w: self } } #[doc = "Bit 12 - Time-stamp overflow flag"] #[inline] pub fn tsovf(&mut self) -> _TSOVFW { _TSOVFW { w: self } } #[doc = "Bit 13 - RTC_TAMP1 detection flag"] #[inline] pub fn tamp1f(&mut self) -> _TAMP1FW { _TAMP1FW { w: self } } #[doc = "Bit 14 - RTC_TAMP2 detection flag"] #[inline] pub fn tamp2f(&mut self) -> _TAMP2FW { _TAMP2FW { w: self } } } } #[doc = "prescaler register"] pub struct PRER { register: ::vcell::VolatileCell, } #[doc = "prescaler register"] pub mod prer { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PRER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PREDIV_AR { bits: u8, } impl PREDIV_AR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PREDIV_SR { bits: u16, } impl PREDIV_SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PREDIV_AW<'a> { w: &'a mut W, } impl<'a> _PREDIV_AW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x7f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PREDIV_SW<'a> { w: &'a mut W, } impl<'a> _PREDIV_SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x7fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 16:22 - Asynchronous prescaler factor"] #[inline] pub fn prediv_a(&self) -> PREDIV_AR { let bits = { const MASK: u8 = 0x7f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; PREDIV_AR { bits } } #[doc = "Bits 0:14 - Synchronous prescaler factor"] #[inline] pub fn prediv_s(&self) -> PREDIV_SR { let bits = { const MASK: u16 = 0x7fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PREDIV_SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x007f_00ff } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 16:22 - Asynchronous prescaler factor"] #[inline] pub fn prediv_a(&mut self) -> _PREDIV_AW { _PREDIV_AW { w: self } } #[doc = "Bits 0:14 - Synchronous prescaler factor"] #[inline] pub fn prediv_s(&mut self) -> _PREDIV_SW { _PREDIV_SW { w: self } } } } #[doc = "alarm A register"] pub struct ALRMAR { register: ::vcell::VolatileCell, } #[doc = "alarm A register"] pub mod alrmar { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ALRMAR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MSK4R { bits: bool, } impl MSK4R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WDSELR { bits: bool, } impl WDSELR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DTR { bits: u8, } impl DTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DUR { bits: u8, } impl DUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSK3R { bits: bool, } impl MSK3R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PMR { bits: bool, } impl PMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTR { bits: u8, } impl HTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HUR { bits: u8, } impl HUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSK2R { bits: bool, } impl MSK2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MNTR { bits: u8, } impl MNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MNUR { bits: u8, } impl MNUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MSK1R { bits: bool, } impl MSK1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STR { bits: u8, } impl STR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SUR { bits: u8, } impl SUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MSK4W<'a> { w: &'a mut W, } impl<'a> _MSK4W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WDSELW<'a> { w: &'a mut W, } impl<'a> _WDSELW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 30; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DTW<'a> { w: &'a mut W, } impl<'a> _DTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 28; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DUW<'a> { w: &'a mut W, } impl<'a> _DUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSK3W<'a> { w: &'a mut W, } impl<'a> _MSK3W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PMW<'a> { w: &'a mut W, } impl<'a> _PMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HTW<'a> { w: &'a mut W, } impl<'a> _HTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _HUW<'a> { w: &'a mut W, } impl<'a> _HUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSK2W<'a> { w: &'a mut W, } impl<'a> _MSK2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MNTW<'a> { w: &'a mut W, } impl<'a> _MNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MNUW<'a> { w: &'a mut W, } impl<'a> _MNUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MSK1W<'a> { w: &'a mut W, } impl<'a> _MSK1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STW<'a> { w: &'a mut W, } impl<'a> _STW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SUW<'a> { w: &'a mut W, } impl<'a> _SUW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 31 - Alarm A date mask"] #[inline] pub fn msk4(&self) -> MSK4R { let bits = { const MASK: bool = true; const OFFSET: u8 = 31; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSK4R { bits } } #[doc = "Bit 30 - Week day selection"] #[inline] pub fn wdsel(&self) -> WDSELR { let bits = { const MASK: bool = true; const OFFSET: u8 = 30; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WDSELR { bits } } #[doc = "Bits 28:29 - Date tens in BCD format."] #[inline] pub fn dt(&self) -> DTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 28; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DTR { bits } } #[doc = "Bits 24:27 - Date units or day in BCD format."] #[inline] pub fn du(&self) -> DUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DUR { bits } } #[doc = "Bit 23 - Alarm A hours mask"] #[inline] pub fn msk3(&self) -> MSK3R { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSK3R { bits } } #[doc = "Bit 22 - AM/PM notation"] #[inline] pub fn pm(&self) -> PMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PMR { bits } } #[doc = "Bits 20:21 - Hour tens in BCD format."] #[inline] pub fn ht(&self) -> HTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HTR { bits } } #[doc = "Bits 16:19 - Hour units in BCD format."] #[inline] pub fn hu(&self) -> HUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HUR { bits } } #[doc = "Bit 15 - Alarm A minutes mask"] #[inline] pub fn msk2(&self) -> MSK2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSK2R { bits } } #[doc = "Bits 12:14 - Minute tens in BCD format."] #[inline] pub fn mnt(&self) -> MNTR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MNTR { bits } } #[doc = "Bits 8:11 - Minute units in BCD format."] #[inline] pub fn mnu(&self) -> MNUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MNUR { bits } } #[doc = "Bit 7 - Alarm A seconds mask"] #[inline] pub fn msk1(&self) -> MSK1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSK1R { bits } } #[doc = "Bits 4:6 - Second tens in BCD format."] #[inline] pub fn st(&self) -> STR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; STR { bits } } #[doc = "Bits 0:3 - Second units in BCD format."] #[inline] pub fn su(&self) -> SUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SUR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 31 - Alarm A date mask"] #[inline] pub fn msk4(&mut self) -> _MSK4W { _MSK4W { w: self } } #[doc = "Bit 30 - Week day selection"] #[inline] pub fn wdsel(&mut self) -> _WDSELW { _WDSELW { w: self } } #[doc = "Bits 28:29 - Date tens in BCD format."] #[inline] pub fn dt(&mut self) -> _DTW { _DTW { w: self } } #[doc = "Bits 24:27 - Date units or day in BCD format."] #[inline] pub fn du(&mut self) -> _DUW { _DUW { w: self } } #[doc = "Bit 23 - Alarm A hours mask"] #[inline] pub fn msk3(&mut self) -> _MSK3W { _MSK3W { w: self } } #[doc = "Bit 22 - AM/PM notation"] #[inline] pub fn pm(&mut self) -> _PMW { _PMW { w: self } } #[doc = "Bits 20:21 - Hour tens in BCD format."] #[inline] pub fn ht(&mut self) -> _HTW { _HTW { w: self } } #[doc = "Bits 16:19 - Hour units in BCD format."] #[inline] pub fn hu(&mut self) -> _HUW { _HUW { w: self } } #[doc = "Bit 15 - Alarm A minutes mask"] #[inline] pub fn msk2(&mut self) -> _MSK2W { _MSK2W { w: self } } #[doc = "Bits 12:14 - Minute tens in BCD format."] #[inline] pub fn mnt(&mut self) -> _MNTW { _MNTW { w: self } } #[doc = "Bits 8:11 - Minute units in BCD format."] #[inline] pub fn mnu(&mut self) -> _MNUW { _MNUW { w: self } } #[doc = "Bit 7 - Alarm A seconds mask"] #[inline] pub fn msk1(&mut self) -> _MSK1W { _MSK1W { w: self } } #[doc = "Bits 4:6 - Second tens in BCD format."] #[inline] pub fn st(&mut self) -> _STW { _STW { w: self } } #[doc = "Bits 0:3 - Second units in BCD format."] #[inline] pub fn su(&mut self) -> _SUW { _SUW { w: self } } } } #[doc = "write protection register"] pub struct WPR { register: ::vcell::VolatileCell, } #[doc = "write protection register"] pub mod wpr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::WPR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _KEYW<'a> { w: &'a mut W, } impl<'a> _KEYW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - Write protection key"] #[inline] pub fn key(&mut self) -> _KEYW { _KEYW { w: self } } } } #[doc = "sub second register"] pub struct SSR { register: ::vcell::VolatileCell, } #[doc = "sub second register"] pub mod ssr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::SSR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct SSR { bits: u16, } impl SSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Sub second value"] #[inline] pub fn ss(&self) -> SSR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; SSR { bits } } } } #[doc = "shift control register"] pub struct SHIFTR { register: ::vcell::VolatileCell, } #[doc = "shift control register"] pub mod shiftr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SHIFTR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _ADD1SW<'a> { w: &'a mut W, } impl<'a> _ADD1SW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 31; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SUBFSW<'a> { w: &'a mut W, } impl<'a> _SUBFSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x7fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 31 - Reserved"] #[inline] pub fn add1s(&mut self) -> _ADD1SW { _ADD1SW { w: self } } #[doc = "Bits 0:14 - Subtract a fraction of a second"] #[inline] pub fn subfs(&mut self) -> _SUBFSW { _SUBFSW { w: self } } } } #[doc = "timestamp time register"] pub struct TSTR { register: ::vcell::VolatileCell, } #[doc = "timestamp time register"] pub mod tstr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::TSTR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct PMR { bits: bool, } impl PMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct HTR { bits: u8, } impl HTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct HUR { bits: u8, } impl HUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MNTR { bits: u8, } impl MNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MNUR { bits: u8, } impl MNUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct STR { bits: u8, } impl STR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SUR { bits: u8, } impl SUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 22 - AM/PM notation"] #[inline] pub fn pm(&self) -> PMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PMR { bits } } #[doc = "Bits 20:21 - Hour tens in BCD format."] #[inline] pub fn ht(&self) -> HTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HTR { bits } } #[doc = "Bits 16:19 - Hour units in BCD format."] #[inline] pub fn hu(&self) -> HUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; HUR { bits } } #[doc = "Bits 12:14 - Minute tens in BCD format."] #[inline] pub fn mnt(&self) -> MNTR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MNTR { bits } } #[doc = "Bits 8:11 - Minute units in BCD format."] #[inline] pub fn mnu(&self) -> MNUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MNUR { bits } } #[doc = "Bits 4:6 - Second tens in BCD format."] #[inline] pub fn st(&self) -> STR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; STR { bits } } #[doc = "Bits 0:3 - Second units in BCD format."] #[inline] pub fn su(&self) -> SUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SUR { bits } } } } #[doc = "timestamp date register"] pub struct TSDR { register: ::vcell::VolatileCell, } #[doc = "timestamp date register"] pub mod tsdr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::TSDR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct WDUR { bits: u8, } impl WDUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct MTR { bits: bool, } impl MTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MUR { bits: u8, } impl MUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DTR { bits: u8, } impl DTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DUR { bits: u8, } impl DUR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 13:15 - Week day units"] #[inline] pub fn wdu(&self) -> WDUR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) as u8 }; WDUR { bits } } #[doc = "Bit 12 - Month tens in BCD format"] #[inline] pub fn mt(&self) -> MTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MTR { bits } } #[doc = "Bits 8:11 - Month units in BCD format"] #[inline] pub fn mu(&self) -> MUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MUR { bits } } #[doc = "Bits 4:5 - Date tens in BCD format"] #[inline] pub fn dt(&self) -> DTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DTR { bits } } #[doc = "Bits 0:3 - Date units in BCD format"] #[inline] pub fn du(&self) -> DUR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DUR { bits } } } } #[doc = "time-stamp sub second register"] pub struct TSSSR { register: ::vcell::VolatileCell, } #[doc = "time-stamp sub second register"] pub mod tsssr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::TSSSR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct SSR { bits: u16, } impl SSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Sub second value"] #[inline] pub fn ss(&self) -> SSR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; SSR { bits } } } } #[doc = "calibration register"] pub struct CALR { register: ::vcell::VolatileCell, } #[doc = "calibration register"] pub mod calr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CALR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CALPR { bits: bool, } impl CALPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CALW8R { bits: bool, } impl CALW8R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CALW16R { bits: bool, } impl CALW16R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CALMR { bits: u16, } impl CALMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CALPW<'a> { w: &'a mut W, } impl<'a> _CALPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CALW8W<'a> { w: &'a mut W, } impl<'a> _CALW8W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CALW16W<'a> { w: &'a mut W, } impl<'a> _CALW16W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CALMW<'a> { w: &'a mut W, } impl<'a> _CALMW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x01ff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Use an 8-second calibration cycle period"] #[inline] pub fn calp(&self) -> CALPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CALPR { bits } } #[doc = "Bit 14 - Use a 16-second calibration cycle period"] #[inline] pub fn calw8(&self) -> CALW8R { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CALW8R { bits } } #[doc = "Bit 13 - Reserved"] #[inline] pub fn calw16(&self) -> CALW16R { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CALW16R { bits } } #[doc = "Bits 0:8 - Calibration minus"] #[inline] pub fn calm(&self) -> CALMR { let bits = { const MASK: u16 = 0x01ff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CALMR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Use an 8-second calibration cycle period"] #[inline] pub fn calp(&mut self) -> _CALPW { _CALPW { w: self } } #[doc = "Bit 14 - Use a 16-second calibration cycle period"] #[inline] pub fn calw8(&mut self) -> _CALW8W { _CALW8W { w: self } } #[doc = "Bit 13 - Reserved"] #[inline] pub fn calw16(&mut self) -> _CALW16W { _CALW16W { w: self } } #[doc = "Bits 0:8 - Calibration minus"] #[inline] pub fn calm(&mut self) -> _CALMW { _CALMW { w: self } } } } #[doc = "tamper and alternate function configuration register"] pub struct TAFCR { register: ::vcell::VolatileCell, } #[doc = "tamper and alternate function configuration register"] pub mod tafcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::TAFCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PC15MODER { bits: bool, } impl PC15MODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PC15VALUER { bits: bool, } impl PC15VALUER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PC14MODER { bits: bool, } impl PC14MODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PC14VALUER { bits: bool, } impl PC14VALUER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PC13MODER { bits: bool, } impl PC13MODER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PC13VALUER { bits: bool, } impl PC13VALUER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP_PUDISR { bits: bool, } impl TAMP_PUDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP_PRCHR { bits: u8, } impl TAMP_PRCHR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct TAMPFLTR { bits: u8, } impl TAMPFLTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct TAMPFREQR { bits: u8, } impl TAMPFREQR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct TAMPTSR { bits: bool, } impl TAMPTSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP2_TRGR { bits: bool, } impl TAMP2_TRGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP2ER { bits: bool, } impl TAMP2ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMPIER { bits: bool, } impl TAMPIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP1TRGR { bits: bool, } impl TAMP1TRGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TAMP1ER { bits: bool, } impl TAMP1ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _PC15MODEW<'a> { w: &'a mut W, } impl<'a> _PC15MODEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 23; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PC15VALUEW<'a> { w: &'a mut W, } impl<'a> _PC15VALUEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 22; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PC14MODEW<'a> { w: &'a mut W, } impl<'a> _PC14MODEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PC14VALUEW<'a> { w: &'a mut W, } impl<'a> _PC14VALUEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 20; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PC13MODEW<'a> { w: &'a mut W, } impl<'a> _PC13MODEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 19; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PC13VALUEW<'a> { w: &'a mut W, } impl<'a> _PC13VALUEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP_PUDISW<'a> { w: &'a mut W, } impl<'a> _TAMP_PUDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP_PRCHW<'a> { w: &'a mut W, } impl<'a> _TAMP_PRCHW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMPFLTW<'a> { w: &'a mut W, } impl<'a> _TAMPFLTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMPFREQW<'a> { w: &'a mut W, } impl<'a> _TAMPFREQW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMPTSW<'a> { w: &'a mut W, } impl<'a> _TAMPTSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP2_TRGW<'a> { w: &'a mut W, } impl<'a> _TAMP2_TRGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP2EW<'a> { w: &'a mut W, } impl<'a> _TAMP2EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMPIEW<'a> { w: &'a mut W, } impl<'a> _TAMPIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP1TRGW<'a> { w: &'a mut W, } impl<'a> _TAMP1TRGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TAMP1EW<'a> { w: &'a mut W, } impl<'a> _TAMP1EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 23 - PC15 mode"] #[inline] pub fn pc15mode(&self) -> PC15MODER { let bits = { const MASK: bool = true; const OFFSET: u8 = 23; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PC15MODER { bits } } #[doc = "Bit 22 - PC15 value"] #[inline] pub fn pc15value(&self) -> PC15VALUER { let bits = { const MASK: bool = true; const OFFSET: u8 = 22; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PC15VALUER { bits } } #[doc = "Bit 21 - PC14 mode"] #[inline] pub fn pc14mode(&self) -> PC14MODER { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PC14MODER { bits } } #[doc = "Bit 20 - PC14 value"] #[inline] pub fn pc14value(&self) -> PC14VALUER { let bits = { const MASK: bool = true; const OFFSET: u8 = 20; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PC14VALUER { bits } } #[doc = "Bit 19 - PC13 mode"] #[inline] pub fn pc13mode(&self) -> PC13MODER { let bits = { const MASK: bool = true; const OFFSET: u8 = 19; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PC13MODER { bits } } #[doc = "Bit 18 - RTC_ALARM output type/PC13 value"] #[inline] pub fn pc13value(&self) -> PC13VALUER { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PC13VALUER { bits } } #[doc = "Bit 15 - RTC_TAMPx pull-up disable"] #[inline] pub fn tamp_pudis(&self) -> TAMP_PUDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP_PUDISR { bits } } #[doc = "Bits 13:14 - RTC_TAMPx precharge duration"] #[inline] pub fn tamp_prch(&self) -> TAMP_PRCHR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TAMP_PRCHR { bits } } #[doc = "Bits 11:12 - RTC_TAMPx filter count"] #[inline] pub fn tampflt(&self) -> TAMPFLTR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TAMPFLTR { bits } } #[doc = "Bits 8:10 - Tamper sampling frequency"] #[inline] pub fn tampfreq(&self) -> TAMPFREQR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TAMPFREQR { bits } } #[doc = "Bit 7 - Activate timestamp on tamper detection event"] #[inline] pub fn tampts(&self) -> TAMPTSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMPTSR { bits } } #[doc = "Bit 4 - Active level for RTC_TAMP2 input"] #[inline] pub fn tamp2_trg(&self) -> TAMP2_TRGR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP2_TRGR { bits } } #[doc = "Bit 3 - RTC_TAMP2 input detection enable"] #[inline] pub fn tamp2e(&self) -> TAMP2ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP2ER { bits } } #[doc = "Bit 2 - Tamper interrupt enable"] #[inline] pub fn tampie(&self) -> TAMPIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMPIER { bits } } #[doc = "Bit 1 - Active level for RTC_TAMP1 input"] #[inline] pub fn tamp1trg(&self) -> TAMP1TRGR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP1TRGR { bits } } #[doc = "Bit 0 - RTC_TAMP1 input detection enable"] #[inline] pub fn tamp1e(&self) -> TAMP1ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TAMP1ER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 23 - PC15 mode"] #[inline] pub fn pc15mode(&mut self) -> _PC15MODEW { _PC15MODEW { w: self } } #[doc = "Bit 22 - PC15 value"] #[inline] pub fn pc15value(&mut self) -> _PC15VALUEW { _PC15VALUEW { w: self } } #[doc = "Bit 21 - PC14 mode"] #[inline] pub fn pc14mode(&mut self) -> _PC14MODEW { _PC14MODEW { w: self } } #[doc = "Bit 20 - PC14 value"] #[inline] pub fn pc14value(&mut self) -> _PC14VALUEW { _PC14VALUEW { w: self } } #[doc = "Bit 19 - PC13 mode"] #[inline] pub fn pc13mode(&mut self) -> _PC13MODEW { _PC13MODEW { w: self } } #[doc = "Bit 18 - RTC_ALARM output type/PC13 value"] #[inline] pub fn pc13value(&mut self) -> _PC13VALUEW { _PC13VALUEW { w: self } } #[doc = "Bit 15 - RTC_TAMPx pull-up disable"] #[inline] pub fn tamp_pudis(&mut self) -> _TAMP_PUDISW { _TAMP_PUDISW { w: self } } #[doc = "Bits 13:14 - RTC_TAMPx precharge duration"] #[inline] pub fn tamp_prch(&mut self) -> _TAMP_PRCHW { _TAMP_PRCHW { w: self } } #[doc = "Bits 11:12 - RTC_TAMPx filter count"] #[inline] pub fn tampflt(&mut self) -> _TAMPFLTW { _TAMPFLTW { w: self } } #[doc = "Bits 8:10 - Tamper sampling frequency"] #[inline] pub fn tampfreq(&mut self) -> _TAMPFREQW { _TAMPFREQW { w: self } } #[doc = "Bit 7 - Activate timestamp on tamper detection event"] #[inline] pub fn tampts(&mut self) -> _TAMPTSW { _TAMPTSW { w: self } } #[doc = "Bit 4 - Active level for RTC_TAMP2 input"] #[inline] pub fn tamp2_trg(&mut self) -> _TAMP2_TRGW { _TAMP2_TRGW { w: self } } #[doc = "Bit 3 - RTC_TAMP2 input detection enable"] #[inline] pub fn tamp2e(&mut self) -> _TAMP2EW { _TAMP2EW { w: self } } #[doc = "Bit 2 - Tamper interrupt enable"] #[inline] pub fn tampie(&mut self) -> _TAMPIEW { _TAMPIEW { w: self } } #[doc = "Bit 1 - Active level for RTC_TAMP1 input"] #[inline] pub fn tamp1trg(&mut self) -> _TAMP1TRGW { _TAMP1TRGW { w: self } } #[doc = "Bit 0 - RTC_TAMP1 input detection enable"] #[inline] pub fn tamp1e(&mut self) -> _TAMP1EW { _TAMP1EW { w: self } } } } #[doc = "alarm A sub second register"] pub struct ALRMASSR { register: ::vcell::VolatileCell, } #[doc = "alarm A sub second register"] pub mod alrmassr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ALRMASSR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MASKSSR { bits: u8, } impl MASKSSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SSR { bits: u16, } impl SSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _MASKSSW<'a> { w: &'a mut W, } impl<'a> _MASKSSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SSW<'a> { w: &'a mut W, } impl<'a> _SSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0x7fff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 24:27 - Mask the most-significant bits starting at this bit"] #[inline] pub fn maskss(&self) -> MASKSSR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MASKSSR { bits } } #[doc = "Bits 0:14 - Sub seconds value"] #[inline] pub fn ss(&self) -> SSR { let bits = { const MASK: u16 = 0x7fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; SSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 24:27 - Mask the most-significant bits starting at this bit"] #[inline] pub fn maskss(&mut self) -> _MASKSSW { _MASKSSW { w: self } } #[doc = "Bits 0:14 - Sub seconds value"] #[inline] pub fn ss(&mut self) -> _SSW { _SSW { w: self } } } } #[doc = "backup register"] pub struct BKP0R { register: ::vcell::VolatileCell, } #[doc = "backup register"] pub mod bkp0r { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BKP0R { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BKPR { bits: u32, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; BKPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } } } #[doc = "backup register"] pub struct BKP1R { register: ::vcell::VolatileCell, } #[doc = "backup register"] pub mod bkp1r { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BKP1R { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BKPR { bits: u32, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; BKPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } } } #[doc = "backup register"] pub struct BKP2R { register: ::vcell::VolatileCell, } #[doc = "backup register"] pub mod bkp2r { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BKP2R { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BKPR { bits: u32, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; BKPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } } } #[doc = "backup register"] pub struct BKP3R { register: ::vcell::VolatileCell, } #[doc = "backup register"] pub mod bkp3r { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BKP3R { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BKPR { bits: u32, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; BKPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } } } #[doc = "backup register"] pub struct BKP4R { register: ::vcell::VolatileCell, } #[doc = "backup register"] pub mod bkp4r { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BKP4R { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct BKPR { bits: u32, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; BKPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - BKP"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } } } } #[doc = "General-purpose-timers"] pub struct TIM15 { _marker: PhantomData<*const ()>, } unsafe impl Send for TIM15 {} impl TIM15 { #[doc = r" Returns a pointer to the register block"] pub fn ptr() -> *const tim15::RegisterBlock { 0x4001_4000 as *const _ } } impl Deref for TIM15 { type Target = tim15::RegisterBlock; fn deref(&self) -> &tim15::RegisterBlock { unsafe { &*TIM15::ptr() } } } #[doc = "General-purpose-timers"] pub mod tim15 { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, #[doc = "0x04 - control register 2"] pub cr2: CR2, #[doc = "0x08 - slave mode control register"] pub smcr: SMCR, #[doc = "0x0c - DMA/Interrupt enable register"] pub dier: DIER, #[doc = "0x10 - status register"] pub sr: SR, #[doc = "0x14 - event generation register"] pub egr: EGR, #[doc = "0x18 - capture/compare mode register (output mode)"] pub ccmr1_output: CCMR1_OUTPUT, _reserved0: [u8; 4usize], #[doc = "0x20 - capture/compare enable register"] pub ccer: CCER, #[doc = "0x24 - counter"] pub cnt: CNT, #[doc = "0x28 - prescaler"] pub psc: PSC, #[doc = "0x2c - auto-reload register"] pub arr: ARR, #[doc = "0x30 - repetition counter register"] pub rcr: RCR, #[doc = "0x34 - capture/compare register 1"] pub ccr1: CCR1, #[doc = "0x38 - capture/compare register 2"] pub ccr2: CCR2, _reserved1: [u8; 8usize], #[doc = "0x44 - break and dead-time register"] pub bdtr: BDTR, #[doc = "0x48 - DMA control register"] pub dcr: DCR, #[doc = "0x4c - DMA address for full transfer"] pub dmar: DMAR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CKDR { bits: u8, } impl CKDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ARPER { bits: bool, } impl ARPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPMR { bits: bool, } impl OPMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct URSR { bits: bool, } impl URSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDISR { bits: bool, } impl UDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CENR { bits: bool, } impl CENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CKDW<'a> { w: &'a mut W, } impl<'a> _CKDW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARPEW<'a> { w: &'a mut W, } impl<'a> _ARPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPMW<'a> { w: &'a mut W, } impl<'a> _OPMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _URSW<'a> { w: &'a mut W, } impl<'a> _URSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDISW<'a> { w: &'a mut W, } impl<'a> _UDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CENW<'a> { w: &'a mut W, } impl<'a> _CENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&self) -> CKDR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CKDR { bits } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&self) -> ARPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARPER { bits } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&self) -> OPMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPMR { bits } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&self) -> URSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; URSR { bits } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&self) -> UDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDISR { bits } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&self) -> CENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&mut self) -> _CKDW { _CKDW { w: self } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&mut self) -> _ARPEW { _ARPEW { w: self } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&mut self) -> _OPMW { _OPMW { w: self } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&mut self) -> _URSW { _URSW { w: self } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&mut self) -> _UDISW { _UDISW { w: self } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&mut self) -> _CENW { _CENW { w: self } } } } #[doc = "control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OIS2R { bits: bool, } impl OIS2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS1NR { bits: bool, } impl OIS1NR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS1R { bits: bool, } impl OIS1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MMSR { bits: u8, } impl MMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CCDSR { bits: bool, } impl CCDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCUSR { bits: bool, } impl CCUSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCPCR { bits: bool, } impl CCPCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OIS2W<'a> { w: &'a mut W, } impl<'a> _OIS2W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS1NW<'a> { w: &'a mut W, } impl<'a> _OIS1NW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS1W<'a> { w: &'a mut W, } impl<'a> _OIS1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MMSW<'a> { w: &'a mut W, } impl<'a> _MMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCDSW<'a> { w: &'a mut W, } impl<'a> _CCDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCUSW<'a> { w: &'a mut W, } impl<'a> _CCUSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCPCW<'a> { w: &'a mut W, } impl<'a> _CCPCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 10 - Output Idle state 2"] #[inline] pub fn ois2(&self) -> OIS2R { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS2R { bits } } #[doc = "Bit 9 - Output Idle state 1"] #[inline] pub fn ois1n(&self) -> OIS1NR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS1NR { bits } } #[doc = "Bit 8 - Output Idle state 1"] #[inline] pub fn ois1(&self) -> OIS1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS1R { bits } } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&self) -> MMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; MMSR { bits } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&self) -> CCDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCDSR { bits } } #[doc = "Bit 2 - Capture/compare control update selection"] #[inline] pub fn ccus(&self) -> CCUSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCUSR { bits } } #[doc = "Bit 0 - Capture/compare preloaded control"] #[inline] pub fn ccpc(&self) -> CCPCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCPCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 10 - Output Idle state 2"] #[inline] pub fn ois2(&mut self) -> _OIS2W { _OIS2W { w: self } } #[doc = "Bit 9 - Output Idle state 1"] #[inline] pub fn ois1n(&mut self) -> _OIS1NW { _OIS1NW { w: self } } #[doc = "Bit 8 - Output Idle state 1"] #[inline] pub fn ois1(&mut self) -> _OIS1W { _OIS1W { w: self } } #[doc = "Bits 4:6 - Master mode selection"] #[inline] pub fn mms(&mut self) -> _MMSW { _MMSW { w: self } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&mut self) -> _CCDSW { _CCDSW { w: self } } #[doc = "Bit 2 - Capture/compare control update selection"] #[inline] pub fn ccus(&mut self) -> _CCUSW { _CCUSW { w: self } } #[doc = "Bit 0 - Capture/compare preloaded control"] #[inline] pub fn ccpc(&mut self) -> _CCPCW { _CCPCW { w: self } } } } #[doc = "slave mode control register"] pub struct SMCR { register: ::vcell::VolatileCell, } #[doc = "slave mode control register"] pub mod smcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SMCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MSMR { bits: bool, } impl MSMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TSR { bits: u8, } impl TSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct SMSR { bits: u8, } impl SMSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MSMW<'a> { w: &'a mut W, } impl<'a> _MSMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TSW<'a> { w: &'a mut W, } impl<'a> _TSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _SMSW<'a> { w: &'a mut W, } impl<'a> _SMSW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - Master/Slave mode"] #[inline] pub fn msm(&self) -> MSMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MSMR { bits } } #[doc = "Bits 4:6 - Trigger selection"] #[inline] pub fn ts(&self) -> TSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; TSR { bits } } #[doc = "Bits 0:2 - Slave mode selection"] #[inline] pub fn sms(&self) -> SMSR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; SMSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Master/Slave mode"] #[inline] pub fn msm(&mut self) -> _MSMW { _MSMW { w: self } } #[doc = "Bits 4:6 - Trigger selection"] #[inline] pub fn ts(&mut self) -> _TSW { _TSW { w: self } } #[doc = "Bits 0:2 - Slave mode selection"] #[inline] pub fn sms(&mut self) -> _SMSW { _SMSW { w: self } } } } #[doc = "DMA/Interrupt enable register"] pub struct DIER { register: ::vcell::VolatileCell, } #[doc = "DMA/Interrupt enable register"] pub mod dier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TDER { bits: bool, } impl TDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2DER { bits: bool, } impl CC2DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1DER { bits: bool, } impl CC1DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDER { bits: bool, } impl UDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIER { bits: bool, } impl BIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIER { bits: bool, } impl TIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMIER { bits: bool, } impl COMIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2IER { bits: bool, } impl CC2IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IER { bits: bool, } impl CC1IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIER { bits: bool, } impl UIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TDEW<'a> { w: &'a mut W, } impl<'a> _TDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2DEW<'a> { w: &'a mut W, } impl<'a> _CC2DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1DEW<'a> { w: &'a mut W, } impl<'a> _CC1DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDEW<'a> { w: &'a mut W, } impl<'a> _UDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIEW<'a> { w: &'a mut W, } impl<'a> _BIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIEW<'a> { w: &'a mut W, } impl<'a> _TIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMIEW<'a> { w: &'a mut W, } impl<'a> _COMIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2IEW<'a> { w: &'a mut W, } impl<'a> _CC2IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IEW<'a> { w: &'a mut W, } impl<'a> _CC1IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIEW<'a> { w: &'a mut W, } impl<'a> _UIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&self) -> TDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TDER { bits } } #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] #[inline] pub fn cc2de(&self) -> CC2DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2DER { bits } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&self) -> CC1DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1DER { bits } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&self) -> UDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDER { bits } } #[doc = "Bit 7 - Break interrupt enable"] #[inline] pub fn bie(&self) -> BIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIER { bits } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&self) -> TIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIER { bits } } #[doc = "Bit 5 - COM interrupt enable"] #[inline] pub fn comie(&self) -> COMIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMIER { bits } } #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] #[inline] pub fn cc2ie(&self) -> CC2IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2IER { bits } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&self) -> CC1IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IER { bits } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&self) -> UIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&mut self) -> _TDEW { _TDEW { w: self } } #[doc = "Bit 10 - Capture/Compare 2 DMA request enable"] #[inline] pub fn cc2de(&mut self) -> _CC2DEW { _CC2DEW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&mut self) -> _CC1DEW { _CC1DEW { w: self } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&mut self) -> _UDEW { _UDEW { w: self } } #[doc = "Bit 7 - Break interrupt enable"] #[inline] pub fn bie(&mut self) -> _BIEW { _BIEW { w: self } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&mut self) -> _TIEW { _TIEW { w: self } } #[doc = "Bit 5 - COM interrupt enable"] #[inline] pub fn comie(&mut self) -> _COMIEW { _COMIEW { w: self } } #[doc = "Bit 2 - Capture/Compare 2 interrupt enable"] #[inline] pub fn cc2ie(&mut self) -> _CC2IEW { _CC2IEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&mut self) -> _CC1IEW { _CC1IEW { w: self } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&mut self) -> _UIEW { _UIEW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC2OFR { bits: bool, } impl CC2OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1OFR { bits: bool, } impl CC1OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIFR { bits: bool, } impl BIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIFR { bits: bool, } impl TIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMIFR { bits: bool, } impl COMIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2IFR { bits: bool, } impl CC2IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IFR { bits: bool, } impl CC1IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIFR { bits: bool, } impl UIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC2OFW<'a> { w: &'a mut W, } impl<'a> _CC2OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1OFW<'a> { w: &'a mut W, } impl<'a> _CC1OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIFW<'a> { w: &'a mut W, } impl<'a> _BIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIFW<'a> { w: &'a mut W, } impl<'a> _TIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMIFW<'a> { w: &'a mut W, } impl<'a> _COMIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2IFW<'a> { w: &'a mut W, } impl<'a> _CC2IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IFW<'a> { w: &'a mut W, } impl<'a> _CC1IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIFW<'a> { w: &'a mut W, } impl<'a> _UIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] #[inline] pub fn cc2of(&self) -> CC2OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2OFR { bits } } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&self) -> CC1OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1OFR { bits } } #[doc = "Bit 7 - Break interrupt flag"] #[inline] pub fn bif(&self) -> BIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIFR { bits } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&self) -> TIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIFR { bits } } #[doc = "Bit 5 - COM interrupt flag"] #[inline] pub fn comif(&self) -> COMIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMIFR { bits } } #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] #[inline] pub fn cc2if(&self) -> CC2IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2IFR { bits } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&self) -> CC1IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IFR { bits } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&self) -> UIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 10 - Capture/compare 2 overcapture flag"] #[inline] pub fn cc2of(&mut self) -> _CC2OFW { _CC2OFW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&mut self) -> _CC1OFW { _CC1OFW { w: self } } #[doc = "Bit 7 - Break interrupt flag"] #[inline] pub fn bif(&mut self) -> _BIFW { _BIFW { w: self } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&mut self) -> _TIFW { _TIFW { w: self } } #[doc = "Bit 5 - COM interrupt flag"] #[inline] pub fn comif(&mut self) -> _COMIFW { _COMIFW { w: self } } #[doc = "Bit 2 - Capture/Compare 2 interrupt flag"] #[inline] pub fn cc2if(&mut self) -> _CC2IFW { _CC2IFW { w: self } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&mut self) -> _CC1IFW { _CC1IFW { w: self } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&mut self) -> _UIFW { _UIFW { w: self } } } } #[doc = "event generation register"] pub struct EGR { register: ::vcell::VolatileCell, } #[doc = "event generation register"] pub mod egr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EGR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BGW<'a> { w: &'a mut W, } impl<'a> _BGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TGW<'a> { w: &'a mut W, } impl<'a> _TGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMGW<'a> { w: &'a mut W, } impl<'a> _COMGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2GW<'a> { w: &'a mut W, } impl<'a> _CC2GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1GW<'a> { w: &'a mut W, } impl<'a> _CC1GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UGW<'a> { w: &'a mut W, } impl<'a> _UGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Break generation"] #[inline] pub fn bg(&mut self) -> _BGW { _BGW { w: self } } #[doc = "Bit 6 - Trigger generation"] #[inline] pub fn tg(&mut self) -> _TGW { _TGW { w: self } } #[doc = "Bit 5 - Capture/Compare control update generation"] #[inline] pub fn comg(&mut self) -> _COMGW { _COMGW { w: self } } #[doc = "Bit 2 - Capture/compare 2 generation"] #[inline] pub fn cc2g(&mut self) -> _CC2GW { _CC2GW { w: self } } #[doc = "Bit 1 - Capture/compare 1 generation"] #[inline] pub fn cc1g(&mut self) -> _CC1GW { _CC1GW { w: self } } #[doc = "Bit 0 - Update generation"] #[inline] pub fn ug(&mut self) -> _UGW { _UGW { w: self } } } } #[doc = "capture/compare mode register (output mode)"] pub struct CCMR1_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register (output mode)"] pub mod ccmr1_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OC2MR { bits: u8, } impl OC2MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC2PER { bits: bool, } impl OC2PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC2FER { bits: bool, } impl OC2FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2SR { bits: u8, } impl CC2SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1MR { bits: u8, } impl OC1MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1PER { bits: bool, } impl OC1PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1FER { bits: bool, } impl OC1FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OC2MW<'a> { w: &'a mut W, } impl<'a> _OC2MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2PEW<'a> { w: &'a mut W, } impl<'a> _OC2PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC2FEW<'a> { w: &'a mut W, } impl<'a> _OC2FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2SW<'a> { w: &'a mut W, } impl<'a> _CC2SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1MW<'a> { w: &'a mut W, } impl<'a> _OC1MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1PEW<'a> { w: &'a mut W, } impl<'a> _OC1PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1FEW<'a> { w: &'a mut W, } impl<'a> _OC1FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:14 - Output Compare 2 mode"] #[inline] pub fn oc2m(&self) -> OC2MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC2MR { bits } } #[doc = "Bit 11 - Output Compare 2 preload enable"] #[inline] pub fn oc2pe(&self) -> OC2PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2PER { bits } } #[doc = "Bit 10 - Output Compare 2 fast enable"] #[inline] pub fn oc2fe(&self) -> OC2FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC2FER { bits } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&self) -> CC2SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC2SR { bits } } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&self) -> OC1MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC1MR { bits } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&self) -> OC1PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1PER { bits } } #[doc = "Bit 2 - Output Compare 1 fast enable"] #[inline] pub fn oc1fe(&self) -> OC1FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1FER { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:14 - Output Compare 2 mode"] #[inline] pub fn oc2m(&mut self) -> _OC2MW { _OC2MW { w: self } } #[doc = "Bit 11 - Output Compare 2 preload enable"] #[inline] pub fn oc2pe(&mut self) -> _OC2PEW { _OC2PEW { w: self } } #[doc = "Bit 10 - Output Compare 2 fast enable"] #[inline] pub fn oc2fe(&mut self) -> _OC2FEW { _OC2FEW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&mut self) -> _CC2SW { _CC2SW { w: self } } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&mut self) -> _OC1MW { _OC1MW { w: self } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&mut self) -> _OC1PEW { _OC1PEW { w: self } } #[doc = "Bit 2 - Output Compare 1 fast enable"] #[inline] pub fn oc1fe(&mut self) -> _OC1FEW { _OC1FEW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare mode register 1 (input mode)"] pub struct CCMR1_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 1 (input mode)"] pub mod ccmr1_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC2FR { bits: u8, } impl IC2FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC2PSCR { bits: u8, } impl IC2PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC2SR { bits: u8, } impl CC2SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1FR { bits: u8, } impl IC1FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1PSCR { bits: u8, } impl IC1PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC2FW<'a> { w: &'a mut W, } impl<'a> _IC2FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC2PSCW<'a> { w: &'a mut W, } impl<'a> _IC2PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2SW<'a> { w: &'a mut W, } impl<'a> _CC2SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1FW<'a> { w: &'a mut W, } impl<'a> _IC1FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1PSCW<'a> { w: &'a mut W, } impl<'a> _IC1PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 12:15 - Input capture 2 filter"] #[inline] pub fn ic2f(&self) -> IC2FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC2FR { bits } } #[doc = "Bits 10:11 - Input capture 2 prescaler"] #[inline] pub fn ic2psc(&self) -> IC2PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC2PSCR { bits } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&self) -> CC2SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC2SR { bits } } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&self) -> IC1FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1FR { bits } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&self) -> IC1PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1PSCR { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 12:15 - Input capture 2 filter"] #[inline] pub fn ic2f(&mut self) -> _IC2FW { _IC2FW { w: self } } #[doc = "Bits 10:11 - Input capture 2 prescaler"] #[inline] pub fn ic2psc(&mut self) -> _IC2PSCW { _IC2PSCW { w: self } } #[doc = "Bits 8:9 - Capture/Compare 2 selection"] #[inline] pub fn cc2s(&mut self) -> _CC2SW { _CC2SW { w: self } } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&mut self) -> _IC1FW { _IC1FW { w: self } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&mut self) -> _IC1PSCW { _IC1PSCW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare enable register"] pub struct CCER { register: ::vcell::VolatileCell, } #[doc = "capture/compare enable register"] pub mod ccer { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC2NPR { bits: bool, } impl CC2NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2PR { bits: bool, } impl CC2PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC2ER { bits: bool, } impl CC2ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1NPR { bits: bool, } impl CC1NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1NER { bits: bool, } impl CC1NER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1PR { bits: bool, } impl CC1PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1ER { bits: bool, } impl CC1ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC2NPW<'a> { w: &'a mut W, } impl<'a> _CC2NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2PW<'a> { w: &'a mut W, } impl<'a> _CC2PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC2EW<'a> { w: &'a mut W, } impl<'a> _CC2EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1NPW<'a> { w: &'a mut W, } impl<'a> _CC1NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1NEW<'a> { w: &'a mut W, } impl<'a> _CC1NEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1PW<'a> { w: &'a mut W, } impl<'a> _CC1PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1EW<'a> { w: &'a mut W, } impl<'a> _CC1EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2np(&self) -> CC2NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2NPR { bits } } #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2p(&self) -> CC2PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2PR { bits } } #[doc = "Bit 4 - Capture/Compare 2 output enable"] #[inline] pub fn cc2e(&self) -> CC2ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC2ER { bits } } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&self) -> CC1NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NPR { bits } } #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] #[inline] pub fn cc1ne(&self) -> CC1NER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NER { bits } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&self) -> CC1PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1PR { bits } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&self) -> CC1ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1ER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2np(&mut self) -> _CC2NPW { _CC2NPW { w: self } } #[doc = "Bit 5 - Capture/Compare 2 output Polarity"] #[inline] pub fn cc2p(&mut self) -> _CC2PW { _CC2PW { w: self } } #[doc = "Bit 4 - Capture/Compare 2 output enable"] #[inline] pub fn cc2e(&mut self) -> _CC2EW { _CC2EW { w: self } } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&mut self) -> _CC1NPW { _CC1NPW { w: self } } #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] #[inline] pub fn cc1ne(&mut self) -> _CC1NEW { _CC1NEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&mut self) -> _CC1PW { _CC1PW { w: self } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&mut self) -> _CC1EW { _CC1EW { w: self } } } } #[doc = "counter"] pub struct CNT { register: ::vcell::VolatileCell, } #[doc = "counter"] pub mod cnt { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CNTR { bits: u16, } impl CNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CNTW<'a> { w: &'a mut W, } impl<'a> _CNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&self) -> CNTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&mut self) -> _CNTW { _CNTW { w: self } } } } #[doc = "prescaler"] pub struct PSC { register: ::vcell::VolatileCell, } #[doc = "prescaler"] pub mod psc { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PSC { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PSCR { bits: u16, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "auto-reload register"] pub struct ARR { register: ::vcell::VolatileCell, } #[doc = "auto-reload register"] pub mod arr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ARR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARRR { bits: u16, } impl ARRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _ARRW<'a> { w: &'a mut W, } impl<'a> _ARRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&self) -> ARRR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&mut self) -> _ARRW { _ARRW { w: self } } } } #[doc = "repetition counter register"] pub struct RCR { register: ::vcell::VolatileCell, } #[doc = "repetition counter register"] pub mod rcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct REPR { bits: u8, } impl REPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _REPW<'a> { w: &'a mut W, } impl<'a> _REPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - Repetition counter value"] #[inline] pub fn rep(&self) -> REPR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; REPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - Repetition counter value"] #[inline] pub fn rep(&mut self) -> _REPW { _REPW { w: self } } } } #[doc = "capture/compare register 1"] pub struct CCR1 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 1"] pub mod ccr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR1R { bits: u16, } impl CCR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR1W<'a> { w: &'a mut W, } impl<'a> _CCR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&self) -> CCR1R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR1R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&mut self) -> _CCR1W { _CCR1W { w: self } } } } #[doc = "capture/compare register 2"] pub struct CCR2 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 2"] pub mod ccr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR2R { bits: u16, } impl CCR2R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR2W<'a> { w: &'a mut W, } impl<'a> _CCR2W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 2 value"] #[inline] pub fn ccr2(&self) -> CCR2R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR2R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 2 value"] #[inline] pub fn ccr2(&mut self) -> _CCR2W { _CCR2W { w: self } } } } #[doc = "break and dead-time register"] pub struct BDTR { register: ::vcell::VolatileCell, } #[doc = "break and dead-time register"] pub mod bdtr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BDTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MOER { bits: bool, } impl MOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AOER { bits: bool, } impl AOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKPR { bits: bool, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKER { bits: bool, } impl BKER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSSRR { bits: bool, } impl OSSRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSSIR { bits: bool, } impl OSSIR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LOCKR { bits: u8, } impl LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DTGR { bits: u8, } impl DTGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MOEW<'a> { w: &'a mut W, } impl<'a> _MOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AOEW<'a> { w: &'a mut W, } impl<'a> _AOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKEW<'a> { w: &'a mut W, } impl<'a> _BKEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSSRW<'a> { w: &'a mut W, } impl<'a> _OSSRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSSIW<'a> { w: &'a mut W, } impl<'a> _OSSIW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LOCKW<'a> { w: &'a mut W, } impl<'a> _LOCKW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DTGW<'a> { w: &'a mut W, } impl<'a> _DTGW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Main output enable"] #[inline] pub fn moe(&self) -> MOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MOER { bits } } #[doc = "Bit 14 - Automatic output enable"] #[inline] pub fn aoe(&self) -> AOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AOER { bits } } #[doc = "Bit 13 - Break polarity"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKPR { bits } } #[doc = "Bit 12 - Break enable"] #[inline] pub fn bke(&self) -> BKER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKER { bits } } #[doc = "Bit 11 - Off-state selection for Run mode"] #[inline] pub fn ossr(&self) -> OSSRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OSSRR { bits } } #[doc = "Bit 10 - Off-state selection for Idle mode"] #[inline] pub fn ossi(&self) -> OSSIR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OSSIR { bits } } #[doc = "Bits 8:9 - Lock configuration"] #[inline] pub fn lock(&self) -> LOCKR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; LOCKR { bits } } #[doc = "Bits 0:7 - Dead-time generator setup"] #[inline] pub fn dtg(&self) -> DTGR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DTGR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Main output enable"] #[inline] pub fn moe(&mut self) -> _MOEW { _MOEW { w: self } } #[doc = "Bit 14 - Automatic output enable"] #[inline] pub fn aoe(&mut self) -> _AOEW { _AOEW { w: self } } #[doc = "Bit 13 - Break polarity"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } #[doc = "Bit 12 - Break enable"] #[inline] pub fn bke(&mut self) -> _BKEW { _BKEW { w: self } } #[doc = "Bit 11 - Off-state selection for Run mode"] #[inline] pub fn ossr(&mut self) -> _OSSRW { _OSSRW { w: self } } #[doc = "Bit 10 - Off-state selection for Idle mode"] #[inline] pub fn ossi(&mut self) -> _OSSIW { _OSSIW { w: self } } #[doc = "Bits 8:9 - Lock configuration"] #[inline] pub fn lock(&mut self) -> _LOCKW { _LOCKW { w: self } } #[doc = "Bits 0:7 - Dead-time generator setup"] #[inline] pub fn dtg(&mut self) -> _DTGW { _DTGW { w: self } } } } #[doc = "DMA control register"] pub struct DCR { register: ::vcell::VolatileCell, } #[doc = "DMA control register"] pub mod dcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBLR { bits: u8, } impl DBLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DBAR { bits: u8, } impl DBAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _DBLW<'a> { w: &'a mut W, } impl<'a> _DBLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBAW<'a> { w: &'a mut W, } impl<'a> _DBAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&self) -> DBLR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBLR { bits } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&self) -> DBAR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&mut self) -> _DBLW { _DBLW { w: self } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&mut self) -> _DBAW { _DBAW { w: self } } } } #[doc = "DMA address for full transfer"] pub struct DMAR { register: ::vcell::VolatileCell, } #[doc = "DMA address for full transfer"] pub mod dmar { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DMAR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DMABR { bits: u16, } impl DMABR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _DMABW<'a> { w: &'a mut W, } impl<'a> _DMABW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmab(&self) -> DMABR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DMABR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmab(&mut self) -> _DMABW { _DMABW { w: self } } } } } #[doc = "General-purpose-timers"] pub struct TIM16 { _marker: PhantomData<*const ()>, } unsafe impl Send for TIM16 {} impl TIM16 { #[doc = r" Returns a pointer to the register block"] pub fn ptr() -> *const tim16::RegisterBlock { 0x4001_4400 as *const _ } } impl Deref for TIM16 { type Target = tim16::RegisterBlock; fn deref(&self) -> &tim16::RegisterBlock { unsafe { &*TIM16::ptr() } } } #[doc = "General-purpose-timers"] pub mod tim16 { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - control register 1"] pub cr1: CR1, #[doc = "0x04 - control register 2"] pub cr2: CR2, _reserved0: [u8; 4usize], #[doc = "0x0c - DMA/Interrupt enable register"] pub dier: DIER, #[doc = "0x10 - status register"] pub sr: SR, #[doc = "0x14 - event generation register"] pub egr: EGR, #[doc = "0x18 - capture/compare mode register (output mode)"] pub ccmr1_output: CCMR1_OUTPUT, _reserved1: [u8; 4usize], #[doc = "0x20 - capture/compare enable register"] pub ccer: CCER, #[doc = "0x24 - counter"] pub cnt: CNT, #[doc = "0x28 - prescaler"] pub psc: PSC, #[doc = "0x2c - auto-reload register"] pub arr: ARR, #[doc = "0x30 - repetition counter register"] pub rcr: RCR, #[doc = "0x34 - capture/compare register 1"] pub ccr1: CCR1, _reserved2: [u8; 12usize], #[doc = "0x44 - break and dead-time register"] pub bdtr: BDTR, #[doc = "0x48 - DMA control register"] pub dcr: DCR, #[doc = "0x4c - DMA address for full transfer"] pub dmar: DMAR, } #[doc = "control register 1"] pub struct CR1 { register: ::vcell::VolatileCell, } #[doc = "control register 1"] pub mod cr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CKDR { bits: u8, } impl CKDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct ARPER { bits: bool, } impl ARPER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPMR { bits: bool, } impl OPMR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct URSR { bits: bool, } impl URSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDISR { bits: bool, } impl UDISR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CENR { bits: bool, } impl CENR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CKDW<'a> { w: &'a mut W, } impl<'a> _CKDW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ARPEW<'a> { w: &'a mut W, } impl<'a> _ARPEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPMW<'a> { w: &'a mut W, } impl<'a> _OPMW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _URSW<'a> { w: &'a mut W, } impl<'a> _URSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDISW<'a> { w: &'a mut W, } impl<'a> _UDISW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CENW<'a> { w: &'a mut W, } impl<'a> _CENW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&self) -> CKDR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CKDR { bits } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&self) -> ARPER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ARPER { bits } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&self) -> OPMR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPMR { bits } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&self) -> URSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; URSR { bits } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&self) -> UDISR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDISR { bits } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&self) -> CENR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CENR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:9 - Clock division"] #[inline] pub fn ckd(&mut self) -> _CKDW { _CKDW { w: self } } #[doc = "Bit 7 - Auto-reload preload enable"] #[inline] pub fn arpe(&mut self) -> _ARPEW { _ARPEW { w: self } } #[doc = "Bit 3 - One-pulse mode"] #[inline] pub fn opm(&mut self) -> _OPMW { _OPMW { w: self } } #[doc = "Bit 2 - Update request source"] #[inline] pub fn urs(&mut self) -> _URSW { _URSW { w: self } } #[doc = "Bit 1 - Update disable"] #[inline] pub fn udis(&mut self) -> _UDISW { _UDISW { w: self } } #[doc = "Bit 0 - Counter enable"] #[inline] pub fn cen(&mut self) -> _CENW { _CENW { w: self } } } } #[doc = "control register 2"] pub struct CR2 { register: ::vcell::VolatileCell, } #[doc = "control register 2"] pub mod cr2 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR2 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OIS1NR { bits: bool, } impl OIS1NR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OIS1R { bits: bool, } impl OIS1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCDSR { bits: bool, } impl CCDSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCUSR { bits: bool, } impl CCUSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CCPCR { bits: bool, } impl CCPCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _OIS1NW<'a> { w: &'a mut W, } impl<'a> _OIS1NW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OIS1W<'a> { w: &'a mut W, } impl<'a> _OIS1W<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCDSW<'a> { w: &'a mut W, } impl<'a> _CCDSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCUSW<'a> { w: &'a mut W, } impl<'a> _CCUSW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CCPCW<'a> { w: &'a mut W, } impl<'a> _CCPCW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Output Idle state 1"] #[inline] pub fn ois1n(&self) -> OIS1NR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS1NR { bits } } #[doc = "Bit 8 - Output Idle state 1"] #[inline] pub fn ois1(&self) -> OIS1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OIS1R { bits } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&self) -> CCDSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCDSR { bits } } #[doc = "Bit 2 - Capture/compare control update selection"] #[inline] pub fn ccus(&self) -> CCUSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCUSR { bits } } #[doc = "Bit 0 - Capture/compare preloaded control"] #[inline] pub fn ccpc(&self) -> CCPCR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CCPCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Output Idle state 1"] #[inline] pub fn ois1n(&mut self) -> _OIS1NW { _OIS1NW { w: self } } #[doc = "Bit 8 - Output Idle state 1"] #[inline] pub fn ois1(&mut self) -> _OIS1W { _OIS1W { w: self } } #[doc = "Bit 3 - Capture/compare DMA selection"] #[inline] pub fn ccds(&mut self) -> _CCDSW { _CCDSW { w: self } } #[doc = "Bit 2 - Capture/compare control update selection"] #[inline] pub fn ccus(&mut self) -> _CCUSW { _CCUSW { w: self } } #[doc = "Bit 0 - Capture/compare preloaded control"] #[inline] pub fn ccpc(&mut self) -> _CCPCW { _CCPCW { w: self } } } } #[doc = "DMA/Interrupt enable register"] pub struct DIER { register: ::vcell::VolatileCell, } #[doc = "DMA/Interrupt enable register"] pub mod dier { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DIER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct TDER { bits: bool, } impl TDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1DER { bits: bool, } impl CC1DER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UDER { bits: bool, } impl UDER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIER { bits: bool, } impl BIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIER { bits: bool, } impl TIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMIER { bits: bool, } impl COMIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IER { bits: bool, } impl CC1IER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIER { bits: bool, } impl UIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _TDEW<'a> { w: &'a mut W, } impl<'a> _TDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1DEW<'a> { w: &'a mut W, } impl<'a> _CC1DEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UDEW<'a> { w: &'a mut W, } impl<'a> _UDEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIEW<'a> { w: &'a mut W, } impl<'a> _BIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIEW<'a> { w: &'a mut W, } impl<'a> _TIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMIEW<'a> { w: &'a mut W, } impl<'a> _COMIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IEW<'a> { w: &'a mut W, } impl<'a> _CC1IEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIEW<'a> { w: &'a mut W, } impl<'a> _UIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&self) -> TDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TDER { bits } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&self) -> CC1DER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1DER { bits } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&self) -> UDER { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UDER { bits } } #[doc = "Bit 7 - Break interrupt enable"] #[inline] pub fn bie(&self) -> BIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIER { bits } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&self) -> TIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIER { bits } } #[doc = "Bit 5 - COM interrupt enable"] #[inline] pub fn comie(&self) -> COMIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMIER { bits } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&self) -> CC1IER { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IER { bits } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&self) -> UIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 14 - Trigger DMA request enable"] #[inline] pub fn tde(&mut self) -> _TDEW { _TDEW { w: self } } #[doc = "Bit 9 - Capture/Compare 1 DMA request enable"] #[inline] pub fn cc1de(&mut self) -> _CC1DEW { _CC1DEW { w: self } } #[doc = "Bit 8 - Update DMA request enable"] #[inline] pub fn ude(&mut self) -> _UDEW { _UDEW { w: self } } #[doc = "Bit 7 - Break interrupt enable"] #[inline] pub fn bie(&mut self) -> _BIEW { _BIEW { w: self } } #[doc = "Bit 6 - Trigger interrupt enable"] #[inline] pub fn tie(&mut self) -> _TIEW { _TIEW { w: self } } #[doc = "Bit 5 - COM interrupt enable"] #[inline] pub fn comie(&mut self) -> _COMIEW { _COMIEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 interrupt enable"] #[inline] pub fn cc1ie(&mut self) -> _CC1IEW { _CC1IEW { w: self } } #[doc = "Bit 0 - Update interrupt enable"] #[inline] pub fn uie(&mut self) -> _UIEW { _UIEW { w: self } } } } #[doc = "status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC1OFR { bits: bool, } impl CC1OFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BIFR { bits: bool, } impl BIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct TIFR { bits: bool, } impl TIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct COMIFR { bits: bool, } impl COMIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1IFR { bits: bool, } impl CC1IFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct UIFR { bits: bool, } impl UIFR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC1OFW<'a> { w: &'a mut W, } impl<'a> _CC1OFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BIFW<'a> { w: &'a mut W, } impl<'a> _BIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TIFW<'a> { w: &'a mut W, } impl<'a> _TIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMIFW<'a> { w: &'a mut W, } impl<'a> _COMIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1IFW<'a> { w: &'a mut W, } impl<'a> _CC1IFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UIFW<'a> { w: &'a mut W, } impl<'a> _UIFW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&self) -> CC1OFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1OFR { bits } } #[doc = "Bit 7 - Break interrupt flag"] #[inline] pub fn bif(&self) -> BIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BIFR { bits } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&self) -> TIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; TIFR { bits } } #[doc = "Bit 5 - COM interrupt flag"] #[inline] pub fn comif(&self) -> COMIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; COMIFR { bits } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&self) -> CC1IFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1IFR { bits } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&self) -> UIFR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; UIFR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 9 - Capture/Compare 1 overcapture flag"] #[inline] pub fn cc1of(&mut self) -> _CC1OFW { _CC1OFW { w: self } } #[doc = "Bit 7 - Break interrupt flag"] #[inline] pub fn bif(&mut self) -> _BIFW { _BIFW { w: self } } #[doc = "Bit 6 - Trigger interrupt flag"] #[inline] pub fn tif(&mut self) -> _TIFW { _TIFW { w: self } } #[doc = "Bit 5 - COM interrupt flag"] #[inline] pub fn comif(&mut self) -> _COMIFW { _COMIFW { w: self } } #[doc = "Bit 1 - Capture/compare 1 interrupt flag"] #[inline] pub fn cc1if(&mut self) -> _CC1IFW { _CC1IFW { w: self } } #[doc = "Bit 0 - Update interrupt flag"] #[inline] pub fn uif(&mut self) -> _UIFW { _UIFW { w: self } } } } #[doc = "event generation register"] pub struct EGR { register: ::vcell::VolatileCell, } #[doc = "event generation register"] pub mod egr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::EGR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _BGW<'a> { w: &'a mut W, } impl<'a> _BGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _TGW<'a> { w: &'a mut W, } impl<'a> _TGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _COMGW<'a> { w: &'a mut W, } impl<'a> _COMGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1GW<'a> { w: &'a mut W, } impl<'a> _CC1GW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _UGW<'a> { w: &'a mut W, } impl<'a> _UGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 7 - Break generation"] #[inline] pub fn bg(&mut self) -> _BGW { _BGW { w: self } } #[doc = "Bit 6 - Trigger generation"] #[inline] pub fn tg(&mut self) -> _TGW { _TGW { w: self } } #[doc = "Bit 5 - Capture/Compare control update generation"] #[inline] pub fn comg(&mut self) -> _COMGW { _COMGW { w: self } } #[doc = "Bit 1 - Capture/compare 1 generation"] #[inline] pub fn cc1g(&mut self) -> _CC1GW { _CC1GW { w: self } } #[doc = "Bit 0 - Update generation"] #[inline] pub fn ug(&mut self) -> _UGW { _UGW { w: self } } } } #[doc = "capture/compare mode register (output mode)"] pub struct CCMR1_OUTPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register (output mode)"] pub mod ccmr1_output { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_OUTPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct OC1MR { bits: u8, } impl OC1MR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct OC1PER { bits: bool, } impl OC1PER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OC1FER { bits: bool, } impl OC1FER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _OC1MW<'a> { w: &'a mut W, } impl<'a> _OC1MW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1PEW<'a> { w: &'a mut W, } impl<'a> _OC1PEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OC1FEW<'a> { w: &'a mut W, } impl<'a> _OC1FEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&self) -> OC1MR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; OC1MR { bits } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&self) -> OC1PER { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1PER { bits } } #[doc = "Bit 2 - Output Compare 1 fast enable"] #[inline] pub fn oc1fe(&self) -> OC1FER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OC1FER { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 4:6 - Output Compare 1 mode"] #[inline] pub fn oc1m(&mut self) -> _OC1MW { _OC1MW { w: self } } #[doc = "Bit 3 - Output Compare 1 preload enable"] #[inline] pub fn oc1pe(&mut self) -> _OC1PEW { _OC1PEW { w: self } } #[doc = "Bit 2 - Output Compare 1 fast enable"] #[inline] pub fn oc1fe(&mut self) -> _OC1FEW { _OC1FEW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare mode register 1 (input mode)"] pub struct CCMR1_INPUT { register: ::vcell::VolatileCell, } #[doc = "capture/compare mode register 1 (input mode)"] pub mod ccmr1_input { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCMR1_INPUT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct IC1FR { bits: u8, } impl IC1FR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct IC1PSCR { bits: u8, } impl IC1PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct CC1SR { bits: u8, } impl CC1SR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _IC1FW<'a> { w: &'a mut W, } impl<'a> _IC1FW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _IC1PSCW<'a> { w: &'a mut W, } impl<'a> _IC1PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1SW<'a> { w: &'a mut W, } impl<'a> _CC1SW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&self) -> IC1FR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1FR { bits } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&self) -> IC1PSCR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) as u8 }; IC1PSCR { bits } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&self) -> CC1SR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; CC1SR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 4:7 - Input capture 1 filter"] #[inline] pub fn ic1f(&mut self) -> _IC1FW { _IC1FW { w: self } } #[doc = "Bits 2:3 - Input capture 1 prescaler"] #[inline] pub fn ic1psc(&mut self) -> _IC1PSCW { _IC1PSCW { w: self } } #[doc = "Bits 0:1 - Capture/Compare 1 selection"] #[inline] pub fn cc1s(&mut self) -> _CC1SW { _CC1SW { w: self } } } } #[doc = "capture/compare enable register"] pub struct CCER { register: ::vcell::VolatileCell, } #[doc = "capture/compare enable register"] pub mod ccer { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCER { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CC1NPR { bits: bool, } impl CC1NPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1NER { bits: bool, } impl CC1NER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1PR { bits: bool, } impl CC1PR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct CC1ER { bits: bool, } impl CC1ER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _CC1NPW<'a> { w: &'a mut W, } impl<'a> _CC1NPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 3; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1NEW<'a> { w: &'a mut W, } impl<'a> _CC1NEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1PW<'a> { w: &'a mut W, } impl<'a> _CC1PW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _CC1EW<'a> { w: &'a mut W, } impl<'a> _CC1EW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&self) -> CC1NPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 3; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NPR { bits } } #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] #[inline] pub fn cc1ne(&self) -> CC1NER { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1NER { bits } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&self) -> CC1PR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1PR { bits } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&self) -> CC1ER { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; CC1ER { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 3 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1np(&mut self) -> _CC1NPW { _CC1NPW { w: self } } #[doc = "Bit 2 - Capture/Compare 1 complementary output enable"] #[inline] pub fn cc1ne(&mut self) -> _CC1NEW { _CC1NEW { w: self } } #[doc = "Bit 1 - Capture/Compare 1 output Polarity"] #[inline] pub fn cc1p(&mut self) -> _CC1PW { _CC1PW { w: self } } #[doc = "Bit 0 - Capture/Compare 1 output enable"] #[inline] pub fn cc1e(&mut self) -> _CC1EW { _CC1EW { w: self } } } } #[doc = "counter"] pub struct CNT { register: ::vcell::VolatileCell, } #[doc = "counter"] pub mod cnt { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CNT { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CNTR { bits: u16, } impl CNTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CNTW<'a> { w: &'a mut W, } impl<'a> _CNTW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&self) -> CNTR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CNTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - counter value"] #[inline] pub fn cnt(&mut self) -> _CNTW { _CNTW { w: self } } } } #[doc = "prescaler"] pub struct PSC { register: ::vcell::VolatileCell, } #[doc = "prescaler"] pub mod psc { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::PSC { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct PSCR { bits: u16, } impl PSCR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _PSCW<'a> { w: &'a mut W, } impl<'a> _PSCW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&self) -> PSCR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; PSCR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Prescaler value"] #[inline] pub fn psc(&mut self) -> _PSCW { _PSCW { w: self } } } } #[doc = "auto-reload register"] pub struct ARR { register: ::vcell::VolatileCell, } #[doc = "auto-reload register"] pub mod arr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ARR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct ARRR { bits: u16, } impl ARRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _ARRW<'a> { w: &'a mut W, } impl<'a> _ARRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&self) -> ARRR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; ARRR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Auto-reload value"] #[inline] pub fn arr(&mut self) -> _ARRW { _ARRW { w: self } } } } #[doc = "repetition counter register"] pub struct RCR { register: ::vcell::VolatileCell, } #[doc = "repetition counter register"] pub mod rcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::RCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct REPR { bits: u8, } impl REPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _REPW<'a> { w: &'a mut W, } impl<'a> _REPW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:7 - Repetition counter value"] #[inline] pub fn rep(&self) -> REPR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; REPR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:7 - Repetition counter value"] #[inline] pub fn rep(&mut self) -> _REPW { _REPW { w: self } } } } #[doc = "capture/compare register 1"] pub struct CCR1 { register: ::vcell::VolatileCell, } #[doc = "capture/compare register 1"] pub mod ccr1 { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CCR1 { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct CCR1R { bits: u16, } impl CCR1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _CCR1W<'a> { w: &'a mut W, } impl<'a> _CCR1W<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&self) -> CCR1R { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; CCR1R { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - Capture/Compare 1 value"] #[inline] pub fn ccr1(&mut self) -> _CCR1W { _CCR1W { w: self } } } } #[doc = "break and dead-time register"] pub struct BDTR { register: ::vcell::VolatileCell, } #[doc = "break and dead-time register"] pub mod bdtr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::BDTR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct MOER { bits: bool, } impl MOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct AOER { bits: bool, } impl AOER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKPR { bits: bool, } impl BKPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BKER { bits: bool, } impl BKER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSSRR { bits: bool, } impl OSSRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OSSIR { bits: bool, } impl OSSIR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LOCKR { bits: u8, } impl LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DTGR { bits: u8, } impl DTGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _MOEW<'a> { w: &'a mut W, } impl<'a> _MOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 15; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _AOEW<'a> { w: &'a mut W, } impl<'a> _AOEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 14; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKPW<'a> { w: &'a mut W, } impl<'a> _BKPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _BKEW<'a> { w: &'a mut W, } impl<'a> _BKEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSSRW<'a> { w: &'a mut W, } impl<'a> _OSSRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OSSIW<'a> { w: &'a mut W, } impl<'a> _OSSIW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LOCKW<'a> { w: &'a mut W, } impl<'a> _LOCKW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x03; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DTGW<'a> { w: &'a mut W, } impl<'a> _DTGW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0xff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 15 - Main output enable"] #[inline] pub fn moe(&self) -> MOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 15; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MOER { bits } } #[doc = "Bit 14 - Automatic output enable"] #[inline] pub fn aoe(&self) -> AOER { let bits = { const MASK: bool = true; const OFFSET: u8 = 14; ((self.bits >> OFFSET) & MASK as u32) != 0 }; AOER { bits } } #[doc = "Bit 13 - Break polarity"] #[inline] pub fn bkp(&self) -> BKPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKPR { bits } } #[doc = "Bit 12 - Break enable"] #[inline] pub fn bke(&self) -> BKER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BKER { bits } } #[doc = "Bit 11 - Off-state selection for Run mode"] #[inline] pub fn ossr(&self) -> OSSRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OSSRR { bits } } #[doc = "Bit 10 - Off-state selection for Idle mode"] #[inline] pub fn ossi(&self) -> OSSIR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OSSIR { bits } } #[doc = "Bits 8:9 - Lock configuration"] #[inline] pub fn lock(&self) -> LOCKR { let bits = { const MASK: u8 = 0x03; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; LOCKR { bits } } #[doc = "Bits 0:7 - Dead-time generator setup"] #[inline] pub fn dtg(&self) -> DTGR { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DTGR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 15 - Main output enable"] #[inline] pub fn moe(&mut self) -> _MOEW { _MOEW { w: self } } #[doc = "Bit 14 - Automatic output enable"] #[inline] pub fn aoe(&mut self) -> _AOEW { _AOEW { w: self } } #[doc = "Bit 13 - Break polarity"] #[inline] pub fn bkp(&mut self) -> _BKPW { _BKPW { w: self } } #[doc = "Bit 12 - Break enable"] #[inline] pub fn bke(&mut self) -> _BKEW { _BKEW { w: self } } #[doc = "Bit 11 - Off-state selection for Run mode"] #[inline] pub fn ossr(&mut self) -> _OSSRW { _OSSRW { w: self } } #[doc = "Bit 10 - Off-state selection for Idle mode"] #[inline] pub fn ossi(&mut self) -> _OSSIW { _OSSIW { w: self } } #[doc = "Bits 8:9 - Lock configuration"] #[inline] pub fn lock(&mut self) -> _LOCKW { _LOCKW { w: self } } #[doc = "Bits 0:7 - Dead-time generator setup"] #[inline] pub fn dtg(&mut self) -> _DTGW { _DTGW { w: self } } } } #[doc = "DMA control register"] pub struct DCR { register: ::vcell::VolatileCell, } #[doc = "DMA control register"] pub mod dcr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DCR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBLR { bits: u8, } impl DBLR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DBAR { bits: u8, } impl DBAR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Proxy"] pub struct _DBLW<'a> { w: &'a mut W, } impl<'a> _DBLW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBAW<'a> { w: &'a mut W, } impl<'a> _DBAW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&self) -> DBLR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBLR { bits } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&self) -> DBAR { let bits = { const MASK: u8 = 0x1f; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DBAR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 8:12 - DMA burst length"] #[inline] pub fn dbl(&mut self) -> _DBLW { _DBLW { w: self } } #[doc = "Bits 0:4 - DMA base address"] #[inline] pub fn dba(&mut self) -> _DBAW { _DBAW { w: self } } } } #[doc = "DMA address for full transfer"] pub struct DMAR { register: ::vcell::VolatileCell, } #[doc = "DMA address for full transfer"] pub mod dmar { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::DMAR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DMABR { bits: u16, } impl DMABR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Proxy"] pub struct _DMABW<'a> { w: &'a mut W, } impl<'a> _DMABW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u16) -> &'a mut W { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmab(&self) -> DMABR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DMABR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:15 - DMA register for burst accesses"] #[inline] pub fn dmab(&mut self) -> _DMABW { _DMABW { w: self } } } } } #[doc = "TIM17"] pub struct TIM17 { _marker: PhantomData<*const ()>, } unsafe impl Send for TIM17 {} impl TIM17 { #[doc = r" Returns a pointer to the register block"] pub fn ptr() -> *const tim16::RegisterBlock { 0x4001_4800 as *const _ } } impl Deref for TIM17 { type Target = tim16::RegisterBlock; fn deref(&self) -> &tim16::RegisterBlock { unsafe { &*TIM17::ptr() } } } #[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 { 0x4002_2000 as *const _ } } impl Deref for FLASH { type Target = flash::RegisterBlock; fn deref(&self) -> &flash::RegisterBlock { unsafe { &*FLASH::ptr() } } } #[doc = "Flash"] pub mod flash { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - Flash access control register"] pub acr: ACR, #[doc = "0x04 - Flash key register"] pub keyr: KEYR, #[doc = "0x08 - Flash option key register"] pub optkeyr: OPTKEYR, #[doc = "0x0c - Flash status register"] pub sr: SR, #[doc = "0x10 - Flash control register"] pub cr: CR, #[doc = "0x14 - Flash address register"] pub ar: AR, _reserved0: [u8; 4usize], #[doc = "0x1c - Option byte register"] pub obr: OBR, #[doc = "0x20 - Write protection register"] pub wrpr: WRPR, } #[doc = "Flash access control register"] pub struct ACR { register: ::vcell::VolatileCell, } #[doc = "Flash access control register"] pub mod acr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::ACR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct LATENCYR { bits: u8, } impl LATENCYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct PRFTBER { bits: bool, } impl PRFTBER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PRFTBSR { bits: bool, } impl PRFTBSR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _LATENCYW<'a> { w: &'a mut W, } impl<'a> _LATENCYW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u8) -> &'a mut W { const MASK: u8 = 0x07; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PRFTBEW<'a> { w: &'a mut W, } impl<'a> _PRFTBEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:2 - LATENCY"] #[inline] pub fn latency(&self) -> LATENCYR { let bits = { const MASK: u8 = 0x07; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u8 }; LATENCYR { bits } } #[doc = "Bit 4 - PRFTBE"] #[inline] pub fn prftbe(&self) -> PRFTBER { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PRFTBER { bits } } #[doc = "Bit 5 - PRFTBS"] #[inline] pub fn prftbs(&self) -> PRFTBSR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PRFTBSR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x30 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:2 - LATENCY"] #[inline] pub fn latency(&mut self) -> _LATENCYW { _LATENCYW { w: self } } #[doc = "Bit 4 - PRFTBE"] #[inline] pub fn prftbe(&mut self) -> _PRFTBEW { _PRFTBEW { w: self } } } } #[doc = "Flash key register"] pub struct KEYR { register: ::vcell::VolatileCell, } #[doc = "Flash key register"] pub mod keyr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::KEYR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _FKEYRW<'a> { w: &'a mut W, } impl<'a> _FKEYRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Flash Key"] #[inline] pub fn fkeyr(&mut self) -> _FKEYRW { _FKEYRW { w: self } } } } #[doc = "Flash option key register"] pub struct OPTKEYR { register: ::vcell::VolatileCell, } #[doc = "Flash option key register"] pub mod optkeyr { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::OPTKEYR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _OPTKEYRW<'a> { w: &'a mut W, } impl<'a> _OPTKEYRW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Option byte key"] #[inline] pub fn optkeyr(&mut self) -> _OPTKEYRW { _OPTKEYRW { w: self } } } } #[doc = "Flash status register"] pub struct SR { register: ::vcell::VolatileCell, } #[doc = "Flash status register"] pub mod sr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::SR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct EOPR { bits: bool, } impl EOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WRPRTR { bits: bool, } impl WRPRTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PGERRR { bits: bool, } impl PGERRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BSYR { bits: bool, } impl BSYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _EOPW<'a> { w: &'a mut W, } impl<'a> _EOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _WRPRTW<'a> { w: &'a mut W, } impl<'a> _WRPRTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PGERRW<'a> { w: &'a mut W, } impl<'a> _PGERRW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 5 - End of operation"] #[inline] pub fn eop(&self) -> EOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOPR { bits } } #[doc = "Bit 4 - Write protection error"] #[inline] pub fn wrprt(&self) -> WRPRTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WRPRTR { bits } } #[doc = "Bit 2 - Programming error"] #[inline] pub fn pgerr(&self) -> PGERRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PGERRR { bits } } #[doc = "Bit 0 - Busy"] #[inline] pub fn bsy(&self) -> BSYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BSYR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 5 - End of operation"] #[inline] pub fn eop(&mut self) -> _EOPW { _EOPW { w: self } } #[doc = "Bit 4 - Write protection error"] #[inline] pub fn wrprt(&mut self) -> _WRPRTW { _WRPRTW { w: self } } #[doc = "Bit 2 - Programming error"] #[inline] pub fn pgerr(&mut self) -> _PGERRW { _PGERRW { w: self } } } } #[doc = "Flash control register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "Flash control register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct FORCE_OPTLOADR { bits: bool, } impl FORCE_OPTLOADR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct EOPIER { bits: bool, } impl EOPIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct ERRIER { bits: bool, } impl ERRIER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPTWRER { bits: bool, } impl OPTWRER { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LOCKR { bits: bool, } impl LOCKR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct STRTR { bits: bool, } impl STRTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPTERR { bits: bool, } impl OPTERR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPTPGR { bits: bool, } impl OPTPGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct MERR { bits: bool, } impl MERR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PERR { bits: bool, } impl PERR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct PGR { bits: bool, } impl PGR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _FORCE_OPTLOADW<'a> { w: &'a mut W, } impl<'a> _FORCE_OPTLOADW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 13; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _EOPIEW<'a> { w: &'a mut W, } impl<'a> _EOPIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _ERRIEW<'a> { w: &'a mut W, } impl<'a> _ERRIEW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPTWREW<'a> { w: &'a mut W, } impl<'a> _OPTWREW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 9; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _LOCKW<'a> { w: &'a mut W, } impl<'a> _LOCKW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 7; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _STRTW<'a> { w: &'a mut W, } impl<'a> _STRTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 6; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPTERW<'a> { w: &'a mut W, } impl<'a> _OPTERW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 5; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _OPTPGW<'a> { w: &'a mut W, } impl<'a> _OPTPGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _MERW<'a> { w: &'a mut W, } impl<'a> _MERW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PERW<'a> { w: &'a mut W, } impl<'a> _PERW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _PGW<'a> { w: &'a mut W, } impl<'a> _PGW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 13 - Force option byte loading"] #[inline] pub fn force_optload(&self) -> FORCE_OPTLOADR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; FORCE_OPTLOADR { bits } } #[doc = "Bit 12 - End of operation interrupt enable"] #[inline] pub fn eopie(&self) -> EOPIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; EOPIER { bits } } #[doc = "Bit 10 - Error interrupt enable"] #[inline] pub fn errie(&self) -> ERRIER { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; ERRIER { bits } } #[doc = "Bit 9 - Option bytes write enable"] #[inline] pub fn optwre(&self) -> OPTWRER { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPTWRER { bits } } #[doc = "Bit 7 - Lock"] #[inline] pub fn lock(&self) -> LOCKR { let bits = { const MASK: bool = true; const OFFSET: u8 = 7; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LOCKR { bits } } #[doc = "Bit 6 - Start"] #[inline] pub fn strt(&self) -> STRTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 6; ((self.bits >> OFFSET) & MASK as u32) != 0 }; STRTR { bits } } #[doc = "Bit 5 - Option byte erase"] #[inline] pub fn opter(&self) -> OPTERR { let bits = { const MASK: bool = true; const OFFSET: u8 = 5; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPTERR { bits } } #[doc = "Bit 4 - Option byte programming"] #[inline] pub fn optpg(&self) -> OPTPGR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPTPGR { bits } } #[doc = "Bit 2 - Mass erase"] #[inline] pub fn mer(&self) -> MERR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; MERR { bits } } #[doc = "Bit 1 - Page erase"] #[inline] pub fn per(&self) -> PERR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PERR { bits } } #[doc = "Bit 0 - Programming"] #[inline] pub fn pg(&self) -> PGR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; PGR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0x80 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 13 - Force option byte loading"] #[inline] pub fn force_optload(&mut self) -> _FORCE_OPTLOADW { _FORCE_OPTLOADW { w: self } } #[doc = "Bit 12 - End of operation interrupt enable"] #[inline] pub fn eopie(&mut self) -> _EOPIEW { _EOPIEW { w: self } } #[doc = "Bit 10 - Error interrupt enable"] #[inline] pub fn errie(&mut self) -> _ERRIEW { _ERRIEW { w: self } } #[doc = "Bit 9 - Option bytes write enable"] #[inline] pub fn optwre(&mut self) -> _OPTWREW { _OPTWREW { w: self } } #[doc = "Bit 7 - Lock"] #[inline] pub fn lock(&mut self) -> _LOCKW { _LOCKW { w: self } } #[doc = "Bit 6 - Start"] #[inline] pub fn strt(&mut self) -> _STRTW { _STRTW { w: self } } #[doc = "Bit 5 - Option byte erase"] #[inline] pub fn opter(&mut self) -> _OPTERW { _OPTERW { w: self } } #[doc = "Bit 4 - Option byte programming"] #[inline] pub fn optpg(&mut self) -> _OPTPGW { _OPTPGW { w: self } } #[doc = "Bit 2 - Mass erase"] #[inline] pub fn mer(&mut self) -> _MERW { _MERW { w: self } } #[doc = "Bit 1 - Page erase"] #[inline] pub fn per(&mut self) -> _PERW { _PERW { w: self } } #[doc = "Bit 0 - Programming"] #[inline] pub fn pg(&mut self) -> _PGW { _PGW { w: self } } } } #[doc = "Flash address register"] pub struct AR { register: ::vcell::VolatileCell, } #[doc = "Flash address register"] pub mod ar { #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::AR { #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } } #[doc = r" Proxy"] pub struct _FARW<'a> { w: &'a mut W, } impl<'a> _FARW<'a> { #[doc = r" Writes raw bits to the field"] #[inline] pub unsafe fn bits(self, value: u32) -> &'a mut W { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bits 0:31 - Flash address"] #[inline] pub fn far(&mut self) -> _FARW { _FARW { w: self } } } } #[doc = "Option byte register"] pub struct OBR { register: ::vcell::VolatileCell, } #[doc = "Option byte register"] pub mod obr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::OBR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct DATA1R { bits: u8, } impl DATA1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct DATA0R { bits: u8, } impl DATA0R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct VDDA_MONITORR { bits: bool, } impl VDDA_MONITORR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct BOOT1R { bits: bool, } impl BOOT1R { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NRST_STDBYR { bits: bool, } impl NRST_STDBYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct NRST_STOPR { bits: bool, } impl NRST_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct WDG_SWR { bits: bool, } impl WDG_SWR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LEVEL2_PROTR { bits: bool, } impl LEVEL2_PROTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct LEVEL1_PROTR { bits: bool, } impl LEVEL1_PROTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct OPTERRR { bits: bool, } impl OPTERRR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 24:31 - Data1"] #[inline] pub fn data1(&self) -> DATA1R { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 24; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DATA1R { bits } } #[doc = "Bits 16:23 - Data0"] #[inline] pub fn data0(&self) -> DATA0R { let bits = { const MASK: u8 = 0xff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DATA0R { bits } } #[doc = "Bit 13 - VDDA_MONITOR"] #[inline] pub fn vdda_monitor(&self) -> VDDA_MONITORR { let bits = { const MASK: bool = true; const OFFSET: u8 = 13; ((self.bits >> OFFSET) & MASK as u32) != 0 }; VDDA_MONITORR { bits } } #[doc = "Bit 12 - BOOT1"] #[inline] pub fn boot1(&self) -> BOOT1R { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; BOOT1R { bits } } #[doc = "Bit 10 - nRST_STDBY"] #[inline] pub fn n_rst_stdby(&self) -> NRST_STDBYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NRST_STDBYR { bits } } #[doc = "Bit 9 - nRST_STOP"] #[inline] pub fn n_rst_stop(&self) -> NRST_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 9; ((self.bits >> OFFSET) & MASK as u32) != 0 }; NRST_STOPR { bits } } #[doc = "Bit 8 - WDG_SW"] #[inline] pub fn wdg_sw(&self) -> WDG_SWR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; WDG_SWR { bits } } #[doc = "Bit 2 - Level 2 protection status"] #[inline] pub fn level2_prot(&self) -> LEVEL2_PROTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LEVEL2_PROTR { bits } } #[doc = "Bit 1 - Level 1 protection status"] #[inline] pub fn level1_prot(&self) -> LEVEL1_PROTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; LEVEL1_PROTR { bits } } #[doc = "Bit 0 - Option byte error"] #[inline] pub fn opterr(&self) -> OPTERRR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; OPTERRR { bits } } } } #[doc = "Write protection register"] pub struct WRPR { register: ::vcell::VolatileCell, } #[doc = "Write protection register"] pub mod wrpr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::WRPR { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct WRPR { bits: u32, } impl WRPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:31 - Write protect"] #[inline] pub fn wrp(&self) -> WRPR { let bits = { const MASK: u32 = 0xffff_ffff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u32 }; WRPR { bits } } } } } #[doc = "Debug support"] pub struct DBGMCU { _marker: PhantomData<*const ()>, } unsafe impl Send for DBGMCU {} impl DBGMCU { #[doc = r" Returns a pointer to the register block"] pub fn ptr() -> *const dbgmcu::RegisterBlock { 0x4001_5800 as *const _ } } impl Deref for DBGMCU { type Target = dbgmcu::RegisterBlock; fn deref(&self) -> &dbgmcu::RegisterBlock { unsafe { &*DBGMCU::ptr() } } } #[doc = "Debug support"] pub mod dbgmcu { #[doc = r" Register block"] #[repr(C)] pub struct RegisterBlock { #[doc = "0x00 - MCU Device ID Code Register"] pub idcode: IDCODE, #[doc = "0x04 - Debug MCU Configuration Register"] pub cr: CR, #[doc = "0x08 - APB Low Freeze Register"] pub apblfz: APBLFZ, #[doc = "0x0c - APB High Freeze Register"] pub apbhfz: APBHFZ, } #[doc = "MCU Device ID Code Register"] pub struct IDCODE { register: ::vcell::VolatileCell, } #[doc = "MCU Device ID Code Register"] pub mod idcode { #[doc = r" Value read from the register"] pub struct R { bits: u32, } impl super::IDCODE { #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } } #[doc = r" Value of the field"] pub struct DEV_IDR { bits: u16, } impl DEV_IDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } #[doc = r" Value of the field"] pub struct DIV_IDR { bits: u8, } impl DIV_IDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u8 { self.bits } } #[doc = r" Value of the field"] pub struct REV_IDR { bits: u16, } impl REV_IDR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bits(&self) -> u16 { self.bits } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bits 0:11 - Device Identifier"] #[inline] pub fn dev_id(&self) -> DEV_IDR { let bits = { const MASK: u16 = 0x0fff; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) as u16 }; DEV_IDR { bits } } #[doc = "Bits 12:15 - Division Identifier"] #[inline] pub fn div_id(&self) -> DIV_IDR { let bits = { const MASK: u8 = 0x0f; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) as u8 }; DIV_IDR { bits } } #[doc = "Bits 16:31 - Revision Identifier"] #[inline] pub fn rev_id(&self) -> REV_IDR { let bits = { const MASK: u16 = 0xffff; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) as u16 }; REV_IDR { bits } } } } #[doc = "Debug MCU Configuration Register"] pub struct CR { register: ::vcell::VolatileCell, } #[doc = "Debug MCU Configuration Register"] pub mod cr { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::CR { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBG_STOPR { bits: bool, } impl DBG_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_STANDBYR { bits: bool, } impl DBG_STANDBYR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _DBG_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_STANDBYW<'a> { w: &'a mut W, } impl<'a> _DBG_STANDBYW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 2; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 1 - Debug Stop Mode"] #[inline] pub fn dbg_stop(&self) -> DBG_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_STOPR { bits } } #[doc = "Bit 2 - Debug Standby Mode"] #[inline] pub fn dbg_standby(&self) -> DBG_STANDBYR { let bits = { const MASK: bool = true; const OFFSET: u8 = 2; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_STANDBYR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 1 - Debug Stop Mode"] #[inline] pub fn dbg_stop(&mut self) -> _DBG_STOPW { _DBG_STOPW { w: self } } #[doc = "Bit 2 - Debug Standby Mode"] #[inline] pub fn dbg_standby(&mut self) -> _DBG_STANDBYW { _DBG_STANDBYW { w: self } } } } #[doc = "APB Low Freeze Register"] pub struct APBLFZ { register: ::vcell::VolatileCell, } #[doc = "APB Low Freeze Register"] pub mod apblfz { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::APBLFZ { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBG_TIMER2_STOPR { bits: bool, } impl DBG_TIMER2_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_TIMER3_STOPR { bits: bool, } impl DBG_TIMER3_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_TIMER6_STOPR { bits: bool, } impl DBG_TIMER6_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_TIMER14_STOPR { bits: bool, } impl DBG_TIMER14_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_RTC_STOPR { bits: bool, } impl DBG_RTC_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_WWDG_STOPR { bits: bool, } impl DBG_WWDG_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_IWDG_STOPR { bits: bool, } impl DBG_IWDG_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct I2C1_SMBUS_TIMEOUTR { bits: bool, } impl I2C1_SMBUS_TIMEOUTR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _DBG_TIMER2_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER2_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 0; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_TIMER3_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER3_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 1; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_TIMER6_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER6_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 4; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_TIMER14_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER14_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 8; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_RTC_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_RTC_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 10; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_WWDG_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_WWDG_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_IWDG_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_IWDG_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 12; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _I2C1_SMBUS_TIMEOUTW<'a> { w: &'a mut W, } impl<'a> _I2C1_SMBUS_TIMEOUTW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 21; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 0 - Debug Timer 2 stopped when Core is halted"] #[inline] pub fn dbg_timer2_stop(&self) -> DBG_TIMER2_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 0; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER2_STOPR { bits } } #[doc = "Bit 1 - Debug Timer 3 stopped when Core is halted"] #[inline] pub fn dbg_timer3_stop(&self) -> DBG_TIMER3_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 1; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER3_STOPR { bits } } #[doc = "Bit 4 - Debug Timer 6 stopped when Core is halted"] #[inline] pub fn dbg_timer6_stop(&self) -> DBG_TIMER6_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 4; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER6_STOPR { bits } } #[doc = "Bit 8 - Debug Timer 14 stopped when Core is halted"] #[inline] pub fn dbg_timer14_stop(&self) -> DBG_TIMER14_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 8; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER14_STOPR { bits } } #[doc = "Bit 10 - Debug RTC stopped when Core is halted"] #[inline] pub fn dbg_rtc_stop(&self) -> DBG_RTC_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 10; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_RTC_STOPR { bits } } #[doc = "Bit 11 - Debug Window Wachdog stopped when Core is halted"] #[inline] pub fn dbg_wwdg_stop(&self) -> DBG_WWDG_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_WWDG_STOPR { bits } } #[doc = "Bit 12 - Debug Independent Wachdog stopped when Core is halted"] #[inline] pub fn dbg_iwdg_stop(&self) -> DBG_IWDG_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 12; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_IWDG_STOPR { bits } } #[doc = "Bit 21 - SMBUS timeout mode stopped when Core is halted"] #[inline] pub fn i2c1_smbus_timeout(&self) -> I2C1_SMBUS_TIMEOUTR { let bits = { const MASK: bool = true; const OFFSET: u8 = 21; ((self.bits >> OFFSET) & MASK as u32) != 0 }; I2C1_SMBUS_TIMEOUTR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 0 - Debug Timer 2 stopped when Core is halted"] #[inline] pub fn dbg_timer2_stop(&mut self) -> _DBG_TIMER2_STOPW { _DBG_TIMER2_STOPW { w: self } } #[doc = "Bit 1 - Debug Timer 3 stopped when Core is halted"] #[inline] pub fn dbg_timer3_stop(&mut self) -> _DBG_TIMER3_STOPW { _DBG_TIMER3_STOPW { w: self } } #[doc = "Bit 4 - Debug Timer 6 stopped when Core is halted"] #[inline] pub fn dbg_timer6_stop(&mut self) -> _DBG_TIMER6_STOPW { _DBG_TIMER6_STOPW { w: self } } #[doc = "Bit 8 - Debug Timer 14 stopped when Core is halted"] #[inline] pub fn dbg_timer14_stop(&mut self) -> _DBG_TIMER14_STOPW { _DBG_TIMER14_STOPW { w: self } } #[doc = "Bit 10 - Debug RTC stopped when Core is halted"] #[inline] pub fn dbg_rtc_stop(&mut self) -> _DBG_RTC_STOPW { _DBG_RTC_STOPW { w: self } } #[doc = "Bit 11 - Debug Window Wachdog stopped when Core is halted"] #[inline] pub fn dbg_wwdg_stop(&mut self) -> _DBG_WWDG_STOPW { _DBG_WWDG_STOPW { w: self } } #[doc = "Bit 12 - Debug Independent Wachdog stopped when Core is halted"] #[inline] pub fn dbg_iwdg_stop(&mut self) -> _DBG_IWDG_STOPW { _DBG_IWDG_STOPW { w: self } } #[doc = "Bit 21 - SMBUS timeout mode stopped when Core is halted"] #[inline] pub fn i2c1_smbus_timeout(&mut self) -> _I2C1_SMBUS_TIMEOUTW { _I2C1_SMBUS_TIMEOUTW { w: self } } } } #[doc = "APB High Freeze Register"] pub struct APBHFZ { register: ::vcell::VolatileCell, } #[doc = "APB High Freeze Register"] pub mod apbhfz { #[doc = r" Value read from the register"] pub struct R { bits: u32, } #[doc = r" Value to write to the register"] pub struct W { bits: u32, } impl super::APBHFZ { #[doc = r" Modifies the contents of the register"] #[inline] pub fn modify(&self, f: F) where for<'w> F: FnOnce(&R, &'w mut W) -> &'w mut W, { let bits = self.register.get(); let r = R { bits: bits }; let mut w = W { bits: bits }; f(&r, &mut w); self.register.set(w.bits); } #[doc = r" Reads the contents of the register"] #[inline] pub fn read(&self) -> R { R { bits: self.register.get(), } } #[doc = r" Writes to the register"] #[inline] pub fn write(&self, f: F) where F: FnOnce(&mut W) -> &mut W, { let mut w = W::reset_value(); f(&mut w); self.register.set(w.bits); } #[doc = r" Writes the reset value to the register"] #[inline] pub fn reset(&self) { self.write(|w| w) } } #[doc = r" Value of the field"] pub struct DBG_TIMER1_STOPR { bits: bool, } impl DBG_TIMER1_STOPR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_TIMER15_STOR { bits: bool, } impl DBG_TIMER15_STOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_TIMER16_STOR { bits: bool, } impl DBG_TIMER16_STOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Value of the field"] pub struct DBG_TIMER17_STOR { bits: bool, } impl DBG_TIMER17_STOR { #[doc = r" Value of the field as raw bits"] #[inline] pub fn bit(&self) -> bool { self.bits } #[doc = r" Returns `true` if the bit is clear (0)"] #[inline] pub fn bit_is_clear(&self) -> bool { !self.bit() } #[doc = r" Returns `true` if the bit is set (1)"] #[inline] pub fn bit_is_set(&self) -> bool { self.bit() } } #[doc = r" Proxy"] pub struct _DBG_TIMER1_STOPW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER1_STOPW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 11; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_TIMER15_STOW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER15_STOW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 16; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_TIMER16_STOW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER16_STOW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 17; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } #[doc = r" Proxy"] pub struct _DBG_TIMER17_STOW<'a> { w: &'a mut W, } impl<'a> _DBG_TIMER17_STOW<'a> { #[doc = r" Sets the field bit"] pub fn set_bit(self) -> &'a mut W { self.bit(true) } #[doc = r" Clears the field bit"] pub fn clear_bit(self) -> &'a mut W { self.bit(false) } #[doc = r" Writes raw bits to the field"] #[inline] pub fn bit(self, value: bool) -> &'a mut W { const MASK: bool = true; const OFFSET: u8 = 18; self.w.bits &= !((MASK as u32) << OFFSET); self.w.bits |= ((value & MASK) as u32) << OFFSET; self.w } } impl R { #[doc = r" Value of the register as raw bits"] #[inline] pub fn bits(&self) -> u32 { self.bits } #[doc = "Bit 11 - Debug Timer 1 stopped when Core is halted"] #[inline] pub fn dbg_timer1_stop(&self) -> DBG_TIMER1_STOPR { let bits = { const MASK: bool = true; const OFFSET: u8 = 11; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER1_STOPR { bits } } #[doc = "Bit 16 - Debug Timer 15 stopped when Core is halted"] #[inline] pub fn dbg_timer15_sto(&self) -> DBG_TIMER15_STOR { let bits = { const MASK: bool = true; const OFFSET: u8 = 16; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER15_STOR { bits } } #[doc = "Bit 17 - Debug Timer 16 stopped when Core is halted"] #[inline] pub fn dbg_timer16_sto(&self) -> DBG_TIMER16_STOR { let bits = { const MASK: bool = true; const OFFSET: u8 = 17; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER16_STOR { bits } } #[doc = "Bit 18 - Debug Timer 17 stopped when Core is halted"] #[inline] pub fn dbg_timer17_sto(&self) -> DBG_TIMER17_STOR { let bits = { const MASK: bool = true; const OFFSET: u8 = 18; ((self.bits >> OFFSET) & MASK as u32) != 0 }; DBG_TIMER17_STOR { bits } } } impl W { #[doc = r" Reset value of the register"] #[inline] pub fn reset_value() -> W { W { bits: 0 } } #[doc = r" Writes raw bits to the register"] #[inline] pub unsafe fn bits(&mut self, bits: u32) -> &mut Self { self.bits = bits; self } #[doc = "Bit 11 - Debug Timer 1 stopped when Core is halted"] #[inline] pub fn dbg_timer1_stop(&mut self) -> _DBG_TIMER1_STOPW { _DBG_TIMER1_STOPW { w: self } } #[doc = "Bit 16 - Debug Timer 15 stopped when Core is halted"] #[inline] pub fn dbg_timer15_sto(&mut self) -> _DBG_TIMER15_STOW { _DBG_TIMER15_STOW { w: self } } #[doc = "Bit 17 - Debug Timer 16 stopped when Core is halted"] #[inline] pub fn dbg_timer16_sto(&mut self) -> _DBG_TIMER16_STOW { _DBG_TIMER16_STOW { w: self } } #[doc = "Bit 18 - Debug Timer 17 stopped when Core is halted"] #[inline] pub fn dbg_timer17_sto(&mut self) -> _DBG_TIMER17_STOW { _DBG_TIMER17_STOW { w: self } } } } } #[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 = "CRC"] pub CRC: CRC, #[doc = "GPIOF"] pub GPIOF: GPIOF, #[doc = "GPIOD"] pub GPIOD: GPIOD, #[doc = "GPIOC"] pub GPIOC: GPIOC, #[doc = "GPIOB"] pub GPIOB: GPIOB, #[doc = "GPIOA"] pub GPIOA: GPIOA, #[doc = "SPI1"] pub SPI1: SPI1, #[doc = "SPI2"] pub SPI2: SPI2, #[doc = "PWR"] pub PWR: PWR, #[doc = "I2C1"] pub I2C1: I2C1, #[doc = "I2C2"] pub I2C2: I2C2, #[doc = "IWDG"] pub IWDG: IWDG, #[doc = "WWDG"] pub WWDG: WWDG, #[doc = "TIM1"] pub TIM1: TIM1, #[doc = "TIM3"] pub TIM3: TIM3, #[doc = "TIM14"] pub TIM14: TIM14, #[doc = "TIM6"] pub TIM6: TIM6, #[doc = "EXTI"] pub EXTI: EXTI, #[doc = "DMA"] pub DMA: DMA, #[doc = "RCC"] pub RCC: RCC, #[doc = "SYSCFG"] pub SYSCFG: SYSCFG, #[doc = "ADC"] pub ADC: ADC, #[doc = "USART1"] pub USART1: USART1, #[doc = "USART2"] pub USART2: USART2, #[doc = "RTC"] pub RTC: RTC, #[doc = "TIM15"] pub TIM15: TIM15, #[doc = "TIM16"] pub TIM16: TIM16, #[doc = "TIM17"] pub TIM17: TIM17, #[doc = "FLASH"] pub FLASH: FLASH, #[doc = "DBGMCU"] pub DBGMCU: DBGMCU, } impl Peripherals { #[doc = r" Returns all the peripherals *once*"] #[inline] pub fn take() -> Option { 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 { CRC: CRC { _marker: PhantomData, }, GPIOF: GPIOF { _marker: PhantomData, }, GPIOD: GPIOD { _marker: PhantomData, }, GPIOC: GPIOC { _marker: PhantomData, }, GPIOB: GPIOB { _marker: PhantomData, }, GPIOA: GPIOA { _marker: PhantomData, }, SPI1: SPI1 { _marker: PhantomData, }, SPI2: SPI2 { _marker: PhantomData, }, PWR: PWR { _marker: PhantomData, }, I2C1: I2C1 { _marker: PhantomData, }, I2C2: I2C2 { _marker: PhantomData, }, IWDG: IWDG { _marker: PhantomData, }, WWDG: WWDG { _marker: PhantomData, }, TIM1: TIM1 { _marker: PhantomData, }, TIM3: TIM3 { _marker: PhantomData, }, TIM14: TIM14 { _marker: PhantomData, }, TIM6: TIM6 { _marker: PhantomData, }, EXTI: EXTI { _marker: PhantomData, }, DMA: DMA { _marker: PhantomData, }, RCC: RCC { _marker: PhantomData, }, SYSCFG: SYSCFG { _marker: PhantomData, }, ADC: ADC { _marker: PhantomData, }, USART1: USART1 { _marker: PhantomData, }, USART2: USART2 { _marker: PhantomData, }, RTC: RTC { _marker: PhantomData, }, TIM15: TIM15 { _marker: PhantomData, }, TIM16: TIM16 { _marker: PhantomData, }, TIM17: TIM17 { _marker: PhantomData, }, FLASH: FLASH { _marker: PhantomData, }, DBGMCU: DBGMCU { _marker: PhantomData, }, } } }